tree-ssa-dom.c (find_equivalent_equality_comparison): Do not a eliminate type…

tree-ssa-dom.c (find_equivalent_equality_comparison): Do not a eliminate type conversion which feeds an equality comparison if...


        * tree-ssa-dom.c (find_equivalent_equality_comparison): Do not
        a eliminate type conversion which feeds an equality comparison
        if the original type or either operand in the comparison is a
        function pointer.

	* gcc.dg/tree-ssa/pr22051-1.c: New test.
	* gcc.dg/tree-ssa/pr22051-2.c: New test.

From-SVN: r101534

gcc/ChangeLog

+2005-07-02  Jeff Law  <law@redhat.com>
+
+	* tree-ssa-dom.c (find_equivalent_equality_comparison): Do not
+	a eliminate type conversion which feeds an equality comparison
+	if the original type or either operand in the comparison is a
+	function pointer.
+
 2005-07-02  Joseph S. Myers  <joseph@codesourcery.com>
 
 	* c.opt, common.opt, config/bfin/bfin.opt, config/pa/pa.opt,

gcc/testsuite/ChangeLog

+2005-07-02  Jeff Law  <law@redhat.com>
+
+	* gcc.dg/tree-ssa/pr22051-1.c: New test.
+	* gcc.dg/tree-ssa/pr22051-2.c: New test.
+
 2005-07-02  Joseph S. Myers  <joseph@codesourcery.com>
 
 	* gcc.dg/format/gcc_diag-1.c: Update.

gcc/testsuite/gcc.dg/tree-ssa/pr22051-1.c

+/* { dg-do compile }  */
+/* { dg-options "-O2 -fdump-tree-optimized" }  */
+
+
+void *arf ();
+int
+foo()
+{
+  void *p = arf ();
+
+  if ((void (*)(void))p != 0)
+    return 1;
+  else
+    return 2;
+}
+
+/* The cast to a function pointer type must remain after all optimizations
+   are complete so that function pointer canonicalization works on those
+   targets which require it.  */
+/* { dg-final { scan-tree-dump-times "if \\(\\(void \\(\\*<.*>\\) \\(void\\)\\) p" 1 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+
+

gcc/testsuite/gcc.dg/tree-ssa/pr22051-2.c

+/* { dg-do compile }  */
+/* { dg-options "-O2 -fdump-tree-optimized -w" }  */
+
+
+
+
+void *arf ();
+int
+foo()
+{
+  void (*q)(void);
+  int r = q;
+
+  if (r != 0)
+    return 1;
+  else
+    return 2;
+}
+
+/* The cast to an int type must remain after all optimizations are complete
+   so that we do not try to canonicalize a function pointer for the
+   comparison when no such canonicalization is wanted.  */
+/* { dg-final { scan-tree-dump-times "if \\(\\(int\\) q" 1 "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */
+

gcc/tree-ssa-dom.c

@@ -1882,6 +1882,18 @@ find_equivalent_equality_comparison (tree cond)
     {
       tree def_rhs = TREE_OPERAND (def_stmt, 1);
 
+
+      /* If either operand to the comparison is a pointer to
+	 a function, then we can not apply this optimization
+	 as some targets require function pointers to be
+	 canonicalized and in this case this optimization would
+	 eliminate a necessary canonicalization.  */
+      if ((POINTER_TYPE_P (TREE_TYPE (op0))
+	   && TREE_CODE (TREE_TYPE (TREE_TYPE (op0))) == FUNCTION_TYPE)
+	  || (POINTER_TYPE_P (TREE_TYPE (op1))
+	      && TREE_CODE (TREE_TYPE (TREE_TYPE (op1))) == FUNCTION_TYPE))
+	return NULL;
+	      
       /* Now make sure the RHS of the MODIFY_EXPR is a typecast.  */
       if ((TREE_CODE (def_rhs) == NOP_EXPR
 	   || TREE_CODE (def_rhs) == CONVERT_EXPR)
@@ -1895,6 +1907,16 @@ find_equivalent_equality_comparison (tree cond)
 	      > TYPE_PRECISION (TREE_TYPE (def_rhs)))
 	    return NULL;
 
+	  /* If the inner type of the conversion is a pointer to
+	     a function, then we can not apply this optimization
+	     as some targets require function pointers to be
+	     canonicalized.  This optimization would result in
+	     canonicalization of the pointer when it was not originally
+	     needed/intended.  */
+	  if (POINTER_TYPE_P (def_rhs_inner_type)
+	      && TREE_CODE (TREE_TYPE (def_rhs_inner_type)) == FUNCTION_TYPE)
+	    return NULL;
+
 	  /* What we want to prove is that if we convert OP1 to
 	     the type of the object inside the NOP_EXPR that the
 	     result is still equivalent to SRC.