* 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-12 Andrew Cagney <cagney@gnu.org>
+
+ * 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 <tausq@debian.org>
* somread.c (som_symtab_read): Exclude gcc local symbols.
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
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);
until_break_command (arg, from_tty, 1);
}
\f
-
-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
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)
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)
{
return val;
}
\f
-/* 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
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))
projects / platform / upstream / binutils.git / commitdiff