diff options
author | obrien <obrien@FreeBSD.org> | 2002-02-01 18:16:02 +0000 |
---|---|---|
committer | obrien <obrien@FreeBSD.org> | 2002-02-01 18:16:02 +0000 |
commit | c9ab9ae440a8066b2c2b85b157b1fdadcf09916a (patch) | |
tree | 086d9d6c8fbd4fc8fe4495059332f66bc0f8d12b /contrib/gcc/read-rtl.c | |
parent | 2ecfd8bd04b63f335c1ec6295740a4bfd97a4fa6 (diff) | |
download | FreeBSD-src-c9ab9ae440a8066b2c2b85b157b1fdadcf09916a.zip FreeBSD-src-c9ab9ae440a8066b2c2b85b157b1fdadcf09916a.tar.gz |
Enlist the FreeBSD-CURRENT users as testers of what is to become Gcc 3.1.0.
These bits are taken from the FSF anoncvs repo on 1-Feb-2002 08:20 PST.
Diffstat (limited to 'contrib/gcc/read-rtl.c')
-rw-r--r-- | contrib/gcc/read-rtl.c | 771 |
1 files changed, 771 insertions, 0 deletions
diff --git a/contrib/gcc/read-rtl.c b/contrib/gcc/read-rtl.c new file mode 100644 index 0000000..5b937ec --- /dev/null +++ b/contrib/gcc/read-rtl.c @@ -0,0 +1,771 @@ +/* RTL reader for GNU C Compiler. + Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000, 2001, 2002 + Free Software Foundation, Inc. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 2, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING. If not, write to the Free +Software Foundation, 59 Temple Place - Suite 330, Boston, MA +02111-1307, USA. */ + +#include "hconfig.h" +#include "system.h" +#include "rtl.h" +#include "obstack.h" +#include "hashtab.h" + +#ifndef ISDIGIT +#include <ctype.h> +#define ISDIGIT isdigit +#define ISSPACE isspace +#endif + +#define obstack_chunk_alloc xmalloc +#define obstack_chunk_free free + +static htab_t md_constants; + +static void fatal_with_file_and_line PARAMS ((FILE *, const char *, ...)) + ATTRIBUTE_PRINTF_2 ATTRIBUTE_NORETURN; +static void fatal_expected_char PARAMS ((FILE *, int, int)) ATTRIBUTE_NORETURN; +static void read_name PARAMS ((char *, FILE *)); +static char *read_string PARAMS ((struct obstack *, FILE *, int)); +static char *read_quoted_string PARAMS ((struct obstack *, FILE *)); +static char *read_braced_string PARAMS ((struct obstack *, FILE *)); +static void read_escape PARAMS ((struct obstack *, FILE *)); +static unsigned def_hash PARAMS ((const void *)); +static int def_name_eq_p PARAMS ((const void *, const void *)); +static void read_constants PARAMS ((FILE *infile, char *tmp_char)); +static void validate_const_int PARAMS ((FILE *, const char *)); + +/* Subroutines of read_rtx. */ + +/* The current line number for the file. */ +int read_rtx_lineno = 1; + +/* The filename for aborting with file and line. */ +const char *read_rtx_filename = "<unknown>"; + +static void +fatal_with_file_and_line VPARAMS ((FILE *infile, const char *msg, ...)) +{ + char context[64]; + size_t i; + int c; + + VA_OPEN (ap, msg); + VA_FIXEDARG (ap, FILE *, infile); + VA_FIXEDARG (ap, const char *, msg); + + fprintf (stderr, "%s:%d: ", read_rtx_filename, read_rtx_lineno); + vfprintf (stderr, msg, ap); + putc ('\n', stderr); + + /* Gather some following context. */ + for (i = 0; i < sizeof (context)-1; ++i) + { + c = getc (infile); + if (c == EOF) + break; + if (c == '\r' || c == '\n') + break; + context[i] = c; + } + context[i] = '\0'; + + fprintf (stderr, "%s:%d: following context is `%s'\n", + read_rtx_filename, read_rtx_lineno, context); + + VA_CLOSE (ap); + exit (1); +} + +/* Dump code after printing a message. Used when read_rtx finds + invalid data. */ + +static void +fatal_expected_char (infile, expected_c, actual_c) + FILE *infile; + int expected_c, actual_c; +{ + fatal_with_file_and_line (infile, "expected character `%c', found `%c'", + expected_c, actual_c); +} + +/* Read chars from INFILE until a non-whitespace char + and return that. Comments, both Lisp style and C style, + are treated as whitespace. + Tools such as genflags use this function. */ + +int +read_skip_spaces (infile) + FILE *infile; +{ + int c; + + while (1) + { + c = getc (infile); + switch (c) + { + case '\n': + read_rtx_lineno++; + break; + + case ' ': case '\t': case '\f': case '\r': + break; + + case ';': + do + c = getc (infile); + while (c != '\n' && c != EOF); + read_rtx_lineno++; + break; + + case '/': + { + int prevc; + c = getc (infile); + if (c != '*') + fatal_expected_char (infile, '*', c); + + prevc = 0; + while ((c = getc (infile)) && c != EOF) + { + if (c == '\n') + read_rtx_lineno++; + else if (prevc == '*' && c == '/') + break; + prevc = c; + } + } + break; + + default: + return c; + } + } +} + +/* Read an rtx code name into the buffer STR[]. + It is terminated by any of the punctuation chars of rtx printed syntax. */ + +static void +read_name (str, infile) + char *str; + FILE *infile; +{ + char *p; + int c; + + c = read_skip_spaces (infile); + + p = str; + while (1) + { + if (c == ' ' || c == '\n' || c == '\t' || c == '\f' || c == '\r') + break; + if (c == ':' || c == ')' || c == ']' || c == '"' || c == '/' + || c == '(' || c == '[') + { + ungetc (c, infile); + break; + } + *p++ = c; + c = getc (infile); + } + if (p == str) + fatal_with_file_and_line (infile, "missing name or number"); + if (c == '\n') + read_rtx_lineno++; + + *p = 0; + + if (md_constants) + { + /* Do constant expansion. */ + struct md_constant *def; + + p = str; + do + { + struct md_constant tmp_def; + + tmp_def.name = p; + def = htab_find (md_constants, &tmp_def); + if (def) + p = def->value; + } while (def); + if (p != str) + strcpy (str, p); + } +} + +/* Subroutine of the string readers. Handles backslash escapes. + Caller has read the backslash, but not placed it into the obstack. */ +static void +read_escape (ob, infile) + struct obstack *ob; + FILE *infile; +{ + int c = getc (infile); + + switch (c) + { + /* Backslash-newline is replaced by nothing, as in C. */ + case '\n': + read_rtx_lineno++; + return; + + /* \" \' \\ are replaced by the second character. */ + case '\\': + case '"': + case '\'': + break; + + /* Standard C string escapes: + \a \b \f \n \r \t \v + \[0-7] \x + all are passed through to the output string unmolested. + In normal use these wind up in a string constant processed + by the C compiler, which will translate them appropriately. + We do not bother checking that \[0-7] are followed by up to + two octal digits, or that \x is followed by N hex digits. + \? \u \U are left out because they are not in traditional C. */ + case 'a': case 'b': case 'f': case 'n': case 'r': case 't': case 'v': + case '0': case '1': case '2': case '3': case '4': case '5': case '6': + case '7': case 'x': + obstack_1grow (ob, '\\'); + break; + + /* \; makes stuff for a C string constant containing + newline and tab. */ + case ';': + obstack_grow (ob, "\\n\\t", 4); + return; + + /* pass anything else through, but issue a warning. */ + default: + fprintf (stderr, "%s:%d: warning: unrecognized escape \\%c\n", + read_rtx_filename, read_rtx_lineno, c); + obstack_1grow (ob, '\\'); + break; + } + + obstack_1grow (ob, c); +} + + +/* Read a double-quoted string onto the obstack. Caller has scanned + the leading quote. */ +static char * +read_quoted_string (ob, infile) + struct obstack *ob; + FILE *infile; +{ + int c; + + while (1) + { + c = getc (infile); /* Read the string */ + if (c == '\n') + read_rtx_lineno++; + else if (c == '\\') + { + read_escape (ob, infile); + continue; + } + else if (c == '"') + break; + + obstack_1grow (ob, c); + } + + obstack_1grow (ob, 0); + return obstack_finish (ob); +} + +/* Read a braced string (a la Tcl) onto the obstack. Caller has + scanned the leading brace. Note that unlike quoted strings, + the outermost braces _are_ included in the string constant. */ +static char * +read_braced_string (ob, infile) + struct obstack *ob; + FILE *infile; +{ + int c; + int brace_depth = 1; /* caller-processed */ + + obstack_1grow (ob, '{'); + while (brace_depth) + { + c = getc (infile); /* Read the string */ + if (c == '\n') + read_rtx_lineno++; + else if (c == '{') + brace_depth++; + else if (c == '}') + brace_depth--; + else if (c == '\\') + { + read_escape (ob, infile); + continue; + } + + obstack_1grow (ob, c); + } + + obstack_1grow (ob, 0); + return obstack_finish (ob); +} + +/* Read some kind of string constant. This is the high-level routine + used by read_rtx. It handles surrounding parentheses, leading star, + and dispatch to the appropriate string constant reader. */ + +static char * +read_string (ob, infile, star_if_braced) + struct obstack *ob; + FILE *infile; + int star_if_braced; +{ + char *stringbuf; + int saw_paren = 0; + int c; + + c = read_skip_spaces (infile); + if (c == '(') + { + saw_paren = 1; + c = read_skip_spaces (infile); + } + + if (c == '"') + stringbuf = read_quoted_string (ob, infile); + else if (c == '{') + { + if (star_if_braced) + obstack_1grow (ob, '*'); + stringbuf = read_braced_string (ob, infile); + } + else + fatal_with_file_and_line (infile, "expected `\"' or `{', found `%c'", c); + + if (saw_paren) + { + c = read_skip_spaces (infile); + if (c != ')') + fatal_expected_char (infile, ')', c); + } + + return stringbuf; +} + +/* Provide a version of a function to read a long long if the system does + not provide one. */ +#if HOST_BITS_PER_WIDE_INT > HOST_BITS_PER_LONG && !defined(HAVE_ATOLL) && !defined(HAVE_ATOQ) +HOST_WIDE_INT +atoll (p) + const char *p; +{ + int neg = 0; + HOST_WIDE_INT tmp_wide; + + while (ISSPACE (*p)) + p++; + if (*p == '-') + neg = 1, p++; + else if (*p == '+') + p++; + + tmp_wide = 0; + while (ISDIGIT (*p)) + { + HOST_WIDE_INT new_wide = tmp_wide*10 + (*p - '0'); + if (new_wide < tmp_wide) + { + /* Return INT_MAX equiv on overflow. */ + tmp_wide = (~(unsigned HOST_WIDE_INT) 0) >> 1; + break; + } + tmp_wide = new_wide; + p++; + } + + if (neg) + tmp_wide = -tmp_wide; + return tmp_wide; +} +#endif + +/* Given a constant definition, return a hash code for its name. */ +static unsigned +def_hash (def) + const void *def; +{ + unsigned result, i; + const char *string = ((const struct md_constant *) def)->name; + + for (result = i = 0;*string++ != '\0'; i++) + result += ((unsigned char) *string << (i % CHAR_BIT)); + return result; +} + +/* Given two constant definitions, return true if they have the same name. */ +static int +def_name_eq_p (def1, def2) + const void *def1, *def2; +{ + return ! strcmp (((const struct md_constant *) def1)->name, + ((const struct md_constant *) def2)->name); +} + +/* INFILE is a FILE pointer to read text from. TMP_CHAR is a buffer suitable + to read a name or number into. Process a define_constants directive, + starting with the optional space after the "define_constants". */ +static void +read_constants (infile, tmp_char) + FILE *infile; + char *tmp_char; +{ + int c; + htab_t defs; + + c = read_skip_spaces (infile); + if (c != '[') + fatal_expected_char (infile, '[', c); + defs = md_constants; + if (! defs) + defs = htab_create (32, def_hash, def_name_eq_p, (htab_del) 0); + /* Disable constant expansion during definition processing. */ + md_constants = 0; + while ( (c = read_skip_spaces (infile)) != ']') + { + struct md_constant *def; + void **entry_ptr; + + if (c != '(') + fatal_expected_char (infile, '(', c); + def = xmalloc (sizeof (struct md_constant)); + def->name = tmp_char; + read_name (tmp_char, infile); + entry_ptr = htab_find_slot (defs, def, TRUE); + if (! *entry_ptr) + def->name = xstrdup (tmp_char); + c = read_skip_spaces (infile); + ungetc (c, infile); + read_name (tmp_char, infile); + if (! *entry_ptr) + { + def->value = xstrdup (tmp_char); + *entry_ptr = def; + } + else + { + def = *entry_ptr; + if (strcmp (def->value, tmp_char)) + fatal_with_file_and_line (infile, + "redefinition of %s, was %s, now %s", + def->name, def->value, tmp_char); + } + c = read_skip_spaces (infile); + if (c != ')') + fatal_expected_char (infile, ')', c); + } + md_constants = defs; + c = read_skip_spaces (infile); + if (c != ')') + fatal_expected_char (infile, ')', c); +} + +/* For every constant definition, call CALLBACK with two arguments: + a pointer a pointer to the constant definition and INFO. + Stops when CALLBACK returns zero. */ +void +traverse_md_constants (callback, info) + htab_trav callback; + void *info; +{ + if (md_constants) + htab_traverse (md_constants, callback, info); +} + +static void +validate_const_int (infile, string) + FILE *infile; + const char *string; +{ + const char *cp; + int valid = 1; + + cp = string; + while (*cp && ISSPACE (*cp)) + cp++; + if (*cp == '-' || *cp == '+') + cp++; + if (*cp == 0) + valid = 0; + for (; *cp; cp++) + if (! ISDIGIT (*cp)) + valid = 0; + if (!valid) + fatal_with_file_and_line (infile, "invalid decimal constant \"%s\"\n", string); +} + +/* Read an rtx in printed representation from INFILE + and return an actual rtx in core constructed accordingly. + read_rtx is not used in the compiler proper, but rather in + the utilities gen*.c that construct C code from machine descriptions. */ + +rtx +read_rtx (infile) + FILE *infile; +{ + int i, j; + RTX_CODE tmp_code; + const char *format_ptr; + /* tmp_char is a buffer used for reading decimal integers + and names of rtx types and machine modes. + Therefore, 256 must be enough. */ + char tmp_char[256]; + rtx return_rtx; + int c; + int tmp_int; + HOST_WIDE_INT tmp_wide; + + /* Obstack used for allocating RTL objects. */ + static struct obstack rtl_obstack; + static int initialized; + + /* Linked list structure for making RTXs: */ + struct rtx_list + { + struct rtx_list *next; + rtx value; /* Value of this node. */ + }; + + if (!initialized) { + obstack_init (&rtl_obstack); + initialized = 1; + } + +again: + c = read_skip_spaces (infile); /* Should be open paren. */ + if (c != '(') + fatal_expected_char (infile, '(', c); + + read_name (tmp_char, infile); + + tmp_code = UNKNOWN; + + if (! strcmp (tmp_char, "define_constants")) + { + read_constants (infile, tmp_char); + goto again; + } + for (i = 0; i < NUM_RTX_CODE; i++) + if (! strcmp (tmp_char, GET_RTX_NAME (i))) + { + tmp_code = (RTX_CODE) i; /* get value for name */ + break; + } + + if (tmp_code == UNKNOWN) + fatal_with_file_and_line (infile, "unknown rtx code `%s'", tmp_char); + + /* (NIL) stands for an expression that isn't there. */ + if (tmp_code == NIL) + { + /* Discard the closeparen. */ + while ((c = getc (infile)) && c != ')') + ; + + return 0; + } + + /* If we end up with an insn expression then we free this space below. */ + return_rtx = rtx_alloc (tmp_code); + format_ptr = GET_RTX_FORMAT (GET_CODE (return_rtx)); + + /* If what follows is `: mode ', read it and + store the mode in the rtx. */ + + i = read_skip_spaces (infile); + if (i == ':') + { + read_name (tmp_char, infile); + for (j = 0; j < NUM_MACHINE_MODES; j++) + if (! strcmp (GET_MODE_NAME (j), tmp_char)) + break; + + if (j == MAX_MACHINE_MODE) + fatal_with_file_and_line (infile, "unknown mode `%s'", tmp_char); + + PUT_MODE (return_rtx, (enum machine_mode) j); + } + else + ungetc (i, infile); + + for (i = 0; i < GET_RTX_LENGTH (GET_CODE (return_rtx)); i++) + switch (*format_ptr++) + { + /* 0 means a field for internal use only. + Don't expect it to be present in the input. */ + case '0': + break; + + case 'e': + case 'u': + XEXP (return_rtx, i) = read_rtx (infile); + break; + + case 'V': + /* 'V' is an optional vector: if a closeparen follows, + just store NULL for this element. */ + c = read_skip_spaces (infile); + ungetc (c, infile); + if (c == ')') + { + XVEC (return_rtx, i) = 0; + break; + } + /* Now process the vector. */ + + case 'E': + { + /* Obstack to store scratch vector in. */ + struct obstack vector_stack; + int list_counter = 0; + rtvec return_vec = NULL_RTVEC; + + c = read_skip_spaces (infile); + if (c != '[') + fatal_expected_char (infile, '[', c); + + /* add expressions to a list, while keeping a count */ + obstack_init (&vector_stack); + while ((c = read_skip_spaces (infile)) && c != ']') + { + ungetc (c, infile); + list_counter++; + obstack_ptr_grow (&vector_stack, (PTR) read_rtx (infile)); + } + if (list_counter > 0) + { + return_vec = rtvec_alloc (list_counter); + memcpy (&return_vec->elem[0], obstack_finish (&vector_stack), + list_counter * sizeof (rtx)); + } + XVEC (return_rtx, i) = return_vec; + obstack_free (&vector_stack, NULL); + /* close bracket gotten */ + } + break; + + case 'S': + /* 'S' is an optional string: if a closeparen follows, + just store NULL for this element. */ + c = read_skip_spaces (infile); + ungetc (c, infile); + if (c == ')') + { + XSTR (return_rtx, i) = 0; + break; + } + + case 'T': + case 's': + { + char *stringbuf; + + /* The output template slot of a DEFINE_INSN, + DEFINE_INSN_AND_SPLIT, or DEFINE_PEEPHOLE automatically + gets a star inserted as its first character, if it is + written with a brace block instead of a string constant. */ + int star_if_braced = (format_ptr[-1] == 'T'); + + stringbuf = read_string (&rtl_obstack, infile, star_if_braced); + + /* For insn patterns, we want to provide a default name + based on the file and line, like "*foo.md:12", if the + given name is blank. These are only for define_insn and + define_insn_and_split, to aid debugging. */ + if (*stringbuf == '\0' + && i == 0 + && (GET_CODE (return_rtx) == DEFINE_INSN + || GET_CODE (return_rtx) == DEFINE_INSN_AND_SPLIT)) + { + char line_name[20]; + const char *fn = (read_rtx_filename ? read_rtx_filename : "rtx"); + const char *slash; + for (slash = fn; *slash; slash ++) + if (*slash == '/' || *slash == '\\' || *slash == ':') + fn = slash + 1; + obstack_1grow (&rtl_obstack, '*'); + obstack_grow (&rtl_obstack, fn, strlen (fn)); + sprintf (line_name, ":%d", read_rtx_lineno); + obstack_grow (&rtl_obstack, line_name, strlen (line_name)+1); + stringbuf = (char *) obstack_finish (&rtl_obstack); + } + + if (star_if_braced) + XTMPL (return_rtx, i) = stringbuf; + else + XSTR (return_rtx, i) = stringbuf; + } + break; + + case 'w': + read_name (tmp_char, infile); + validate_const_int (infile, tmp_char); +#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT + tmp_wide = atoi (tmp_char); +#else +#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG + tmp_wide = atol (tmp_char); +#else + /* Prefer atoll over atoq, since the former is in the ISO C99 standard. + But prefer not to use our hand-rolled function above either. */ +#if defined(HAVE_ATOLL) || !defined(HAVE_ATOQ) + tmp_wide = atoll (tmp_char); +#else + tmp_wide = atoq (tmp_char); +#endif +#endif +#endif + XWINT (return_rtx, i) = tmp_wide; + break; + + case 'i': + case 'n': + read_name (tmp_char, infile); + validate_const_int (infile, tmp_char); + tmp_int = atoi (tmp_char); + XINT (return_rtx, i) = tmp_int; + break; + + default: + fprintf (stderr, + "switch format wrong in rtl.read_rtx(). format was: %c.\n", + format_ptr[-1]); + fprintf (stderr, "\tfile position: %ld\n", ftell (infile)); + abort (); + } + + c = read_skip_spaces (infile); + if (c != ')') + fatal_expected_char (infile, ')', c); + + return return_rtx; +} |