* tree.c (expr_first, expr_length): New fns.

        * tree.h: Declare them.

        * tree.c (iterative_hash_expr): Hash commutative expressions
        consistently.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@67201 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index d56b572..08805e7 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,11 @@
+2003-05-27  Jason Merrill  <jason@redhat.com>
+
+       * tree.c (expr_first, expr_length): New fns.
+       * tree.h: Declare them.
+
+       * tree.c (iterative_hash_expr): Hash commutative expressions
+       consistently.
+
 2003-05027  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
 
        * tree.h (contains_placeholder_p): Now returns bool.

diff --git a/gcc/tree.c b/gcc/tree.c
index 51ff3fa..ad4f51c 100644 (file)
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -1123,11 +1123,22 @@ tree_cons (purpose, value, chain)
   return node;
 }
 
+/* Return the first expression in a sequence of COMPOUND_EXPRs.  */
+
+tree
+expr_first (tree expr)
+{
+  if (expr == NULL_TREE)
+    return expr;
+  while (TREE_CODE (expr) == COMPOUND_EXPR)
+    expr = TREE_OPERAND (expr, 0);
+  return expr;
+}
+
 /* Return the last expression in a sequence of COMPOUND_EXPRs.  */
 
 tree
-expr_last (expr)
-     tree expr;
+expr_last (tree expr)
 {
   if (expr == NULL_TREE)
     return expr;
@@ -1135,6 +1146,21 @@ expr_last (expr)
     expr = TREE_OPERAND (expr, 1);
   return expr;
 }
+
+/* Return the number of subexpressions in a sequence of COMPOUND_EXPRs.  */
+
+int
+expr_length (tree expr)
+{
+  int len = 0;
+  
+  if (expr == NULL_TREE)
+    return 0;
+  for (; TREE_CODE (expr) == COMPOUND_EXPR; expr = TREE_OPERAND (expr, 1))
+    len += expr_length (TREE_OPERAND (expr, 0));
+  ++len;
+  return len;
+}
 \f
 /* Return the size nominally occupied by an object of type TYPE
    when it resides in memory.  The value is measured in units of bytes,
@@ -3653,9 +3679,28 @@ iterative_hash_expr (tree t, hashval_t val)
       if (code == NOP_EXPR || code == CONVERT_EXPR
          || code == NON_LVALUE_EXPR)
        val = iterative_hash_object (TREE_TYPE (t), val);
-  
-      for (i = first_rtl_op (code) - 1; i >= 0; --i)
-       val = iterative_hash_expr (TREE_OPERAND (t, i), val);
+
+      if (code == PLUS_EXPR || code == MULT_EXPR || code == MIN_EXPR
+         || code == MAX_EXPR || code == BIT_IOR_EXPR || code == BIT_XOR_EXPR
+         || code == BIT_AND_EXPR || code == NE_EXPR || code == EQ_EXPR)
+       {
+         /* It's a commutative expression.  We want to hash it the same
+            however it appears.  We do this by first hashing both operands
+            and then rehashing based on the order of their independent
+            hashes.  */
+         hashval_t one = iterative_hash_expr (TREE_OPERAND (t, 0), 0);
+         hashval_t two = iterative_hash_expr (TREE_OPERAND (t, 1), 0);
+         hashval_t t;
+
+         if (one > two)
+           t = one, one = two, two = t;
+
+         val = iterative_hash_object (one, val);
+         val = iterative_hash_object (two, val);
+       }
+      else
+       for (i = first_rtl_op (code) - 1; i >= 0; --i)
+         val = iterative_hash_expr (TREE_OPERAND (t, i), val);
     }
   else if (code == TREE_LIST)
     {

diff --git a/gcc/tree.h b/gcc/tree.h
index 65b7de2..446e42f 100644 (file)
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -2349,7 +2349,9 @@ extern tree pedantic_non_lvalue           PARAMS ((tree));
 
 extern tree convert                    PARAMS ((tree, tree));
 extern unsigned int expr_align         PARAMS ((tree));
+extern tree expr_first                 PARAMS ((tree));
 extern tree expr_last                  PARAMS ((tree));
+extern int expr_length                 PARAMS ((tree));
 extern tree size_in_bytes              PARAMS ((tree));
 extern HOST_WIDE_INT int_size_in_bytes PARAMS ((tree));
 extern tree bit_position               PARAMS ((tree));