From: Richard Stallman <rms@gnu.org>
Date: Sat, 5 Jun 1993 09:08:32 +0000 (+0000)
Subject: (convert_for_assignment): Allow conversion to union type
X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=2df34974748c2d55cd28d5bf137f943bbdee0c71;p=gcc.git

(convert_for_assignment): Allow conversion to union type
for pointer if the pointer could convert to the union member.

From-SVN: r4634
---

diff --git a/gcc/c-typeck.c b/gcc/c-typeck.c
index 89a838fef8b..d7bd4ad521d 100644
--- a/gcc/c-typeck.c
+++ b/gcc/c-typeck.c
@@ -4173,6 +4173,51 @@ convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
 		pedwarn ("ANSI C prohibits argument conversion to union type");
 	      return build1 (NOP_EXPR, type, rhs);
 	    }
+	  else if (coder == POINTER_TYPE
+		   && TREE_CODE (TREE_TYPE (memb_types)) == POINTER_TYPE)
+	    {
+	      tree memb_type = TREE_TYPE (memb_types);
+	      register tree ttl = TREE_TYPE (memb_type);
+	      register tree ttr = TREE_TYPE (rhstype);
+
+	      /* Any non-function converts to a [const][volatile] void *
+		 and vice versa; otherwise, targets must be the same.
+		 Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
+	      if (TYPE_MAIN_VARIANT (ttl) == void_type_node
+		  || TYPE_MAIN_VARIANT (ttr) == void_type_node
+		  || comp_target_types (memb_type, rhstype))
+		{
+		  /* Const and volatile mean something different for function types,
+		     so the usual warnings are not appropriate.  */
+		  if (TREE_CODE (ttr) != FUNCTION_TYPE
+		      || TREE_CODE (ttl) != FUNCTION_TYPE)
+		    {
+		      if (! TYPE_READONLY (ttl) && TYPE_READONLY (ttr))
+			warn_for_assignment ("%s discards `const' from pointer target type",
+					     get_spelling (errtype), funname, parmnum);
+		      if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr))
+			warn_for_assignment ("%s discards `volatile' from pointer target type",
+					     get_spelling (errtype), funname, parmnum);
+		    }
+		  else
+		    {
+		      /* Because const and volatile on functions are restrictions
+			 that say the function will not do certain things,
+			 it is okay to use a const or volatile function
+			 where an ordinary one is wanted, but not vice-versa.  */
+		      if (TYPE_READONLY (ttl) && ! TYPE_READONLY (ttr))
+			warn_for_assignment ("%s makes `const *' function pointer from non-const",
+					     get_spelling (errtype), funname, parmnum);
+		      if (TYPE_VOLATILE (ttl) && ! TYPE_VOLATILE (ttr))
+			warn_for_assignment ("%s makes `volatile *' function pointer from non-volatile",
+					     get_spelling (errtype), funname, parmnum);
+		    }
+		  if (pedantic
+		      && !(fundecl != 0 && DECL_IN_SYSTEM_HEADER (fundecl)))
+		    pedwarn ("ANSI C prohibits argument conversion to union type");
+		  return build1 (NOP_EXPR, type, rhs);
+		}
+	    }
 	}
     }
   /* Conversions among pointers */