re PR c++/16405 (Temporary aggregate copy not elided)

	PR c++/16405
	* gimplify.c (gimplify_modify_expr_rhs): Handle
	INDIRECT_REF/ADDR_EXPR combinations.

	PR c++/16405
	* g++.dg/opt/temp1.C: New test.

From-SVN: r92539

gcc/ChangeLog

+2004-12-23  Mark Mitchell  <mark@codesourcery.com>
+
+	PR c++/16405
+	* gimplify.c (gimplify_modify_expr_rhs): Handle
+	INDIRECT_REF/ADDR_EXPR combinations.
+
 2004-12-22  Richard Henderson  <rth@redhat.com>
 
 	* config/alpha/alpha.c (alpha_expand_mov): Split out ...

gcc/gimplify.c

@@ -2801,6 +2801,33 @@ gimplify_modify_expr_rhs (tree *expr_p, tree *from_p, tree *to_p, tree *pre_p,
   while (ret != GS_UNHANDLED)
     switch (TREE_CODE (*from_p))
       {
+      case INDIRECT_REF:
+	{
+	  /* If we have code like 
+
+	        *(const A*)(A*)&x
+
+	     where the type of "x" is a (possibly cv-qualified variant
+	     of "A"), treat the entire expression as identical to "x".
+	     This kind of code arises in C++ when an object is bound
+	     to a const reference, and if "x" is a TARGET_EXPR we want
+	     to take advantage of the optimization below.  */
+	  tree pointer;
+
+	  pointer = TREE_OPERAND (*from_p, 0);
+	  STRIP_NOPS (pointer);
+	  if (TREE_CODE (pointer) == ADDR_EXPR
+	      && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (pointer, 0)))
+		  == TYPE_MAIN_VARIANT (TREE_TYPE (*from_p))))
+	    {
+	      *from_p = TREE_OPERAND (pointer, 0); 
+	      ret = GS_OK;
+	    }
+	  else
+	    ret = GS_UNHANDLED;
+	  break;
+	}
+
       case TARGET_EXPR:
 	{
 	  /* If we are initializing something from a TARGET_EXPR, strip the

gcc/testsuite/ChangeLog

+2004-12-23  Mark Mitchell  <mark@codesourcery.com>
+
+	PR c++/16405
+	* g++.dg/opt/temp1.C: New test.
+
 2004-12-23  Giovanni Bajo  <giovannibajo@gcc.gnu.org>
 
 	PR c++/18733

gcc/testsuite/g++.dg/opt/temp1.C

+// PR c++/16405
+// { dg-options "-O2" } 
+
+// There should be exactly one temporary generated for the code in "f"
+// below when optimizing -- for the result of "b + c".  We have no
+// easy way of checking that directly, so we count the number of calls
+// to "memcpy", which is used on (some?) targets to copy temporaries.
+// If there is more than two calls (one for coping "*this" to "t", and
+// one for copying the temporary to "a"), then there are too many
+// temporaries. 
+
+int i;
+
+extern "C"
+void *memcpy (void *dest, const void *src, __SIZE_TYPE__ n)
+{
+  ++i;
+}
+ 
+struct T {
+  int a[128];
+  T &operator+=(T const &v) __attribute__((noinline));
+  T operator+(T const &v) const { T t = *this; t += v; return t; }
+};
+
+T &T::operator+=(T const &v) {
+  return *this;
+}
+
+T a, b, c;
+
+void f() { a = b + c; }
+
+int main () {
+  i = 0;
+  f();
+  if (i > 2)
+    return 1;
+}