Mercurial > hg > CbC > CbC_gcc
diff gcc/read-rtl.c @ 111:04ced10e8804
gcc 7
| author | kono |
|---|---|
| date | Fri, 27 Oct 2017 22:46:09 +0900 |
| parents | f6334be47118 |
| children | 84e7813d76e9 |
line wrap: on
line diff
--- a/gcc/read-rtl.c Sun Aug 21 07:07:55 2011 +0900 +++ b/gcc/read-rtl.c Fri Oct 27 22:46:09 2017 +0900 @@ -1,7 +1,5 @@ /* RTL reader for GCC. - Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000, 2001, 2002, - 2003, 2004, 2005, 2007, 2008, 2010 - Free Software Foundation, Inc. + Copyright (C) 1987-2017 Free Software Foundation, Inc. This file is part of GCC. @@ -19,7 +17,13 @@ along with GCC; see the file COPYING3. If not see <http://www.gnu.org/licenses/>. */ +/* This file is compiled twice: once for the generator programs + once for the compiler. */ +#ifdef GENERATOR_FILE #include "bconfig.h" +#else +#include "config.h" +#endif /* Disable rtl checking; it conflicts with the iterator handling. */ #undef ENABLE_RTL_CHECKING @@ -29,10 +33,15 @@ #include "tm.h" #include "rtl.h" #include "obstack.h" -#include "hashtab.h" #include "read-md.h" #include "gensupport.h" +#ifndef GENERATOR_FILE +#include "function.h" +#include "memmodel.h" +#include "emit-rtl.h" +#endif + /* One element in a singly-linked list of (integer, string) pairs. */ struct map_value { struct map_value *next; @@ -41,7 +50,7 @@ }; /* 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 + The integers are iterator values; the strings are either C conditions or attribute values. */ struct mapping { /* The name of the iterator or attribute. */ @@ -50,82 +59,89 @@ /* The group (modes or codes) to which the iterator or attribute belongs. */ struct iterator_group *group; - /* Gives a unique number to the attribute or iterator. Numbers are - allocated consecutively, starting at 0. */ - int index; - /* The list of (integer, string) pairs. */ struct map_value *values; + + /* For iterators, records the current value of the iterator. */ + struct map_value *current_value; }; -/* A structure for abstracting the common parts of code and mode iterators. */ +/* A structure for abstracting the common parts of iterators. */ struct iterator_group { - /* Tables of "mapping" structures, one for attributes and one for iterators. */ + /* 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 an iterator placeholder). */ - int num_builtins; - - /* Treat the given string as the name of a standard mode or code and + /* Treat the given string as the name of a standard mode, etc., and return its integer value. */ int (*find_builtin) (const char *); - /* Return true if the given rtx uses the given mode or code. */ - bool (*uses_iterator_p) (rtx, int); - - /* Make the given rtx use the given mode or code. */ - void (*apply_iterator) (rtx, int); + /* Make the given rtx use the iterator value given by the third argument. + If the iterator applies to operands, the second argument gives the + operand index, otherwise it is ignored. */ + void (*apply_iterator) (rtx, unsigned int, int); }; -/* A structure used to pass data from read_rtx to apply_iterator_traverse - via htab_traverse. */ -struct iterator_traverse_data { - /* Instruction queue. */ - rtx queue; - /* Attributes seen for modes. */ - struct map_value *mode_maps; - /* The last unknown attribute used as a mode. */ - const char *unknown_mode_attr; +/* Records one use of an iterator. */ +struct iterator_use { + /* The iterator itself. */ + struct mapping *iterator; + + /* The location of the use, as passed to the apply_iterator callback. + The index is the number of the operand that used the iterator + if applicable, otherwise it is ignored. */ + rtx x; + unsigned int index; }; -/* 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]) +/* Records one use of an attribute (the "<[iterator:]attribute>" syntax) + in a non-string rtx field. */ +struct attribute_use { + /* The group that describes the use site. */ + struct iterator_group *group; + + /* The name of the attribute, possibly with an "iterator:" prefix. */ + const char *value; + + /* The location of the use, as passed to GROUP's apply_iterator callback. + The index is the number of the operand that used the iterator + if applicable, otherwise it is ignored. */ + rtx x; + unsigned int index; +}; -static int find_mode (const char *); -static bool uses_mode_iterator_p (rtx, int); -static void apply_mode_iterator (rtx, int); -static int find_code (const char *); -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 *, 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_iterator_traverse (void **, void *); -static struct mapping *add_mapping (struct iterator_group *, htab_t t, - const char *); -static struct map_value **add_map_value (struct map_value **, - int, const char *); -static void initialize_iterators (void); -static void read_conditions (void); +/* This struct is used to link subst_attr named ATTR_NAME with + corresponding define_subst named ITER_NAME. */ +struct subst_attr_to_iter_mapping +{ + char *attr_name; + char *iter_name; +}; + +/* Hash-table to store links between subst-attributes and + define_substs. */ +htab_t subst_attr_to_iter_map = NULL; +/* This global stores name of subst-iterator which is currently being + processed. */ +const char *current_iterator_name; + static void validate_const_int (const char *); -static int find_iterator (struct iterator_group *, const char *); -static struct mapping *read_mapping (struct iterator_group *, htab_t); -static void check_code_iterator (struct mapping *); -static rtx read_rtx_code (const char *, struct map_value **); -static rtx read_nested_rtx (struct map_value **); -static rtx read_rtx_variadic (struct map_value **, rtx); +static void one_time_initialization (void); + +/* Global singleton. */ +rtx_reader *rtx_reader_ptr = NULL; /* The mode and code iterator structures. */ -static struct iterator_group modes, codes; +static struct iterator_group modes, codes, ints, substs; + +/* All iterators used in the current rtx. */ +static vec<mapping *> current_iterators; -/* Index I is the value of BELLWETHER_CODE (I + NUM_RTX_CODE). */ -static enum rtx_code *bellwether_codes; +/* The list of all iterator uses in the current rtx. */ +static vec<iterator_use> iterator_uses; + +/* The list of all attribute uses in the current rtx. */ +static vec<attribute_use> attribute_uses; /* Implementations of the iterator_group callbacks for modes. */ @@ -141,17 +157,30 @@ fatal_with_file_and_line ("unknown mode `%s'", name); } -static bool -uses_mode_iterator_p (rtx x, int mode) +static void +apply_mode_iterator (rtx x, unsigned int, int mode) { - return (int) GET_MODE (x) == mode; + PUT_MODE (x, (machine_mode) mode); } -static void -apply_mode_iterator (rtx x, int mode) -{ - PUT_MODE (x, (enum machine_mode) mode); -} +/* In compact dumps, the code of insns is prefixed with "c", giving "cinsn", + "cnote" etc, and CODE_LABEL is special-cased as "clabel". */ + +struct compact_insn_name { + RTX_CODE code; + const char *name; +}; + +static const compact_insn_name compact_insn_names[] = { + { DEBUG_INSN, "cdebug_insn" }, + { INSN, "cinsn" }, + { JUMP_INSN, "cjump_insn" }, + { CALL_INSN, "ccall_insn" }, + { JUMP_TABLE_DATA, "cjump_table_data" }, + { BARRIER, "cbarrier" }, + { CODE_LABEL, "clabel" }, + { NOTE, "cnote" } +}; /* Implementations of the iterator_group callbacks for codes. */ @@ -164,125 +193,190 @@ if (strcmp (GET_RTX_NAME (i), name) == 0) return i; + for (i = 0; i < (signed)ARRAY_SIZE (compact_insn_names); i++) + if (strcmp (compact_insn_names[i].name, name) == 0) + return compact_insn_names[i].code; + fatal_with_file_and_line ("unknown rtx code `%s'", name); } -static bool -uses_code_iterator_p (rtx x, int code) -{ - return (int) GET_CODE (x) == code; -} - static void -apply_code_iterator (rtx x, int code) +apply_code_iterator (rtx x, unsigned int, int code) { PUT_CODE (x, (enum rtx_code) code); } -/* Map a code or mode attribute string P to the underlying string for - ITERATOR and VALUE. */ +/* Implementations of the iterator_group callbacks for ints. */ + +/* Since GCC does not construct a table of valid constants, + we have to accept any int as valid. No cross-checking can + be done. */ + +static int +find_int (const char *name) +{ + validate_const_int (name); + return atoi (name); +} + +static void +apply_int_iterator (rtx x, unsigned int index, int value) +{ + XINT (x, index) = value; +} + +#ifdef GENERATOR_FILE + +/* This routine adds attribute or does nothing depending on VALUE. When + VALUE is 1, it does nothing - the first duplicate of original + template is kept untouched when it's subjected to a define_subst. + When VALUE isn't 1, the routine modifies RTL-template RT, adding + attribute, named exactly as define_subst, which later will be + applied. If such attribute has already been added, then no the + routine has no effect. */ +static void +apply_subst_iterator (rtx rt, unsigned int, int value) +{ + rtx new_attr; + rtvec attrs_vec, new_attrs_vec; + int i; + if (value == 1) + return; + gcc_assert (GET_CODE (rt) == DEFINE_INSN + || GET_CODE (rt) == DEFINE_EXPAND); + + attrs_vec = XVEC (rt, 4); + + /* If we've already added attribute 'current_iterator_name', then we + have nothing to do now. */ + if (attrs_vec) + { + for (i = 0; i < GET_NUM_ELEM (attrs_vec); i++) + { + if (strcmp (XSTR (attrs_vec->elem[i], 0), current_iterator_name) == 0) + return; + } + } + + /* Add attribute with subst name - it serves as a mark for + define_subst which later would be applied to this pattern. */ + new_attr = rtx_alloc (SET_ATTR); + PUT_CODE (new_attr, SET_ATTR); + XSTR (new_attr, 0) = xstrdup (current_iterator_name); + XSTR (new_attr, 1) = xstrdup ("yes"); + + if (!attrs_vec) + { + new_attrs_vec = rtvec_alloc (1); + new_attrs_vec->elem[0] = new_attr; + } + else + { + new_attrs_vec = rtvec_alloc (GET_NUM_ELEM (attrs_vec) + 1); + memcpy (&new_attrs_vec->elem[0], &attrs_vec->elem[0], + GET_NUM_ELEM (attrs_vec) * sizeof (rtx)); + new_attrs_vec->elem[GET_NUM_ELEM (attrs_vec)] = new_attr; + } + XVEC (rt, 4) = new_attrs_vec; +} + +/* Map subst-attribute ATTR to subst iterator ITER. */ + +static void +bind_subst_iter_and_attr (const char *iter, const char *attr) +{ + struct subst_attr_to_iter_mapping *value; + void **slot; + if (!subst_attr_to_iter_map) + subst_attr_to_iter_map = + htab_create (1, leading_string_hash, leading_string_eq_p, 0); + value = XNEW (struct subst_attr_to_iter_mapping); + value->attr_name = xstrdup (attr); + value->iter_name = xstrdup (iter); + slot = htab_find_slot (subst_attr_to_iter_map, value, INSERT); + *slot = value; +} + +#endif /* #ifdef GENERATOR_FILE */ + +/* Return name of a subst-iterator, corresponding to subst-attribute ATTR. */ + +static char* +find_subst_iter_by_attr (const char *attr) +{ + char *iter_name = NULL; + struct subst_attr_to_iter_mapping *value; + value = (struct subst_attr_to_iter_mapping*) + htab_find (subst_attr_to_iter_map, &attr); + if (value) + iter_name = value->iter_name; + return iter_name; +} + +/* Map attribute string P to its current value. Return null if the attribute + isn't known. */ static struct map_value * -map_attr_string (const char *p, struct mapping *iterator, int value) +map_attr_string (const char *p) { const char *attr; + struct mapping *iterator; + unsigned int i; struct mapping *m; struct map_value *v; + int iterator_name_len; - /* If there's a "iterator:" prefix, check whether the iterator name matches. - Set ATTR to the start of the attribute name. */ + /* Peel off any "iterator:" prefix. Set ATTR to the start of the + attribute name. */ attr = strchr (p, ':'); if (attr == 0) - attr = p; + { + iterator_name_len = -1; + attr = p; + } else { - if (strncmp (p, iterator->name, attr - p) != 0 - || iterator->name[attr - p] != 0) - return 0; + iterator_name_len = attr - p; attr++; } - /* Find the attribute specification. */ - m = (struct mapping *) htab_find (iterator->group->attrs, &attr); - if (m == 0) - return 0; - - /* Find the attribute value for VALUE. */ - for (v = m->values; v != 0; v = v->next) - if (v->number == value) - break; - - return v; -} - -/* Given an attribute string used as a machine mode, return an index - to store in the machine mode to be translated by - apply_iterator_to_rtx. */ + FOR_EACH_VEC_ELT (current_iterators, i, iterator) + { + /* If an iterator name was specified, check that it matches. */ + if (iterator_name_len >= 0 + && (strncmp (p, iterator->name, iterator_name_len) != 0 + || iterator->name[iterator_name_len] != 0)) + continue; -static unsigned int -mode_attr_index (struct map_value **mode_maps, const char *string) -{ - char *p; - struct map_value *mv; - - /* Copy the attribute string into permanent storage, without the - angle brackets around it. */ - obstack_grow0 (&string_obstack, string + 1, strlen (string) - 2); - p = XOBFINISH (&string_obstack, char *); - - mv = XNEW (struct map_value); - mv->number = *mode_maps == 0 ? 0 : (*mode_maps)->number + 1; - mv->string = p; - mv->next = *mode_maps; - *mode_maps = mv; - - /* We return a code which we can map back into this string: the - number of machine modes + the number of mode iterators + the index - we just used. */ - return MAX_MACHINE_MODE + htab_elements (modes.iterators) + mv->number; + /* Find the attribute specification. */ + m = (struct mapping *) htab_find (iterator->group->attrs, &attr); + if (m) + { + /* In contrast to code/mode/int iterators, attributes of subst + iterators are linked to one specific subst-iterator. So, if + we are dealing with subst-iterator, we should check if it's + the one which linked with the given attribute. */ + if (iterator->group == &substs) + { + char *iter_name = find_subst_iter_by_attr (attr); + if (strcmp (iter_name, iterator->name) != 0) + continue; + } + /* Find the attribute value associated with the current + iterator value. */ + for (v = m->values; v; v = v->next) + if (v->number == iterator->current_value->number) + return v; + } + } + return NULL; } -/* Apply MODE_MAPS to the top level of X, expanding cases where an - 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. - 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 *iterator, - int value, const char **unknown) -{ - unsigned int offset; - int indx; - struct map_value *pm; - - offset = MAX_MACHINE_MODE + htab_elements (modes.iterators); - if (GET_MODE (x) < offset) - return; +/* Apply the current iterator values to STRING. Return the new string + if any changes were needed, otherwise return STRING itself. */ - indx = GET_MODE (x) - offset; - for (pm = mode_maps; pm; pm = pm->next) - { - if (pm->number == indx) - { - struct map_value *v; - - v = map_attr_string (pm->string, iterator, value); - if (v) - PUT_MODE (x, (enum machine_mode) find_mode (v->string)); - else - *unknown = pm->string; - return; - } - } -} - -/* 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_iterator_to_string (const char *string, struct mapping *iterator, int value) +const char * +md_reader::apply_iterator_to_string (const char *string) { char *base, *copy, *p, *start, *end; struct map_value *v; @@ -296,76 +390,62 @@ p = start + 1; *end = 0; - v = map_attr_string (p, iterator, value); + v = map_attr_string (p); *end = '>'; 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)); + obstack_grow (&m_string_obstack, base, start - base); + obstack_grow (&m_string_obstack, v->string, strlen (v->string)); base = end + 1; } if (base != copy) { - obstack_grow (&string_obstack, base, strlen (base) + 1); - copy = XOBFINISH (&string_obstack, char *); + obstack_grow (&m_string_obstack, base, strlen (base) + 1); + copy = XOBFINISH (&m_string_obstack, char *); copy_md_ptr_loc (copy, string); return copy; } return string; } -/* 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. This sets *UNKNOWN_MODE_ATTR to the value of - an unknown mode attribute, and does not change it otherwise. */ +/* Return a deep copy of X, substituting the current iterator + values into any strings. */ -static rtx -apply_iterator_to_rtx (rtx original, struct mapping *iterator, int value, - struct map_value *mode_maps, - const char **unknown_mode_attr) +rtx +md_reader::copy_rtx_for_iterators (rtx original) { - struct iterator_group *group; - const char *format_ptr; + const char *format_ptr, *p; 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_CODE_SIZE (bellwether_code)); - - /* Change the mode or code itself. */ - 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, iterator, value, unknown_mode_attr); + x = rtx_alloc (GET_CODE (original)); + memcpy (x, original, RTX_CODE_SIZE (GET_CODE (original))); /* Change each string and recursively change each rtx. */ - format_ptr = GET_RTX_FORMAT (bellwether_code); + format_ptr = GET_RTX_FORMAT (GET_CODE (original)); for (i = 0; format_ptr[i] != 0; i++) switch (format_ptr[i]) { case 'T': - XTMPL (x, i) = apply_iterator_to_string (XTMPL (x, i), iterator, value); + while (XTMPL (x, i) != (p = apply_iterator_to_string (XTMPL (x, i)))) + XTMPL (x, i) = p; break; case 'S': case 's': - XSTR (x, i) = apply_iterator_to_string (XSTR (x, i), iterator, value); + while (XSTR (x, i) != (p = apply_iterator_to_string (XSTR (x, i)))) + XSTR (x, i) = p; break; case 'e': - XEXP (x, i) = apply_iterator_to_rtx (XEXP (x, i), iterator, value, - mode_maps, unknown_mode_attr); + XEXP (x, i) = copy_rtx_for_iterators (XEXP (x, i)); break; case 'V': @@ -374,9 +454,8 @@ { XVEC (x, i) = rtvec_alloc (XVECLEN (original, i)); for (j = 0; j < XVECLEN (x, i); j++) - XVECEXP (x, i, j) = apply_iterator_to_rtx (XVECEXP (original, i, j), - iterator, value, mode_maps, - unknown_mode_attr); + XVECEXP (x, i, j) + = copy_rtx_for_iterators (XVECEXP (original, i, j)); } break; @@ -386,44 +465,7 @@ return x; } -/* Return true if X (or some subexpression of X) uses iterator ITERATOR. */ - -static bool -uses_iterator_p (rtx x, struct mapping *iterator) -{ - struct iterator_group *group; - const char *format_ptr; - int i, j; - - if (x == 0) - return false; - - 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))); - for (i = 0; format_ptr[i] != 0; i++) - switch (format_ptr[i]) - { - case 'e': - if (uses_iterator_p (XEXP (x, i), iterator)) - return true; - break; - - case 'V': - case 'E': - if (XVEC (x, i)) - for (j = 0; j < XVECLEN (x, i); j++) - if (uses_iterator_p (XVECEXP (x, i, j), iterator)) - return true; - break; - - default: - break; - } - return false; -} +#ifdef GENERATOR_FILE /* Return a condition that must satisfy both ORIGINAL and EXTRA. If ORIGINAL has the form "&& ..." (as used in define_insn_and_splits), assume that @@ -434,7 +476,7 @@ { if (original != 0 && original[0] == '&' && original[1] == '&') return original; - return join_c_conditions (original, extra); + return rtx_reader_ptr->join_c_conditions (original, extra); } /* Like add_condition, but applied to all conditions in rtx X. */ @@ -446,6 +488,7 @@ { case DEFINE_INSN: case DEFINE_EXPAND: + case DEFINE_SUBST: XSTR (x, 2) = add_condition_to_string (XSTR (x, 2), extra); break; @@ -466,52 +509,132 @@ } } -/* A htab_traverse callback. Search the EXPR_LIST given by DATA - for rtxes that use the iterator in *SLOT. Replace each such rtx - with a list of expansions. */ +/* Apply the current iterator values to all attribute_uses. */ + +static void +apply_attribute_uses (void) +{ + struct map_value *v; + attribute_use *ause; + unsigned int i; + + FOR_EACH_VEC_ELT (attribute_uses, i, ause) + { + v = map_attr_string (ause->value); + if (!v) + fatal_with_file_and_line ("unknown iterator value `%s'", ause->value); + ause->group->apply_iterator (ause->x, ause->index, + ause->group->find_builtin (v->string)); + } +} + +/* A htab_traverse callback for iterators. Add all used iterators + to current_iterators. */ static int -apply_iterator_traverse (void **slot, void *data) +add_current_iterators (void **slot, void *data ATTRIBUTE_UNUSED) { - struct iterator_traverse_data *mtd = (struct iterator_traverse_data *) data; struct mapping *iterator; - struct map_value *v; - rtx elem, new_elem, original, x; iterator = (struct mapping *) *slot; - for (elem = mtd->queue; elem != 0; elem = XEXP (elem, 1)) - if (uses_iterator_p (XEXP (elem, 0), iterator)) - { - /* 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 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 = iterator->values; v != 0; v = v->next) - { - x = apply_iterator_to_rtx (original, iterator, v->number, - mtd->mode_maps, - &mtd->unknown_mode_attr); - add_condition_to_rtx (x, v->string); - if (v != iterator->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; - } - } + if (iterator->current_value) + current_iterators.safe_push (iterator); return 1; } +/* Expand all iterators in the current rtx, which is given as ORIGINAL. + Build a list of expanded rtxes in the EXPR_LIST pointed to by QUEUE. */ + +static void +apply_iterators (rtx original, vec<rtx> *queue) +{ + unsigned int i; + const char *condition; + iterator_use *iuse; + struct mapping *iterator; + struct map_value *v; + rtx x; + + if (iterator_uses.is_empty ()) + { + /* Raise an error if any attributes were used. */ + apply_attribute_uses (); + queue->safe_push (original); + return; + } + + /* Clear out the iterators from the previous run. */ + FOR_EACH_VEC_ELT (current_iterators, i, iterator) + iterator->current_value = NULL; + current_iterators.truncate (0); + + /* Mark the iterators that we need this time. */ + FOR_EACH_VEC_ELT (iterator_uses, i, iuse) + iuse->iterator->current_value = iuse->iterator->values; + + /* Get the list of iterators that are in use, preserving the + definition order within each group. */ + htab_traverse (modes.iterators, add_current_iterators, NULL); + htab_traverse (codes.iterators, add_current_iterators, NULL); + htab_traverse (ints.iterators, add_current_iterators, NULL); + htab_traverse (substs.iterators, add_current_iterators, NULL); + gcc_assert (!current_iterators.is_empty ()); + + for (;;) + { + /* Apply the current iterator values. Accumulate a condition to + say when the resulting rtx can be used. */ + condition = ""; + FOR_EACH_VEC_ELT (iterator_uses, i, iuse) + { + if (iuse->iterator->group == &substs) + continue; + v = iuse->iterator->current_value; + iuse->iterator->group->apply_iterator (iuse->x, iuse->index, + v->number); + condition = rtx_reader_ptr->join_c_conditions (condition, v->string); + } + apply_attribute_uses (); + x = rtx_reader_ptr->copy_rtx_for_iterators (original); + add_condition_to_rtx (x, condition); + + /* We apply subst iterator after RTL-template is copied, as during + subst-iterator processing, we could add an attribute to the + RTL-template, and we don't want to do it in the original one. */ + FOR_EACH_VEC_ELT (iterator_uses, i, iuse) + { + v = iuse->iterator->current_value; + if (iuse->iterator->group == &substs) + { + iuse->x = x; + iuse->index = 0; + current_iterator_name = iuse->iterator->name; + iuse->iterator->group->apply_iterator (iuse->x, iuse->index, + v->number); + } + } + /* Add the new rtx to the end of the queue. */ + queue->safe_push (x); + + /* Lexicographically increment the iterator value sequence. + That is, cycle through iterator values, starting from the right, + and stopping when one of them doesn't wrap around. */ + i = current_iterators.length (); + for (;;) + { + if (i == 0) + return; + i--; + iterator = current_iterators[i]; + iterator->current_value = iterator->current_value->next; + if (iterator->current_value) + break; + iterator->current_value = iterator->values; + } + } +} +#endif /* #ifdef GENERATOR_FILE */ + /* Add a new "mapping" structure to hashtable TABLE. NAME is the name of the mapping and GROUP is the group to which it belongs. */ @@ -524,8 +647,8 @@ m = XNEW (struct mapping); m->name = xstrdup (name); m->group = group; - m->index = htab_elements (table); m->values = 0; + m->current_value = NULL; slot = htab_find_slot (table, m, INSERT); if (*slot != 0) @@ -566,19 +689,29 @@ modes.attrs = htab_create (13, leading_string_hash, leading_string_eq_p, 0); modes.iterators = htab_create (13, leading_string_hash, leading_string_eq_p, 0); - modes.num_builtins = MAX_MACHINE_MODE; modes.find_builtin = find_mode; - modes.uses_iterator_p = uses_mode_iterator_p; modes.apply_iterator = apply_mode_iterator; codes.attrs = htab_create (13, leading_string_hash, leading_string_eq_p, 0); codes.iterators = htab_create (13, leading_string_hash, leading_string_eq_p, 0); - codes.num_builtins = NUM_RTX_CODE; codes.find_builtin = find_code; - codes.uses_iterator_p = uses_code_iterator_p; codes.apply_iterator = apply_code_iterator; + ints.attrs = htab_create (13, leading_string_hash, leading_string_eq_p, 0); + ints.iterators = htab_create (13, leading_string_hash, + leading_string_eq_p, 0); + ints.find_builtin = find_int; + ints.apply_iterator = apply_int_iterator; + + substs.attrs = htab_create (13, leading_string_hash, leading_string_eq_p, 0); + substs.iterators = htab_create (13, leading_string_hash, + leading_string_eq_p, 0); + substs.find_builtin = find_int; /* We don't use it, anyway. */ +#ifdef GENERATOR_FILE + substs.apply_iterator = apply_subst_iterator; +#endif + lower = add_mapping (&modes, modes.attrs, "mode"); upper = add_mapping (&modes, modes.attrs, "MODE"); lower_ptr = &lower->values; @@ -610,7 +743,7 @@ /* 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) +#if HOST_BITS_PER_WIDE_INT > HOST_BITS_PER_LONG && !HAVE_DECL_ATOLL && !defined(HAVE_ATOQ) HOST_WIDE_INT atoll (const char *); HOST_WIDE_INT @@ -633,7 +766,7 @@ if (new_wide < tmp_wide) { /* Return INT_MAX equiv on overflow. */ - tmp_wide = (~(unsigned HOST_WIDE_INT) 0) >> 1; + tmp_wide = HOST_WIDE_INT_M1U >> 1; break; } tmp_wide = new_wide; @@ -646,6 +779,8 @@ } #endif + +#ifdef GENERATOR_FILE /* Process a define_conditions directive, starting with the optional space after the "define_conditions". The directive looks like this: @@ -659,14 +794,12 @@ generated by (the program generated by) genconditions.c, and slipped in at the beginning of the sequence of MD files read by most of the other generators. */ -static void -read_conditions (void) +void +md_reader::read_conditions () { int c; - c = read_skip_spaces (); - if (c != '[') - fatal_expected_char ('[', c); + require_char_ws ('['); while ( (c = read_skip_spaces ()) != ']') { @@ -681,18 +814,15 @@ validate_const_int (name.string); value = atoi (name.string); - c = read_skip_spaces (); - if (c != '"') - fatal_expected_char ('"', c); + require_char_ws ('"'); expr = read_quoted_string (); - c = read_skip_spaces (); - if (c != ')') - fatal_expected_char (')', c); + require_char_ws (')'); add_c_test (expr, value); } } +#endif /* #ifdef GENERATOR_FILE */ static void validate_const_int (const char *string) @@ -709,25 +839,92 @@ valid = 0; for (; *cp; cp++) if (! ISDIGIT (*cp)) - valid = 0; + { + valid = 0; + break; + } if (!valid) fatal_with_file_and_line ("invalid decimal constant \"%s\"\n", string); } -/* Search GROUP for a mode or code called NAME and return its numerical - identifier. */ +static void +validate_const_wide_int (const char *string) +{ + const char *cp; + int valid = 1; + + cp = string; + while (*cp && ISSPACE (*cp)) + cp++; + /* Skip the leading 0x. */ + if (cp[0] == '0' || cp[1] == 'x') + cp += 2; + else + valid = 0; + if (*cp == 0) + valid = 0; + for (; *cp; cp++) + if (! ISXDIGIT (*cp)) + valid = 0; + if (!valid) + fatal_with_file_and_line ("invalid hex constant \"%s\"\n", string); +} + +/* Record that X uses iterator ITERATOR. If the use is in an operand + of X, INDEX is the index of that operand, otherwise it is ignored. */ -static int -find_iterator (struct iterator_group *group, const char *name) +static void +record_iterator_use (struct mapping *iterator, rtx x, unsigned int index) +{ + struct iterator_use iuse = {iterator, x, index}; + iterator_uses.safe_push (iuse); +} + +/* Record that X uses attribute VALUE, which must match a built-in + value from group GROUP. If the use is in an operand of X, INDEX + is the index of that operand, otherwise it is ignored. */ + +static void +record_attribute_use (struct iterator_group *group, rtx x, + unsigned int index, const char *value) +{ + struct attribute_use ause = {group, value, x, index}; + attribute_uses.safe_push (ause); +} + +/* Interpret NAME as either a built-in value, iterator or attribute + for group GROUP. X and INDEX are the values to pass to GROUP's + apply_iterator callback. */ + +void +md_reader::record_potential_iterator_use (struct iterator_group *group, + rtx x, unsigned int index, + const char *name) { struct mapping *m; + size_t len; - m = (struct mapping *) htab_find (group->iterators, &name); - if (m != 0) - return m->index + group->num_builtins; - return group->find_builtin (name); + len = strlen (name); + if (name[0] == '<' && name[len - 1] == '>') + { + /* Copy the attribute string into permanent storage, without the + angle brackets around it. */ + obstack_grow0 (&m_string_obstack, name + 1, len - 2); + record_attribute_use (group, x, index, + XOBFINISH (&m_string_obstack, char *)); + } + else + { + m = (struct mapping *) htab_find (group->iterators, &name); + if (m != 0) + record_iterator_use (m, x, index); + else + group->apply_iterator (x, index, group->find_builtin (name)); + } } +#ifdef GENERATOR_FILE + /* Finish reading a declaration of the form: (define... <name> [<value1> ... <valuen>]) @@ -738,8 +935,8 @@ Represent the declaration as a "mapping" structure; add it to TABLE (which belongs to GROUP) and return it. */ -static struct mapping * -read_mapping (struct iterator_group *group, htab_t table) +struct mapping * +md_reader::read_mapping (struct iterator_group *group, htab_t table) { struct md_name name; struct mapping *m; @@ -751,9 +948,7 @@ read_name (&name); m = add_mapping (group, table, name.string); - c = read_skip_spaces (); - if (c != '[') - fatal_expected_char ('[', c); + require_char_ws ('['); /* Read each value. */ end_ptr = &m->values; @@ -773,9 +968,7 @@ /* A "(name string)" pair. */ read_name (&name); string = read_string (false); - c = read_skip_spaces (); - if (c != ')') - fatal_expected_char (')', c); + require_char_ws (')'); } number = group->find_builtin (name.string); end_ptr = add_map_value (end_ptr, number, string); @@ -786,8 +979,89 @@ return m; } +/* For iterator with name ATTR_NAME generate define_attr with values + 'yes' and 'no'. This attribute is used to mark templates to which + define_subst ATTR_NAME should be applied. This attribute is set and + defined implicitly and automatically. */ +static void +add_define_attr_for_define_subst (const char *attr_name, vec<rtx> *queue) +{ + rtx const_str, return_rtx; + + return_rtx = rtx_alloc (DEFINE_ATTR); + PUT_CODE (return_rtx, DEFINE_ATTR); + + const_str = rtx_alloc (CONST_STRING); + PUT_CODE (const_str, CONST_STRING); + XSTR (const_str, 0) = xstrdup ("no"); + + XSTR (return_rtx, 0) = xstrdup (attr_name); + XSTR (return_rtx, 1) = xstrdup ("no,yes"); + XEXP (return_rtx, 2) = const_str; + + queue->safe_push (return_rtx); +} + +/* This routine generates DEFINE_SUBST_ATTR expression with operands + ATTR_OPERANDS and places it to QUEUE. */ +static void +add_define_subst_attr (const char **attr_operands, vec<rtx> *queue) +{ + rtx return_rtx; + int i; + + return_rtx = rtx_alloc (DEFINE_SUBST_ATTR); + PUT_CODE (return_rtx, DEFINE_SUBST_ATTR); + + for (i = 0; i < 4; i++) + XSTR (return_rtx, i) = xstrdup (attr_operands[i]); + + queue->safe_push (return_rtx); +} + +/* Read define_subst_attribute construction. It has next form: + (define_subst_attribute <attribute_name> <iterator_name> <value1> <value2>) + Attribute is substituted with value1 when no subst is applied and with + value2 in the opposite case. + Attributes are added to SUBST_ATTRS_TABLE. + In case the iterator is encountered for the first time, it's added to + SUBST_ITERS_TABLE. Also, implicit define_attr is generated. */ + +static void +read_subst_mapping (htab_t subst_iters_table, htab_t subst_attrs_table, + vec<rtx> *queue) +{ + struct mapping *m; + struct map_value **end_ptr; + const char *attr_operands[4]; + int i; + + for (i = 0; i < 4; i++) + attr_operands[i] = rtx_reader_ptr->read_string (false); + + add_define_subst_attr (attr_operands, queue); + + bind_subst_iter_and_attr (attr_operands[1], attr_operands[0]); + + m = (struct mapping *) htab_find (substs.iterators, &attr_operands[1]); + if (!m) + { + m = add_mapping (&substs, subst_iters_table, attr_operands[1]); + end_ptr = &m->values; + end_ptr = add_map_value (end_ptr, 1, ""); + end_ptr = add_map_value (end_ptr, 2, ""); + + add_define_attr_for_define_subst (attr_operands[1], queue); + } + + m = add_mapping (&substs, subst_attrs_table, attr_operands[0]); + end_ptr = &m->values; + end_ptr = add_map_value (end_ptr, 1, attr_operands[2]); + end_ptr = add_map_value (end_ptr, 2, attr_operands[3]); +} + /* Check newly-created code iterator ITERATOR to see whether every code has the - same format. Initialize the iterator's entry in bellwether_codes. */ + same format. */ static void check_code_iterator (struct mapping *iterator) @@ -800,10 +1074,6 @@ if (strcmp (GET_RTX_FORMAT (bellwether), GET_RTX_FORMAT (v->number)) != 0) fatal_with_file_and_line ("code iterator `%s' combines " "different rtx formats", iterator->name); - - bellwether_codes = XRESIZEVEC (enum rtx_code, bellwether_codes, - iterator->index + 1); - bellwether_codes[iterator->index] = bellwether; } /* Read an rtx-related declaration from the MD file, given that it @@ -812,19 +1082,8 @@ store the list of rtxes as an EXPR_LIST in *X. */ bool -read_rtx (const char *rtx_name, rtx *x) +rtx_reader::read_rtx (const char *rtx_name, vec<rtx> *rtxen) { - static rtx queue_head; - struct map_value *mode_maps; - struct iterator_traverse_data mtd; - - /* Do one-time initialization. */ - if (queue_head == 0) - { - initialize_iterators (); - queue_head = rtx_alloc (EXPR_LIST); - } - /* Handle various rtx-related declarations that aren't themselves encoded as rtxes. */ if (strcmp (rtx_name, "define_conditions") == 0) @@ -852,39 +1111,143 @@ check_code_iterator (read_mapping (&codes, codes.iterators)); return false; } + if (strcmp (rtx_name, "define_int_attr") == 0) + { + read_mapping (&ints, ints.attrs); + return false; + } + if (strcmp (rtx_name, "define_int_iterator") == 0) + { + read_mapping (&ints, ints.iterators); + return false; + } + if (strcmp (rtx_name, "define_subst_attr") == 0) + { + read_subst_mapping (substs.iterators, substs.attrs, rtxen); - mode_maps = 0; - XEXP (queue_head, 0) = read_rtx_code (rtx_name, &mode_maps); - XEXP (queue_head, 1) = 0; + /* READ_SUBST_MAPPING could generate a new DEFINE_ATTR. Return + TRUE to process it. */ + return true; + } + + apply_iterators (rtx_reader_ptr->read_rtx_code (rtx_name), rtxen); + iterator_uses.truncate (0); + attribute_uses.truncate (0); + + return true; +} + +#endif /* #ifdef GENERATOR_FILE */ + +/* Do one-time initialization. */ + +static void +one_time_initialization (void) +{ + static bool initialized = false; + + if (!initialized) + { + initialize_iterators (); + initialized = true; + } +} + +/* Consume characters until encountering a character in TERMINATOR_CHARS, + consuming the terminator character if CONSUME_TERMINATOR is true. + Return all characters before the terminator as an allocated buffer. */ - mtd.queue = queue_head; - mtd.mode_maps = mode_maps; - mtd.unknown_mode_attr = mode_maps ? mode_maps->string : NULL; - 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 ("undefined attribute '%s' used for mode", - mtd.unknown_mode_attr); +char * +rtx_reader::read_until (const char *terminator_chars, bool consume_terminator) +{ + int ch = read_skip_spaces (); + unread_char (ch); + auto_vec<char> buf; + while (1) + { + ch = read_char (); + if (strchr (terminator_chars, ch)) + { + if (!consume_terminator) + unread_char (ch); + break; + } + buf.safe_push (ch); + } + buf.safe_push ('\0'); + return xstrdup (buf.address ()); +} + +/* Subroutine of read_rtx_code, for parsing zero or more flags. */ + +static void +read_flags (rtx return_rtx) +{ + while (1) + { + int ch = read_char (); + if (ch != '/') + { + unread_char (ch); + break; + } - *x = queue_head; - return true; + int flag_char = read_char (); + switch (flag_char) + { + case 's': + RTX_FLAG (return_rtx, in_struct) = 1; + break; + case 'v': + RTX_FLAG (return_rtx, volatil) = 1; + break; + case 'u': + RTX_FLAG (return_rtx, unchanging) = 1; + break; + case 'f': + RTX_FLAG (return_rtx, frame_related) = 1; + break; + case 'j': + RTX_FLAG (return_rtx, jump) = 1; + break; + case 'c': + RTX_FLAG (return_rtx, call) = 1; + break; + case 'i': + RTX_FLAG (return_rtx, return_val) = 1; + break; + default: + fatal_with_file_and_line ("unrecognized flag: `%c'", flag_char); + } + } +} + +/* Return the numeric value n for GET_REG_NOTE_NAME (n) for STRING, + or fail if STRING isn't recognized. */ + +static int +parse_reg_note_name (const char *string) +{ + for (int i = 0; i < REG_NOTE_MAX; i++) + if (0 == strcmp (string, GET_REG_NOTE_NAME (i))) + return i; + fatal_with_file_and_line ("unrecognized REG_NOTE name: `%s'", string); } /* Subroutine of read_rtx and read_nested_rtx. CODE_NAME is the name of either an rtx code or a code iterator. Parse the rest of the rtx and - return it. MODE_MAPS is as for iterator_traverse_data. */ + return it. */ -static rtx -read_rtx_code (const char *code_name, struct map_value **mode_maps) +rtx +rtx_reader::read_rtx_code (const char *code_name) { - int i; - RTX_CODE real_code, bellwether_code; + RTX_CODE code; + struct mapping *iterator = NULL; const char *format_ptr; struct md_name name; rtx return_rtx; int c; - int tmp_int; - HOST_WIDE_INT tmp_wide; + long reuse_id = -1; /* Linked list structure for making RTXs: */ struct rtx_list @@ -893,150 +1256,335 @@ rtx value; /* Value of this node. */ }; - real_code = (enum rtx_code) find_iterator (&codes, code_name); - bellwether_code = BELLWETHER_CODE (real_code); + /* Handle reuse_rtx ids e.g. "(0|scratch:DI)". */ + if (ISDIGIT (code_name[0])) + { + reuse_id = atoi (code_name); + while (char ch = *code_name++) + if (ch == '|') + break; + } + + /* Handle "reuse_rtx". */ + if (strcmp (code_name, "reuse_rtx") == 0) + { + read_name (&name); + unsigned idx = atoi (name.string); + /* Look it up by ID. */ + gcc_assert (idx < m_reuse_rtx_by_id.length ()); + return_rtx = m_reuse_rtx_by_id[idx]; + return return_rtx; + } + + /* If this code is an iterator, build the rtx using the iterator's + first value. */ +#ifdef GENERATOR_FILE + iterator = (struct mapping *) htab_find (codes.iterators, &code_name); + if (iterator != 0) + code = (enum rtx_code) iterator->values->number; + else + code = (enum rtx_code) codes.find_builtin (code_name); +#else + code = (enum rtx_code) codes.find_builtin (code_name); +#endif /* If we end up with an insn expression then we free this space below. */ - return_rtx = rtx_alloc (bellwether_code); - format_ptr = GET_RTX_FORMAT (bellwether_code); - PUT_CODE (return_rtx, real_code); + return_rtx = rtx_alloc (code); + format_ptr = GET_RTX_FORMAT (code); + memset (return_rtx, 0, RTX_CODE_SIZE (code)); + PUT_CODE (return_rtx, code); + + if (reuse_id != -1) + { + /* Store away for later reuse. */ + m_reuse_rtx_by_id.safe_grow_cleared (reuse_id + 1); + m_reuse_rtx_by_id[reuse_id] = return_rtx; + } + + if (iterator) + record_iterator_use (iterator, return_rtx, 0); + + /* Check for flags. */ + read_flags (return_rtx); + + /* Read REG_NOTE names for EXPR_LIST and INSN_LIST. */ + if ((GET_CODE (return_rtx) == EXPR_LIST + || GET_CODE (return_rtx) == INSN_LIST + || GET_CODE (return_rtx) == INT_LIST) + && !m_in_call_function_usage) + { + char ch = read_char (); + if (ch == ':') + { + read_name (&name); + PUT_MODE_RAW (return_rtx, + (machine_mode)parse_reg_note_name (name.string)); + } + else + unread_char (ch); + } /* If what follows is `: mode ', read it and store the mode in the rtx. */ - i = read_skip_spaces (); - if (i == ':') + c = read_skip_spaces (); + if (c == ':') { - unsigned int mode; - read_name (&name); - if (name.string[0] != '<' || name.string[strlen (name.string) - 1] != '>') - mode = find_iterator (&modes, name.string); - else - mode = mode_attr_index (mode_maps, name.string); - PUT_MODE (return_rtx, (enum machine_mode) mode); - if (GET_MODE (return_rtx) != mode) - fatal_with_file_and_line ("mode too large"); + record_potential_iterator_use (&modes, return_rtx, 0, name.string); } else - unread_char (i); + unread_char (c); + + if (INSN_CHAIN_CODE_P (code)) + { + read_name (&name); + INSN_UID (return_rtx) = atoi (name.string); + } - for (i = 0; format_ptr[i] != 0; i++) - switch (format_ptr[i]) + /* Use the format_ptr to parse the various operands of this rtx. */ + for (int idx = 0; format_ptr[idx] != 0; idx++) + return_rtx = read_rtx_operand (return_rtx, idx); + + /* Handle any additional information that after the regular fields + (e.g. when parsing function dumps). */ + handle_any_trailing_information (return_rtx); + + if (CONST_WIDE_INT_P (return_rtx)) + { + read_name (&name); + validate_const_wide_int (name.string); { - /* 0 means a field for internal use only. - Don't expect it to be present in the input. */ - case '0': - break; + const char *s = name.string; + int len; + int index = 0; + int gs = HOST_BITS_PER_WIDE_INT/4; + int pos; + char * buf = XALLOCAVEC (char, gs + 1); + unsigned HOST_WIDE_INT wi; + int wlen; + + /* Skip the leading spaces. */ + while (*s && ISSPACE (*s)) + s++; + + /* Skip the leading 0x. */ + gcc_assert (s[0] == '0'); + gcc_assert (s[1] == 'x'); + s += 2; + + len = strlen (s); + pos = len - gs; + wlen = (len + gs - 1) / gs; /* Number of words needed */ + + return_rtx = const_wide_int_alloc (wlen); + + while (pos > 0) + { +#if HOST_BITS_PER_WIDE_INT == 64 + sscanf (s + pos, "%16" HOST_WIDE_INT_PRINT "x", &wi); +#else + sscanf (s + pos, "%8" HOST_WIDE_INT_PRINT "x", &wi); +#endif + CWI_ELT (return_rtx, index++) = wi; + pos -= gs; + } + strncpy (buf, s, gs - pos); + buf [gs - pos] = 0; + sscanf (buf, "%" HOST_WIDE_INT_PRINT "x", &wi); + CWI_ELT (return_rtx, index++) = wi; + /* TODO: After reading, do we want to canonicalize with: + value = lookup_const_wide_int (value); ? */ + } + } + + c = read_skip_spaces (); + /* Syntactic sugar for AND and IOR, allowing Lisp-like + arbitrary number of arguments for them. */ + if (c == '(' + && (GET_CODE (return_rtx) == AND + || GET_CODE (return_rtx) == IOR)) + return read_rtx_variadic (return_rtx); + + unread_char (c); + return return_rtx; +} + +/* Subroutine of read_rtx_code. Parse operand IDX within RETURN_RTX, + based on the corresponding format character within GET_RTX_FORMAT + for the GET_CODE (RETURN_RTX), and return RETURN_RTX. + This is a virtual function, so that function_reader can override + some parsing, and potentially return a different rtx. */ + +rtx +rtx_reader::read_rtx_operand (rtx return_rtx, int idx) +{ + RTX_CODE code = GET_CODE (return_rtx); + const char *format_ptr = GET_RTX_FORMAT (code); + int c; + struct md_name name; - case 'e': - case 'u': - XEXP (return_rtx, i) = read_nested_rtx (mode_maps); - break; + switch (format_ptr[idx]) + { + /* 0 means a field for internal use only. + Don't expect it to be present in the input. */ + case '0': + if (code == REG) + ORIGINAL_REGNO (return_rtx) = REGNO (return_rtx); + break; + + case 'e': + XEXP (return_rtx, idx) = read_nested_rtx (); + break; + + case 'u': + XEXP (return_rtx, idx) = read_nested_rtx (); + break; + + case 'V': + /* 'V' is an optional vector: if a closeparen follows, + just store NULL for this element. */ + c = read_skip_spaces (); + unread_char (c); + if (c == ')') + { + XVEC (return_rtx, idx) = 0; + break; + } + /* Now process the vector. */ + /* FALLTHRU */ - case 'V': - /* 'V' is an optional vector: if a closeparen follows, - just store NULL for this element. */ + case 'E': + { + /* Obstack to store scratch vector in. */ + struct obstack vector_stack; + int list_counter = 0; + rtvec return_vec = NULL_RTVEC; + + require_char_ws ('['); + + /* Add expressions to a list, while keeping a count. */ + obstack_init (&vector_stack); + while ((c = read_skip_spaces ()) && c != ']') + { + if (c == EOF) + fatal_expected_char (']', c); + unread_char (c); + list_counter++; + obstack_ptr_grow (&vector_stack, read_nested_rtx ()); + } + if (list_counter > 0) + { + return_vec = rtvec_alloc (list_counter); + memcpy (&return_vec->elem[0], obstack_finish (&vector_stack), + list_counter * sizeof (rtx)); + } + else if (format_ptr[idx] == 'E') + fatal_with_file_and_line ("vector must have at least one element"); + XVEC (return_rtx, idx) = return_vec; + obstack_free (&vector_stack, NULL); + /* close bracket gotten */ + } + break; + + case 'S': + case 'T': + case 's': + { + char *stringbuf; + int star_if_braced; + c = read_skip_spaces (); unread_char (c); if (c == ')') { - XVEC (return_rtx, i) = 0; + /* '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, idx) = (format_ptr[idx] == 'S' ? NULL : ""); 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; + /* 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. */ + star_if_braced = (format_ptr[idx] == 'T'); - c = read_skip_spaces (); - if (c != '[') - fatal_expected_char ('[', c); + stringbuf = read_string (star_if_braced); + if (!stringbuf) + break; - /* Add expressions to a list, while keeping a count. */ - obstack_init (&vector_stack); - while ((c = read_skip_spaces ()) && c != ']') - { - if (c == EOF) - fatal_expected_char (']', c); - unread_char (c); - list_counter++; - obstack_ptr_grow (&vector_stack, read_nested_rtx (mode_maps)); - } - if (list_counter > 0) - { - return_vec = rtvec_alloc (list_counter); - memcpy (&return_vec->elem[0], obstack_finish (&vector_stack), - list_counter * sizeof (rtx)); - } - else if (format_ptr[i] == 'E') - fatal_with_file_and_line ("vector must have at least one element"); - XVEC (return_rtx, i) = return_vec; - obstack_free (&vector_stack, NULL); - /* close bracket gotten */ - } - break; - - case 'S': - case 'T': - case 's': - { - char *stringbuf; - int star_if_braced; +#ifdef GENERATOR_FILE + /* 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' + && idx == 0 + && (GET_CODE (return_rtx) == DEFINE_INSN + || GET_CODE (return_rtx) == DEFINE_INSN_AND_SPLIT)) + { + struct obstack *string_obstack = get_string_obstack (); + char line_name[20]; + const char *read_md_filename = get_filename (); + const char *fn = (read_md_filename ? read_md_filename : "rtx"); + const char *slash; + for (slash = fn; *slash; slash ++) + if (*slash == '/' || *slash == '\\' || *slash == ':') + fn = slash + 1; + obstack_1grow (string_obstack, '*'); + obstack_grow (string_obstack, fn, strlen (fn)); + sprintf (line_name, ":%d", get_lineno ()); + obstack_grow (string_obstack, line_name, strlen (line_name)+1); + stringbuf = XOBFINISH (string_obstack, char *); + } - c = read_skip_spaces (); - unread_char (c); - if (c == ')') - { - /* '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[i] == 'S' ? NULL : ""); + /* Find attr-names in the string. */ + char *str; + char *start, *end, *ptr; + char tmpstr[256]; + ptr = &tmpstr[0]; + end = stringbuf; + while ((start = strchr (end, '<')) && (end = strchr (start, '>'))) + { + if ((end - start - 1 > 0) + && (end - start - 1 < (int)sizeof (tmpstr))) + { + strncpy (tmpstr, start+1, end-start-1); + tmpstr[end-start-1] = 0; + end++; + } + else break; - } - - /* 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. */ - star_if_braced = (format_ptr[i] == 'T'); - - stringbuf = read_string (star_if_braced); + struct mapping *m + = (struct mapping *) htab_find (substs.attrs, &ptr); + if (m != 0) + { + /* Here we should find linked subst-iter. */ + str = find_subst_iter_by_attr (ptr); + if (str) + m = (struct mapping *) htab_find (substs.iterators, &str); + else + m = 0; + } + if (m != 0) + record_iterator_use (m, return_rtx, 0); + } +#endif /* #ifdef GENERATOR_FILE */ - /* 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_md_filename ? read_md_filename : "rtx"); - const char *slash; - for (slash = fn; *slash; slash ++) - if (*slash == '/' || *slash == '\\' || *slash == ':') - fn = slash + 1; - obstack_1grow (&string_obstack, '*'); - obstack_grow (&string_obstack, fn, strlen (fn)); - sprintf (line_name, ":%d", read_md_lineno); - obstack_grow (&string_obstack, line_name, strlen (line_name)+1); - stringbuf = XOBFINISH (&string_obstack, char *); - } + const char *string_ptr = finalize_string (stringbuf); - if (star_if_braced) - XTMPL (return_rtx, i) = stringbuf; - else - XSTR (return_rtx, i) = stringbuf; - } - break; + if (star_if_braced) + XTMPL (return_rtx, idx) = string_ptr; + else + XSTR (return_rtx, idx) = string_ptr; + } + break; - case 'w': + case 'w': + { + HOST_WIDE_INT tmp_wide; read_name (&name); validate_const_int (name.string); #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT @@ -1047,63 +1595,62 @@ #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) +#if HAVE_DECL_ATOLL || !defined(HAVE_ATOQ) tmp_wide = atoll (name.string); #else tmp_wide = atoq (name.string); #endif #endif #endif - XWINT (return_rtx, i) = tmp_wide; - break; + XWINT (return_rtx, idx) = tmp_wide; + } + break; - case 'i': - case 'n': - read_name (&name); - validate_const_int (name.string); - tmp_int = atoi (name.string); - XINT (return_rtx, i) = tmp_int; - break; + case 'i': + case 'n': + /* Can be an iterator or an integer constant. */ + read_name (&name); + record_potential_iterator_use (&ints, return_rtx, idx, name.string); + break; - default: - gcc_unreachable (); - } + case 'r': + read_name (&name); + validate_const_int (name.string); + set_regno_raw (return_rtx, atoi (name.string), 1); + REG_ATTRS (return_rtx) = NULL; + break; - c = read_skip_spaces (); - /* Syntactic sugar for AND and IOR, allowing Lisp-like - arbitrary number of arguments for them. */ - if (c == '(' - && (GET_CODE (return_rtx) == AND - || GET_CODE (return_rtx) == IOR)) - return read_rtx_variadic (mode_maps, return_rtx); + default: + gcc_unreachable (); + } - unread_char (c); return return_rtx; } -/* Read a nested rtx construct from the MD file and return it. - MODE_MAPS is as for iterator_traverse_data. */ +/* Read a nested rtx construct from the MD file and return it. */ -static rtx -read_nested_rtx (struct map_value **mode_maps) +rtx +rtx_reader::read_nested_rtx () { struct md_name name; - int c; rtx return_rtx; - c = read_skip_spaces (); - if (c != '(') - fatal_expected_char ('(', c); + /* In compact dumps, trailing "(nil)" values can be omitted. + Handle such dumps. */ + if (peek_char () == ')') + return NULL_RTX; + + require_char_ws ('('); read_name (&name); if (strcmp (name.string, "nil") == 0) return_rtx = NULL; else - return_rtx = read_rtx_code (name.string, mode_maps); + return_rtx = read_rtx_code (name.string); - c = read_skip_spaces (); - if (c != ')') - fatal_expected_char (')', c); + require_char_ws (')'); + + return_rtx = postprocess (return_rtx); return return_rtx; } @@ -1114,8 +1661,8 @@ When called, FORM is (thing x1 x2), and the file position is just past the leading parenthesis of x3. Only works for THINGs which are dyadic expressions, e.g. AND, IOR. */ -static rtx -read_rtx_variadic (struct map_value **mode_maps, rtx form) +rtx +rtx_reader::read_rtx_variadic (rtx form) { char c = '('; rtx p = form, q; @@ -1128,7 +1675,7 @@ PUT_MODE (q, GET_MODE (p)); XEXP (q, 0) = XEXP (p, 1); - XEXP (q, 1) = read_nested_rtx (mode_maps); + XEXP (q, 1) = read_nested_rtx (); XEXP (p, 1) = q; p = q; @@ -1138,3 +1685,23 @@ unread_char (c); return form; } + +/* Constructor for class rtx_reader. */ + +rtx_reader::rtx_reader (bool compact) +: md_reader (compact), + m_in_call_function_usage (false) +{ + /* Set the global singleton pointer. */ + rtx_reader_ptr = this; + + one_time_initialization (); +} + +/* Destructor for class rtx_reader. */ + +rtx_reader::~rtx_reader () +{ + /* Clear the global singleton pointer. */ + rtx_reader_ptr = NULL; +}