c-common.c: Rename all identifiers named `class' to `cl'.

	* c-common.c: Rename all identifiers named `class' to `cl'.
	* c-decl.c: Likewise.
	* c-common.h: Likewise.
	* c-parse.in: Likewise.
	* c-typeck.c: Likewise.
	* genmodes.c: Likewise.
	* real.c: Likewise.
	* real.h: Likewise.
	* recog.c: Likewise.
	* recog.h: Likewise.
	* regrename.c: Likewise.
	* tree.h: Likewise.

From-SVN: r85153

12 files changed, 249 insertions, 229 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 55be14e..e1aa4b8 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,17 @@
+2004-07-25  Bernardo Innocenti  <bernie@develer.com>
+
+	* c-common.c: Rename all identifiers named `class' to `cl'.
+	* c-common.h: Likewise.
+	* c-parse.in: Likewise.
+	* c-typeck.c: Likewise.
+	* genmodes.c: Likewise.
+	* real.c: Likewise.
+	* real.h: Likewise.
+	* recog.c: Likewise.
+	* recog.h: Likewise.
+	* regrename.c: Likewise.
+	* tree.h: Likewise.
+
 2004-07-25  Daniel Jacobowitz  <dan@debian.org>
 
 	* regmove.c (optimize_reg_copy_1): Don't try to replace call-used
diff --git a/gcc/c-common.c b/gcc/c-common.c
index 7de8cde..37e10e7 100644
--- a/gcc/c-common.c
+++ b/gcc/c-common.c
@@ -1196,7 +1196,7 @@ verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
 {
   struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
   enum tree_code code;
-  char class;
+  char cl;
 
   /* X may be NULL if it is the operand of an empty statement expression
      ({ }).  */
@@ -1205,7 +1205,7 @@ verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
 
  restart:
   code = TREE_CODE (x);
-  class = TREE_CODE_CLASS (code);
+  cl = TREE_CODE_CLASS (code);
 
   if (warning_candidate_p (x))
     {
@@ -1349,7 +1349,7 @@ verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
       break;
     }
 
-  if (class == '1')
+  if (cl == '1')
     {
       if (first_rtl_op (code) == 0)
 	return;
@@ -1358,7 +1358,7 @@ verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
       goto restart;
     }
 
-  switch (class)
+  switch (cl)
     {
     case 'r':
     case '<':
@@ -2460,9 +2460,12 @@ c_common_truthvalue_conversion (tree expr)
   return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
 }
 
-static tree builtin_function_2 (const char *, const char *, tree, tree,
-				int, enum built_in_class, int, int,
-				tree);
+static tree builtin_function_2 (const char *builtin_name, const char *name,
+				tree builtin_type, tree type,
+				enum built_in_function function_code,
+				enum built_in_class cl, int library_name_p,
+				bool nonansi_p,
+				tree attrs);
 
 /* Make a variant type in the proper way for C/C++, propagating qualifiers
    down to the element type of an array.  */
@@ -3269,10 +3272,10 @@ builtin_function_disabled_p (const char *name)
    BUILTIN_TYPE is the type of the __builtin_-prefixed function;
    TYPE is the type of the function with the ordinary name.  These
    may differ if the ordinary name is declared with a looser type to avoid
-   conflicts with headers.  FUNCTION_CODE and CLASS are as for
+   conflicts with headers.  FUNCTION_CODE and CL are as for
    builtin_function.  If LIBRARY_NAME_P is nonzero, NAME is passed as
    the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
-   If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
+   If NONANSI_P is true, the name NAME is treated as a non-ANSI name;
    ATTRS is the tree list representing the builtin's function attributes.
    Returns the declaration of BUILTIN_NAME, if any, otherwise
    the declaration of NAME.  Does not declare NAME if flag_no_builtin,
@@ -3280,21 +3283,22 @@ builtin_function_disabled_p (const char *name)
 
 static tree
 builtin_function_2 (const char *builtin_name, const char *name,
-		    tree builtin_type, tree type, int function_code,
-		    enum built_in_class class, int library_name_p,
-		    int nonansi_p, tree attrs)
+		    tree builtin_type, tree type,
+		    enum built_in_function function_code,
+		    enum built_in_class cl, int library_name_p,
+		    bool nonansi_p, tree attrs)
 {
   tree bdecl = NULL_TREE;
   tree decl = NULL_TREE;
 
   if (builtin_name != 0)
     bdecl = lang_hooks.builtin_function (builtin_name, builtin_type,
-					 function_code, class,
+					 function_code, cl,
 					 library_name_p ? name : NULL, attrs);
 
   if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
       && !(nonansi_p && flag_no_nonansi_builtin))
-    decl = lang_hooks.builtin_function (name, type, function_code, class,
+    decl = lang_hooks.builtin_function (name, type, function_code, cl,
 					NULL, attrs);
 
   return (bdecl != 0 ? bdecl : decl);
diff --git a/gcc/c-decl.c b/gcc/c-decl.c
index 62a464e..e5e1ee2 100644
--- a/gcc/c-decl.c
+++ b/gcc/c-decl.c
@@ -2475,15 +2475,15 @@ c_make_fname_decl (tree id, int type_dep)
 
 tree
 builtin_function (const char *name, tree type, int function_code,
-		  enum built_in_class class, const char *library_name,
+		  enum built_in_class cl, const char *library_name,
 		  tree attrs)
 {
   tree id = get_identifier (name);
   tree decl = build_decl (FUNCTION_DECL, id, type);
   TREE_PUBLIC (decl) = 1;
   DECL_EXTERNAL (decl) = 1;
-  DECL_LANG_SPECIFIC (decl) = ggc_alloc_cleared (sizeof (struct lang_decl));
-  DECL_BUILT_IN_CLASS (decl) = class;
+  DECL_LANG_SPECIFIC (decl) = GGC_CNEW (struct lang_decl);
+  DECL_BUILT_IN_CLASS (decl) = cl;
   DECL_FUNCTION_CODE (decl) = function_code;
   if (library_name)
     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
diff --git a/gcc/c-typeck.c b/gcc/c-typeck.c
index 2ed3c37..50ac48de 100644
--- a/gcc/c-typeck.c
+++ b/gcc/c-typeck.c
@@ -1975,7 +1975,7 @@ convert_arguments (tree typelist, tree values, tree name, tree fundecl)
 		 differ from the default conversions.  */
 	      if (warn_conversion || warn_traditional)
 		{
-		  int formal_prec = TYPE_PRECISION (type);
+		  unsigned int formal_prec = TYPE_PRECISION (type);
 
 		  if (INTEGRAL_TYPE_P (type)
 		      && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
diff --git a/gcc/genmodes.c b/gcc/genmodes.c
index 4186c91..fb2bb46 100644
--- a/gcc/genmodes.c
+++ b/gcc/genmodes.c
@@ -55,7 +55,7 @@ struct mode_data
   struct mode_data *next;	/* next this class - arbitrary order */
 
   const char *name;		/* printable mode name -- SI, not SImode */
-  enum mode_class class;	/* this mode class */
+  enum mode_class cl;		/* this mode class */
   unsigned int precision;	/* size in bits, equiv to TYPE_PRECISION */
   unsigned int bytesize;	/* storage size in addressable units */
   unsigned int ncomponents;	/* number of subunits */
@@ -79,7 +79,7 @@ static struct mode_data *void_mode;
 
 static const struct mode_data blank_mode = {
   0, "<unknown>", MAX_MODE_CLASS,
-  -1, -1, -1, -1,
+  -1U, -1U, -1U, -1U,
   0, 0, 0, 0, 0,
   "<unknown>", 0
 };
@@ -105,27 +105,27 @@ static struct mode_adjust *adj_format;
 
 /* Mode class operations.  */
 static enum mode_class
-complex_class (enum mode_class class)
+complex_class (enum mode_class c)
 {
-  switch (class)
+  switch (c)
     {
     case MODE_INT: return MODE_COMPLEX_INT;
     case MODE_FLOAT: return MODE_COMPLEX_FLOAT;
     default:
-      error ("no complex class for class %s", mode_class_names[class]);
+      error ("no complex class for class %s", mode_class_names[c]);
       return MODE_RANDOM;
     }
 }
 
 static enum mode_class
-vector_class (enum mode_class class)
+vector_class (enum mode_class cl)
 {
-  switch (class)
+  switch (cl)
     {
     case MODE_INT: return MODE_VECTOR_INT;
     case MODE_FLOAT: return MODE_VECTOR_FLOAT;
     default:
-      error ("no vector class for class %s", mode_class_names[class]);
+      error ("no vector class for class %s", mode_class_names[cl]);
       return MODE_RANDOM;
     }
 }
@@ -137,11 +137,11 @@ find_mode (const char *name)
   struct mode_data key;
 
   key.name = name;
-  return htab_find (modes_by_name, &key);
+  return (struct mode_data *) htab_find (modes_by_name, &key);
 }
 
 static struct mode_data *
-new_mode (enum mode_class class, const char *name,
+new_mode (enum mode_class cl, const char *name,
 	  const char *file, unsigned int line)
 {
   struct mode_data *m;
@@ -155,17 +155,17 @@ new_mode (enum mode_class class, const char *name,
       return m;
     }
 
-  m = xmalloc (sizeof (struct mode_data));
+  m = XNEW (struct mode_data);
   memcpy (m, &blank_mode, sizeof (struct mode_data));
-  m->class = class;
+  m->cl = cl;
   m->name = name;
   if (file)
     m->file = trim_filename (file);
   m->line = line;
 
-  m->next = modes[class];
-  modes[class] = m;
-  n_modes[class]++;
+  m->next = modes[cl];
+  modes[cl] = m;
+  n_modes[cl]++;
 
   *htab_find_slot (modes_by_name, m, INSERT) = m;
   
@@ -210,7 +210,7 @@ new_adjust (const char *name,
       return;
     }
 
-  if (required_class != MODE_RANDOM && mode->class != required_class)
+  if (required_class != MODE_RANDOM && mode->cl != required_class)
     {
       error ("%s:%d: mode \"%s\" is not class %s",
 	     file, line, name, mode_class_names[required_class] + 5);
@@ -289,13 +289,13 @@ complete_mode (struct mode_data *m)
       error ("%s:%d: mode with no name", m->file, m->line);
       return;
     }
-  if (m->class == MAX_MODE_CLASS)
+  if (m->cl == MAX_MODE_CLASS)
     {
       error ("%s:%d: %smode has no mode class", m->file, m->line, m->name);
       return;
     }
 
-  switch (m->class)
+  switch (m->cl)
     {
     case MODE_RANDOM:
       /* Nothing more need be said.  */
@@ -326,7 +326,7 @@ complete_mode (struct mode_data *m)
 	 and must not have components.   A float mode must have a
          format.  */
       validate_mode (m, OPTIONAL, SET, UNSET, UNSET,
-		     m->class == MODE_FLOAT ? SET : UNSET);
+		     m->cl == MODE_FLOAT ? SET : UNSET);
 
       m->ncomponents = 1;
       m->component = 0;
@@ -370,7 +370,7 @@ complete_mode (struct mode_data *m)
   /* If not already specified, the mode alignment defaults to the largest
      power of two that divides the size of the object.  Complex types are
      not more aligned than their contents.  */
-  if (m->class == MODE_COMPLEX_INT || m->class == MODE_COMPLEX_FLOAT)
+  if (m->cl == MODE_COMPLEX_INT || m->cl == MODE_COMPLEX_FLOAT)
     alignment = m->component->bytesize;
   else
     alignment = m->bytesize;
@@ -390,27 +390,27 @@ static void
 complete_all_modes (void)
 {
   struct mode_data *m;
-  enum mode_class c;
-  
-  for_all_modes (c, m)
+  int cl;
+
+  for_all_modes (cl, m)
     complete_mode (m);
 }
 
 /* For each mode in class CLASS, construct a corresponding complex mode.  */
 #define COMPLEX_MODES(C) make_complex_modes(MODE_##C, __FILE__, __LINE__)
 static void
-make_complex_modes (enum mode_class class,
+make_complex_modes (enum mode_class cl,
 		    const char *file, unsigned int line)
 {
   struct mode_data *m;
   struct mode_data *c;
   char buf[8];
-  enum mode_class cclass = complex_class (class);
+  enum mode_class cclass = complex_class (cl);
 
   if (cclass == MODE_RANDOM)
     return;
-    
-  for (m = modes[class]; m; m = m->next)
+
+  for (m = modes[cl]; m; m = m->next)
     {
       /* Skip BImode.  FIXME: BImode probably shouldn't be MODE_INT.  */
       if (m->precision == 1)
@@ -426,7 +426,7 @@ make_complex_modes (enum mode_class class,
       /* Float complex modes are named SCmode, etc.
 	 Int complex modes are named CSImode, etc.
          This inconsistency should be eliminated.  */
-      if (class == MODE_FLOAT)
+      if (cl == MODE_FLOAT)
 	{
 	  char *p;
 	  strncpy (buf, m->name, sizeof buf);
@@ -448,23 +448,23 @@ make_complex_modes (enum mode_class class,
     }
 }
 
-/* For all modes in class CLASS, construct vector modes of width
+/* For all modes in class CL, construct vector modes of width
    WIDTH, having as many components as necessary.  */
 #define VECTOR_MODES(C, W) make_vector_modes(MODE_##C, W, __FILE__, __LINE__)
 static void ATTRIBUTE_UNUSED
-make_vector_modes (enum mode_class class, unsigned int width,
+make_vector_modes (enum mode_class cl, unsigned int width,
 		   const char *file, unsigned int line)
 {
   struct mode_data *m;
   struct mode_data *v;
   char buf[8];
   unsigned int ncomponents;
-  enum mode_class vclass = vector_class (class);
+  enum mode_class vclass = vector_class (cl);
 
   if (vclass == MODE_RANDOM)
     return;
 
-  for (m = modes[class]; m; m = m->next)
+  for (m = modes[cl]; m; m = m->next)
     {
       /* Do not construct vector modes with only one element, or
 	 vector modes where the element size doesn't divide the full
@@ -477,9 +477,9 @@ make_vector_modes (enum mode_class class, unsigned int width,
 
       /* Skip QFmode and BImode.  FIXME: this special case should
 	 not be necessary.  */
-      if (class == MODE_FLOAT && m->bytesize == 1)
+      if (cl == MODE_FLOAT && m->bytesize == 1)
 	continue;
-      if (class == MODE_INT && m->precision == 1)
+      if (cl == MODE_INT && m->precision == 1)
 	continue;
 
       if ((size_t)snprintf (buf, sizeof buf, "V%u%s", ncomponents, m->name)
@@ -503,13 +503,13 @@ make_vector_modes (enum mode_class class, unsigned int width,
 #define CC_MODE(N) _SPECIAL_MODE (CC, N)
 
 static void
-make_special_mode (enum mode_class class, const char *name,
+make_special_mode (enum mode_class cl, const char *name,
 		   const char *file, unsigned int line)
 {
-  new_mode (class, name, file, line);
+  new_mode (cl, name, file, line);
 }
 
-#define INT_MODE(N, Y) FRACTIONAL_INT_MODE (N, -1, Y)
+#define INT_MODE(N, Y) FRACTIONAL_INT_MODE (N, -1U, Y)
 #define FRACTIONAL_INT_MODE(N, B, Y) \
   make_int_mode (#N, B, Y, __FILE__, __LINE__)
 
@@ -523,7 +523,7 @@ make_int_mode (const char *name,
   m->precision = precision;
 }
 
-#define FLOAT_MODE(N, Y, F)             FRACTIONAL_FLOAT_MODE (N, -1, Y, F)
+#define FLOAT_MODE(N, Y, F)             FRACTIONAL_FLOAT_MODE (N, -1U, Y, F)
 #define FRACTIONAL_FLOAT_MODE(N, B, Y, F) \
   make_float_mode (#N, B, Y, #F, __FILE__, __LINE__)
 
@@ -551,7 +551,7 @@ reset_float_format (const char *name, const char *format,
       error ("%s:%d: no mode \"%s\"", file, line, name);
       return;
     }
-  if (m->class != MODE_FLOAT)
+  if (m->cl != MODE_FLOAT)
     {
       error ("%s:%d: mode \"%s\" is not class FLOAT", file, line, name);
       return;
@@ -562,7 +562,7 @@ reset_float_format (const char *name, const char *format,
 /* Partial integer modes are specified by relation to a full integer mode.
    For now, we do not attempt to narrow down their bit sizes.  */
 #define PARTIAL_INT_MODE(M) \
-  make_partial_integer_mode (#M, "P" #M, -1, __FILE__, __LINE__)
+  make_partial_integer_mode (#M, "P" #M, -1U, __FILE__, __LINE__)
 static void ATTRIBUTE_UNUSED
 make_partial_integer_mode (const char *base, const char *name,
 			   unsigned int precision,
@@ -575,12 +575,12 @@ make_partial_integer_mode (const char *base, const char *name,
       error ("%s:%d: no mode \"%s\"", file, line, name);
       return;
     }
-  if (component->class != MODE_INT)
+  if (component->cl != MODE_INT)
     {
       error ("%s:%d: mode \"%s\" is not class INT", file, line, name);
       return;
     }
-  
+
   m = new_mode (MODE_PARTIAL_INT, name, file, line);
   m->precision = precision;
   m->component = component;
@@ -608,7 +608,7 @@ make_vector_mode (enum mode_class bclass,
       error ("%s:%d: no mode \"%s\"", file, line, base);
       return;
     }
-  if (component->class != bclass)
+  if (component->cl != bclass)
     {
       error ("%s:%d: mode \"%s\" is not class %s",
 	     file, line, base, mode_class_names[bclass] + 5);
@@ -692,7 +692,7 @@ cmp_modes (const void *a, const void *b)
 static void
 calc_wider_mode (void)
 {
-  enum mode_class c;
+  int c;
   struct mode_data *m;
   struct mode_data **sortbuf;
   unsigned int max_n_modes = 0;
@@ -765,7 +765,7 @@ calc_wider_mode (void)
 static void
 emit_insn_modes_h (void)
 {
-  enum mode_class c;
+  int c;
   struct mode_data *m, *first, *last;
 
   printf ("/* Generated automatically from machmode.def%s%s\n",
@@ -866,7 +866,7 @@ emit_min_insn_modes_c_header (void)
 static void
 emit_mode_name (void)
 {
-  enum mode_class c;
+  int c;
   struct mode_data *m;
 
   print_decl ("char *const", "mode_name", "NUM_MACHINE_MODES");
@@ -880,13 +880,13 @@ emit_mode_name (void)
 static void
 emit_mode_class (void)
 {
-  enum mode_class c;
+  int c;
   struct mode_data *m;
 
   print_decl ("unsigned char", "mode_class", "NUM_MACHINE_MODES");
 
   for_all_modes (c, m)
-    tagged_printf ("%s", mode_class_names[m->class], m->name);
+    tagged_printf ("%s", mode_class_names[m->cl], m->name);
 
   print_closer ();
 }
@@ -894,7 +894,7 @@ emit_mode_class (void)
 static void
 emit_mode_precision (void)
 {
-  enum mode_class c;
+  int c;
   struct mode_data *m;
 
   print_decl ("unsigned short", "mode_precision", "NUM_MACHINE_MODES");
@@ -911,7 +911,7 @@ emit_mode_precision (void)
 static void
 emit_mode_size (void)
 {
-  enum mode_class c;
+  int c;
   struct mode_data *m;
 
   print_maybe_const_decl ("%sunsigned char", "mode_size",
@@ -926,7 +926,7 @@ emit_mode_size (void)
 static void
 emit_mode_nunits (void)
 {
-  enum mode_class c;
+  int c;
   struct mode_data *m;
 
   print_decl ("unsigned char", "mode_nunits", "NUM_MACHINE_MODES");
@@ -940,7 +940,7 @@ emit_mode_nunits (void)
 static void
 emit_mode_wider (void)
 {
-  enum mode_class c;
+  int c;
   struct mode_data *m;
 
   print_decl ("unsigned char", "mode_wider", "NUM_MACHINE_MODES");
@@ -956,7 +956,7 @@ emit_mode_wider (void)
 static void
 emit_mode_mask (void)
 {
-  enum mode_class c;
+  int c;
   struct mode_data *m;
 
   print_decl ("unsigned HOST_WIDE_INT", "mode_mask_array",
@@ -980,7 +980,7 @@ emit_mode_mask (void)
 static void
 emit_mode_inner (void)
 {
-  enum mode_class c;
+  int c;
   struct mode_data *m;
 
   print_decl ("unsigned char", "mode_inner", "NUM_MACHINE_MODES");
@@ -996,7 +996,7 @@ emit_mode_inner (void)
 static void
 emit_mode_base_align (void)
 {
-  enum mode_class c;
+  int c;
   struct mode_data *m;
 
   print_maybe_const_decl ("%sunsigned char",
@@ -1012,7 +1012,7 @@ emit_mode_base_align (void)
 static void
 emit_class_narrowest_mode (void)
 {
-  enum mode_class c;
+  int c;
 
   print_decl ("unsigned char", "class_narrowest_mode", "MAX_MODE_CLASS");
 
@@ -1084,7 +1084,7 @@ emit_mode_adjustments (void)
 
       for (m = a->mode->contained; m; m = m->next_cont)
 	{
-	  switch (m->class)
+	  switch (m->cl)
 	    {
 	    case MODE_COMPLEX_INT:
 	    case MODE_COMPLEX_FLOAT:
@@ -1120,7 +1120,7 @@ emit_mode_adjustments (void)
 
       for (m = a->mode->contained; m; m = m->next_cont)
 	{
-	  switch (m->class)
+	  switch (m->cl)
 	    {
 	    case MODE_COMPLEX_INT:
 	    case MODE_COMPLEX_FLOAT:
diff --git a/gcc/real.c b/gcc/real.c
index 896aa9d..2eb2019 100644
--- a/gcc/real.c
+++ b/gcc/real.c
@@ -138,7 +138,7 @@ static inline void
 get_canonical_qnan (REAL_VALUE_TYPE *r, int sign)
 {
   memset (r, 0, sizeof (*r));
-  r->class = rvc_nan;
+  r->cl = rvc_nan;
   r->sign = sign;
   r->canonical = 1;
 }
@@ -147,7 +147,7 @@ static inline void
 get_canonical_snan (REAL_VALUE_TYPE *r, int sign)
 {
   memset (r, 0, sizeof (*r));
-  r->class = rvc_nan;
+  r->cl = rvc_nan;
   r->sign = sign;
   r->signalling = 1;
   r->canonical = 1;
@@ -157,7 +157,7 @@ static inline void
 get_inf (REAL_VALUE_TYPE *r, int sign)
 {
   memset (r, 0, sizeof (*r));
-  r->class = rvc_inf;
+  r->cl = rvc_inf;
   r->sign = sign;
 }
 
@@ -490,7 +490,7 @@ normalize (REAL_VALUE_TYPE *r)
   /* Zero significand flushes to zero.  */
   if (i < 0)
     {
-      r->class = rvc_zero;
+      r->cl = rvc_zero;
       SET_REAL_EXP (r, 0);
       return;
     }
@@ -531,7 +531,7 @@ do_add (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
   sign = a->sign;
   subtract_p = (sign ^ b->sign) ^ subtract_p;
 
-  switch (CLASS2 (a->class, b->class))
+  switch (CLASS2 (a->cl, b->cl))
     {
     case CLASS2 (rvc_zero, rvc_zero):
       /* -0 + -0 = -0, -0 - +0 = -0; all other cases yield +0.  */
@@ -637,7 +637,7 @@ do_add (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
 	}
     }
 
-  r->class = rvc_normal;
+  r->cl = rvc_normal;
   r->sign = sign;
   SET_REAL_EXP (r, exp);
 
@@ -646,7 +646,7 @@ do_add (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
 
   /* Special case: if the subtraction results in zero, the result
      is positive.  */
-  if (r->class == rvc_zero)
+  if (r->cl == rvc_zero)
     r->sign = 0;
   else
     r->sig[0] |= inexact;
@@ -665,7 +665,7 @@ do_multiply (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
   int sign = a->sign ^ b->sign;
   bool inexact = false;
 
-  switch (CLASS2 (a->class, b->class))
+  switch (CLASS2 (a->cl, b->cl))
     {
     case CLASS2 (rvc_zero, rvc_zero):
     case CLASS2 (rvc_zero, rvc_normal):
@@ -764,7 +764,7 @@ do_multiply (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
 	    }
 
 	  memset (&u, 0, sizeof (u));
-	  u.class = rvc_normal;
+	  u.cl = rvc_normal;
 	  SET_REAL_EXP (&u, exp);
 
 	  for (k = j; k < SIGSZ * 2; k += 2)
@@ -800,7 +800,7 @@ do_divide (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
   REAL_VALUE_TYPE t, *rr;
   bool inexact;
 
-  switch (CLASS2 (a->class, b->class))
+  switch (CLASS2 (a->cl, b->cl))
     {
     case CLASS2 (rvc_zero, rvc_zero):
       /* 0 / 0 = NaN.  */
@@ -860,7 +860,7 @@ do_divide (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
 
   /* Make sure all fields in the result are initialized.  */
   get_zero (rr, 0);
-  rr->class = rvc_normal;
+  rr->cl = rvc_normal;
   rr->sign = sign;
 
   exp = REAL_EXP (a) - REAL_EXP (b) + 1;
@@ -897,7 +897,7 @@ do_compare (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b,
 {
   int ret;
 
-  switch (CLASS2 (a->class, b->class))
+  switch (CLASS2 (a->cl, b->cl))
     {
     case CLASS2 (rvc_zero, rvc_zero):
       /* Sign of zero doesn't matter for compares.  */
@@ -952,7 +952,7 @@ do_fix_trunc (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
 {
   *r = *a;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
     case rvc_inf:
@@ -999,7 +999,7 @@ real_arithmetic (REAL_VALUE_TYPE *r, int icode, const REAL_VALUE_TYPE *op0,
       break;
 
     case MIN_EXPR:
-      if (op1->class == rvc_nan)
+      if (op1->cl == rvc_nan)
 	*r = *op1;
       else if (do_compare (op0, op1, -1) < 0)
 	*r = *op0;
@@ -1008,7 +1008,7 @@ real_arithmetic (REAL_VALUE_TYPE *r, int icode, const REAL_VALUE_TYPE *op0,
       break;
 
     case MAX_EXPR:
-      if (op1->class == rvc_nan)
+      if (op1->cl == rvc_nan)
 	*r = *op1;
       else if (do_compare (op0, op1, 1) < 0)
 	*r = *op1;
@@ -1067,9 +1067,9 @@ real_compare (int icode, const REAL_VALUE_TYPE *op0,
     case NE_EXPR:
       return do_compare (op0, op1, -1) != 0;
     case UNORDERED_EXPR:
-      return op0->class == rvc_nan || op1->class == rvc_nan;
+      return op0->cl == rvc_nan || op1->cl == rvc_nan;
     case ORDERED_EXPR:
-      return op0->class != rvc_nan && op1->class != rvc_nan;
+      return op0->cl != rvc_nan && op1->cl != rvc_nan;
     case UNLT_EXPR:
       return do_compare (op0, op1, -1) < 0;
     case UNLE_EXPR:
@@ -1093,7 +1093,7 @@ real_compare (int icode, const REAL_VALUE_TYPE *op0,
 int
 real_exponent (const REAL_VALUE_TYPE *r)
 {
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       return 0;
@@ -1113,7 +1113,7 @@ void
 real_ldexp (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0, int exp)
 {
   *r = *op0;
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
     case rvc_inf:
@@ -1140,7 +1140,7 @@ real_ldexp (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0, int exp)
 bool
 real_isinf (const REAL_VALUE_TYPE *r)
 {
-  return (r->class == rvc_inf);
+  return (r->cl == rvc_inf);
 }
 
 /* Determine whether a floating-point value X is a NaN.  */
@@ -1148,7 +1148,7 @@ real_isinf (const REAL_VALUE_TYPE *r)
 bool
 real_isnan (const REAL_VALUE_TYPE *r)
 {
-  return (r->class == rvc_nan);
+  return (r->cl == rvc_nan);
 }
 
 /* Determine whether a floating-point value X is negative.  */
@@ -1164,7 +1164,7 @@ real_isneg (const REAL_VALUE_TYPE *r)
 bool
 real_isnegzero (const REAL_VALUE_TYPE *r)
 {
-  return r->sign && r->class == rvc_zero;
+  return r->sign && r->cl == rvc_zero;
 }
 
 /* Compare two floating-point objects for bitwise identity.  */
@@ -1174,12 +1174,12 @@ real_identical (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b)
 {
   int i;
 
-  if (a->class != b->class)
+  if (a->cl != b->cl)
     return false;
   if (a->sign != b->sign)
     return false;
 
-  switch (a->class)
+  switch (a->cl)
     {
     case rvc_zero:
     case rvc_inf:
@@ -1219,7 +1219,7 @@ exact_real_inverse (enum machine_mode mode, REAL_VALUE_TYPE *r)
   REAL_VALUE_TYPE u;
   int i;
 
-  if (r->class != rvc_normal)
+  if (r->cl != rvc_normal)
     return false;
 
   /* Check for a power of two: all significand bits zero except the MSB.  */
@@ -1234,7 +1234,7 @@ exact_real_inverse (enum machine_mode mode, REAL_VALUE_TYPE *r)
   real_convert (&u, mode, &u);
 
   /* The rounding may have overflowed.  */
-  if (u.class != rvc_normal)
+  if (u.cl != rvc_normal)
     return false;
   for (i = 0; i < SIGSZ-1; ++i)
     if (u.sig[i] != 0)
@@ -1253,7 +1253,7 @@ real_to_integer (const REAL_VALUE_TYPE *r)
 {
   unsigned HOST_WIDE_INT i;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
     underflow:
@@ -1309,7 +1309,7 @@ real_to_integer2 (HOST_WIDE_INT *plow, HOST_WIDE_INT *phigh,
   HOST_WIDE_INT low, high;
   int exp;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
     underflow:
@@ -1431,7 +1431,7 @@ real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size,
   bool sign;
 
   r = *r_orig;
-  switch (r.class)
+  switch (r.cl)
     {
     case rvc_zero:
       strcpy (str, (r.sign ? "-0.0" : "0.0"));
@@ -1698,7 +1698,7 @@ real_to_hexadecimal (char *str, const REAL_VALUE_TYPE *r, size_t buf_size,
   char exp_buf[16];
   size_t max_digits;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       exp = 0;
@@ -1851,7 +1851,7 @@ real_from_string (REAL_VALUE_TYPE *r, const char *str)
 	  exp += d;
 	}
 
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
       SET_REAL_EXP (r, exp);
 
       normalize (r);
@@ -1874,7 +1874,7 @@ real_from_string (REAL_VALUE_TYPE *r, const char *str)
       if (*str == '.')
 	{
 	  str++;
-	  if (r->class == rvc_zero)
+	  if (r->cl == rvc_zero)
 	    {
 	      while (*str == '0')
 		str++, exp--;
@@ -1963,7 +1963,7 @@ real_from_integer (REAL_VALUE_TYPE *r, enum machine_mode mode,
     get_zero (r, 0);
   else
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
       r->sign = high < 0 && !unsigned_p;
       SET_REAL_EXP (r, 2 * HOST_BITS_PER_WIDE_INT);
 
@@ -2011,7 +2011,7 @@ ten_to_ptwo (int n)
   if (n < 0 || n >= EXP_BITS)
     abort ();
 
-  if (tens[n].class == rvc_zero)
+  if (tens[n].cl == rvc_zero)
     {
       if (n < (HOST_BITS_PER_WIDE_INT == 64 ? 5 : 4))
 	{
@@ -2043,7 +2043,7 @@ ten_to_mptwo (int n)
   if (n < 0 || n >= EXP_BITS)
     abort ();
 
-  if (tens[n].class == rvc_zero)
+  if (tens[n].cl == rvc_zero)
     do_divide (&tens[n], real_digit (1), ten_to_ptwo (n));
 
   return &tens[n];
@@ -2059,7 +2059,7 @@ real_digit (int n)
   if (n < 0 || n > 9)
     abort ();
 
-  if (n > 0 && num[n].class == rvc_zero)
+  if (n > 0 && num[n].cl == rvc_zero)
     real_from_integer (&num[n], VOIDmode, n, 0, 1);
 
   return &num[n];
@@ -2127,7 +2127,7 @@ real_nan (REAL_VALUE_TYPE *r, const char *str, int quiet,
       bool neg = false;
 
       memset (r, 0, sizeof (*r));
-      r->class = rvc_nan;
+      r->cl = rvc_nan;
 
       /* Parse akin to strtol into the significand of R.  */
 
@@ -2204,7 +2204,7 @@ real_maxval (REAL_VALUE_TYPE *r, int sign, enum machine_mode mode)
   if (fmt == NULL)
     abort ();
 
-  r->class = rvc_normal;
+  r->cl = rvc_normal;
   r->sign = sign;
   r->signalling = 0;
   r->canonical = 0;
@@ -2224,12 +2224,12 @@ real_2expN (REAL_VALUE_TYPE *r, int n)
 
   n++;
   if (n > MAX_EXP)
-    r->class = rvc_inf;
+    r->cl = rvc_inf;
   else if (n < -MAX_EXP)
     ;
   else
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
       SET_REAL_EXP (r, n);
       r->sig[SIGSZ-1] = SIG_MSB;
     }
@@ -2249,7 +2249,7 @@ round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r)
   emax2 = fmt->emax * fmt->log2_b;
 
   np2 = SIGNIFICAND_BITS - p2;
-  switch (r->class)
+  switch (r->cl)
     {
     underflow:
       get_zero (r, r->sign);
@@ -2382,7 +2382,7 @@ real_convert (REAL_VALUE_TYPE *r, enum machine_mode mode,
   round_for_format (fmt, r);
 
   /* round_for_format de-normalizes denormals.  Undo just that part.  */
-  if (r->class == rvc_normal)
+  if (r->cl == rvc_normal)
     normalize (r);
 }
 
@@ -2493,8 +2493,8 @@ real_hash (const REAL_VALUE_TYPE *r)
   unsigned int h;
   size_t i;
 
-  h = r->class | (r->sign << 2);
-  switch (r->class)
+  h = r->cl | (r->sign << 2);
+  switch (r->cl)
     {
     case rvc_zero:
     case rvc_inf:
@@ -2546,7 +2546,7 @@ encode_ieee_single (const struct real_format *fmt, long *buf,
   image = sign << 31;
   sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       break;
@@ -2618,7 +2618,7 @@ decode_ieee_single (const struct real_format *fmt, REAL_VALUE_TYPE *r,
     {
       if (image && fmt->has_denorm)
 	{
-	  r->class = rvc_normal;
+	  r->cl = rvc_normal;
 	  r->sign = sign;
 	  SET_REAL_EXP (r, -126);
 	  r->sig[SIGSZ-1] = image << 1;
@@ -2631,7 +2631,7 @@ decode_ieee_single (const struct real_format *fmt, REAL_VALUE_TYPE *r,
     {
       if (image)
 	{
-	  r->class = rvc_nan;
+	  r->cl = rvc_nan;
 	  r->sign = sign;
 	  r->signalling = (((image >> (HOST_BITS_PER_LONG - 2)) & 1)
 			   ^ fmt->qnan_msb_set);
@@ -2639,13 +2639,13 @@ decode_ieee_single (const struct real_format *fmt, REAL_VALUE_TYPE *r,
 	}
       else
 	{
-	  r->class = rvc_inf;
+	  r->cl = rvc_inf;
 	  r->sign = sign;
 	}
     }
   else
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
       r->sign = sign;
       SET_REAL_EXP (r, exp - 127 + 1);
       r->sig[SIGSZ-1] = image | SIG_MSB;
@@ -2720,7 +2720,7 @@ encode_ieee_double (const struct real_format *fmt, long *buf,
       sig_hi = (sig_hi >> 11) & 0xfffff;
     }
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       break;
@@ -2819,7 +2819,7 @@ decode_ieee_double (const struct real_format *fmt, REAL_VALUE_TYPE *r,
     {
       if ((image_hi || image_lo) && fmt->has_denorm)
 	{
-	  r->class = rvc_normal;
+	  r->cl = rvc_normal;
 	  r->sign = sign;
 	  SET_REAL_EXP (r, -1022);
 	  if (HOST_BITS_PER_LONG == 32)
@@ -2843,7 +2843,7 @@ decode_ieee_double (const struct real_format *fmt, REAL_VALUE_TYPE *r,
     {
       if (image_hi || image_lo)
 	{
-	  r->class = rvc_nan;
+	  r->cl = rvc_nan;
 	  r->sign = sign;
 	  r->signalling = ((image_hi >> 30) & 1) ^ fmt->qnan_msb_set;
 	  if (HOST_BITS_PER_LONG == 32)
@@ -2856,13 +2856,13 @@ decode_ieee_double (const struct real_format *fmt, REAL_VALUE_TYPE *r,
 	}
       else
 	{
-	  r->class = rvc_inf;
+	  r->cl = rvc_inf;
 	  r->sign = sign;
 	}
     }
   else
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
       r->sign = sign;
       SET_REAL_EXP (r, exp - 1023 + 1);
       if (HOST_BITS_PER_LONG == 32)
@@ -2930,7 +2930,7 @@ encode_ieee_extended (const struct real_format *fmt, long *buf,
   image_hi = r->sign << 15;
   sig_hi = sig_lo = 0;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       break;
@@ -3108,7 +3108,7 @@ decode_ieee_extended (const struct real_format *fmt, REAL_VALUE_TYPE *r,
     {
       if ((sig_hi || sig_lo) && fmt->has_denorm)
 	{
-	  r->class = rvc_normal;
+	  r->cl = rvc_normal;
 	  r->sign = sign;
 
 	  /* When the IEEE format contains a hidden bit, we know that
@@ -3139,7 +3139,7 @@ decode_ieee_extended (const struct real_format *fmt, REAL_VALUE_TYPE *r,
 
       if (sig_hi || sig_lo)
 	{
-	  r->class = rvc_nan;
+	  r->cl = rvc_nan;
 	  r->sign = sign;
 	  r->signalling = ((sig_hi >> 30) & 1) ^ fmt->qnan_msb_set;
 	  if (HOST_BITS_PER_LONG == 32)
@@ -3152,13 +3152,13 @@ decode_ieee_extended (const struct real_format *fmt, REAL_VALUE_TYPE *r,
 	}
       else
 	{
-	  r->class = rvc_inf;
+	  r->cl = rvc_inf;
 	  r->sign = sign;
 	}
     }
   else
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
       r->sign = sign;
       SET_REAL_EXP (r, exp - 16383 + 1);
       if (HOST_BITS_PER_LONG == 32)
@@ -3322,7 +3322,7 @@ encode_ibm_extended (const struct real_format *fmt, long *buf,
 
   /* Renormlize R before doing any arithmetic on it.  */
   normr = *r;
-  if (normr.class == rvc_normal)
+  if (normr.cl == rvc_normal)
     normalize (&normr);
 
   /* u = IEEE double precision portion of significand.  */
@@ -3330,7 +3330,7 @@ encode_ibm_extended (const struct real_format *fmt, long *buf,
   round_for_format (base_fmt, &u);
   encode_ieee_double (base_fmt, &buf[0], &u);
 
-  if (u.class == rvc_normal)
+  if (u.cl == rvc_normal)
     {
       do_add (&v, &normr, &u, 1);
       /* Call round_for_format since we might need to denormalize.  */
@@ -3356,7 +3356,7 @@ decode_ibm_extended (const struct real_format *fmt ATTRIBUTE_UNUSED, REAL_VALUE_
   base_fmt = fmt->qnan_msb_set ? &ieee_double_format : &mips_double_format;
   decode_ieee_double (base_fmt, &u, &buf[0]);
 
-  if (u.class != rvc_zero && u.class != rvc_inf && u.class != rvc_nan)
+  if (u.cl != rvc_zero && u.cl != rvc_inf && u.cl != rvc_nan)
     {
       decode_ieee_double (base_fmt, &v, &buf[2]);
       do_add (r, &u, &v, 0);
@@ -3424,7 +3424,7 @@ encode_ieee_quad (const struct real_format *fmt, long *buf,
 
   rshift_significand (&u, r, SIGNIFICAND_BITS - 113);
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       break;
@@ -3576,7 +3576,7 @@ decode_ieee_quad (const struct real_format *fmt, REAL_VALUE_TYPE *r,
     {
       if ((image3 | image2 | image1 | image0) && fmt->has_denorm)
 	{
-	  r->class = rvc_normal;
+	  r->cl = rvc_normal;
 	  r->sign = sign;
 
 	  SET_REAL_EXP (r, -16382 + (SIGNIFICAND_BITS - 112));
@@ -3602,7 +3602,7 @@ decode_ieee_quad (const struct real_format *fmt, REAL_VALUE_TYPE *r,
     {
       if (image3 | image2 | image1 | image0)
 	{
-	  r->class = rvc_nan;
+	  r->cl = rvc_nan;
 	  r->sign = sign;
 	  r->signalling = ((image3 >> 15) & 1) ^ fmt->qnan_msb_set;
 
@@ -3622,13 +3622,13 @@ decode_ieee_quad (const struct real_format *fmt, REAL_VALUE_TYPE *r,
 	}
       else
 	{
-	  r->class = rvc_inf;
+	  r->cl = rvc_inf;
 	  r->sign = sign;
 	}
     }
   else
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
       r->sign = sign;
       SET_REAL_EXP (r, exp - 16383 + 1);
 
@@ -3716,7 +3716,7 @@ encode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
 
   sign = r->sign << 15;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       image = 0;
@@ -3755,7 +3755,7 @@ decode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED,
 
   if (exp != 0)
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
       r->sign = (image >> 15) & 1;
       SET_REAL_EXP (r, exp - 128);
 
@@ -3770,7 +3770,7 @@ encode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
 {
   unsigned long image0, image1, sign = r->sign << 15;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       image0 = image1 = 0;
@@ -3838,7 +3838,7 @@ decode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED,
 
   if (exp != 0)
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
       r->sign = (image0 >> 15) & 1;
       SET_REAL_EXP (r, exp - 128);
 
@@ -3870,7 +3870,7 @@ encode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
 {
   unsigned long image0, image1, sign = r->sign << 15;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       image0 = image1 = 0;
@@ -3938,7 +3938,7 @@ decode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED,
 
   if (exp != 0)
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
       r->sign = (image0 >> 15) & 1;
       SET_REAL_EXP (r, exp - 1024);
 
@@ -4042,7 +4042,7 @@ encode_i370_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
 
   sign = r->sign << 31;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       image = 0;
@@ -4081,7 +4081,7 @@ decode_i370_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
 
   if (exp || sig)
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
       r->sign = sign;
       SET_REAL_EXP (r, (exp - 64) * 4);
       r->sig[SIGSZ-1] = sig << (HOST_BITS_PER_LONG - 24);
@@ -4097,7 +4097,7 @@ encode_i370_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
 
   sign = r->sign << 31;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       image_hi = image_lo = 0;
@@ -4159,7 +4159,7 @@ decode_i370_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
 
   if (exp || image_hi || image_lo)
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
       r->sign = sign;
       SET_REAL_EXP (r, (exp - 64) * 4 + (SIGNIFICAND_BITS - 56));
 
@@ -4245,7 +4245,7 @@ encode_c4x_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
 {
   unsigned long image, exp, sig;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       exp = -128;
@@ -4294,7 +4294,7 @@ decode_c4x_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
 
   if (exp != -128)
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
 
       sig = sf & 0x7fffff;
       if (sf < 0)
@@ -4318,7 +4318,7 @@ encode_c4x_extended (const struct real_format *fmt ATTRIBUTE_UNUSED,
 {
   unsigned long exp, sig;
 
-  switch (r->class)
+  switch (r->cl)
     {
     case rvc_zero:
       exp = -128;
@@ -4381,7 +4381,7 @@ decode_c4x_extended (const struct real_format *fmt ATTRIBUTE_UNUSED,
 
   if (exp != -128)
     {
-      r->class = rvc_normal;
+      r->cl = rvc_normal;
 
       sig = sf & 0x7fffffff;
       if (sf < 0)
diff --git a/gcc/real.h b/gcc/real.h
index 4200e5e..c477be1 100644
--- a/gcc/real.h
+++ b/gcc/real.h
@@ -45,7 +45,7 @@ struct real_value GTY(())
   /* Use the same underlying type for all bit-fields, so as to make
      sure they're packed together, otherwise REAL_VALUE_TYPE_SIZE will
      be miscomputed.  */
-  unsigned int /* ENUM_BITFIELD (real_value_class) */ class : 2;
+  unsigned int /* ENUM_BITFIELD (real_value_class) */ cl : 2;
   unsigned int sign : 1;
   unsigned int signalling : 1;
   unsigned int canonical : 1;
diff --git a/gcc/recog.c b/gcc/recog.c
index 9c9d038..82fb12e 100644
--- a/gcc/recog.c
+++ b/gcc/recog.c
@@ -2096,7 +2096,7 @@ preprocess_constraints (void)
 
       for (j = 0; j < recog_data.n_alternatives; j++)
 	{
-	  op_alt[j].class = NO_REGS;
+	  op_alt[j].cl = NO_REGS;
 	  op_alt[j].constraint = p;
 	  op_alt[j].matches = -1;
 	  op_alt[j].matched = -1;
@@ -2171,12 +2171,14 @@ preprocess_constraints (void)
 
 		case 'p':
 		  op_alt[j].is_address = 1;
-		  op_alt[j].class = reg_class_subunion[(int) op_alt[j].class]
+		  op_alt[j].cl = reg_class_subunion[(int) op_alt[j].cl]
 		    [(int) MODE_BASE_REG_CLASS (VOIDmode)];
 		  break;
 
-		case 'g': case 'r':
-		  op_alt[j].class = reg_class_subunion[(int) op_alt[j].class][(int) GENERAL_REGS];
+		case 'g':
+		case 'r':
+		  op_alt[j].cl =
+		   reg_class_subunion[(int) op_alt[j].cl][(int) GENERAL_REGS];
 		  break;
 
 		default:
@@ -2188,16 +2190,16 @@ preprocess_constraints (void)
 		  if (EXTRA_ADDRESS_CONSTRAINT (c, p))
 		    {
 		      op_alt[j].is_address = 1;
-		      op_alt[j].class
+		      op_alt[j].cl
 			= (reg_class_subunion
-			   [(int) op_alt[j].class]
+			   [(int) op_alt[j].cl]
 			   [(int) MODE_BASE_REG_CLASS (VOIDmode)]);
 		      break;
 		    }
 
-		  op_alt[j].class
+		  op_alt[j].cl
 		    = (reg_class_subunion
-		       [(int) op_alt[j].class]
+		       [(int) op_alt[j].cl]
 		       [(int) REG_CLASS_FROM_CONSTRAINT ((unsigned char) c, p)]);
 		  break;
 		}
@@ -2518,11 +2520,11 @@ constrain_operands (int strict)
 
 	      default:
 		{
-		  enum reg_class class;
+		  enum reg_class cl;
 
-		  class = (c == 'r'
+		  cl = (c == 'r'
 			   ? GENERAL_REGS : REG_CLASS_FROM_CONSTRAINT (c, p));
-		  if (class != NO_REGS)
+		  if (cl != NO_REGS)
 		    {
 		      if (strict < 0
 			  || (strict == 0
@@ -2530,7 +2532,7 @@ constrain_operands (int strict)
 			      && REGNO (op) >= FIRST_PSEUDO_REGISTER)
 			  || (strict == 0 && GET_CODE (op) == SCRATCH)
 			  || (REG_P (op)
-			      && reg_fits_class_p (op, class, offset, mode)))
+			      && reg_fits_class_p (op, cl, offset, mode)))
 		        win = 1;
 		    }
 #ifdef EXTRA_CONSTRAINT_STR
@@ -2623,19 +2625,19 @@ constrain_operands (int strict)
    If REG occupies multiple hard regs, all of them must be in CLASS.  */
 
 int
-reg_fits_class_p (rtx operand, enum reg_class class, int offset,
+reg_fits_class_p (rtx operand, enum reg_class cl, int offset,
 		  enum machine_mode mode)
 {
   int regno = REGNO (operand);
   if (regno < FIRST_PSEUDO_REGISTER
-      && TEST_HARD_REG_BIT (reg_class_contents[(int) class],
+      && TEST_HARD_REG_BIT (reg_class_contents[(int) cl],
 			    regno + offset))
     {
       int sr;
       regno += offset;
       for (sr = hard_regno_nregs[regno][mode] - 1;
 	   sr > 0; sr--)
-	if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
+	if (! TEST_HARD_REG_BIT (reg_class_contents[(int) cl],
 				 regno + sr))
 	  break;
       return sr == 0;
@@ -2898,7 +2900,7 @@ peep2_find_free_register (int from, int to, const char *class_str,
 			  enum machine_mode mode, HARD_REG_SET *reg_set)
 {
   static int search_ofs;
-  enum reg_class class;
+  enum reg_class cl;
   HARD_REG_SET live;
   int i;
 
@@ -2928,7 +2930,7 @@ peep2_find_free_register (int from, int to, const char *class_str,
       IOR_HARD_REG_SET (live, this_live);
     }
 
-  class = (class_str[0] == 'r' ? GENERAL_REGS
+  cl = (class_str[0] == 'r' ? GENERAL_REGS
 	   : REG_CLASS_FROM_CONSTRAINT (class_str[0], class_str));
 
   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
@@ -2949,7 +2951,7 @@ peep2_find_free_register (int from, int to, const char *class_str,
       if (fixed_regs[regno])
 	continue;
       /* Make sure the register is of the right class.  */
-      if (! TEST_HARD_REG_BIT (reg_class_contents[class], regno))
+      if (! TEST_HARD_REG_BIT (reg_class_contents[cl], regno))
 	continue;
       /* And can support the mode we need.  */
       if (! HARD_REGNO_MODE_OK (regno, mode))
diff --git a/gcc/recog.h b/gcc/recog.h
index b0382ab..28db9aa 100644
--- a/gcc/recog.h
+++ b/gcc/recog.h
@@ -38,7 +38,7 @@ struct operand_alternative
   const char *constraint;
 
   /* The register class valid for this alternative (possibly NO_REGS).  */
-  enum reg_class class;
+  enum reg_class cl;
 
   /* "Badness" of this alternative, computed from number of '?' and '!'
      characters in the constraint string.  */
diff --git a/gcc/reg-stack.c b/gcc/reg-stack.c
index 5eb253f..e21f11b 100644
--- a/gcc/reg-stack.c
+++ b/gcc/reg-stack.c
@@ -667,7 +667,7 @@ check_asm_stack_operands (rtx insn)
   for (i = 0; i < n_outputs; i++)
     if (STACK_REG_P (recog_data.operand[i]))
       {
-	if (reg_class_size[(int) recog_op_alt[i][alt].class] != 1)
+	if (reg_class_size[(int) recog_op_alt[i][alt].cl] != 1)
 	  {
 	    error_for_asm (insn, "output constraint %d must specify a single register", i);
 	    malformed_asm = 1;
@@ -2147,9 +2147,9 @@ subst_asm_stack_regs (rtx insn, stack regstack)
 
   for (i = n_outputs; i < n_outputs + n_inputs; i++)
     if (STACK_REG_P (recog_data.operand[i])
-	&& reg_class_subset_p (recog_op_alt[i][alt].class,
+	&& reg_class_subset_p (recog_op_alt[i][alt].cl,
 			       FLOAT_REGS)
-	&& recog_op_alt[i][alt].class != FLOAT_REGS)
+	&& recog_op_alt[i][alt].cl != FLOAT_REGS)
       {
 	/* If an operand needs to be in a particular reg in
 	   FLOAT_REGS, the constraint was either 't' or 'u'.  Since
diff --git a/gcc/regrename.c b/gcc/regrename.c
index b4226bf..7168d4c 100644
--- a/gcc/regrename.c
+++ b/gcc/regrename.c
@@ -51,7 +51,7 @@ struct du_chain
 
   rtx insn;
   rtx *loc;
-  ENUM_BITFIELD(reg_class) class : 16;
+  ENUM_BITFIELD(reg_class) cl : 16;
   unsigned int need_caller_save_reg:1;
   unsigned int earlyclobber:1;
 };
@@ -270,13 +270,13 @@ regrename_optimize (void)
 	    {
 	      n_uses++;
 	      IOR_COMPL_HARD_REG_SET (this_unavailable,
-				      reg_class_contents[last->class]);
+				      reg_class_contents[last->cl]);
 	    }
 	  if (n_uses < 1)
 	    continue;
 
 	  IOR_COMPL_HARD_REG_SET (this_unavailable,
-				  reg_class_contents[last->class]);
+				  reg_class_contents[last->cl]);
 
 	  if (this->need_caller_save_reg)
 	    IOR_HARD_REG_SET (this_unavailable, call_used_reg_set);
@@ -385,7 +385,7 @@ static struct du_chain *open_chains;
 static struct du_chain *closed_chains;
 
 static void
-scan_rtx_reg (rtx insn, rtx *loc, enum reg_class class,
+scan_rtx_reg (rtx insn, rtx *loc, enum reg_class cl,
 	      enum scan_actions action, enum op_type type, int earlyclobber)
 {
   struct du_chain **p;
@@ -404,7 +404,7 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class class,
 	  this->next_chain = open_chains;
 	  this->loc = loc;
 	  this->insn = insn;
-	  this->class = class;
+	  this->cl = cl;
 	  this->need_caller_save_reg = 0;
 	  this->earlyclobber = earlyclobber;
 	  open_chains = this;
@@ -451,14 +451,14 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class class,
 		 EXTRA_CONSTRAINTS to match registers.  Which is arguably
 		 wrong, but there we are.  Since we know not what this may
 		 be replaced with, terminate the chain.  */
-	      if (class != NO_REGS)
+	      if (cl != NO_REGS)
 		{
 		  this = obstack_alloc (&rename_obstack, sizeof (struct du_chain));
 		  this->next_use = 0;
 		  this->next_chain = (*p)->next_chain;
 		  this->loc = loc;
 		  this->insn = insn;
-		  this->class = class;
+		  this->cl = cl;
 		  this->need_caller_save_reg = 0;
 		  while (*p)
 		    p = &(*p)->next_use;
@@ -502,11 +502,11 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class class,
     }
 }
 
-/* Adapted from find_reloads_address_1.  CLASS is INDEX_REG_CLASS or
+/* Adapted from find_reloads_address_1.  CL is INDEX_REG_CLASS or
    BASE_REG_CLASS depending on how the register is being considered.  */
 
 static void
-scan_rtx_address (rtx insn, rtx *loc, enum reg_class class,
+scan_rtx_address (rtx insn, rtx *loc, enum reg_class cl,
 		  enum scan_actions action, enum machine_mode mode)
 {
   rtx x = *loc;
@@ -620,7 +620,7 @@ scan_rtx_address (rtx insn, rtx *loc, enum reg_class class,
       return;
 
     case REG:
-      scan_rtx_reg (insn, loc, class, action, OP_IN, 0);
+      scan_rtx_reg (insn, loc, cl, action, OP_IN, 0);
       return;
 
     default:
@@ -631,15 +631,15 @@ scan_rtx_address (rtx insn, rtx *loc, enum reg_class class,
   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
     {
       if (fmt[i] == 'e')
-	scan_rtx_address (insn, &XEXP (x, i), class, action, mode);
+	scan_rtx_address (insn, &XEXP (x, i), cl, action, mode);
       else if (fmt[i] == 'E')
 	for (j = XVECLEN (x, i) - 1; j >= 0; j--)
-	  scan_rtx_address (insn, &XVECEXP (x, i, j), class, action, mode);
+	  scan_rtx_address (insn, &XVECEXP (x, i, j), cl, action, mode);
     }
 }
 
 static void
-scan_rtx (rtx insn, rtx *loc, enum reg_class class,
+scan_rtx (rtx insn, rtx *loc, enum reg_class cl,
 	  enum scan_actions action, enum op_type type, int earlyclobber)
 {
   const char *fmt;
@@ -661,7 +661,7 @@ scan_rtx (rtx insn, rtx *loc, enum reg_class class,
       return;
 
     case REG:
-      scan_rtx_reg (insn, loc, class, action, type, earlyclobber);
+      scan_rtx_reg (insn, loc, cl, action, type, earlyclobber);
       return;
 
     case MEM:
@@ -671,20 +671,20 @@ scan_rtx (rtx insn, rtx *loc, enum reg_class class,
       return;
 
     case SET:
-      scan_rtx (insn, &SET_SRC (x), class, action, OP_IN, 0);
-      scan_rtx (insn, &SET_DEST (x), class, action, OP_OUT, 0);
+      scan_rtx (insn, &SET_SRC (x), cl, action, OP_IN, 0);
+      scan_rtx (insn, &SET_DEST (x), cl, action, OP_OUT, 0);
       return;
 
     case STRICT_LOW_PART:
-      scan_rtx (insn, &XEXP (x, 0), class, action, OP_INOUT, earlyclobber);
+      scan_rtx (insn, &XEXP (x, 0), cl, action, OP_INOUT, earlyclobber);
       return;
 
     case ZERO_EXTRACT:
     case SIGN_EXTRACT:
-      scan_rtx (insn, &XEXP (x, 0), class, action,
+      scan_rtx (insn, &XEXP (x, 0), cl, action,
 		type == OP_IN ? OP_IN : OP_INOUT, earlyclobber);
-      scan_rtx (insn, &XEXP (x, 1), class, action, OP_IN, 0);
-      scan_rtx (insn, &XEXP (x, 2), class, action, OP_IN, 0);
+      scan_rtx (insn, &XEXP (x, 1), cl, action, OP_IN, 0);
+      scan_rtx (insn, &XEXP (x, 2), cl, action, OP_IN, 0);
       return;
 
     case POST_INC:
@@ -697,13 +697,13 @@ scan_rtx (rtx insn, rtx *loc, enum reg_class class,
       abort ();
 
     case CLOBBER:
-      scan_rtx (insn, &SET_DEST (x), class, action, OP_OUT, 1);
+      scan_rtx (insn, &SET_DEST (x), cl, action, OP_OUT, 1);
       return;
 
     case EXPR_LIST:
-      scan_rtx (insn, &XEXP (x, 0), class, action, type, 0);
+      scan_rtx (insn, &XEXP (x, 0), cl, action, type, 0);
       if (XEXP (x, 1))
-	scan_rtx (insn, &XEXP (x, 1), class, action, type, 0);
+	scan_rtx (insn, &XEXP (x, 1), cl, action, type, 0);
       return;
 
     default:
@@ -714,10 +714,10 @@ scan_rtx (rtx insn, rtx *loc, enum reg_class class,
   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
     {
       if (fmt[i] == 'e')
-	scan_rtx (insn, &XEXP (x, i), class, action, type, 0);
+	scan_rtx (insn, &XEXP (x, i), cl, action, type, 0);
       else if (fmt[i] == 'E')
 	for (j = XVECLEN (x, i) - 1; j >= 0; j--)
-	  scan_rtx (insn, &XVECEXP (x, i, j), class, action, type, 0);
+	  scan_rtx (insn, &XVECEXP (x, i, j), cl, action, type, 0);
     }
 }
 
@@ -775,7 +775,7 @@ build_def_use (basic_block bb)
 	    {
 	      int matches = recog_op_alt[i][alt].matches;
 	      if (matches >= 0)
-		recog_op_alt[i][alt].class = recog_op_alt[matches][alt].class;
+		recog_op_alt[i][alt].cl = recog_op_alt[matches][alt].cl;
 	      if (matches >= 0 || recog_op_alt[i][alt].matched >= 0
 	          || (predicated && recog_data.operand_type[i] == OP_OUT))
 		recog_data.operand_type[i] = OP_INOUT;
@@ -850,7 +850,7 @@ build_def_use (basic_block bb)
 	      rtx *loc = (i < n_ops
 			  ? recog_data.operand_loc[opn]
 			  : recog_data.dup_loc[i - n_ops]);
-	      enum reg_class class = recog_op_alt[opn][alt].class;
+	      enum reg_class cl = recog_op_alt[opn][alt].cl;
 	      enum op_type type = recog_data.operand_type[opn];
 
 	      /* Don't scan match_operand here, since we've no reg class
@@ -860,9 +860,9 @@ build_def_use (basic_block bb)
 		continue;
 
 	      if (recog_op_alt[opn][alt].is_address)
-		scan_rtx_address (insn, loc, class, mark_read, VOIDmode);
+		scan_rtx_address (insn, loc, cl, mark_read, VOIDmode);
 	      else
-		scan_rtx (insn, loc, class, mark_read, type, 0);
+		scan_rtx (insn, loc, cl, mark_read, type, 0);
 	    }
 
 	  /* Step 4: Close chains for registers that die here.
@@ -924,13 +924,13 @@ build_def_use (basic_block bb)
 		  {
 		    rtx *loc = recog_data.operand_loc[i];
 		    rtx op = *loc;
-		    enum reg_class class = recog_op_alt[i][alt].class;
+		    enum reg_class cl = recog_op_alt[i][alt].cl;
 
 		    if (REG_P (op)
 			&& REGNO (op) == ORIGINAL_REGNO (op))
 		      continue;
 
-		    scan_rtx (insn, loc, class, mark_write, OP_OUT,
+		    scan_rtx (insn, loc, cl, mark_write, OP_OUT,
 			      recog_op_alt[i][alt].earlyclobber);
 		  }
 	    }
@@ -941,10 +941,10 @@ build_def_use (basic_block bb)
 		rtx *loc = (i < n_ops
 			    ? recog_data.operand_loc[opn]
 			    : recog_data.dup_loc[i - n_ops]);
-		enum reg_class class = recog_op_alt[opn][alt].class;
+		enum reg_class cl = recog_op_alt[opn][alt].cl;
 
 		if (recog_data.operand_type[opn] == OP_OUT)
-		  scan_rtx (insn, loc, class, mark_write, OP_OUT,
+		  scan_rtx (insn, loc, cl, mark_write, OP_OUT,
 			    recog_op_alt[opn][alt].earlyclobber);
 	      }
 
@@ -979,7 +979,7 @@ dump_def_use_chain (struct du_chain *chains)
       while (this)
 	{
 	  fprintf (dump_file, " %d [%s]", INSN_UID (this->insn),
-		   reg_class_names[this->class]);
+		   reg_class_names[this->cl]);
 	  this = this->next_use;
 	}
       fprintf (dump_file, "\n");
@@ -1312,11 +1312,11 @@ maybe_mode_change (enum machine_mode orig_mode, enum machine_mode copy_mode,
 }
 
 /* Find the oldest copy of the value contained in REGNO that is in
-   register class CLASS and has mode MODE.  If found, return an rtx
+   register class CL and has mode MODE.  If found, return an rtx
    of that oldest register, otherwise return NULL.  */
 
 static rtx
-find_oldest_value_reg (enum reg_class class, rtx reg, struct value_data *vd)
+find_oldest_value_reg (enum reg_class cl, rtx reg, struct value_data *vd)
 {
   unsigned int regno = REGNO (reg);
   enum machine_mode mode = GET_MODE (reg);
@@ -1343,7 +1343,7 @@ find_oldest_value_reg (enum reg_class class, rtx reg, struct value_data *vd)
       unsigned int last;
 
       for (last = i; last < i + hard_regno_nregs[i][mode]; last++)
-	if (!TEST_HARD_REG_BIT (reg_class_contents[class], last))
+	if (!TEST_HARD_REG_BIT (reg_class_contents[cl], last))
 	  return NULL_RTX;
 
       new = maybe_mode_change (oldmode, vd->e[regno].mode, mode, i, regno);
@@ -1359,13 +1359,13 @@ find_oldest_value_reg (enum reg_class class, rtx reg, struct value_data *vd)
 }
 
 /* If possible, replace the register at *LOC with the oldest register
-   in register class CLASS.  Return true if successfully replaced.  */
+   in register class CL.  Return true if successfully replaced.  */
 
 static bool
-replace_oldest_value_reg (rtx *loc, enum reg_class class, rtx insn,
+replace_oldest_value_reg (rtx *loc, enum reg_class cl, rtx insn,
 			  struct value_data *vd)
 {
-  rtx new = find_oldest_value_reg (class, *loc, vd);
+  rtx new = find_oldest_value_reg (cl, *loc, vd);
   if (new)
     {
       if (dump_file)
@@ -1379,11 +1379,11 @@ replace_oldest_value_reg (rtx *loc, enum reg_class class, rtx insn,
 }
 
 /* Similar to replace_oldest_value_reg, but *LOC contains an address.
-   Adapted from find_reloads_address_1.  CLASS is INDEX_REG_CLASS or
+   Adapted from find_reloads_address_1.  CL is INDEX_REG_CLASS or
    BASE_REG_CLASS depending on how the register is being considered.  */
 
 static bool
-replace_oldest_value_addr (rtx *loc, enum reg_class class,
+replace_oldest_value_addr (rtx *loc, enum reg_class cl,
 			   enum machine_mode mode, rtx insn,
 			   struct value_data *vd)
 {
@@ -1491,7 +1491,7 @@ replace_oldest_value_addr (rtx *loc, enum reg_class class,
       return replace_oldest_value_mem (x, insn, vd);
 
     case REG:
-      return replace_oldest_value_reg (loc, class, insn, vd);
+      return replace_oldest_value_reg (loc, cl, insn, vd);
 
     default:
       break;
@@ -1501,11 +1501,11 @@ replace_oldest_value_addr (rtx *loc, enum reg_class class,
   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
     {
       if (fmt[i] == 'e')
-	changed |= replace_oldest_value_addr (&XEXP (x, i), class, mode,
+	changed |= replace_oldest_value_addr (&XEXP (x, i), cl, mode,
 					      insn, vd);
       else if (fmt[i] == 'E')
 	for (j = XVECLEN (x, i) - 1; j >= 0; j--)
-	  changed |= replace_oldest_value_addr (&XVECEXP (x, i, j), class,
+	  changed |= replace_oldest_value_addr (&XVECEXP (x, i, j), cl,
 						mode, insn, vd);
     }
 
@@ -1562,7 +1562,7 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
 	{
 	  int matches = recog_op_alt[i][alt].matches;
 	  if (matches >= 0)
-	    recog_op_alt[i][alt].class = recog_op_alt[matches][alt].class;
+	    recog_op_alt[i][alt].cl = recog_op_alt[matches][alt].cl;
 	  if (matches >= 0 || recog_op_alt[i][alt].matched >= 0
 	      || (predicated && recog_data.operand_type[i] == OP_OUT))
 	    recog_data.operand_type[i] = OP_INOUT;
@@ -1669,12 +1669,12 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
 	      if (recog_op_alt[i][alt].is_address)
 		replaced
 		  = replace_oldest_value_addr (recog_data.operand_loc[i],
-					       recog_op_alt[i][alt].class,
+					       recog_op_alt[i][alt].cl,
 					       VOIDmode, insn, vd);
 	      else if (REG_P (recog_data.operand[i]))
 		replaced
 		  = replace_oldest_value_reg (recog_data.operand_loc[i],
-					      recog_op_alt[i][alt].class,
+					      recog_op_alt[i][alt].cl,
 					      insn, vd);
 	      else if (MEM_P (recog_data.operand[i]))
 		replaced = replace_oldest_value_mem (recog_data.operand[i],
diff --git a/gcc/tree.h b/gcc/tree.h
index f60da20..f9567c3 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -3140,7 +3140,7 @@ extern int integer_pow2p (tree);
 
 extern int integer_nonzerop (tree);
 
-/* staticp (tree x) is nonzero if X is a reference to data allocated
+/* staticp (tree x) is true if X is a reference to data allocated
    at a fixed address in memory.  */
 
 extern bool staticp (tree);