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, 2010
   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 "read-md.h"
  34 #include "gensupport.h"
  35
  36 /* One element in a singly-linked list of (integer, string) pairs.  */
  37 struct map_value {
  38   struct map_value *next;
  39   int number;
  40   const char *string;
  41 };
  42
  43 /* Maps an iterator or attribute name to a list of (integer, string) pairs.
  44    The integers are mode or code values; the strings are either C conditions
  45    or attribute values.  */
  46 struct mapping {
  47   /* The name of the iterator or attribute.  */
  48   const char *name;
  49
  50   /* The group (modes or codes) to which the iterator or attribute belongs.  */
  51   struct iterator_group *group;
  52
  53   /* Gives a unique number to the attribute or iterator.  Numbers are
  54      allocated consecutively, starting at 0.  */
  55   int index;
  56
  57   /* The list of (integer, string) pairs.  */
  58   struct map_value *values;
  59 };
  60
  61 /* A structure for abstracting the common parts of code and mode iterators.  */
  62 struct iterator_group {
  63   /* Tables of "mapping" structures, one for attributes and one for iterators.  */
  64   htab_t attrs, iterators;
  65
  66   /* The number of "real" modes or codes (and by extension, the first
  67      number available for use as an iterator placeholder).  */
  68   int num_builtins;
  69
  70   /* Treat the given string as the name of a standard mode or code and
  71      return its integer value.  */
  72   int (*find_builtin) (const char *);
  73
  74   /* Return true if the given rtx uses the given mode or code.  */
  75   bool (*uses_iterator_p) (rtx, int);
  76
  77   /* Make the given rtx use the given mode or code.  */
  78   void (*apply_iterator) (rtx, int);
  79 };
  80
  81 /* A structure used to pass data from read_rtx to apply_iterator_traverse
  82    via htab_traverse.  */
  83 struct iterator_traverse_data {
  84   /* Instruction queue.  */
  85   rtx queue;
  86   /* Attributes seen for modes.  */
  87   struct map_value *mode_maps;
  88   /* The last unknown attribute used as a mode.  */
  89   const char *unknown_mode_attr;
  90 };
  91
  92 /* If CODE is the number of a code iterator, return a real rtx code that
  93    has the same format.  Return CODE otherwise.  */
  94 #define BELLWETHER_CODE(CODE) \
  95   ((CODE) < NUM_RTX_CODE ? CODE : bellwether_codes[CODE - NUM_RTX_CODE])
  96
  97 static int find_mode (const char *);
  98 static bool uses_mode_iterator_p (rtx, int);
  99 static void apply_mode_iterator (rtx, int);
 100 static int find_code (const char *);
 101 static bool uses_code_iterator_p (rtx, int);
 102 static void apply_code_iterator (rtx, int);
 103 static const char *apply_iterator_to_string (const char *, struct mapping *, int);
 104 static rtx apply_iterator_to_rtx (rtx, struct mapping *, int,
 105                                   struct map_value *, const char **);
 106 static bool uses_iterator_p (rtx, struct mapping *);
 107 static const char *add_condition_to_string (const char *, const char *);
 108 static void add_condition_to_rtx (rtx, const char *);
 109 static int apply_iterator_traverse (void **, void *);
 110 static struct mapping *add_mapping (struct iterator_group *, htab_t t,
 111                                     const char *);
 112 static struct map_value **add_map_value (struct map_value **,
 113                                          int, const char *);
 114 static void initialize_iterators (void);
 115 static void read_conditions (void);
 116 static void validate_const_int (const char *);
 117 static int find_iterator (struct iterator_group *, const char *);
 118 static struct mapping *read_mapping (struct iterator_group *, htab_t);
 119 static void check_code_iterator (struct mapping *);
 120 static rtx read_rtx_code (const char *, struct map_value **);
 121 static rtx read_nested_rtx (struct map_value **);
 122 static rtx read_rtx_variadic (struct map_value **, rtx);
 123
 124 /* The mode and code iterator structures.  */
 125 static struct iterator_group modes, codes;
 126
 127 /* Index I is the value of BELLWETHER_CODE (I + NUM_RTX_CODE).  */
 128 static enum rtx_code *bellwether_codes;
 129
 130 /* Implementations of the iterator_group callbacks for modes.  */
 131
 132 static int
 133 find_mode (const char *name)
 134 {
 135   int i;
 136
 137   for (i = 0; i < NUM_MACHINE_MODES; i++)
 138     if (strcmp (GET_MODE_NAME (i), name) == 0)
 139       return i;
 140
 141   fatal_with_file_and_line ("unknown mode `%s'", name);
 142 }
 143
 144 static bool
 145 uses_mode_iterator_p (rtx x, int mode)
 146 {
 147   return (int) GET_MODE (x) == mode;
 148 }
 149
 150 static void
 151 apply_mode_iterator (rtx x, int mode)
 152 {
 153   PUT_MODE (x, (enum machine_mode) mode);
 154 }
 155
 156 /* Implementations of the iterator_group callbacks for codes.  */
 157
 158 static int
 159 find_code (const char *name)
 160 {
 161   int i;
 162
 163   for (i = 0; i < NUM_RTX_CODE; i++)
 164     if (strcmp (GET_RTX_NAME (i), name) == 0)
 165       return i;
 166
 167   fatal_with_file_and_line ("unknown rtx code `%s'", name);
 168 }
 169
 170 static bool
 171 uses_code_iterator_p (rtx x, int code)
 172 {
 173   return (int) GET_CODE (x) == code;
 174 }
 175
 176 static void
 177 apply_code_iterator (rtx x, int code)
 178 {
 179   PUT_CODE (x, (enum rtx_code) code);
 180 }
 181
 182 /* Map a code or mode attribute string P to the underlying string for
 183    ITERATOR and VALUE.  */
 184
 185 static struct map_value *
 186 map_attr_string (const char *p, struct mapping *iterator, int value)
 187 {
 188   const char *attr;
 189   struct mapping *m;
 190   struct map_value *v;
 191
 192   /* If there's a "iterator:" prefix, check whether the iterator name matches.
 193      Set ATTR to the start of the attribute name.  */
 194   attr = strchr (p, ':');
 195   if (attr == 0)
 196     attr = p;
 197   else
 198     {
 199       if (strncmp (p, iterator->name, attr - p) != 0
 200           || iterator->name[attr - p] != 0)
 201         return 0;
 202       attr++;
 203     }
 204
 205   /* Find the attribute specification.  */
 206   m = (struct mapping *) htab_find (iterator->group->attrs, &attr);
 207   if (m == 0)
 208     return 0;
 209
 210   /* Find the attribute value for VALUE.  */
 211   for (v = m->values; v != 0; v = v->next)
 212     if (v->number == value)
 213       break;
 214
 215   return v;
 216 }
 217
 218 /* Given an attribute string used as a machine mode, return an index
 219    to store in the machine mode to be translated by
 220    apply_iterator_to_rtx.  */
 221
 222 static unsigned int
 223 mode_attr_index (struct map_value **mode_maps, const char *string)
 224 {
 225   char *p;
 226   struct map_value *mv;
 227
 228   /* Copy the attribute string into permanent storage, without the
 229      angle brackets around it.  */
 230   obstack_grow0 (&string_obstack, string + 1, strlen (string) - 2);
 231   p = XOBFINISH (&string_obstack, char *);
 232
 233   mv = XNEW (struct map_value);
 234   mv->number = *mode_maps == 0 ? 0 : (*mode_maps)->number + 1;
 235   mv->string = p;
 236   mv->next = *mode_maps;
 237   *mode_maps = mv;
 238
 239   /* We return a code which we can map back into this string: the
 240      number of machine modes + the number of mode iterators + the index
 241      we just used.  */
 242   return MAX_MACHINE_MODE + htab_elements (modes.iterators) + mv->number;
 243 }
 244
 245 /* Apply MODE_MAPS to the top level of X, expanding cases where an
 246    attribute is used for a mode.  ITERATOR is the current iterator we are
 247    expanding, and VALUE is the value to which we are expanding it.
 248    This sets *UNKNOWN to true if we find a mode attribute which has not
 249    yet been defined, and does not change it otherwise.  */
 250
 251 static void
 252 apply_mode_maps (rtx x, struct map_value *mode_maps, struct mapping *iterator,
 253                  int value, const char **unknown)
 254 {
 255   unsigned int offset;
 256   int indx;
 257   struct map_value *pm;
 258
 259   offset = MAX_MACHINE_MODE + htab_elements (modes.iterators);
 260   if (GET_MODE (x) < offset)
 261     return;
 262
 263   indx = GET_MODE (x) - offset;
 264   for (pm = mode_maps; pm; pm = pm->next)
 265     {
 266       if (pm->number == indx)
 267         {
 268           struct map_value *v;
 269
 270           v = map_attr_string (pm->string, iterator, value);
 271           if (v)
 272             PUT_MODE (x, (enum machine_mode) find_mode (v->string));
 273           else
 274             *unknown = pm->string;
 275           return;
 276         }
 277     }
 278 }
 279
 280 /* Given that ITERATOR is being expanded as VALUE, apply the appropriate
 281    string substitutions to STRING.  Return the new string if any changes
 282    were needed, otherwise return STRING itself.  */
 283
 284 static const char *
 285 apply_iterator_to_string (const char *string, struct mapping *iterator, int value)
 286 {
 287   char *base, *copy, *p, *start, *end;
 288   struct map_value *v;
 289
 290   if (string == 0)
 291     return string;
 292
 293   base = p = copy = ASTRDUP (string);
 294   while ((start = strchr (p, '<')) && (end = strchr (start, '>')))
 295     {
 296       p = start + 1;
 297
 298       *end = 0;
 299       v = map_attr_string (p, iterator, value);
 300       *end = '>';
 301       if (v == 0)
 302         continue;
 303
 304       /* Add everything between the last copied byte and the '<',
 305          then add in the attribute value.  */
 306       obstack_grow (&string_obstack, base, start - base);
 307       obstack_grow (&string_obstack, v->string, strlen (v->string));
 308       base = end + 1;
 309     }
 310   if (base != copy)
 311     {
 312       obstack_grow (&string_obstack, base, strlen (base) + 1);
 313       copy = XOBFINISH (&string_obstack, char *);
 314       copy_md_ptr_loc (copy, string);
 315       return copy;
 316     }
 317   return string;
 318 }
 319
 320 /* Return a copy of ORIGINAL in which all uses of ITERATOR have been
 321    replaced by VALUE.  MODE_MAPS holds information about attribute
 322    strings used for modes.  This sets *UNKNOWN_MODE_ATTR to the value of
 323    an unknown mode attribute, and does not change it otherwise.  */
 324
 325 static rtx
 326 apply_iterator_to_rtx (rtx original, struct mapping *iterator, int value,
 327                        struct map_value *mode_maps,
 328                        const char **unknown_mode_attr)
 329 {
 330   struct iterator_group *group;
 331   const char *format_ptr;
 332   int i, j;
 333   rtx x;
 334   enum rtx_code bellwether_code;
 335
 336   if (original == 0)
 337     return original;
 338
 339   /* Create a shallow copy of ORIGINAL.  */
 340   bellwether_code = BELLWETHER_CODE (GET_CODE (original));
 341   x = rtx_alloc (bellwether_code);
 342   memcpy (x, original, RTX_CODE_SIZE (bellwether_code));
 343
 344   /* Change the mode or code itself.  */
 345   group = iterator->group;
 346   if (group->uses_iterator_p (x, iterator->index + group->num_builtins))
 347     group->apply_iterator (x, value);
 348
 349   if (mode_maps)
 350     apply_mode_maps (x, mode_maps, iterator, value, unknown_mode_attr);
 351
 352   /* Change each string and recursively change each rtx.  */
 353   format_ptr = GET_RTX_FORMAT (bellwether_code);
 354   for (i = 0; format_ptr[i] != 0; i++)
 355     switch (format_ptr[i])
 356       {
 357       case 'T':
 358         XTMPL (x, i) = apply_iterator_to_string (XTMPL (x, i), iterator, value);
 359         break;
 360
 361       case 'S':
 362       case 's':
 363         XSTR (x, i) = apply_iterator_to_string (XSTR (x, i), iterator, value);
 364         break;
 365
 366       case 'e':
 367         XEXP (x, i) = apply_iterator_to_rtx (XEXP (x, i), iterator, value,
 368                                              mode_maps, unknown_mode_attr);
 369         break;
 370
 371       case 'V':
 372       case 'E':
 373         if (XVEC (original, i))
 374           {
 375             XVEC (x, i) = rtvec_alloc (XVECLEN (original, i));
 376             for (j = 0; j < XVECLEN (x, i); j++)
 377               XVECEXP (x, i, j) = apply_iterator_to_rtx (XVECEXP (original, i, j),
 378                                                          iterator, value, mode_maps,
 379                                                          unknown_mode_attr);
 380           }
 381         break;
 382
 383       default:
 384         break;
 385       }
 386   return x;
 387 }
 388
 389 /* Return true if X (or some subexpression of X) uses iterator ITERATOR.  */
 390
 391 static bool
 392 uses_iterator_p (rtx x, struct mapping *iterator)
 393 {
 394   struct iterator_group *group;
 395   const char *format_ptr;
 396   int i, j;
 397
 398   if (x == 0)
 399     return false;
 400
 401   group = iterator->group;
 402   if (group->uses_iterator_p (x, iterator->index + group->num_builtins))
 403     return true;
 404
 405   format_ptr = GET_RTX_FORMAT (BELLWETHER_CODE (GET_CODE (x)));
 406   for (i = 0; format_ptr[i] != 0; i++)
 407     switch (format_ptr[i])
 408       {
 409       case 'e':
 410         if (uses_iterator_p (XEXP (x, i), iterator))
 411           return true;
 412         break;
 413
 414       case 'V':
 415       case 'E':
 416         if (XVEC (x, i))
 417           for (j = 0; j < XVECLEN (x, i); j++)
 418             if (uses_iterator_p (XVECEXP (x, i, j), iterator))
 419               return true;
 420         break;
 421
 422       default:
 423         break;
 424       }
 425   return false;
 426 }
 427
 428 /* Return a condition that must satisfy both ORIGINAL and EXTRA.  If ORIGINAL
 429    has the form "&& ..." (as used in define_insn_and_splits), assume that
 430    EXTRA is already satisfied.  Empty strings are treated like "true".  */
 431
 432 static const char *
 433 add_condition_to_string (const char *original, const char *extra)
 434 {
 435   if (original != 0 && original[0] == '&' && original[1] == '&')
 436     return original;
 437   return join_c_conditions (original, extra);
 438 }
 439
 440 /* Like add_condition, but applied to all conditions in rtx X.  */
 441
 442 static void
 443 add_condition_to_rtx (rtx x, const char *extra)
 444 {
 445   switch (GET_CODE (x))
 446     {
 447     case DEFINE_INSN:
 448     case DEFINE_EXPAND:
 449       XSTR (x, 2) = add_condition_to_string (XSTR (x, 2), extra);
 450       break;
 451
 452     case DEFINE_SPLIT:
 453     case DEFINE_PEEPHOLE:
 454     case DEFINE_PEEPHOLE2:
 455     case DEFINE_COND_EXEC:
 456       XSTR (x, 1) = add_condition_to_string (XSTR (x, 1), extra);
 457       break;
 458
 459     case DEFINE_INSN_AND_SPLIT:
 460       XSTR (x, 2) = add_condition_to_string (XSTR (x, 2), extra);
 461       XSTR (x, 4) = add_condition_to_string (XSTR (x, 4), extra);
 462       break;
 463
 464     default:
 465       break;
 466     }
 467 }
 468
 469 /* A htab_traverse callback.  Search the EXPR_LIST given by DATA
 470    for rtxes that use the iterator in *SLOT.  Replace each such rtx
 471    with a list of expansions.  */
 472
 473 static int
 474 apply_iterator_traverse (void **slot, void *data)
 475 {
 476   struct iterator_traverse_data *mtd = (struct iterator_traverse_data *) data;
 477   struct mapping *iterator;
 478   struct map_value *v;
 479   rtx elem, new_elem, original, x;
 480
 481   iterator = (struct mapping *) *slot;
 482   for (elem = mtd->queue; elem != 0; elem = XEXP (elem, 1))
 483     if (uses_iterator_p (XEXP (elem, 0), iterator))
 484       {
 485         /* For each iterator we expand, we set UNKNOWN_MODE_ATTR to NULL.
 486            If apply_iterator_rtx finds an unknown attribute for a mode,
 487            it will set it to the attribute.  We want to know whether
 488            the attribute is unknown after we have expanded all
 489            possible iterators, so setting it to NULL here gives us the
 490            right result when the hash table traversal is complete.  */
 491         mtd->unknown_mode_attr = NULL;
 492
 493         original = XEXP (elem, 0);
 494         for (v = iterator->values; v != 0; v = v->next)
 495           {
 496             x = apply_iterator_to_rtx (original, iterator, v->number,
 497                                        mtd->mode_maps,
 498                                        &mtd->unknown_mode_attr);
 499             add_condition_to_rtx (x, v->string);
 500             if (v != iterator->values)
 501               {
 502                 /* Insert a new EXPR_LIST node after ELEM and put the
 503                    new expansion there.  */
 504                 new_elem = rtx_alloc (EXPR_LIST);
 505                 XEXP (new_elem, 1) = XEXP (elem, 1);
 506                 XEXP (elem, 1) = new_elem;
 507                 elem = new_elem;
 508               }
 509             XEXP (elem, 0) = x;
 510           }
 511     }
 512   return 1;
 513 }
 514
 515 /* Add a new "mapping" structure to hashtable TABLE.  NAME is the name
 516    of the mapping and GROUP is the group to which it belongs.  */
 517
 518 static struct mapping *
 519 add_mapping (struct iterator_group *group, htab_t table, const char *name)
 520 {
 521   struct mapping *m;
 522   void **slot;
 523
 524   m = XNEW (struct mapping);
 525   m->name = xstrdup (name);
 526   m->group = group;
 527   m->index = htab_elements (table);
 528   m->values = 0;
 529
 530   slot = htab_find_slot (table, m, INSERT);
 531   if (*slot != 0)
 532     fatal_with_file_and_line ("`%s' already defined", name);
 533
 534   *slot = m;
 535   return m;
 536 }
 537
 538 /* Add the pair (NUMBER, STRING) to a list of map_value structures.
 539    END_PTR points to the current null terminator for the list; return
 540    a pointer the new null terminator.  */
 541
 542 static struct map_value **
 543 add_map_value (struct map_value **end_ptr, int number, const char *string)
 544 {
 545   struct map_value *value;
 546
 547   value = XNEW (struct map_value);
 548   value->next = 0;
 549   value->number = number;
 550   value->string = string;
 551
 552   *end_ptr = value;
 553   return &value->next;
 554 }
 555
 556 /* Do one-time initialization of the mode and code attributes.  */
 557
 558 static void
 559 initialize_iterators (void)
 560 {
 561   struct mapping *lower, *upper;
 562   struct map_value **lower_ptr, **upper_ptr;
 563   char *copy, *p;
 564   int i;
 565
 566   modes.attrs = htab_create (13, leading_string_hash, leading_string_eq_p, 0);
 567   modes.iterators = htab_create (13, leading_string_hash,
 568                                  leading_string_eq_p, 0);
 569   modes.num_builtins = MAX_MACHINE_MODE;
 570   modes.find_builtin = find_mode;
 571   modes.uses_iterator_p = uses_mode_iterator_p;
 572   modes.apply_iterator = apply_mode_iterator;
 573
 574   codes.attrs = htab_create (13, leading_string_hash, leading_string_eq_p, 0);
 575   codes.iterators = htab_create (13, leading_string_hash,
 576                                  leading_string_eq_p, 0);
 577   codes.num_builtins = NUM_RTX_CODE;
 578   codes.find_builtin = find_code;
 579   codes.uses_iterator_p = uses_code_iterator_p;
 580   codes.apply_iterator = apply_code_iterator;
 581
 582   lower = add_mapping (&modes, modes.attrs, "mode");
 583   upper = add_mapping (&modes, modes.attrs, "MODE");
 584   lower_ptr = &lower->values;
 585   upper_ptr = &upper->values;
 586   for (i = 0; i < MAX_MACHINE_MODE; i++)
 587     {
 588       copy = xstrdup (GET_MODE_NAME (i));
 589       for (p = copy; *p != 0; p++)
 590         *p = TOLOWER (*p);
 591
 592       upper_ptr = add_map_value (upper_ptr, i, GET_MODE_NAME (i));
 593       lower_ptr = add_map_value (lower_ptr, i, copy);
 594     }
 595
 596   lower = add_mapping (&codes, codes.attrs, "code");
 597   upper = add_mapping (&codes, codes.attrs, "CODE");
 598   lower_ptr = &lower->values;
 599   upper_ptr = &upper->values;
 600   for (i = 0; i < NUM_RTX_CODE; i++)
 601     {
 602       copy = xstrdup (GET_RTX_NAME (i));
 603       for (p = copy; *p != 0; p++)
 604         *p = TOUPPER (*p);
 605
 606       lower_ptr = add_map_value (lower_ptr, i, GET_RTX_NAME (i));
 607       upper_ptr = add_map_value (upper_ptr, i, copy);
 608     }
 609 }
 610 \f
 611 /* Provide a version of a function to read a long long if the system does
 612    not provide one.  */
 613 #if HOST_BITS_PER_WIDE_INT > HOST_BITS_PER_LONG && !defined(HAVE_ATOLL) && !defined(HAVE_ATOQ)
 614 HOST_WIDE_INT atoll (const char *);
 615
 616 HOST_WIDE_INT
 617 atoll (const char *p)
 618 {
 619   int neg = 0;
 620   HOST_WIDE_INT tmp_wide;
 621
 622   while (ISSPACE (*p))
 623     p++;
 624   if (*p == '-')
 625     neg = 1, p++;
 626   else if (*p == '+')
 627     p++;
 628
 629   tmp_wide = 0;
 630   while (ISDIGIT (*p))
 631     {
 632       HOST_WIDE_INT new_wide = tmp_wide*10 + (*p - '0');
 633       if (new_wide < tmp_wide)
 634         {
 635           /* Return INT_MAX equiv on overflow.  */
 636           tmp_wide = (~(unsigned HOST_WIDE_INT) 0) >> 1;
 637           break;
 638         }
 639       tmp_wide = new_wide;
 640       p++;
 641     }
 642
 643   if (neg)
 644     tmp_wide = -tmp_wide;
 645   return tmp_wide;
 646 }
 647 #endif
 648 \f
 649 /* Process a define_conditions directive, starting with the optional
 650    space after the "define_conditions".  The directive looks like this:
 651
 652      (define_conditions [
 653         (number "string")
 654         (number "string")
 655         ...
 656      ])
 657
 658    It's not intended to appear in machine descriptions.  It is
 659    generated by (the program generated by) genconditions.c, and
 660    slipped in at the beginning of the sequence of MD files read by
 661    most of the other generators.  */
 662 static void
 663 read_conditions (void)
 664 {
 665   int c;
 666
 667   c = read_skip_spaces ();
 668   if (c != '[')
 669     fatal_expected_char ('[', c);
 670
 671   while ( (c = read_skip_spaces ()) != ']')
 672     {
 673       struct md_name name;
 674       char *expr;
 675       int value;
 676
 677       if (c != '(')
 678         fatal_expected_char ('(', c);
 679
 680       read_name (&name);
 681       validate_const_int (name.string);
 682       value = atoi (name.string);
 683
 684       c = read_skip_spaces ();
 685       if (c != '"')
 686         fatal_expected_char ('"', c);
 687       expr = read_quoted_string ();
 688
 689       c = read_skip_spaces ();
 690       if (c != ')')
 691         fatal_expected_char (')', c);
 692
 693       add_c_test (expr, value);
 694     }
 695 }
 696
 697 static void
 698 validate_const_int (const char *string)
 699 {
 700   const char *cp;
 701   int valid = 1;
 702
 703   cp = string;
 704   while (*cp && ISSPACE (*cp))
 705     cp++;
 706   if (*cp == '-' || *cp == '+')
 707     cp++;
 708   if (*cp == 0)
 709     valid = 0;
 710   for (; *cp; cp++)
 711     if (! ISDIGIT (*cp))
 712       valid = 0;
 713   if (!valid)
 714     fatal_with_file_and_line ("invalid decimal constant \"%s\"\n", string);
 715 }
 716
 717 /* Search GROUP for a mode or code called NAME and return its numerical
 718    identifier.  */
 719
 720 static int
 721 find_iterator (struct iterator_group *group, const char *name)
 722 {
 723   struct mapping *m;
 724
 725   m = (struct mapping *) htab_find (group->iterators, &name);
 726   if (m != 0)
 727     return m->index + group->num_builtins;
 728   return group->find_builtin (name);
 729 }
 730
 731 /* Finish reading a declaration of the form:
 732
 733        (define... <name> [<value1> ... <valuen>])
 734
 735    from the MD file, where each <valuei> is either a bare symbol name or a
 736    "(<name> <string>)" pair.  The "(define..." part has already been read.
 737
 738    Represent the declaration as a "mapping" structure; add it to TABLE
 739    (which belongs to GROUP) and return it.  */
 740
 741 static struct mapping *
 742 read_mapping (struct iterator_group *group, htab_t table)
 743 {
 744   struct md_name name;
 745   struct mapping *m;
 746   struct map_value **end_ptr;
 747   const char *string;
 748   int number, c;
 749
 750   /* Read the mapping name and create a structure for it.  */
 751   read_name (&name);
 752   m = add_mapping (group, table, name.string);
 753
 754   c = read_skip_spaces ();
 755   if (c != '[')
 756     fatal_expected_char ('[', c);
 757
 758   /* Read each value.  */
 759   end_ptr = &m->values;
 760   c = read_skip_spaces ();
 761   do
 762     {
 763       if (c != '(')
 764         {
 765           /* A bare symbol name that is implicitly paired to an
 766              empty string.  */
 767           unread_char (c);
 768           read_name (&name);
 769           string = "";
 770         }
 771       else
 772         {
 773           /* A "(name string)" pair.  */
 774           read_name (&name);
 775           string = read_string (false);
 776           c = read_skip_spaces ();
 777           if (c != ')')
 778             fatal_expected_char (')', c);
 779         }
 780       number = group->find_builtin (name.string);
 781       end_ptr = add_map_value (end_ptr, number, string);
 782       c = read_skip_spaces ();
 783     }
 784   while (c != ']');
 785
 786   return m;
 787 }
 788
 789 /* Check newly-created code iterator ITERATOR to see whether every code has the
 790    same format.  Initialize the iterator's entry in bellwether_codes.  */
 791
 792 static void
 793 check_code_iterator (struct mapping *iterator)
 794 {
 795   struct map_value *v;
 796   enum rtx_code bellwether;
 797
 798   bellwether = (enum rtx_code) iterator->values->number;
 799   for (v = iterator->values->next; v != 0; v = v->next)
 800     if (strcmp (GET_RTX_FORMAT (bellwether), GET_RTX_FORMAT (v->number)) != 0)
 801       fatal_with_file_and_line ("code iterator `%s' combines "
 802                                 "different rtx formats", iterator->name);
 803
 804   bellwether_codes = XRESIZEVEC (enum rtx_code, bellwether_codes,
 805                                  iterator->index + 1);
 806   bellwether_codes[iterator->index] = bellwether;
 807 }
 808
 809 /* Read an rtx-related declaration from the MD file, given that it
 810    starts with directive name RTX_NAME.  Return true if it expands to
 811    one or more rtxes (as defined by rtx.def).  When returning true,
 812    store the list of rtxes as an EXPR_LIST in *X.  */
 813
 814 bool
 815 read_rtx (const char *rtx_name, rtx *x)
 816 {
 817   static rtx queue_head;
 818   struct map_value *mode_maps;
 819   struct iterator_traverse_data mtd;
 820
 821   /* Do one-time initialization.  */
 822   if (queue_head == 0)
 823     {
 824       initialize_iterators ();
 825       queue_head = rtx_alloc (EXPR_LIST);
 826     }
 827
 828   /* Handle various rtx-related declarations that aren't themselves
 829      encoded as rtxes.  */
 830   if (strcmp (rtx_name, "define_conditions") == 0)
 831     {
 832       read_conditions ();
 833       return false;
 834     }
 835   if (strcmp (rtx_name, "define_mode_attr") == 0)
 836     {
 837       read_mapping (&modes, modes.attrs);
 838       return false;
 839     }
 840   if (strcmp (rtx_name, "define_mode_iterator") == 0)
 841     {
 842       read_mapping (&modes, modes.iterators);
 843       return false;
 844     }
 845   if (strcmp (rtx_name, "define_code_attr") == 0)
 846     {
 847       read_mapping (&codes, codes.attrs);
 848       return false;
 849     }
 850   if (strcmp (rtx_name, "define_code_iterator") == 0)
 851     {
 852       check_code_iterator (read_mapping (&codes, codes.iterators));
 853       return false;
 854     }
 855
 856   mode_maps = 0;
 857   XEXP (queue_head, 0) = read_rtx_code (rtx_name, &mode_maps);
 858   XEXP (queue_head, 1) = 0;
 859
 860   mtd.queue = queue_head;
 861   mtd.mode_maps = mode_maps;
 862   mtd.unknown_mode_attr = mode_maps ? mode_maps->string : NULL;
 863   htab_traverse (modes.iterators, apply_iterator_traverse, &mtd);
 864   htab_traverse (codes.iterators, apply_iterator_traverse, &mtd);
 865   if (mtd.unknown_mode_attr)
 866     fatal_with_file_and_line ("undefined attribute '%s' used for mode",
 867                               mtd.unknown_mode_attr);
 868
 869   *x = queue_head;
 870   return true;
 871 }
 872
 873 /* Subroutine of read_rtx and read_nested_rtx.  CODE_NAME is the name of
 874    either an rtx code or a code iterator.  Parse the rest of the rtx and
 875    return it.  MODE_MAPS is as for iterator_traverse_data.  */
 876
 877 static rtx
 878 read_rtx_code (const char *code_name, struct map_value **mode_maps)
 879 {
 880   int i;
 881   RTX_CODE real_code, bellwether_code;
 882   const char *format_ptr;
 883   struct md_name name;
 884   rtx return_rtx;
 885   int c;
 886   int tmp_int;
 887   HOST_WIDE_INT tmp_wide;
 888
 889   /* Linked list structure for making RTXs: */
 890   struct rtx_list
 891     {
 892       struct rtx_list *next;
 893       rtx value;                /* Value of this node.  */
 894     };
 895
 896   real_code = (enum rtx_code) find_iterator (&codes, code_name);
 897   bellwether_code = BELLWETHER_CODE (real_code);
 898
 899   /* If we end up with an insn expression then we free this space below.  */
 900   return_rtx = rtx_alloc (bellwether_code);
 901   format_ptr = GET_RTX_FORMAT (bellwether_code);
 902   PUT_CODE (return_rtx, real_code);
 903
 904   /* If what follows is `: mode ', read it and
 905      store the mode in the rtx.  */
 906
 907   i = read_skip_spaces ();
 908   if (i == ':')
 909     {
 910       unsigned int mode;
 911
 912       read_name (&name);
 913       if (name.string[0] != '<' || name.string[strlen (name.string) - 1] != '>')
 914         mode = find_iterator (&modes, name.string);
 915       else
 916         mode = mode_attr_index (mode_maps, name.string);
 917       PUT_MODE (return_rtx, (enum machine_mode) mode);
 918       if (GET_MODE (return_rtx) != mode)
 919         fatal_with_file_and_line ("mode too large");
 920     }
 921   else
 922     unread_char (i);
 923
 924   for (i = 0; format_ptr[i] != 0; i++)
 925     switch (format_ptr[i])
 926       {
 927         /* 0 means a field for internal use only.
 928            Don't expect it to be present in the input.  */
 929       case '0':
 930         break;
 931
 932       case 'e':
 933       case 'u':
 934         XEXP (return_rtx, i) = read_nested_rtx (mode_maps);
 935         break;
 936
 937       case 'V':
 938         /* 'V' is an optional vector: if a closeparen follows,
 939            just store NULL for this element.  */
 940         c = read_skip_spaces ();
 941         unread_char (c);
 942         if (c == ')')
 943           {
 944             XVEC (return_rtx, i) = 0;
 945             break;
 946           }
 947         /* Now process the vector.  */
 948
 949       case 'E':
 950         {
 951           /* Obstack to store scratch vector in.  */
 952           struct obstack vector_stack;
 953           int list_counter = 0;
 954           rtvec return_vec = NULL_RTVEC;
 955
 956           c = read_skip_spaces ();
 957           if (c != '[')
 958             fatal_expected_char ('[', c);
 959
 960           /* Add expressions to a list, while keeping a count.  */
 961           obstack_init (&vector_stack);
 962           while ((c = read_skip_spaces ()) && c != ']')
 963             {
 964               if (c == EOF)
 965                 fatal_expected_char (']', c);
 966               unread_char (c);
 967               list_counter++;
 968               obstack_ptr_grow (&vector_stack, read_nested_rtx (mode_maps));
 969             }
 970           if (list_counter > 0)
 971             {
 972               return_vec = rtvec_alloc (list_counter);
 973               memcpy (&return_vec->elem[0], obstack_finish (&vector_stack),
 974                       list_counter * sizeof (rtx));
 975             }
 976           else if (format_ptr[i] == 'E')
 977             fatal_with_file_and_line ("vector must have at least one element");
 978           XVEC (return_rtx, i) = return_vec;
 979           obstack_free (&vector_stack, NULL);
 980           /* close bracket gotten */
 981         }
 982         break;
 983
 984       case 'S':
 985       case 'T':
 986       case 's':
 987         {
 988           char *stringbuf;
 989           int star_if_braced;
 990
 991           c = read_skip_spaces ();
 992           unread_char (c);
 993           if (c == ')')
 994             {
 995               /* 'S' fields are optional and should be NULL if no string
 996                  was given.  Also allow normal 's' and 'T' strings to be
 997                  omitted, treating them in the same way as empty strings.  */
 998               XSTR (return_rtx, i) = (format_ptr[i] == 'S' ? NULL : "");
 999               break;
1000             }
1001
1002           /* The output template slot of a DEFINE_INSN,
1003              DEFINE_INSN_AND_SPLIT, or DEFINE_PEEPHOLE automatically
1004              gets a star inserted as its first character, if it is
1005              written with a brace block instead of a string constant.  */
1006           star_if_braced = (format_ptr[i] == 'T');
1007
1008           stringbuf = read_string (star_if_braced);
1009
1010           /* For insn patterns, we want to provide a default name
1011              based on the file and line, like "*foo.md:12", if the
1012              given name is blank.  These are only for define_insn and
1013              define_insn_and_split, to aid debugging.  */
1014           if (*stringbuf == '\0'
1015               && i == 0
1016               && (GET_CODE (return_rtx) == DEFINE_INSN
1017                   || GET_CODE (return_rtx) == DEFINE_INSN_AND_SPLIT))
1018             {
1019               char line_name[20];
1020               const char *fn = (read_md_filename ? read_md_filename : "rtx");
1021               const char *slash;
1022               for (slash = fn; *slash; slash ++)
1023                 if (*slash == '/' || *slash == '\\' || *slash == ':')
1024                   fn = slash + 1;
1025               obstack_1grow (&string_obstack, '*');
1026               obstack_grow (&string_obstack, fn, strlen (fn));
1027               sprintf (line_name, ":%d", read_md_lineno);
1028               obstack_grow (&string_obstack, line_name, strlen (line_name)+1);
1029               stringbuf = XOBFINISH (&string_obstack, char *);
1030             }
1031
1032           if (star_if_braced)
1033             XTMPL (return_rtx, i) = stringbuf;
1034           else
1035             XSTR (return_rtx, i) = stringbuf;
1036         }
1037         break;
1038
1039       case 'w':
1040         read_name (&name);
1041         validate_const_int (name.string);
1042 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
1043         tmp_wide = atoi (name.string);
1044 #else
1045 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
1046         tmp_wide = atol (name.string);
1047 #else
1048         /* Prefer atoll over atoq, since the former is in the ISO C99 standard.
1049            But prefer not to use our hand-rolled function above either.  */
1050 #if defined(HAVE_ATOLL) || !defined(HAVE_ATOQ)
1051         tmp_wide = atoll (name.string);
1052 #else
1053         tmp_wide = atoq (name.string);
1054 #endif
1055 #endif
1056 #endif
1057         XWINT (return_rtx, i) = tmp_wide;
1058         break;
1059
1060       case 'i':
1061       case 'n':
1062         read_name (&name);
1063         validate_const_int (name.string);
1064         tmp_int = atoi (name.string);
1065         XINT (return_rtx, i) = tmp_int;
1066         break;
1067
1068       default:
1069         gcc_unreachable ();
1070       }
1071
1072   c = read_skip_spaces ();
1073   /* Syntactic sugar for AND and IOR, allowing Lisp-like
1074      arbitrary number of arguments for them.  */
1075   if (c == '('
1076       && (GET_CODE (return_rtx) == AND
1077           || GET_CODE (return_rtx) == IOR))
1078     return read_rtx_variadic (mode_maps, return_rtx);
1079
1080   unread_char (c);
1081   return return_rtx;
1082 }
1083
1084 /* Read a nested rtx construct from the MD file and return it.
1085    MODE_MAPS is as for iterator_traverse_data.  */
1086
1087 static rtx
1088 read_nested_rtx (struct map_value **mode_maps)
1089 {
1090   struct md_name name;
1091   int c;
1092   rtx return_rtx;
1093
1094   c = read_skip_spaces ();
1095   if (c != '(')
1096     fatal_expected_char ('(', c);
1097
1098   read_name (&name);
1099   if (strcmp (name.string, "nil") == 0)
1100     return_rtx = NULL;
1101   else
1102     return_rtx = read_rtx_code (name.string, mode_maps);
1103
1104   c = read_skip_spaces ();
1105   if (c != ')')
1106     fatal_expected_char (')', c);
1107
1108   return return_rtx;
1109 }
1110
1111 /* Mutually recursive subroutine of read_rtx which reads
1112    (thing x1 x2 x3 ...) and produces RTL as if
1113    (thing x1 (thing x2 (thing x3 ...)))  had been written.
1114    When called, FORM is (thing x1 x2), and the file position
1115    is just past the leading parenthesis of x3.  Only works
1116    for THINGs which are dyadic expressions, e.g. AND, IOR.  */
1117 static rtx
1118 read_rtx_variadic (struct map_value **mode_maps, rtx form)
1119 {
1120   char c = '(';
1121   rtx p = form, q;
1122
1123   do
1124     {
1125       unread_char (c);
1126
1127       q = rtx_alloc (GET_CODE (p));
1128       PUT_MODE (q, GET_MODE (p));
1129
1130       XEXP (q, 0) = XEXP (p, 1);
1131       XEXP (q, 1) = read_nested_rtx (mode_maps);
1132
1133       XEXP (p, 1) = q;
1134       p = q;
1135       c = read_skip_spaces ();
1136     }
1137   while (c == '(');
1138   unread_char (c);
1139   return form;
1140 }