diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 1e22fd36845..bd9a3e04504 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,7 @@
+2005-11-08  Jason Merrill  <jason@redhat.com>
+
+	* tree.h (CALL_FROM_THUNK_P): Add CALL_EXPR_CHECK.
+
 2005-11-08  Uros Bizjak  <uros@kss-loka.si>
 
 	PR target/19340
diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 3d2f36ec767..1b2d16661ab 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,9 @@
+2005-11-08  Jason Merrill  <jason@redhat.com>
+
+	PR c++/21123
+	* method.c (use_thunk): Use build_cplus_new instead of 
+	force_target_expr.
+
 2005-11-06  Jason Merrill  <jason@redhat.com>
 	    James A. Morrison <phython@gcc.gnu.org>
 
diff --git a/gcc/cp/method.c b/gcc/cp/method.c
index d68423ce8fe..67e42ea1e0e 100644
--- a/gcc/cp/method.c
+++ b/gcc/cp/method.c
@@ -502,7 +502,8 @@ use_thunk (tree thunk_fndecl, bool emit_p)
 		t = build3 (COND_EXPR, TREE_TYPE (t), cond, t,
 			    cp_convert (TREE_TYPE (t), integer_zero_node));
 	    }
-	  t = force_target_expr (TREE_TYPE (t), t);
+	  if (IS_AGGR_TYPE (TREE_TYPE (t)))
+	    t = build_cplus_new (TREE_TYPE (t), t);
 	  finish_return_stmt (t);
 	}
 
diff --git a/gcc/testsuite/g++.dg/inherit/thunk4.C b/gcc/testsuite/g++.dg/inherit/thunk4.C
new file mode 100644
index 00000000000..a6e913e59e3
--- /dev/null
+++ b/gcc/testsuite/g++.dg/inherit/thunk4.C
@@ -0,0 +1,23 @@
+// PR c++/21123
+
+struct A
+{
+  A( const A &a);
+  const A& operator=( const A& a);
+};
+
+struct B
+{
+  virtual A f();
+};
+
+struct C : virtual B
+{
+  virtual A f();
+  A a;
+};
+
+A C::f() 
+{
+  return a;
+}
diff --git a/gcc/tree.h b/gcc/tree.h
index 4705bb12b83..7b1796c0800 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -1023,7 +1023,7 @@ extern void tree_operand_check_failed (int, enum tree_code,
 
 /* In a CALL_EXPR, means that the call is the jump from a thunk to the
    thunked-to function.  */
-#define CALL_FROM_THUNK_P(NODE) ((NODE)->common.protected_flag)
+#define CALL_FROM_THUNK_P(NODE) (CALL_EXPR_CHECK (NODE)->common.protected_flag)
 
 /* In a type, nonzero means that all objects of the type are guaranteed by the
    language or front-end to be properly aligned, so we can indicate that a MEM