X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fframe.h;h=cfc15022ed5b0da93c853b372a53d68c2a8dc17e;hb=f5df0b5f0874598790a60f1462f67887868bd77f;hp=8549e4387b3c06f942c52b329e30db548cbf683a;hpb=3e43a32aaa2d78fca10dea6746b820176f39bcc8;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/frame.h b/gdb/frame.h index 8549e4387b..cfc15022ed 100644 --- a/gdb/frame.h +++ b/gdb/frame.h @@ -1,8 +1,6 @@ /* 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, 2010, 2011 - Free Software Foundation, Inc. + Copyright (C) 1986-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -23,12 +21,12 @@ #define FRAME_H 1 /* The following is the intended naming schema for frame functions. - It isn't 100% consistent, but it is aproaching that. Frame naming + It isn't 100% consistent, but it is approaching that. Frame naming schema: Prefixes: - get_frame_WHAT...(): Get WHAT from the THIS frame (functionaly + get_frame_WHAT...(): Get WHAT from the THIS frame (functionally equivalent to THIS->next->unwind->what) frame_unwind_WHAT...(): Unwind THIS frame's WHAT from the NEXT @@ -71,12 +69,37 @@ */ +#include "language.h" +#include "cli/cli-option.h" + struct symtab_and_line; struct frame_unwind; struct frame_base; struct block; struct gdbarch; struct ui_file; +struct ui_out; +struct frame_print_options; + +/* 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, + + /* Sentinel frame. */ + FID_STACK_SENTINEL = 2, + + /* 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. */ @@ -99,8 +122,9 @@ struct frame_id 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 @@ -131,13 +155,34 @@ struct frame_id 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 : 3; 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; +}; + +/* Save and restore the currently selected frame. */ + +class scoped_restore_selected_frame +{ +public: + /* Save the currently selected frame. */ + scoped_restore_selected_frame (); + + /* Restore the currently selected frame. */ + ~scoped_restore_selected_frame (); + + DISABLE_COPY_AND_ASSIGN (scoped_restore_selected_frame); + +private: + + /* The ID of the previously selected frame. */ + struct frame_id m_fid; }; /* Methods for constructing and comparing Frame IDs. */ @@ -145,6 +190,9 @@ struct frame_id /* For convenience. All fields are zero. This means "there is no frame". */ extern const struct frame_id null_frame_id; +/* Sentinel frame. */ +extern const struct frame_id sentinel_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. */ @@ -152,7 +200,7 @@ extern const struct frame_id outer_frame_id; /* 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 @@ -164,11 +212,25 @@ extern struct frame_id frame_id_build (CORE_ADDR stack_addr, /* 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); +/* 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. */ @@ -179,9 +241,10 @@ extern struct frame_id frame_id_build_wild (CORE_ADDR stack_addr); 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. */ @@ -204,8 +267,10 @@ enum frame_type 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, + /* A virtual frame of a tail call - see dwarf2_tailcall_frame_unwind. */ + TAILCALL_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, @@ -218,7 +283,7 @@ enum frame_type /* 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 @@ -260,6 +325,9 @@ extern void reinit_frame_cache (void); 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 *); @@ -269,10 +337,25 @@ extern void select_frame (struct frame_info *); extern struct frame_info *get_prev_frame (struct frame_info *); extern struct frame_info *get_next_frame (struct frame_info *); +/* Like get_next_frame(), but allows return of the sentinel frame. NULL + is never returned. */ +extern struct frame_info *get_next_frame_sentinel_okay (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); +/* Given a frame's ID, find the previous frame's ID. Returns null_frame_id + if the frame is not found. */ +extern struct frame_id get_prev_frame_id_by_id (struct frame_id id); + /* Base attributes of a frame: */ /* The frame's `resume' address. Where the program will resume in @@ -281,6 +364,12 @@ extern struct frame_info *frame_find_by_id (struct frame_id id); 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. @@ -296,6 +385,15 @@ extern CORE_ADDR get_frame_pc (struct frame_info *); 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. */ @@ -306,6 +404,13 @@ extern CORE_ADDR get_frame_sp (struct frame_info *); 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 @@ -324,14 +429,12 @@ extern CORE_ADDR get_frame_func (struct frame_info *fi); find_frame_symtab(), find_frame_function(). Each will need to be carefully considered to determine if the real intent was for it to apply to the PC or the adjusted PC. */ -extern void find_frame_sal (struct frame_info *frame, - struct symtab_and_line *sal); +extern symtab_and_line find_frame_sal (frame_info *frame); /* 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). @@ -344,7 +447,7 @@ void set_current_sal_from_frame (struct frame_info *, int); 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: @@ -412,63 +515,55 @@ 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 *); +class address_space; + /* Return the frame's address space. */ -extern struct address_space *get_frame_address_space (struct frame_info *); +extern const address_space *get_frame_address_space (struct frame_info *); /* For frames where we can not unwind further, describe why. */ enum unwind_stop_reason { - /* No particular reason; either we haven't tried unwinding yet, - or we didn't fail. */ - UNWIND_NO_REASON, - - /* The previous frame's analyzer returns an invalid result - from this_id. - - FIXME drow/2006-08-16: This is how GDB used to indicate end of - stack. We should migrate to a model where frames always have a - valid ID, and this becomes not just an error but an internal - error. But that's a project for another day. */ - UNWIND_NULL_ID, - - /* 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, - - /* 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. */ - UNWIND_INNER_ID, - - /* This frame has the same ID as the previous one. That means - that unwinding further would almost certainly give us another - frame with exactly the same ID, so break the chain. Normally, - this is a sign of unwinder failure. It could also indicate - stack corruption. */ - UNWIND_SAME_ID, - - /* The frame unwinder didn't find any saved PC, but we needed - one to unwind further. */ - UNWIND_NO_SAVED_PC, +#define SET(name, description) name, +#define FIRST_ENTRY(name) UNWIND_FIRST = name, +#define LAST_ENTRY(name) UNWIND_LAST = name, +#define FIRST_ERROR(name) UNWIND_FIRST_ERROR = name, + +#include "unwind_stop_reasons.def" +#undef SET +#undef FIRST_ENTRY +#undef LAST_ENTRY +#undef FIRST_ERROR }; /* Return the reason why we can't unwind past this frame. */ 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 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, +extern void frame_register_unwind (frame_info *frame, int regnum, + int *optimizedp, int *unavailablep, + enum lval_type *lvalp, CORE_ADDR *addrp, int *realnump, gdb_byte *valuep); @@ -478,25 +573,32 @@ extern void frame_register_unwind (struct frame_info *frame, int regnum, fetch fails. The value methods never return NULL, but usually do return a lazy value. */ -extern void frame_unwind_register (struct frame_info *frame, +extern void frame_unwind_register (frame_info *next_frame, int regnum, gdb_byte *buf); extern void get_frame_register (struct frame_info *frame, int regnum, gdb_byte *buf); -struct value *frame_unwind_register_value (struct frame_info *frame, +struct value *frame_unwind_register_value (frame_info *next_frame, int regnum); struct value *get_frame_register_value (struct frame_info *frame, int regnum); -extern LONGEST frame_unwind_register_signed (struct frame_info *frame, +extern LONGEST frame_unwind_register_signed (frame_info *next_frame, int regnum); extern LONGEST get_frame_register_signed (struct frame_info *frame, int regnum); -extern ULONGEST frame_unwind_register_unsigned (struct frame_info *frame, - int regnum); +extern ULONGEST frame_unwind_register_unsigned (frame_info *frame, + int regnum); 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 @@ -504,7 +606,8 @@ extern ULONGEST get_frame_register_unsigned (struct frame_info *frame, 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); @@ -515,10 +618,13 @@ extern void put_frame_register (struct frame_info *frame, int regnum, 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. */ @@ -565,24 +671,34 @@ extern int safe_frame_unwind_memory (struct frame_info *this_frame, 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); +extern struct gdbarch *frame_unwind_arch (frame_info *next_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(). */ +/* Values for the source flag to be used in print_frame_info (). + For all the cases below, the address is never printed if + 'set print address' is off. When 'set print address' is on, + the address is printed if the program counter is not at the + beginning of the source line of the frame + and PRINT_WHAT is != LOC_AND_ADDRESS. */ enum print_what - { - /* 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. */ + { + /* Print only the address, source line, like in stepi. */ + SRC_LINE = -1, + /* Print only the location, i.e. level, address, + function, args (as controlled by 'set print frame-arguments'), + file, line, line num. */ LOCATION, - /* Print both of the above. */ - SRC_AND_LOC, - /* Print location only, but always include the address. */ - LOC_AND_ADDRESS + /* Print both of the above. */ + SRC_AND_LOC, + /* Print location only, print the address even if the program counter + is at the beginning of the source line. */ + LOC_AND_ADDRESS, + /* Print only level and function, + i.e. location only, without address, file, line, line num. */ + SHORT_LOCATION }; /* Allocate zero initialized memory from the frame cache obstack. @@ -595,11 +711,13 @@ extern void *frame_obstack_zalloc (unsigned long size); #define FRAME_OBSTACK_CALLOC(NUMBER,TYPE) \ ((TYPE *) frame_obstack_zalloc ((NUMBER) * sizeof (TYPE))) +class readonly_detached_regcache; /* Create a regcache, and copy the frame's registers into it. */ -struct regcache *frame_save_as_regcache (struct frame_info *this_frame); +std::unique_ptr 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. @@ -627,7 +745,7 @@ extern struct block *get_frame_block (struct frame_info *, 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 *); @@ -635,47 +753,120 @@ extern CORE_ADDR get_pc_function_start (CORE_ADDR); 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); +/* Wrapper over print_stack_frame modifying current_uiout with UIOUT for + the function call. */ -extern void print_stack_frame (struct frame_info *, int print_level, - enum print_what print_what); +extern void print_stack_frame_to_uiout (struct ui_out *uiout, + struct frame_info *, int print_level, + 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); - -extern struct frame_info *block_innermost_frame (struct block *); +extern void print_stack_frame (struct frame_info *, int print_level, + enum print_what print_what, + int set_current_sal); -extern int deprecated_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc); +extern void print_frame_info (const frame_print_options &fp_opts, + struct frame_info *, int print_level, + enum print_what print_what, int args, + int set_current_sal); -/* 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). */ +extern struct frame_info *block_innermost_frame (const struct block *); -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 args_info (char *, int); -extern void locals_info (char *, int); +/* The possible choices of "set print frame-arguments". */ +extern const char print_frame_arguments_all[]; +extern const char print_frame_arguments_scalars[]; +extern const char print_frame_arguments_none[]; + +/* The possible choices of "set print frame-info". */ +extern const char print_frame_info_auto[]; +extern const char print_frame_info_source_line[]; +extern const char print_frame_info_location[]; +extern const char print_frame_info_source_and_location[]; +extern const char print_frame_info_location_and_address[]; +extern const char print_frame_info_short_location[]; + +/* The possible choices of "set print entry-values". */ +extern const char print_entry_values_no[]; +extern const char print_entry_values_only[]; +extern const char print_entry_values_preferred[]; +extern const char print_entry_values_if_needed[]; +extern const char print_entry_values_both[]; +extern const char print_entry_values_compact[]; +extern const char print_entry_values_default[]; + +/* Data for the frame-printing "set print" settings exposed as command + options. */ + +struct frame_print_options +{ + const char *print_frame_arguments = print_frame_arguments_scalars; + const char *print_frame_info = print_frame_info_auto; + const char *print_entry_values = print_entry_values_default; + + /* If true, don't invoke pretty-printers for frame + arguments. */ + bool print_raw_frame_arguments; +}; -extern void (*deprecated_selected_frame_level_changed_hook) (int); +/* The values behind the global "set print ..." settings. */ +extern frame_print_options user_frame_print_options; -extern void return_command (char *, int); +/* Inferior function parameter value read in from a frame. */ + +struct frame_arg +{ + /* Symbol for this parameter used for example for its name. */ + struct symbol *sym = nullptr; + + /* Value of the parameter. It is NULL if ERROR is not NULL; if both VAL and + ERROR are NULL this parameter's value should not be printed. */ + struct value *val = nullptr; + + /* String containing the error message, it is more usually NULL indicating no + error occured reading this parameter. */ + gdb::unique_xmalloc_ptr error; + + /* One of the print_entry_values_* entries as appropriate specifically for + this frame_arg. It will be different from print_entry_values. With + print_entry_values_no this frame_arg should be printed as a normal + parameter. print_entry_values_only says it should be printed as entry + value parameter. print_entry_values_compact says it should be printed as + both as a normal parameter and entry values parameter having the same + value - print_entry_values_compact is not permitted fi ui_out_is_mi_like_p + (in such case print_entry_values_no and print_entry_values_only is used + for each parameter kind specifically. */ + const char *entry_kind = nullptr; +}; + +extern void read_frame_arg (const frame_print_options &fp_opts, + symbol *sym, 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 info_args_command (const char *, int); + +extern void info_locals_command (const char *, int); + +extern void return_command (const char *, int); /* Set FRAME's unwinder temporarily, so that we can call a sniffer. - Return a cleanup which should be called if unwinding fails, and - discarded if it succeeds. */ + If sniffing fails, the caller should be sure to call + frame_cleanup_after_sniffer. */ + +extern void frame_prepare_for_sniffer (struct frame_info *frame, + const struct frame_unwind *unwind); + +/* Clean up after a failed (wrong unwinder) attempt to unwind past + FRAME. */ -struct cleanup *frame_prepare_for_sniffer (struct frame_info *frame, - const struct frame_unwind *unwind); +extern void frame_cleanup_after_sniffer (struct frame_info *frame); /* Notes (cagney/2002-11-27, drow/2003-09-06): @@ -719,4 +910,52 @@ extern struct frame_info *create_new_frame (CORE_ADDR base, CORE_ADDR pc); 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); + +/* Return the first non-tailcall frame above FRAME or FRAME if it is not a + tailcall frame. Return NULL if FRAME is the start of a tailcall-only + chain. */ + +extern struct frame_info *skip_tailcall_frames (struct frame_info *frame); + +/* Return the first frame above FRAME or FRAME of which the code is + writable. */ + +extern struct frame_info *skip_unwritable_frames (struct frame_info *frame); + +/* Data for the "set backtrace" settings. */ + +struct set_backtrace_options +{ + /* Flag to indicate whether backtraces should continue past + main. */ + bool backtrace_past_main = false; + + /* Flag to indicate whether backtraces should continue past + entry. */ + bool backtrace_past_entry = false; + + /* Upper bound on the number of backtrace levels. Note this is not + exposed as a command option, because "backtrace" and "frame + apply" already have other means to set a frame count limit. */ + unsigned int backtrace_limit = UINT_MAX; +}; + +/* The corresponding option definitions. */ +extern const gdb::option::option_def set_backtrace_option_defs[2]; + +/* The values behind the global "set backtrace ..." settings. */ +extern set_backtrace_options user_set_backtrace_options; + +/* Mark that the PC value is masked for the previous frame. */ + +extern void set_frame_previous_pc_masked (struct frame_info *frame); + +/* Get whether the PC value is masked for the given frame. */ + +extern bool get_frame_pc_masked (const struct frame_info *frame); + + #endif /* !defined (FRAME_H) */