/* Cache and manage frames for GDB, the GNU debugger.
- Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
- 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+ Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001,
+ 2002, 2003, 2004, 2007 Free Software Foundation, Inc.
This file is part of GDB.
}
CORE_ADDR
-frame_func_unwind (struct frame_info *fi)
+frame_func_unwind (struct frame_info *fi, enum frame_type this_type)
{
if (!fi->prev_func.p)
{
/* Make certain that this, and not the adjacent, function is
found. */
- CORE_ADDR addr_in_block = frame_unwind_address_in_block (fi);
+ CORE_ADDR addr_in_block = frame_unwind_address_in_block (fi, this_type);
fi->prev_func.p = 1;
fi->prev_func.addr = get_pc_function_start (addr_in_block);
if (frame_debug)
CORE_ADDR
get_frame_func (struct frame_info *fi)
{
- return frame_func_unwind (fi->next);
+ return frame_func_unwind (fi->next, get_frame_type (fi));
}
static int
return !optimized;
}
+int
+get_frame_register_bytes (struct frame_info *frame, int regnum,
+ CORE_ADDR offset, int len, gdb_byte *myaddr)
+{
+ struct gdbarch *gdbarch = get_frame_arch (frame);
+
+ /* Skip registers wholly inside of OFFSET. */
+ while (offset >= register_size (gdbarch, regnum))
+ {
+ offset -= register_size (gdbarch, regnum);
+ regnum++;
+ }
+
+ /* Copy the data. */
+ while (len > 0)
+ {
+ int curr_len = register_size (gdbarch, regnum) - offset;
+ if (curr_len > len)
+ curr_len = len;
+
+ if (curr_len == register_size (gdbarch, regnum))
+ {
+ if (!frame_register_read (frame, regnum, myaddr))
+ return 0;
+ }
+ else
+ {
+ gdb_byte buf[MAX_REGISTER_SIZE];
+ if (!frame_register_read (frame, regnum, buf))
+ return 0;
+ memcpy (myaddr, buf + offset, curr_len);
+ }
+
+ myaddr += curr_len;
+ len -= curr_len;
+ offset = 0;
+ regnum++;
+ }
+
+ return 1;
+}
+
+void
+put_frame_register_bytes (struct frame_info *frame, int regnum,
+ CORE_ADDR offset, int len, const gdb_byte *myaddr)
+{
+ struct gdbarch *gdbarch = get_frame_arch (frame);
+
+ /* Skip registers wholly inside of OFFSET. */
+ while (offset >= register_size (gdbarch, regnum))
+ {
+ offset -= register_size (gdbarch, regnum);
+ regnum++;
+ }
+
+ /* Copy the data. */
+ while (len > 0)
+ {
+ int curr_len = register_size (gdbarch, regnum) - offset;
+ if (curr_len > len)
+ curr_len = len;
+
+ if (curr_len == register_size (gdbarch, regnum))
+ {
+ put_frame_register (frame, regnum, myaddr);
+ }
+ else
+ {
+ gdb_byte buf[MAX_REGISTER_SIZE];
+ frame_register_read (frame, regnum, buf);
+ memcpy (buf + offset, myaddr, curr_len);
+ put_frame_register (frame, regnum, buf);
+ }
+
+ myaddr += curr_len;
+ len -= curr_len;
+ offset = 0;
+ regnum++;
+ }
+}
/* Map between a frame register number and its name. A frame register
space is a superset of the cooked register space --- it also
/* The "selected" stack frame is used by default for local and arg
access. May be zero, for no selected frame. */
-struct frame_info *deprecated_selected_frame;
+static struct frame_info *selected_frame;
/* Return the selected frame. Always non-NULL (unless there isn't an
inferior sufficient for creating a frame) in which case an error is
struct frame_info *
get_selected_frame (const char *message)
{
- if (deprecated_selected_frame == NULL)
+ if (selected_frame == NULL)
{
if (message != NULL && (!target_has_registers
|| !target_has_stack
select_frame (get_current_frame ());
}
/* There is always a frame. */
- gdb_assert (deprecated_selected_frame != NULL);
- return deprecated_selected_frame;
+ gdb_assert (selected_frame != NULL);
+ return selected_frame;
}
/* This is a variant of get_selected_frame() which can be called when
{
struct symtab *s;
- deprecated_selected_frame = fi;
+ selected_frame = fi;
/* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
frame is being invalidated. */
if (deprecated_selected_frame_level_changed_hook)
/* Find where a register is saved (in memory or another register).
The result of frame_register_unwind is just where it is saved
- relative to this particular frame.
-
- FIXME: alpha, m32c, and h8300 actually do the transitive operation
- themselves. */
+ relative to this particular frame. */
static void
frame_register_unwind_location (struct frame_info *this_frame, int regnum,
have different frame IDs, the new frame will be bogus; two
functions can't share a register save slot for the PC. This can
happen when the prologue analyzer finds a stack adjustment, but
- no PC save. This check does assume that the "PC register" is
- roughly a traditional PC, even if the gdbarch_unwind_pc method
- frobs it. */
+ no PC save.
+
+ This check does assume that the "PC register" is roughly a
+ traditional PC, even if the gdbarch_unwind_pc method adjusts
+ it (we do not rely on the value, only on the unwound PC being
+ dependent on this value). A potential improvement would be
+ to have the frame prev_pc method and the gdbarch unwind_pc
+ method set the same lval and location information as
+ frame_register_unwind. */
if (this_frame->level > 0
+ && PC_REGNUM >= 0
&& get_frame_type (this_frame) == NORMAL_FRAME
&& get_frame_type (this_frame->next) == NORMAL_FRAME)
{
return frame_pc_unwind (frame->next);
}
-/* Return an address of that falls within the frame's code block. */
+/* Return an address that falls within NEXT_FRAME's caller's code
+ block, assuming that the caller is a THIS_TYPE frame. */
CORE_ADDR
-frame_unwind_address_in_block (struct frame_info *next_frame)
+frame_unwind_address_in_block (struct frame_info *next_frame,
+ enum frame_type this_type)
{
/* A draft address. */
CORE_ADDR pc = frame_pc_unwind (next_frame);
+ /* If NEXT_FRAME was called by a signal frame or dummy frame, then
+ we shold not adjust the unwound PC. These frames may not call
+ their next frame in the normal way; the operating system or GDB
+ may have pushed their resume address manually onto the stack, so
+ it may be the very first instruction. Even if the resume address
+ was not manually pushed, they expect to be returned to. */
+ if (this_type != NORMAL_FRAME)
+ return pc;
+
/* If THIS frame is not inner most (i.e., NEXT isn't the sentinel),
and NEXT is `normal' (i.e., not a sigtramp, dummy, ....) THIS
frame's PC ends up pointing at the instruction fallowing the
"call". Adjust that PC value so that it falls on the call
instruction (which, hopefully, falls within THIS frame's code
- block. So far it's proved to be a very good approximation. See
+ block). So far it's proved to be a very good approximation. See
get_frame_type() for why ->type can't be used. */
if (next_frame->level >= 0
&& get_frame_type (next_frame) == NORMAL_FRAME)
CORE_ADDR
get_frame_address_in_block (struct frame_info *this_frame)
{
- return frame_unwind_address_in_block (this_frame->next);
+ return frame_unwind_address_in_block (this_frame->next,
+ get_frame_type (this_frame));
}
static int
projects / deliverable / binutils-gdb.git / blobdiff