fold-const.c (operand_equal_p): Remove kludge allowing ARG0 and ARG1 to be null...

	* fold-const.c (operand_equal_p): Remove kludge allowing ARG0 and
	ARG1 to be null; instead define OP_SAME and OP_SAME_NULL and use them.

From-SVN: r91170

1 files changed, 37 insertions, 54 deletions

diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 0a7b7d2..167fc03 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -2331,17 +2331,8 @@ truth_value_p (enum tree_code code)
 int
 operand_equal_p (tree arg0, tree arg1, unsigned int flags)
 {
-  /* If one is specified and the other isn't, they aren't equal and if
-     neither is specified, they are.
-
-     ??? This is temporary and is meant only to handle the cases of the
-     optional operands for COMPONENT_REF and ARRAY_REF.  */
-  if ((arg0 && !arg1) || (!arg0 && arg1))
-    return 0;
-  else if (!arg0 && !arg1)
-    return 1;
   /* If either is ERROR_MARK, they aren't equal.  */
-  else if (TREE_CODE (arg0) == ERROR_MARK || TREE_CODE (arg1) == ERROR_MARK)
+  if (TREE_CODE (arg0) == ERROR_MARK || TREE_CODE (arg1) == ERROR_MARK)
     return 0;
 
   /* If both types don't have the same signedness, then we can't consider
@@ -2433,6 +2424,17 @@ operand_equal_p (tree arg0, tree arg1, unsigned int flags)
   if (flags & OEP_ONLY_CONST)
     return 0;
 
+/* Define macros to test an operan from arg0 and arg1 for equality and a
+   variant that allows null and views null as being different from any
+   non-null value.  In the latter case, if either is null, the both
+   must be; otherwise, do the normal comparison.  */
+#define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N),	\
+				    TREE_OPERAND (arg1, N), flags)
+
+#define OP_SAME_WITH_NULL(N)				\
+  ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N))	\
+   ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
+
   switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
     {
     case tcc_unary:
@@ -2453,15 +2455,12 @@ operand_equal_p (tree arg0, tree arg1, unsigned int flags)
 	  break;
 	}
 
-      return operand_equal_p (TREE_OPERAND (arg0, 0),
-			      TREE_OPERAND (arg1, 0), flags);
+      return OP_SAME (0);
+
 
     case tcc_comparison:
     case tcc_binary:
-      if (operand_equal_p (TREE_OPERAND (arg0, 0),
-			   TREE_OPERAND (arg1, 0), flags)
-	  && operand_equal_p (TREE_OPERAND (arg0, 1),
-			      TREE_OPERAND (arg1, 1), flags))
+      if (OP_SAME (0) && OP_SAME (1))
 	return 1;
 
       /* For commutative ops, allow the other order.  */
@@ -2485,37 +2484,23 @@ operand_equal_p (tree arg0, tree arg1, unsigned int flags)
 	case MISALIGNED_INDIRECT_REF:
 	case REALPART_EXPR:
 	case IMAGPART_EXPR:
-	  return operand_equal_p (TREE_OPERAND (arg0, 0),
-				  TREE_OPERAND (arg1, 0), flags);
+	  return OP_SAME (0);
 
 	case ARRAY_REF:
 	case ARRAY_RANGE_REF:
-	  return (operand_equal_p (TREE_OPERAND (arg0, 0),
-				   TREE_OPERAND (arg1, 0), flags)
-		  && operand_equal_p (TREE_OPERAND (arg0, 1),
-				      TREE_OPERAND (arg1, 1), flags)
-		  && operand_equal_p (TREE_OPERAND (arg0, 2),
-				      TREE_OPERAND (arg1, 2), flags)
-		  && operand_equal_p (TREE_OPERAND (arg0, 3),
-				      TREE_OPERAND (arg1, 3), flags));
-
+	  /* Operands 2 and 3 may be null.  */
+	  return (OP_SAME (0)
+		  && OP_SAME (1)
+		  && OP_SAME_WITH_NULL (2)
+		  && OP_SAME_WITH_NULL (3));
 
 	case COMPONENT_REF:
-	  return (operand_equal_p (TREE_OPERAND (arg0, 0),
-				   TREE_OPERAND (arg1, 0), flags)
-		  && operand_equal_p (TREE_OPERAND (arg0, 1),
-				      TREE_OPERAND (arg1, 1), flags)
-		  && operand_equal_p (TREE_OPERAND (arg0, 2),
-				      TREE_OPERAND (arg1, 2), flags));
-
+	  /* Handle operand 2 the same as for ARRAY_REF.  */
+	  return OP_SAME (0) && OP_SAME (1) && OP_SAME_WITH_NULL (2);
 
 	case BIT_FIELD_REF:
-	  return (operand_equal_p (TREE_OPERAND (arg0, 0),
-				   TREE_OPERAND (arg1, 0), flags)
-		  && operand_equal_p (TREE_OPERAND (arg0, 1),
-				      TREE_OPERAND (arg1, 1), flags)
-		  && operand_equal_p (TREE_OPERAND (arg0, 2),
-				      TREE_OPERAND (arg1, 2), flags));
+	  return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
+
 	default:
 	  return 0;
 	}
@@ -2525,33 +2510,28 @@ operand_equal_p (tree arg0, tree arg1, unsigned int flags)
 	{
 	case ADDR_EXPR:
 	case TRUTH_NOT_EXPR:
-	  return operand_equal_p (TREE_OPERAND (arg0, 0),
-				  TREE_OPERAND (arg1, 0), flags);
+	  return OP_SAME (0);
 
 	case TRUTH_ANDIF_EXPR:
 	case TRUTH_ORIF_EXPR:
-	  return operand_equal_p (TREE_OPERAND (arg0, 0),
-				  TREE_OPERAND (arg1, 0), flags)
-		 && operand_equal_p (TREE_OPERAND (arg0, 1),
-				     TREE_OPERAND (arg1, 1), flags);
+	  return OP_SAME (0) && OP_SAME (1);
 
 	case TRUTH_AND_EXPR:
 	case TRUTH_OR_EXPR:
 	case TRUTH_XOR_EXPR:
+	  if (OP_SAME (0) && OP_SAME (1))
+	    return 1;
+
+	  /* Otherwise take into account this is a commutative operation.  */
 	  return (operand_equal_p (TREE_OPERAND (arg0, 0),
-				   TREE_OPERAND (arg1, 0), flags)
+				   TREE_OPERAND (arg1, 1), flags)
 		  && operand_equal_p (TREE_OPERAND (arg0, 1),
-				      TREE_OPERAND (arg1, 1), flags))
-		 || (operand_equal_p (TREE_OPERAND (arg0, 0),
-				      TREE_OPERAND (arg1, 1), flags)
-		     && operand_equal_p (TREE_OPERAND (arg0, 1),
-					 TREE_OPERAND (arg1, 0), flags));
+				      TREE_OPERAND (arg1, 0), flags));
 
 	case CALL_EXPR:
 	  /* If the CALL_EXPRs call different functions, then they
 	     clearly can not be equal.  */
-	  if (! operand_equal_p (TREE_OPERAND (arg0, 0),
-				 TREE_OPERAND (arg1, 0), flags))
+	  if (!OP_SAME (0))
 	    return 0;
 
 	  {
@@ -2597,6 +2577,9 @@ operand_equal_p (tree arg0, tree arg1, unsigned int flags)
     default:
       return 0;
     }
+
+#undef OP_SAME
+#undef OP_SAME_WITH_NULL
 }
 
 /* Similar to operand_equal_p, but see if ARG0 might have been made by