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;
vector. Hence this direct call.
A follow-on change is to modify this interface so that it takes
- thread OR frame OR tpid as a parameter, and returns a dummy
+ thread OR frame OR ptid as a parameter, and returns a dummy
frame handle. The handle can then be used further down as a
parameter to generic_save_dummy_frame_tos(). Hmm, thinking
about it, since everything is ment to be using generic dummy
CORE_ADDR old_sp = read_sp ();
if (gdbarch_frame_align_p (current_gdbarch))
{
+ sp = gdbarch_frame_align (current_gdbarch, old_sp);
+ /* NOTE: cagney/2003-08-13: Skip the "red zone". For some
+ ABIs, a function can use memory beyond the inner most stack
+ address. AMD64 called that region the "red zone". Skip at
+ least the "red zone" size before allocating any space on
+ the stack. */
+ if (INNER_THAN (1, 2))
+ sp -= gdbarch_frame_red_zone_size (current_gdbarch);
+ else
+ sp += gdbarch_frame_red_zone_size (current_gdbarch);
+ /* Still aligned? */
+ gdb_assert (sp == gdbarch_frame_align (current_gdbarch, sp));
/* NOTE: cagney/2002-09-18:
On a RISC architecture, a void parameterless generic dummy
frame (i.e., no parameters, no result) typically does not
need to push anything the stack and hence can leave SP and
- FP. Similarly, a framelss (possibly leaf) function does
+ FP. Similarly, a frameless (possibly leaf) function does
not push anything on the stack and, hence, that too can
leave FP and SP unchanged. As a consequence, a sequence of
void parameterless generic dummy frame calls to frameless
stack. That way, two dummy frames can never be identical.
It does burn a few bytes of stack but that is a small price
to pay :-). */
- sp = gdbarch_frame_align (current_gdbarch, old_sp);
if (sp == old_sp)
{
if (INNER_THAN (1, 2))
else
/* FIXME: cagney/2002-09-18: Hey, you loose!
- Who knows how badly aligned the SP is! Further, per comment
- above, if the generic dummy frame ends up empty (because
- nothing is pushed) GDB won't be able to correctly perform
- back traces. If a target is having trouble with backtraces,
- first thing to do is add FRAME_ALIGN() to the architecture
- vector. If that fails, try unwind_dummy_id(). */
+ Who knows how badly aligned the SP is!
+
+ If the generic dummy frame ends up empty (because nothing is
+ pushed) GDB won't be able to correctly perform back traces.
+ If a target is having trouble with backtraces, first thing to
+ do is add FRAME_ALIGN() to the architecture vector. If that
+ fails, try unwind_dummy_id().
+
+ If the ABI specifies a "Red Zone" (see the doco) the code
+ below will quietly trash it. */
sp = old_sp;
}
/* 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
value_type, using_gcc);
}
real_pc = funaddr;
- dummy_addr = CALL_DUMMY_ADDRESS ();
+ dummy_addr = entry_point_address ();
+ if (DEPRECATED_CALL_DUMMY_ADDRESS_P ())
+ /* Override it. */
+ dummy_addr = DEPRECATED_CALL_DUMMY_ADDRESS ();
+ /* Make certain that the address points at real code, and not a
+ function descriptor. */
+ 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;
break;
+ case AT_SYMBOL:
+ /* Some executables define a symbol __CALL_DUMMY_ADDRESS whose
+ address is the location where the breakpoint should be
+ placed. Once all targets are using the overhauled frame code
+ this can be deleted - ON_STACK is a better option. */
+ {
+ struct minimal_symbol *sym;
+
+ sym = lookup_minimal_symbol ("__CALL_DUMMY_ADDRESS", NULL, NULL);
+ real_pc = funaddr;
+ if (sym)
+ dummy_addr = SYMBOL_VALUE_ADDRESS (sym);
+ else
+ dummy_addr = entry_point_address ();
+ /* Make certain that the address points at real code, and not
+ a function descriptor. */
+ 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;
+ break;
+ }
default:
internal_error (__FILE__, __LINE__, "bad switch");
}
}
}
- 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
if (stopped_by_random_signal || !stop_stack_dummy)
{
/* Find the name of the function we're about to complain about. */
- char *name = NULL;
+ const char *name = NULL;
{
struct symbol *symbol = find_pc_function (funaddr);
if (symbol)
if (msymbol)
name = SYMBOL_PRINT_NAME (msymbol);
}
+ if (name == NULL)
+ {
+ /* Can't use a cleanup here. It is discarded, instead use
+ an alloca. */
+ char *tmp = xstrprintf ("at %s", local_hex_string (funaddr));
+ char *a = alloca (strlen (tmp) + 1);
+ strcpy (a, tmp);
+ xfree (tmp);
+ name = a;
+ }
}
- if (name == NULL)
- {
- /* NOTE: cagney/2003-04-23: Don't blame me. This code dates
- back to 1993-07-08, I simply moved it. */
- char format[80];
- sprintf (format, "at %s", local_hex_format ());
- name = alloca (80);
- /* FIXME-32x64: assumes funaddr fits in a long. */
- sprintf (name, format, (unsigned long) funaddr);
- }
if (stopped_by_random_signal)
{
/* We stopped inside the FUNCTION because of a random
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;
}