/* RTL reader for GCC.
Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000, 2001, 2002,
- 2003, 2004
+ 2003, 2004, 2005
Free Software Foundation, Inc.
This file is part of GCC.
02111-1307, USA. */
#include "bconfig.h"
+
+/* Disable rtl checking; it conflicts with the macro handling. */
+#undef ENABLE_RTL_CHECKING
+
#include "system.h"
#include "coretypes.h"
#include "tm.h"
static htab_t md_constants;
+/* One element in a singly-linked list of (integer, string) pairs. */
+struct map_value {
+ struct map_value *next;
+ int number;
+ const char *string;
+};
+
+/* Maps a macro or attribute name to a list of (integer, string) pairs.
+ The integers are mode or code values; the strings are either C conditions
+ or attribute values. */
+struct mapping {
+ /* The name of the macro or attribute. */
+ const char *name;
+
+ /* The group (modes or codes) to which the macro or attribute belongs. */
+ struct macro_group *group;
+
+ /* Gives a unique number to the attribute or macro. Numbers are
+ allocated consecutively, starting at 0. */
+ int index;
+
+ /* The list of (integer, string) pairs. */
+ struct map_value *values;
+};
+
+/* A structure for abstracting the common parts of code and mode macros. */
+struct macro_group {
+ /* Tables of "mapping" structures, one for attributes and one for macros. */
+ htab_t attrs, macros;
+
+ /* The number of "real" modes or codes (and by extension, the first
+ number available for use as a macro placeholder). */
+ int num_builtins;
+
+ /* Treat the given string as the name of a standard mode or code and
+ return its integer value. Use the given file for error reporting. */
+ int (*find_builtin) (const char *, FILE *);
+
+ /* Return true if the given rtx uses the given mode or code. */
+ bool (*uses_macro_p) (rtx, int);
+
+ /* Make the given rtx use the given mode or code. */
+ void (*apply_macro) (rtx, int);
+};
+
+/* Associates PTR (which can be a string, etc.) with the file location
+ specified by FILENAME and LINENO. */
+struct ptr_loc {
+ const void *ptr;
+ const char *filename;
+ int lineno;
+};
+
+/* If CODE is the number of a code macro, return a real rtx code that
+ has the same format. Return CODE otherwise. */
+#define BELLWETHER_CODE(CODE) \
+ ((CODE) < NUM_RTX_CODE ? CODE : bellwether_codes[CODE - NUM_RTX_CODE])
+
static void fatal_with_file_and_line (FILE *, const char *, ...)
ATTRIBUTE_PRINTF_2 ATTRIBUTE_NORETURN;
static void fatal_expected_char (FILE *, int, int) ATTRIBUTE_NORETURN;
+static int find_mode (const char *, FILE *);
+static bool uses_mode_macro_p (rtx, int);
+static void apply_mode_macro (rtx, int);
+static int find_code (const char *, FILE *);
+static bool uses_code_macro_p (rtx, int);
+static void apply_code_macro (rtx, int);
+static const char *apply_macro_to_string (const char *, struct mapping *, int);
+static rtx apply_macro_to_rtx (rtx, struct mapping *, int);
+static bool uses_macro_p (rtx, struct mapping *);
+static const char *add_condition_to_string (const char *, const char *);
+static void add_condition_to_rtx (rtx, const char *);
+static int apply_macro_traverse (void **, void *);
+static struct mapping *add_mapping (struct macro_group *, htab_t t,
+ const char *, FILE *);
+static struct map_value **add_map_value (struct map_value **,
+ int, const char *);
+static void initialize_macros (void);
static void read_name (char *, FILE *);
+static hashval_t leading_ptr_hash (const void *);
+static int leading_ptr_eq_p (const void *, const void *);
+static void set_rtx_ptr_loc (const void *, const char *, int);
+static const struct ptr_loc *get_rtx_ptr_loc (const void *);
static char *read_string (FILE *, int);
static char *read_quoted_string (FILE *);
static char *read_braced_string (FILE *);
static int def_name_eq_p (const void *, const void *);
static void read_constants (FILE *infile, char *tmp_char);
static void validate_const_int (FILE *, const char *);
+static int find_macro (struct macro_group *, const char *, FILE *);
+static struct mapping *read_mapping (struct macro_group *, htab_t, FILE *);
+static void check_code_macro (struct mapping *, FILE *);
+static rtx read_rtx_1 (FILE *);
+
+/* The mode and code macro structures. */
+static struct macro_group modes, codes;
+
+/* Index I is the value of BELLWETHER_CODE (I + NUM_RTX_CODE). */
+static enum rtx_code *bellwether_codes;
/* Obstack used for allocating RTL strings. */
static struct obstack string_obstack;
+/* A table of ptr_locs, hashed on the PTR field. */
+static htab_t ptr_locs;
+
+/* An obstack for the above. Plain xmalloc is a bit heavyweight for a
+ small structure like ptr_loc. */
+static struct obstack ptr_loc_obstack;
+
+/* A hash table of triples (A, B, C), where each of A, B and C is a condition
+ and A is equivalent to "B && C". This is used to keep track of the source
+ of conditions that are made up of separate rtx strings (such as the split
+ condition of a define_insn_and_split). */
+static htab_t joined_conditions;
+
+/* An obstack for allocating joined_conditions entries. */
+static struct obstack joined_conditions_obstack;
+
/* Subroutines of read_rtx. */
/* The current line number for the file. */
expected_c, actual_c);
}
+/* Implementations of the macro_group callbacks for modes. */
+
+static int
+find_mode (const char *name, FILE *infile)
+{
+ int i;
+
+ for (i = 0; i < NUM_MACHINE_MODES; i++)
+ if (strcmp (GET_MODE_NAME (i), name) == 0)
+ return i;
+
+ fatal_with_file_and_line (infile, "unknown mode `%s'", name);
+}
+
+static bool
+uses_mode_macro_p (rtx x, int mode)
+{
+ return (int) GET_MODE (x) == mode;
+}
+
+static void
+apply_mode_macro (rtx x, int mode)
+{
+ PUT_MODE (x, mode);
+}
+
+/* Implementations of the macro_group callbacks for codes. */
+
+static int
+find_code (const char *name, FILE *infile)
+{
+ int i;
+
+ for (i = 0; i < NUM_RTX_CODE; i++)
+ if (strcmp (GET_RTX_NAME (i), name) == 0)
+ return i;
+
+ fatal_with_file_and_line (infile, "unknown rtx code `%s'", name);
+}
+
+static bool
+uses_code_macro_p (rtx x, int code)
+{
+ return (int) GET_CODE (x) == code;
+}
+
+static void
+apply_code_macro (rtx x, int code)
+{
+ PUT_CODE (x, code);
+}
+
+/* Given that MACRO is being expanded as VALUE, apply the appropriate
+ string substitutions to STRING. Return the new string if any changes
+ were needed, otherwise return STRING itself. */
+
+static const char *
+apply_macro_to_string (const char *string, struct mapping *macro, int value)
+{
+ char *base, *copy, *p, *attr, *start, *end;
+ struct mapping *m;
+ struct map_value *v;
+
+ if (string == 0)
+ return string;
+
+ base = p = copy = ASTRDUP (string);
+ while ((start = strchr (p, '<')) && (end = strchr (start, '>')))
+ {
+ p = start + 1;
+
+ /* If there's a "macro:" prefix, check whether the macro name matches.
+ Set ATTR to the start of the attribute name. */
+ attr = strchr (p, ':');
+ if (attr == 0 || attr > end)
+ attr = p;
+ else
+ {
+ if (strncmp (p, macro->name, attr - p) != 0
+ || macro->name[attr - p] != 0)
+ continue;
+ attr++;
+ }
+
+ /* Find the attribute specification. */
+ *end = 0;
+ m = (struct mapping *) htab_find (macro->group->attrs, &attr);
+ *end = '>';
+ if (m == 0)
+ continue;
+
+ /* Find the attribute value for VALUE. */
+ for (v = m->values; v != 0; v = v->next)
+ if (v->number == value)
+ break;
+ if (v == 0)
+ continue;
+
+ /* Add everything between the last copied byte and the '<',
+ then add in the attribute value. */
+ obstack_grow (&string_obstack, base, start - base);
+ obstack_grow (&string_obstack, v->string, strlen (v->string));
+ base = end + 1;
+ }
+ if (base != copy)
+ {
+ obstack_grow (&string_obstack, base, strlen (base) + 1);
+ copy = obstack_finish (&string_obstack);
+ copy_rtx_ptr_loc (copy, string);
+ return copy;
+ }
+ return string;
+}
+
+/* Return a copy of ORIGINAL in which all uses of MACRO have been
+ replaced by VALUE. */
+
+static rtx
+apply_macro_to_rtx (rtx original, struct mapping *macro, int value)
+{
+ struct macro_group *group;
+ const char *format_ptr;
+ int i, j;
+ rtx x;
+ enum rtx_code bellwether_code;
+
+ if (original == 0)
+ return original;
+
+ /* Create a shallow copy of ORIGINAL. */
+ bellwether_code = BELLWETHER_CODE (GET_CODE (original));
+ x = rtx_alloc (bellwether_code);
+ memcpy (x, original, RTX_SIZE (bellwether_code));
+
+ /* Change the mode or code itself. */
+ group = macro->group;
+ if (group->uses_macro_p (x, macro->index + group->num_builtins))
+ group->apply_macro (x, value);
+
+ /* Change each string and recursively change each rtx. */
+ format_ptr = GET_RTX_FORMAT (bellwether_code);
+ for (i = 0; format_ptr[i] != 0; i++)
+ switch (format_ptr[i])
+ {
+ case 'T':
+ XTMPL (x, i) = apply_macro_to_string (XTMPL (x, i), macro, value);
+ break;
+
+ case 'S':
+ case 's':
+ XSTR (x, i) = apply_macro_to_string (XSTR (x, i), macro, value);
+ break;
+
+ case 'e':
+ XEXP (x, i) = apply_macro_to_rtx (XEXP (x, i), macro, value);
+ break;
+
+ case 'V':
+ case 'E':
+ if (XVEC (original, i))
+ {
+ XVEC (x, i) = rtvec_alloc (XVECLEN (original, i));
+ for (j = 0; j < XVECLEN (x, i); j++)
+ XVECEXP (x, i, j) = apply_macro_to_rtx (XVECEXP (original, i, j),
+ macro, value);
+ }
+ break;
+
+ default:
+ break;
+ }
+ return x;
+}
+
+/* Return true if X (or some subexpression of X) uses macro MACRO. */
+
+static bool
+uses_macro_p (rtx x, struct mapping *macro)
+{
+ struct macro_group *group;
+ const char *format_ptr;
+ int i, j;
+
+ if (x == 0)
+ return false;
+
+ group = macro->group;
+ if (group->uses_macro_p (x, macro->index + group->num_builtins))
+ return true;
+
+ format_ptr = GET_RTX_FORMAT (BELLWETHER_CODE (GET_CODE (x)));
+ for (i = 0; format_ptr[i] != 0; i++)
+ switch (format_ptr[i])
+ {
+ case 'e':
+ if (uses_macro_p (XEXP (x, i), macro))
+ return true;
+ break;
+
+ case 'V':
+ case 'E':
+ if (XVEC (x, i))
+ for (j = 0; j < XVECLEN (x, i); j++)
+ if (uses_macro_p (XVECEXP (x, i, j), macro))
+ return true;
+ break;
+
+ default:
+ break;
+ }
+ return false;
+}
+
+/* Return a condition that must satisfy both ORIGINAL and EXTRA. If ORIGINAL
+ has the form "&& ..." (as used in define_insn_and_splits), assume that
+ EXTRA is already satisfied. Empty strings are treated like "true". */
+
+static const char *
+add_condition_to_string (const char *original, const char *extra)
+{
+ if (original != 0 && original[0] == '&' && original[1] == '&')
+ return original;
+ return join_c_conditions (original, extra);
+}
+
+/* Like add_condition, but applied to all conditions in rtx X. */
+
+static void
+add_condition_to_rtx (rtx x, const char *extra)
+{
+ switch (GET_CODE (x))
+ {
+ case DEFINE_INSN:
+ case DEFINE_EXPAND:
+ XSTR (x, 2) = add_condition_to_string (XSTR (x, 2), extra);
+ break;
+
+ case DEFINE_SPLIT:
+ case DEFINE_PEEPHOLE:
+ case DEFINE_PEEPHOLE2:
+ case DEFINE_COND_EXEC:
+ XSTR (x, 1) = add_condition_to_string (XSTR (x, 1), extra);
+ break;
+
+ case DEFINE_INSN_AND_SPLIT:
+ XSTR (x, 2) = add_condition_to_string (XSTR (x, 2), extra);
+ XSTR (x, 4) = add_condition_to_string (XSTR (x, 4), extra);
+ break;
+
+ default:
+ break;
+ }
+}
+
+/* A htab_traverse callback. Search the EXPR_LIST given by DATA
+ for rtxes that use the macro in *SLOT. Replace each such rtx
+ with a list of expansions. */
+
+static int
+apply_macro_traverse (void **slot, void *data)
+{
+ struct mapping *macro;
+ struct map_value *v;
+ rtx elem, new_elem, original, x;
+
+ macro = (struct mapping *) *slot;
+ for (elem = (rtx) data; elem != 0; elem = XEXP (elem, 1))
+ if (uses_macro_p (XEXP (elem, 0), macro))
+ {
+ original = XEXP (elem, 0);
+ for (v = macro->values; v != 0; v = v->next)
+ {
+ x = apply_macro_to_rtx (original, macro, v->number);
+ add_condition_to_rtx (x, v->string);
+ if (v != macro->values)
+ {
+ /* Insert a new EXPR_LIST node after ELEM and put the
+ new expansion there. */
+ new_elem = rtx_alloc (EXPR_LIST);
+ XEXP (new_elem, 1) = XEXP (elem, 1);
+ XEXP (elem, 1) = new_elem;
+ elem = new_elem;
+ }
+ XEXP (elem, 0) = x;
+ }
+ }
+ return 1;
+}
+
+/* Add a new "mapping" structure to hashtable TABLE. NAME is the name
+ of the mapping, GROUP is the group to which it belongs, and INFILE
+ is the file that defined the mapping. */
+
+static struct mapping *
+add_mapping (struct macro_group *group, htab_t table,
+ const char *name, FILE *infile)
+{
+ struct mapping *m;
+ void **slot;
+
+ m = XNEW (struct mapping);
+ m->name = xstrdup (name);
+ m->group = group;
+ m->index = htab_elements (table);
+ m->values = 0;
+
+ slot = htab_find_slot (table, m, INSERT);
+ if (*slot != 0)
+ fatal_with_file_and_line (infile, "`%s' already defined", name);
+
+ *slot = m;
+ return m;
+}
+
+/* Add the pair (NUMBER, STRING) to a list of map_value structures.
+ END_PTR points to the current null terminator for the list; return
+ a pointer the new null terminator. */
+
+static struct map_value **
+add_map_value (struct map_value **end_ptr, int number, const char *string)
+{
+ struct map_value *value;
+
+ value = XNEW (struct map_value);
+ value->next = 0;
+ value->number = number;
+ value->string = string;
+
+ *end_ptr = value;
+ return &value->next;
+}
+
+/* Do one-time initialization of the mode and code attributes. */
+
+static void
+initialize_macros (void)
+{
+ struct mapping *lower, *upper;
+ struct map_value **lower_ptr, **upper_ptr;
+ char *copy, *p;
+ int i;
+
+ modes.attrs = htab_create (13, def_hash, def_name_eq_p, 0);
+ modes.macros = htab_create (13, def_hash, def_name_eq_p, 0);
+ modes.num_builtins = MAX_MACHINE_MODE;
+ modes.find_builtin = find_mode;
+ modes.uses_macro_p = uses_mode_macro_p;
+ modes.apply_macro = apply_mode_macro;
+
+ codes.attrs = htab_create (13, def_hash, def_name_eq_p, 0);
+ codes.macros = htab_create (13, def_hash, def_name_eq_p, 0);
+ codes.num_builtins = NUM_RTX_CODE;
+ codes.find_builtin = find_code;
+ codes.uses_macro_p = uses_code_macro_p;
+ codes.apply_macro = apply_code_macro;
+
+ lower = add_mapping (&modes, modes.attrs, "mode", 0);
+ upper = add_mapping (&modes, modes.attrs, "MODE", 0);
+ lower_ptr = &lower->values;
+ upper_ptr = &upper->values;
+ for (i = 0; i < MAX_MACHINE_MODE; i++)
+ {
+ copy = xstrdup (GET_MODE_NAME (i));
+ for (p = copy; *p != 0; p++)
+ *p = TOLOWER (*p);
+
+ upper_ptr = add_map_value (upper_ptr, i, GET_MODE_NAME (i));
+ lower_ptr = add_map_value (lower_ptr, i, copy);
+ }
+
+ lower = add_mapping (&codes, codes.attrs, "code", 0);
+ upper = add_mapping (&codes, codes.attrs, "CODE", 0);
+ lower_ptr = &lower->values;
+ upper_ptr = &upper->values;
+ for (i = 0; i < NUM_RTX_CODE; i++)
+ {
+ copy = xstrdup (GET_RTX_NAME (i));
+ for (p = copy; *p != 0; p++)
+ *p = TOUPPER (*p);
+
+ lower_ptr = add_map_value (lower_ptr, i, GET_RTX_NAME (i));
+ upper_ptr = add_map_value (upper_ptr, i, copy);
+ }
+}
+
+/* Return a hash value for the pointer pointed to by DEF. */
+
+static hashval_t
+leading_ptr_hash (const void *def)
+{
+ return htab_hash_pointer (*(const void *const *) def);
+}
+
+/* Return true if DEF1 and DEF2 are pointers to the same pointer. */
+
+static int
+leading_ptr_eq_p (const void *def1, const void *def2)
+{
+ return *(const void *const *) def1 == *(const void *const *) def2;
+}
+
+/* Associate PTR with the file position given by FILENAME and LINENO. */
+
+static void
+set_rtx_ptr_loc (const void *ptr, const char *filename, int lineno)
+{
+ struct ptr_loc *loc;
+
+ loc = (struct ptr_loc *) obstack_alloc (&ptr_loc_obstack,
+ sizeof (struct ptr_loc));
+ loc->ptr = ptr;
+ loc->filename = filename;
+ loc->lineno = lineno;
+ *htab_find_slot (ptr_locs, loc, INSERT) = loc;
+}
+
+/* Return the position associated with pointer PTR. Return null if no
+ position was set. */
+
+static const struct ptr_loc *
+get_rtx_ptr_loc (const void *ptr)
+{
+ return (const struct ptr_loc *) htab_find (ptr_locs, &ptr);
+}
+
+/* Associate NEW_PTR with the same file position as OLD_PTR. */
+
+void
+copy_rtx_ptr_loc (const void *new_ptr, const void *old_ptr)
+{
+ const struct ptr_loc *loc = get_rtx_ptr_loc (old_ptr);
+ if (loc != 0)
+ set_rtx_ptr_loc (new_ptr, loc->filename, loc->lineno);
+}
+
+/* If PTR is associated with a known file position, print a #line
+ directive for it. */
+
+void
+print_rtx_ptr_loc (const void *ptr)
+{
+ const struct ptr_loc *loc = get_rtx_ptr_loc (ptr);
+ if (loc != 0)
+ printf ("#line %d \"%s\"\n", loc->lineno, loc->filename);
+}
+
+/* Return a condition that satisfies both COND1 and COND2. Either string
+ may be null or empty. */
+
+const char *
+join_c_conditions (const char *cond1, const char *cond2)
+{
+ char *result;
+ const void **entry;
+
+ if (cond1 == 0 || cond1[0] == 0)
+ return cond2;
+
+ if (cond2 == 0 || cond2[0] == 0)
+ return cond1;
+
+ result = concat ("(", cond1, ") && (", cond2, ")", NULL);
+ obstack_ptr_grow (&joined_conditions_obstack, result);
+ obstack_ptr_grow (&joined_conditions_obstack, cond1);
+ obstack_ptr_grow (&joined_conditions_obstack, cond2);
+ entry = obstack_finish (&joined_conditions_obstack);
+ *htab_find_slot (joined_conditions, entry, INSERT) = entry;
+ return result;
+}
+
+/* Print condition COND, wrapped in brackets. If COND was created by
+ join_c_conditions, recursively invoke this function for the original
+ conditions and join the result with "&&". Otherwise print a #line
+ directive for COND if its original file position is known. */
+
+void
+print_c_condition (const char *cond)
+{
+ const void **halves = htab_find (joined_conditions, &cond);
+ if (halves != 0)
+ {
+ printf ("(");
+ print_c_condition (halves[1]);
+ printf (" && ");
+ print_c_condition (halves[2]);
+ printf (")");
+ }
+ else
+ {
+ putc ('\n', stdout);
+ print_rtx_ptr_loc (cond);
+ printf ("(%s)", cond);
+ }
+}
+
/* Read chars from INFILE until a non-whitespace char
and return that. Comments, both Lisp style and C style,
are treated as whitespace.
{
char *stringbuf;
int saw_paren = 0;
- int c;
+ int c, old_lineno;
c = read_skip_spaces (infile);
if (c == '(')
c = read_skip_spaces (infile);
}
+ old_lineno = read_rtx_lineno;
if (c == '"')
stringbuf = read_quoted_string (infile);
else if (c == '{')
fatal_expected_char (infile, ')', c);
}
+ set_rtx_ptr_loc (stringbuf, read_rtx_filename, old_lineno);
return stringbuf;
}
\f
}
#endif
-/* Given a constant definition, return a hash code for its name. */
+/* Given an object that starts with a char * name field, return a hash
+ code for its name. */
static hashval_t
def_hash (const void *def)
{
unsigned result, i;
- const char *string = ((const struct md_constant *) def)->name;
+ const char *string = *(const char *const *) def;
- for (result = i = 0;*string++ != '\0'; i++)
+ 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. */
+/* Given two objects that start with char * name fields, return true if
+ they have the same name. */
static int
def_name_eq_p (const void *def1, const void *def2)
{
- return ! strcmp (((const struct md_constant *) def1)->name,
- ((const struct md_constant *) def2)->name);
+ return ! strcmp (*(const char *const *) def1,
+ *(const char *const *) def2);
}
/* INFILE is a FILE pointer to read text from. TMP_CHAR is a buffer suitable
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.
+/* Search GROUP for a mode or code called NAME and return its numerical
+ identifier. INFILE is the file that contained NAME. */
+
+static int
+find_macro (struct macro_group *group, const char *name, FILE *infile)
+{
+ struct mapping *m;
+
+ m = (struct mapping *) htab_find (group->macros, &name);
+ if (m != 0)
+ return m->index + group->num_builtins;
+ return group->find_builtin (name, infile);
+}
+
+/* Finish reading a declaration of the form:
+
+ (define... <name> [<value1> ... <valuen>])
+
+ from INFILE, where each <valuei> is either a bare symbol name or a
+ "(<name> <string>)" pair. The "(define..." part has already been read.
+
+ Represent the declaration as a "mapping" structure; add it to TABLE
+ (which belongs to GROUP) and return it. */
+
+static struct mapping *
+read_mapping (struct macro_group *group, htab_t table, FILE *infile)
+{
+ char tmp_char[256];
+ struct mapping *m;
+ struct map_value **end_ptr;
+ const char *string;
+ int number, c;
+
+ /* Read the mapping name and create a structure for it. */
+ read_name (tmp_char, infile);
+ m = add_mapping (group, table, tmp_char, infile);
+
+ c = read_skip_spaces (infile);
+ if (c != '[')
+ fatal_expected_char (infile, '[', c);
+
+ /* Read each value. */
+ end_ptr = &m->values;
+ c = read_skip_spaces (infile);
+ do
+ {
+ if (c != '(')
+ {
+ /* A bare symbol name that is implicitly paired to an
+ empty string. */
+ ungetc (c, infile);
+ read_name (tmp_char, infile);
+ string = "";
+ }
+ else
+ {
+ /* A "(name string)" pair. */
+ read_name (tmp_char, infile);
+ string = read_string (infile, false);
+ c = read_skip_spaces (infile);
+ if (c != ')')
+ fatal_expected_char (infile, ')', c);
+ }
+ number = group->find_builtin (tmp_char, infile);
+ end_ptr = add_map_value (end_ptr, number, string);
+ c = read_skip_spaces (infile);
+ }
+ while (c != ']');
+
+ c = read_skip_spaces (infile);
+ if (c != ')')
+ fatal_expected_char (infile, ')', c);
+
+ return m;
+}
+
+/* Check newly-created code macro MACRO to see whether every code has the
+ same format. Initialize the macro's entry in bellwether_codes. */
+
+static void
+check_code_macro (struct mapping *macro, FILE *infile)
+{
+ struct map_value *v;
+ enum rtx_code bellwether;
+
+ bellwether = macro->values->number;
+ for (v = macro->values->next; v != 0; v = v->next)
+ if (strcmp (GET_RTX_FORMAT (bellwether), GET_RTX_FORMAT (v->number)) != 0)
+ fatal_with_file_and_line (infile, "code macro `%s' combines "
+ "different rtx formats", macro->name);
+
+ bellwether_codes = XRESIZEVEC (enum rtx_code, bellwether_codes,
+ macro->index + 1);
+ bellwether_codes[macro->index] = bellwether;
+}
+
+/* Read an rtx in printed representation from INFILE and store its
+ core representation in *X. Also store the line number of the
+ opening '(' in *LINENO. Return true on success or false if the
+ end of file has been reached.
+
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 (FILE *infile)
+bool
+read_rtx (FILE *infile, rtx *x, int *lineno)
{
- int i, j;
- RTX_CODE tmp_code;
+ static rtx queue_head, queue_next;
+ static int queue_lineno;
+ int c;
+
+ /* Do one-time initialization. */
+ if (queue_head == 0)
+ {
+ initialize_macros ();
+ obstack_init (&string_obstack);
+ queue_head = rtx_alloc (EXPR_LIST);
+ ptr_locs = htab_create (161, leading_ptr_hash, leading_ptr_eq_p, 0);
+ obstack_init (&ptr_loc_obstack);
+ joined_conditions = htab_create (161, leading_ptr_hash,
+ leading_ptr_eq_p, 0);
+ obstack_init (&joined_conditions_obstack);
+ }
+
+ if (queue_next == 0)
+ {
+ c = read_skip_spaces (infile);
+ if (c == EOF)
+ return false;
+ ungetc (c, infile);
+
+ queue_next = queue_head;
+ queue_lineno = read_rtx_lineno;
+ XEXP (queue_next, 0) = read_rtx_1 (infile);
+ XEXP (queue_next, 1) = 0;
+
+ htab_traverse (modes.macros, apply_macro_traverse, queue_next);
+ htab_traverse (codes.macros, apply_macro_traverse, queue_next);
+ }
+
+ *x = XEXP (queue_next, 0);
+ *lineno = queue_lineno;
+ queue_next = XEXP (queue_next, 1);
+
+ return true;
+}
+
+/* Subroutine of read_rtx that reads one construct from INFILE but
+ doesn't apply any macros. */
+
+static rtx
+read_rtx_1 (FILE *infile)
+{
+ int i;
+ RTX_CODE real_code, bellwether_code;
const char *format_ptr;
/* tmp_char is a buffer used for reading decimal integers
and names of rtx types and machine modes.
int tmp_int;
HOST_WIDE_INT tmp_wide;
- static int initialized;
-
/* Linked list structure for making RTXs: */
struct rtx_list
{
rtx value; /* Value of this node. */
};
- if (!initialized)
- {
- obstack_init (&string_obstack);
- initialized = 1;
- }
-
-again:
+ 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;
- 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)
+ if (strcmp (tmp_char, "nil") == 0)
{
/* (nil) stands for an expression that isn't there. */
- if (! strcmp (tmp_char, "nil"))
- {
- /* Discard the closeparen. */
- c = read_skip_spaces (infile);
- if (c != ')')
- fatal_expected_char (infile, ')', c);
- return 0;
- }
- /* (define_constants ...) has special syntax. */
- else if (! strcmp (tmp_char, "define_constants"))
- {
- read_constants (infile, tmp_char);
- goto again;
- }
- else
- fatal_with_file_and_line (infile, "unknown rtx code `%s'", tmp_char);
+ c = read_skip_spaces (infile);
+ if (c != ')')
+ fatal_expected_char (infile, ')', c);
+ return 0;
}
+ if (strcmp (tmp_char, "define_constants") == 0)
+ {
+ read_constants (infile, tmp_char);
+ goto again;
+ }
+ if (strcmp (tmp_char, "define_mode_attr") == 0)
+ {
+ read_mapping (&modes, modes.attrs, infile);
+ goto again;
+ }
+ if (strcmp (tmp_char, "define_mode_macro") == 0)
+ {
+ read_mapping (&modes, modes.macros, infile);
+ goto again;
+ }
+ if (strcmp (tmp_char, "define_code_attr") == 0)
+ {
+ read_mapping (&codes, codes.attrs, infile);
+ goto again;
+ }
+ if (strcmp (tmp_char, "define_code_macro") == 0)
+ {
+ check_code_macro (read_mapping (&codes, codes.macros, infile), infile);
+ goto again;
+ }
+ real_code = find_macro (&codes, tmp_char, infile);
+ bellwether_code = BELLWETHER_CODE (real_code);
/* 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));
+ return_rtx = rtx_alloc (bellwether_code);
+ format_ptr = GET_RTX_FORMAT (bellwether_code);
+ PUT_CODE (return_rtx, real_code);
/* If what follows is `: mode ', read it and
store the mode in the rtx. */
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);
+ PUT_MODE (return_rtx, find_macro (&modes, tmp_char, infile));
}
else
ungetc (i, infile);
- for (i = 0; i < GET_RTX_LENGTH (GET_CODE (return_rtx)); i++)
- switch (*format_ptr++)
+ for (i = 0; format_ptr[i] != 0; i++)
+ switch (format_ptr[i])
{
/* 0 means a field for internal use only.
Don't expect it to be present in the input. */
case 'e':
case 'u':
- XEXP (return_rtx, i) = read_rtx (infile);
+ XEXP (return_rtx, i) = read_rtx_1 (infile);
break;
case 'V':
{
ungetc (c, infile);
list_counter++;
- obstack_ptr_grow (&vector_stack, read_rtx (infile));
+ obstack_ptr_grow (&vector_stack, read_rtx_1 (infile));
}
if (list_counter > 0)
{
memcpy (&return_vec->elem[0], obstack_finish (&vector_stack),
list_counter * sizeof (rtx));
}
+ else if (format_ptr[i] == 'E')
+ fatal_with_file_and_line (infile,
+ "vector must have at least one element");
XVEC (return_rtx, i) = return_vec;
obstack_free (&vector_stack, NULL);
/* close bracket gotten */
/* 'S' fields are optional and should be NULL if no string
was given. Also allow normal 's' and 'T' strings to be
omitted, treating them in the same way as empty strings. */
- XSTR (return_rtx, i) = (format_ptr[-1] == 'S' ? NULL : "");
+ XSTR (return_rtx, i) = (format_ptr[i] == 'S' ? NULL : "");
break;
}
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. */
- star_if_braced = (format_ptr[-1] == 'T');
+ star_if_braced = (format_ptr[i] == 'T');
stringbuf = read_string (infile, star_if_braced);
default:
fprintf (stderr,
"switch format wrong in rtl.read_rtx(). format was: %c.\n",
- format_ptr[-1]);
+ format_ptr[i]);
fprintf (stderr, "\tfile position: %ld\n", ftell (infile));
abort ();
}
OSDN Git Service
