[PR,debug/45130] fix MEM_REF -fcompare-debug regression

Submitted by Alexandre Oliva on Sept. 6, 2010, 5:57 p.m.

Details

Message ID ork4myoiur.fsf@livre.localdomain
State New
Headers show

Commit Message

Alexandre Oliva Sept. 6, 2010, 5:57 p.m.
On Sep  5, 2010, Richard Guenther <richard.guenther@gmail.com> wrote:

> +   If OEP_SAME_TYPE is set, then mismatched types */

> there seems to be missing sth.

Ugh.  Sorry.

> Thus, simply add a type equality check for operand 1 in operand_equal_p here:

Thanks.  I'm going ahead and hashing the main type variant of operand 1,
and discarding qualifiers and checking types when dumping trees.  How
does this look?  (pending regstrap)

Comments

Richard Guenther Sept. 7, 2010, 9:43 a.m.
On Mon, Sep 6, 2010 at 7:57 PM, Alexandre Oliva <aoliva@redhat.com> wrote:
> On Sep  5, 2010, Richard Guenther <richard.guenther@gmail.com> wrote:
>
>> +   If OEP_SAME_TYPE is set, then mismatched types */
>
>> there seems to be missing sth.
>
> Ugh.  Sorry.
>
>> Thus, simply add a type equality check for operand 1 in operand_equal_p here:
>
> Thanks.  I'm going ahead and hashing the main type variant of operand 1,
> and discarding qualifiers and checking types when dumping trees.  How
> does this look?  (pending regstrap)

+       /* The type of the second operand is irrelevant, except for
+          its top-level qualifiers.  */
+       val = iterative_hash_object (TYPE_HASH (type), val);

I suppose this was to be "The type of the second operand is relevant, ..."

Ok with that change.

Thanks,
Richard.

Patch hide | download patch | download mbox

for gcc/ChangeLog
from  Alexandre Oliva  <aoliva@redhat.com>

	PR debug/45419
	PR debug/45408
	* tree-pretty-print.c (dump_generic_node): Disregard top-level
	qualifiers in otherwise equal MEM_REF pointer types.
	* fold-const.c (operand_equal_p): Compare pointer type of MEM_REFs.
	* tree.c (iterative_hash_expr): Hash the pointer type of MEM_REFs.

Index: gcc/tree-pretty-print.c
===================================================================
--- gcc/tree-pretty-print.c.orig	2010-09-05 09:17:52.542299276 -0300
+++ gcc/tree-pretty-print.c	2010-09-06 14:50:07.000000000 -0300
@@ -807,8 +807,8 @@  dump_generic_node (pretty_printer *buffe
 		== TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 1))))
 	    && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 0)))
 		== TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 1))))
-	    && (TYPE_QUALS (TREE_TYPE (TREE_OPERAND (node, 0)))
-		== TYPE_QUALS (TREE_TYPE (TREE_OPERAND (node, 1))))
+	    && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node, 0)))
+		== TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node, 1))))
 	    /* Same value types ignoring qualifiers.  */
 	    && (TYPE_MAIN_VARIANT (TREE_TYPE (node))
 		== TYPE_MAIN_VARIANT
@@ -827,9 +827,12 @@  dump_generic_node (pretty_printer *buffe
 	  }
 	else
 	  {
+	    tree ptype;
+
 	    pp_string (buffer, "MEM[");
 	    pp_string (buffer, "(");
-	    dump_generic_node (buffer, TREE_TYPE (TREE_OPERAND (node, 1)),
+	    ptype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node, 1)));
+	    dump_generic_node (buffer, ptype,
 			       spc, flags | TDF_SLIM, false);
 	    pp_string (buffer, ")");
 	    dump_generic_node (buffer, TREE_OPERAND (node, 0),
Index: gcc/fold-const.c
===================================================================
--- gcc/fold-const.c.orig	2010-09-05 09:17:52.620425283 -0300
+++ gcc/fold-const.c	2010-09-06 14:32:03.000000000 -0300
@@ -2593,14 +2593,17 @@  operand_equal_p (const_tree arg0, const_
 	  return OP_SAME (0);
 
 	case MEM_REF:
-	  /* Require equal access sizes.  We can have incomplete types
-	     for array references of variable-sized arrays from the
-	     Fortran frontent though.  */
+	  /* Require equal access sizes, and similar pointer types.
+	     We can have incomplete types for array references of
+	     variable-sized arrays from the Fortran frontent
+	     though.  */
 	  return ((TYPE_SIZE (TREE_TYPE (arg0)) == TYPE_SIZE (TREE_TYPE (arg1))
 		   || (TYPE_SIZE (TREE_TYPE (arg0))
 		       && TYPE_SIZE (TREE_TYPE (arg1))
 		       && operand_equal_p (TYPE_SIZE (TREE_TYPE (arg0)),
 					   TYPE_SIZE (TREE_TYPE (arg1)), flags)))
+		  && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg0, 1)))
+		      == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg1, 1))))
 		  && OP_SAME (0) && OP_SAME (1));
 
 	case ARRAY_REF:
Index: gcc/tree.c
===================================================================
--- gcc/tree.c.orig	2010-09-05 09:17:52.677304476 -0300
+++ gcc/tree.c	2010-09-06 14:46:57.000000000 -0300
@@ -6734,6 +6734,21 @@  iterative_hash_expr (const_tree t, hashv
 	  }
 	return val;
       }
+    case MEM_REF:
+      {
+	tree type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (t, 1)));
+
+	/* The type of the second operand is irrelevant, except for
+	   its top-level qualifiers.  */
+	val = iterative_hash_object (TYPE_HASH (type), val);
+
+	/* We could use the standard hash computation from this point
+	   on.  */
+	val = iterative_hash_object (code, val);
+	val = iterative_hash_expr (TREE_OPERAND (t, 1), val);
+	val = iterative_hash_expr (TREE_OPERAND (t, 0), val);
+	return val;
+      }
     case FUNCTION_DECL:
       /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form.
 	 Otherwise nodes that compare equal according to operand_equal_p might