gcc/read-rtl.c

   1 /* RTL reader for GCC.
   2    Copyright (C) 1987-2016 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #include "bconfig.h"
  21
  22 /* Disable rtl checking; it conflicts with the iterator handling.  */
  23 #undef ENABLE_RTL_CHECKING
  24
  25 #include "system.h"
  26 #include "coretypes.h"
  27 #include "tm.h"
  28 #include "rtl.h"
  29 #include "obstack.h"
  30 #include "read-md.h"
  31 #include "gensupport.h"
  32
  33 /* One element in a singly-linked list of (integer, string) pairs.  */
  34 struct map_value {
  35   struct map_value *next;
  36   int number;
  37   const char *string;
  38 };
  39
  40 /* Maps an iterator or attribute name to a list of (integer, string) pairs.
  41    The integers are iterator values; the strings are either C conditions
  42    or attribute values.  */
  43 struct mapping {
  44   /* The name of the iterator or attribute.  */
  45   const char *name;
  46
  47   /* The group (modes or codes) to which the iterator or attribute belongs.  */
  48   struct iterator_group *group;
  49
  50   /* The list of (integer, string) pairs.  */
  51   struct map_value *values;
  52
  53   /* For iterators, records the current value of the iterator.  */
  54   struct map_value *current_value;
  55 };
  56
  57 /* A structure for abstracting the common parts of iterators.  */
  58 struct iterator_group {
  59   /* Tables of "mapping" structures, one for attributes and one for
  60      iterators.  */
  61   htab_t attrs, iterators;
  62
  63   /* Treat the given string as the name of a standard mode, etc., and
  64      return its integer value.  */
  65   int (*find_builtin) (const char *);
  66
  67   /* Make the given pointer use the given iterator value.  */
  68   void (*apply_iterator) (void *, int);
  69 };
  70
  71 /* Records one use of an iterator.  */
  72 struct iterator_use {
  73   /* The iterator itself.  */
  74   struct mapping *iterator;
  75
  76   /* The location of the use, as passed to the apply_iterator callback.  */
  77   void *ptr;
  78 };
  79
  80 /* Records one use of an attribute (the "<[iterator:]attribute>" syntax)
  81    in a non-string rtx field.  */
  82 struct attribute_use {
  83   /* The group that describes the use site.  */
  84   struct iterator_group *group;
  85
  86   /* The name of the attribute, possibly with an "iterator:" prefix.  */
  87   const char *value;
  88
  89   /* The location of the use, as passed to GROUP's apply_iterator callback.  */
  90   void *ptr;
  91 };
  92
  93 /* This struct is used to link subst_attr named ATTR_NAME with
  94    corresponding define_subst named ITER_NAME.  */
  95 struct subst_attr_to_iter_mapping
  96 {
  97     char *attr_name;
  98     char *iter_name;
  99 };
 100
 101 /* Hash-table to store links between subst-attributes and
 102    define_substs.  */
 103 htab_t subst_attr_to_iter_map = NULL;
 104 /* This global stores name of subst-iterator which is currently being
 105    processed.  */
 106 const char *current_iterator_name;
 107
 108 static void validate_const_int (const char *);
 109 static rtx read_rtx_code (const char *);
 110 static rtx read_nested_rtx (void);
 111 static rtx read_rtx_variadic (rtx);
 112
 113 /* The mode and code iterator structures.  */
 114 static struct iterator_group modes, codes, ints, substs;
 115
 116 /* All iterators used in the current rtx.  */
 117 static vec<mapping *> current_iterators;
 118
 119 /* The list of all iterator uses in the current rtx.  */
 120 static vec<iterator_use> iterator_uses;
 121
 122 /* The list of all attribute uses in the current rtx.  */
 123 static vec<attribute_use> attribute_uses;
 124
 125 /* Implementations of the iterator_group callbacks for modes.  */
 126
 127 static int
 128 find_mode (const char *name)
 129 {
 130   int i;
 131
 132   for (i = 0; i < NUM_MACHINE_MODES; i++)
 133     if (strcmp (GET_MODE_NAME (i), name) == 0)
 134       return i;
 135
 136   fatal_with_file_and_line ("unknown mode `%s'", name);
 137 }
 138
 139 static void
 140 apply_mode_iterator (void *loc, int mode)
 141 {
 142   PUT_MODE ((rtx) loc, (machine_mode) mode);
 143 }
 144
 145 /* Implementations of the iterator_group callbacks for codes.  */
 146
 147 static int
 148 find_code (const char *name)
 149 {
 150   int i;
 151
 152   for (i = 0; i < NUM_RTX_CODE; i++)
 153     if (strcmp (GET_RTX_NAME (i), name) == 0)
 154       return i;
 155
 156   fatal_with_file_and_line ("unknown rtx code `%s'", name);
 157 }
 158
 159 static void
 160 apply_code_iterator (void *loc, int code)
 161 {
 162   PUT_CODE ((rtx) loc, (enum rtx_code) code);
 163 }
 164
 165 /* Implementations of the iterator_group callbacks for ints.  */
 166
 167 /* Since GCC does not construct a table of valid constants,
 168    we have to accept any int as valid.  No cross-checking can
 169    be done.  */
 170
 171 static int
 172 find_int (const char *name)
 173 {
 174   validate_const_int (name);
 175   return atoi (name);
 176 }
 177
 178 static void
 179 apply_int_iterator (void *loc, int value)
 180 {
 181   *(int *)loc = value;
 182 }
 183
 184 /* This routine adds attribute or does nothing depending on VALUE.  When
 185    VALUE is 1, it does nothing - the first duplicate of original
 186    template is kept untouched when it's subjected to a define_subst.
 187    When VALUE isn't 1, the routine modifies RTL-template LOC, adding
 188    attribute, named exactly as define_subst, which later will be
 189    applied.  If such attribute has already been added, then no the
 190    routine has no effect.  */
 191 static void
 192 apply_subst_iterator (void *loc, int value)
 193 {
 194   rtx rt = (rtx)loc;
 195   rtx new_attr;
 196   rtvec attrs_vec, new_attrs_vec;
 197   int i;
 198   if (value == 1)
 199     return;
 200   gcc_assert (GET_CODE (rt) == DEFINE_INSN
 201               || GET_CODE (rt) == DEFINE_EXPAND);
 202
 203   attrs_vec = XVEC (rt, 4);
 204
 205   /* If we've already added attribute 'current_iterator_name', then we
 206      have nothing to do now.  */
 207   if (attrs_vec)
 208     {
 209       for (i = 0; i < GET_NUM_ELEM (attrs_vec); i++)
 210         {
 211           if (strcmp (XSTR (attrs_vec->elem[i], 0), current_iterator_name) == 0)
 212             return;
 213         }
 214     }
 215
 216   /* Add attribute with subst name - it serves as a mark for
 217      define_subst which later would be applied to this pattern.  */
 218   new_attr = rtx_alloc (SET_ATTR);
 219   PUT_CODE (new_attr, SET_ATTR);
 220   XSTR (new_attr, 0) = xstrdup (current_iterator_name);
 221   XSTR (new_attr, 1) = xstrdup ("yes");
 222
 223   if (!attrs_vec)
 224     {
 225       new_attrs_vec = rtvec_alloc (1);
 226       new_attrs_vec->elem[0] = new_attr;
 227     }
 228   else
 229     {
 230       new_attrs_vec = rtvec_alloc (GET_NUM_ELEM (attrs_vec) + 1);
 231       memcpy (&new_attrs_vec->elem[0], &attrs_vec->elem[0],
 232               GET_NUM_ELEM (attrs_vec) * sizeof (rtx));
 233       new_attrs_vec->elem[GET_NUM_ELEM (attrs_vec)] = new_attr;
 234     }
 235   XVEC (rt, 4) = new_attrs_vec;
 236 }
 237
 238 /* Map subst-attribute ATTR to subst iterator ITER.  */
 239
 240 static void
 241 bind_subst_iter_and_attr (const char *iter, const char *attr)
 242 {
 243   struct subst_attr_to_iter_mapping *value;
 244   void **slot;
 245   if (!subst_attr_to_iter_map)
 246     subst_attr_to_iter_map =
 247       htab_create (1, leading_string_hash, leading_string_eq_p, 0);
 248   value = XNEW (struct subst_attr_to_iter_mapping);
 249   value->attr_name = xstrdup (attr);
 250   value->iter_name = xstrdup (iter);
 251   slot = htab_find_slot (subst_attr_to_iter_map, value, INSERT);
 252   *slot = value;
 253 }
 254
 255 /* Return name of a subst-iterator, corresponding to subst-attribute ATTR.  */
 256
 257 static char*
 258 find_subst_iter_by_attr (const char *attr)
 259 {
 260   char *iter_name = NULL;
 261   struct subst_attr_to_iter_mapping *value;
 262   value = (struct subst_attr_to_iter_mapping*)
 263     htab_find (subst_attr_to_iter_map, &attr);
 264   if (value)
 265     iter_name = value->iter_name;
 266   return iter_name;
 267 }
 268
 269 /* Map attribute string P to its current value.  Return null if the attribute
 270    isn't known.  */
 271
 272 static struct map_value *
 273 map_attr_string (const char *p)
 274 {
 275   const char *attr;
 276   struct mapping *iterator;
 277   unsigned int i;
 278   struct mapping *m;
 279   struct map_value *v;
 280   int iterator_name_len;
 281
 282   /* Peel off any "iterator:" prefix.  Set ATTR to the start of the
 283      attribute name.  */
 284   attr = strchr (p, ':');
 285   if (attr == 0)
 286     {
 287       iterator_name_len = -1;
 288       attr = p;
 289     }
 290   else
 291     {
 292       iterator_name_len = attr - p;
 293       attr++;
 294     }
 295
 296   FOR_EACH_VEC_ELT (current_iterators, i, iterator)
 297     {
 298       /* If an iterator name was specified, check that it matches.  */
 299       if (iterator_name_len >= 0
 300           && (strncmp (p, iterator->name, iterator_name_len) != 0
 301               || iterator->name[iterator_name_len] != 0))
 302         continue;
 303
 304       /* Find the attribute specification.  */
 305       m = (struct mapping *) htab_find (iterator->group->attrs, &attr);
 306       if (m)
 307         {
 308           /* In contrast to code/mode/int iterators, attributes of subst
 309              iterators are linked to one specific subst-iterator.  So, if
 310              we are dealing with subst-iterator, we should check if it's
 311              the one which linked with the given attribute.  */
 312           if (iterator->group == &substs)
 313             {
 314               char *iter_name = find_subst_iter_by_attr (attr);
 315               if (strcmp (iter_name, iterator->name) != 0)
 316                 continue;
 317             }
 318           /* Find the attribute value associated with the current
 319              iterator value.  */
 320           for (v = m->values; v; v = v->next)
 321             if (v->number == iterator->current_value->number)
 322               return v;
 323         }
 324     }
 325   return NULL;
 326 }
 327
 328 /* Apply the current iterator values to STRING.  Return the new string
 329    if any changes were needed, otherwise return STRING itself.  */
 330
 331 static const char *
 332 apply_iterator_to_string (const char *string)
 333 {
 334   char *base, *copy, *p, *start, *end;
 335   struct map_value *v;
 336
 337   if (string == 0)
 338     return string;
 339
 340   base = p = copy = ASTRDUP (string);
 341   while ((start = strchr (p, '<')) && (end = strchr (start, '>')))
 342     {
 343       p = start + 1;
 344
 345       *end = 0;
 346       v = map_attr_string (p);
 347       *end = '>';
 348       if (v == 0)
 349         continue;
 350
 351       /* Add everything between the last copied byte and the '<',
 352          then add in the attribute value.  */
 353       obstack_grow (&string_obstack, base, start - base);
 354       obstack_grow (&string_obstack, v->string, strlen (v->string));
 355       base = end + 1;
 356     }
 357   if (base != copy)
 358     {
 359       obstack_grow (&string_obstack, base, strlen (base) + 1);
 360       copy = XOBFINISH (&string_obstack, char *);
 361       copy_md_ptr_loc (copy, string);
 362       return copy;
 363     }
 364   return string;
 365 }
 366
 367 /* Return a deep copy of X, substituting the current iterator
 368    values into any strings.  */
 369
 370 static rtx
 371 copy_rtx_for_iterators (rtx original)
 372 {
 373   const char *format_ptr, *p;
 374   int i, j;
 375   rtx x;
 376
 377   if (original == 0)
 378     return original;
 379
 380   /* Create a shallow copy of ORIGINAL.  */
 381   x = rtx_alloc (GET_CODE (original));
 382   memcpy (x, original, RTX_CODE_SIZE (GET_CODE (original)));
 383
 384   /* Change each string and recursively change each rtx.  */
 385   format_ptr = GET_RTX_FORMAT (GET_CODE (original));
 386   for (i = 0; format_ptr[i] != 0; i++)
 387     switch (format_ptr[i])
 388       {
 389       case 'T':
 390         while (XTMPL (x, i) != (p = apply_iterator_to_string (XTMPL (x, i))))
 391           XTMPL (x, i) = p;
 392         break;
 393
 394       case 'S':
 395       case 's':
 396         while (XSTR (x, i) != (p = apply_iterator_to_string (XSTR (x, i))))
 397           XSTR (x, i) = p;
 398         break;
 399
 400       case 'e':
 401         XEXP (x, i) = copy_rtx_for_iterators (XEXP (x, i));
 402         break;
 403
 404       case 'V':
 405       case 'E':
 406         if (XVEC (original, i))
 407           {
 408             XVEC (x, i) = rtvec_alloc (XVECLEN (original, i));
 409             for (j = 0; j < XVECLEN (x, i); j++)
 410               XVECEXP (x, i, j)
 411                 = copy_rtx_for_iterators (XVECEXP (original, i, j));
 412           }
 413         break;
 414
 415       default:
 416         break;
 417       }
 418   return x;
 419 }
 420
 421 /* Return a condition that must satisfy both ORIGINAL and EXTRA.  If ORIGINAL
 422    has the form "&& ..." (as used in define_insn_and_splits), assume that
 423    EXTRA is already satisfied.  Empty strings are treated like "true".  */
 424
 425 static const char *
 426 add_condition_to_string (const char *original, const char *extra)
 427 {
 428   if (original != 0 && original[0] == '&' && original[1] == '&')
 429     return original;
 430   return join_c_conditions (original, extra);
 431 }
 432
 433 /* Like add_condition, but applied to all conditions in rtx X.  */
 434
 435 static void
 436 add_condition_to_rtx (rtx x, const char *extra)
 437 {
 438   switch (GET_CODE (x))
 439     {
 440     case DEFINE_INSN:
 441     case DEFINE_EXPAND:
 442     case DEFINE_SUBST:
 443       XSTR (x, 2) = add_condition_to_string (XSTR (x, 2), extra);
 444       break;
 445
 446     case DEFINE_SPLIT:
 447     case DEFINE_PEEPHOLE:
 448     case DEFINE_PEEPHOLE2:
 449     case DEFINE_COND_EXEC:
 450       XSTR (x, 1) = add_condition_to_string (XSTR (x, 1), extra);
 451       break;
 452
 453     case DEFINE_INSN_AND_SPLIT:
 454       XSTR (x, 2) = add_condition_to_string (XSTR (x, 2), extra);
 455       XSTR (x, 4) = add_condition_to_string (XSTR (x, 4), extra);
 456       break;
 457
 458     default:
 459       break;
 460     }
 461 }
 462
 463 /* Apply the current iterator values to all attribute_uses.  */
 464
 465 static void
 466 apply_attribute_uses (void)
 467 {
 468   struct map_value *v;
 469   attribute_use *ause;
 470   unsigned int i;
 471
 472   FOR_EACH_VEC_ELT (attribute_uses, i, ause)
 473     {
 474       v = map_attr_string (ause->value);
 475       if (!v)
 476         fatal_with_file_and_line ("unknown iterator value `%s'", ause->value);
 477       ause->group->apply_iterator (ause->ptr,
 478                                    ause->group->find_builtin (v->string));
 479     }
 480 }
 481
 482 /* A htab_traverse callback for iterators.  Add all used iterators
 483    to current_iterators.  */
 484
 485 static int
 486 add_current_iterators (void **slot, void *data ATTRIBUTE_UNUSED)
 487 {
 488   struct mapping *iterator;
 489
 490   iterator = (struct mapping *) *slot;
 491   if (iterator->current_value)
 492     current_iterators.safe_push (iterator);
 493   return 1;
 494 }
 495
 496 /* Expand all iterators in the current rtx, which is given as ORIGINAL.
 497    Build a list of expanded rtxes in the EXPR_LIST pointed to by QUEUE.  */
 498
 499 static void
 500 apply_iterators (rtx original, vec<rtx> *queue)
 501 {
 502   unsigned int i;
 503   const char *condition;
 504   iterator_use *iuse;
 505   struct mapping *iterator;
 506   struct map_value *v;
 507   rtx x;
 508
 509   if (iterator_uses.is_empty ())
 510     {
 511       /* Raise an error if any attributes were used.  */
 512       apply_attribute_uses ();
 513       queue->safe_push (original);
 514       return;
 515     }
 516
 517   /* Clear out the iterators from the previous run.  */
 518   FOR_EACH_VEC_ELT (current_iterators, i, iterator)
 519     iterator->current_value = NULL;
 520   current_iterators.truncate (0);
 521
 522   /* Mark the iterators that we need this time.  */
 523   FOR_EACH_VEC_ELT (iterator_uses, i, iuse)
 524     iuse->iterator->current_value = iuse->iterator->values;
 525
 526   /* Get the list of iterators that are in use, preserving the
 527      definition order within each group.  */
 528   htab_traverse (modes.iterators, add_current_iterators, NULL);
 529   htab_traverse (codes.iterators, add_current_iterators, NULL);
 530   htab_traverse (ints.iterators, add_current_iterators, NULL);
 531   htab_traverse (substs.iterators, add_current_iterators, NULL);
 532   gcc_assert (!current_iterators.is_empty ());
 533
 534   for (;;)
 535     {
 536       /* Apply the current iterator values.  Accumulate a condition to
 537          say when the resulting rtx can be used.  */
 538       condition = "";
 539       FOR_EACH_VEC_ELT (iterator_uses, i, iuse)
 540         {
 541           if (iuse->iterator->group == &substs)
 542             continue;
 543           v = iuse->iterator->current_value;
 544           iuse->iterator->group->apply_iterator (iuse->ptr, v->number);
 545           condition = join_c_conditions (condition, v->string);
 546         }
 547       apply_attribute_uses ();
 548       x = copy_rtx_for_iterators (original);
 549       add_condition_to_rtx (x, condition);
 550
 551       /* We apply subst iterator after RTL-template is copied, as during
 552          subst-iterator processing, we could add an attribute to the
 553          RTL-template, and we don't want to do it in the original one.  */
 554       FOR_EACH_VEC_ELT (iterator_uses, i, iuse)
 555         {
 556           v = iuse->iterator->current_value;
 557           if (iuse->iterator->group == &substs)
 558             {
 559               iuse->ptr = x;
 560               current_iterator_name = iuse->iterator->name;
 561               iuse->iterator->group->apply_iterator (iuse->ptr, v->number);
 562             }
 563         }
 564       /* Add the new rtx to the end of the queue.  */
 565       queue->safe_push (x);
 566
 567       /* Lexicographically increment the iterator value sequence.
 568          That is, cycle through iterator values, starting from the right,
 569          and stopping when one of them doesn't wrap around.  */
 570       i = current_iterators.length ();
 571       for (;;)
 572         {
 573           if (i == 0)
 574             return;
 575           i--;
 576           iterator = current_iterators[i];
 577           iterator->current_value = iterator->current_value->next;
 578           if (iterator->current_value)
 579             break;
 580           iterator->current_value = iterator->values;
 581         }
 582     }
 583 }
 584
 585 /* Add a new "mapping" structure to hashtable TABLE.  NAME is the name
 586    of the mapping and GROUP is the group to which it belongs.  */
 587
 588 static struct mapping *
 589 add_mapping (struct iterator_group *group, htab_t table, const char *name)
 590 {
 591   struct mapping *m;
 592   void **slot;
 593
 594   m = XNEW (struct mapping);
 595   m->name = xstrdup (name);
 596   m->group = group;
 597   m->values = 0;
 598   m->current_value = NULL;
 599
 600   slot = htab_find_slot (table, m, INSERT);
 601   if (*slot != 0)
 602     fatal_with_file_and_line ("`%s' already defined", name);
 603
 604   *slot = m;
 605   return m;
 606 }
 607
 608 /* Add the pair (NUMBER, STRING) to a list of map_value structures.
 609    END_PTR points to the current null terminator for the list; return
 610    a pointer the new null terminator.  */
 611
 612 static struct map_value **
 613 add_map_value (struct map_value **end_ptr, int number, const char *string)
 614 {
 615   struct map_value *value;
 616
 617   value = XNEW (struct map_value);
 618   value->next = 0;
 619   value->number = number;
 620   value->string = string;
 621
 622   *end_ptr = value;
 623   return &value->next;
 624 }
 625
 626 /* Do one-time initialization of the mode and code attributes.  */
 627
 628 static void
 629 initialize_iterators (void)
 630 {
 631   struct mapping *lower, *upper;
 632   struct map_value **lower_ptr, **upper_ptr;
 633   char *copy, *p;
 634   int i;
 635
 636   modes.attrs = htab_create (13, leading_string_hash, leading_string_eq_p, 0);
 637   modes.iterators = htab_create (13, leading_string_hash,
 638                                  leading_string_eq_p, 0);
 639   modes.find_builtin = find_mode;
 640   modes.apply_iterator = apply_mode_iterator;
 641
 642   codes.attrs = htab_create (13, leading_string_hash, leading_string_eq_p, 0);
 643   codes.iterators = htab_create (13, leading_string_hash,
 644                                  leading_string_eq_p, 0);
 645   codes.find_builtin = find_code;
 646   codes.apply_iterator = apply_code_iterator;
 647
 648   ints.attrs = htab_create (13, leading_string_hash, leading_string_eq_p, 0);
 649   ints.iterators = htab_create (13, leading_string_hash,
 650                                  leading_string_eq_p, 0);
 651   ints.find_builtin = find_int;
 652   ints.apply_iterator = apply_int_iterator;
 653
 654   substs.attrs = htab_create (13, leading_string_hash, leading_string_eq_p, 0);
 655   substs.iterators = htab_create (13, leading_string_hash,
 656                                  leading_string_eq_p, 0);
 657   substs.find_builtin = find_int; /* We don't use it, anyway.  */
 658   substs.apply_iterator = apply_subst_iterator;
 659
 660   lower = add_mapping (&modes, modes.attrs, "mode");
 661   upper = add_mapping (&modes, modes.attrs, "MODE");
 662   lower_ptr = &lower->values;
 663   upper_ptr = &upper->values;
 664   for (i = 0; i < MAX_MACHINE_MODE; i++)
 665     {
 666       copy = xstrdup (GET_MODE_NAME (i));
 667       for (p = copy; *p != 0; p++)
 668         *p = TOLOWER (*p);
 669
 670       upper_ptr = add_map_value (upper_ptr, i, GET_MODE_NAME (i));
 671       lower_ptr = add_map_value (lower_ptr, i, copy);
 672     }
 673
 674   lower = add_mapping (&codes, codes.attrs, "code");
 675   upper = add_mapping (&codes, codes.attrs, "CODE");
 676   lower_ptr = &lower->values;
 677   upper_ptr = &upper->values;
 678   for (i = 0; i < NUM_RTX_CODE; i++)
 679     {
 680       copy = xstrdup (GET_RTX_NAME (i));
 681       for (p = copy; *p != 0; p++)
 682         *p = TOUPPER (*p);
 683
 684       lower_ptr = add_map_value (lower_ptr, i, GET_RTX_NAME (i));
 685       upper_ptr = add_map_value (upper_ptr, i, copy);
 686     }
 687 }
 688 \f
 689 /* Provide a version of a function to read a long long if the system does
 690    not provide one.  */
 691 #if HOST_BITS_PER_WIDE_INT > HOST_BITS_PER_LONG && !HAVE_DECL_ATOLL && !defined(HAVE_ATOQ)
 692 HOST_WIDE_INT atoll (const char *);
 693
 694 HOST_WIDE_INT
 695 atoll (const char *p)
 696 {
 697   int neg = 0;
 698   HOST_WIDE_INT tmp_wide;
 699
 700   while (ISSPACE (*p))
 701     p++;
 702   if (*p == '-')
 703     neg = 1, p++;
 704   else if (*p == '+')
 705     p++;
 706
 707   tmp_wide = 0;
 708   while (ISDIGIT (*p))
 709     {
 710       HOST_WIDE_INT new_wide = tmp_wide*10 + (*p - '0');
 711       if (new_wide < tmp_wide)
 712         {
 713           /* Return INT_MAX equiv on overflow.  */
 714           tmp_wide = (~(unsigned HOST_WIDE_INT) 0) >> 1;
 715           break;
 716         }
 717       tmp_wide = new_wide;
 718       p++;
 719     }
 720
 721   if (neg)
 722     tmp_wide = -tmp_wide;
 723   return tmp_wide;
 724 }
 725 #endif
 726 \f
 727 /* Process a define_conditions directive, starting with the optional
 728    space after the "define_conditions".  The directive looks like this:
 729
 730      (define_conditions [
 731         (number "string")
 732         (number "string")
 733         ...
 734      ])
 735
 736    It's not intended to appear in machine descriptions.  It is
 737    generated by (the program generated by) genconditions.c, and
 738    slipped in at the beginning of the sequence of MD files read by
 739    most of the other generators.  */
 740 static void
 741 read_conditions (void)
 742 {
 743   int c;
 744
 745   c = read_skip_spaces ();
 746   if (c != '[')
 747     fatal_expected_char ('[', c);
 748
 749   while ( (c = read_skip_spaces ()) != ']')
 750     {
 751       struct md_name name;
 752       char *expr;
 753       int value;
 754
 755       if (c != '(')
 756         fatal_expected_char ('(', c);
 757
 758       read_name (&name);
 759       validate_const_int (name.string);
 760       value = atoi (name.string);
 761
 762       c = read_skip_spaces ();
 763       if (c != '"')
 764         fatal_expected_char ('"', c);
 765       expr = read_quoted_string ();
 766
 767       c = read_skip_spaces ();
 768       if (c != ')')
 769         fatal_expected_char (')', c);
 770
 771       add_c_test (expr, value);
 772     }
 773 }
 774
 775 static void
 776 validate_const_int (const char *string)
 777 {
 778   const char *cp;
 779   int valid = 1;
 780
 781   cp = string;
 782   while (*cp && ISSPACE (*cp))
 783     cp++;
 784   if (*cp == '-' || *cp == '+')
 785     cp++;
 786   if (*cp == 0)
 787     valid = 0;
 788   for (; *cp; cp++)
 789     if (! ISDIGIT (*cp))
 790       {
 791         valid = 0;
 792         break;
 793       }
 794   if (!valid)
 795     fatal_with_file_and_line ("invalid decimal constant \"%s\"\n", string);
 796 }
 797
 798 static void
 799 validate_const_wide_int (const char *string)
 800 {
 801   const char *cp;
 802   int valid = 1;
 803
 804   cp = string;
 805   while (*cp && ISSPACE (*cp))
 806     cp++;
 807   /* Skip the leading 0x.  */
 808   if (cp[0] == '0' || cp[1] == 'x')
 809     cp += 2;
 810   else
 811     valid = 0;
 812   if (*cp == 0)
 813     valid = 0;
 814   for (; *cp; cp++)
 815     if (! ISXDIGIT (*cp))
 816       valid = 0;
 817   if (!valid)
 818     fatal_with_file_and_line ("invalid hex constant \"%s\"\n", string);
 819 }
 820
 821 /* Record that PTR uses iterator ITERATOR.  */
 822
 823 static void
 824 record_iterator_use (struct mapping *iterator, void *ptr)
 825 {
 826   struct iterator_use iuse = {iterator, ptr};
 827   iterator_uses.safe_push (iuse);
 828 }
 829
 830 /* Record that PTR uses attribute VALUE, which must match a built-in
 831    value from group GROUP.  */
 832
 833 static void
 834 record_attribute_use (struct iterator_group *group, void *ptr,
 835                       const char *value)
 836 {
 837   struct attribute_use ause = {group, value, ptr};
 838   attribute_uses.safe_push (ause);
 839 }
 840
 841 /* Interpret NAME as either a built-in value, iterator or attribute
 842    for group GROUP.  PTR is the value to pass to GROUP's apply_iterator
 843    callback.  */
 844
 845 static void
 846 record_potential_iterator_use (struct iterator_group *group, void *ptr,
 847                                const char *name)
 848 {
 849   struct mapping *m;
 850   size_t len;
 851
 852   len = strlen (name);
 853   if (name[0] == '<' && name[len - 1] == '>')
 854     {
 855       /* Copy the attribute string into permanent storage, without the
 856          angle brackets around it.  */
 857       obstack_grow0 (&string_obstack, name + 1, len - 2);
 858       record_attribute_use (group, ptr, XOBFINISH (&string_obstack, char *));
 859     }
 860   else
 861     {
 862       m = (struct mapping *) htab_find (group->iterators, &name);
 863       if (m != 0)
 864         record_iterator_use (m, ptr);
 865       else
 866         group->apply_iterator (ptr, group->find_builtin (name));
 867     }
 868 }
 869
 870 /* Finish reading a declaration of the form:
 871
 872        (define... <name> [<value1> ... <valuen>])
 873
 874    from the MD file, where each <valuei> is either a bare symbol name or a
 875    "(<name> <string>)" pair.  The "(define..." part has already been read.
 876
 877    Represent the declaration as a "mapping" structure; add it to TABLE
 878    (which belongs to GROUP) and return it.  */
 879
 880 static struct mapping *
 881 read_mapping (struct iterator_group *group, htab_t table)
 882 {
 883   struct md_name name;
 884   struct mapping *m;
 885   struct map_value **end_ptr;
 886   const char *string;
 887   int number, c;
 888
 889   /* Read the mapping name and create a structure for it.  */
 890   read_name (&name);
 891   m = add_mapping (group, table, name.string);
 892
 893   c = read_skip_spaces ();
 894   if (c != '[')
 895     fatal_expected_char ('[', c);
 896
 897   /* Read each value.  */
 898   end_ptr = &m->values;
 899   c = read_skip_spaces ();
 900   do
 901     {
 902       if (c != '(')
 903         {
 904           /* A bare symbol name that is implicitly paired to an
 905              empty string.  */
 906           unread_char (c);
 907           read_name (&name);
 908           string = "";
 909         }
 910       else
 911         {
 912           /* A "(name string)" pair.  */
 913           read_name (&name);
 914           string = read_string (false);
 915           c = read_skip_spaces ();
 916           if (c != ')')
 917             fatal_expected_char (')', c);
 918         }
 919       number = group->find_builtin (name.string);
 920       end_ptr = add_map_value (end_ptr, number, string);
 921       c = read_skip_spaces ();
 922     }
 923   while (c != ']');
 924
 925   return m;
 926 }
 927
 928 /* For iterator with name ATTR_NAME generate define_attr with values
 929    'yes' and 'no'.  This attribute is used to mark templates to which
 930    define_subst ATTR_NAME should be applied.  This attribute is set and
 931    defined implicitly and automatically.  */
 932 static void
 933 add_define_attr_for_define_subst (const char *attr_name, vec<rtx> *queue)
 934 {
 935   rtx const_str, return_rtx;
 936
 937   return_rtx = rtx_alloc (DEFINE_ATTR);
 938   PUT_CODE (return_rtx, DEFINE_ATTR);
 939
 940   const_str = rtx_alloc (CONST_STRING);
 941   PUT_CODE (const_str, CONST_STRING);
 942   XSTR (const_str, 0) = xstrdup ("no");
 943
 944   XSTR (return_rtx, 0) = xstrdup (attr_name);
 945   XSTR (return_rtx, 1) = xstrdup ("no,yes");
 946   XEXP (return_rtx, 2) = const_str;
 947
 948   queue->safe_push (return_rtx);
 949 }
 950
 951 /* This routine generates DEFINE_SUBST_ATTR expression with operands
 952    ATTR_OPERANDS and places it to QUEUE.  */
 953 static void
 954 add_define_subst_attr (const char **attr_operands, vec<rtx> *queue)
 955 {
 956   rtx return_rtx;
 957   int i;
 958
 959   return_rtx = rtx_alloc (DEFINE_SUBST_ATTR);
 960   PUT_CODE (return_rtx, DEFINE_SUBST_ATTR);
 961
 962   for (i = 0; i < 4; i++)
 963     XSTR (return_rtx, i) = xstrdup (attr_operands[i]);
 964
 965   queue->safe_push (return_rtx);
 966 }
 967
 968 /* Read define_subst_attribute construction.  It has next form:
 969         (define_subst_attribute <attribute_name> <iterator_name> <value1> <value2>)
 970    Attribute is substituted with value1 when no subst is applied and with
 971    value2 in the opposite case.
 972    Attributes are added to SUBST_ATTRS_TABLE.
 973    In case the iterator is encountered for the first time, it's added to
 974    SUBST_ITERS_TABLE.  Also, implicit define_attr is generated.  */
 975
 976 static void
 977 read_subst_mapping (htab_t subst_iters_table, htab_t subst_attrs_table,
 978                     vec<rtx> *queue)
 979 {
 980   struct mapping *m;
 981   struct map_value **end_ptr;
 982   const char *attr_operands[4];
 983   int i;
 984
 985   for (i = 0; i < 4; i++)
 986     attr_operands[i] = read_string (false);
 987
 988   add_define_subst_attr (attr_operands, queue);
 989
 990   bind_subst_iter_and_attr (attr_operands[1], attr_operands[0]);
 991
 992   m = (struct mapping *) htab_find (substs.iterators, &attr_operands[1]);
 993   if (!m)
 994     {
 995       m = add_mapping (&substs, subst_iters_table, attr_operands[1]);
 996       end_ptr = &m->values;
 997       end_ptr = add_map_value (end_ptr, 1, "");
 998       end_ptr = add_map_value (end_ptr, 2, "");
 999
1000       add_define_attr_for_define_subst (attr_operands[1], queue);
1001     }
1002
1003   m = add_mapping (&substs, subst_attrs_table, attr_operands[0]);
1004   end_ptr = &m->values;
1005   end_ptr = add_map_value (end_ptr, 1, attr_operands[2]);
1006   end_ptr = add_map_value (end_ptr, 2, attr_operands[3]);
1007 }
1008
1009 /* Check newly-created code iterator ITERATOR to see whether every code has the
1010    same format.  */
1011
1012 static void
1013 check_code_iterator (struct mapping *iterator)
1014 {
1015   struct map_value *v;
1016   enum rtx_code bellwether;
1017
1018   bellwether = (enum rtx_code) iterator->values->number;
1019   for (v = iterator->values->next; v != 0; v = v->next)
1020     if (strcmp (GET_RTX_FORMAT (bellwether), GET_RTX_FORMAT (v->number)) != 0)
1021       fatal_with_file_and_line ("code iterator `%s' combines "
1022                                 "different rtx formats", iterator->name);
1023 }
1024
1025 /* Read an rtx-related declaration from the MD file, given that it
1026    starts with directive name RTX_NAME.  Return true if it expands to
1027    one or more rtxes (as defined by rtx.def).  When returning true,
1028    store the list of rtxes as an EXPR_LIST in *X.  */
1029
1030 bool
1031 read_rtx (const char *rtx_name, vec<rtx> *rtxen)
1032 {
1033   static bool initialized = false;
1034
1035   /* Do one-time initialization.  */
1036   if (!initialized)
1037     {
1038       initialize_iterators ();
1039       initialized = true;
1040     }
1041
1042   /* Handle various rtx-related declarations that aren't themselves
1043      encoded as rtxes.  */
1044   if (strcmp (rtx_name, "define_conditions") == 0)
1045     {
1046       read_conditions ();
1047       return false;
1048     }
1049   if (strcmp (rtx_name, "define_mode_attr") == 0)
1050     {
1051       read_mapping (&modes, modes.attrs);
1052       return false;
1053     }
1054   if (strcmp (rtx_name, "define_mode_iterator") == 0)
1055     {
1056       read_mapping (&modes, modes.iterators);
1057       return false;
1058     }
1059   if (strcmp (rtx_name, "define_code_attr") == 0)
1060     {
1061       read_mapping (&codes, codes.attrs);
1062       return false;
1063     }
1064   if (strcmp (rtx_name, "define_code_iterator") == 0)
1065     {
1066       check_code_iterator (read_mapping (&codes, codes.iterators));
1067       return false;
1068     }
1069   if (strcmp (rtx_name, "define_int_attr") == 0)
1070     {
1071       read_mapping (&ints, ints.attrs);
1072       return false;
1073     }
1074   if (strcmp (rtx_name, "define_int_iterator") == 0)
1075     {
1076       read_mapping (&ints, ints.iterators);
1077       return false;
1078     }
1079   if (strcmp (rtx_name, "define_subst_attr") == 0)
1080     {
1081       read_subst_mapping (substs.iterators, substs.attrs, rtxen);
1082
1083       /* READ_SUBST_MAPPING could generate a new DEFINE_ATTR.  Return
1084          TRUE to process it.  */
1085       return true;
1086     }
1087
1088   apply_iterators (read_rtx_code (rtx_name), rtxen);
1089   iterator_uses.truncate (0);
1090   attribute_uses.truncate (0);
1091
1092   return true;
1093 }
1094
1095 /* Subroutine of read_rtx and read_nested_rtx.  CODE_NAME is the name of
1096    either an rtx code or a code iterator.  Parse the rest of the rtx and
1097    return it.  */
1098
1099 static rtx
1100 read_rtx_code (const char *code_name)
1101 {
1102   int i;
1103   RTX_CODE code;
1104   struct mapping *iterator, *m;
1105   const char *format_ptr;
1106   struct md_name name;
1107   rtx return_rtx;
1108   int c;
1109   HOST_WIDE_INT tmp_wide;
1110   char *str;
1111   char *start, *end, *ptr;
1112   char tmpstr[256];
1113
1114   /* Linked list structure for making RTXs: */
1115   struct rtx_list
1116     {
1117       struct rtx_list *next;
1118       rtx value;                /* Value of this node.  */
1119     };
1120
1121   /* If this code is an iterator, build the rtx using the iterator's
1122      first value.  */
1123   iterator = (struct mapping *) htab_find (codes.iterators, &code_name);
1124   if (iterator != 0)
1125     code = (enum rtx_code) iterator->values->number;
1126   else
1127     code = (enum rtx_code) codes.find_builtin (code_name);
1128
1129   /* If we end up with an insn expression then we free this space below.  */
1130   return_rtx = rtx_alloc (code);
1131   format_ptr = GET_RTX_FORMAT (code);
1132   memset (return_rtx, 0, RTX_CODE_SIZE (code));
1133   PUT_CODE (return_rtx, code);
1134
1135   if (iterator)
1136     record_iterator_use (iterator, return_rtx);
1137
1138   /* If what follows is `: mode ', read it and
1139      store the mode in the rtx.  */
1140
1141   i = read_skip_spaces ();
1142   if (i == ':')
1143     {
1144       read_name (&name);
1145       record_potential_iterator_use (&modes, return_rtx, name.string);
1146     }
1147   else
1148     unread_char (i);
1149
1150   for (i = 0; format_ptr[i] != 0; i++)
1151     switch (format_ptr[i])
1152       {
1153         /* 0 means a field for internal use only.
1154            Don't expect it to be present in the input.  */
1155       case '0':
1156         if (code == REG)
1157           ORIGINAL_REGNO (return_rtx) = REGNO (return_rtx);
1158         break;
1159
1160       case 'e':
1161       case 'u':
1162         XEXP (return_rtx, i) = read_nested_rtx ();
1163         break;
1164
1165       case 'V':
1166         /* 'V' is an optional vector: if a closeparen follows,
1167            just store NULL for this element.  */
1168         c = read_skip_spaces ();
1169         unread_char (c);
1170         if (c == ')')
1171           {
1172             XVEC (return_rtx, i) = 0;
1173             break;
1174           }
1175         /* Now process the vector.  */
1176
1177       case 'E':
1178         {
1179           /* Obstack to store scratch vector in.  */
1180           struct obstack vector_stack;
1181           int list_counter = 0;
1182           rtvec return_vec = NULL_RTVEC;
1183
1184           c = read_skip_spaces ();
1185           if (c != '[')
1186             fatal_expected_char ('[', c);
1187
1188           /* Add expressions to a list, while keeping a count.  */
1189           obstack_init (&vector_stack);
1190           while ((c = read_skip_spaces ()) && c != ']')
1191             {
1192               if (c == EOF)
1193                 fatal_expected_char (']', c);
1194               unread_char (c);
1195               list_counter++;
1196               obstack_ptr_grow (&vector_stack, read_nested_rtx ());
1197             }
1198           if (list_counter > 0)
1199             {
1200               return_vec = rtvec_alloc (list_counter);
1201               memcpy (&return_vec->elem[0], obstack_finish (&vector_stack),
1202                       list_counter * sizeof (rtx));
1203             }
1204           else if (format_ptr[i] == 'E')
1205             fatal_with_file_and_line ("vector must have at least one element");
1206           XVEC (return_rtx, i) = return_vec;
1207           obstack_free (&vector_stack, NULL);
1208           /* close bracket gotten */
1209         }
1210         break;
1211
1212       case 'S':
1213       case 'T':
1214       case 's':
1215         {
1216           char *stringbuf;
1217           int star_if_braced;
1218
1219           c = read_skip_spaces ();
1220           unread_char (c);
1221           if (c == ')')
1222             {
1223               /* 'S' fields are optional and should be NULL if no string
1224                  was given.  Also allow normal 's' and 'T' strings to be
1225                  omitted, treating them in the same way as empty strings.  */
1226               XSTR (return_rtx, i) = (format_ptr[i] == 'S' ? NULL : "");
1227               break;
1228             }
1229
1230           /* The output template slot of a DEFINE_INSN,
1231              DEFINE_INSN_AND_SPLIT, or DEFINE_PEEPHOLE automatically
1232              gets a star inserted as its first character, if it is
1233              written with a brace block instead of a string constant.  */
1234           star_if_braced = (format_ptr[i] == 'T');
1235
1236           stringbuf = read_string (star_if_braced);
1237
1238           /* For insn patterns, we want to provide a default name
1239              based on the file and line, like "*foo.md:12", if the
1240              given name is blank.  These are only for define_insn and
1241              define_insn_and_split, to aid debugging.  */
1242           if (*stringbuf == '\0'
1243               && i == 0
1244               && (GET_CODE (return_rtx) == DEFINE_INSN
1245                   || GET_CODE (return_rtx) == DEFINE_INSN_AND_SPLIT))
1246             {
1247               char line_name[20];
1248               const char *fn = (read_md_filename ? read_md_filename : "rtx");
1249               const char *slash;
1250               for (slash = fn; *slash; slash ++)
1251                 if (*slash == '/' || *slash == '\\' || *slash == ':')
1252                   fn = slash + 1;
1253               obstack_1grow (&string_obstack, '*');
1254               obstack_grow (&string_obstack, fn, strlen (fn));
1255               sprintf (line_name, ":%d", read_md_lineno);
1256               obstack_grow (&string_obstack, line_name, strlen (line_name)+1);
1257               stringbuf = XOBFINISH (&string_obstack, char *);
1258             }
1259
1260           /* Find attr-names in the string.  */
1261           ptr = &tmpstr[0];
1262           end = stringbuf;
1263           while ((start = strchr (end, '<')) && (end  = strchr (start, '>')))
1264             {
1265               if ((end - start - 1 > 0)
1266                   && (end - start - 1 < (int)sizeof (tmpstr)))
1267                 {
1268                   strncpy (tmpstr, start+1, end-start-1);
1269                   tmpstr[end-start-1] = 0;
1270                   end++;
1271                 }
1272               else
1273                 break;
1274               m = (struct mapping *) htab_find (substs.attrs, &ptr);
1275               if (m != 0)
1276                 {
1277                   /* Here we should find linked subst-iter.  */
1278                   str = find_subst_iter_by_attr (ptr);
1279                   if (str)
1280                     m = (struct mapping *) htab_find (substs.iterators, &str);
1281                   else
1282                     m = 0;
1283                 }
1284               if (m != 0)
1285                 record_iterator_use (m, return_rtx);
1286             }
1287
1288           if (star_if_braced)
1289             XTMPL (return_rtx, i) = stringbuf;
1290           else
1291             XSTR (return_rtx, i) = stringbuf;
1292         }
1293         break;
1294
1295       case 'w':
1296         read_name (&name);
1297         validate_const_int (name.string);
1298 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
1299         tmp_wide = atoi (name.string);
1300 #else
1301 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
1302         tmp_wide = atol (name.string);
1303 #else
1304         /* Prefer atoll over atoq, since the former is in the ISO C99 standard.
1305            But prefer not to use our hand-rolled function above either.  */
1306 #if HAVE_DECL_ATOLL || !defined(HAVE_ATOQ)
1307         tmp_wide = atoll (name.string);
1308 #else
1309         tmp_wide = atoq (name.string);
1310 #endif
1311 #endif
1312 #endif
1313         XWINT (return_rtx, i) = tmp_wide;
1314         break;
1315
1316       case 'i':
1317       case 'n':
1318         /* Can be an iterator or an integer constant.  */
1319         read_name (&name);
1320         record_potential_iterator_use (&ints, &XINT (return_rtx, i),
1321                                        name.string);
1322         break;
1323
1324       case 'r':
1325         read_name (&name);
1326         validate_const_int (name.string);
1327         set_regno_raw (return_rtx, atoi (name.string), 1);
1328         REG_ATTRS (return_rtx) = NULL;
1329         break;
1330
1331       default:
1332         gcc_unreachable ();
1333       }
1334
1335   if (CONST_WIDE_INT_P (return_rtx))
1336     {
1337       read_name (&name);
1338       validate_const_wide_int (name.string);
1339       {
1340         const char *s = name.string;
1341         int len;
1342         int index = 0;
1343         int gs = HOST_BITS_PER_WIDE_INT/4;
1344         int pos;
1345         char * buf = XALLOCAVEC (char, gs + 1);
1346         unsigned HOST_WIDE_INT wi;
1347         int wlen;
1348
1349         /* Skip the leading spaces.  */
1350         while (*s && ISSPACE (*s))
1351           s++;
1352
1353         /* Skip the leading 0x.  */
1354         gcc_assert (s[0] == '0');
1355         gcc_assert (s[1] == 'x');
1356         s += 2;
1357
1358         len = strlen (s);
1359         pos = len - gs;
1360         wlen = (len + gs - 1) / gs;     /* Number of words needed */
1361
1362         return_rtx = const_wide_int_alloc (wlen);
1363
1364         while (pos > 0)
1365           {
1366 #if HOST_BITS_PER_WIDE_INT == 64
1367             sscanf (s + pos, "%16" HOST_WIDE_INT_PRINT "x", &wi);
1368 #else
1369             sscanf (s + pos, "%8" HOST_WIDE_INT_PRINT "x", &wi);
1370 #endif
1371             CWI_ELT (return_rtx, index++) = wi;
1372             pos -= gs;
1373           }
1374         strncpy (buf, s, gs - pos);
1375         buf [gs - pos] = 0;
1376         sscanf (buf, "%" HOST_WIDE_INT_PRINT "x", &wi);
1377         CWI_ELT (return_rtx, index++) = wi;
1378         /* TODO: After reading, do we want to canonicalize with:
1379            value = lookup_const_wide_int (value); ? */
1380       }
1381     }
1382
1383   c = read_skip_spaces ();
1384   /* Syntactic sugar for AND and IOR, allowing Lisp-like
1385      arbitrary number of arguments for them.  */
1386   if (c == '('
1387       && (GET_CODE (return_rtx) == AND
1388           || GET_CODE (return_rtx) == IOR))
1389     return read_rtx_variadic (return_rtx);
1390
1391   unread_char (c);
1392   return return_rtx;
1393 }
1394
1395 /* Read a nested rtx construct from the MD file and return it.  */
1396
1397 static rtx
1398 read_nested_rtx (void)
1399 {
1400   struct md_name name;
1401   int c;
1402   rtx return_rtx;
1403
1404   c = read_skip_spaces ();
1405   if (c != '(')
1406     fatal_expected_char ('(', c);
1407
1408   read_name (&name);
1409   if (strcmp (name.string, "nil") == 0)
1410     return_rtx = NULL;
1411   else
1412     return_rtx = read_rtx_code (name.string);
1413
1414   c = read_skip_spaces ();
1415   if (c != ')')
1416     fatal_expected_char (')', c);
1417
1418   return return_rtx;
1419 }
1420
1421 /* Mutually recursive subroutine of read_rtx which reads
1422    (thing x1 x2 x3 ...) and produces RTL as if
1423    (thing x1 (thing x2 (thing x3 ...)))  had been written.
1424    When called, FORM is (thing x1 x2), and the file position
1425    is just past the leading parenthesis of x3.  Only works
1426    for THINGs which are dyadic expressions, e.g. AND, IOR.  */
1427 static rtx
1428 read_rtx_variadic (rtx form)
1429 {
1430   char c = '(';
1431   rtx p = form, q;
1432
1433   do
1434     {
1435       unread_char (c);
1436
1437       q = rtx_alloc (GET_CODE (p));
1438       PUT_MODE (q, GET_MODE (p));
1439
1440       XEXP (q, 0) = XEXP (p, 1);
1441       XEXP (q, 1) = read_nested_rtx ();
1442
1443       XEXP (p, 1) = q;
1444       p = q;
1445       c = read_skip_spaces ();
1446     }
1447   while (c == '(');
1448   unread_char (c);
1449   return form;
1450 }