This patch needs to be submitted for the FSF.  Also, there may be testcases

 already in the GDB testsuite (currently disabled) that it would probably fix.

 Index: gdb-6.3/gdb/infcall.c

 ===================================================================

 --- gdb-6.3.orig/gdb/infcall.c	2004-10-08 04:15:56.000000000 -0400

 +++ gdb-6.3/gdb/infcall.c	2004-11-10 12:30:07.000000000 -0500

 @@ -36,6 +36,7 @@

  #include "gdb_string.h"

  #include "infcall.h"

  #include "dummy-frame.h"

 +#include "cp-abi.h"

  /* NOTE: cagney/2003-04-16: What's the future of this code?

 @@ -297,8 +298,8 @@ call_function_by_hand (struct value *fun

  {

    CORE_ADDR sp;

    CORE_ADDR dummy_addr;

 -  struct type *value_type;

 -  unsigned char struct_return;

 +  struct type *value_type, *target_value_type;

 +  unsigned char struct_return = 0, cp_struct_return = 0;

    CORE_ADDR struct_addr = 0;

    struct regcache *retbuf;

    struct cleanup *retbuf_cleanup;

 @@ -312,6 +313,7 @@ call_function_by_hand (struct value *fun

    struct regcache *caller_regcache;

    struct cleanup *caller_regcache_cleanup;

    struct frame_id dummy_id;

 +  struct cleanup *args_cleanup;

    if (!target_has_execution)

      noprocess ();

 @@ -410,10 +412,31 @@ call_function_by_hand (struct value *fun

      using_gcc = (b == NULL ? 2 : BLOCK_GCC_COMPILED (b));

    }

 -  /* Are we returning a value using a structure return or a normal

 -     value return? */

 +  /* Are we returning a value using a structure return (passing a

 +     hidden argument pointing to storage) or a normal value return?

 +     There are two cases: C++ ABI mandated structure return and

 +     target ABI structure return.  The variable STRUCT_RETURN only

 +     describes the latter.  The C++ version is handled by passing

 +     the return location as the first parameter to the function,

 +     even preceding "this".  This is different from the target

 +     ABI version, which is target-specific; for instance, on ia64

 +     the first argument is passed in out0 but the hidden structure

 +     return pointer would normally be passed in r8.  */

 -  struct_return = using_struct_return (value_type, using_gcc);

 +  if (current_language->la_language == language_cplus

 +      && cp_pass_by_reference (value_type))

 +    {

 +      cp_struct_return = 1;

 +

 +      /* Tell the target specific argument pushing routine not to

 +	 expect a value.  */

 +      target_value_type = builtin_type_void;

 +    }

 +  else

 +    {

 +      struct_return = using_struct_return (value_type, using_gcc);

 +      target_value_type = value_type;

 +    }

    /* Determine the location of the breakpoint (and possibly other

       stuff) that the called function will return to.  The SPARC, for a

 @@ -432,7 +455,7 @@ call_function_by_hand (struct value *fun

        if (INNER_THAN (1, 2))

  	{

  	  sp = push_dummy_code (current_gdbarch, sp, funaddr,

 -				using_gcc, args, nargs, value_type,

 +				using_gcc, args, nargs, target_value_type,

  				&real_pc, &bp_addr);

  	  dummy_addr = sp;

  	}

 @@ -440,7 +463,7 @@ call_function_by_hand (struct value *fun

  	{

  	  dummy_addr = sp;

  	  sp = push_dummy_code (current_gdbarch, sp, funaddr,

 -				using_gcc, args, nargs, value_type,

 +				using_gcc, args, nargs, target_value_type,

  				&real_pc, &bp_addr);

  	}

        break;

 @@ -507,9 +530,15 @@ call_function_by_hand (struct value *fun

  	  param_type = TYPE_FIELD_TYPE (ftype, i);

  	else

  	  param_type = NULL;

 -	

 +

  	args[i] = value_arg_coerce (args[i], param_type, prototyped);

 +	/* FIXME: Is current_language the right language?  */

 +	if (current_language->la_language == language_cplus

 +	    && param_type != NULL

 +	    && cp_pass_by_reference (param_type))

 +	  args[i] = value_addr (args[i]);

 +

  	/* elz: this code is to handle the case in which the function

  	   to be called has a pointer to function as parameter and the

  	   corresponding actual argument is the address of a function

 @@ -607,7 +636,7 @@ You must use a pointer to function type 

       stack, if necessary.  Make certain that the value is correctly

       aligned. */

 -  if (struct_return)

 +  if (struct_return || cp_struct_return)

      {

        int len = TYPE_LENGTH (value_type);

        if (INNER_THAN (1, 2))

 @@ -632,6 +661,22 @@ You must use a pointer to function type 

  	}

      }

 +  if (cp_struct_return)

 +    {

 +      struct value **new_args;

 +

 +      /* Add the new argument to the front of the argument list.  */

 +      new_args = xmalloc (sizeof (struct value *) * (nargs + 1));

 +      new_args[0] = value_from_pointer (lookup_pointer_type (value_type),

 +					struct_addr);

 +      memcpy (&new_args[1], &args[0], sizeof (struct value *) * nargs);

 +      args = new_args;

 +      nargs++;

 +      args_cleanup = make_cleanup (xfree, args);

 +    }

 +  else

 +    args_cleanup = make_cleanup (null_cleanup, NULL);

 +

    /* Create the dummy stack frame.  Pass in the call dummy address as,

       presumably, the ABI code knows where, in the call dummy, the

       return address should be pointed.  */

 @@ -649,6 +694,8 @@ You must use a pointer to function type 

    else

      error ("This target does not support function calls");

 +  do_cleanups (args_cleanup);

 +

    /* Set up a frame ID for the dummy frame so we can pass it to

       set_momentary_breakpoint.  We need to give the breakpoint a frame

       ID so that the breakpoint code can correctly re-identify the

 @@ -839,11 +886,7 @@ the function call).", name);

    /* Figure out the value returned by the function, return that.  */

    {

      struct value *retval;

 -    if (TYPE_CODE (value_type) == TYPE_CODE_VOID)

 -      /* If the function returns void, don't bother fetching the

 -	 return value.  */

 -      retval = allocate_value (value_type);

 -    else if (struct_return)

 +    if (struct_return || cp_struct_return)

        /* NOTE: cagney/2003-09-27: This assumes that PUSH_DUMMY_CALL

  	 has correctly stored STRUCT_ADDR in the target.  In the past

  	 that hasn't been the case, the old MIPS PUSH_ARGUMENTS

 @@ -853,6 +896,10 @@ the function call).", name);

  	 "struct return convention", check that PUSH_DUMMY_CALL isn't

  	 playing tricks.  */

        retval = value_at (value_type, struct_addr, NULL);

 +    else if (TYPE_CODE (value_type) == TYPE_CODE_VOID)

 +      /* If the function returns void, don't bother fetching the

 +	 return value.  */

 +      retval = allocate_value (value_type);

      else

        {

  	/* This code only handles "register convention".  */

 Index: gdb-6.3/gdb/cp-abi.h

 ===================================================================

 --- gdb-6.3.orig/gdb/cp-abi.h	2003-04-12 13:41:25.000000000 -0400

 +++ gdb-6.3/gdb/cp-abi.h	2004-11-10 12:30:07.000000000 -0500

 @@ -1,7 +1,7 @@

  /* Abstraction of various C++ ABI's we support, and the info we need

     to get from them.

     Contributed by Daniel Berlin <dberlin@redhat.com>

 -   Copyright 2001 Free Software Foundation, Inc.

 +   Copyright 2001, 2002, 2003, 2004 Free Software Foundation, Inc.

     This file is part of GDB.

 @@ -145,6 +145,10 @@ extern struct type *value_rtti_type (str

  extern int baseclass_offset (struct type *type, int index, char *valaddr,

  			     CORE_ADDR address);

 +/* Return non-zero if an argument of type TYPE should be passed by reference

 +   instead of value.  */

 +extern int cp_pass_by_reference (struct type *type);

 +

  struct cp_abi_ops

  {

    const char *shortname;

 @@ -162,6 +166,7 @@ struct cp_abi_ops

  			     int *using_enc);

    int (*baseclass_offset) (struct type *type, int index, char *valaddr,

  			   CORE_ADDR address);

 +  int (*pass_by_reference) (struct type *type);

  };

 Index: gdb-6.3/gdb/cp-abi.c

 ===================================================================

 --- gdb-6.3.orig/gdb/cp-abi.c	2003-11-26 17:04:00.000000000 -0500

 +++ gdb-6.3/gdb/cp-abi.c	2004-11-10 12:30:07.000000000 -0500

 @@ -1,5 +1,5 @@

  /* Generic code for supporting multiple C++ ABI's

 -   Copyright 2001, 2002, 2003 Free Software Foundation, Inc.

 +   Copyright 2001, 2002, 2003, 2004 Free Software Foundation, Inc.

     This file is part of GDB.

 @@ -94,6 +94,14 @@ value_rtti_type (struct value *v, int *f

    return (*current_cp_abi.rtti_type) (v, full, top, using_enc);

  }

 +int

 +cp_pass_by_reference (struct type *type)

 +{

 +  if ((current_cp_abi.pass_by_reference) == NULL)

 +    return 0;

 +  return (*current_cp_abi.pass_by_reference) (type);

 +}

 +

  /* Set the current C++ ABI to SHORT_NAME.  */

  static int

 Index: gdb-6.3/gdb/gnu-v3-abi.c

 ===================================================================

 --- gdb-6.3.orig/gdb/gnu-v3-abi.c	2004-03-15 15:38:08.000000000 -0500

 +++ gdb-6.3/gdb/gnu-v3-abi.c	2004-11-10 12:30:07.000000000 -0500

 @@ -1,7 +1,7 @@

  /* Abstraction of GNU v3 abi.

     Contributed by Jim Blandy <jimb@redhat.com>

 -   Copyright 2001, 2002, 2003 Free Software Foundation, Inc.

 +   Copyright 2001, 2002, 2003, 2004 Free Software Foundation, Inc.

     This file is part of GDB.

 @@ -419,6 +419,84 @@ gnuv3_baseclass_offset (struct type *typ

    return base_offset;

  }

 +/* Return nonzero if a type should be passed by reference.

 +

 +   The rule in the v3 ABI document comes from section 3.1.1.  If the

 +   type has a non-trivial copy constructor or destructor, then the

 +   caller must make a copy (by calling the copy constructor if there

 +   is one or perform the copy itself otherwise), pass the address of

 +   the copy, and then destroy the temporary (if necessary).

 +

 +   For return values with non-trivial copy constructors or

 +   destructors, space will be allocated in the caller, and a pointer

 +   will be passed as the first argument (preceding "this").

 +

 +   We don't have a bulletproof mechanism for determining whether a

 +   constructor or destructor is trivial.  For GCC and DWARF2 debug

 +   information, we can check the artificial flag.

 +

 +   We don't do anything with the constructors or destructors yet,

 +   but we have to get the argument passing right anyway.  */

 +static int

 +gnuv3_pass_by_reference (struct type *type)

 +{

 +  int fieldnum, fieldelem, basenum;

 +

 +  CHECK_TYPEDEF (type);

 +

 +  /* We're only interested in things that can have methods.  */

 +  if (TYPE_CODE (type) != TYPE_CODE_STRUCT

 +      && TYPE_CODE (type) != TYPE_CODE_CLASS

 +      && TYPE_CODE (type) != TYPE_CODE_UNION)

 +    return 0;

 +

 +  for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)

 +    for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);

 +	 fieldelem++)

 +      {

 +	struct fn_field *fn = TYPE_FN_FIELDLIST1 (type, fieldnum);

 +	char *name = TYPE_FN_FIELDLIST_NAME (type, fieldnum);

 +	struct type *fieldtype = TYPE_FN_FIELD_TYPE (fn, fieldelem);

 +

 +	/* If this function is marked as artificial, it is compiler-generated,

 +	   and we assume it is trivial.  */

 +	if (TYPE_FN_FIELD_ARTIFICIAL (fn, fieldelem))

 +	  continue;

 +

 +	/* If we've found a destructor, we must pass this by reference.  */

 +	if (name[0] == '~')

 +	  return 1;

 +

 +	/* If the mangled name of this method doesn't indicate that it

 +	   is a constructor, we're not interested.

 +

 +	   FIXME drow/2004-05-27: We could do this using the name of

 +	   the method and the name of the class instead of dealing

 +	   with the mangled name.  We don't have a convenient function

 +	   to strip off both leading scope qualifiers and trailing

 +	   template arguments yet.  */

 +	if (!is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn, fieldelem)))

 +	  continue;

 +

 +	/* If this method takes two arguments, and the second argument is

 +	   a reference to this class, then it is a copy constructor.  */

 +	if (TYPE_NFIELDS (fieldtype) == 2

 +	    && TYPE_CODE (TYPE_FIELD_TYPE (fieldtype, 1)) == TYPE_CODE_REF

 +	    && check_typedef (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (fieldtype, 1))) == type)

 +	  return 1;

 +      }

 +

 +  /* Even if all the constructors and destructors were artificial, one

 +     of them may have invoked a non-artificial constructor or

 +     destructor in a base class.  If any base class needs to be passed

 +     by reference, so does this class.  */

 +  for (basenum = 0; basenum < TYPE_N_BASECLASSES (type); basenum++)

 +    if (gnuv3_pass_by_reference (TYPE_BASECLASS (type, basenum)))

 +      return 1;

 +

 +  return 0;

 +}

 +

  static void

  init_gnuv3_ops (void)

  {

 @@ -434,6 +512,7 @@ init_gnuv3_ops (void)

    gnu_v3_abi_ops.rtti_type = gnuv3_rtti_type;

    gnu_v3_abi_ops.virtual_fn_field = gnuv3_virtual_fn_field;

    gnu_v3_abi_ops.baseclass_offset = gnuv3_baseclass_offset;

 +  gnu_v3_abi_ops.pass_by_reference = gnuv3_pass_by_reference;

  }

  extern initialize_file_ftype _initialize_gnu_v3_abi; /* -Wmissing-prototypes */

 Index: gdb-6.3/gdb/hpacc-abi.c

 ===================================================================

 --- gdb-6.3.orig/gdb/hpacc-abi.c	2003-06-08 14:27:13.000000000 -0400

 +++ gdb-6.3/gdb/hpacc-abi.c	2004-11-10 12:30:07.000000000 -0500

 @@ -3,7 +3,7 @@

     Most of the real code is from HP, i've just fiddled it to fit in

     the C++ ABI abstraction framework.

 -   Copyright 2001 Free Software Foundation, Inc.

 +   Copyright 2001, 2002, 2003 Free Software Foundation, Inc.

     This file is part of GDB.

 Index: gdb-6.3/gdb/Makefile.in

 ===================================================================

 --- gdb-6.3.orig/gdb/Makefile.in	2004-11-10 12:30:06.000000000 -0500

 +++ gdb-6.3/gdb/Makefile.in	2004-11-10 12:30:07.000000000 -0500

 @@ -2073,7 +2073,7 @@ ia64-tdep.o: ia64-tdep.c $(defs_h) $(inf

  infcall.o: infcall.c $(defs_h) $(breakpoint_h) $(target_h) $(regcache_h) \

  	$(inferior_h) $(gdb_assert_h) $(block_h) $(gdbcore_h) $(language_h) \

  	$(objfiles_h) $(gdbcmd_h) $(command_h) $(gdb_string_h) $(infcall_h) \

 -	$(dummy_frame_h)

 +	$(dummy_frame_h) $(cp_abi_h)

  inf-child.o: inf-child.c $(defs_h) $(regcache_h) $(memattr_h) $(symtab_h) \

  	$(target_h) $(inferior_h) $(gdb_string_h)

  infcmd.o: infcmd.c $(defs_h) $(gdb_string_h) $(symtab_h) $(gdbtypes_h) \

 Index: gdb-6.3/gdb/testsuite/gdb.cp/pass-by-ref.exp

 ===================================================================

 --- /dev/null	1970-01-01 00:00:00.000000000 +0000

 +++ gdb-6.3/gdb/testsuite/gdb.cp/pass-by-ref.exp	2004-11-11 09:48:00.498518899 -0500

 @@ -0,0 +1,38 @@

 +# This testcase is part of GDB, the GNU debugger.

 +

 +# Copyright 2004 Free Software Foundation, Inc.

 +

 +# This program is free software; you can redistribute it and/or modify

 +# it under the terms of the GNU General Public License as published by

 +# the Free Software Foundation; either version 2 of the License, or

 +# (at your option) any later version.

 +#

 +# This program is distributed in the hope that it will be useful,

 +# but WITHOUT ANY WARRANTY; without even the implied warranty of

 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 +# GNU General Public License for more details.

 +#

 +# You should have received a copy of the GNU General Public License

 +# along with this program; if not, write to the Free Software

 +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  

 +

 +# Check that GDB can call C++ functions whose parameters have

 +# object type, but are passed by reference.

 +

 +set testfile "pass-by-ref"

 +set srcfile ${testfile}.cc

 +set binfile ${objdir}/${subdir}/${testfile}

 +if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {

 +    return -1

 +}

 +

 +gdb_exit

 +gdb_start

 +gdb_reinitialize_dir $srcdir/$subdir

 +gdb_load ${binfile}

 +

 +if ![runto_main] then {

 +    return -1

 +}

 +

 +gdb_test "print foo (global_obj)" " = 3" "call function"

 Index: gdb-6.3/gdb/testsuite/gdb.cp/pass-by-ref.cc

 ===================================================================

 --- /dev/null	1970-01-01 00:00:00.000000000 +0000

 +++ gdb-6.3/gdb/testsuite/gdb.cp/pass-by-ref.cc	2004-11-11 09:44:17.815014667 -0500

 @@ -0,0 +1,57 @@

 +/* This testcase is part of GDB, the GNU debugger.

 +

 +   Copyright 2004 Free Software Foundation, Inc.

 +

 +   This program is free software; you can redistribute it and/or modify

 +   it under the terms of the GNU General Public License as published by

 +   the Free Software Foundation; either version 2 of the License, or

 +   (at your option) any later version.

 +

 +   This program is distributed in the hope that it will be useful,

 +   but WITHOUT ANY WARRANTY; without even the implied warranty of

 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 +   GNU General Public License for more details.

 + 

 +   You should have received a copy of the GNU General Public License

 +   along with this program; if not, write to the Free Software

 +   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,

 +   USA.  */

 +

 +class Obj {

 +public:

 +  Obj ();

 +  Obj (const Obj &);

 +  ~Obj ();

 +  int var[2];

 +};

 +

 +int foo (Obj arg)

 +{

 +  return arg.var[0] + arg.var[1];

 +}

 +

 +Obj::Obj ()

 +{

 +  var[0] = 1;

 +  var[1] = 2;

 +}

 +

 +Obj::Obj (const Obj &obj)

 +{

 +  var[0] = obj.var[0];

 +  var[1] = obj.var[1];

 +}

 +

 +Obj::~Obj ()

 +{

 +

 +}

 +

 +Obj global_obj;

 +

 +int

 +main ()

 +{

 +  int bar = foo (global_obj);

 +  return bar;

 +}