value_arg_coerce (struct value *arg, struct type *param_type,
int is_prototyped)
{
- register struct type *arg_type = check_typedef (VALUE_TYPE (arg));
- register struct type *type
+ struct type *arg_type = check_typedef (VALUE_TYPE (arg));
+ struct type *type
= param_type ? check_typedef (param_type) : arg_type;
switch (TYPE_CODE (type))
CORE_ADDR
find_function_addr (struct value *function, struct type **retval_type)
{
- register struct type *ftype = check_typedef (VALUE_TYPE (function));
- register enum type_code code = TYPE_CODE (ftype);
+ struct type *ftype = check_typedef (VALUE_TYPE (function));
+ enum type_code code = TYPE_CODE (ftype);
struct type *value_type;
CORE_ADDR funaddr;
if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
|| TYPE_CODE (ftype) == TYPE_CODE_METHOD)
{
- funaddr = CONVERT_FROM_FUNC_PTR_ADDR (funaddr);
+ funaddr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
+ funaddr,
+ ¤t_target);
value_type = TYPE_TARGET_TYPE (ftype);
}
else
struct value *
call_function_by_hand (struct value *function, int nargs, struct value **args)
{
- register CORE_ADDR sp;
+ CORE_ADDR sp;
CORE_ADDR dummy_addr;
struct type *value_type;
unsigned char struct_return;
/* Are we returning a value using a structure return or a normal
value return? */
- struct_return = using_struct_return (function, funaddr, value_type,
- using_gcc);
+ struct_return = using_struct_return (value_type, using_gcc);
/* Determine the location of the breakpoint (and possibly other
stuff) that the called function will return to. The SPARC, for a
dummy_addr = DEPRECATED_CALL_DUMMY_ADDRESS ();
/* Make certain that the address points at real code, and not a
function descriptor. */
- dummy_addr = CONVERT_FROM_FUNC_PTR_ADDR (dummy_addr);
+ dummy_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
+ dummy_addr,
+ ¤t_target);
/* A call dummy always consists of just a single breakpoint, so
it's address is the same as the address of the dummy. */
bp_addr = dummy_addr;
dummy_addr = entry_point_address ();
/* Make certain that the address points at real code, and not
a function descriptor. */
- dummy_addr = CONVERT_FROM_FUNC_PTR_ADDR (dummy_addr);
+ dummy_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
+ dummy_addr,
+ ¤t_target);
/* A call dummy always consists of just a single breakpoint,
so it's address is the same as the address of the dummy. */
bp_addr = dummy_addr;
}
}
- if (REG_STRUCT_HAS_ADDR_P ())
+ if (DEPRECATED_REG_STRUCT_HAS_ADDR_P ())
{
int i;
/* This is a machine like the sparc, where we may need to pass a
|| (TYPE_CODE (arg_type) == TYPE_CODE_FLT
&& TYPE_LENGTH (arg_type) > 8)
)
- && REG_STRUCT_HAS_ADDR (using_gcc, arg_type))
+ && DEPRECATED_REG_STRUCT_HAS_ADDR (using_gcc, arg_type))
{
CORE_ADDR addr;
int len; /* = TYPE_LENGTH (arg_type); */
arg_type = check_typedef (VALUE_ENCLOSING_TYPE (args[i]));
len = TYPE_LENGTH (arg_type);
- if (STACK_ALIGN_P ())
+ if (DEPRECATED_STACK_ALIGN_P ())
/* MVS 11/22/96: I think at least some of this
stack_align code is really broken. Better to let
PUSH_ARGUMENTS adjust the stack in a target-defined
manner. */
- aligned_len = STACK_ALIGN (len);
+ aligned_len = DEPRECATED_STACK_ALIGN (len);
else
aligned_len = len;
if (INNER_THAN (1, 2))
if (struct_return)
{
int len = TYPE_LENGTH (value_type);
- if (STACK_ALIGN_P ())
+ if (DEPRECATED_STACK_ALIGN_P ())
/* NOTE: cagney/2003-03-22: Should rely on frame align, rather
than stack align to force the alignment of the stack. */
- len = STACK_ALIGN (len);
+ len = DEPRECATED_STACK_ALIGN (len);
if (INNER_THAN (1, 2))
{
/* Stack grows downward. Align STRUCT_ADDR and SP after
/* elz: on HPPA no need for this extra alignment, maybe it is needed
on other architectures. This is because all the alignment is
- taken care of in the above code (ifdef REG_STRUCT_HAS_ADDR) and
- in hppa_push_arguments */
+ taken care of in the above code (ifdef DEPRECATED_REG_STRUCT_HAS_ADDR)
+ and in hppa_push_arguments */
/* NOTE: cagney/2003-03-24: The below code is very broken. Given an
odd sized parameter the below will mis-align the stack. As was
suggested back in '96, better to let PUSH_ARGUMENTS handle it. */
/* MVS 11/22/96: I think at least some of this stack_align code
is really broken. Better to let push_dummy_call() adjust the
stack in a target-defined manner. */
- if (STACK_ALIGN_P () && INNER_THAN (1, 2))
+ if (DEPRECATED_STACK_ALIGN_P () && INNER_THAN (1, 2))
{
/* If stack grows down, we must leave a hole at the top. */
int len = 0;
len += TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
if (DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ())
len += DEPRECATED_CALL_DUMMY_STACK_ADJUST;
- sp -= STACK_ALIGN (len) - len;
+ sp -= DEPRECATED_STACK_ALIGN (len) - len;
}
}
handled any alignment issues, the code below is entirely
redundant. */
if (!gdbarch_push_dummy_call_p (current_gdbarch)
- && STACK_ALIGN_P () && !INNER_THAN (1, 2))
+ && DEPRECATED_STACK_ALIGN_P () && !INNER_THAN (1, 2))
{
/* If stack grows up, we must leave a hole at the bottom, note
that sp already has been advanced for the arguments! */
if (DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ())
sp += DEPRECATED_CALL_DUMMY_STACK_ADJUST;
- sp = STACK_ALIGN (sp);
+ sp = DEPRECATED_STACK_ALIGN (sp);
}
/* XXX This seems wrong. For stacks that grow down we shouldn't do
else
{
/* The assumption here is that push_dummy_call() returned the
- stack part of the frame ID. Unfortunatly, many older
+ stack part of the frame ID. Unfortunately, many older
architectures were, via a convoluted mess, relying on the
poorly defined and greatly overloaded
DEPRECATED_TARGET_READ_FP or DEPRECATED_FP_REGNUM to supply
do_cleanups (inf_status_cleanup);
/* Figure out the value returned by the function. */
- /* elz: I defined this new macro for the hppa architecture only.
- this gives us a way to get the value returned by the function
- from the stack, at the same address we told the function to put
- it. We cannot assume on the pa that r28 still contains the
- 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 */
-#ifdef VALUE_RETURNED_FROM_STACK
if (struct_return)
{
- do_cleanups (retbuf_cleanup);
- return 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))
- {
+ /* 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);
+ /* The non-register case was handled above. */
+ struct value *retval = register_value_being_returned (value_type,
+ retbuf);
do_cleanups (retbuf_cleanup);
return retval;
}