From 44e5158b4560dd6ceb7a63cc7e79cb388f56e9d8 Mon Sep 17 00:00:00 2001 From: Andrew Cagney Date: Sat, 12 Jun 2004 18:02:30 +0000 Subject: [PATCH] 2004-06-12 Andrew Cagney * values.c (register_value_being_returned): Delete function. * infcmd.c (legacy_return_value): Delete function. * infcall.c (call_function_by_hand): Inline "register_value_being_returned", simplify. * values.c (using_struct_return): Update comment, refer to print_return_value instead of register_value_being_returned. * infcmd.c (print_return_value): Inline calls to register_value_being_returned and legacy_return_value. Simplify. --- gdb/ChangeLog | 11 ++++++++++ gdb/infcall.c | 47 ++++++++++++++++++++++++++++-------------- gdb/infcmd.c | 56 +++++++++++++++++---------------------------------- gdb/values.c | 46 +----------------------------------------- 4 files changed, 62 insertions(+), 98 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index d9bf0975722..74179f75136 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,14 @@ +2004-06-12 Andrew Cagney + + * values.c (register_value_being_returned): Delete function. + * infcmd.c (legacy_return_value): Delete function. + * infcall.c (call_function_by_hand): Inline + "register_value_being_returned", simplify. + * values.c (using_struct_return): Update comment, refer to + print_return_value instead of register_value_being_returned. + * infcmd.c (print_return_value): Inline calls to + register_value_being_returned and legacy_return_value. Simplify. + 2004-06-11 Randolph Chung * somread.c (som_symtab_read): Exclude gcc local symbols. diff --git a/gdb/infcall.c b/gdb/infcall.c index ce3f25470b5..8123806e9f6 100644 --- a/gdb/infcall.c +++ b/gdb/infcall.c @@ -922,9 +922,14 @@ the function call).", name); leave the RETBUF alone. */ do_cleanups (inf_status_cleanup); - /* Figure out the value returned by the function. */ - if (struct_return) - { + /* 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) /* 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 @@ -933,18 +938,30 @@ the function call).", name); you're seeing problems with values being returned using the "struct return convention", check that PUSH_DUMMY_CALL isn't playing tricks. */ - struct value *retval = value_at (value_type, struct_addr, NULL); - do_cleanups (retbuf_cleanup); - return retval; - } - else - { - /* The non-register case was handled above. */ - struct value *retval = register_value_being_returned (value_type, - retbuf); - do_cleanups (retbuf_cleanup); - return retval; - } + retval = value_at (value_type, struct_addr, NULL); + else if (gdbarch_return_value_p (current_gdbarch)) + { + /* This code only handles "register convention". */ + retval = allocate_value (value_type); + gdb_assert (gdbarch_return_value (current_gdbarch, value_type, + NULL, NULL, NULL) + == RETURN_VALUE_REGISTER_CONVENTION); + gdbarch_return_value (current_gdbarch, value_type, retbuf, + VALUE_CONTENTS_RAW (retval) /*read*/, + NULL /*write*/); + } + else + { + /* NOTE: cagney/2003-10-20: Unlike "gdbarch_return_value", the + EXTRACT_RETURN_VALUE and USE_STRUCT_CONVENTION methods do + not handle the edge case of a function returning a small + structure / union in registers. */ + retval = allocate_value (value_type); + EXTRACT_RETURN_VALUE (value_type, retbuf, VALUE_CONTENTS_RAW (retval)); + } + do_cleanups (retbuf_cleanup); + return retval; + } } void _initialize_infcall (void); diff --git a/gdb/infcmd.c b/gdb/infcmd.c index b58e4112064..4eeacca8838 100644 --- a/gdb/infcmd.c +++ b/gdb/infcmd.c @@ -1072,41 +1072,6 @@ advance_command (char *arg, int from_tty) until_break_command (arg, from_tty, 1); } - -static struct value * -legacy_return_value (int struct_return, struct type *value_type) -{ - struct value *value; - - if (!struct_return) - { - /* The return value can be found in the inferior's registers. */ - return register_value_being_returned (value_type, stop_registers); - } - - if (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()) - { - CORE_ADDR addr; - - addr = DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (stop_registers); - if (!addr) - error ("Function return value unknown."); - return value_at (value_type, addr, NULL); - } - - /* It is "struct return" yet the value is being extracted, - presumably from registers, using EXTRACT_RETURN_VALUE. This - doesn't make sense. Unfortunately, the legacy interfaces allowed - this behavior. Sigh! */ - value = allocate_value (value_type); - CHECK_TYPEDEF (value_type); - /* If the function returns void, don't bother fetching the return - value. */ - EXTRACT_RETURN_VALUE (value_type, stop_registers, - VALUE_CONTENTS_RAW (value)); - return value; -} - /* Print the result of a function at the end of a 'finish' command. */ static void @@ -1115,7 +1080,9 @@ print_return_value (int struct_return, struct type *value_type) struct gdbarch *gdbarch = current_gdbarch; struct cleanup *old_chain; struct ui_stream *stb; - struct value *value = NULL; + struct value *value; + + gdb_assert (TYPE_CODE (value_type) != TYPE_CODE_VOID); /* FIXME: 2003-09-27: When returning from a nested inferior function call, it's possible (with no help from the architecture vector) @@ -1135,13 +1102,26 @@ print_return_value (int struct_return, struct type *value_type) gdbarch_return_value (current_gdbarch, value_type, stop_registers, VALUE_CONTENTS_RAW (value), NULL); break; - case RETURN_VALUE_STRUCT_CONVENTION: + value = NULL; break; + default: + internal_error (__FILE__, __LINE__, "bad switch"); } } + else if (!struct_return && DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()) + { + CORE_ADDR addr = DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (stop_registers); + if (!addr) + error ("Function return value unknown."); + value = value_at (value_type, addr, NULL); + } else - value = legacy_return_value (struct_return, value_type); + { + value = allocate_value (value_type); + EXTRACT_RETURN_VALUE (value_type, stop_registers, + VALUE_CONTENTS_RAW (value)); + } if (value) { diff --git a/gdb/values.c b/gdb/values.c index f468ff8abf7..5ed10b56328 100644 --- a/gdb/values.c +++ b/gdb/values.c @@ -1202,50 +1202,6 @@ value_from_double (struct type *type, DOUBLEST num) return val; } -/* Deal with the return-value of a function that has "just returned". - - Extract the return-value (as a "struct value") that a function, - using register convention, has just returned to its caller. Assume - that the type of the function is VALTYPE, and that the "just - returned" register state is found in RETBUF. - - The function has "just returned" because GDB halts a returning - function by setting a breakpoint at the return address (in the - caller), and not the return instruction (in the callee). - - Because, in the case of a return from an inferior function call, - GDB needs to restore the inferiors registers, RETBUF is normally a - copy of the inferior's registers. */ - -struct value * -register_value_being_returned (struct type *valtype, struct regcache *retbuf) -{ - struct value *val = allocate_value (valtype); - - /* If the function returns void, don't bother fetching the return - value. See also "using_struct_return". */ - if (TYPE_CODE (valtype) == TYPE_CODE_VOID) - return val; - - if (!gdbarch_return_value_p (current_gdbarch)) - { - /* NOTE: cagney/2003-10-20: Unlike "gdbarch_return_value", the - EXTRACT_RETURN_VALUE and USE_STRUCT_CONVENTION methods do not - handle the edge case of a function returning a small - structure / union in registers. */ - CHECK_TYPEDEF (valtype); - EXTRACT_RETURN_VALUE (valtype, retbuf, VALUE_CONTENTS_RAW (val)); - return val; - } - - /* This function only handles "register convention". */ - gdb_assert (gdbarch_return_value (current_gdbarch, valtype, - NULL, NULL, NULL) - == RETURN_VALUE_REGISTER_CONVENTION); - gdbarch_return_value (current_gdbarch, valtype, retbuf, - VALUE_CONTENTS_RAW (val) /*read*/, NULL /*write*/); - return val; -} /* Should we use DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS instead of EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc and TYPE @@ -1287,7 +1243,7 @@ using_struct_return (struct type *value_type, int gcc_p) if (code == TYPE_CODE_VOID) /* A void return value is never in memory. See also corresponding - code in "register_value_being_returned". */ + code in "print_return_value". */ return 0; if (!gdbarch_return_value_p (current_gdbarch)) -- 2.30.2