int
f77_get_dynamic_lowerbound (struct type *type, int *lower_bound)
{
CORE_ADDR current_frame_addr;
CORE_ADDR ptr_to_lower_bound;
switch (TYPE_ARRAY_LOWER_BOUND_TYPE (type))
{
case BOUND_BY_VALUE_ON_STACK:
current_frame_addr = get_frame_base (deprecated_selected_frame);
if (current_frame_addr > 0)
{
*lower_bound =
read_memory_integer (current_frame_addr +
TYPE_ARRAY_LOWER_BOUND_VALUE (type),
4);
}
else
{
*lower_bound = DEFAULT_LOWER_BOUND;
return BOUND_FETCH_ERROR;
}
break;
case BOUND_SIMPLE:
*lower_bound = TYPE_ARRAY_LOWER_BOUND_VALUE (type);
break;
case BOUND_CANNOT_BE_DETERMINED:
error ("Lower bound may not be '*' in F77");
break;
case BOUND_BY_REF_ON_STACK:
current_frame_addr = get_frame_base (deprecated_selected_frame);
if (current_frame_addr > 0)
{
ptr_to_lower_bound =
read_memory_typed_address (current_frame_addr +
TYPE_ARRAY_LOWER_BOUND_VALUE (type),
builtin_type_void_data_ptr);
*lower_bound = read_memory_integer (ptr_to_lower_bound, 4);
}
else
{
*lower_bound = DEFAULT_LOWER_BOUND;
return BOUND_FETCH_ERROR;
}
break;
case BOUND_BY_REF_IN_REG:
case BOUND_BY_VALUE_IN_REG:
default:
error ("??? unhandled dynamic array bound type ???");
break;
}
return BOUND_FETCH_OK;
}
static CORE_ADDR
alpha_osf1_sigcontext_addr (struct frame_info *frame)
{
struct frame_info *next_frame = get_next_frame (frame);
if (next_frame != NULL)
return (read_memory_integer (get_frame_base (next_frame), 8));
else
return (read_memory_integer (get_frame_base (frame), 8));
}
static CORE_ADDR
alphanbsd_sigcontext_addr (struct frame_info *frame)
{
/* FIXME: This is not correct for all versions of NetBSD/alpha.
We will probably need to disassemble the trampoline to figure
out which trampoline frame type we have. */
return get_frame_base (frame);
}
static int
derive_stack_segment (bfd_vma *bottom, bfd_vma *top)
{
struct frame_info *fi, *tmp_fi;
gdb_assert (bottom);
gdb_assert (top);
/* Can't succeed without stack and registers. */
if (!target_has_stack || !target_has_registers)
return 0;
/* Can't succeed without current frame. */
fi = get_current_frame ();
if (fi == NULL)
return 0;
/* Save frame pointer of TOS frame. */
*top = get_frame_base (fi);
/* If current stack pointer is more "inner", use that instead. */
if (gdbarch_inner_than (current_gdbarch, get_frame_sp (fi), *top))
*top = get_frame_sp (fi);
/* Find prev-most frame. */
while ((tmp_fi = get_prev_frame (fi)) != NULL)
fi = tmp_fi;
/* Save frame pointer of prev-most frame. */
*bottom = get_frame_base (fi);
/* Now canonicalize their order, so that BOTTOM is a lower address
(as opposed to a lower stack frame). */
if (*bottom > *top)
{
bfd_vma tmp_vma;
tmp_vma = *top;
*top = *bottom;
*bottom = tmp_vma;
}
return 1;
}
static struct value *
value_of_builtin_frame_reg (struct frame_info *frame)
{
struct value *val;
gdb_byte *buf;
build_builtin_type_frame_reg ();
val = allocate_value (builtin_type_frame_reg);
VALUE_LVAL (val) = not_lval;
buf = value_contents_raw (val);
memset (buf, 0, TYPE_LENGTH (value_type (val)));
/* frame.base. */
if (frame != NULL)
ADDRESS_TO_POINTER (builtin_type_void_data_ptr, buf,
get_frame_base (frame));
buf += TYPE_LENGTH (builtin_type_void_data_ptr);
/* frame.XXX. */
return val;
}
int
legacy_frame_chain_valid (CORE_ADDR fp, struct frame_info *fi)
{
/* Don't prune CALL_DUMMY frames. */
if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
&& DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), 0, 0))
return 1;
/* If the new frame pointer is zero, then it isn't valid. */
if (fp == 0)
return 0;
/* If the new frame would be inside (younger than) the previous frame,
then it isn't valid. */
if (INNER_THAN (fp, get_frame_base (fi)))
return 0;
/* If the architecture has a custom DEPRECATED_FRAME_CHAIN_VALID,
call it now. */
if (DEPRECATED_FRAME_CHAIN_VALID_P ())
return DEPRECATED_FRAME_CHAIN_VALID (fp, fi);
/* If we're already inside the entry function for the main objfile, then it
isn't valid. */
if (legacy_inside_entry_func (get_frame_pc (fi)))
return 0;
/* If we're inside the entry file, it isn't valid. */
/* NOTE/drow 2002-12-25: should there be a way to disable this check? It
assumes a single small entry file, and the way some debug readers (e.g.
dbxread) figure out which object is the entry file is somewhat hokey. */
if (deprecated_inside_entry_file (frame_pc_unwind (fi)))
return 0;
return 1;
}
int
f77_get_dynamic_upperbound (struct type *type, int *upper_bound)
{
CORE_ADDR current_frame_addr = 0;
CORE_ADDR ptr_to_upper_bound;
switch (TYPE_ARRAY_UPPER_BOUND_TYPE (type))
{
case BOUND_BY_VALUE_ON_STACK:
current_frame_addr = get_frame_base (deprecated_selected_frame);
if (current_frame_addr > 0)
{
*upper_bound =
read_memory_integer (current_frame_addr +
TYPE_ARRAY_UPPER_BOUND_VALUE (type),
4);
}
else
{
*upper_bound = DEFAULT_UPPER_BOUND;
return BOUND_FETCH_ERROR;
}
break;
case BOUND_SIMPLE:
*upper_bound = TYPE_ARRAY_UPPER_BOUND_VALUE (type);
break;
case BOUND_CANNOT_BE_DETERMINED:
/* we have an assumed size array on our hands. Assume that
upper_bound == lower_bound so that we show at least
1 element.If the user wants to see more elements, let
him manually ask for 'em and we'll subscript the
array and show him */
f77_get_dynamic_lowerbound (type, upper_bound);
break;
case BOUND_BY_REF_ON_STACK:
current_frame_addr = get_frame_base (deprecated_selected_frame);
if (current_frame_addr > 0)
{
ptr_to_upper_bound =
read_memory_typed_address (current_frame_addr +
TYPE_ARRAY_UPPER_BOUND_VALUE (type),
builtin_type_void_data_ptr);
*upper_bound = read_memory_integer (ptr_to_upper_bound, 4);
}
else
{
*upper_bound = DEFAULT_UPPER_BOUND;
return BOUND_FETCH_ERROR;
}
break;
case BOUND_BY_REF_IN_REG:
case BOUND_BY_VALUE_IN_REG:
default:
error ("??? unhandled dynamic array bound type ???");
break;
}
return BOUND_FETCH_OK;
}
static CORE_ADDR
default_frame_base_address (struct frame_info *this_frame, void **this_cache)
{
return get_frame_base (this_frame); /* sigh! */
}