From 5fe830e4fe7e59c595fac7082edb4954e17a7688 Mon Sep 17 00:00:00 2001 From: Andrew Cagney Date: Thu, 2 Oct 2003 04:40:58 +0000 Subject: [PATCH] 2003-10-01 Andrew Cagney * value.h (register_value_being_returned): Declare. Replace "value_being_returned". * infcall.c (call_function_by_hand): Use register_value_being_returned. * infcmd.c (print_return_value): Call "register_value_being_returned", handle struct return locally. * values.c (register_value_being_returned): New function. Replace "value_being_returned". --- gdb/ChangeLog | 13 +++++++++++- gdb/infcall.c | 9 +++----- gdb/infcmd.c | 36 +++++++++++++++++++++++++------ gdb/value.h | 5 ++--- gdb/values.c | 59 +++++++++++---------------------------------------- 5 files changed, 58 insertions(+), 64 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index adba7031fc7..1bed411b1ff 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,4 +1,15 @@ -2003-09-24 Elena Zannoni +2003-10-01 Andrew Cagney + + * value.h (register_value_being_returned): Declare. Replace + "value_being_returned". + * infcall.c (call_function_by_hand): Use + register_value_being_returned. + * infcmd.c (print_return_value): Call + "register_value_being_returned", handle struct return locally. + * values.c (register_value_being_returned): New function. Replace + "value_being_returned". + +2003-09-30 Elena Zannoni * linux-proc.c (linux_do_registers): New function. (linux_make_note_section): Use linux_do_registers in case of diff --git a/gdb/infcall.c b/gdb/infcall.c index 40dbb4b03cc..f9cb87e89d4 100644 --- a/gdb/infcall.c +++ b/gdb/infcall.c @@ -1101,12 +1101,9 @@ the function call).", name); } else { - /* This call to value_being_returned is never made when the - function uses "struct return convention". Hence, pass "0" - instead of STRUCT_RETURN. Besides, VALUE_TYPE, in - combination with RETURN_VALUE() (nee USE_STRUCT_CONVENTION) - can be used to re-construct the value of STRUCT_RETURN. */ - struct value *retval = value_being_returned (value_type, retbuf, 0); + /* The non-register case was handled above. */ + struct value *retval = register_value_being_returned (value_type, + retbuf); do_cleanups (retbuf_cleanup); return retval; } diff --git a/gdb/infcmd.c b/gdb/infcmd.c index 9fa05591484..cb6acf0704f 100644 --- a/gdb/infcmd.c +++ b/gdb/infcmd.c @@ -1070,7 +1070,7 @@ print_return_value (int structure_return, struct type *value_type) if (!structure_return) { - value = value_being_returned (value_type, stop_registers, 0); + value = register_value_being_returned (value_type, stop_registers); stb = ui_out_stream_new (uiout); ui_out_text (uiout, "Value returned is "); ui_out_field_fmt (uiout, "gdb-result-var", "$%d", record_latest_value (value)); @@ -1081,11 +1081,6 @@ print_return_value (int structure_return, struct type *value_type) } else { - /* FIXME: 2003-09-27: This code block should be handling the - "use struct convention" case, and not the function - value_being_returned. This would allow the dramatic - simplification of value_being_returned (perhaphs renamed to - register_value_being_returned). */ /* FIXME: 2003-09-27: When returning from a nested inferior function call, it's possible (with no help from the architecture vector) to locate and return/print a "struct @@ -1103,7 +1098,34 @@ print_return_value (int structure_return, struct type *value_type) ui_out_text (uiout, "."); ui_out_text (uiout, " Cannot determine contents\n"); #else - value = value_being_returned (value_type, stop_registers, 1); + if (EXTRACT_STRUCT_VALUE_ADDRESS_P ()) + { + CORE_ADDR addr = EXTRACT_STRUCT_VALUE_ADDRESS (stop_registers); + if (!addr) + error ("Function return value unknown."); + value = value_at (value_type, addr, NULL); + } + else if (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()) + { + char *buf = deprecated_grub_regcache_for_registers (stop_registers); + CORE_ADDR addr = DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (buf); + if (!addr) + error ("Function return value unknown."); + value = value_at (value_type, addr, NULL); + } + else + { + /* It is "struct return" yet the value is being extracted, + presumably from registers, using EXTRACT_RETURN_VALUE. + This doesn't make sense. Unfortunatly, 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)); + } stb = ui_out_stream_new (uiout); ui_out_text (uiout, "Value returned is "); ui_out_field_fmt (uiout, "gdb-result-var", "$%d", record_latest_value (value)); diff --git a/gdb/value.h b/gdb/value.h index 2040c86381d..1ee176a7d4b 100644 --- a/gdb/value.h +++ b/gdb/value.h @@ -416,9 +416,8 @@ extern struct value *value_repeat (struct value *arg1, int count); extern struct value *value_subscript (struct value *array, struct value *idx); -extern struct value *value_being_returned (struct type *valtype, - struct regcache *retbuf, - int struct_return); +extern struct value *register_value_being_returned (struct type *valtype, + struct regcache *retbuf); extern struct value *value_in (struct value *element, struct value *set); diff --git a/gdb/values.c b/gdb/values.c index 3d3238324c7..3b1bca8a786 100644 --- a/gdb/values.c +++ b/gdb/values.c @@ -1202,60 +1202,25 @@ value_from_double (struct type *type, DOUBLEST num) return val; } -/* Deal with the value that is "about to be returned". */ +/* Deal with the value that is "about to be returned". -/* Return the value that a function returning now - would be returning to its caller, assuming its type is VALTYPE. - RETBUF is where we look for what ought to be the contents - of the registers (in raw form). This is because it is often - desirable to restore old values to those registers - after saving the contents of interest, and then call - this function using the saved values. - struct_return is non-zero when the function in question is - using the structure return conventions on the machine in question; - 0 when it is using the value returning conventions (this often - means returning pointer to where structure is vs. returning value). */ - -/* FIXME: cagney/2003-09-27: Should move the "struct return - convention" code to the only call site in print_return_value that - needs it. This function can then be renamed to - "register_value_being_returned" and with the "struct_return" - parameter dropped. */ + Return the value that a function, using the register convention, + returning now would be returning to its caller, assuming its type + is VALTYPE. RETBUF is where we look for what ought to be the + contents of the registers (in raw form). This is because it is + often desirable to restore old values to those registers after + saving the contents of interest, and then call this function using + the saved values. */ struct value * -value_being_returned (struct type *valtype, struct regcache *retbuf, - int struct_return) +register_value_being_returned (struct type *valtype, struct regcache *retbuf) { - struct value *val; - CORE_ADDR addr; - - /* If this is not defined, just use EXTRACT_RETURN_VALUE instead. */ - if (EXTRACT_STRUCT_VALUE_ADDRESS_P ()) - if (struct_return) - { - addr = EXTRACT_STRUCT_VALUE_ADDRESS (retbuf); - if (!addr) - error ("Function return value unknown."); - return value_at (valtype, addr, NULL); - } - - /* If this is not defined, just use EXTRACT_RETURN_VALUE instead. */ - if (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()) - if (struct_return) - { - char *buf = deprecated_grub_regcache_for_registers (retbuf); - addr = DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (buf); - if (!addr) - error ("Function return value unknown."); - return value_at (valtype, addr, NULL); - } - - val = allocate_value (valtype); + struct value *val = allocate_value (valtype); CHECK_TYPEDEF (valtype); - /* If the function returns void, don't bother fetching the return value. */ + /* If the function returns void, don't bother fetching the return + value. */ if (TYPE_CODE (valtype) != TYPE_CODE_VOID) EXTRACT_RETURN_VALUE (valtype, retbuf, VALUE_CONTENTS_RAW (val)); - return val; }