gcc/read-rtl.c

   1 /* RTL reader for GCC.
   2    Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000, 2001, 2002,
   3    2003, 2004, 2005, 2007, 2008
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "bconfig.h"
  23
  24 /* Disable rtl checking; it conflicts with the iterator handling.  */
  25 #undef ENABLE_RTL_CHECKING
  26
  27 #include "system.h"
  28 #include "coretypes.h"
  29 #include "tm.h"
  30 #include "rtl.h"
  31 #include "obstack.h"
  32 #include "hashtab.h"
  33 #include "gensupport.h"
  34
  35 static htab_t md_constants;
  36
  37 /* One element in a singly-linked list of (integer, string) pairs.  */
  38 struct map_value {
  39   struct map_value *next;
  40   int number;
  41   const char *string;
  42 };
  43
  44 /* Maps an iterator or attribute name to a list of (integer, string) pairs.
  45    The integers are mode or code values; the strings are either C conditions
  46    or attribute values.  */
  47 struct mapping {
  48   /* The name of the iterator or attribute.  */
  49   const char *name;
  50
  51   /* The group (modes or codes) to which the iterator or attribute belongs.  */
  52   struct iterator_group *group;
  53
  54   /* Gives a unique number to the attribute or iterator.  Numbers are
  55      allocated consecutively, starting at 0.  */
  56   int index;
  57
  58   /* The list of (integer, string) pairs.  */
  59   struct map_value *values;
  60 };
  61
  62 /* A structure for abstracting the common parts of code and mode iterators.  */
  63 struct iterator_group {
  64   /* Tables of "mapping" structures, one for attributes and one for iterators.  */
  65   htab_t attrs, iterators;
  66
  67   /* The number of "real" modes or codes (and by extension, the first
  68      number available for use as an iterator placeholder).  */
  69   int num_builtins;
  70
  71   /* Treat the given string as the name of a standard mode or code and
  72      return its integer value.  Use the given file for error reporting.  */
  73   int (*find_builtin) (const char *, FILE *);
  74
  75   /* Return true if the given rtx uses the given mode or code.  */
  76   bool (*uses_iterator_p) (rtx, int);
  77
  78   /* Make the given rtx use the given mode or code.  */
  79   void (*apply_iterator) (rtx, int);
  80 };
  81
  82 /* Associates PTR (which can be a string, etc.) with the file location
  83    specified by FILENAME and LINENO.  */
  84 struct ptr_loc {
  85   const void *ptr;
  86   const char *filename;
  87   int lineno;
  88 };
  89
  90 /* A structure used to pass data from read_rtx to apply_iterator_traverse
  91    via htab_traverse.  */
  92 struct iterator_traverse_data {
  93   /* Instruction queue.  */
  94   rtx queue;
  95   /* Attributes seen for modes.  */
  96   struct map_value *mode_maps;
  97   /* Input file.  */
  98   FILE *infile;
  99   /* The last unknown attribute used as a mode.  */
 100   const char *unknown_mode_attr;
 101 };
 102
 103 /* If CODE is the number of a code iterator, return a real rtx code that
 104    has the same format.  Return CODE otherwise.  */
 105 #define BELLWETHER_CODE(CODE) \
 106   ((CODE) < NUM_RTX_CODE ? CODE : bellwether_codes[CODE - NUM_RTX_CODE])
 107
 108 static void fatal_with_file_and_line (FILE *, const char *, ...)
 109   ATTRIBUTE_PRINTF_2 ATTRIBUTE_NORETURN;
 110 static void fatal_expected_char (FILE *, int, int) ATTRIBUTE_NORETURN;
 111 static int find_mode (const char *, FILE *);
 112 static bool uses_mode_iterator_p (rtx, int);
 113 static void apply_mode_iterator (rtx, int);
 114 static int find_code (const char *, FILE *);
 115 static bool uses_code_iterator_p (rtx, int);
 116 static void apply_code_iterator (rtx, int);
 117 static const char *apply_iterator_to_string (const char *, struct mapping *, int);
 118 static rtx apply_iterator_to_rtx (rtx, struct mapping *, int,
 119                                   struct map_value *, FILE *, const char **);
 120 static bool uses_iterator_p (rtx, struct mapping *);
 121 static const char *add_condition_to_string (const char *, const char *);
 122 static void add_condition_to_rtx (rtx, const char *);
 123 static int apply_iterator_traverse (void **, void *);
 124 static struct mapping *add_mapping (struct iterator_group *, htab_t t,
 125                                     const char *, FILE *);
 126 static struct map_value **add_map_value (struct map_value **,
 127                                          int, const char *);
 128 static void initialize_iterators (void);
 129 static void read_name (char *, FILE *);
 130 static hashval_t leading_ptr_hash (const void *);
 131 static int leading_ptr_eq_p (const void *, const void *);
 132 static void set_rtx_ptr_loc (const void *, const char *, int);
 133 static const struct ptr_loc *get_rtx_ptr_loc (const void *);
 134 static char *read_string (FILE *, int);
 135 static char *read_quoted_string (FILE *);
 136 static char *read_braced_string (FILE *);
 137 static void read_escape (FILE *);
 138 static hashval_t def_hash (const void *);
 139 static int def_name_eq_p (const void *, const void *);
 140 static void read_constants (FILE *infile, char *tmp_char);
 141 static void read_conditions (FILE *infile, char *tmp_char);
 142 static void validate_const_int (FILE *, const char *);
 143 static int find_iterator (struct iterator_group *, const char *, FILE *);
 144 static struct mapping *read_mapping (struct iterator_group *, htab_t, FILE *);
 145 static void check_code_iterator (struct mapping *, FILE *);
 146 static rtx read_rtx_1 (FILE *, struct map_value **);
 147 static rtx read_rtx_variadic (FILE *, struct map_value **, rtx);
 148
 149 /* The mode and code iterator structures.  */
 150 static struct iterator_group modes, codes;
 151
 152 /* Index I is the value of BELLWETHER_CODE (I + NUM_RTX_CODE).  */
 153 static enum rtx_code *bellwether_codes;
 154
 155 /* Obstack used for allocating RTL strings.  */
 156 static struct obstack string_obstack;
 157
 158 /* A table of ptr_locs, hashed on the PTR field.  */
 159 static htab_t ptr_locs;
 160
 161 /* An obstack for the above.  Plain xmalloc is a bit heavyweight for a
 162    small structure like ptr_loc.  */
 163 static struct obstack ptr_loc_obstack;
 164
 165 /* A hash table of triples (A, B, C), where each of A, B and C is a condition
 166    and A is equivalent to "B && C".  This is used to keep track of the source
 167    of conditions that are made up of separate rtx strings (such as the split
 168    condition of a define_insn_and_split).  */
 169 static htab_t joined_conditions;
 170
 171 /* An obstack for allocating joined_conditions entries.  */
 172 static struct obstack joined_conditions_obstack;
 173
 174 /* Subroutines of read_rtx.  */
 175
 176 /* The current line number for the file.  */
 177 int read_rtx_lineno = 1;
 178
 179 /* The filename for error reporting.  */
 180 const char *read_rtx_filename = "<unknown>";
 181
 182 static void
 183 fatal_with_file_and_line (FILE *infile, const char *msg, ...)
 184 {
 185   char context[64];
 186   size_t i;
 187   int c;
 188   va_list ap;
 189
 190   va_start (ap, msg);
 191
 192   fprintf (stderr, "%s:%d: ", read_rtx_filename, read_rtx_lineno);
 193   vfprintf (stderr, msg, ap);
 194   putc ('\n', stderr);
 195
 196   /* Gather some following context.  */
 197   for (i = 0; i < sizeof (context)-1; ++i)
 198     {
 199       c = getc (infile);
 200       if (c == EOF)
 201         break;
 202       if (c == '\r' || c == '\n')
 203         break;
 204       context[i] = c;
 205     }
 206   context[i] = '\0';
 207
 208   fprintf (stderr, "%s:%d: following context is `%s'\n",
 209            read_rtx_filename, read_rtx_lineno, context);
 210
 211   va_end (ap);
 212   exit (1);
 213 }
 214
 215 /* Dump code after printing a message.  Used when read_rtx finds
 216    invalid data.  */
 217
 218 static void
 219 fatal_expected_char (FILE *infile, int expected_c, int actual_c)
 220 {
 221   if (actual_c == EOF)
 222     fatal_with_file_and_line (infile, "expected character `%c', found EOF",
 223                               expected_c);
 224   else
 225     fatal_with_file_and_line (infile, "expected character `%c', found `%c'",
 226                               expected_c, actual_c);
 227 }
 228
 229 /* Implementations of the iterator_group callbacks for modes.  */
 230
 231 static int
 232 find_mode (const char *name, FILE *infile)
 233 {
 234   int i;
 235
 236   for (i = 0; i < NUM_MACHINE_MODES; i++)
 237     if (strcmp (GET_MODE_NAME (i), name) == 0)
 238       return i;
 239
 240   fatal_with_file_and_line (infile, "unknown mode `%s'", name);
 241 }
 242
 243 static bool
 244 uses_mode_iterator_p (rtx x, int mode)
 245 {
 246   return (int) GET_MODE (x) == mode;
 247 }
 248
 249 static void
 250 apply_mode_iterator (rtx x, int mode)
 251 {
 252   PUT_MODE (x, (enum machine_mode) mode);
 253 }
 254
 255 /* Implementations of the iterator_group callbacks for codes.  */
 256
 257 static int
 258 find_code (const char *name, FILE *infile)
 259 {
 260   int i;
 261
 262   for (i = 0; i < NUM_RTX_CODE; i++)
 263     if (strcmp (GET_RTX_NAME (i), name) == 0)
 264       return i;
 265
 266   fatal_with_file_and_line (infile, "unknown rtx code `%s'", name);
 267 }
 268
 269 static bool
 270 uses_code_iterator_p (rtx x, int code)
 271 {
 272   return (int) GET_CODE (x) == code;
 273 }
 274
 275 static void
 276 apply_code_iterator (rtx x, int code)
 277 {
 278   PUT_CODE (x, (enum rtx_code) code);
 279 }
 280
 281 /* Map a code or mode attribute string P to the underlying string for
 282    ITERATOR and VALUE.  */
 283
 284 static struct map_value *
 285 map_attr_string (const char *p, struct mapping *iterator, int value)
 286 {
 287   const char *attr;
 288   struct mapping *m;
 289   struct map_value *v;
 290
 291   /* If there's a "iterator:" prefix, check whether the iterator name matches.
 292      Set ATTR to the start of the attribute name.  */
 293   attr = strchr (p, ':');
 294   if (attr == 0)
 295     attr = p;
 296   else
 297     {
 298       if (strncmp (p, iterator->name, attr - p) != 0
 299           || iterator->name[attr - p] != 0)
 300         return 0;
 301       attr++;
 302     }
 303
 304   /* Find the attribute specification.  */
 305   m = (struct mapping *) htab_find (iterator->group->attrs, &attr);
 306   if (m == 0)
 307     return 0;
 308
 309   /* Find the attribute value for VALUE.  */
 310   for (v = m->values; v != 0; v = v->next)
 311     if (v->number == value)
 312       break;
 313
 314   return v;
 315 }
 316
 317 /* Given an attribute string used as a machine mode, return an index
 318    to store in the machine mode to be translated by
 319    apply_iterator_to_rtx.  */
 320
 321 static unsigned int
 322 mode_attr_index (struct map_value **mode_maps, const char *string)
 323 {
 324   char *p;
 325   struct map_value *mv;
 326
 327   /* Copy the attribute string into permanent storage, without the
 328      angle brackets around it.  */
 329   obstack_grow0 (&string_obstack, string + 1, strlen (string) - 2);
 330   p = XOBFINISH (&string_obstack, char *);
 331
 332   mv = XNEW (struct map_value);
 333   mv->number = *mode_maps == 0 ? 0 : (*mode_maps)->number + 1;
 334   mv->string = p;
 335   mv->next = *mode_maps;
 336   *mode_maps = mv;
 337
 338   /* We return a code which we can map back into this string: the
 339      number of machine modes + the number of mode iterators + the index
 340      we just used.  */
 341   return MAX_MACHINE_MODE + htab_elements (modes.iterators) + mv->number;
 342 }
 343
 344 /* Apply MODE_MAPS to the top level of X, expanding cases where an
 345    attribute is used for a mode.  ITERATOR is the current iterator we are
 346    expanding, and VALUE is the value to which we are expanding it.
 347    INFILE is used for error messages.  This sets *UNKNOWN to true if
 348    we find a mode attribute which has not yet been defined, and does
 349    not change it otherwise.  */
 350
 351 static void
 352 apply_mode_maps (rtx x, struct map_value *mode_maps, struct mapping *iterator,
 353                  int value, FILE *infile, const char **unknown)
 354 {
 355   unsigned int offset;
 356   int indx;
 357   struct map_value *pm;
 358
 359   offset = MAX_MACHINE_MODE + htab_elements (modes.iterators);
 360   if (GET_MODE (x) < offset)
 361     return;
 362
 363   indx = GET_MODE (x) - offset;
 364   for (pm = mode_maps; pm; pm = pm->next)
 365     {
 366       if (pm->number == indx)
 367         {
 368           struct map_value *v;
 369
 370           v = map_attr_string (pm->string, iterator, value);
 371           if (v)
 372             PUT_MODE (x, (enum machine_mode) find_mode (v->string, infile));
 373           else
 374             *unknown = pm->string;
 375           return;
 376         }
 377     }
 378 }
 379
 380 /* Given that ITERATOR is being expanded as VALUE, apply the appropriate
 381    string substitutions to STRING.  Return the new string if any changes
 382    were needed, otherwise return STRING itself.  */
 383
 384 static const char *
 385 apply_iterator_to_string (const char *string, struct mapping *iterator, int value)
 386 {
 387   char *base, *copy, *p, *start, *end;
 388   struct map_value *v;
 389
 390   if (string == 0)
 391     return string;
 392
 393   base = p = copy = ASTRDUP (string);
 394   while ((start = strchr (p, '<')) && (end = strchr (start, '>')))
 395     {
 396       p = start + 1;
 397
 398       *end = 0;
 399       v = map_attr_string (p, iterator, value);
 400       *end = '>';
 401       if (v == 0)
 402         continue;
 403
 404       /* Add everything between the last copied byte and the '<',
 405          then add in the attribute value.  */
 406       obstack_grow (&string_obstack, base, start - base);
 407       obstack_grow (&string_obstack, v->string, strlen (v->string));
 408       base = end + 1;
 409     }
 410   if (base != copy)
 411     {
 412       obstack_grow (&string_obstack, base, strlen (base) + 1);
 413       copy = XOBFINISH (&string_obstack, char *);
 414       copy_rtx_ptr_loc (copy, string);
 415       return copy;
 416     }
 417   return string;
 418 }
 419
 420 /* Return a copy of ORIGINAL in which all uses of ITERATOR have been
 421    replaced by VALUE.  MODE_MAPS holds information about attribute
 422    strings used for modes.  INFILE is used for error messages.  This
 423    sets *UNKNOWN_MODE_ATTR to the value of an unknown mode attribute,
 424    and does not change it otherwise.  */
 425
 426 static rtx
 427 apply_iterator_to_rtx (rtx original, struct mapping *iterator, int value,
 428                        struct map_value *mode_maps, FILE *infile,
 429                        const char **unknown_mode_attr)
 430 {
 431   struct iterator_group *group;
 432   const char *format_ptr;
 433   int i, j;
 434   rtx x;
 435   enum rtx_code bellwether_code;
 436
 437   if (original == 0)
 438     return original;
 439
 440   /* Create a shallow copy of ORIGINAL.  */
 441   bellwether_code = BELLWETHER_CODE (GET_CODE (original));
 442   x = rtx_alloc (bellwether_code);
 443   memcpy (x, original, RTX_CODE_SIZE (bellwether_code));
 444
 445   /* Change the mode or code itself.  */
 446   group = iterator->group;
 447   if (group->uses_iterator_p (x, iterator->index + group->num_builtins))
 448     group->apply_iterator (x, value);
 449
 450   if (mode_maps)
 451     apply_mode_maps (x, mode_maps, iterator, value, infile, unknown_mode_attr);
 452
 453   /* Change each string and recursively change each rtx.  */
 454   format_ptr = GET_RTX_FORMAT (bellwether_code);
 455   for (i = 0; format_ptr[i] != 0; i++)
 456     switch (format_ptr[i])
 457       {
 458       case 'T':
 459         XTMPL (x, i) = apply_iterator_to_string (XTMPL (x, i), iterator, value);
 460         break;
 461
 462       case 'S':
 463       case 's':
 464         XSTR (x, i) = apply_iterator_to_string (XSTR (x, i), iterator, value);
 465         break;
 466
 467       case 'e':
 468         XEXP (x, i) = apply_iterator_to_rtx (XEXP (x, i), iterator, value,
 469                                              mode_maps, infile,
 470                                              unknown_mode_attr);
 471         break;
 472
 473       case 'V':
 474       case 'E':
 475         if (XVEC (original, i))
 476           {
 477             XVEC (x, i) = rtvec_alloc (XVECLEN (original, i));
 478             for (j = 0; j < XVECLEN (x, i); j++)
 479               XVECEXP (x, i, j) = apply_iterator_to_rtx (XVECEXP (original, i, j),
 480                                                          iterator, value, mode_maps,
 481                                                          infile,
 482                                                          unknown_mode_attr);
 483           }
 484         break;
 485
 486       default:
 487         break;
 488       }
 489   return x;
 490 }
 491
 492 /* Return true if X (or some subexpression of X) uses iterator ITERATOR.  */
 493
 494 static bool
 495 uses_iterator_p (rtx x, struct mapping *iterator)
 496 {
 497   struct iterator_group *group;
 498   const char *format_ptr;
 499   int i, j;
 500
 501   if (x == 0)
 502     return false;
 503
 504   group = iterator->group;
 505   if (group->uses_iterator_p (x, iterator->index + group->num_builtins))
 506     return true;
 507
 508   format_ptr = GET_RTX_FORMAT (BELLWETHER_CODE (GET_CODE (x)));
 509   for (i = 0; format_ptr[i] != 0; i++)
 510     switch (format_ptr[i])
 511       {
 512       case 'e':
 513         if (uses_iterator_p (XEXP (x, i), iterator))
 514           return true;
 515         break;
 516
 517       case 'V':
 518       case 'E':
 519         if (XVEC (x, i))
 520           for (j = 0; j < XVECLEN (x, i); j++)
 521             if (uses_iterator_p (XVECEXP (x, i, j), iterator))
 522               return true;
 523         break;
 524
 525       default:
 526         break;
 527       }
 528   return false;
 529 }
 530
 531 /* Return a condition that must satisfy both ORIGINAL and EXTRA.  If ORIGINAL
 532    has the form "&& ..." (as used in define_insn_and_splits), assume that
 533    EXTRA is already satisfied.  Empty strings are treated like "true".  */
 534
 535 static const char *
 536 add_condition_to_string (const char *original, const char *extra)
 537 {
 538   if (original != 0 && original[0] == '&' && original[1] == '&')
 539     return original;
 540   return join_c_conditions (original, extra);
 541 }
 542
 543 /* Like add_condition, but applied to all conditions in rtx X.  */
 544
 545 static void
 546 add_condition_to_rtx (rtx x, const char *extra)
 547 {
 548   switch (GET_CODE (x))
 549     {
 550     case DEFINE_INSN:
 551     case DEFINE_EXPAND:
 552       XSTR (x, 2) = add_condition_to_string (XSTR (x, 2), extra);
 553       break;
 554
 555     case DEFINE_SPLIT:
 556     case DEFINE_PEEPHOLE:
 557     case DEFINE_PEEPHOLE2:
 558     case DEFINE_COND_EXEC:
 559       XSTR (x, 1) = add_condition_to_string (XSTR (x, 1), extra);
 560       break;
 561
 562     case DEFINE_INSN_AND_SPLIT:
 563       XSTR (x, 2) = add_condition_to_string (XSTR (x, 2), extra);
 564       XSTR (x, 4) = add_condition_to_string (XSTR (x, 4), extra);
 565       break;
 566
 567     default:
 568       break;
 569     }
 570 }
 571
 572 /* A htab_traverse callback.  Search the EXPR_LIST given by DATA
 573    for rtxes that use the iterator in *SLOT.  Replace each such rtx
 574    with a list of expansions.  */
 575
 576 static int
 577 apply_iterator_traverse (void **slot, void *data)
 578 {
 579   struct iterator_traverse_data *mtd = (struct iterator_traverse_data *) data;
 580   struct mapping *iterator;
 581   struct map_value *v;
 582   rtx elem, new_elem, original, x;
 583
 584   iterator = (struct mapping *) *slot;
 585   for (elem = mtd->queue; elem != 0; elem = XEXP (elem, 1))
 586     if (uses_iterator_p (XEXP (elem, 0), iterator))
 587       {
 588         /* For each iterator we expand, we set UNKNOWN_MODE_ATTR to NULL.
 589            If apply_iterator_rtx finds an unknown attribute for a mode,
 590            it will set it to the attribute.  We want to know whether
 591            the attribute is unknown after we have expanded all
 592            possible iterators, so setting it to NULL here gives us the
 593            right result when the hash table traversal is complete.  */
 594         mtd->unknown_mode_attr = NULL;
 595
 596         original = XEXP (elem, 0);
 597         for (v = iterator->values; v != 0; v = v->next)
 598           {
 599             x = apply_iterator_to_rtx (original, iterator, v->number,
 600                                        mtd->mode_maps, mtd->infile,
 601                                        &mtd->unknown_mode_attr);
 602             add_condition_to_rtx (x, v->string);
 603             if (v != iterator->values)
 604               {
 605                 /* Insert a new EXPR_LIST node after ELEM and put the
 606                    new expansion there.  */
 607                 new_elem = rtx_alloc (EXPR_LIST);
 608                 XEXP (new_elem, 1) = XEXP (elem, 1);
 609                 XEXP (elem, 1) = new_elem;
 610                 elem = new_elem;
 611               }
 612             XEXP (elem, 0) = x;
 613           }
 614     }
 615   return 1;
 616 }
 617
 618 /* Add a new "mapping" structure to hashtable TABLE.  NAME is the name
 619    of the mapping, GROUP is the group to which it belongs, and INFILE
 620    is the file that defined the mapping.  */
 621
 622 static struct mapping *
 623 add_mapping (struct iterator_group *group, htab_t table,
 624              const char *name, FILE *infile)
 625 {
 626   struct mapping *m;
 627   void **slot;
 628
 629   m = XNEW (struct mapping);
 630   m->name = xstrdup (name);
 631   m->group = group;
 632   m->index = htab_elements (table);
 633   m->values = 0;
 634
 635   slot = htab_find_slot (table, m, INSERT);
 636   if (*slot != 0)
 637     fatal_with_file_and_line (infile, "`%s' already defined", name);
 638
 639   *slot = m;
 640   return m;
 641 }
 642
 643 /* Add the pair (NUMBER, STRING) to a list of map_value structures.
 644    END_PTR points to the current null terminator for the list; return
 645    a pointer the new null terminator.  */
 646
 647 static struct map_value **
 648 add_map_value (struct map_value **end_ptr, int number, const char *string)
 649 {
 650   struct map_value *value;
 651
 652   value = XNEW (struct map_value);
 653   value->next = 0;
 654   value->number = number;
 655   value->string = string;
 656
 657   *end_ptr = value;
 658   return &value->next;
 659 }
 660
 661 /* Do one-time initialization of the mode and code attributes.  */
 662
 663 static void
 664 initialize_iterators (void)
 665 {
 666   struct mapping *lower, *upper;
 667   struct map_value **lower_ptr, **upper_ptr;
 668   char *copy, *p;
 669   int i;
 670
 671   modes.attrs = htab_create (13, def_hash, def_name_eq_p, 0);
 672   modes.iterators = htab_create (13, def_hash, def_name_eq_p, 0);
 673   modes.num_builtins = MAX_MACHINE_MODE;
 674   modes.find_builtin = find_mode;
 675   modes.uses_iterator_p = uses_mode_iterator_p;
 676   modes.apply_iterator = apply_mode_iterator;
 677
 678   codes.attrs = htab_create (13, def_hash, def_name_eq_p, 0);
 679   codes.iterators = htab_create (13, def_hash, def_name_eq_p, 0);
 680   codes.num_builtins = NUM_RTX_CODE;
 681   codes.find_builtin = find_code;
 682   codes.uses_iterator_p = uses_code_iterator_p;
 683   codes.apply_iterator = apply_code_iterator;
 684
 685   lower = add_mapping (&modes, modes.attrs, "mode", 0);
 686   upper = add_mapping (&modes, modes.attrs, "MODE", 0);
 687   lower_ptr = &lower->values;
 688   upper_ptr = &upper->values;
 689   for (i = 0; i < MAX_MACHINE_MODE; i++)
 690     {
 691       copy = xstrdup (GET_MODE_NAME (i));
 692       for (p = copy; *p != 0; p++)
 693         *p = TOLOWER (*p);
 694
 695       upper_ptr = add_map_value (upper_ptr, i, GET_MODE_NAME (i));
 696       lower_ptr = add_map_value (lower_ptr, i, copy);
 697     }
 698
 699   lower = add_mapping (&codes, codes.attrs, "code", 0);
 700   upper = add_mapping (&codes, codes.attrs, "CODE", 0);
 701   lower_ptr = &lower->values;
 702   upper_ptr = &upper->values;
 703   for (i = 0; i < NUM_RTX_CODE; i++)
 704     {
 705       copy = xstrdup (GET_RTX_NAME (i));
 706       for (p = copy; *p != 0; p++)
 707         *p = TOUPPER (*p);
 708
 709       lower_ptr = add_map_value (lower_ptr, i, GET_RTX_NAME (i));
 710       upper_ptr = add_map_value (upper_ptr, i, copy);
 711     }
 712 }
 713
 714 /* Return a hash value for the pointer pointed to by DEF.  */
 715
 716 static hashval_t
 717 leading_ptr_hash (const void *def)
 718 {
 719   return htab_hash_pointer (*(const void *const *) def);
 720 }
 721
 722 /* Return true if DEF1 and DEF2 are pointers to the same pointer.  */
 723
 724 static int
 725 leading_ptr_eq_p (const void *def1, const void *def2)
 726 {
 727   return *(const void *const *) def1 == *(const void *const *) def2;
 728 }
 729
 730 /* Associate PTR with the file position given by FILENAME and LINENO.  */
 731
 732 static void
 733 set_rtx_ptr_loc (const void *ptr, const char *filename, int lineno)
 734 {
 735   struct ptr_loc *loc;
 736
 737   loc = (struct ptr_loc *) obstack_alloc (&ptr_loc_obstack,
 738                                           sizeof (struct ptr_loc));
 739   loc->ptr = ptr;
 740   loc->filename = filename;
 741   loc->lineno = lineno;
 742   *htab_find_slot (ptr_locs, loc, INSERT) = loc;
 743 }
 744
 745 /* Return the position associated with pointer PTR.  Return null if no
 746    position was set.  */
 747
 748 static const struct ptr_loc *
 749 get_rtx_ptr_loc (const void *ptr)
 750 {
 751   return (const struct ptr_loc *) htab_find (ptr_locs, &ptr);
 752 }
 753
 754 /* Associate NEW_PTR with the same file position as OLD_PTR.  */
 755
 756 void
 757 copy_rtx_ptr_loc (const void *new_ptr, const void *old_ptr)
 758 {
 759   const struct ptr_loc *loc = get_rtx_ptr_loc (old_ptr);
 760   if (loc != 0)
 761     set_rtx_ptr_loc (new_ptr, loc->filename, loc->lineno);
 762 }
 763
 764 /* If PTR is associated with a known file position, print a #line
 765    directive for it.  */
 766
 767 void
 768 print_rtx_ptr_loc (const void *ptr)
 769 {
 770   const struct ptr_loc *loc = get_rtx_ptr_loc (ptr);
 771   if (loc != 0)
 772     printf ("#line %d \"%s\"\n", loc->lineno, loc->filename);
 773 }
 774
 775 /* Return a condition that satisfies both COND1 and COND2.  Either string
 776    may be null or empty.  */
 777
 778 const char *
 779 join_c_conditions (const char *cond1, const char *cond2)
 780 {
 781   char *result;
 782   const void **entry;
 783
 784   if (cond1 == 0 || cond1[0] == 0)
 785     return cond2;
 786
 787   if (cond2 == 0 || cond2[0] == 0)
 788     return cond1;
 789
 790   if (strcmp (cond1, cond2) == 0)
 791     return cond1;
 792
 793   result = concat ("(", cond1, ") && (", cond2, ")", NULL);
 794   obstack_ptr_grow (&joined_conditions_obstack, result);
 795   obstack_ptr_grow (&joined_conditions_obstack, cond1);
 796   obstack_ptr_grow (&joined_conditions_obstack, cond2);
 797   entry = XOBFINISH (&joined_conditions_obstack, const void **);
 798   *htab_find_slot (joined_conditions, entry, INSERT) = entry;
 799   return result;
 800 }
 801
 802 /* Print condition COND, wrapped in brackets.  If COND was created by
 803    join_c_conditions, recursively invoke this function for the original
 804    conditions and join the result with "&&".  Otherwise print a #line
 805    directive for COND if its original file position is known.  */
 806
 807 void
 808 print_c_condition (const char *cond)
 809 {
 810   const char **halves = (const char **) htab_find (joined_conditions, &cond);
 811   if (halves != 0)
 812     {
 813       printf ("(");
 814       print_c_condition (halves[1]);
 815       printf (" && ");
 816       print_c_condition (halves[2]);
 817       printf (")");
 818     }
 819   else
 820     {
 821       putc ('\n', stdout);
 822       print_rtx_ptr_loc (cond);
 823       printf ("(%s)", cond);
 824     }
 825 }
 826
 827 /* Read chars from INFILE until a non-whitespace char
 828    and return that.  Comments, both Lisp style and C style,
 829    are treated as whitespace.
 830    Tools such as genflags use this function.  */
 831
 832 int
 833 read_skip_spaces (FILE *infile)
 834 {
 835   int c;
 836
 837   while (1)
 838     {
 839       c = getc (infile);
 840       switch (c)
 841         {
 842         case '\n':
 843           read_rtx_lineno++;
 844           break;
 845
 846         case ' ': case '\t': case '\f': case '\r':
 847           break;
 848
 849         case ';':
 850           do
 851             c = getc (infile);
 852           while (c != '\n' && c != EOF);
 853           read_rtx_lineno++;
 854           break;
 855
 856         case '/':
 857           {
 858             int prevc;
 859             c = getc (infile);
 860             if (c != '*')
 861               fatal_expected_char (infile, '*', c);
 862
 863             prevc = 0;
 864             while ((c = getc (infile)) && c != EOF)
 865               {
 866                 if (c == '\n')
 867                    read_rtx_lineno++;
 868                 else if (prevc == '*' && c == '/')
 869                   break;
 870                 prevc = c;
 871               }
 872           }
 873           break;
 874
 875         default:
 876           return c;
 877         }
 878     }
 879 }
 880
 881 /* Read an rtx code name into the buffer STR[].
 882    It is terminated by any of the punctuation chars of rtx printed syntax.  */
 883
 884 static void
 885 read_name (char *str, FILE *infile)
 886 {
 887   char *p;
 888   int c;
 889
 890   c = read_skip_spaces (infile);
 891
 892   p = str;
 893   while (1)
 894     {
 895       if (c == ' ' || c == '\n' || c == '\t' || c == '\f' || c == '\r' || c == EOF)
 896         break;
 897       if (c == ':' || c == ')' || c == ']' || c == '"' || c == '/'
 898           || c == '(' || c == '[')
 899         {
 900           ungetc (c, infile);
 901           break;
 902         }
 903       *p++ = c;
 904       c = getc (infile);
 905     }
 906   if (p == str)
 907     fatal_with_file_and_line (infile, "missing name or number");
 908   if (c == '\n')
 909     read_rtx_lineno++;
 910
 911   *p = 0;
 912
 913   if (md_constants)
 914     {
 915       /* Do constant expansion.  */
 916       struct md_constant *def;
 917
 918       p = str;
 919       do
 920         {
 921           struct md_constant tmp_def;
 922
 923           tmp_def.name = p;
 924           def = (struct md_constant *) htab_find (md_constants, &tmp_def);
 925           if (def)
 926             p = def->value;
 927         } while (def);
 928       if (p != str)
 929         strcpy (str, p);
 930     }
 931 }
 932
 933 /* Subroutine of the string readers.  Handles backslash escapes.
 934    Caller has read the backslash, but not placed it into the obstack.  */
 935 static void
 936 read_escape (FILE *infile)
 937 {
 938   int c = getc (infile);
 939
 940   switch (c)
 941     {
 942       /* Backslash-newline is replaced by nothing, as in C.  */
 943     case '\n':
 944       read_rtx_lineno++;
 945       return;
 946
 947       /* \" \' \\ are replaced by the second character.  */
 948     case '\\':
 949     case '"':
 950     case '\'':
 951       break;
 952
 953       /* Standard C string escapes:
 954          \a \b \f \n \r \t \v
 955          \[0-7] \x
 956          all are passed through to the output string unmolested.
 957          In normal use these wind up in a string constant processed
 958          by the C compiler, which will translate them appropriately.
 959          We do not bother checking that \[0-7] are followed by up to
 960          two octal digits, or that \x is followed by N hex digits.
 961          \? \u \U are left out because they are not in traditional C.  */
 962     case 'a': case 'b': case 'f': case 'n': case 'r': case 't': case 'v':
 963     case '0': case '1': case '2': case '3': case '4': case '5': case '6':
 964     case '7': case 'x':
 965       obstack_1grow (&string_obstack, '\\');
 966       break;
 967
 968       /* \; makes stuff for a C string constant containing
 969          newline and tab.  */
 970     case ';':
 971       obstack_grow (&string_obstack, "\\n\\t", 4);
 972       return;
 973
 974       /* pass anything else through, but issue a warning.  */
 975     default:
 976       fprintf (stderr, "%s:%d: warning: unrecognized escape \\%c\n",
 977                read_rtx_filename, read_rtx_lineno, c);
 978       obstack_1grow (&string_obstack, '\\');
 979       break;
 980     }
 981
 982   obstack_1grow (&string_obstack, c);
 983 }
 984
 985
 986 /* Read a double-quoted string onto the obstack.  Caller has scanned
 987    the leading quote.  */
 988 static char *
 989 read_quoted_string (FILE *infile)
 990 {
 991   int c;
 992
 993   while (1)
 994     {
 995       c = getc (infile); /* Read the string  */
 996       if (c == '\n')
 997         read_rtx_lineno++;
 998       else if (c == '\\')
 999         {
1000           read_escape (infile);
1001           continue;
1002         }
1003       else if (c == '"' || c == EOF)
1004         break;
1005
1006       obstack_1grow (&string_obstack, c);
1007     }
1008
1009   obstack_1grow (&string_obstack, 0);
1010   return XOBFINISH (&string_obstack, char *);
1011 }
1012
1013 /* Read a braced string (a la Tcl) onto the string obstack.  Caller
1014    has scanned the leading brace.  Note that unlike quoted strings,
1015    the outermost braces _are_ included in the string constant.  */
1016 static char *
1017 read_braced_string (FILE *infile)
1018 {
1019   int c;
1020   int brace_depth = 1;  /* caller-processed */
1021   unsigned long starting_read_rtx_lineno = read_rtx_lineno;
1022
1023   obstack_1grow (&string_obstack, '{');
1024   while (brace_depth)
1025     {
1026       c = getc (infile); /* Read the string  */
1027
1028       if (c == '\n')
1029         read_rtx_lineno++;
1030       else if (c == '{')
1031         brace_depth++;
1032       else if (c == '}')
1033         brace_depth--;
1034       else if (c == '\\')
1035         {
1036           read_escape (infile);
1037           continue;
1038         }
1039       else if (c == EOF)
1040         fatal_with_file_and_line
1041           (infile, "missing closing } for opening brace on line %lu",
1042            starting_read_rtx_lineno);
1043
1044       obstack_1grow (&string_obstack, c);
1045     }
1046
1047   obstack_1grow (&string_obstack, 0);
1048   return XOBFINISH (&string_obstack, char *);
1049 }
1050
1051 /* Read some kind of string constant.  This is the high-level routine
1052    used by read_rtx.  It handles surrounding parentheses, leading star,
1053    and dispatch to the appropriate string constant reader.  */
1054
1055 static char *
1056 read_string (FILE *infile, int star_if_braced)
1057 {
1058   char *stringbuf;
1059   int saw_paren = 0;
1060   int c, old_lineno;
1061
1062   c = read_skip_spaces (infile);
1063   if (c == '(')
1064     {
1065       saw_paren = 1;
1066       c = read_skip_spaces (infile);
1067     }
1068
1069   old_lineno = read_rtx_lineno;
1070   if (c == '"')
1071     stringbuf = read_quoted_string (infile);
1072   else if (c == '{')
1073     {
1074       if (star_if_braced)
1075         obstack_1grow (&string_obstack, '*');
1076       stringbuf = read_braced_string (infile);
1077     }
1078   else
1079     fatal_with_file_and_line (infile, "expected `\"' or `{', found `%c'", c);
1080
1081   if (saw_paren)
1082     {
1083       c = read_skip_spaces (infile);
1084       if (c != ')')
1085         fatal_expected_char (infile, ')', c);
1086     }
1087
1088   set_rtx_ptr_loc (stringbuf, read_rtx_filename, old_lineno);
1089   return stringbuf;
1090 }
1091 \f
1092 /* Provide a version of a function to read a long long if the system does
1093    not provide one.  */
1094 #if HOST_BITS_PER_WIDE_INT > HOST_BITS_PER_LONG && !defined(HAVE_ATOLL) && !defined(HAVE_ATOQ)
1095 HOST_WIDE_INT atoll (const char *);
1096
1097 HOST_WIDE_INT
1098 atoll (const char *p)
1099 {
1100   int neg = 0;
1101   HOST_WIDE_INT tmp_wide;
1102
1103   while (ISSPACE (*p))
1104     p++;
1105   if (*p == '-')
1106     neg = 1, p++;
1107   else if (*p == '+')
1108     p++;
1109
1110   tmp_wide = 0;
1111   while (ISDIGIT (*p))
1112     {
1113       HOST_WIDE_INT new_wide = tmp_wide*10 + (*p - '0');
1114       if (new_wide < tmp_wide)
1115         {
1116           /* Return INT_MAX equiv on overflow.  */
1117           tmp_wide = (~(unsigned HOST_WIDE_INT) 0) >> 1;
1118           break;
1119         }
1120       tmp_wide = new_wide;
1121       p++;
1122     }
1123
1124   if (neg)
1125     tmp_wide = -tmp_wide;
1126   return tmp_wide;
1127 }
1128 #endif
1129
1130 /* Given an object that starts with a char * name field, return a hash
1131    code for its name.  */
1132 static hashval_t
1133 def_hash (const void *def)
1134 {
1135   unsigned result, i;
1136   const char *string = *(const char *const *) def;
1137
1138   for (result = i = 0; *string++ != '\0'; i++)
1139     result += ((unsigned char) *string << (i % CHAR_BIT));
1140   return result;
1141 }
1142
1143 /* Given two objects that start with char * name fields, return true if
1144    they have the same name.  */
1145 static int
1146 def_name_eq_p (const void *def1, const void *def2)
1147 {
1148   return ! strcmp (*(const char *const *) def1,
1149                    *(const char *const *) def2);
1150 }
1151
1152 /* INFILE is a FILE pointer to read text from.  TMP_CHAR is a buffer suitable
1153    to read a name or number into.  Process a define_constants directive,
1154    starting with the optional space after the "define_constants".  */
1155 static void
1156 read_constants (FILE *infile, char *tmp_char)
1157 {
1158   int c;
1159   htab_t defs;
1160
1161   c = read_skip_spaces (infile);
1162   if (c != '[')
1163     fatal_expected_char (infile, '[', c);
1164   defs = md_constants;
1165   if (! defs)
1166     defs = htab_create (32, def_hash, def_name_eq_p, (htab_del) 0);
1167   /* Disable constant expansion during definition processing.  */
1168   md_constants = 0;
1169   while ( (c = read_skip_spaces (infile)) != ']')
1170     {
1171       struct md_constant *def;
1172       void **entry_ptr;
1173
1174       if (c != '(')
1175         fatal_expected_char (infile, '(', c);
1176       def = XNEW (struct md_constant);
1177       def->name = tmp_char;
1178       read_name (tmp_char, infile);
1179       entry_ptr = htab_find_slot (defs, def, INSERT);
1180       if (! *entry_ptr)
1181         def->name = xstrdup (tmp_char);
1182       c = read_skip_spaces (infile);
1183       ungetc (c, infile);
1184       read_name (tmp_char, infile);
1185       if (! *entry_ptr)
1186         {
1187           def->value = xstrdup (tmp_char);
1188           *entry_ptr = def;
1189         }
1190       else
1191         {
1192           def = (struct md_constant *) *entry_ptr;
1193           if (strcmp (def->value, tmp_char))
1194             fatal_with_file_and_line (infile,
1195                                       "redefinition of %s, was %s, now %s",
1196                                       def->name, def->value, tmp_char);
1197         }
1198       c = read_skip_spaces (infile);
1199       if (c != ')')
1200         fatal_expected_char (infile, ')', c);
1201     }
1202   md_constants = defs;
1203   c = read_skip_spaces (infile);
1204   if (c != ')')
1205     fatal_expected_char (infile, ')', c);
1206 }
1207
1208 /* For every constant definition, call CALLBACK with two arguments:
1209    a pointer a pointer to the constant definition and INFO.
1210    Stops when CALLBACK returns zero.  */
1211 void
1212 traverse_md_constants (htab_trav callback, void *info)
1213 {
1214   if (md_constants)
1215     htab_traverse (md_constants, callback, info);
1216 }
1217 \f
1218 /* INFILE is a FILE pointer to read text from.  TMP_CHAR is a buffer
1219    suitable to read a name or number into.  Process a
1220    define_conditions directive, starting with the optional space after
1221    the "define_conditions".  The directive looks like this:
1222
1223      (define_conditions [
1224         (number "string")
1225         (number "string")
1226         ...
1227      ])
1228
1229    It's not intended to appear in machine descriptions.  It is
1230    generated by (the program generated by) genconditions.c, and
1231    slipped in at the beginning of the sequence of MD files read by
1232    most of the other generators.  */
1233 static void
1234 read_conditions (FILE *infile, char *tmp_char)
1235 {
1236   int c;
1237
1238   c = read_skip_spaces (infile);
1239   if (c != '[')
1240     fatal_expected_char (infile, '[', c);
1241
1242   while ( (c = read_skip_spaces (infile)) != ']')
1243     {
1244       char *expr;
1245       int value;
1246
1247       if (c != '(')
1248         fatal_expected_char (infile, '(', c);
1249
1250       read_name (tmp_char, infile);
1251       validate_const_int (infile, tmp_char);
1252       value = atoi (tmp_char);
1253
1254       c = read_skip_spaces (infile);
1255       if (c != '"')
1256         fatal_expected_char (infile, '"', c);
1257       expr = read_quoted_string (infile);
1258
1259       c = read_skip_spaces (infile);
1260       if (c != ')')
1261         fatal_expected_char (infile, ')', c);
1262
1263       add_c_test (expr, value);
1264     }
1265   c = read_skip_spaces (infile);
1266   if (c != ')')
1267     fatal_expected_char (infile, ')', c);
1268 }
1269
1270 static void
1271 validate_const_int (FILE *infile, const char *string)
1272 {
1273   const char *cp;
1274   int valid = 1;
1275
1276   cp = string;
1277   while (*cp && ISSPACE (*cp))
1278     cp++;
1279   if (*cp == '-' || *cp == '+')
1280     cp++;
1281   if (*cp == 0)
1282     valid = 0;
1283   for (; *cp; cp++)
1284     if (! ISDIGIT (*cp))
1285       valid = 0;
1286   if (!valid)
1287     fatal_with_file_and_line (infile, "invalid decimal constant \"%s\"\n", string);
1288 }
1289
1290 /* Search GROUP for a mode or code called NAME and return its numerical
1291    identifier.  INFILE is the file that contained NAME.  */
1292
1293 static int
1294 find_iterator (struct iterator_group *group, const char *name, FILE *infile)
1295 {
1296   struct mapping *m;
1297
1298   m = (struct mapping *) htab_find (group->iterators, &name);
1299   if (m != 0)
1300     return m->index + group->num_builtins;
1301   return group->find_builtin (name, infile);
1302 }
1303
1304 /* Finish reading a declaration of the form:
1305
1306        (define... <name> [<value1> ... <valuen>])
1307
1308    from INFILE, where each <valuei> is either a bare symbol name or a
1309    "(<name> <string>)" pair.  The "(define..." part has already been read.
1310
1311    Represent the declaration as a "mapping" structure; add it to TABLE
1312    (which belongs to GROUP) and return it.  */
1313
1314 static struct mapping *
1315 read_mapping (struct iterator_group *group, htab_t table, FILE *infile)
1316 {
1317   char tmp_char[256];
1318   struct mapping *m;
1319   struct map_value **end_ptr;
1320   const char *string;
1321   int number, c;
1322
1323   /* Read the mapping name and create a structure for it.  */
1324   read_name (tmp_char, infile);
1325   m = add_mapping (group, table, tmp_char, infile);
1326
1327   c = read_skip_spaces (infile);
1328   if (c != '[')
1329     fatal_expected_char (infile, '[', c);
1330
1331   /* Read each value.  */
1332   end_ptr = &m->values;
1333   c = read_skip_spaces (infile);
1334   do
1335     {
1336       if (c != '(')
1337         {
1338           /* A bare symbol name that is implicitly paired to an
1339              empty string.  */
1340           ungetc (c, infile);
1341           read_name (tmp_char, infile);
1342           string = "";
1343         }
1344       else
1345         {
1346           /* A "(name string)" pair.  */
1347           read_name (tmp_char, infile);
1348           string = read_string (infile, false);
1349           c = read_skip_spaces (infile);
1350           if (c != ')')
1351             fatal_expected_char (infile, ')', c);
1352         }
1353       number = group->find_builtin (tmp_char, infile);
1354       end_ptr = add_map_value (end_ptr, number, string);
1355       c = read_skip_spaces (infile);
1356     }
1357   while (c != ']');
1358
1359   c = read_skip_spaces (infile);
1360   if (c != ')')
1361     fatal_expected_char (infile, ')', c);
1362
1363   return m;
1364 }
1365
1366 /* Check newly-created code iterator ITERATOR to see whether every code has the
1367    same format.  Initialize the iterator's entry in bellwether_codes.  */
1368
1369 static void
1370 check_code_iterator (struct mapping *iterator, FILE *infile)
1371 {
1372   struct map_value *v;
1373   enum rtx_code bellwether;
1374
1375   bellwether = (enum rtx_code) iterator->values->number;
1376   for (v = iterator->values->next; v != 0; v = v->next)
1377     if (strcmp (GET_RTX_FORMAT (bellwether), GET_RTX_FORMAT (v->number)) != 0)
1378       fatal_with_file_and_line (infile, "code iterator `%s' combines "
1379                                 "different rtx formats", iterator->name);
1380
1381   bellwether_codes = XRESIZEVEC (enum rtx_code, bellwether_codes,
1382                                  iterator->index + 1);
1383   bellwether_codes[iterator->index] = bellwether;
1384 }
1385
1386 /* Read an rtx in printed representation from INFILE and store its
1387    core representation in *X.  Also store the line number of the
1388    opening '(' in *LINENO.  Return true on success or false if the
1389    end of file has been reached.
1390
1391    read_rtx is not used in the compiler proper, but rather in
1392    the utilities gen*.c that construct C code from machine descriptions.  */
1393
1394 bool
1395 read_rtx (FILE *infile, rtx *x, int *lineno)
1396 {
1397   static rtx queue_head, queue_next;
1398   static int queue_lineno;
1399   int c;
1400
1401   /* Do one-time initialization.  */
1402   if (queue_head == 0)
1403     {
1404       initialize_iterators ();
1405       obstack_init (&string_obstack);
1406       queue_head = rtx_alloc (EXPR_LIST);
1407       ptr_locs = htab_create (161, leading_ptr_hash, leading_ptr_eq_p, 0);
1408       obstack_init (&ptr_loc_obstack);
1409       joined_conditions = htab_create (161, leading_ptr_hash,
1410                                        leading_ptr_eq_p, 0);
1411       obstack_init (&joined_conditions_obstack);
1412     }
1413
1414   if (queue_next == 0)
1415     {
1416       struct map_value *mode_maps;
1417       struct iterator_traverse_data mtd;
1418       rtx from_file;
1419
1420       c = read_skip_spaces (infile);
1421       if (c == EOF)
1422         return false;
1423       ungetc (c, infile);
1424
1425       queue_lineno = read_rtx_lineno;
1426       mode_maps = 0;
1427       from_file = read_rtx_1 (infile, &mode_maps);
1428       if (from_file == 0)
1429         return false;  /* This confuses a top level (nil) with end of
1430                           file, but a top level (nil) would have
1431                           crashed our caller anyway.  */
1432
1433       queue_next = queue_head;
1434       XEXP (queue_next, 0) = from_file;
1435       XEXP (queue_next, 1) = 0;
1436
1437       mtd.queue = queue_next;
1438       mtd.mode_maps = mode_maps;
1439       mtd.infile = infile;
1440       mtd.unknown_mode_attr = mode_maps ? mode_maps->string : NULL;
1441       htab_traverse (modes.iterators, apply_iterator_traverse, &mtd);
1442       htab_traverse (codes.iterators, apply_iterator_traverse, &mtd);
1443       if (mtd.unknown_mode_attr)
1444         fatal_with_file_and_line (infile,
1445                                   "undefined attribute '%s' used for mode",
1446                                   mtd.unknown_mode_attr);
1447     }
1448
1449   *x = XEXP (queue_next, 0);
1450   *lineno = queue_lineno;
1451   queue_next = XEXP (queue_next, 1);
1452
1453   return true;
1454 }
1455
1456 /* Subroutine of read_rtx that reads one construct from INFILE but
1457    doesn't apply any iterators.  */
1458
1459 static rtx
1460 read_rtx_1 (FILE *infile, struct map_value **mode_maps)
1461 {
1462   int i;
1463   RTX_CODE real_code, bellwether_code;
1464   const char *format_ptr;
1465   /* tmp_char is a buffer used for reading decimal integers
1466      and names of rtx types and machine modes.
1467      Therefore, 256 must be enough.  */
1468   char tmp_char[256];
1469   rtx return_rtx;
1470   int c;
1471   int tmp_int;
1472   HOST_WIDE_INT tmp_wide;
1473
1474   /* Linked list structure for making RTXs: */
1475   struct rtx_list
1476     {
1477       struct rtx_list *next;
1478       rtx value;                /* Value of this node.  */
1479     };
1480
1481  again:
1482   c = read_skip_spaces (infile); /* Should be open paren.  */
1483
1484   if (c == EOF)
1485     return 0;
1486
1487   if (c != '(')
1488     fatal_expected_char (infile, '(', c);
1489
1490   read_name (tmp_char, infile);
1491   if (strcmp (tmp_char, "nil") == 0)
1492     {
1493       /* (nil) stands for an expression that isn't there.  */
1494       c = read_skip_spaces (infile);
1495       if (c != ')')
1496         fatal_expected_char (infile, ')', c);
1497       return 0;
1498     }
1499   if (strcmp (tmp_char, "define_constants") == 0)
1500     {
1501       read_constants (infile, tmp_char);
1502       goto again;
1503     }
1504   if (strcmp (tmp_char, "define_conditions") == 0)
1505     {
1506       read_conditions (infile, tmp_char);
1507       goto again;
1508     }
1509   if (strcmp (tmp_char, "define_mode_attr") == 0)
1510     {
1511       read_mapping (&modes, modes.attrs, infile);
1512       goto again;
1513     }
1514   if (strcmp (tmp_char, "define_mode_iterator") == 0)
1515     {
1516       read_mapping (&modes, modes.iterators, infile);
1517       goto again;
1518     }
1519   if (strcmp (tmp_char, "define_code_attr") == 0)
1520     {
1521       read_mapping (&codes, codes.attrs, infile);
1522       goto again;
1523     }
1524   if (strcmp (tmp_char, "define_code_iterator") == 0)
1525     {
1526       check_code_iterator (read_mapping (&codes, codes.iterators, infile),
1527                            infile);
1528       goto again;
1529     }
1530   real_code = (enum rtx_code) find_iterator (&codes, tmp_char, infile);
1531   bellwether_code = BELLWETHER_CODE (real_code);
1532
1533   /* If we end up with an insn expression then we free this space below.  */
1534   return_rtx = rtx_alloc (bellwether_code);
1535   format_ptr = GET_RTX_FORMAT (bellwether_code);
1536   PUT_CODE (return_rtx, real_code);
1537
1538   /* If what follows is `: mode ', read it and
1539      store the mode in the rtx.  */
1540
1541   i = read_skip_spaces (infile);
1542   if (i == ':')
1543     {
1544       unsigned int mode;
1545
1546       read_name (tmp_char, infile);
1547       if (tmp_char[0] != '<' || tmp_char[strlen (tmp_char) - 1] != '>')
1548         mode = find_iterator (&modes, tmp_char, infile);
1549       else
1550         mode = mode_attr_index (mode_maps, tmp_char);
1551       PUT_MODE (return_rtx, (enum machine_mode) mode);
1552       if (GET_MODE (return_rtx) != mode)
1553         fatal_with_file_and_line (infile, "mode too large");
1554     }
1555   else
1556     ungetc (i, infile);
1557
1558   for (i = 0; format_ptr[i] != 0; i++)
1559     switch (format_ptr[i])
1560       {
1561         /* 0 means a field for internal use only.
1562            Don't expect it to be present in the input.  */
1563       case '0':
1564         break;
1565
1566       case 'e':
1567       case 'u':
1568         XEXP (return_rtx, i) = read_rtx_1 (infile, mode_maps);
1569         break;
1570
1571       case 'V':
1572         /* 'V' is an optional vector: if a closeparen follows,
1573            just store NULL for this element.  */
1574         c = read_skip_spaces (infile);
1575         ungetc (c, infile);
1576         if (c == ')')
1577           {
1578             XVEC (return_rtx, i) = 0;
1579             break;
1580           }
1581         /* Now process the vector.  */
1582
1583       case 'E':
1584         {
1585           /* Obstack to store scratch vector in.  */
1586           struct obstack vector_stack;
1587           int list_counter = 0;
1588           rtvec return_vec = NULL_RTVEC;
1589
1590           c = read_skip_spaces (infile);
1591           if (c != '[')
1592             fatal_expected_char (infile, '[', c);
1593
1594           /* Add expressions to a list, while keeping a count.  */
1595           obstack_init (&vector_stack);
1596           while ((c = read_skip_spaces (infile)) && c != ']')
1597             {
1598               ungetc (c, infile);
1599               list_counter++;
1600               obstack_ptr_grow (&vector_stack, read_rtx_1 (infile, mode_maps));
1601             }
1602           if (list_counter > 0)
1603             {
1604               return_vec = rtvec_alloc (list_counter);
1605               memcpy (&return_vec->elem[0], obstack_finish (&vector_stack),
1606                       list_counter * sizeof (rtx));
1607             }
1608           else if (format_ptr[i] == 'E')
1609             fatal_with_file_and_line (infile,
1610                                       "vector must have at least one element");
1611           XVEC (return_rtx, i) = return_vec;
1612           obstack_free (&vector_stack, NULL);
1613           /* close bracket gotten */
1614         }
1615         break;
1616
1617       case 'S':
1618       case 'T':
1619       case 's':
1620         {
1621           char *stringbuf;
1622           int star_if_braced;
1623
1624           c = read_skip_spaces (infile);
1625           ungetc (c, infile);
1626           if (c == ')')
1627             {
1628               /* 'S' fields are optional and should be NULL if no string
1629                  was given.  Also allow normal 's' and 'T' strings to be
1630                  omitted, treating them in the same way as empty strings.  */
1631               XSTR (return_rtx, i) = (format_ptr[i] == 'S' ? NULL : "");
1632               break;
1633             }
1634
1635           /* The output template slot of a DEFINE_INSN,
1636              DEFINE_INSN_AND_SPLIT, or DEFINE_PEEPHOLE automatically
1637              gets a star inserted as its first character, if it is
1638              written with a brace block instead of a string constant.  */
1639           star_if_braced = (format_ptr[i] == 'T');
1640
1641           stringbuf = read_string (infile, star_if_braced);
1642
1643           /* For insn patterns, we want to provide a default name
1644              based on the file and line, like "*foo.md:12", if the
1645              given name is blank.  These are only for define_insn and
1646              define_insn_and_split, to aid debugging.  */
1647           if (*stringbuf == '\0'
1648               && i == 0
1649               && (GET_CODE (return_rtx) == DEFINE_INSN
1650                   || GET_CODE (return_rtx) == DEFINE_INSN_AND_SPLIT))
1651             {
1652               char line_name[20];
1653               const char *fn = (read_rtx_filename ? read_rtx_filename : "rtx");
1654               const char *slash;
1655               for (slash = fn; *slash; slash ++)
1656                 if (*slash == '/' || *slash == '\\' || *slash == ':')
1657                   fn = slash + 1;
1658               obstack_1grow (&string_obstack, '*');
1659               obstack_grow (&string_obstack, fn, strlen (fn));
1660               sprintf (line_name, ":%d", read_rtx_lineno);
1661               obstack_grow (&string_obstack, line_name, strlen (line_name)+1);
1662               stringbuf = XOBFINISH (&string_obstack, char *);
1663             }
1664
1665           if (star_if_braced)
1666             XTMPL (return_rtx, i) = stringbuf;
1667           else
1668             XSTR (return_rtx, i) = stringbuf;
1669         }
1670         break;
1671
1672       case 'w':
1673         read_name (tmp_char, infile);
1674         validate_const_int (infile, tmp_char);
1675 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
1676         tmp_wide = atoi (tmp_char);
1677 #else
1678 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
1679         tmp_wide = atol (tmp_char);
1680 #else
1681         /* Prefer atoll over atoq, since the former is in the ISO C99 standard.
1682            But prefer not to use our hand-rolled function above either.  */
1683 #if defined(HAVE_ATOLL) || !defined(HAVE_ATOQ)
1684         tmp_wide = atoll (tmp_char);
1685 #else
1686         tmp_wide = atoq (tmp_char);
1687 #endif
1688 #endif
1689 #endif
1690         XWINT (return_rtx, i) = tmp_wide;
1691         break;
1692
1693       case 'i':
1694       case 'n':
1695         read_name (tmp_char, infile);
1696         validate_const_int (infile, tmp_char);
1697         tmp_int = atoi (tmp_char);
1698         XINT (return_rtx, i) = tmp_int;
1699         break;
1700
1701       default:
1702         gcc_unreachable ();
1703       }
1704
1705   c = read_skip_spaces (infile);
1706   if (c != ')')
1707     {
1708       /* Syntactic sugar for AND and IOR, allowing Lisp-like
1709          arbitrary number of arguments for them.  */
1710       if (c == '(' && (GET_CODE (return_rtx) == AND
1711                        || GET_CODE (return_rtx) == IOR))
1712         return read_rtx_variadic (infile, mode_maps, return_rtx);
1713       else
1714         fatal_expected_char (infile, ')', c);
1715     }
1716
1717   return return_rtx;
1718 }
1719
1720 /* Mutually recursive subroutine of read_rtx which reads
1721    (thing x1 x2 x3 ...) and produces RTL as if
1722    (thing x1 (thing x2 (thing x3 ...)))  had been written.
1723    When called, FORM is (thing x1 x2), and the file position
1724    is just past the leading parenthesis of x3.  Only works
1725    for THINGs which are dyadic expressions, e.g. AND, IOR.  */
1726 static rtx
1727 read_rtx_variadic (FILE *infile, struct map_value **mode_maps, rtx form)
1728 {
1729   char c = '(';
1730   rtx p = form, q;
1731
1732   do
1733     {
1734       ungetc (c, infile);
1735
1736       q = rtx_alloc (GET_CODE (p));
1737       PUT_MODE (q, GET_MODE (p));
1738
1739       XEXP (q, 0) = XEXP (p, 1);
1740       XEXP (q, 1) = read_rtx_1 (infile, mode_maps);
1741
1742       XEXP (p, 1) = q;
1743       p = q;
1744       c = read_skip_spaces (infile);
1745     }
1746   while (c == '(');
1747
1748   if (c != ')')
1749     fatal_expected_char (infile, ')', c);
1750
1751   return form;
1752 }