+/* 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, (enum machine_mode) 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, (enum rtx_code) code);
+}
+
+/* Map a code or mode attribute string P to the underlying string for
+ MACRO and VALUE. */
+
+static struct map_value *
+map_attr_string (const char *p, struct mapping *macro, int value)
+{
+ const char *attr;
+ struct mapping *m;
+ struct map_value *v;
+
+ /* 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 = p;
+ else
+ {
+ if (strncmp (p, macro->name, attr - p) != 0
+ || macro->name[attr - p] != 0)
+ return 0;
+ attr++;
+ }
+
+ /* Find the attribute specification. */
+ m = (struct mapping *) htab_find (macro->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_macro_to_rtx. */
+
+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 macros + the index
+ we just used. */
+ return MAX_MACHINE_MODE + htab_elements (modes.macros) + 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
+ 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,
+ int value, FILE *infile, const char **unknown)
+{
+ unsigned int offset;
+ int indx;
+ struct map_value *pm;
+
+ offset = MAX_MACHINE_MODE + htab_elements (modes.macros);
+ if (GET_MODE (x) < offset)
+ return;
+
+ 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, macro, value);
+ if (v)
+ PUT_MODE (x, (enum machine_mode) find_mode (v->string, infile));
+ else
+ *unknown = pm->string;
+ return;
+ }
+ }
+}
+
+/* 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, *start, *end;
+ struct map_value *v;
+
+ if (string == 0)
+ return string;
+
+ base = p = copy = ASTRDUP (string);
+ while ((start = strchr (p, '<')) && (end = strchr (start, '>')))
+ {
+ p = start + 1;
+
+ *end = 0;
+ v = map_attr_string (p, macro, value);
+ *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));
+ base = end + 1;
+ }
+ if (base != copy)
+ {
+ obstack_grow (&string_obstack, base, strlen (base) + 1);
+ copy = XOBFINISH (&string_obstack, char *);
+ 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. 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)
+{
+ 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_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);
+
+ if (mode_maps)
+ apply_mode_maps (x, mode_maps, macro, value, infile, unknown_mode_attr);
+
+ /* 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,
+ mode_maps, infile,
+ unknown_mode_attr);
+ 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, mode_maps,
+ infile,
+ unknown_mode_attr);
+ }
+ 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 macro_traverse_data *mtd = (struct macro_traverse_data *) data;
+ struct mapping *macro;
+ struct map_value *v;
+ rtx elem, new_elem, original, x;
+
+ macro = (struct mapping *) *slot;
+ for (elem = mtd->queue; elem != 0; elem = XEXP (elem, 1))
+ if (uses_macro_p (XEXP (elem, 0), macro))
+ {
+ /* For each macro we expand, we set UNKNOWN_MODE_ATTR to NULL.
+ If apply_macro_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
+ 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)
+ {
+ x = apply_macro_to_rtx (original, macro, v->number,
+ mtd->mode_maps, mtd->infile,
+ &mtd->unknown_mode_attr);
+ 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 = XOBFINISH (&joined_conditions_obstack, const void **);
+ *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 char **halves = (const char **) 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);
+ }
+}
+