/*
** _tuiUpdateLocation_command().
** Command to update the display with the current execution point
*/
static void
_tuiUpdateLocation_command (char *arg, int fromTTY)
{
#ifndef TRY
extern void frame_command (char *, int);
frame_command ("0", FALSE);
#else
struct frame_info *curFrame;
/* Obtain the current execution point */
if ((curFrame = get_current_frame ()) != (struct frame_info *) NULL)
{
struct frame_info *frame;
int curLevel = 0;
for (frame = get_prev_frame (curLevel);
(frame != (struct frame_info *) NULL && (frame != curFrame));
frame = get_prev_frame (frame))
curLevel++;
if (curFrame != (struct frame_info *) NULL)
print_frame_info (frame, curLevel, 0, 1);
}
#endif
return;
} /* _tuiUpdateLocation_command */
/* Print a list of the stack frames. Args can be none, in which case
we want to print the whole backtrace, or a pair of numbers
specifying the frame numbers at which to start and stop the
display. If the two numbers are equal, a single frame will be
displayed. */
enum mi_cmd_result
mi_cmd_stack_list_frames (char *command, char **argv, int argc)
{
int frame_low;
int frame_high;
int i;
struct cleanup *cleanup_stack;
struct frame_info *fi;
if (!target_has_stack)
error ("mi_cmd_stack_list_frames: No stack.");
if (argc > 2 || argc == 1)
error ("mi_cmd_stack_list_frames: Usage: [FRAME_LOW FRAME_HIGH]");
if (argc == 2)
{
frame_low = atoi (argv[0]);
frame_high = atoi (argv[1]);
}
else
{
/* Called with no arguments, it means we want the whole
backtrace. */
frame_low = -1;
frame_high = -1;
}
/* Let's position fi on the frame at which to start the
display. Could be the innermost frame if the whole stack needs
displaying, or if frame_low is 0. */
for (i = 0, fi = get_current_frame ();
fi && i < frame_low;
i++, fi = get_prev_frame (fi));
if (fi == NULL)
error ("mi_cmd_stack_list_frames: Not enough frames in stack.");
cleanup_stack = make_cleanup_ui_out_list_begin_end (uiout, "stack");
/* Now let;s print the frames up to frame_high, or until there are
frames in the stack. */
for (;
fi && (i <= frame_high || frame_high == -1);
i++, fi = get_prev_frame (fi))
{
QUIT;
/* Print the location and the address always, even for level 0.
args == 0: don't print the arguments. */
print_frame_info (fi, 1, LOC_AND_ADDRESS, 0 /* args */ );
}
do_cleanups (cleanup_stack);
if (i < frame_high)
error ("mi_cmd_stack_list_frames: Not enough frames in stack.");
return MI_CMD_DONE;
}
/* Print a list of the arguments for the current frame. With argument
of 0, print only the names, with argument of 1 print also the
values. */
enum mi_cmd_result
mi_cmd_stack_list_args (char *command, char **argv, int argc)
{
int frame_low;
int frame_high;
int i;
struct frame_info *fi;
struct cleanup *cleanup_stack_args;
if (argc < 1 || argc > 3 || argc == 2)
error ("mi_cmd_stack_list_args: Usage: PRINT_VALUES [FRAME_LOW FRAME_HIGH]");
if (argc == 3)
{
frame_low = atoi (argv[1]);
frame_high = atoi (argv[2]);
}
else
{
/* Called with no arguments, it means we want args for the whole
backtrace. */
frame_low = -1;
frame_high = -1;
}
/* Let's position fi on the frame at which to start the
display. Could be the innermost frame if the whole stack needs
displaying, or if frame_low is 0. */
for (i = 0, fi = get_current_frame ();
fi && i < frame_low;
i++, fi = get_prev_frame (fi));
if (fi == NULL)
error ("mi_cmd_stack_list_args: Not enough frames in stack.");
cleanup_stack_args = make_cleanup_ui_out_list_begin_end (uiout, "stack-args");
/* Now let's print the frames up to frame_high, or until there are
frames in the stack. */
for (;
fi && (i <= frame_high || frame_high == -1);
i++, fi = get_prev_frame (fi))
{
struct cleanup *cleanup_frame;
QUIT;
cleanup_frame = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
ui_out_field_int (uiout, "level", i);
list_args_or_locals (0, atoi (argv[0]), fi);
do_cleanups (cleanup_frame);
}
do_cleanups (cleanup_stack_args);
if (i < frame_high)
error ("mi_cmd_stack_list_args: Not enough frames in stack.");
return MI_CMD_DONE;
}
enum mi_cmd_result
mi_cmd_stack_info_depth (char *command, char **argv, int argc)
{
int frame_high;
int i;
struct frame_info *fi;
if (!target_has_stack)
error ("mi_cmd_stack_info_depth: No stack.");
if (argc > 1)
error ("mi_cmd_stack_info_depth: Usage: [MAX_DEPTH]");
if (argc == 1)
frame_high = atoi (argv[0]);
else
/* Called with no arguments, it means we want the real depth of
the stack. */
frame_high = -1;
for (i = 0, fi = get_current_frame ();
fi && (i < frame_high || frame_high == -1);
i++, fi = get_prev_frame (fi))
QUIT;
ui_out_field_int (uiout, "depth", i);
return MI_CMD_DONE;
}
struct frame_info *
block_innermost_frame (const struct block *block)
{
struct frame_info *frame;
CORE_ADDR start;
CORE_ADDR end;
if (block == NULL)
return NULL;
start = BLOCK_START (block);
end = BLOCK_END (block);
frame = get_selected_frame_if_set ();
if (frame == NULL)
frame = get_current_frame ();
while (frame != NULL)
{
struct block *frame_block = get_frame_block (frame, NULL);
if (frame_block != NULL && contained_in (frame_block, block))
return frame;
frame = get_prev_frame (frame);
}
return NULL;
}
void deinterlace_update_async_video(obs_source_t *source)
{
struct obs_source_frame *frame;
bool updated;
if (source->deinterlace_rendered)
return;
frame = get_prev_frame(source, &updated);
source->deinterlace_rendered = true;
if (frame)
frame = filter_async_video(source, frame);
if (frame) {
if (set_async_texture_size(source, frame)) {
update_async_texture(source, frame,
source->async_prev_texture,
source->async_prev_texrender);
}
obs_source_release_frame(source, frame);
} else if (updated) { /* swap cur/prev if no previous texture */
gs_texture_t *prev_tex = source->async_prev_texture;
source->async_prev_texture = source->async_texture;
source->async_texture = prev_tex;
if (source->async_texrender) {
gs_texrender_t *prev = source->async_prev_texrender;
source->async_prev_texrender = source->async_texrender;
source->async_texrender = prev;
}
}
}
struct frame_info *
block_innermost_frame (struct block *block)
{
struct frame_info *frame;
CORE_ADDR start;
CORE_ADDR end;
CORE_ADDR calling_pc;
if (block == NULL)
return NULL;
start = BLOCK_START (block);
end = BLOCK_END (block);
frame = NULL;
while (1)
{
frame = get_prev_frame (frame);
if (frame == NULL)
return NULL;
calling_pc = get_frame_address_in_block (frame);
if (calling_pc >= start && calling_pc < end)
return frame;
}
}
static int
wrap_get_prev_frame (char *opaque_arg)
{
struct gdb_wrapper_arguments **args = (struct gdb_wrapper_arguments **) opaque_arg;
struct frame_info *fi = (struct frame_info *) (*args)->args[0].ptr;
(*args)->result.ptr = get_prev_frame (fi);
return 1;
}
static SCM
frscm_scm_from_frame (struct frame_info *frame, struct inferior *inferior)
{
frame_smob *f_smob, f_smob_for_lookup;
SCM f_scm;
htab_t htab;
eqable_gdb_smob **slot;
struct frame_id frame_id = null_frame_id;
struct gdbarch *gdbarch = NULL;
int frame_id_is_next = 0;
/* If we've already created a gsmob for this frame, return it.
This makes frames eq?-able. */
htab = frscm_inferior_frame_map (inferior);
f_smob_for_lookup.frame_id = get_frame_id (frame);
f_smob_for_lookup.inferior = inferior;
slot = gdbscm_find_eqable_gsmob_ptr_slot (htab, &f_smob_for_lookup.base);
if (*slot != NULL)
return (*slot)->containing_scm;
TRY
{
/* Try to get the previous frame, to determine if this is the last frame
in a corrupt stack. If so, we need to store the frame_id of the next
frame and not of this one (which is possibly invalid). */
if (get_prev_frame (frame) == NULL
&& get_frame_unwind_stop_reason (frame) != UNWIND_NO_REASON
&& get_next_frame (frame) != NULL)
{
frame_id = get_frame_id (get_next_frame (frame));
frame_id_is_next = 1;
}
else
{
frame_id = get_frame_id (frame);
frame_id_is_next = 0;
}
gdbarch = get_frame_arch (frame);
}
CATCH (except, RETURN_MASK_ALL)
{
return gdbscm_scm_from_gdb_exception (except);
}
END_CATCH
f_scm = frscm_make_frame_smob ();
f_smob = (frame_smob *) SCM_SMOB_DATA (f_scm);
f_smob->frame_id = frame_id;
f_smob->gdbarch = gdbarch;
f_smob->inferior = inferior;
f_smob->frame_id_is_next = frame_id_is_next;
gdbscm_fill_eqable_gsmob_ptr_slot (slot, &f_smob->base);
return f_scm;
}
static CORE_ADDR
default_frame_args_address (struct frame_info *next_frame, void **this_cache)
{
if (DEPRECATED_FRAME_ARGS_ADDRESS_P ())
{
struct frame_info *this_frame = get_prev_frame (next_frame);
return DEPRECATED_FRAME_ARGS_ADDRESS (this_frame);
}
return default_frame_base_address (next_frame, this_cache);
}
static CORE_ADDR
default_frame_locals_address (struct frame_info *next_frame, void **this_cache)
{
if (DEPRECATED_FRAME_LOCALS_ADDRESS_P ())
{
/* This is bad. The computation of per-frame locals address
should use a per-frame frame-base. */
struct frame_info *this_frame = get_prev_frame (next_frame);
return DEPRECATED_FRAME_LOCALS_ADDRESS (this_frame);
}
return default_frame_base_address (next_frame, this_cache);
}
struct frame_info *
frscm_frame_smob_to_frame (frame_smob *f_smob)
{
struct frame_info *frame;
frame = frame_find_by_id (f_smob->frame_id);
if (frame == NULL)
return NULL;
if (f_smob->frame_id_is_next)
frame = get_prev_frame (frame);
return frame;
}
static struct frame_info *
frame_object_to_frame_info (frame_object *frame_obj)
{
struct frame_info *frame;
frame = frame_find_by_id (frame_obj->frame_id);
if (frame == NULL)
return NULL;
if (frame_obj->frame_id_is_next)
frame = get_prev_frame (frame);
return frame;
}
struct frame_info *
find_frame_addr_in_frame_chain (CORE_ADDR frame_addr)
{
struct frame_info *frame = NULL;
if (frame_addr == (CORE_ADDR) 0)
return NULL;
while (1)
{
frame = get_prev_frame (frame);
if (frame == NULL)
return NULL;
if (FRAME_FP (frame) == frame_addr)
return 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;
}
struct frame_info *
block_innermost_frame (const struct block *block)
{
struct frame_info *frame;
if (block == NULL)
return NULL;
frame = get_selected_frame_if_set ();
if (frame == NULL)
frame = get_current_frame ();
while (frame != NULL)
{
const struct block *frame_block = get_frame_block (frame, NULL);
if (frame_block != NULL && contained_in (frame_block, block))
return frame;
frame = get_prev_frame (frame);
}
return NULL;
}
struct frame_info *
block_innermost_frame (struct block *block)
{
struct frame_info *frame;
CORE_ADDR calling_pc;
if (block == NULL)
return NULL;
frame = NULL;
while (1)
{
frame = get_prev_frame (frame);
if (frame == NULL)
return NULL;
calling_pc = get_frame_address_in_block (frame);
/* APPLE LOCAL begin address ranges */
if (block_contains_pc (block, calling_pc))
/* APPLE LOCAL end address ranges */
return frame;
}
}
struct frame_info *
block_innermost_frame (struct block *block)
{
struct frame_info *frame;
register CORE_ADDR start;
register CORE_ADDR end;
if (block == NULL)
return NULL;
start = BLOCK_START (block);
end = BLOCK_END (block);
frame = NULL;
while (1)
{
frame = get_prev_frame (frame);
if (frame == NULL)
return NULL;
if (frame->pc >= start && frame->pc < end)
return frame;
}
}
void
mi_cmd_stack_info_depth (char *command, char **argv, int argc)
{
int frame_high;
int i;
struct frame_info *fi;
if (argc > 1)
error (_("-stack-info-depth: Usage: [MAX_DEPTH]"));
if (argc == 1)
frame_high = atoi (argv[0]);
else
/* Called with no arguments, it means we want the real depth of
the stack. */
frame_high = -1;
for (i = 0, fi = get_current_frame ();
fi && (i < frame_high || frame_high == -1);
i++, fi = get_prev_frame (fi))
QUIT;
ui_out_field_int (current_uiout, "depth", i);
}
static int
bpfinishpy_init (PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *keywords[] = { "frame", "internal", NULL };
struct finish_breakpoint_object *self_bpfinish =
(struct finish_breakpoint_object *) self;
PyObject *frame_obj = NULL;
int thread;
struct frame_info *frame = NULL; /* init for gcc -Wall */
struct frame_info *prev_frame = NULL;
struct frame_id frame_id;
PyObject *internal = NULL;
int internal_bp = 0;
CORE_ADDR pc;
struct symbol *function;
if (!PyArg_ParseTupleAndKeywords (args, kwargs, "|OO", keywords,
&frame_obj, &internal))
return -1;
TRY
{
/* Default frame to newest frame if necessary. */
if (frame_obj == NULL)
frame = get_current_frame ();
else
frame = frame_object_to_frame_info (frame_obj);
if (frame == NULL)
{
PyErr_SetString (PyExc_ValueError,
_("Invalid ID for the `frame' object."));
}
else
{
prev_frame = get_prev_frame (frame);
if (prev_frame == 0)
{
PyErr_SetString (PyExc_ValueError,
_("\"FinishBreakpoint\" not "
"meaningful in the outermost "
"frame."));
}
else if (get_frame_type (prev_frame) == DUMMY_FRAME)
{
PyErr_SetString (PyExc_ValueError,
_("\"FinishBreakpoint\" cannot "
"be set on a dummy frame."));
}
else
{
frame_id = get_frame_id (prev_frame);
if (frame_id_eq (frame_id, null_frame_id))
PyErr_SetString (PyExc_ValueError,
_("Invalid ID for the `frame' object."));
}
}
}
CATCH (except, RETURN_MASK_ALL)
{
gdbpy_convert_exception (except);
return -1;
}
void
mi_cmd_stack_list_args (char *command, char **argv, int argc)
{
int frame_low;
int frame_high;
int i;
struct frame_info *fi;
struct cleanup *cleanup_stack_args;
enum print_values print_values;
struct ui_out *uiout = current_uiout;
int raw_arg = 0;
enum py_bt_status result = PY_BT_ERROR;
if (argc > 0)
raw_arg = parse_no_frames_option (argv[0]);
if (argc < 1 || (argc > 3 && ! raw_arg) || (argc == 2 && ! raw_arg))
error (_("-stack-list-arguments: Usage: " \
"[--no-frame-filters] PRINT_VALUES [FRAME_LOW FRAME_HIGH]"));
if (argc >= 3)
{
frame_low = atoi (argv[1 + raw_arg]);
frame_high = atoi (argv[2 + raw_arg]);
}
else
{
/* Called with no arguments, it means we want args for the whole
backtrace. */
frame_low = -1;
frame_high = -1;
}
print_values = mi_parse_print_values (argv[raw_arg]);
/* Let's position fi on the frame at which to start the
display. Could be the innermost frame if the whole stack needs
displaying, or if frame_low is 0. */
for (i = 0, fi = get_current_frame ();
fi && i < frame_low;
i++, fi = get_prev_frame (fi));
if (fi == NULL)
error (_("-stack-list-arguments: Not enough frames in stack."));
cleanup_stack_args
= make_cleanup_ui_out_list_begin_end (uiout, "stack-args");
if (! raw_arg && frame_filters)
{
int flags = PRINT_LEVEL | PRINT_ARGS;
int py_frame_low = frame_low;
/* We cannot pass -1 to frame_low, as that would signify a
relative backtrace from the tail of the stack. So, in the case
of frame_low == -1, assign and increment it. */
if (py_frame_low == -1)
py_frame_low++;
result = apply_frame_filter (get_current_frame (), flags,
print_values, current_uiout,
py_frame_low, frame_high);
}
/* Run the inbuilt backtrace if there are no filters registered, or
if "--no-frame-filters" has been specified from the command. */
if (! frame_filters || raw_arg || result == PY_BT_NO_FILTERS)
{
/* Now let's print the frames up to frame_high, or until there are
frames in the stack. */
for (;
fi && (i <= frame_high || frame_high == -1);
i++, fi = get_prev_frame (fi))
{
struct cleanup *cleanup_frame;
QUIT;
cleanup_frame = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
ui_out_field_int (uiout, "level", i);
list_args_or_locals (arguments, print_values, fi);
do_cleanups (cleanup_frame);
}
}
do_cleanups (cleanup_stack_args);
}
void
mi_cmd_stack_list_frames (char *command, char **argv, int argc)
{
int frame_low;
int frame_high;
int i;
struct cleanup *cleanup_stack;
struct frame_info *fi;
enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
int raw_arg = 0;
int oind = 0;
enum opt
{
NO_FRAME_FILTERS
};
static const struct mi_opt opts[] =
{
{"-no-frame-filters", NO_FRAME_FILTERS, 0},
{ 0, 0, 0 }
};
/* Parse arguments. In this instance we are just looking for
--no-frame-filters. */
while (1)
{
char *oarg;
int opt = mi_getopt ("-stack-list-frames", argc, argv,
opts, &oind, &oarg);
if (opt < 0)
break;
switch ((enum opt) opt)
{
case NO_FRAME_FILTERS:
raw_arg = oind;
break;
}
}
/* After the last option is parsed, there should either be low -
high range, or no further arguments. */
if ((argc - oind != 0) && (argc - oind != 2))
error (_("-stack-list-frames: Usage: [--no-frame-filters] [FRAME_LOW FRAME_HIGH]"));
/* If there is a range, set it. */
if (argc - oind == 2)
{
frame_low = atoi (argv[0 + oind]);
frame_high = atoi (argv[1 + oind]);
}
else
{
/* Called with no arguments, it means we want the whole
backtrace. */
frame_low = -1;
frame_high = -1;
}
/* Let's position fi on the frame at which to start the
display. Could be the innermost frame if the whole stack needs
displaying, or if frame_low is 0. */
for (i = 0, fi = get_current_frame ();
fi && i < frame_low;
i++, fi = get_prev_frame (fi));
if (fi == NULL)
error (_("-stack-list-frames: Not enough frames in stack."));
cleanup_stack = make_cleanup_ui_out_list_begin_end (current_uiout, "stack");
if (! raw_arg && frame_filters)
{
int flags = PRINT_LEVEL | PRINT_FRAME_INFO;
int py_frame_low = frame_low;
/* We cannot pass -1 to frame_low, as that would signify a
relative backtrace from the tail of the stack. So, in the case
of frame_low == -1, assign and increment it. */
if (py_frame_low == -1)
py_frame_low++;
result = apply_ext_lang_frame_filter (get_current_frame (), flags,
NO_VALUES, current_uiout,
py_frame_low, frame_high);
}
/* Run the inbuilt backtrace if there are no filters registered, or
if "--no-frame-filters" has been specified from the command. */
if (! frame_filters || raw_arg || result == EXT_LANG_BT_NO_FILTERS)
{
/* Now let's print the frames up to frame_high, or until there are
frames in the stack. */
for (;
fi && (i <= frame_high || frame_high == -1);
i++, fi = get_prev_frame (fi))
{
QUIT;
/* Print the location and the address always, even for level 0.
If args is 0, don't print the arguments. */
print_frame_info (fi, 1, LOC_AND_ADDRESS, 0 /* args */, 0);
}
}
do_cleanups (cleanup_stack);
}
void
mi_cmd_stack_list_args (char *command, char **argv, int argc)
{
int frame_low;
int frame_high;
int i;
struct frame_info *fi;
struct cleanup *cleanup_stack_args;
enum print_values print_values;
struct ui_out *uiout = current_uiout;
int raw_arg = 0;
int oind = 0;
int skip_unavailable = 0;
enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
enum opt
{
NO_FRAME_FILTERS,
SKIP_UNAVAILABLE,
};
static const struct mi_opt opts[] =
{
{"-no-frame-filters", NO_FRAME_FILTERS, 0},
{"-skip-unavailable", SKIP_UNAVAILABLE, 0},
{ 0, 0, 0 }
};
while (1)
{
char *oarg;
int opt = mi_getopt_allow_unknown ("-stack-list-args", argc, argv,
opts, &oind, &oarg);
if (opt < 0)
break;
switch ((enum opt) opt)
{
case NO_FRAME_FILTERS:
raw_arg = oind;
break;
case SKIP_UNAVAILABLE:
skip_unavailable = 1;
break;
}
}
if (argc - oind != 1 && argc - oind != 3)
error (_("-stack-list-arguments: Usage: " \
"[--no-frame-filters] [--skip-unavailable] "
"PRINT_VALUES [FRAME_LOW FRAME_HIGH]"));
if (argc - oind == 3)
{
frame_low = atoi (argv[1 + oind]);
frame_high = atoi (argv[2 + oind]);
}
else
{
/* Called with no arguments, it means we want args for the whole
backtrace. */
frame_low = -1;
frame_high = -1;
}
print_values = mi_parse_print_values (argv[oind]);
/* Let's position fi on the frame at which to start the
display. Could be the innermost frame if the whole stack needs
displaying, or if frame_low is 0. */
for (i = 0, fi = get_current_frame ();
fi && i < frame_low;
i++, fi = get_prev_frame (fi));
if (fi == NULL)
error (_("-stack-list-arguments: Not enough frames in stack."));
cleanup_stack_args
= make_cleanup_ui_out_list_begin_end (uiout, "stack-args");
if (! raw_arg && frame_filters)
{
int flags = PRINT_LEVEL | PRINT_ARGS;
int py_frame_low = frame_low;
/* We cannot pass -1 to frame_low, as that would signify a
relative backtrace from the tail of the stack. So, in the case
of frame_low == -1, assign and increment it. */
if (py_frame_low == -1)
py_frame_low++;
result = mi_apply_ext_lang_frame_filter (get_current_frame (), flags,
print_values, current_uiout,
py_frame_low, frame_high);
}
/* Run the inbuilt backtrace if there are no filters registered, or
if "--no-frame-filters" has been specified from the command. */
if (! frame_filters || raw_arg || result == EXT_LANG_BT_NO_FILTERS)
{
/* Now let's print the frames up to frame_high, or until there are
frames in the stack. */
for (;
fi && (i <= frame_high || frame_high == -1);
i++, fi = get_prev_frame (fi))
{
struct cleanup *cleanup_frame;
QUIT;
cleanup_frame = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
ui_out_field_int (uiout, "level", i);
list_args_or_locals (arguments, print_values, fi, skip_unavailable);
do_cleanups (cleanup_frame);
}
}
do_cleanups (cleanup_stack_args);
}
static int
arm_linux_copy_svc (struct gdbarch *gdbarch, uint32_t insn, CORE_ADDR to,
struct regcache *regs, struct displaced_step_closure *dsc)
{
CORE_ADDR from = dsc->insn_addr;
struct frame_info *frame;
unsigned int svc_number = displaced_read_reg (regs, from, 7);
if (debug_displaced)
fprintf_unfiltered (gdb_stdlog, "displaced: copying Linux svc insn %.8lx\n",
(unsigned long) insn);
frame = get_current_frame ();
/* Is this a sigreturn or rt_sigreturn syscall? Note: these are only useful
for EABI. */
if (svc_number == 119 || svc_number == 173)
{
if (get_frame_type (frame) == SIGTRAMP_FRAME)
{
CORE_ADDR return_to;
struct symtab_and_line sal;
if (debug_displaced)
fprintf_unfiltered (gdb_stdlog, "displaced: found "
"sigreturn/rt_sigreturn SVC call. PC in frame = %lx\n",
(unsigned long) get_frame_pc (frame));
return_to = frame_unwind_caller_pc (frame);
if (debug_displaced)
fprintf_unfiltered (gdb_stdlog, "displaced: unwind pc = %lx. "
"Setting momentary breakpoint.\n", (unsigned long) return_to);
gdb_assert (inferior_thread ()->step_resume_breakpoint == NULL);
sal = find_pc_line (return_to, 0);
sal.pc = return_to;
sal.section = find_pc_overlay (return_to);
sal.explicit_pc = 1;
frame = get_prev_frame (frame);
if (frame)
{
inferior_thread ()->step_resume_breakpoint
= set_momentary_breakpoint (gdbarch, sal, get_frame_id (frame),
bp_step_resume);
/* We need to make sure we actually insert the momentary
breakpoint set above. */
insert_breakpoints ();
}
else if (debug_displaced)
fprintf_unfiltered (gdb_stderr, "displaced: couldn't find previous "
"frame to set momentary breakpoint for "
"sigreturn/rt_sigreturn\n");
}
else if (debug_displaced)
fprintf_unfiltered (gdb_stdlog, "displaced: sigreturn/rt_sigreturn "
"SVC call not in signal trampoline frame\n");
}
/* Preparation: If we detect sigreturn, set momentary breakpoint at resume
location, else nothing.
Insn: unmodified svc.
Cleanup: if pc lands in scratch space, pc <- insn_addr + 4
else leave pc alone. */
dsc->modinsn[0] = insn;
dsc->cleanup = &arm_linux_cleanup_svc;
/* Pretend we wrote to the PC, so cleanup doesn't set PC to the next
instruction. */
dsc->wrote_to_pc = 1;
return 0;
}
static int
arm_linux_copy_svc (struct gdbarch *gdbarch, struct regcache *regs,
struct displaced_step_closure *dsc)
{
CORE_ADDR return_to = 0;
struct frame_info *frame;
unsigned int svc_number = displaced_read_reg (regs, dsc, 7);
int is_sigreturn = 0;
int is_thumb;
frame = get_current_frame ();
is_sigreturn = arm_linux_sigreturn_return_addr(frame, svc_number,
&return_to, &is_thumb);
if (is_sigreturn)
{
struct symtab_and_line sal;
if (debug_displaced)
fprintf_unfiltered (gdb_stdlog, "displaced: found "
"sigreturn/rt_sigreturn SVC call. PC in frame = %lx\n",
(unsigned long) get_frame_pc (frame));
if (debug_displaced)
fprintf_unfiltered (gdb_stdlog, "displaced: unwind pc = %lx. "
"Setting momentary breakpoint.\n", (unsigned long) return_to);
gdb_assert (inferior_thread ()->control.step_resume_breakpoint
== NULL);
sal = find_pc_line (return_to, 0);
sal.pc = return_to;
sal.section = find_pc_overlay (return_to);
sal.explicit_pc = 1;
frame = get_prev_frame (frame);
if (frame)
{
inferior_thread ()->control.step_resume_breakpoint
= set_momentary_breakpoint (gdbarch, sal, get_frame_id (frame),
bp_step_resume);
/* set_momentary_breakpoint invalidates FRAME. */
frame = NULL;
/* We need to make sure we actually insert the momentary
breakpoint set above. */
insert_breakpoints ();
}
else if (debug_displaced)
fprintf_unfiltered (gdb_stderr, "displaced: couldn't find previous "
"frame to set momentary breakpoint for "
"sigreturn/rt_sigreturn\n");
}
else if (debug_displaced)
fprintf_unfiltered (gdb_stdlog, "displaced: sigreturn/rt_sigreturn "
"SVC call not in signal trampoline frame\n");
/* Preparation: If we detect sigreturn, set momentary breakpoint at resume
location, else nothing.
Insn: unmodified svc.
Cleanup: if pc lands in scratch space, pc <- insn_addr + 4
else leave pc alone. */
dsc->cleanup = &arm_linux_cleanup_svc;
/* Pretend we wrote to the PC, so cleanup doesn't set PC to the next
instruction. */
dsc->wrote_to_pc = 1;
return 0;
}
static CORE_ADDR
default_frame_base_address (struct frame_info *next_frame, void **this_cache)
{
struct frame_info *this_frame = get_prev_frame (next_frame);
return get_frame_base (this_frame); /* sigh! */
}