X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;ds=sidebyside;f=gcc%2Fread-rtl.c;h=1a0160d35891d81644579dc98288ea8ec155abe8;hb=bd149779199adf9e13b4136d593c8ff6425f995d;hp=15fa503115c38a751aa561a488ba06949507b2b1;hpb=8c4c00c181e6df4f0a9afc76e4c9edbbc1c2fd41;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/read-rtl.c b/gcc/read-rtl.c index 15fa503115c..1a0160d3589 100644 --- a/gcc/read-rtl.c +++ b/gcc/read-rtl.c @@ -1,6 +1,6 @@ /* RTL reader for GCC. Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000, 2001, 2002, - 2003, 2004, 2005, 2007 + 2003, 2004, 2005, 2007, 2008 Free Software Foundation, Inc. This file is part of GCC. @@ -21,7 +21,7 @@ along with GCC; see the file COPYING3. If not see #include "bconfig.h" -/* Disable rtl checking; it conflicts with the macro handling. */ +/* Disable rtl checking; it conflicts with the iterator handling. */ #undef ENABLE_RTL_CHECKING #include "system.h" @@ -41,17 +41,17 @@ struct map_value { const char *string; }; -/* Maps a macro or attribute name to a list of (integer, string) pairs. +/* Maps an iterator 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. */ + /* The name of the iterator or attribute. */ const char *name; - /* The group (modes or codes) to which the macro or attribute belongs. */ - struct macro_group *group; + /* The group (modes or codes) to which the iterator or attribute belongs. */ + struct iterator_group *group; - /* Gives a unique number to the attribute or macro. Numbers are + /* Gives a unique number to the attribute or iterator. Numbers are allocated consecutively, starting at 0. */ int index; @@ -59,13 +59,13 @@ struct mapping { 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; +/* A structure for abstracting the common parts of code and mode iterators. */ +struct iterator_group { + /* Tables of "mapping" structures, one for attributes and one for iterators. */ + htab_t attrs, iterators; /* The number of "real" modes or codes (and by extension, the first - number available for use as a macro placeholder). */ + number available for use as an iterator placeholder). */ int num_builtins; /* Treat the given string as the name of a standard mode or code and @@ -73,10 +73,10 @@ struct macro_group { int (*find_builtin) (const char *, FILE *); /* Return true if the given rtx uses the given mode or code. */ - bool (*uses_macro_p) (rtx, int); + bool (*uses_iterator_p) (rtx, int); /* Make the given rtx use the given mode or code. */ - void (*apply_macro) (rtx, int); + void (*apply_iterator) (rtx, int); }; /* Associates PTR (which can be a string, etc.) with the file location @@ -87,9 +87,9 @@ struct ptr_loc { int lineno; }; -/* A structure used to pass data from read_rtx to apply_macro_traverse +/* A structure used to pass data from read_rtx to apply_iterator_traverse via htab_traverse. */ -struct macro_traverse_data { +struct iterator_traverse_data { /* Instruction queue. */ rtx queue; /* Attributes seen for modes. */ @@ -100,7 +100,7 @@ struct macro_traverse_data { const char *unknown_mode_attr; }; -/* If CODE is the number of a code macro, return a real rtx code that +/* If CODE is the number of a code iterator, 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]) @@ -109,23 +109,23 @@ 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 bool uses_mode_iterator_p (rtx, int); +static void apply_mode_iterator (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, - struct map_value *, FILE *, const char **); -static bool uses_macro_p (rtx, struct mapping *); +static bool uses_code_iterator_p (rtx, int); +static void apply_code_iterator (rtx, int); +static const char *apply_iterator_to_string (const char *, struct mapping *, int); +static rtx apply_iterator_to_rtx (rtx, struct mapping *, int, + struct map_value *, FILE *, const char **); +static bool uses_iterator_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, +static int apply_iterator_traverse (void **, void *); +static struct mapping *add_mapping (struct iterator_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 initialize_iterators (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 *); @@ -140,14 +140,14 @@ static int def_name_eq_p (const void *, const void *); static void read_constants (FILE *infile, char *tmp_char); static void read_conditions (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 int find_iterator (struct iterator_group *, const char *, FILE *); +static struct mapping *read_mapping (struct iterator_group *, htab_t, FILE *); +static void check_code_iterator (struct mapping *, FILE *); static rtx read_rtx_1 (FILE *, struct map_value **); static rtx read_rtx_variadic (FILE *, struct map_value **, rtx); -/* The mode and code macro structures. */ -static struct macro_group modes, codes; +/* The mode and code iterator structures. */ +static struct iterator_group modes, codes; /* Index I is the value of BELLWETHER_CODE (I + NUM_RTX_CODE). */ static enum rtx_code *bellwether_codes; @@ -218,11 +218,15 @@ fatal_with_file_and_line (FILE *infile, const char *msg, ...) static void fatal_expected_char (FILE *infile, int expected_c, int actual_c) { - fatal_with_file_and_line (infile, "expected character `%c', found `%c'", - expected_c, actual_c); + if (actual_c == EOF) + fatal_with_file_and_line (infile, "expected character `%c', found EOF", + expected_c); + else + fatal_with_file_and_line (infile, "expected character `%c', found `%c'", + expected_c, actual_c); } -/* Implementations of the macro_group callbacks for modes. */ +/* Implementations of the iterator_group callbacks for modes. */ static int find_mode (const char *name, FILE *infile) @@ -237,18 +241,18 @@ find_mode (const char *name, FILE *infile) } static bool -uses_mode_macro_p (rtx x, int mode) +uses_mode_iterator_p (rtx x, int mode) { return (int) GET_MODE (x) == mode; } static void -apply_mode_macro (rtx x, int mode) +apply_mode_iterator (rtx x, int mode) { PUT_MODE (x, (enum machine_mode) mode); } -/* Implementations of the macro_group callbacks for codes. */ +/* Implementations of the iterator_group callbacks for codes. */ static int find_code (const char *name, FILE *infile) @@ -263,42 +267,42 @@ find_code (const char *name, FILE *infile) } static bool -uses_code_macro_p (rtx x, int code) +uses_code_iterator_p (rtx x, int code) { return (int) GET_CODE (x) == code; } static void -apply_code_macro (rtx x, int code) +apply_code_iterator (rtx x, int code) { PUT_CODE (x, (enum rtx_code) code); } /* Map a code or mode attribute string P to the underlying string for - MACRO and VALUE. */ + ITERATOR and VALUE. */ static struct map_value * -map_attr_string (const char *p, struct mapping *macro, int value) +map_attr_string (const char *p, struct mapping *iterator, int value) { const char *attr; struct mapping *m; struct map_value *v; - /* If there's a "macro:" prefix, check whether the macro name matches. + /* If there's a "iterator:" prefix, check whether the iterator name matches. Set ATTR to the start of the attribute name. */ attr = strchr (p, ':'); if (attr == 0) attr = p; else { - if (strncmp (p, macro->name, attr - p) != 0 - || macro->name[attr - p] != 0) + if (strncmp (p, iterator->name, attr - p) != 0 + || iterator->name[attr - p] != 0) return 0; attr++; } /* Find the attribute specification. */ - m = (struct mapping *) htab_find (macro->group->attrs, &attr); + m = (struct mapping *) htab_find (iterator->group->attrs, &attr); if (m == 0) return 0; @@ -312,7 +316,7 @@ map_attr_string (const char *p, struct mapping *macro, int value) /* Given an attribute string used as a machine mode, return an index to store in the machine mode to be translated by - apply_macro_to_rtx. */ + apply_iterator_to_rtx. */ static unsigned int mode_attr_index (struct map_value **mode_maps, const char *string) @@ -332,27 +336,27 @@ mode_attr_index (struct map_value **mode_maps, const char *string) *mode_maps = mv; /* We return a code which we can map back into this string: the - number of machine modes + the number of mode macros + the index + number of machine modes + the number of mode iterators + the index we just used. */ - return MAX_MACHINE_MODE + htab_elements (modes.macros) + mv->number; + return MAX_MACHINE_MODE + htab_elements (modes.iterators) + mv->number; } /* Apply MODE_MAPS to the top level of X, expanding cases where an - attribute is used for a mode. MACRO is the current macro we are + attribute is used for a mode. ITERATOR is the current iterator we are expanding, and VALUE is the value to which we are expanding it. INFILE is used for error messages. This sets *UNKNOWN to true if we find a mode attribute which has not yet been defined, and does not change it otherwise. */ static void -apply_mode_maps (rtx x, struct map_value *mode_maps, struct mapping *macro, +apply_mode_maps (rtx x, struct map_value *mode_maps, struct mapping *iterator, int value, FILE *infile, const char **unknown) { unsigned int offset; int indx; struct map_value *pm; - offset = MAX_MACHINE_MODE + htab_elements (modes.macros); + offset = MAX_MACHINE_MODE + htab_elements (modes.iterators); if (GET_MODE (x) < offset) return; @@ -363,7 +367,7 @@ apply_mode_maps (rtx x, struct map_value *mode_maps, struct mapping *macro, { struct map_value *v; - v = map_attr_string (pm->string, macro, value); + v = map_attr_string (pm->string, iterator, value); if (v) PUT_MODE (x, (enum machine_mode) find_mode (v->string, infile)); else @@ -373,12 +377,12 @@ apply_mode_maps (rtx x, struct map_value *mode_maps, struct mapping *macro, } } -/* Given that MACRO is being expanded as VALUE, apply the appropriate +/* Given that ITERATOR 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) +apply_iterator_to_string (const char *string, struct mapping *iterator, int value) { char *base, *copy, *p, *start, *end; struct map_value *v; @@ -392,7 +396,7 @@ apply_macro_to_string (const char *string, struct mapping *macro, int value) p = start + 1; *end = 0; - v = map_attr_string (p, macro, value); + v = map_attr_string (p, iterator, value); *end = '>'; if (v == 0) continue; @@ -413,18 +417,18 @@ apply_macro_to_string (const char *string, struct mapping *macro, int value) return string; } -/* Return a copy of ORIGINAL in which all uses of MACRO have been +/* Return a copy of ORIGINAL in which all uses of ITERATOR have been replaced by VALUE. MODE_MAPS holds information about attribute strings used for modes. INFILE is used for error messages. This sets *UNKNOWN_MODE_ATTR to the value of an unknown mode attribute, and does not change it otherwise. */ static rtx -apply_macro_to_rtx (rtx original, struct mapping *macro, int value, - struct map_value *mode_maps, FILE *infile, - const char **unknown_mode_attr) +apply_iterator_to_rtx (rtx original, struct mapping *iterator, int value, + struct map_value *mode_maps, FILE *infile, + const char **unknown_mode_attr) { - struct macro_group *group; + struct iterator_group *group; const char *format_ptr; int i, j; rtx x; @@ -439,12 +443,12 @@ apply_macro_to_rtx (rtx original, struct mapping *macro, int value, memcpy (x, original, RTX_CODE_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); + group = iterator->group; + if (group->uses_iterator_p (x, iterator->index + group->num_builtins)) + group->apply_iterator (x, value); if (mode_maps) - apply_mode_maps (x, mode_maps, macro, value, infile, unknown_mode_attr); + apply_mode_maps (x, mode_maps, iterator, value, infile, unknown_mode_attr); /* Change each string and recursively change each rtx. */ format_ptr = GET_RTX_FORMAT (bellwether_code); @@ -452,18 +456,18 @@ apply_macro_to_rtx (rtx original, struct mapping *macro, int value, switch (format_ptr[i]) { case 'T': - XTMPL (x, i) = apply_macro_to_string (XTMPL (x, i), macro, value); + XTMPL (x, i) = apply_iterator_to_string (XTMPL (x, i), iterator, value); break; case 'S': case 's': - XSTR (x, i) = apply_macro_to_string (XSTR (x, i), macro, value); + XSTR (x, i) = apply_iterator_to_string (XSTR (x, i), iterator, value); break; case 'e': - XEXP (x, i) = apply_macro_to_rtx (XEXP (x, i), macro, value, - mode_maps, infile, - unknown_mode_attr); + XEXP (x, i) = apply_iterator_to_rtx (XEXP (x, i), iterator, value, + mode_maps, infile, + unknown_mode_attr); break; case 'V': @@ -472,10 +476,10 @@ apply_macro_to_rtx (rtx original, struct mapping *macro, int value, { 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, mode_maps, - infile, - unknown_mode_attr); + XVECEXP (x, i, j) = apply_iterator_to_rtx (XVECEXP (original, i, j), + iterator, value, mode_maps, + infile, + unknown_mode_attr); } break; @@ -485,20 +489,20 @@ apply_macro_to_rtx (rtx original, struct mapping *macro, int value, return x; } -/* Return true if X (or some subexpression of X) uses macro MACRO. */ +/* Return true if X (or some subexpression of X) uses iterator ITERATOR. */ static bool -uses_macro_p (rtx x, struct mapping *macro) +uses_iterator_p (rtx x, struct mapping *iterator) { - struct macro_group *group; + struct iterator_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)) + group = iterator->group; + if (group->uses_iterator_p (x, iterator->index + group->num_builtins)) return true; format_ptr = GET_RTX_FORMAT (BELLWETHER_CODE (GET_CODE (x))); @@ -506,7 +510,7 @@ uses_macro_p (rtx x, struct mapping *macro) switch (format_ptr[i]) { case 'e': - if (uses_macro_p (XEXP (x, i), macro)) + if (uses_iterator_p (XEXP (x, i), iterator)) return true; break; @@ -514,7 +518,7 @@ uses_macro_p (rtx x, struct mapping *macro) case 'E': if (XVEC (x, i)) for (j = 0; j < XVECLEN (x, i); j++) - if (uses_macro_p (XVECEXP (x, i, j), macro)) + if (uses_iterator_p (XVECEXP (x, i, j), iterator)) return true; break; @@ -566,37 +570,37 @@ add_condition_to_rtx (rtx x, const char *extra) } /* A htab_traverse callback. Search the EXPR_LIST given by DATA - for rtxes that use the macro in *SLOT. Replace each such rtx + for rtxes that use the iterator in *SLOT. Replace each such rtx with a list of expansions. */ static int -apply_macro_traverse (void **slot, void *data) +apply_iterator_traverse (void **slot, void *data) { - struct macro_traverse_data *mtd = (struct macro_traverse_data *) data; - struct mapping *macro; + struct iterator_traverse_data *mtd = (struct iterator_traverse_data *) data; + struct mapping *iterator; struct map_value *v; rtx elem, new_elem, original, x; - macro = (struct mapping *) *slot; + iterator = (struct mapping *) *slot; for (elem = mtd->queue; elem != 0; elem = XEXP (elem, 1)) - if (uses_macro_p (XEXP (elem, 0), macro)) + if (uses_iterator_p (XEXP (elem, 0), iterator)) { - /* For each macro we expand, we set UNKNOWN_MODE_ATTR to NULL. - If apply_macro_rtx finds an unknown attribute for a mode, + /* For each iterator we expand, we set UNKNOWN_MODE_ATTR to NULL. + If apply_iterator_rtx finds an unknown attribute for a mode, it will set it to the attribute. We want to know whether the attribute is unknown after we have expanded all - possible macros, so setting it to NULL here gives us the + possible iterators, so setting it to NULL here gives us the right result when the hash table traversal is complete. */ mtd->unknown_mode_attr = NULL; original = XEXP (elem, 0); - for (v = macro->values; v != 0; v = v->next) + for (v = iterator->values; v != 0; v = v->next) { - x = apply_macro_to_rtx (original, macro, v->number, - mtd->mode_maps, mtd->infile, - &mtd->unknown_mode_attr); + x = apply_iterator_to_rtx (original, iterator, v->number, + mtd->mode_maps, mtd->infile, + &mtd->unknown_mode_attr); add_condition_to_rtx (x, v->string); - if (v != macro->values) + if (v != iterator->values) { /* Insert a new EXPR_LIST node after ELEM and put the new expansion there. */ @@ -616,7 +620,7 @@ apply_macro_traverse (void **slot, void *data) is the file that defined the mapping. */ static struct mapping * -add_mapping (struct macro_group *group, htab_t table, +add_mapping (struct iterator_group *group, htab_t table, const char *name, FILE *infile) { struct mapping *m; @@ -657,7 +661,7 @@ add_map_value (struct map_value **end_ptr, int number, const char *string) /* Do one-time initialization of the mode and code attributes. */ static void -initialize_macros (void) +initialize_iterators (void) { struct mapping *lower, *upper; struct map_value **lower_ptr, **upper_ptr; @@ -665,18 +669,18 @@ initialize_macros (void) 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.iterators = 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; + modes.uses_iterator_p = uses_mode_iterator_p; + modes.apply_iterator = apply_mode_iterator; 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.iterators = 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; + codes.uses_iterator_p = uses_code_iterator_p; + codes.apply_iterator = apply_code_iterator; lower = add_mapping (&modes, modes.attrs, "mode", 0); upper = add_mapping (&modes, modes.attrs, "MODE", 0); @@ -783,6 +787,9 @@ join_c_conditions (const char *cond1, const char *cond2) if (cond2 == 0 || cond2[0] == 0) return cond1; + if (strcmp (cond1, cond2) == 0) + return cond1; + result = concat ("(", cond1, ") && (", cond2, ")", NULL); obstack_ptr_grow (&joined_conditions_obstack, result); obstack_ptr_grow (&joined_conditions_obstack, cond1); @@ -1284,11 +1291,11 @@ validate_const_int (FILE *infile, const char *string) identifier. INFILE is the file that contained NAME. */ static int -find_macro (struct macro_group *group, const char *name, FILE *infile) +find_iterator (struct iterator_group *group, const char *name, FILE *infile) { struct mapping *m; - m = (struct mapping *) htab_find (group->macros, &name); + m = (struct mapping *) htab_find (group->iterators, &name); if (m != 0) return m->index + group->num_builtins; return group->find_builtin (name, infile); @@ -1305,7 +1312,7 @@ find_macro (struct macro_group *group, const char *name, FILE *infile) (which belongs to GROUP) and return it. */ static struct mapping * -read_mapping (struct macro_group *group, htab_t table, FILE *infile) +read_mapping (struct iterator_group *group, htab_t table, FILE *infile) { char tmp_char[256]; struct mapping *m; @@ -1356,24 +1363,24 @@ read_mapping (struct macro_group *group, htab_t table, FILE *infile) 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. */ +/* Check newly-created code iterator ITERATOR to see whether every code has the + same format. Initialize the iterator's entry in bellwether_codes. */ static void -check_code_macro (struct mapping *macro, FILE *infile) +check_code_iterator (struct mapping *iterator, FILE *infile) { struct map_value *v; enum rtx_code bellwether; - bellwether = (enum rtx_code) macro->values->number; - for (v = macro->values->next; v != 0; v = v->next) + bellwether = (enum rtx_code) iterator->values->number; + for (v = iterator->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); + fatal_with_file_and_line (infile, "code iterator `%s' combines " + "different rtx formats", iterator->name); bellwether_codes = XRESIZEVEC (enum rtx_code, bellwether_codes, - macro->index + 1); - bellwether_codes[macro->index] = bellwether; + iterator->index + 1); + bellwether_codes[iterator->index] = bellwether; } /* Read an rtx in printed representation from INFILE and store its @@ -1394,7 +1401,7 @@ read_rtx (FILE *infile, rtx *x, int *lineno) /* Do one-time initialization. */ if (queue_head == 0) { - initialize_macros (); + initialize_iterators (); obstack_init (&string_obstack); queue_head = rtx_alloc (EXPR_LIST); ptr_locs = htab_create (161, leading_ptr_hash, leading_ptr_eq_p, 0); @@ -1407,7 +1414,7 @@ read_rtx (FILE *infile, rtx *x, int *lineno) if (queue_next == 0) { struct map_value *mode_maps; - struct macro_traverse_data mtd; + struct iterator_traverse_data mtd; rtx from_file; c = read_skip_spaces (infile); @@ -1431,8 +1438,8 @@ read_rtx (FILE *infile, rtx *x, int *lineno) mtd.mode_maps = mode_maps; mtd.infile = infile; mtd.unknown_mode_attr = mode_maps ? mode_maps->string : NULL; - htab_traverse (modes.macros, apply_macro_traverse, &mtd); - htab_traverse (codes.macros, apply_macro_traverse, &mtd); + htab_traverse (modes.iterators, apply_iterator_traverse, &mtd); + htab_traverse (codes.iterators, apply_iterator_traverse, &mtd); if (mtd.unknown_mode_attr) fatal_with_file_and_line (infile, "undefined attribute '%s' used for mode", @@ -1447,7 +1454,7 @@ read_rtx (FILE *infile, rtx *x, int *lineno) } /* Subroutine of read_rtx that reads one construct from INFILE but - doesn't apply any macros. */ + doesn't apply any iterators. */ static rtx read_rtx_1 (FILE *infile, struct map_value **mode_maps) @@ -1476,7 +1483,7 @@ read_rtx_1 (FILE *infile, struct map_value **mode_maps) if (c == EOF) return 0; - + if (c != '(') fatal_expected_char (infile, '(', c); @@ -1504,9 +1511,9 @@ read_rtx_1 (FILE *infile, struct map_value **mode_maps) read_mapping (&modes, modes.attrs, infile); goto again; } - if (strcmp (tmp_char, "define_mode_macro") == 0) + if (strcmp (tmp_char, "define_mode_iterator") == 0) { - read_mapping (&modes, modes.macros, infile); + read_mapping (&modes, modes.iterators, infile); goto again; } if (strcmp (tmp_char, "define_code_attr") == 0) @@ -1514,12 +1521,13 @@ read_rtx_1 (FILE *infile, struct map_value **mode_maps) read_mapping (&codes, codes.attrs, infile); goto again; } - if (strcmp (tmp_char, "define_code_macro") == 0) + if (strcmp (tmp_char, "define_code_iterator") == 0) { - check_code_macro (read_mapping (&codes, codes.macros, infile), infile); + check_code_iterator (read_mapping (&codes, codes.iterators, infile), + infile); goto again; } - real_code = (enum rtx_code) find_macro (&codes, tmp_char, infile); + real_code = (enum rtx_code) find_iterator (&codes, tmp_char, infile); bellwether_code = BELLWETHER_CODE (real_code); /* If we end up with an insn expression then we free this space below. */ @@ -1537,7 +1545,7 @@ read_rtx_1 (FILE *infile, struct map_value **mode_maps) read_name (tmp_char, infile); if (tmp_char[0] != '<' || tmp_char[strlen (tmp_char) - 1] != '>') - mode = find_macro (&modes, tmp_char, infile); + mode = find_iterator (&modes, tmp_char, infile); else mode = mode_attr_index (mode_maps, tmp_char); PUT_MODE (return_rtx, (enum machine_mode) mode); @@ -1587,6 +1595,8 @@ read_rtx_1 (FILE *infile, struct map_value **mode_maps) obstack_init (&vector_stack); while ((c = read_skip_spaces (infile)) && c != ']') { + if (c == EOF) + fatal_expected_char (infile, ']', c); ungetc (c, infile); list_counter++; obstack_ptr_grow (&vector_stack, read_rtx_1 (infile, mode_maps)); @@ -1730,7 +1740,7 @@ read_rtx_variadic (FILE *infile, struct map_value **mode_maps, rtx form) XEXP (q, 0) = XEXP (p, 1); XEXP (q, 1) = read_rtx_1 (infile, mode_maps); - + XEXP (p, 1) = q; p = q; c = read_skip_spaces (infile);