/* Perform an inferior function call, for GDB, the GNU debugger.
- Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
- 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
+ Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
+ 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
Free Software Foundation, Inc.
This file is part of GDB.
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. */
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
#include "defs.h"
#include "breakpoint.h"
with "set coerce-float-to-double 0". */
static int coerce_float_to_double_p = 1;
+static void
+show_coerce_float_to_double_p (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("\
+Coercion of floats to doubles when calling functions is %s.\n"),
+ value);
+}
/* This boolean tells what gdb should do if a signal is received while
in a function called from gdb (call dummy). If set, gdb unwinds
The default is to stop in the frame where the signal was received. */
int unwind_on_signal_p = 0;
+static void
+show_unwind_on_signal_p (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("\
+Unwinding of stack if a signal is received while in a call dummy is %s.\n"),
+ value);
+}
+
/* Perform the standard coercions that are specified
for arguments to be passed to C functions.
switch (TYPE_CODE (type))
{
case TYPE_CODE_REF:
- if (TYPE_CODE (arg_type) != TYPE_CODE_REF
- && TYPE_CODE (arg_type) != TYPE_CODE_PTR)
- {
- arg = value_addr (arg);
- deprecated_set_value_type (arg, param_type);
- return arg;
- }
- break;
+ {
+ struct value *new_value;
+
+ if (TYPE_CODE (arg_type) == TYPE_CODE_REF)
+ return value_cast_pointers (type, arg);
+
+ /* Cast the value to the reference's target type, and then
+ convert it back to a reference. This will issue an error
+ if the value was not previously in memory - in some cases
+ we should clearly be allowing this, but how? */
+ new_value = value_cast (TYPE_TARGET_TYPE (type), arg);
+ new_value = value_ref (new_value);
+ return new_value;
+ }
case TYPE_CODE_INT:
case TYPE_CODE_CHAR:
case TYPE_CODE_BOOL:
case TYPE_CODE_STRING:
case TYPE_CODE_BITSTRING:
case TYPE_CODE_ERROR:
- case TYPE_CODE_MEMBER:
+ case TYPE_CODE_MEMBERPTR:
+ case TYPE_CODE_METHODPTR:
case TYPE_CODE_METHOD:
case TYPE_CODE_COMPLEX:
default:
struct cleanup *caller_regcache_cleanup;
struct frame_id dummy_id;
+ if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
+ ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
+
if (!target_has_execution)
noprocess ();
+ if (!gdbarch_push_dummy_call_p (current_gdbarch))
+ error (_("This target does not support function calls"));
+
/* Create a cleanup chain that contains the retbuf (buffer
containing the register values). This chain is create BEFORE the
inf_status chain so that the inferior status can cleaned up
/* 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. */
- if (gdbarch_push_dummy_call_p (current_gdbarch))
- /* When there is no push_dummy_call method, should this code
- simply error out. That would the implementation of this method
- for all ABIs (which is probably a good thing). */
- sp = gdbarch_push_dummy_call (current_gdbarch, function, current_regcache,
- bp_addr, nargs, args, sp, struct_return,
- struct_addr);
- else if (DEPRECATED_PUSH_ARGUMENTS_P ())
- /* Keep old targets working. */
- sp = DEPRECATED_PUSH_ARGUMENTS (nargs, args, sp, struct_return,
- struct_addr);
- else
- error (_("This target does not support function calls"));
+ sp = gdbarch_push_dummy_call (current_gdbarch, function, current_regcache,
+ bp_addr, nargs, args, sp, struct_return,
+ struct_addr);
/* 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
leave the RETBUF alone. */
do_cleanups (inf_status_cleanup);
- /* Figure out the value returned by the function, return that. */
+ /* Figure out the value returned by the function. */
{
- struct value *retval;
+ struct value *retval = NULL;
+
if (TYPE_CODE (values_type) == TYPE_CODE_VOID)
- /* If the function returns void, don't bother fetching the
- return value. */
- retval = allocate_value (values_type);
- else if (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
- (PUSH_DUMMY_CALL precursor) would silently move the location
- of the struct return value making STRUCT_ADDR bogus. If
- you're seeing problems with values being returned using the
- "struct return convention", check that PUSH_DUMMY_CALL isn't
- playing tricks. */
- retval = value_at (values_type, struct_addr);
- else
{
- /* This code only handles "register convention". */
+ /* If the function returns void, don't bother fetching the
+ return value. */
retval = allocate_value (values_type);
- gdb_assert (gdbarch_return_value (current_gdbarch, values_type,
- NULL, NULL, NULL)
- == RETURN_VALUE_REGISTER_CONVENTION);
- gdbarch_return_value (current_gdbarch, values_type, retbuf,
- value_contents_raw (retval) /*read*/,
- NULL /*write*/);
}
+ else
+ {
+ struct gdbarch *arch = current_gdbarch;
+
+ switch (gdbarch_return_value (arch, values_type, NULL, NULL, NULL))
+ {
+ case RETURN_VALUE_REGISTER_CONVENTION:
+ case RETURN_VALUE_ABI_RETURNS_ADDRESS:
+ case RETURN_VALUE_ABI_PRESERVES_ADDRESS:
+ retval = allocate_value (values_type);
+ gdbarch_return_value (current_gdbarch, values_type, retbuf,
+ value_contents_raw (retval), NULL);
+ break;
+ case RETURN_VALUE_STRUCT_CONVENTION:
+ retval = value_at (values_type, struct_addr);
+ break;
+ }
+ }
+
do_cleanups (retbuf_cleanup);
+
+ gdb_assert(retval);
return retval;
}
}
+\f
+/* Provide a prototype to silence -Wmissing-prototypes. */
void _initialize_infcall (void);
void
set, GDB will perform the conversion for a function it considers\n\
unprototyped.\n\
The default is to perform the conversion.\n"),
- NULL, /* FIXME: i18n: Coercion of floats to doubles when calling functions is %s. */
- NULL, NULL, &setlist, &showlist);
+ NULL,
+ show_coerce_float_to_double_p,
+ &setlist, &showlist);
add_setshow_boolean_cmd ("unwindonsignal", no_class,
&unwind_on_signal_p, _("\
is received while in a function called from gdb (call dummy). If set, gdb\n\
unwinds the stack and restore the context to what as it was before the call.\n\
The default is to stop in the frame where the signal was received."),
- NULL, /* FIXME: i18n: Unwinding of stack if a signal is received while in a call dummy is %s. */
- NULL, NULL, &setlist, &showlist);
+ NULL,
+ show_unwind_on_signal_p,
+ &setlist, &showlist);
}
projects / deliverable / binutils-gdb.git / blobdiff