md.texi (Iterators): Renamed from Macros.

	* doc/md.texi (Iterators): Renamed from Macros.  All contents
	changed to reflect rename of respectively define_code_macro and
	define_mode_macro to define_code_iterator and define_mode_iterator.
	(Mode Iterators, Code Iterators): Similar.
	* read-rtl.c (struct iterator_group, struct iterator_traverse_data)
	(uses_mode_iterator_p, apply_mode_iterator, uses_code_iterator_p)
	(apply_iterator_to_string, uses_iterator_p, apply_iterator_traverse)
	(initialize_iterators, find_iterator, check_code_iterator)
	(map_attr_string, apply_mode_maps, apply_iterator_to_rtx, add_mapping)
	(read_mapping, read_rtx_1): Similar.
	* config/alpha/sync.md, config/alpha/alpha.md, config/frv/frv.md,
	config/s390/s390.md, config/m32c/blkmov.md, config/m32c/m32c.md,
	config/spu/spu.md, config/sparc/sparc.md, config/sparc/sync.md,
	config/i386/i386.md, config/i386/mmx.md, config/i386/sse.md,
	config/i386/sync.md, config/crx/crx.md, config/xtensa/xtensa.md,
	config/cris/cris.c, config/cris/cris.md, config/ia64/sync.md,
	config/ia64/div.md, config/ia64/vect.md, config/ia64/ia64.md,
	config/m68k/m68k.md, config/rs6000/spe.md, config/rs6000/altivec.md,
	config/rs6000/sync.md, config/rs6000/rs6000.md,
	config/arm/vec-common.md, config/arm/neon.md, config/arm/iwmmxt.md,
	config/arm/arm.md, config/mips/mips-dsp.md, config/mips/mips.md,
	config/vax/vax.md, config/bfin/bfin.md: Similar.

From-SVN: r127715

1 files changed, 125 insertions, 124 deletions

diff --git a/gcc/read-rtl.c b/gcc/read-rtl.c
index 15fa503115c..fbb67b47785 100644
--- a/gcc/read-rtl.c
+++ b/gcc/read-rtl.c
@@ -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;
@@ -222,7 +222,7 @@ fatal_expected_char (FILE *infile, int expected_c, int actual_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 +237,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 +263,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 +312,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 +332,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 +363,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 +373,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 +392,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 +413,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 +439,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 +452,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 +472,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 +485,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 +506,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 +514,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 +566,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 +616,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 +657,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 +665,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);
@@ -1284,11 +1284,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 +1305,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 +1356,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 +1394,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 +1407,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 +1431,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 +1447,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)
@@ -1504,9 +1504,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 +1514,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 +1538,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);