/* Definitions for dealing with stack frames, for GDB, the GNU debugger.
- Copyright (C) 1986, 1988-1994, 1996-2004, 2007-2012 Free Software
- Foundation, Inc.
+ Copyright (C) 1986-2015 Free Software Foundation, Inc.
This file is part of GDB.
*/
+#include "language.h"
+
struct symtab_and_line;
struct frame_unwind;
struct frame_base;
struct gdbarch;
struct ui_file;
+/* Status of a given frame's stack. */
+
+enum frame_id_stack_status
+{
+ /* Stack address is invalid. E.g., this frame is the outermost
+ (i.e., _start), and the stack hasn't been setup yet. */
+ FID_STACK_INVALID = 0,
+
+ /* Stack address is valid, and is found in the stack_addr field. */
+ FID_STACK_VALID = 1,
+
+ /* Stack address is unavailable. I.e., there's a valid stack, but
+ we don't know where it is (because memory or registers we'd
+ compute it from were not collected). */
+ FID_STACK_UNAVAILABLE = -1
+};
+
/* The frame object. */
struct frame_info;
function pointer register or stack pointer register. They are
wrong.
- This field is valid only if stack_addr_p is true. Otherwise, this
- frame represents the null frame. */
+ This field is valid only if frame_id.stack_status is
+ FID_STACK_VALID. It will be 0 for other
+ FID_STACK_... statuses. */
CORE_ADDR stack_addr;
/* The frame's code address. This shall be constant through out the
CORE_ADDR special_addr;
/* Flags to indicate the above fields have valid contents. */
- unsigned int stack_addr_p : 1;
+ ENUM_BITFIELD(frame_id_stack_status) stack_status : 2;
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;
+ /* It is non-zero for a frame made up by GDB without stack data
+ representation in inferior, such as INLINE_FRAME or TAILCALL_FRAME.
+ Caller of inlined function will have it zero, each more inner called frame
+ will have it increasingly one, two etc. Similarly for TAILCALL_FRAME. */
+ int artificial_depth;
};
/* Methods for constructing and comparing Frame IDs. */
/* Flag to control debugging. */
-extern int frame_debug;
+extern unsigned int frame_debug;
/* Construct a frame ID. The first parameter is the frame's constant
stack address (typically the outer-bound), and the second the
CORE_ADDR code_addr,
CORE_ADDR special_addr);
+/* Construct a frame ID representing a frame where the stack address
+ exists, but is unavailable. CODE_ADDR is the frame's constant code
+ address (typically the entry point). The special identifier
+ address is set to indicate a wild card. */
+extern struct frame_id frame_id_build_unavailable_stack (CORE_ADDR code_addr);
+
+/* Construct a frame ID representing a frame where the stack address
+ exists, but is unavailable. CODE_ADDR is the frame's constant code
+ address (typically the entry point). SPECIAL_ADDR is the special
+ identifier address. */
+extern struct frame_id
+ frame_id_build_unavailable_stack_special (CORE_ADDR code_addr,
+ CORE_ADDR special_addr);
+
/* Construct a wild card frame ID. The parameter is the frame's constant
stack address (typically the outer-bound). The code address as well
as the special identifier address are set to indicate wild cards. */
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 is a valid frame representing a frame made up by GDB
+ without stack data representation in inferior, such as INLINE_FRAME or
+ TAILCALL_FRAME. */
+extern int frame_id_artificial_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 struct frame_info *get_prev_frame (struct frame_info *);
extern struct frame_info *get_next_frame (struct frame_info *);
+/* Return a "struct frame_info" corresponding to the frame that called
+ THIS_FRAME. Returns NULL if there is no such frame.
+
+ Unlike get_prev_frame, this function always tries to unwind the
+ frame. */
+extern struct frame_info *get_prev_frame_always (struct frame_info *);
+
/* Given a frame's ID, relocate the frame. Returns NULL if the frame
is not found. */
extern struct frame_info *frame_find_by_id (struct frame_id id);
struct symtab_and_line *sal);
/* Set the current source and line to the location given by frame
- FRAME, if possible. When CENTER is true, adjust so the relevant
- line is in the center of the next 'list'. */
+ FRAME, if possible. */
-void set_current_sal_from_frame (struct frame_info *, int);
+void set_current_sal_from_frame (struct frame_info *);
/* Return the frame base (what ever that is) (DEPRECATED).
enum unwind_stop_reason get_frame_unwind_stop_reason (struct frame_info *);
-/* Translate a reason code to an informative string. */
+/* Translate a reason code to an informative string. This converts the
+ generic stop reason codes into a generic string describing the code.
+ For a possibly frame specific string explaining the stop reason, use
+ FRAME_STOP_REASON_STRING instead. */
-const char *frame_stop_reason_string (enum unwind_stop_reason);
+const char *unwind_stop_reason_to_string (enum unwind_stop_reason);
+
+/* Return a possibly frame specific string explaining why the unwind
+ stopped here. E.g., if unwinding tripped on a memory error, this
+ will return the error description string, which includes the address
+ that we failed to access. If there's no specific reason stored for
+ a frame then a generic reason string will be returned.
+
+ Should only be called for frames that don't have a previous frame. */
+
+const char *frame_stop_reason_string (struct frame_info *);
/* Unwind the stack frame so that the value of REGNUM, in the previous
(up, older) frame is returned. If VALUEP is NULL, don't
extern ULONGEST get_frame_register_unsigned (struct frame_info *frame,
int regnum);
+/* Read a register from this, or unwind a register from the next
+ frame. Note that the read_frame methods are wrappers to
+ get_frame_register_value, that do not throw if the result is
+ optimized out or unavailable. */
+
+extern int read_frame_register_unsigned (struct frame_info *frame,
+ int regnum, ULONGEST *val);
/* Get the value of the register that belongs to this FRAME. This
function is a wrapper to the call sequence ``frame_register_unwind
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);
/* Create a regcache, and copy the frame's registers into it. */
struct regcache *frame_save_as_regcache (struct frame_info *this_frame);
-extern struct block *get_frame_block (struct frame_info *,
- CORE_ADDR *addr_in_block);
+extern const struct block *get_frame_block (struct frame_info *,
+ CORE_ADDR *addr_in_block);
/* Return the `struct block' that belongs to the selected thread's
selected frame. If the inferior has no state, return NULL.
it occurs in the CLI code and makes it possible for commands to
work, even when the inferior has no state. */
-extern struct block *get_selected_block (CORE_ADDR *addr_in_block);
+extern const struct block *get_selected_block (CORE_ADDR *addr_in_block);
extern struct symbol *get_frame_function (struct frame_info *);
extern struct frame_info *find_relative_frame (struct frame_info *, int *);
-extern void show_and_print_stack_frame (struct frame_info *fi, int print_level,
- enum print_what print_what);
-
extern void print_stack_frame (struct frame_info *, int print_level,
- enum print_what print_what);
+ enum print_what print_what,
+ int set_current_sal);
extern void print_frame_info (struct frame_info *, int print_level,
- enum print_what print_what, int args);
+ enum print_what print_what, int args,
+ int set_current_sal);
extern struct frame_info *block_innermost_frame (const struct block *);
-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
- older) variant of get_frame_register() returns zero (indicating the
- 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,
+extern int deprecated_frame_register_read (struct frame_info *frame, int regnum,
gdb_byte *buf);
/* From stack.c. */
extern void read_frame_arg (struct symbol *sym, struct frame_info *frame,
struct frame_arg *argp,
struct frame_arg *entryargp);
+extern void read_frame_local (struct symbol *sym, struct frame_info *frame,
+ struct frame_arg *argp);
extern void args_info (char *, int);
extern void locals_info (char *, int);
-extern void (*deprecated_selected_frame_level_changed_hook) (int);
-
extern void return_command (char *, int);
/* Set FRAME's unwinder temporarily, so that we can call a sniffer.
extern int frame_unwinder_is (struct frame_info *fi,
const struct frame_unwind *unwinder);
+/* Return the language of FRAME. */
+
+extern enum language get_frame_language (struct frame_info *frame);
+
+
#endif /* !defined (FRAME_H) */