From ac5a28a64eb31508e1708a480583829edfe3e23d Mon Sep 17 00:00:00 2001
From: Jan Hubicka <jh@suse.cz>
Date: Fri, 4 May 2007 02:40:20 +0200
Subject: [PATCH] fold-const.c (fold_unary): Convert (T1)(X op Y) into ((T1)X
 op (T1)Y)...

	* fold-const.c (fold_unary): Convert (T1)(X op Y) into ((T1)X op (T1)Y),
	for pointer type in more cases than before.

	* gimplify.c (gimplify_expr): Fold (void *)&a + 4.

	* tree-object-size.c (plus_expr_object_size): When operand size is
	unknown, return unknown.

From-SVN: r124403
---
 gcc/ChangeLog          | 10 ++++++++++
 gcc/fold-const.c       | 24 ++++++++++--------------
 gcc/gimplify.c         | 17 ++++++++++++++++-
 gcc/tree-object-size.c |  4 +++-
 4 files changed, 39 insertions(+), 16 deletions(-)

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index eb93c4bc994a..1add00feeb6f 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,13 @@
+2007-05-03  Jan Hubicka  <jh@suse.cz>
+
+	* fold-const.c (fold_unary): Convert (T1)(X op Y) into ((T1)X op (T1)Y),
+	for pointer type in more cases than before.
+
+	* gimplify.c (gimplify_expr): Fold (void *)&a + 4.
+
+	* tree-object-size.c (plus_expr_object_size): When operand size is
+	unknown, return unknown.
+
 2007-05-03  Dirk Mueller  <dmueller@suse.de>
 
 	* doc/invoke.texi (-m386,-m486,-mpentium,-mpentiumpro): Remove.
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 2d9f752c5b37..ba17d464d05b 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -7814,24 +7814,20 @@ fold_unary (enum tree_code code, tree type, tree op0)
 	    }
 	}
 
-      /* Convert (T1)((T2)X op Y) into (T1)X op Y, for pointer types T1 and
-	 T2 being pointers to types of the same size.  */
-      if (POINTER_TYPE_P (type)
+      /* Convert (T1)(X op Y) into ((T1)X op (T1)Y), for pointer type,
+         when one of the new casts will fold away. Conservatively we assume
+	 that this happens when X or Y is NOP_EXPR or Y is INTEGER_CST.  */
+      if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE (arg0))
 	  && BINARY_CLASS_P (arg0)
-	  && TREE_CODE (TREE_OPERAND (arg0, 0)) == NOP_EXPR
-	  && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 0))))
+	  && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
+	      || TREE_CODE (TREE_OPERAND (arg0, 0)) == NOP_EXPR
+	      || TREE_CODE (TREE_OPERAND (arg0, 1)) == NOP_EXPR))
 	{
 	  tree arg00 = TREE_OPERAND (arg0, 0);
-	  tree t0 = type;
-	  tree t1 = TREE_TYPE (arg00);
-	  tree tt0 = TREE_TYPE (t0);
-	  tree tt1 = TREE_TYPE (t1);
-	  tree s0 = TYPE_SIZE (tt0);
-	  tree s1 = TYPE_SIZE (tt1);
+	  tree arg01 = TREE_OPERAND (arg0, 1);
 
-	  if (s0 && s1 && operand_equal_p (s0, s1, OEP_ONLY_CONST))
-	    return build2 (TREE_CODE (arg0), t0, fold_convert (t0, arg00),
-			   TREE_OPERAND (arg0, 1));
+	  return fold_build2 (TREE_CODE (arg0), type, fold_convert (type, arg00),
+			      fold_convert (type, arg01));
 	}
 
       /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index 805c30202723..3efb2b868c84 100644
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -5881,7 +5881,22 @@ gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p,
 	     {
                *expr_p = build_fold_addr_expr_with_type (tmp,
 							 TREE_TYPE (*expr_p));
-		break;
+	       break;
+	     }
+	  /* Convert (void *)&a + 4 into (void *)&a[1].  */
+	  if (POINTER_TYPE_P (TREE_TYPE (*expr_p))
+	      && TREE_CODE (TREE_OPERAND (*expr_p, 0)) == NOP_EXPR
+	      && TREE_CODE (TREE_OPERAND (*expr_p, 1)) == INTEGER_CST
+	      && (tmp = maybe_fold_offset_to_reference
+			 (TREE_OPERAND (TREE_OPERAND (*expr_p, 0), 0),
+			  TREE_OPERAND (*expr_p, 1),
+		   	  TREE_TYPE (TREE_TYPE
+				  (TREE_OPERAND (TREE_OPERAND (*expr_p, 0),
+						 0))))))
+	     {
+               tmp = build_fold_addr_expr (tmp);
+               *expr_p = fold_convert (TREE_TYPE (*expr_p), tmp);
+	       break;
 	     }
           /* FALLTHRU */
 	default:
diff --git a/gcc/tree-object-size.c b/gcc/tree-object-size.c
index f1852ca5a7ba..1eb09cbc50a5 100644
--- a/gcc/tree-object-size.c
+++ b/gcc/tree-object-size.c
@@ -588,7 +588,9 @@ plus_expr_object_size (struct object_size_info *osi, tree var, tree value)
 	  unsigned HOST_WIDE_INT off = tree_low_cst (op1, 1);
 
 	  bytes = compute_builtin_object_size (op0, object_size_type);
-	  if (off > offset_limit)
+	  if (bytes == unknown[object_size_type])
+	    ;
+	  else if (off > offset_limit)
 	    bytes = unknown[object_size_type];
 	  else if (off > bytes)
 	    bytes = 0;