/* 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
+ 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009, 2010
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. */
frames that do not change the stack but are still distinct and have
some form of distinct identifier (e.g. the ia64 which uses a 2nd
stack for registers). This field is treated as unordered - i.e. will
- not be used in frame ordering comparisons such as frame_id_inner().
+ not be used in frame ordering comparisons.
This field is valid only if special_addr_p is true. Otherwise, this
frame is considered to have a wildcard special address, i.e. one that
unsigned int stack_addr_p : 1;
unsigned int code_addr_p : 1;
unsigned int special_addr_p : 1;
-};
-
-/* Methods for constructing and comparing Frame IDs.
-
- NOTE: Given stackless functions A and B, where A calls B (and hence
- B is inner-to A). The relationships: !eq(A,B); !eq(B,A);
- !inner(A,B); !inner(B,A); all hold.
- This is because, while B is inner-to A, B is not strictly inner-to A.
- Being stackless, they have an identical .stack_addr value, and differ
- only by their unordered .code_addr and/or .special_addr values.
+ /* The inline depth of this frame. A frame representing a "called"
+ inlined function will have this set to a nonzero value. */
+ int inline_depth;
+};
- Because frame_id_inner is only used as a safety net (e.g.,
- detect a corrupt stack) the lack of strictness is not a problem.
- Code needing to determine an exact relationship between two frames
- must instead use frame_id_eq and frame_id_unwind. For instance,
- in the above, to determine that A stepped-into B, the equation
- "A.id != B.id && A.id == id_unwind (B)" can be used. */
+/* 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;
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);
-/* Returns non-zero when L is strictly inner-than R (they have
- different frame .bases). Neither L, nor R can be `null'. See note
- above about frameless functions. */
-extern int frame_id_inner (struct gdbarch *gdbarch, struct frame_id l,
- struct frame_id r);
-
/* Write the internal representation of a frame ID on the specified
stream. */
extern void fprint_frame_id (struct ui_file *file, struct frame_id id);
/* A fake frame, created by GDB when performing an inferior function
call. */
DUMMY_FRAME,
+ /* A frame representing an inlined function, associated with an
+ upcoming (next, inner, younger) 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
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).
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
CORE_ADDR offset, int len,
const gdb_byte *myaddr);
-/* Map between a frame register number and its name. A frame register
- space is a superset of the cooked register space --- it also
- includes builtin registers. If NAMELEN is negative, use the NAME's
- length when doing the comparison. */
-
-extern int frame_map_name_to_regnum (struct frame_info *frame,
- const char *name, int namelen);
-extern const char *frame_map_regnum_to_name (struct frame_info *frame,
- int regnum);
-
/* Unwind the PC. Strictly speaking return the resume address of the
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
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