OSDN Git Service

1402c5468371c0a90fbf63b59c65bca6bd2dbade
[pf3gnuchains/gcc-fork.git] / 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 }