OSDN Git Service

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