freebsd-dev/contrib/gcc/read-rtl.c
David E. O'Brien 1952e2e1c1 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.
2002-02-01 18:16:02 +00:00

772 lines
18 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* 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;
}