RepoMirrors/openwrt
1
0
Fork 0
mirror of git://git.openwrt.org/openwrt/openwrt.git synced 2024-12-14 19:04:39 +00:00
Code Issues Packages Projects Releases Wiki Activity
71b43456c7
openwrt/toolchain/gdb/patches/700-debian_cp-pass-by-reference.patch
Felix Fietkau 60c1f0f64d finally move buildroot-ng to trunk
2016-03-20 17:29:15 +01:00

465 lines
16 KiB
Diff
Raw Blame History

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;
+}
Reference in New Issue View Git Blame Copy Permalink