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;
}
/* Build a data packet (send a buffer to an address). An empty addr means
* broadcast. Returns the frame_id used */
uint8_t
xbee_build_data_packet(struct xbee_packet *p, uint64_t addr,
const uint8_t *data, uint16_t bytes) {
p->len = bytes + 18;
/* use 0 for the frame_id if ACKs are disabled */
uint8_t frame_id = p->disable_ack ? 0x00 : get_frame_id();
if(!addr) addr = XBEE_BROADCAST_ADDRESS;
p->buf[0] = XBEE_START;
p->buf[1] = (uint8_t)((p->len-4)>>8); /* len upper */
p->buf[2] = (uint8_t)((p->len-4)); /* len lower */
p->buf[3] = XBEE_FRAME_TRANSMIT_REQUEST;
p->buf[4] = frame_id;
p->buf[5] = addr>>56; /* addr high */
p->buf[6] = addr>>48;
p->buf[7] = addr>>40;
p->buf[8] = addr>>32;
p->buf[9] = addr>>24;
p->buf[10] = addr>>16;
p->buf[11] = addr>>8;
p->buf[12] = addr; /* addr low */
p->buf[13] = 0xff; /* reserved */
p->buf[14] = 0xfe; /* reserved */
p->buf[15] = 0x00; /* max hops */
p->buf[16] = 0x00; /* Tx options */
memcpy((uint8_t*)p->buf+17, data, bytes); /* insert data payoad */
p->buf[p->len-1] = xbee_calc_checksum(p);
return frame_id;
}
static CORE_ADDR
alpha_osf1_sigcontext_addr (struct frame_info *next_frame)
{
const struct frame_id next_id = get_frame_id (next_frame);
return (read_memory_integer (next_id.stack_addr, 8));
}
FrameHandles FrameHandle::get_children() const {
Ints children = get_shared_data()->get_children(get_frame_id());
FrameHandles ret(children.size());
for (unsigned int i = 0; i < ret.size(); ++i) {
ret[i] = FrameHandle(children[i], get_shared_data());
}
return ret;
}
FrameHandle FrameHandle::add_child(std::string name, FrameType t) {
FrameHandle ret(get_shared_data()->add_child_frame(get_frame_id(), name, t),
get_shared_data());
ret.set_as_current_frame();
RMF_INTERNAL_CHECK(get_shared_data()->get_number_of_frames()
== static_cast<unsigned int>(ret.get_id().get_index() + 1),
"Wrong number of frames");
return ret;
}
static CORE_ADDR
alpha_osf1_sigcontext_addr (struct frame_info *this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
struct frame_info *next_frame = get_next_frame (this_frame);
struct frame_id next_id = null_frame_id;
if (next_frame != NULL)
next_id = get_frame_id (next_frame);
return (read_memory_integer (next_id.stack_addr, 8, byte_order));
}
/* Build packet for an AT command. Pass a pointer to an empty xbee_packet, a
* pointer to the buffer to use for the payload, and the length of the payload.
* Returns the frame_id used. Example arg: "NITEST" set NI to "TEST" */
uint8_t
xbee_build_command_packet(struct xbee_packet *p, const uint8_t *data,
uint16_t bytes) {
/* use 0 for the frame_id if ACKs are disabled */
uint8_t frame_id = p->disable_ack ? 0x00 : get_frame_id();
p->len = bytes + 6;
p->buf[0] = XBEE_START;
p->buf[1] = (uint8_t)((p->len-4)>>8);
p->buf[2] = (uint8_t)(p->len-4);
p->buf[3] = XBEE_FRAME_AT_COMMAND;
p->buf[4] = frame_id;
memcpy(p->buf+5, data, bytes);
p->buf[p->len-1] = xbee_calc_checksum(p);
return frame_id;
}
static void
tailcall_frame_this_id (struct frame_info *this_frame, void **this_cache,
struct frame_id *this_id)
{
struct tailcall_cache *cache = *this_cache;
struct frame_info *next_frame;
/* Tail call does not make sense for a sentinel frame. */
next_frame = get_next_frame (this_frame);
gdb_assert (next_frame != NULL);
*this_id = get_frame_id (next_frame);
(*this_id).code_addr = get_frame_pc (this_frame);
(*this_id).code_addr_p = 1;
(*this_id).artificial_depth = (cache->chain_levels
- existing_next_levels (this_frame, cache));
gdb_assert ((*this_id).artificial_depth > 0);
}
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;
}
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 struct btrace_insn_iterator *
record_btrace_start_replaying (struct thread_info *tp)
{
volatile struct gdb_exception except;
struct btrace_insn_iterator *replay;
struct btrace_thread_info *btinfo;
int executing;
btinfo = &tp->btrace;
replay = NULL;
/* We can't start replaying without trace. */
if (btinfo->begin == NULL)
return NULL;
/* Clear the executing flag to allow changes to the current frame.
We are not actually running, yet. We just started a reverse execution
command or a record goto command.
For the latter, EXECUTING is false and this has no effect.
For the former, EXECUTING is true and we're in to_wait, about to
move the thread. Since we need to recompute the stack, we temporarily
set EXECUTING to flase. */
executing = is_executing (tp->ptid);
set_executing (tp->ptid, 0);
/* GDB stores the current frame_id when stepping in order to detects steps
into subroutines.
Since frames are computed differently when we're replaying, we need to
recompute those stored frames and fix them up so we can still detect
subroutines after we started replaying. */
TRY_CATCH (except, RETURN_MASK_ALL)
{
struct frame_info *frame;
struct frame_id frame_id;
int upd_step_frame_id, upd_step_stack_frame_id;
/* The current frame without replaying - computed via normal unwind. */
frame = get_current_frame ();
frame_id = get_frame_id (frame);
/* Check if we need to update any stepping-related frame id's. */
upd_step_frame_id = frame_id_eq (frame_id,
tp->control.step_frame_id);
upd_step_stack_frame_id = frame_id_eq (frame_id,
tp->control.step_stack_frame_id);
/* We start replaying at the end of the branch trace. This corresponds
to the current instruction. */
replay = xmalloc (sizeof (*replay));
btrace_insn_end (replay, btinfo);
/* We're not replaying, yet. */
gdb_assert (btinfo->replay == NULL);
btinfo->replay = replay;
/* Make sure we're not using any stale registers. */
registers_changed_ptid (tp->ptid);
/* The current frame with replaying - computed via btrace unwind. */
frame = get_current_frame ();
frame_id = get_frame_id (frame);
/* Replace stepping related frames where necessary. */
if (upd_step_frame_id)
tp->control.step_frame_id = frame_id;
if (upd_step_stack_frame_id)
tp->control.step_stack_frame_id = frame_id;
}
/* Restore the previous execution state. */
set_executing (tp->ptid, executing);
if (except.reason < 0)
{
xfree (btinfo->replay);
btinfo->replay = NULL;
registers_changed_ptid (tp->ptid);
throw_exception (except);
}
return replay;
}
gboolean id3v22_read_tag (Tuple * tuple, VFSFile * handle)
{
gint version, header_size, data_size;
gboolean syncsafe;
gsize offset;
gint pos;
if (! read_header (handle, & version, & syncsafe, & offset, & header_size,
& data_size))
return FALSE;
TAGDBG("Reading tags from %i bytes of ID3 data in %s\n", data_size, handle->uri);
for (pos = 0; pos < data_size; )
{
gint frame_size, size, id;
gchar key[5];
guchar * data;
if (! read_frame (handle, data_size - pos, version, syncsafe,
& frame_size, key, & data, & size))
{
TAGDBG("read_frame failed at pos %i\n", pos);
break;
}
id = get_frame_id (key);
switch (id)
{
case ID3_ALBUM:
associate_string (tuple, FIELD_ALBUM, NULL, data, size);
break;
case ID3_TITLE:
associate_string (tuple, FIELD_TITLE, NULL, data, size);
break;
case ID3_COMPOSER:
associate_string (tuple, FIELD_COMPOSER, NULL, data, size);
break;
case ID3_COPYRIGHT:
associate_string (tuple, FIELD_COPYRIGHT, NULL, data, size);
break;
case ID3_DATE:
associate_string (tuple, FIELD_DATE, NULL, data, size);
break;
case ID3_LENGTH:
associate_int (tuple, FIELD_LENGTH, NULL, data, size);
break;
case ID3_FUCKO_ARTIST:
case ID3_ARTIST:
associate_string (tuple, FIELD_ARTIST, NULL, data, size);
break;
case ID3_TRACKNR:
associate_int (tuple, FIELD_TRACK_NUMBER, NULL, data, size);
break;
case ID3_YEAR:
associate_int (tuple, FIELD_YEAR, NULL, data, size);
break;
case ID3_GENRE:
decode_genre (tuple, data, size);
break;
case ID3_COMMENT:
decode_comment (tuple, data, size);
break;
case ID3_ENCODER:
associate_string (tuple, -1, "encoder", data, size);
break;
case ID3_TXX:
decode_txx (tuple, data, size);
break;
case ID3_RVA:
decode_rva (tuple, data, size);
break;
default:
TAGDBG ("Ignoring unsupported ID3 frame %s.\n", key);
break;
}
g_free (data);
pos += frame_size;
}
return TRUE;
}
static bool_t id3v24_read_tag (Tuple * tuple, VFSFile * handle)
{
int version, header_size, data_size, footer_size;
bool_t syncsafe;
int64_t offset;
int pos;
if (! read_header (handle, & version, & syncsafe, & offset, & header_size,
& data_size, & footer_size))
return FALSE;
for (pos = 0; pos < data_size; )
{
int frame_size, size, id;
char key[5];
char * data;
if (! read_frame (handle, data_size - pos, version, syncsafe,
& frame_size, key, & data, & size))
break;
id = get_frame_id (key);
switch (id)
{
case ID3_ALBUM:
id3_associate_string (tuple, FIELD_ALBUM, data, size);
break;
case ID3_TITLE:
id3_associate_string (tuple, FIELD_TITLE, data, size);
break;
case ID3_COMPOSER:
id3_associate_string (tuple, FIELD_COMPOSER, data, size);
break;
case ID3_COPYRIGHT:
id3_associate_string (tuple, FIELD_COPYRIGHT, data, size);
break;
case ID3_DATE:
id3_associate_string (tuple, FIELD_DATE, data, size);
break;
case ID3_LENGTH:
id3_associate_int (tuple, FIELD_LENGTH, data, size);
break;
case ID3_ARTIST:
id3_associate_string (tuple, FIELD_ARTIST, data, size);
break;
case ID3_TRACKNR:
id3_associate_int (tuple, FIELD_TRACK_NUMBER, data, size);
break;
case ID3_YEAR:
case ID3_RECORDING_TIME:
id3_associate_int (tuple, FIELD_YEAR, data, size);
break;
case ID3_GENRE:
id3_decode_genre (tuple, data, size);
break;
case ID3_COMMENT:
id3_decode_comment (tuple, data, size);
break;
#if 0
case ID3_PRIVATE:
decode_private_info (tuple, data, size);
break;
#endif
case ID3_RVA2:
id3_decode_rva (tuple, data, size);
break;
default:
TAGDBG ("Ignoring unsupported ID3 frame %s.\n", key);
break;
}
g_free (data);
pos += frame_size;
}
return TRUE;
}
void FrameHandle::add_child(FrameConstHandle nh) {
get_shared_data()->add_child_frame(get_frame_id(), nh.get_frame_id());
}
static gboolean id3v24_read_tag (Tuple * tuple, VFSFile * handle)
{
gint version, header_size, data_size, footer_size;
gboolean syncsafe;
gint64 offset;
gint pos;
if (! read_header (handle, & version, & syncsafe, & offset, & header_size,
& data_size, & footer_size))
return FALSE;
for (pos = 0; pos < data_size; )
{
gint frame_size, size, id;
gchar key[5];
guchar * data;
if (! read_frame (handle, data_size - pos, version, syncsafe,
& frame_size, key, & data, & size))
break;
id = get_frame_id (key);
switch (id)
{
case ID3_ALBUM:
associate_string (tuple, FIELD_ALBUM, NULL, data, size);
break;
case ID3_TITLE:
associate_string (tuple, FIELD_TITLE, NULL, data, size);
break;
case ID3_COMPOSER:
associate_string (tuple, FIELD_COMPOSER, NULL, data, size);
break;
case ID3_COPYRIGHT:
associate_string (tuple, FIELD_COPYRIGHT, NULL, data, size);
break;
case ID3_DATE:
associate_string (tuple, FIELD_DATE, NULL, data, size);
break;
case ID3_TIME:
associate_int (tuple, FIELD_LENGTH, NULL, data, size);
break;
case ID3_LENGTH:
associate_int (tuple, FIELD_LENGTH, NULL, data, size);
break;
case ID3_ARTIST:
associate_string (tuple, FIELD_ARTIST, NULL, data, size);
break;
case ID3_TRACKNR:
associate_int (tuple, FIELD_TRACK_NUMBER, NULL, data, size);
break;
case ID3_YEAR:
case ID3_RECORDING_TIME:
associate_int (tuple, FIELD_YEAR, NULL, data, size);
break;
case ID3_GENRE:
decode_genre (tuple, data, size);
break;
case ID3_COMMENT:
decode_comment (tuple, data, size);
break;
case ID3_PRIVATE:
decode_private_info (tuple, data, size);
break;
case ID3_ENCODER:
associate_string (tuple, -1, "encoder", data, size);
break;
case ID3_TXXX:
decode_txxx (tuple, data, size);
break;
case ID3_RVA2:
decode_rva2 (tuple, data, size);
break;
default:
TAGDBG ("Ignoring unsupported ID3 frame %s.\n", key);
break;
}
g_free (data);
pos += frame_size;
}
return TRUE;
}
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;
}
