/* 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.
frame_unwind_WHAT...(): Unwind THIS frame's WHAT from the NEXT
frame.
+ frame_unwind_caller_WHAT...(): Unwind WHAT for NEXT stack frame's
+ real caller. Any inlined functions in NEXT's stack frame are
+ skipped. Use these to ignore any potentially inlined functions,
+ e.g. inlined into the first instruction of a library trampoline.
+
+ get_stack_frame_WHAT...(): Get WHAT for THIS frame, but if THIS is
+ inlined, skip to the containing stack frame.
+
put_frame_WHAT...(): Put a value into this frame (unsafe, need to
invalidate the frame / regcache afterwards) (better name more
strongly hinting at its unsafeness)
Typically, it is set to the address of the entry point of the
frame's function (as returned by get_frame_func).
+ For inlined functions (INLINE_DEPTH != 0), this is the address of
+ the first executed instruction in the block corresponding to the
+ inlined function.
+
This field is valid only if code_addr_p is true. Otherwise, this
frame is considered to have a wildcard code address, i.e. one that
matches every address value in frame comparisons. */
unsigned int stack_addr_p : 1;
unsigned int code_addr_p : 1;
unsigned int special_addr_p : 1;
+
+ /* The inline depth of this frame. A frame representing a "called"
+ inlined function will have this set to a nonzero value. */
+ int inline_depth;
};
/* Methods for constructing and comparing Frame IDs. */
-/* For convenience. All fields are zero. */
+/* For convenience. All fields are zero. This means "there is no frame". */
extern const struct frame_id null_frame_id;
+/* This means "there is no frame ID, but there is a frame". It should be
+ replaced by best-effort frame IDs for the outermost frame, somehow.
+ The implementation is only special_addr_p set. */
+extern const struct frame_id outer_frame_id;
+
/* Flag to control debugging. */
extern int frame_debug;
/* 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);
extern struct frame_id frame_id_build_wild (CORE_ADDR stack_addr);
/* Returns non-zero when L is a valid frame (a valid frame has a
- non-zero .base). */
+ non-zero .base). The outermost frame is valid even without an
+ ID. */
extern int frame_id_p (struct frame_id l);
+/* Returns non-zero when L is a valid frame representing an inlined
+ function. */
+extern int frame_id_inlined_p (struct frame_id l);
+
/* Returns non-zero when L and R identify the same frame, or, if
either L or R have a zero .func, then the same frame base. */
extern int frame_id_eq (struct frame_id l, struct frame_id r);
/* A fake frame, created by GDB when performing an inferior function
call. */
DUMMY_FRAME,
+ /* A frame representing an inlined function, associated with an
+ 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. */
SIGTRAMP_FRAME,
+ /* Fake frame representing a cross-architecture call. */
+ ARCH_FRAME,
/* Sentinel or registers frame. This frame obtains register values
direct from the inferior's registers. */
SENTINEL_FRAME
/* 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
error. */
extern struct frame_info *get_current_frame (void);
+/* Does the current target interface have enough state to be able to
+ query the current inferior for frame info, and is the inferior in a
+ state where that is possible? */
+extern int has_stack_frames (void);
+
/* Invalidates the frame cache (this function should have been called
invalidate_cached_frames).
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 *);
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:
instead, since that avoids the bug. */
extern struct frame_id get_frame_id (struct frame_info *fi);
-extern struct frame_id frame_unwind_id (struct frame_info *next_frame);
+extern struct frame_id get_stack_frame_id (struct frame_info *fi);
+extern struct frame_id frame_unwind_caller_id (struct frame_info *next_frame);
/* Assuming that a frame is `normal', return its base-address, or 0 if
the information isn't available. NOTE: This address is really only
extern enum frame_type get_frame_type (struct frame_info *);
+/* Return the frame's program space. */
+extern struct program_space *get_frame_program_space (struct frame_info *);
+
+/* Unwind THIS frame's program space from the NEXT frame. */
+extern struct program_space *frame_unwind_program_space (struct frame_info *);
+
+/* Return the frame's address space. */
+extern struct address_space *get_frame_address_space (struct frame_info *);
+
/* For frames where we can not unwind further, describe why. */
enum unwind_stop_reason
calling frame. For GDB, `pc' is the resume address and not a
specific register. */
-extern CORE_ADDR frame_pc_unwind (struct frame_info *frame);
+extern CORE_ADDR frame_unwind_caller_pc (struct frame_info *frame);
/* Discard the specified frame. Restoring the registers to the state
of the caller. */
CORE_ADDR addr, gdb_byte *buf, int len);
/* Return this frame's architecture. */
-
extern struct gdbarch *get_frame_arch (struct frame_info *this_frame);
+/* Return the previous frame's architecture. */
+extern struct gdbarch *frame_unwind_arch (struct frame_info *frame);
+
+/* Return the previous frame's architecture, skipping inline functions. */
+extern struct gdbarch *frame_unwind_caller_arch (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);
extern struct frame_info *block_innermost_frame (struct block *);
-extern int deprecated_pc_in_call_dummy (CORE_ADDR pc);
+extern int deprecated_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc);
/* FIXME: cagney/2003-02-02: Should be deprecated or replaced with a
function called get_frame_register_p(). This slightly weird (and
extern struct frame_info *create_new_frame (CORE_ADDR base, CORE_ADDR pc);
-/* FIXME: cagney/2002-12-06: Has the PC in the current frame changed?
- "infrun.c", Thanks to gdbarch_decr_pc_after_break, can change the PC after
- the initial frame create. This puts things back in sync.
-
- This replaced: frame->pc = ....; */
-extern void deprecated_update_frame_pc_hack (struct frame_info *frame,
- CORE_ADDR pc);
-
-/* FIXME: cagney/2002-12-18: Has the frame's base changed? Or to be
- more exact, was that initial guess at the frame's base as returned
- by the deleted read_fp() wrong? If it was, fix it. This shouldn't
- be necessary since the code should be getting the frame's base
- correct from the outset.
+/* Return true if the frame unwinder for frame FI is UNWINDER; false
+ otherwise. */
- This replaced: frame->frame = ....; */
-extern void deprecated_update_frame_base_hack (struct frame_info *frame,
- CORE_ADDR base);
+extern int frame_unwinder_is (struct frame_info *fi,
+ const struct frame_unwind *unwinder);
#endif /* !defined (FRAME_H) */
projects / deliverable / binutils-gdb.git / blobdiff