/* Definitions for dealing with stack frames, for GDB, the GNU debugger.
Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1996, 1997,
- 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009
+ 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
This file is part of GDB.
/* Construct a special frame ID. The first parameter is the frame's constant
stack address (typically the outer-bound), the second is the
frame's constant code address (typically the entry point),
- and the third parameter is the frame's special identifier address. */
+ and the third parameter is the frame's special identifier address. */
extern struct frame_id frame_id_build_special (CORE_ADDR stack_addr,
CORE_ADDR code_addr,
CORE_ADDR special_addr);
call. */
DUMMY_FRAME,
/* A frame representing an inlined function, associated with an
- upcoming (next, inner, younger) NORMAL_FRAME. */
+ upcoming (prev, outer, older) NORMAL_FRAME. */
INLINE_FRAME,
/* In a signal handler, various OSs handle this in various ways.
The main thing is that the frame may be far from normal. */
/* For every stopped thread, GDB tracks two frames: current and
selected. Current frame is the inner most frame of the selected
- thread. Selected frame is the one being examined by the the GDB
+ thread. Selected frame is the one being examined by the GDB
CLI (selected using `up', `down', ...). The frames are created
on-demand (via get_prev_frame()) and then held in a frame cache. */
/* FIXME: cagney/2002-11-28: Er, there is a lie here. If you do the
and then return that thread's previously selected frame. */
extern struct frame_info *get_selected_frame (const char *message);
+/* If there is a selected frame, return it. Otherwise, return NULL. */
+extern struct frame_info *get_selected_frame_if_set (void);
+
/* Select a specific frame. NULL, apparently implies re-select the
inner most frame. */
extern void select_frame (struct frame_info *);
This replaced: frame->pc; */
extern CORE_ADDR get_frame_pc (struct frame_info *);
+/* Same as get_frame_pc, but return a boolean indication of whether
+ the PC is actually available, instead of throwing an error. */
+
+extern int get_frame_pc_if_available (struct frame_info *frame,
+ CORE_ADDR *pc);
+
/* An address (not necessarily aligned to an instruction boundary)
that falls within THIS frame's code block.
extern CORE_ADDR get_frame_address_in_block (struct frame_info *this_frame);
+/* Same as get_frame_address_in_block, but returns a boolean
+ indication of whether the frame address is determinable (when the
+ PC is unavailable, it will not be), instead of possibly throwing an
+ error trying to read an unavailable PC. */
+
+extern int
+ get_frame_address_in_block_if_available (struct frame_info *this_frame,
+ CORE_ADDR *pc);
+
/* The frame's inner-most bound. AKA the stack-pointer. Confusingly
known as top-of-stack. */
that function isn't known. */
extern CORE_ADDR get_frame_func (struct frame_info *fi);
+/* Same as get_frame_func, but returns a boolean indication of whether
+ the frame function is determinable (when the PC is unavailable, it
+ will not be), instead of possibly throwing an error trying to read
+ an unavailable PC. */
+
+extern int get_frame_func_if_available (struct frame_info *fi, CORE_ADDR *);
+
/* Closely related to the resume address, various symbol table
attributes that are determined by the PC. Note that for a normal
frame, the PC refers to the resume address after the return, and
low-level unwinder, the stack part [typically] being the
top-of-stack of the previous frame, and the function part being the
function's start address. Since the correct identification of a
- frameless function requires both the a stack and function address,
+ frameless function requires both a stack and function address,
the old get_frame_base method was not sufficient.
get_frame_base_address: get_frame_locals_address:
error. But that's a project for another day. */
UNWIND_NULL_ID,
+ /* This frame is the outermost. */
+ UNWIND_OUTERMOST,
+
/* All the conditions after this point are considered errors;
abnormal stack termination. If a backtrace stops for one
of these reasons, we'll let the user know. This marker
is not a valid stop reason. */
UNWIND_FIRST_ERROR,
+ /* Can't unwind further, because that would require knowing the
+ values of registers or memory that haven't been collected. */
+ UNWIND_UNAVAILABLE,
+
/* This frame ID looks like it ought to belong to a NEXT frame,
but we got it for a PREV frame. Normally, this is a sign of
unwinder failure. It could also indicate stack corruption. */
fetch/compute the value. Instead just return the location of the
value. */
extern void frame_register_unwind (struct frame_info *frame, int regnum,
- int *optimizedp, enum lval_type *lvalp,
+ int *optimizedp, int *unavailablep,
+ enum lval_type *lvalp,
CORE_ADDR *addrp, int *realnump,
gdb_byte *valuep);
VALUEP is NULL, the registers value is not fetched/computed. */
extern void frame_register (struct frame_info *frame, int regnum,
- int *optimizedp, enum lval_type *lvalp,
+ int *optimizedp, int *unavailablep,
+ enum lval_type *lvalp,
CORE_ADDR *addrp, int *realnump,
gdb_byte *valuep);
const gdb_byte *buf);
/* Read LEN bytes from one or multiple registers starting with REGNUM
- in frame FRAME, starting at OFFSET, into BUF. */
+ in frame FRAME, starting at OFFSET, into BUF. If the register
+ contents are optimized out or unavailable, set *OPTIMIZEDP,
+ *UNAVAILABLEP accordingly. */
extern int get_frame_register_bytes (struct frame_info *frame, int regnum,
CORE_ADDR offset, int len,
- gdb_byte *myaddr);
+ gdb_byte *myaddr,
+ int *optimizedp, int *unavailablep);
/* Write LEN bytes to one or multiple registers starting with REGNUM
in frame FRAME, starting at OFFSET, into BUF. */
extern CORE_ADDR frame_unwind_caller_pc (struct frame_info *frame);
+/* Same as frame_unwind_caller_pc, but returns a boolean indication of
+ whether the caller PC is determinable (when the PC is unavailable,
+ it will not be), instead of possibly throwing an error trying to
+ read unavailable memory or registers. */
+
+extern int frame_unwind_caller_pc_if_available (struct frame_info *this_frame,
+ CORE_ADDR *pc);
+
/* Discard the specified frame. Restoring the registers to the state
of the caller. */
extern void frame_pop (struct frame_info *frame);
/* Values for the source flag to be used in print_frame_info_base(). */
enum print_what
{
- /* Print only the source line, like in stepi. */
+ /* Print only the source line, like in stepi. */
SRC_LINE = -1,
/* Print only the location, i.e. level, address (sometimes)
- function, args, file, line, line num. */
+ function, args, file, line, line num. */
LOCATION,
- /* Print both of the above. */
+ /* Print both of the above. */
SRC_AND_LOC,
- /* Print location only, but always include the address. */
+ /* Print location only, but always include the address. */
LOC_AND_ADDRESS
};
allocate memory using this method. */
extern void *frame_obstack_zalloc (unsigned long size);
-#define FRAME_OBSTACK_ZALLOC(TYPE) ((TYPE *) frame_obstack_zalloc (sizeof (TYPE)))
-#define FRAME_OBSTACK_CALLOC(NUMBER,TYPE) ((TYPE *) frame_obstack_zalloc ((NUMBER) * sizeof (TYPE)))
+#define FRAME_OBSTACK_ZALLOC(TYPE) \
+ ((TYPE *) frame_obstack_zalloc (sizeof (TYPE)))
+#define FRAME_OBSTACK_CALLOC(NUMBER,TYPE) \
+ ((TYPE *) frame_obstack_zalloc ((NUMBER) * sizeof (TYPE)))
/* Create a regcache, and copy the frame's registers into it. */
struct regcache *frame_save_as_regcache (struct frame_info *this_frame);
/* FIXME: cagney/2003-02-02: Should be deprecated or replaced with a
function called get_frame_register_p(). This slightly weird (and
older) variant of get_frame_register() returns zero (indicating the
- register is unavailable) if either: the register isn't cached; or
- the register has been optimized out. Problem is, neither check is
- exactly correct. A register can't be optimized out (it may not
- have been saved as part of a function call); The fact that a
- register isn't in the register cache doesn't mean that the register
- isn't available (it could have been fetched from memory). */
+ register value is unavailable/invalid) if either: the register
+ isn't cached; or the register has been optimized out; or the
+ register contents are unavailable (because they haven't been
+ collected in a traceframe). Problem is, neither check is exactly
+ correct. A register can't be optimized out (it may not have been
+ saved as part of a function call); The fact that a register isn't
+ in the register cache doesn't mean that the register isn't
+ available (it could have been fetched from memory). */
extern int frame_register_read (struct frame_info *frame, int regnum,
gdb_byte *buf);
projects / deliverable / binutils-gdb.git / blobdiff