diff options
| -rw-r--r-- | gdb/ChangeLog | 11 | ||||
| -rw-r--r-- | gdb/hppa-tdep.c | 7 | ||||
| -rw-r--r-- | gdb/infcall.c | 27 | ||||
| -rw-r--r-- | gdb/infcmd.c | 16 | ||||
| -rw-r--r-- | gdb/values.c | 6 |
5 files changed, 55 insertions, 12 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 720229b..910bd3f 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,14 @@ +2003-10-01 Andrew Cagney <cagney@redhat.com> + + * infcall.c (call_function_by_hand): When STRUCT_RETURN, always + use STRUCT_ADDR. When not using "struct return convention", pass + "0" to "value_being_returned". Add FIXMEs. + * infcmd.c (print_return_value): Pass an explicit 0/1 to + value_being_returned. Add comments. + * values.c (value_being_returned): Add fixme. + * hppa-tdep.c (hppa_extract_struct_value_address): Add FIXME. + (hppa_value_returned_from_stack): Add FIXME. + 2003-09-30 David Carlton <carlton@kealia.com> * dwarf2read.c (struct die_info): Add 'parent' field; replace diff --git a/gdb/hppa-tdep.c b/gdb/hppa-tdep.c index e82d736..fda327f 100644 --- a/gdb/hppa-tdep.c +++ b/gdb/hppa-tdep.c @@ -2067,6 +2067,9 @@ hppa_push_arguments (int nargs, struct value **args, CORE_ADDR sp, This function does the same stuff as value_being_returned in values.c, but gets the value from the stack rather than from the buffer where all the registers were saved when the function called completed. */ +/* FIXME: cagney/2003-09-27: This function is no longer needed. The + inferior function call code now directly handles the case described + above. */ struct value * hppa_value_returned_from_stack (struct type *valtype, CORE_ADDR addr) { @@ -5040,6 +5043,10 @@ hppa_extract_struct_value_address (char *regbuf) the address size is equal to the size of an int* _on the host_... One possible implementation that crossed my mind is to use extract_address. */ + /* FIXME: cagney/2003-09-27: This function can probably go. ELZ + writes: We cannot assume on the pa that r28 still contains the + address of the returned structure. Usually this will be + overwritten by the callee. */ return (*(int *)(regbuf + DEPRECATED_REGISTER_BYTE (28))); } diff --git a/gdb/infcall.c b/gdb/infcall.c index 0477d1e..40dbb4b 100644 --- a/gdb/infcall.c +++ b/gdb/infcall.c @@ -1076,6 +1076,8 @@ the function call).", name); address of the returned structure. Usually this will be overwritten by the callee. I don't know about other architectures, so I defined this macro */ + /* FIXME: cagney/2003-09-27: This is no longer needed. The problem + is now handled directly be by the code below. */ #ifdef DEPRECATED_VALUE_RETURNED_FROM_STACK if (struct_return) { @@ -1083,23 +1085,28 @@ the function call).", name); return DEPRECATED_VALUE_RETURNED_FROM_STACK (value_type, struct_addr); } #endif - /* NOTE: cagney/2002-09-10: Only when the stack has been correctly - aligned (using frame_align()) do we can trust STRUCT_ADDR and - fetch the return value direct from the stack. This lack of trust - comes about because legacy targets have a nasty habit of - silently, and local to PUSH_ARGUMENTS(), moving STRUCT_ADDR. For - such targets, just hope that value_being_returned() can find the - adjusted value. */ - if (struct_return && gdbarch_frame_align_p (current_gdbarch)) + 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. */ struct value *retval = value_at (value_type, struct_addr, NULL); do_cleanups (retbuf_cleanup); return retval; } else { - struct value *retval = value_being_returned (value_type, retbuf, - struct_return); + /* 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); do_cleanups (retbuf_cleanup); return retval; } diff --git a/gdb/infcmd.c b/gdb/infcmd.c index f232fd5..9fa0559 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, structure_return); + value = value_being_returned (value_type, stop_registers, 0); 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,6 +1081,18 @@ 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 + return" value. This is just a more complicated case of what + is already being done in in the inferior function call code. + In fact, when inferior function calls are made async, this + will likely be made the norm. */ /* We cannot determine the contents of the structure because it is on the stack, and we don't know where, since we did not initiate the call, as opposed to the call_function_by_hand case */ @@ -1091,7 +1103,7 @@ 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, structure_return); + value = value_being_returned (value_type, stop_registers, 1); 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/values.c b/gdb/values.c index 52f70a1..3d32383 100644 --- a/gdb/values.c +++ b/gdb/values.c @@ -1216,6 +1216,12 @@ value_from_double (struct type *type, DOUBLEST num) 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. */ + struct value * value_being_returned (struct type *valtype, struct regcache *retbuf, int struct_return) |