gimple vs volatiles vs enumerations

[Richard Henderson <rth at redhat dot com>]

The sync_resolve_return and create_tmp_from_val changes are needed
to avoid creating new local temporaries of volatile type.  The problem
is that this exposes a bug that 

  typedef enum { e = 1 } E __attribute__((mode(QI)));

has a type-main-variant that is of a different mode than E.  And in
fact generates incorrect debug info to boot.  After this change, the
type-main-variant thing is fixed, but the debug info isn't.  We no
run into 

  /* ??? If this type is an unnamed subrange type of an integral or
     floating-point type, use the inner type.  This is because we have no
     support for unnamed types in base_type_die.  This can happen if this is
     an Ada subrange type.  Correct solution is emit a subrange type die.  */

in dwarf2out.c.  Which, I suppose, is an improvement.  It means that
what we're emitting from the front end should have been correct...

Tested on i686-linux.


r~


        * c-common.c (handle_mode_attribute): When not modifying in place,
        create subtypes for enumerations.
        (sync_resolve_return): Use TYPE_MAIN_VARIANT.
        * gimplify.c (create_tmp_from_val): Likewise.

Index: c-common.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-common.c,v
retrieving revision 1.651
diff -u -p -d -r1.651 c-common.c
--- c-common.c	26 Aug 2005 16:26:50 -0000	1.651
+++ c-common.c	24 Sep 2005 16:19:38 -0000
@@ -4520,21 +4520,24 @@ handle_mode_attribute (tree *node, tree 
 	      return NULL_TREE;
 	    }
 
-	  if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
-	    type = build_variant_type_copy (type);
-
-	  /* We cannot use layout_type here, because that will attempt
-	     to re-layout all variants, corrupting our original.  */
-	  TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
-	  TYPE_MIN_VALUE (type) = TYPE_MIN_VALUE (typefm);
-	  TYPE_MAX_VALUE (type) = TYPE_MAX_VALUE (typefm);
-	  TYPE_SIZE (type) = TYPE_SIZE (typefm);
-	  TYPE_SIZE_UNIT (type) = TYPE_SIZE_UNIT (typefm);
-	  TYPE_MODE (type) = TYPE_MODE (typefm);
-	  if (!TYPE_USER_ALIGN (type))
-	    TYPE_ALIGN (type) = TYPE_ALIGN (typefm);
-
-	  typefm = type;
+	  if (flags & ATTR_FLAG_TYPE_IN_PLACE)
+	    {
+	      TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
+	      typefm = type;
+	    }
+	  else
+	    {
+	      /* We cannot build a type variant, as there's code that assumes
+		 that TYPE_MAIN_VARIANT has the same mode.  This includes the
+		 debug generators.  Instead, create a subrange type.  This
+		 results in all of the enumeral values being emitted only once
+		 in the original, and the subtype gets them by reference.  */
+	      if (TYPE_UNSIGNED (type))
+		typefm = make_unsigned_type (TYPE_PRECISION (typefm));
+	      else
+		typefm = make_signed_type (TYPE_PRECISION (typefm));
+	      TREE_TYPE (typefm) = type;
+	    }
 	}
       else if (VECTOR_MODE_P (mode)
 	       ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
@@ -6119,6 +6122,7 @@ static tree
 sync_resolve_return (tree params, tree result)
 {
   tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
+  ptype = TYPE_MAIN_VARIANT (ptype);
   return convert (ptype, result);
 }
 
Index: gimplify.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/gimplify.c,v
retrieving revision 2.153
diff -u -p -d -r2.153 gimplify.c
--- gimplify.c	18 Sep 2005 14:15:11 -0000	2.153
+++ gimplify.c	24 Sep 2005 16:19:39 -0000
@@ -404,7 +404,7 @@ get_name (tree t)
 static inline tree
 create_tmp_from_val (tree val)
 {
-  return create_tmp_var (TREE_TYPE (val), get_name (val));
+  return create_tmp_var (TYPE_MAIN_VARIANT (TREE_TYPE (val)), get_name (val));
 }
 
 /* Create a temporary to hold the value of VAL.  If IS_FORMAL, try to reuse