OSDN Git Service

6006745c3dd8e200056d3c8742b223dbbe0f4bad
[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
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 2, 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 COPYING.  If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
21 02111-1307, USA.  */
22
23 #include "bconfig.h"
24
25 /* Disable rtl checking; it conflicts with the macro handling.  */
26 #undef ENABLE_RTL_CHECKING
27
28 #include "system.h"
29 #include "coretypes.h"
30 #include "tm.h"
31 #include "rtl.h"
32 #include "obstack.h"
33 #include "hashtab.h"
34
35 static htab_t md_constants;
36
37 /* One element in a singly-linked list of (integer, string) pairs.  */
38 struct map_value {
39   struct map_value *next;
40   int number;
41   const char *string;
42 };
43
44 /* Maps a macro or attribute name to a list of (integer, string) pairs.
45    The integers are mode or code values; the strings are either C conditions
46    or attribute values.  */
47 struct mapping {
48   /* The name of the macro or attribute.  */
49   const char *name;
50
51   /* The group (modes or codes) to which the macro or attribute belongs.  */
52   struct macro_group *group;
53
54   /* Gives a unique number to the attribute or macro.  Numbers are
55      allocated consecutively, starting at 0.  */
56   int index;
57
58   /* The list of (integer, string) pairs.  */
59   struct map_value *values;
60 };
61
62 /* A structure for abstracting the common parts of code and mode macros.  */
63 struct macro_group {
64   /* Tables of "mapping" structures, one for attributes and one for macros.  */
65   htab_t attrs, macros;
66
67   /* The number of "real" modes or codes (and by extension, the first
68      number available for use as a macro placeholder).  */
69   int num_builtins;
70
71   /* Treat the given string as the name of a standard mode or code and
72      return its integer value.  Use the given file for error reporting.  */
73   int (*find_builtin) (const char *, FILE *);
74
75   /* Return true if the given rtx uses the given mode or code.  */
76   bool (*uses_macro_p) (rtx, int);
77
78   /* Make the given rtx use the given mode or code.  */
79   void (*apply_macro) (rtx, int);
80 };
81
82 /* If CODE is the number of a code macro, return a real rtx code that
83    has the same format.  Return CODE otherwise.  */
84 #define BELLWETHER_CODE(CODE) \
85   ((CODE) < NUM_RTX_CODE ? CODE : bellwether_codes[CODE - NUM_RTX_CODE])
86
87 static void fatal_with_file_and_line (FILE *, const char *, ...)
88   ATTRIBUTE_PRINTF_2 ATTRIBUTE_NORETURN;
89 static void fatal_expected_char (FILE *, int, int) ATTRIBUTE_NORETURN;
90 static int find_mode (const char *, FILE *);
91 static bool uses_mode_macro_p (rtx, int);
92 static void apply_mode_macro (rtx, int);
93 static int find_code (const char *, FILE *);
94 static bool uses_code_macro_p (rtx, int);
95 static void apply_code_macro (rtx, int);
96 static const char *apply_macro_to_string (const char *, struct mapping *, int);
97 static rtx apply_macro_to_rtx (rtx, struct mapping *, int);
98 static bool uses_macro_p (rtx, struct mapping *);
99 static const char *add_condition_to_string (const char *, const char *);
100 static void add_condition_to_rtx (rtx, const char *);
101 static int apply_macro_traverse (void **, void *);
102 static struct mapping *add_mapping (struct macro_group *, htab_t t,
103                                     const char *, FILE *);
104 static struct map_value **add_map_value (struct map_value **,
105                                          int, const char *);
106 static void initialize_macros (void);
107 static void read_name (char *, FILE *);
108 static char *read_string (FILE *, int);
109 static char *read_quoted_string (FILE *);
110 static char *read_braced_string (FILE *);
111 static void read_escape (FILE *);
112 static hashval_t def_hash (const void *);
113 static int def_name_eq_p (const void *, const void *);
114 static void read_constants (FILE *infile, char *tmp_char);
115 static void validate_const_int (FILE *, const char *);
116 static int find_macro (struct macro_group *, const char *, FILE *);
117 static struct mapping *read_mapping (struct macro_group *, htab_t, FILE *);
118 static void check_code_macro (struct mapping *, FILE *);
119 static rtx read_rtx_1 (FILE *);
120
121 /* The mode and code macro structures.  */
122 static struct macro_group modes, codes;
123
124 /* Index I is the value of BELLWETHER_CODE (I + NUM_RTX_CODE).  */
125 static enum rtx_code *bellwether_codes;
126
127 /* Obstack used for allocating RTL strings.  */
128 static struct obstack string_obstack;
129
130 /* Subroutines of read_rtx.  */
131
132 /* The current line number for the file.  */
133 int read_rtx_lineno = 1;
134
135 /* The filename for aborting with file and line.  */
136 const char *read_rtx_filename = "<unknown>";
137
138 static void
139 fatal_with_file_and_line (FILE *infile, const char *msg, ...)
140 {
141   char context[64];
142   size_t i;
143   int c;
144   va_list ap;
145
146   va_start (ap, msg);
147
148   fprintf (stderr, "%s:%d: ", read_rtx_filename, read_rtx_lineno);
149   vfprintf (stderr, msg, ap);
150   putc ('\n', stderr);
151
152   /* Gather some following context.  */
153   for (i = 0; i < sizeof (context)-1; ++i)
154     {
155       c = getc (infile);
156       if (c == EOF)
157         break;
158       if (c == '\r' || c == '\n')
159         break;
160       context[i] = c;
161     }
162   context[i] = '\0';
163
164   fprintf (stderr, "%s:%d: following context is `%s'\n",
165            read_rtx_filename, read_rtx_lineno, context);
166
167   va_end (ap);
168   exit (1);
169 }
170
171 /* Dump code after printing a message.  Used when read_rtx finds
172    invalid data.  */
173
174 static void
175 fatal_expected_char (FILE *infile, int expected_c, int actual_c)
176 {
177   fatal_with_file_and_line (infile, "expected character `%c', found `%c'",
178                             expected_c, actual_c);
179 }
180
181 /* Implementations of the macro_group callbacks for modes.  */
182
183 static int
184 find_mode (const char *name, FILE *infile)
185 {
186   int i;
187
188   for (i = 0; i < NUM_MACHINE_MODES; i++)
189     if (strcmp (GET_MODE_NAME (i), name) == 0)
190       return i;
191
192   fatal_with_file_and_line (infile, "unknown mode `%s'", name);
193 }
194
195 static bool
196 uses_mode_macro_p (rtx x, int mode)
197 {
198   return (int) GET_MODE (x) == mode;
199 }
200
201 static void
202 apply_mode_macro (rtx x, int mode)
203 {
204   PUT_MODE (x, mode);
205 }
206
207 /* Implementations of the macro_group callbacks for codes.  */
208
209 static int
210 find_code (const char *name, FILE *infile)
211 {
212   int i;
213
214   for (i = 0; i < NUM_RTX_CODE; i++)
215     if (strcmp (GET_RTX_NAME (i), name) == 0)
216       return i;
217
218   fatal_with_file_and_line (infile, "unknown rtx code `%s'", name);
219 }
220
221 static bool
222 uses_code_macro_p (rtx x, int code)
223 {
224   return (int) GET_CODE (x) == code;
225 }
226
227 static void
228 apply_code_macro (rtx x, int code)
229 {
230   PUT_CODE (x, code);
231 }
232
233 /* Given that MACRO is being expanded as VALUE, apply the appropriate
234    string substitutions to STRING.  Return the new string if any changes
235    were needed, otherwise return STRING itself.  */
236
237 static const char *
238 apply_macro_to_string (const char *string, struct mapping *macro, int value)
239 {
240   char *base, *copy, *p, *attr, *start, *end;
241   struct mapping *m;
242   struct map_value *v;
243
244   if (string == 0)
245     return string;
246
247   base = p = copy = ASTRDUP (string);
248   while ((start = strchr (p, '<')) && (end = strchr (start, '>')))
249     {
250       p = start + 1;
251
252       /* If there's a "macro:" prefix, check whether the macro name matches.
253          Set ATTR to the start of the attribute name.  */
254       attr = strchr (p, ':');
255       if (attr == 0 || attr > end)
256         attr = p;
257       else
258         {
259           if (strncmp (p, macro->name, attr - p) != 0
260               || macro->name[attr - p] != 0)
261             continue;
262           attr++;
263         }
264
265       /* Find the attribute specification.  */
266       *end = 0;
267       m = (struct mapping *) htab_find (macro->group->attrs, &attr);
268       *end = '>';
269       if (m == 0)
270         continue;
271
272       /* Find the attribute value for VALUE.  */
273       for (v = m->values; v != 0; v = v->next)
274         if (v->number == value)
275           break;
276       if (v == 0)
277         continue;
278
279       /* Add everything between the last copied byte and the '<',
280          then add in the attribute value.  */
281       obstack_grow (&string_obstack, base, start - base);
282       obstack_grow (&string_obstack, v->string, strlen (v->string));
283       base = end + 1;
284     }
285   if (base != copy)
286     {
287       obstack_grow (&string_obstack, base, strlen (base) + 1);
288       return (char *) obstack_finish (&string_obstack);
289     }
290   return string;
291 }
292
293 /* Return a copy of ORIGINAL in which all uses of MACRO have been
294    replaced by VALUE.  */
295
296 static rtx
297 apply_macro_to_rtx (rtx original, struct mapping *macro, int value)
298 {
299   struct macro_group *group;
300   const char *format_ptr;
301   int i, j;
302   rtx x;
303   enum rtx_code bellwether_code;
304
305   if (original == 0)
306     return original;
307
308   /* Create a shallow copy of ORIGINAL.  */
309   bellwether_code = BELLWETHER_CODE (GET_CODE (original));
310   x = rtx_alloc (bellwether_code);
311   memcpy (x, original, RTX_SIZE (bellwether_code));
312
313   /* Change the mode or code itself.  */
314   group = macro->group;
315   if (group->uses_macro_p (x, macro->index + group->num_builtins))
316     group->apply_macro (x, value);
317
318   /* Change each string and recursively change each rtx.  */
319   format_ptr = GET_RTX_FORMAT (bellwether_code);
320   for (i = 0; format_ptr[i] != 0; i++)
321     switch (format_ptr[i])
322       {
323       case 'T':
324         XTMPL (x, i) = apply_macro_to_string (XTMPL (x, i), macro, value);
325         break;
326
327       case 'S':
328       case 's':
329         XSTR (x, i) = apply_macro_to_string (XSTR (x, i), macro, value);
330         break;
331
332       case 'e':
333         XEXP (x, i) = apply_macro_to_rtx (XEXP (x, i), macro, value);
334         break;
335
336       case 'V':
337       case 'E':
338         if (XVEC (original, i))
339           {
340             XVEC (x, i) = rtvec_alloc (XVECLEN (original, i));
341             for (j = 0; j < XVECLEN (x, i); j++)
342               XVECEXP (x, i, j) = apply_macro_to_rtx (XVECEXP (original, i, j),
343                                                       macro, value);
344           }
345         break;
346
347       default:
348         break;
349       }
350   return x;
351 }
352
353 /* Return true if X (or some subexpression of X) uses macro MACRO.  */
354
355 static bool
356 uses_macro_p (rtx x, struct mapping *macro)
357 {
358   struct macro_group *group;
359   const char *format_ptr;
360   int i, j;
361
362   if (x == 0)
363     return false;
364
365   group = macro->group;
366   if (group->uses_macro_p (x, macro->index + group->num_builtins))
367     return true;
368
369   format_ptr = GET_RTX_FORMAT (BELLWETHER_CODE (GET_CODE (x)));
370   for (i = 0; format_ptr[i] != 0; i++)
371     switch (format_ptr[i])
372       {
373       case 'e':
374         if (uses_macro_p (XEXP (x, i), macro))
375           return true;
376         break;
377
378       case 'V':
379       case 'E':
380         if (XVEC (x, i))
381           for (j = 0; j < XVECLEN (x, i); j++)
382             if (uses_macro_p (XVECEXP (x, i, j), macro))
383               return true;
384         break;
385
386       default:
387         break;
388       }
389   return false;
390 }
391
392 /* Return a condition that must satisfy both ORIGINAL and EXTRA.  If ORIGINAL
393    has the form "&& ..." (as used in define_insn_and_splits), assume that
394    EXTRA is already satisfied.  Empty strings are treated like "true".  */
395
396 static const char *
397 add_condition_to_string (const char *original, const char *extra)
398 {
399   char *result;
400
401   if (original == 0 || original[0] == 0)
402     return extra;
403
404   if ((original[0] == '&' && original[1] == '&') || extra[0] == 0)
405     return original;
406
407   asprintf (&result, "(%s) && (%s)", original, extra);
408   return result;
409 }
410
411 /* Like add_condition, but applied to all conditions in rtx X.  */
412
413 static void
414 add_condition_to_rtx (rtx x, const char *extra)
415 {
416   switch (GET_CODE (x))
417     {
418     case DEFINE_INSN:
419     case DEFINE_EXPAND:
420       XSTR (x, 2) = add_condition_to_string (XSTR (x, 2), extra);
421       break;
422
423     case DEFINE_SPLIT:
424     case DEFINE_PEEPHOLE:
425     case DEFINE_PEEPHOLE2:
426     case DEFINE_COND_EXEC:
427       XSTR (x, 1) = add_condition_to_string (XSTR (x, 1), extra);
428       break;
429
430     case DEFINE_INSN_AND_SPLIT:
431       XSTR (x, 2) = add_condition_to_string (XSTR (x, 2), extra);
432       XSTR (x, 4) = add_condition_to_string (XSTR (x, 4), extra);
433       break;
434
435     default:
436       break;
437     }
438 }
439
440 /* A htab_traverse callback.  Search the EXPR_LIST given by DATA
441    for rtxes that use the macro in *SLOT.  Replace each such rtx
442    with a list of expansions.  */
443
444 static int
445 apply_macro_traverse (void **slot, void *data)
446 {
447   struct mapping *macro;
448   struct map_value *v;
449   rtx elem, new_elem, original, x;
450
451   macro = (struct mapping *) *slot;
452   for (elem = (rtx) data; elem != 0; elem = XEXP (elem, 1))
453     if (uses_macro_p (XEXP (elem, 0), macro))
454       {
455         original = XEXP (elem, 0);
456         for (v = macro->values; v != 0; v = v->next)
457           {
458             x = apply_macro_to_rtx (original, macro, v->number);
459             add_condition_to_rtx (x, v->string);
460             if (v != macro->values)
461               {
462                 /* Insert a new EXPR_LIST node after ELEM and put the
463                    new expansion there.  */
464                 new_elem = rtx_alloc (EXPR_LIST);
465                 XEXP (new_elem, 1) = XEXP (elem, 1);
466                 XEXP (elem, 1) = new_elem;
467                 elem = new_elem;
468               }
469             XEXP (elem, 0) = x;
470           }
471     }
472   return 1;
473 }
474
475 /* Add a new "mapping" structure to hashtable TABLE.  NAME is the name
476    of the mapping, GROUP is the group to which it belongs, and INFILE
477    is the file that defined the mapping.  */
478
479 static struct mapping *
480 add_mapping (struct macro_group *group, htab_t table,
481              const char *name, FILE *infile)
482 {
483   struct mapping *m;
484   void **slot;
485
486   m = XNEW (struct mapping);
487   m->name = xstrdup (name);
488   m->group = group;
489   m->index = htab_elements (table);
490   m->values = 0;
491
492   slot = htab_find_slot (table, m, INSERT);
493   if (*slot != 0)
494     fatal_with_file_and_line (infile, "`%s' already defined", name);
495
496   *slot = m;
497   return m;
498 }
499
500 /* Add the pair (NUMBER, STRING) to a list of map_value structures.
501    END_PTR points to the current null terminator for the list; return
502    a pointer the new null terminator.  */
503
504 static struct map_value **
505 add_map_value (struct map_value **end_ptr, int number, const char *string)
506 {
507   struct map_value *value;
508
509   value = XNEW (struct map_value);
510   value->next = 0;
511   value->number = number;
512   value->string = string;
513
514   *end_ptr = value;
515   return &value->next;
516 }
517
518 /* Do one-time initialization of the mode and code attributes.  */
519
520 static void
521 initialize_macros (void)
522 {
523   struct mapping *lower, *upper;
524   struct map_value **lower_ptr, **upper_ptr;
525   char *copy, *p;
526   int i;
527
528   modes.attrs = htab_create (13, def_hash, def_name_eq_p, 0);
529   modes.macros = htab_create (13, def_hash, def_name_eq_p, 0);
530   modes.num_builtins = MAX_MACHINE_MODE;
531   modes.find_builtin = find_mode;
532   modes.uses_macro_p = uses_mode_macro_p;
533   modes.apply_macro = apply_mode_macro;
534
535   codes.attrs = htab_create (13, def_hash, def_name_eq_p, 0);
536   codes.macros = htab_create (13, def_hash, def_name_eq_p, 0);
537   codes.num_builtins = NUM_RTX_CODE;
538   codes.find_builtin = find_code;
539   codes.uses_macro_p = uses_code_macro_p;
540   codes.apply_macro = apply_code_macro;
541
542   lower = add_mapping (&modes, modes.attrs, "mode", 0);
543   upper = add_mapping (&modes, modes.attrs, "MODE", 0);
544   lower_ptr = &lower->values;
545   upper_ptr = &upper->values;
546   for (i = 0; i < MAX_MACHINE_MODE; i++)
547     {
548       copy = xstrdup (GET_MODE_NAME (i));
549       for (p = copy; *p != 0; p++)
550         *p = TOLOWER (*p);
551
552       upper_ptr = add_map_value (upper_ptr, i, GET_MODE_NAME (i));
553       lower_ptr = add_map_value (lower_ptr, i, copy);
554     }
555
556   lower = add_mapping (&codes, codes.attrs, "code", 0);
557   upper = add_mapping (&codes, codes.attrs, "CODE", 0);
558   lower_ptr = &lower->values;
559   upper_ptr = &upper->values;
560   for (i = 0; i < NUM_RTX_CODE; i++)
561     {
562       copy = xstrdup (GET_RTX_NAME (i));
563       for (p = copy; *p != 0; p++)
564         *p = TOUPPER (*p);
565
566       lower_ptr = add_map_value (lower_ptr, i, GET_RTX_NAME (i));
567       upper_ptr = add_map_value (upper_ptr, i, copy);
568     }
569 }
570
571 /* Read chars from INFILE until a non-whitespace char
572    and return that.  Comments, both Lisp style and C style,
573    are treated as whitespace.
574    Tools such as genflags use this function.  */
575
576 int
577 read_skip_spaces (FILE *infile)
578 {
579   int c;
580
581   while (1)
582     {
583       c = getc (infile);
584       switch (c)
585         {
586         case '\n':
587           read_rtx_lineno++;
588           break;
589
590         case ' ': case '\t': case '\f': case '\r':
591           break;
592
593         case ';':
594           do
595             c = getc (infile);
596           while (c != '\n' && c != EOF);
597           read_rtx_lineno++;
598           break;
599
600         case '/':
601           {
602             int prevc;
603             c = getc (infile);
604             if (c != '*')
605               fatal_expected_char (infile, '*', c);
606
607             prevc = 0;
608             while ((c = getc (infile)) && c != EOF)
609               {
610                 if (c == '\n')
611                    read_rtx_lineno++;
612                 else if (prevc == '*' && c == '/')
613                   break;
614                 prevc = c;
615               }
616           }
617           break;
618
619         default:
620           return c;
621         }
622     }
623 }
624
625 /* Read an rtx code name into the buffer STR[].
626    It is terminated by any of the punctuation chars of rtx printed syntax.  */
627
628 static void
629 read_name (char *str, FILE *infile)
630 {
631   char *p;
632   int c;
633
634   c = read_skip_spaces (infile);
635
636   p = str;
637   while (1)
638     {
639       if (c == ' ' || c == '\n' || c == '\t' || c == '\f' || c == '\r')
640         break;
641       if (c == ':' || c == ')' || c == ']' || c == '"' || c == '/'
642           || c == '(' || c == '[')
643         {
644           ungetc (c, infile);
645           break;
646         }
647       *p++ = c;
648       c = getc (infile);
649     }
650   if (p == str)
651     fatal_with_file_and_line (infile, "missing name or number");
652   if (c == '\n')
653     read_rtx_lineno++;
654
655   *p = 0;
656
657   if (md_constants)
658     {
659       /* Do constant expansion.  */
660       struct md_constant *def;
661
662       p = str;
663       do
664         {
665           struct md_constant tmp_def;
666
667           tmp_def.name = p;
668           def = (struct md_constant *) htab_find (md_constants, &tmp_def);
669           if (def)
670             p = def->value;
671         } while (def);
672       if (p != str)
673         strcpy (str, p);
674     }
675 }
676
677 /* Subroutine of the string readers.  Handles backslash escapes.
678    Caller has read the backslash, but not placed it into the obstack.  */
679 static void
680 read_escape (FILE *infile)
681 {
682   int c = getc (infile);
683
684   switch (c)
685     {
686       /* Backslash-newline is replaced by nothing, as in C.  */
687     case '\n':
688       read_rtx_lineno++;
689       return;
690
691       /* \" \' \\ are replaced by the second character.  */
692     case '\\':
693     case '"':
694     case '\'':
695       break;
696
697       /* Standard C string escapes:
698          \a \b \f \n \r \t \v
699          \[0-7] \x
700          all are passed through to the output string unmolested.
701          In normal use these wind up in a string constant processed
702          by the C compiler, which will translate them appropriately.
703          We do not bother checking that \[0-7] are followed by up to
704          two octal digits, or that \x is followed by N hex digits.
705          \? \u \U are left out because they are not in traditional C.  */
706     case 'a': case 'b': case 'f': case 'n': case 'r': case 't': case 'v':
707     case '0': case '1': case '2': case '3': case '4': case '5': case '6':
708     case '7': case 'x':
709       obstack_1grow (&string_obstack, '\\');
710       break;
711
712       /* \; makes stuff for a C string constant containing
713          newline and tab.  */
714     case ';':
715       obstack_grow (&string_obstack, "\\n\\t", 4);
716       return;
717
718       /* pass anything else through, but issue a warning.  */
719     default:
720       fprintf (stderr, "%s:%d: warning: unrecognized escape \\%c\n",
721                read_rtx_filename, read_rtx_lineno, c);
722       obstack_1grow (&string_obstack, '\\');
723       break;
724     }
725
726   obstack_1grow (&string_obstack, c);
727 }
728
729
730 /* Read a double-quoted string onto the obstack.  Caller has scanned
731    the leading quote.  */
732 static char *
733 read_quoted_string (FILE *infile)
734 {
735   int c;
736
737   while (1)
738     {
739       c = getc (infile); /* Read the string  */
740       if (c == '\n')
741         read_rtx_lineno++;
742       else if (c == '\\')
743         {
744           read_escape (infile);
745           continue;
746         }
747       else if (c == '"')
748         break;
749
750       obstack_1grow (&string_obstack, c);
751     }
752
753   obstack_1grow (&string_obstack, 0);
754   return (char *) obstack_finish (&string_obstack);
755 }
756
757 /* Read a braced string (a la Tcl) onto the string obstack.  Caller
758    has scanned the leading brace.  Note that unlike quoted strings,
759    the outermost braces _are_ included in the string constant.  */
760 static char *
761 read_braced_string (FILE *infile)
762 {
763   int c;
764   int brace_depth = 1;  /* caller-processed */
765   unsigned long starting_read_rtx_lineno = read_rtx_lineno;
766
767   obstack_1grow (&string_obstack, '{');
768   while (brace_depth)
769     {
770       c = getc (infile); /* Read the string  */
771
772       if (c == '\n')
773         read_rtx_lineno++;
774       else if (c == '{')
775         brace_depth++;
776       else if (c == '}')
777         brace_depth--;
778       else if (c == '\\')
779         {
780           read_escape (infile);
781           continue;
782         }
783       else if (c == EOF)
784         fatal_with_file_and_line
785           (infile, "missing closing } for opening brace on line %lu",
786            starting_read_rtx_lineno);
787
788       obstack_1grow (&string_obstack, c);
789     }
790
791   obstack_1grow (&string_obstack, 0);
792   return (char *) obstack_finish (&string_obstack);
793 }
794
795 /* Read some kind of string constant.  This is the high-level routine
796    used by read_rtx.  It handles surrounding parentheses, leading star,
797    and dispatch to the appropriate string constant reader.  */
798
799 static char *
800 read_string (FILE *infile, int star_if_braced)
801 {
802   char *stringbuf;
803   int saw_paren = 0;
804   int c;
805
806   c = read_skip_spaces (infile);
807   if (c == '(')
808     {
809       saw_paren = 1;
810       c = read_skip_spaces (infile);
811     }
812
813   if (c == '"')
814     stringbuf = read_quoted_string (infile);
815   else if (c == '{')
816     {
817       if (star_if_braced)
818         obstack_1grow (&string_obstack, '*');
819       stringbuf = read_braced_string (infile);
820     }
821   else
822     fatal_with_file_and_line (infile, "expected `\"' or `{', found `%c'", c);
823
824   if (saw_paren)
825     {
826       c = read_skip_spaces (infile);
827       if (c != ')')
828         fatal_expected_char (infile, ')', c);
829     }
830
831   return stringbuf;
832 }
833 \f
834 /* Provide a version of a function to read a long long if the system does
835    not provide one.  */
836 #if HOST_BITS_PER_WIDE_INT > HOST_BITS_PER_LONG && !defined(HAVE_ATOLL) && !defined(HAVE_ATOQ)
837 HOST_WIDE_INT atoll (const char *);
838
839 HOST_WIDE_INT
840 atoll (const char *p)
841 {
842   int neg = 0;
843   HOST_WIDE_INT tmp_wide;
844
845   while (ISSPACE (*p))
846     p++;
847   if (*p == '-')
848     neg = 1, p++;
849   else if (*p == '+')
850     p++;
851
852   tmp_wide = 0;
853   while (ISDIGIT (*p))
854     {
855       HOST_WIDE_INT new_wide = tmp_wide*10 + (*p - '0');
856       if (new_wide < tmp_wide)
857         {
858           /* Return INT_MAX equiv on overflow.  */
859           tmp_wide = (~(unsigned HOST_WIDE_INT) 0) >> 1;
860           break;
861         }
862       tmp_wide = new_wide;
863       p++;
864     }
865
866   if (neg)
867     tmp_wide = -tmp_wide;
868   return tmp_wide;
869 }
870 #endif
871
872 /* Given an object that starts with a char * name field, return a hash
873    code for its name.  */
874 static hashval_t
875 def_hash (const void *def)
876 {
877   unsigned result, i;
878   const char *string = *(const char *const *) def;
879
880   for (result = i = 0; *string++ != '\0'; i++)
881     result += ((unsigned char) *string << (i % CHAR_BIT));
882   return result;
883 }
884
885 /* Given two objects that start with char * name fields, return true if
886    they have the same name.  */
887 static int
888 def_name_eq_p (const void *def1, const void *def2)
889 {
890   return ! strcmp (*(const char *const *) def1,
891                    *(const char *const *) def2);
892 }
893
894 /* INFILE is a FILE pointer to read text from.  TMP_CHAR is a buffer suitable
895    to read a name or number into.  Process a define_constants directive,
896    starting with the optional space after the "define_constants".  */
897 static void
898 read_constants (FILE *infile, char *tmp_char)
899 {
900   int c;
901   htab_t defs;
902
903   c = read_skip_spaces (infile);
904   if (c != '[')
905     fatal_expected_char (infile, '[', c);
906   defs = md_constants;
907   if (! defs)
908     defs = htab_create (32, def_hash, def_name_eq_p, (htab_del) 0);
909   /* Disable constant expansion during definition processing.  */
910   md_constants = 0;
911   while ( (c = read_skip_spaces (infile)) != ']')
912     {
913       struct md_constant *def;
914       void **entry_ptr;
915
916       if (c != '(')
917         fatal_expected_char (infile, '(', c);
918       def = XNEW (struct md_constant);
919       def->name = tmp_char;
920       read_name (tmp_char, infile);
921       entry_ptr = htab_find_slot (defs, def, INSERT);
922       if (! *entry_ptr)
923         def->name = xstrdup (tmp_char);
924       c = read_skip_spaces (infile);
925       ungetc (c, infile);
926       read_name (tmp_char, infile);
927       if (! *entry_ptr)
928         {
929           def->value = xstrdup (tmp_char);
930           *entry_ptr = def;
931         }
932       else
933         {
934           def = (struct md_constant *) *entry_ptr;
935           if (strcmp (def->value, tmp_char))
936             fatal_with_file_and_line (infile,
937                                       "redefinition of %s, was %s, now %s",
938                                       def->name, def->value, tmp_char);
939         }
940       c = read_skip_spaces (infile);
941       if (c != ')')
942         fatal_expected_char (infile, ')', c);
943     }
944   md_constants = defs;
945   c = read_skip_spaces (infile);
946   if (c != ')')
947     fatal_expected_char (infile, ')', c);
948 }
949
950 /* For every constant definition, call CALLBACK with two arguments:
951    a pointer a pointer to the constant definition and INFO.
952    Stops when CALLBACK returns zero.  */
953 void
954 traverse_md_constants (htab_trav callback, void *info)
955 {
956   if (md_constants)
957     htab_traverse (md_constants, callback, info);
958 }
959
960 static void
961 validate_const_int (FILE *infile, const char *string)
962 {
963   const char *cp;
964   int valid = 1;
965
966   cp = string;
967   while (*cp && ISSPACE (*cp))
968     cp++;
969   if (*cp == '-' || *cp == '+')
970     cp++;
971   if (*cp == 0)
972     valid = 0;
973   for (; *cp; cp++)
974     if (! ISDIGIT (*cp))
975       valid = 0;
976   if (!valid)
977     fatal_with_file_and_line (infile, "invalid decimal constant \"%s\"\n", string);
978 }
979
980 /* Search GROUP for a mode or code called NAME and return its numerical
981    identifier.  INFILE is the file that contained NAME.  */
982
983 static int
984 find_macro (struct macro_group *group, const char *name, FILE *infile)
985 {
986   struct mapping *m;
987
988   m = (struct mapping *) htab_find (group->macros, &name);
989   if (m != 0)
990     return m->index + group->num_builtins;
991   return group->find_builtin (name, infile);
992 }
993
994 /* Finish reading a declaration of the form:
995
996        (define... <name> [<value1> ... <valuen>])
997
998    from INFILE, where each <valuei> is either a bare symbol name or a
999    "(<name> <string>)" pair.  The "(define..." part has already been read.
1000
1001    Represent the declaration as a "mapping" structure; add it to TABLE
1002    (which belongs to GROUP) and return it.  */
1003
1004 static struct mapping *
1005 read_mapping (struct macro_group *group, htab_t table, FILE *infile)
1006 {
1007   char tmp_char[256];
1008   struct mapping *m;
1009   struct map_value **end_ptr;
1010   const char *string;
1011   int number, c;
1012
1013   /* Read the mapping name and create a structure for it.  */
1014   read_name (tmp_char, infile);
1015   m = add_mapping (group, table, tmp_char, infile);
1016
1017   c = read_skip_spaces (infile);
1018   if (c != '[')
1019     fatal_expected_char (infile, '[', c);
1020
1021   /* Read each value.  */
1022   end_ptr = &m->values;
1023   c = read_skip_spaces (infile);
1024   do
1025     {
1026       if (c != '(')
1027         {
1028           /* A bare symbol name that is implicitly paired to an
1029              empty string.  */
1030           ungetc (c, infile);
1031           read_name (tmp_char, infile);
1032           string = "";
1033         }
1034       else
1035         {
1036           /* A "(name string)" pair.  */
1037           read_name (tmp_char, infile);
1038           string = read_string (infile, false);
1039           c = read_skip_spaces (infile);
1040           if (c != ')')
1041             fatal_expected_char (infile, ')', c);
1042         }
1043       number = group->find_builtin (tmp_char, infile);
1044       end_ptr = add_map_value (end_ptr, number, string);
1045       c = read_skip_spaces (infile);
1046     }
1047   while (c != ']');
1048
1049   c = read_skip_spaces (infile);
1050   if (c != ')')
1051     fatal_expected_char (infile, ')', c);
1052
1053   return m;
1054 }
1055
1056 /* Check newly-created code macro MACRO to see whether every code has the
1057    same format.  Initialize the macro's entry in bellwether_codes.  */
1058
1059 static void
1060 check_code_macro (struct mapping *macro, FILE *infile)
1061 {
1062   struct map_value *v;
1063   enum rtx_code bellwether;
1064
1065   bellwether = macro->values->number;
1066   for (v = macro->values->next; v != 0; v = v->next)
1067     if (strcmp (GET_RTX_FORMAT (bellwether), GET_RTX_FORMAT (v->number)) != 0)
1068       fatal_with_file_and_line (infile, "code macro `%s' combines "
1069                                 "different rtx formats", macro->name);
1070
1071   bellwether_codes = XRESIZEVEC (enum rtx_code, bellwether_codes,
1072                                  macro->index + 1);
1073   bellwether_codes[macro->index] = bellwether;
1074 }
1075
1076 /* Read an rtx in printed representation from INFILE and store its
1077    core representation in *X.  Also store the line number of the
1078    opening '(' in *LINENO.  Return true on success or false if the
1079    end of file has been reached.
1080
1081    read_rtx is not used in the compiler proper, but rather in
1082    the utilities gen*.c that construct C code from machine descriptions.  */
1083
1084 bool
1085 read_rtx (FILE *infile, rtx *x, int *lineno)
1086 {
1087   static rtx queue_head, queue_next;
1088   static int queue_lineno;
1089   int c;
1090
1091   /* Do one-time initialization.  */
1092   if (queue_head == 0)
1093     {
1094       initialize_macros ();
1095       obstack_init (&string_obstack);
1096       queue_head = rtx_alloc (EXPR_LIST);
1097     }
1098
1099   if (queue_next == 0)
1100     {
1101       c = read_skip_spaces (infile);
1102       if (c == EOF)
1103         return false;
1104       ungetc (c, infile);
1105
1106       queue_next = queue_head;
1107       queue_lineno = read_rtx_lineno;
1108       XEXP (queue_next, 0) = read_rtx_1 (infile);
1109       XEXP (queue_next, 1) = 0;
1110
1111       htab_traverse (modes.macros, apply_macro_traverse, queue_next);
1112       htab_traverse (codes.macros, apply_macro_traverse, queue_next);
1113     }
1114
1115   *x = XEXP (queue_next, 0);
1116   *lineno = queue_lineno;
1117   queue_next = XEXP (queue_next, 1);
1118
1119   return true;
1120 }
1121
1122 /* Subroutine of read_rtx that reads one construct from INFILE but
1123    doesn't apply any macros.  */
1124
1125 static rtx
1126 read_rtx_1 (FILE *infile)
1127 {
1128   int i;
1129   RTX_CODE real_code, bellwether_code;
1130   const char *format_ptr;
1131   /* tmp_char is a buffer used for reading decimal integers
1132      and names of rtx types and machine modes.
1133      Therefore, 256 must be enough.  */
1134   char tmp_char[256];
1135   rtx return_rtx;
1136   int c;
1137   int tmp_int;
1138   HOST_WIDE_INT tmp_wide;
1139
1140   /* Linked list structure for making RTXs: */
1141   struct rtx_list
1142     {
1143       struct rtx_list *next;
1144       rtx value;                /* Value of this node.  */
1145     };
1146
1147  again:
1148   c = read_skip_spaces (infile); /* Should be open paren.  */
1149   if (c != '(')
1150     fatal_expected_char (infile, '(', c);
1151
1152   read_name (tmp_char, infile);
1153   if (strcmp (tmp_char, "nil") == 0)
1154     {
1155       /* (nil) stands for an expression that isn't there.  */
1156       c = read_skip_spaces (infile);
1157       if (c != ')')
1158         fatal_expected_char (infile, ')', c);
1159       return 0;
1160     }
1161   if (strcmp (tmp_char, "define_constants") == 0)
1162     {
1163       read_constants (infile, tmp_char);
1164       goto again;
1165     }
1166   if (strcmp (tmp_char, "define_mode_attr") == 0)
1167     {
1168       read_mapping (&modes, modes.attrs, infile);
1169       goto again;
1170     }
1171   if (strcmp (tmp_char, "define_mode_macro") == 0)
1172     {
1173       read_mapping (&modes, modes.macros, infile);
1174       goto again;
1175     }
1176   if (strcmp (tmp_char, "define_code_attr") == 0)
1177     {
1178       read_mapping (&codes, codes.attrs, infile);
1179       goto again;
1180     }
1181   if (strcmp (tmp_char, "define_code_macro") == 0)
1182     {
1183       check_code_macro (read_mapping (&codes, codes.macros, infile), infile);
1184       goto again;
1185     }
1186   real_code = find_macro (&codes, tmp_char, infile);
1187   bellwether_code = BELLWETHER_CODE (real_code);
1188
1189   /* If we end up with an insn expression then we free this space below.  */
1190   return_rtx = rtx_alloc (bellwether_code);
1191   format_ptr = GET_RTX_FORMAT (bellwether_code);
1192   PUT_CODE (return_rtx, real_code);
1193
1194   /* If what follows is `: mode ', read it and
1195      store the mode in the rtx.  */
1196
1197   i = read_skip_spaces (infile);
1198   if (i == ':')
1199     {
1200       read_name (tmp_char, infile);
1201       PUT_MODE (return_rtx, find_macro (&modes, tmp_char, infile));
1202     }
1203   else
1204     ungetc (i, infile);
1205
1206   for (i = 0; format_ptr[i] != 0; i++)
1207     switch (format_ptr[i])
1208       {
1209         /* 0 means a field for internal use only.
1210            Don't expect it to be present in the input.  */
1211       case '0':
1212         break;
1213
1214       case 'e':
1215       case 'u':
1216         XEXP (return_rtx, i) = read_rtx_1 (infile);
1217         break;
1218
1219       case 'V':
1220         /* 'V' is an optional vector: if a closeparen follows,
1221            just store NULL for this element.  */
1222         c = read_skip_spaces (infile);
1223         ungetc (c, infile);
1224         if (c == ')')
1225           {
1226             XVEC (return_rtx, i) = 0;
1227             break;
1228           }
1229         /* Now process the vector.  */
1230
1231       case 'E':
1232         {
1233           /* Obstack to store scratch vector in.  */
1234           struct obstack vector_stack;
1235           int list_counter = 0;
1236           rtvec return_vec = NULL_RTVEC;
1237
1238           c = read_skip_spaces (infile);
1239           if (c != '[')
1240             fatal_expected_char (infile, '[', c);
1241
1242           /* Add expressions to a list, while keeping a count.  */
1243           obstack_init (&vector_stack);
1244           while ((c = read_skip_spaces (infile)) && c != ']')
1245             {
1246               ungetc (c, infile);
1247               list_counter++;
1248               obstack_ptr_grow (&vector_stack, read_rtx_1 (infile));
1249             }
1250           if (list_counter > 0)
1251             {
1252               return_vec = rtvec_alloc (list_counter);
1253               memcpy (&return_vec->elem[0], obstack_finish (&vector_stack),
1254                       list_counter * sizeof (rtx));
1255             }
1256           else if (format_ptr[i] == 'E')
1257             fatal_with_file_and_line (infile,
1258                                       "vector must have at least one element");
1259           XVEC (return_rtx, i) = return_vec;
1260           obstack_free (&vector_stack, NULL);
1261           /* close bracket gotten */
1262         }
1263         break;
1264
1265       case 'S':
1266       case 'T':
1267       case 's':
1268         {
1269           char *stringbuf;
1270           int star_if_braced;
1271
1272           c = read_skip_spaces (infile);
1273           ungetc (c, infile);
1274           if (c == ')')
1275             {
1276               /* 'S' fields are optional and should be NULL if no string
1277                  was given.  Also allow normal 's' and 'T' strings to be
1278                  omitted, treating them in the same way as empty strings.  */
1279               XSTR (return_rtx, i) = (format_ptr[i] == 'S' ? NULL : "");
1280               break;
1281             }
1282
1283           /* The output template slot of a DEFINE_INSN,
1284              DEFINE_INSN_AND_SPLIT, or DEFINE_PEEPHOLE automatically
1285              gets a star inserted as its first character, if it is
1286              written with a brace block instead of a string constant.  */
1287           star_if_braced = (format_ptr[i] == 'T');
1288
1289           stringbuf = read_string (infile, star_if_braced);
1290
1291           /* For insn patterns, we want to provide a default name
1292              based on the file and line, like "*foo.md:12", if the
1293              given name is blank.  These are only for define_insn and
1294              define_insn_and_split, to aid debugging.  */
1295           if (*stringbuf == '\0'
1296               && i == 0
1297               && (GET_CODE (return_rtx) == DEFINE_INSN
1298                   || GET_CODE (return_rtx) == DEFINE_INSN_AND_SPLIT))
1299             {
1300               char line_name[20];
1301               const char *fn = (read_rtx_filename ? read_rtx_filename : "rtx");
1302               const char *slash;
1303               for (slash = fn; *slash; slash ++)
1304                 if (*slash == '/' || *slash == '\\' || *slash == ':')
1305                   fn = slash + 1;
1306               obstack_1grow (&string_obstack, '*');
1307               obstack_grow (&string_obstack, fn, strlen (fn));
1308               sprintf (line_name, ":%d", read_rtx_lineno);
1309               obstack_grow (&string_obstack, line_name, strlen (line_name)+1);
1310               stringbuf = (char *) obstack_finish (&string_obstack);
1311             }
1312
1313           if (star_if_braced)
1314             XTMPL (return_rtx, i) = stringbuf;
1315           else
1316             XSTR (return_rtx, i) = stringbuf;
1317         }
1318         break;
1319
1320       case 'w':
1321         read_name (tmp_char, infile);
1322         validate_const_int (infile, tmp_char);
1323 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
1324         tmp_wide = atoi (tmp_char);
1325 #else
1326 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
1327         tmp_wide = atol (tmp_char);
1328 #else
1329         /* Prefer atoll over atoq, since the former is in the ISO C99 standard.
1330            But prefer not to use our hand-rolled function above either.  */
1331 #if defined(HAVE_ATOLL) || !defined(HAVE_ATOQ)
1332         tmp_wide = atoll (tmp_char);
1333 #else
1334         tmp_wide = atoq (tmp_char);
1335 #endif
1336 #endif
1337 #endif
1338         XWINT (return_rtx, i) = tmp_wide;
1339         break;
1340
1341       case 'i':
1342       case 'n':
1343         read_name (tmp_char, infile);
1344         validate_const_int (infile, tmp_char);
1345         tmp_int = atoi (tmp_char);
1346         XINT (return_rtx, i) = tmp_int;
1347         break;
1348
1349       default:
1350         fprintf (stderr,
1351                  "switch format wrong in rtl.read_rtx(). format was: %c.\n",
1352                  format_ptr[i]);
1353         fprintf (stderr, "\tfile position: %ld\n", ftell (infile));
1354         abort ();
1355       }
1356
1357   c = read_skip_spaces (infile);
1358   if (c != ')')
1359     fatal_expected_char (infile, ')', c);
1360
1361   return return_rtx;
1362 }