* config/i386/uwin.h: Remove SUBTARGET_PROLOGUE.
[official-gcc.git] / gcc / read-rtl.c
blob5b4a6c44b18d6dfc745e3dfa1def98caa0a09d6a
1 /* RTL reader for GNU C Compiler.
2 Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA. */
22 #include "bconfig.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "rtl.h"
27 #include "obstack.h"
28 #include "hashtab.h"
30 static htab_t md_constants;
32 static void fatal_with_file_and_line PARAMS ((FILE *, const char *, ...))
33 ATTRIBUTE_PRINTF_2 ATTRIBUTE_NORETURN;
34 static void fatal_expected_char PARAMS ((FILE *, int, int)) ATTRIBUTE_NORETURN;
35 static void read_name PARAMS ((char *, FILE *));
36 static char *read_string PARAMS ((struct obstack *, FILE *, int));
37 static char *read_quoted_string PARAMS ((struct obstack *, FILE *));
38 static char *read_braced_string PARAMS ((struct obstack *, FILE *));
39 static void read_escape PARAMS ((struct obstack *, FILE *));
40 static hashval_t def_hash PARAMS ((const void *));
41 static int def_name_eq_p PARAMS ((const void *, const void *));
42 static void read_constants PARAMS ((FILE *infile, char *tmp_char));
43 static void validate_const_int PARAMS ((FILE *, const char *));
45 /* Subroutines of read_rtx. */
47 /* The current line number for the file. */
48 int read_rtx_lineno = 1;
50 /* The filename for aborting with file and line. */
51 const char *read_rtx_filename = "<unknown>";
53 static void
54 fatal_with_file_and_line (FILE *infile, const char *msg, ...)
56 char context[64];
57 size_t i;
58 int c;
59 va_list ap;
61 va_start (ap, msg);
63 fprintf (stderr, "%s:%d: ", read_rtx_filename, read_rtx_lineno);
64 vfprintf (stderr, msg, ap);
65 putc ('\n', stderr);
67 /* Gather some following context. */
68 for (i = 0; i < sizeof (context)-1; ++i)
70 c = getc (infile);
71 if (c == EOF)
72 break;
73 if (c == '\r' || c == '\n')
74 break;
75 context[i] = c;
77 context[i] = '\0';
79 fprintf (stderr, "%s:%d: following context is `%s'\n",
80 read_rtx_filename, read_rtx_lineno, context);
82 va_end (ap);
83 exit (1);
86 /* Dump code after printing a message. Used when read_rtx finds
87 invalid data. */
89 static void
90 fatal_expected_char (infile, expected_c, actual_c)
91 FILE *infile;
92 int expected_c, actual_c;
94 fatal_with_file_and_line (infile, "expected character `%c', found `%c'",
95 expected_c, actual_c);
98 /* Read chars from INFILE until a non-whitespace char
99 and return that. Comments, both Lisp style and C style,
100 are treated as whitespace.
101 Tools such as genflags use this function. */
104 read_skip_spaces (infile)
105 FILE *infile;
107 int c;
109 while (1)
111 c = getc (infile);
112 switch (c)
114 case '\n':
115 read_rtx_lineno++;
116 break;
118 case ' ': case '\t': case '\f': case '\r':
119 break;
121 case ';':
123 c = getc (infile);
124 while (c != '\n' && c != EOF);
125 read_rtx_lineno++;
126 break;
128 case '/':
130 int prevc;
131 c = getc (infile);
132 if (c != '*')
133 fatal_expected_char (infile, '*', c);
135 prevc = 0;
136 while ((c = getc (infile)) && c != EOF)
138 if (c == '\n')
139 read_rtx_lineno++;
140 else if (prevc == '*' && c == '/')
141 break;
142 prevc = c;
145 break;
147 default:
148 return c;
153 /* Read an rtx code name into the buffer STR[].
154 It is terminated by any of the punctuation chars of rtx printed syntax. */
156 static void
157 read_name (str, infile)
158 char *str;
159 FILE *infile;
161 char *p;
162 int c;
164 c = read_skip_spaces (infile);
166 p = str;
167 while (1)
169 if (c == ' ' || c == '\n' || c == '\t' || c == '\f' || c == '\r')
170 break;
171 if (c == ':' || c == ')' || c == ']' || c == '"' || c == '/'
172 || c == '(' || c == '[')
174 ungetc (c, infile);
175 break;
177 *p++ = c;
178 c = getc (infile);
180 if (p == str)
181 fatal_with_file_and_line (infile, "missing name or number");
182 if (c == '\n')
183 read_rtx_lineno++;
185 *p = 0;
187 if (md_constants)
189 /* Do constant expansion. */
190 struct md_constant *def;
192 p = str;
195 struct md_constant tmp_def;
197 tmp_def.name = p;
198 def = htab_find (md_constants, &tmp_def);
199 if (def)
200 p = def->value;
201 } while (def);
202 if (p != str)
203 strcpy (str, p);
207 /* Subroutine of the string readers. Handles backslash escapes.
208 Caller has read the backslash, but not placed it into the obstack. */
209 static void
210 read_escape (ob, infile)
211 struct obstack *ob;
212 FILE *infile;
214 int c = getc (infile);
216 switch (c)
218 /* Backslash-newline is replaced by nothing, as in C. */
219 case '\n':
220 read_rtx_lineno++;
221 return;
223 /* \" \' \\ are replaced by the second character. */
224 case '\\':
225 case '"':
226 case '\'':
227 break;
229 /* Standard C string escapes:
230 \a \b \f \n \r \t \v
231 \[0-7] \x
232 all are passed through to the output string unmolested.
233 In normal use these wind up in a string constant processed
234 by the C compiler, which will translate them appropriately.
235 We do not bother checking that \[0-7] are followed by up to
236 two octal digits, or that \x is followed by N hex digits.
237 \? \u \U are left out because they are not in traditional C. */
238 case 'a': case 'b': case 'f': case 'n': case 'r': case 't': case 'v':
239 case '0': case '1': case '2': case '3': case '4': case '5': case '6':
240 case '7': case 'x':
241 obstack_1grow (ob, '\\');
242 break;
244 /* \; makes stuff for a C string constant containing
245 newline and tab. */
246 case ';':
247 obstack_grow (ob, "\\n\\t", 4);
248 return;
250 /* pass anything else through, but issue a warning. */
251 default:
252 fprintf (stderr, "%s:%d: warning: unrecognized escape \\%c\n",
253 read_rtx_filename, read_rtx_lineno, c);
254 obstack_1grow (ob, '\\');
255 break;
258 obstack_1grow (ob, c);
262 /* Read a double-quoted string onto the obstack. Caller has scanned
263 the leading quote. */
264 static char *
265 read_quoted_string (ob, infile)
266 struct obstack *ob;
267 FILE *infile;
269 int c;
271 while (1)
273 c = getc (infile); /* Read the string */
274 if (c == '\n')
275 read_rtx_lineno++;
276 else if (c == '\\')
278 read_escape (ob, infile);
279 continue;
281 else if (c == '"')
282 break;
284 obstack_1grow (ob, c);
287 obstack_1grow (ob, 0);
288 return obstack_finish (ob);
291 /* Read a braced string (a la Tcl) onto the obstack. Caller has
292 scanned the leading brace. Note that unlike quoted strings,
293 the outermost braces _are_ included in the string constant. */
294 static char *
295 read_braced_string (ob, infile)
296 struct obstack *ob;
297 FILE *infile;
299 int c;
300 int brace_depth = 1; /* caller-processed */
302 obstack_1grow (ob, '{');
303 while (brace_depth)
305 c = getc (infile); /* Read the string */
306 if (c == '\n')
307 read_rtx_lineno++;
308 else if (c == '{')
309 brace_depth++;
310 else if (c == '}')
311 brace_depth--;
312 else if (c == '\\')
314 read_escape (ob, infile);
315 continue;
318 obstack_1grow (ob, c);
321 obstack_1grow (ob, 0);
322 return obstack_finish (ob);
325 /* Read some kind of string constant. This is the high-level routine
326 used by read_rtx. It handles surrounding parentheses, leading star,
327 and dispatch to the appropriate string constant reader. */
329 static char *
330 read_string (ob, infile, star_if_braced)
331 struct obstack *ob;
332 FILE *infile;
333 int star_if_braced;
335 char *stringbuf;
336 int saw_paren = 0;
337 int c;
339 c = read_skip_spaces (infile);
340 if (c == '(')
342 saw_paren = 1;
343 c = read_skip_spaces (infile);
346 if (c == '"')
347 stringbuf = read_quoted_string (ob, infile);
348 else if (c == '{')
350 if (star_if_braced)
351 obstack_1grow (ob, '*');
352 stringbuf = read_braced_string (ob, infile);
354 else
355 fatal_with_file_and_line (infile, "expected `\"' or `{', found `%c'", c);
357 if (saw_paren)
359 c = read_skip_spaces (infile);
360 if (c != ')')
361 fatal_expected_char (infile, ')', c);
364 return stringbuf;
367 /* Provide a version of a function to read a long long if the system does
368 not provide one. */
369 #if HOST_BITS_PER_WIDE_INT > HOST_BITS_PER_LONG && !defined(HAVE_ATOLL) && !defined(HAVE_ATOQ)
370 HOST_WIDE_INT atoll PARAMS ((const char *));
372 HOST_WIDE_INT
373 atoll (p)
374 const char *p;
376 int neg = 0;
377 HOST_WIDE_INT tmp_wide;
379 while (ISSPACE (*p))
380 p++;
381 if (*p == '-')
382 neg = 1, p++;
383 else if (*p == '+')
384 p++;
386 tmp_wide = 0;
387 while (ISDIGIT (*p))
389 HOST_WIDE_INT new_wide = tmp_wide*10 + (*p - '0');
390 if (new_wide < tmp_wide)
392 /* Return INT_MAX equiv on overflow. */
393 tmp_wide = (~(unsigned HOST_WIDE_INT) 0) >> 1;
394 break;
396 tmp_wide = new_wide;
397 p++;
400 if (neg)
401 tmp_wide = -tmp_wide;
402 return tmp_wide;
404 #endif
406 /* Given a constant definition, return a hash code for its name. */
407 static hashval_t
408 def_hash (def)
409 const void *def;
411 unsigned result, i;
412 const char *string = ((const struct md_constant *) def)->name;
414 for (result = i = 0;*string++ != '\0'; i++)
415 result += ((unsigned char) *string << (i % CHAR_BIT));
416 return result;
419 /* Given two constant definitions, return true if they have the same name. */
420 static int
421 def_name_eq_p (def1, def2)
422 const void *def1, *def2;
424 return ! strcmp (((const struct md_constant *) def1)->name,
425 ((const struct md_constant *) def2)->name);
428 /* INFILE is a FILE pointer to read text from. TMP_CHAR is a buffer suitable
429 to read a name or number into. Process a define_constants directive,
430 starting with the optional space after the "define_constants". */
431 static void
432 read_constants (infile, tmp_char)
433 FILE *infile;
434 char *tmp_char;
436 int c;
437 htab_t defs;
439 c = read_skip_spaces (infile);
440 if (c != '[')
441 fatal_expected_char (infile, '[', c);
442 defs = md_constants;
443 if (! defs)
444 defs = htab_create (32, def_hash, def_name_eq_p, (htab_del) 0);
445 /* Disable constant expansion during definition processing. */
446 md_constants = 0;
447 while ( (c = read_skip_spaces (infile)) != ']')
449 struct md_constant *def;
450 void **entry_ptr;
452 if (c != '(')
453 fatal_expected_char (infile, '(', c);
454 def = xmalloc (sizeof (struct md_constant));
455 def->name = tmp_char;
456 read_name (tmp_char, infile);
457 entry_ptr = htab_find_slot (defs, def, TRUE);
458 if (! *entry_ptr)
459 def->name = xstrdup (tmp_char);
460 c = read_skip_spaces (infile);
461 ungetc (c, infile);
462 read_name (tmp_char, infile);
463 if (! *entry_ptr)
465 def->value = xstrdup (tmp_char);
466 *entry_ptr = def;
468 else
470 def = *entry_ptr;
471 if (strcmp (def->value, tmp_char))
472 fatal_with_file_and_line (infile,
473 "redefinition of %s, was %s, now %s",
474 def->name, def->value, tmp_char);
476 c = read_skip_spaces (infile);
477 if (c != ')')
478 fatal_expected_char (infile, ')', c);
480 md_constants = defs;
481 c = read_skip_spaces (infile);
482 if (c != ')')
483 fatal_expected_char (infile, ')', c);
486 /* For every constant definition, call CALLBACK with two arguments:
487 a pointer a pointer to the constant definition and INFO.
488 Stops when CALLBACK returns zero. */
489 void
490 traverse_md_constants (callback, info)
491 htab_trav callback;
492 void *info;
494 if (md_constants)
495 htab_traverse (md_constants, callback, info);
498 static void
499 validate_const_int (infile, string)
500 FILE *infile;
501 const char *string;
503 const char *cp;
504 int valid = 1;
506 cp = string;
507 while (*cp && ISSPACE (*cp))
508 cp++;
509 if (*cp == '-' || *cp == '+')
510 cp++;
511 if (*cp == 0)
512 valid = 0;
513 for (; *cp; cp++)
514 if (! ISDIGIT (*cp))
515 valid = 0;
516 if (!valid)
517 fatal_with_file_and_line (infile, "invalid decimal constant \"%s\"\n", string);
520 /* Read an rtx in printed representation from INFILE
521 and return an actual rtx in core constructed accordingly.
522 read_rtx is not used in the compiler proper, but rather in
523 the utilities gen*.c that construct C code from machine descriptions. */
526 read_rtx (infile)
527 FILE *infile;
529 int i, j;
530 RTX_CODE tmp_code;
531 const char *format_ptr;
532 /* tmp_char is a buffer used for reading decimal integers
533 and names of rtx types and machine modes.
534 Therefore, 256 must be enough. */
535 char tmp_char[256];
536 rtx return_rtx;
537 int c;
538 int tmp_int;
539 HOST_WIDE_INT tmp_wide;
541 /* Obstack used for allocating RTL objects. */
542 static struct obstack rtl_obstack;
543 static int initialized;
545 /* Linked list structure for making RTXs: */
546 struct rtx_list
548 struct rtx_list *next;
549 rtx value; /* Value of this node. */
552 if (!initialized) {
553 obstack_init (&rtl_obstack);
554 initialized = 1;
557 again:
558 c = read_skip_spaces (infile); /* Should be open paren. */
559 if (c != '(')
560 fatal_expected_char (infile, '(', c);
562 read_name (tmp_char, infile);
564 tmp_code = UNKNOWN;
566 if (! strcmp (tmp_char, "define_constants"))
568 read_constants (infile, tmp_char);
569 goto again;
571 for (i = 0; i < NUM_RTX_CODE; i++)
572 if (! strcmp (tmp_char, GET_RTX_NAME (i)))
574 tmp_code = (RTX_CODE) i; /* get value for name */
575 break;
578 if (tmp_code == UNKNOWN)
579 fatal_with_file_and_line (infile, "unknown rtx code `%s'", tmp_char);
581 /* (NIL) stands for an expression that isn't there. */
582 if (tmp_code == NIL)
584 /* Discard the closeparen. */
585 while ((c = getc (infile)) && c != ')')
588 return 0;
591 /* If we end up with an insn expression then we free this space below. */
592 return_rtx = rtx_alloc (tmp_code);
593 format_ptr = GET_RTX_FORMAT (GET_CODE (return_rtx));
595 /* If what follows is `: mode ', read it and
596 store the mode in the rtx. */
598 i = read_skip_spaces (infile);
599 if (i == ':')
601 read_name (tmp_char, infile);
602 for (j = 0; j < NUM_MACHINE_MODES; j++)
603 if (! strcmp (GET_MODE_NAME (j), tmp_char))
604 break;
606 if (j == MAX_MACHINE_MODE)
607 fatal_with_file_and_line (infile, "unknown mode `%s'", tmp_char);
609 PUT_MODE (return_rtx, (enum machine_mode) j);
611 else
612 ungetc (i, infile);
614 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (return_rtx)); i++)
615 switch (*format_ptr++)
617 /* 0 means a field for internal use only.
618 Don't expect it to be present in the input. */
619 case '0':
620 break;
622 case 'e':
623 case 'u':
624 XEXP (return_rtx, i) = read_rtx (infile);
625 break;
627 case 'V':
628 /* 'V' is an optional vector: if a closeparen follows,
629 just store NULL for this element. */
630 c = read_skip_spaces (infile);
631 ungetc (c, infile);
632 if (c == ')')
634 XVEC (return_rtx, i) = 0;
635 break;
637 /* Now process the vector. */
639 case 'E':
641 /* Obstack to store scratch vector in. */
642 struct obstack vector_stack;
643 int list_counter = 0;
644 rtvec return_vec = NULL_RTVEC;
646 c = read_skip_spaces (infile);
647 if (c != '[')
648 fatal_expected_char (infile, '[', c);
650 /* add expressions to a list, while keeping a count */
651 obstack_init (&vector_stack);
652 while ((c = read_skip_spaces (infile)) && c != ']')
654 ungetc (c, infile);
655 list_counter++;
656 obstack_ptr_grow (&vector_stack, (PTR) read_rtx (infile));
658 if (list_counter > 0)
660 return_vec = rtvec_alloc (list_counter);
661 memcpy (&return_vec->elem[0], obstack_finish (&vector_stack),
662 list_counter * sizeof (rtx));
664 XVEC (return_rtx, i) = return_vec;
665 obstack_free (&vector_stack, NULL);
666 /* close bracket gotten */
668 break;
670 case 'S':
671 /* 'S' is an optional string: if a closeparen follows,
672 just store NULL for this element. */
673 c = read_skip_spaces (infile);
674 ungetc (c, infile);
675 if (c == ')')
677 XSTR (return_rtx, i) = 0;
678 break;
681 case 'T':
682 case 's':
684 char *stringbuf;
686 /* The output template slot of a DEFINE_INSN,
687 DEFINE_INSN_AND_SPLIT, or DEFINE_PEEPHOLE automatically
688 gets a star inserted as its first character, if it is
689 written with a brace block instead of a string constant. */
690 int star_if_braced = (format_ptr[-1] == 'T');
692 stringbuf = read_string (&rtl_obstack, infile, star_if_braced);
694 /* For insn patterns, we want to provide a default name
695 based on the file and line, like "*foo.md:12", if the
696 given name is blank. These are only for define_insn and
697 define_insn_and_split, to aid debugging. */
698 if (*stringbuf == '\0'
699 && i == 0
700 && (GET_CODE (return_rtx) == DEFINE_INSN
701 || GET_CODE (return_rtx) == DEFINE_INSN_AND_SPLIT))
703 char line_name[20];
704 const char *fn = (read_rtx_filename ? read_rtx_filename : "rtx");
705 const char *slash;
706 for (slash = fn; *slash; slash ++)
707 if (*slash == '/' || *slash == '\\' || *slash == ':')
708 fn = slash + 1;
709 obstack_1grow (&rtl_obstack, '*');
710 obstack_grow (&rtl_obstack, fn, strlen (fn));
711 sprintf (line_name, ":%d", read_rtx_lineno);
712 obstack_grow (&rtl_obstack, line_name, strlen (line_name)+1);
713 stringbuf = (char *) obstack_finish (&rtl_obstack);
716 if (star_if_braced)
717 XTMPL (return_rtx, i) = stringbuf;
718 else
719 XSTR (return_rtx, i) = stringbuf;
721 break;
723 case 'w':
724 read_name (tmp_char, infile);
725 validate_const_int (infile, tmp_char);
726 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
727 tmp_wide = atoi (tmp_char);
728 #else
729 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
730 tmp_wide = atol (tmp_char);
731 #else
732 /* Prefer atoll over atoq, since the former is in the ISO C99 standard.
733 But prefer not to use our hand-rolled function above either. */
734 #if defined(HAVE_ATOLL) || !defined(HAVE_ATOQ)
735 tmp_wide = atoll (tmp_char);
736 #else
737 tmp_wide = atoq (tmp_char);
738 #endif
739 #endif
740 #endif
741 XWINT (return_rtx, i) = tmp_wide;
742 break;
744 case 'i':
745 case 'n':
746 read_name (tmp_char, infile);
747 validate_const_int (infile, tmp_char);
748 tmp_int = atoi (tmp_char);
749 XINT (return_rtx, i) = tmp_int;
750 break;
752 default:
753 fprintf (stderr,
754 "switch format wrong in rtl.read_rtx(). format was: %c.\n",
755 format_ptr[-1]);
756 fprintf (stderr, "\tfile position: %ld\n", ftell (infile));
757 abort ();
760 c = read_skip_spaces (infile);
761 if (c != ')')
762 fatal_expected_char (infile, ')', c);
764 return return_rtx;