/* Definitions for dealing with stack frames, for GDB, the GNU debugger.
- Copyright (C) 1986-2022 Free Software Foundation, Inc.
+ Copyright (C) 1986-2024 Free Software Foundation, Inc.
This file is part of GDB.
#if !defined (FRAME_H)
#define FRAME_H 1
-#include "frame-info.h"
-
/* The following is the intended naming schema for frame functions.
It isn't 100% consistent, but it is approaching that. Frame naming
schema:
*/
-#include "language.h"
#include "cli/cli-option.h"
+#include "frame-id.h"
#include "gdbsupport/common-debug.h"
+#include "gdbsupport/intrusive_list.h"
struct symtab_and_line;
struct frame_unwind;
/* The frame object. */
-class frame_info_ptr;
/* Save and restore the currently selected frame. */
as the special identifier address are set to indicate wild cards. */
extern struct frame_id frame_id_build_wild (CORE_ADDR stack_addr);
+/* Construct a frame ID for a sentinel frame.
+
+ If either STACK_ADDR or CODE_ADDR is not 0, the ID represents a sentinel
+ frame for a user-created frame. STACK_ADDR and CODE_ADDR are the addresses
+ used to create the frame.
+
+ If STACK_ADDR and CODE_ADDR are both 0, the ID represents a regular sentinel
+ frame (i.e. the "next" frame of the target's current frame). */
+extern frame_id frame_id_build_sentinel (CORE_ADDR stack_addr, CORE_ADDR code_addr);
+
/* Returns true when L is a valid frame. */
extern bool frame_id_p (frame_id l);
SENTINEL_FRAME
};
+/* Return a string representation of TYPE. */
+
+extern const char *frame_type_str (frame_type type);
+
+/* A wrapper for "frame_info *". frame_info objects are invalidated
+ whenever reinit_frame_cache is called. This class arranges to
+ invalidate the pointer when appropriate. This is done to help
+ detect a GDB bug that was relatively common.
+
+ A small amount of code must still operate on raw pointers, so a
+ "get" method is provided. However, you should normally not use
+ this in new code. */
+
+class frame_info_ptr : public intrusive_list_node<frame_info_ptr>
+{
+public:
+ /* Create a frame_info_ptr from a raw pointer. */
+ explicit frame_info_ptr (struct frame_info *ptr);
+
+ /* Create a null frame_info_ptr. */
+ frame_info_ptr ()
+ {
+ frame_list.push_back (*this);
+ }
+
+ frame_info_ptr (std::nullptr_t)
+ {
+ frame_list.push_back (*this);
+ }
+
+ frame_info_ptr (const frame_info_ptr &other)
+ : m_ptr (other.m_ptr),
+ m_cached_id (other.m_cached_id),
+ m_cached_level (other.m_cached_level)
+ {
+ frame_list.push_back (*this);
+ }
+
+ frame_info_ptr (frame_info_ptr &&other)
+ : m_ptr (other.m_ptr),
+ m_cached_id (other.m_cached_id),
+ m_cached_level (other.m_cached_level)
+ {
+ other.m_ptr = nullptr;
+ other.m_cached_id = null_frame_id;
+ other.m_cached_level = invalid_level;
+ frame_list.push_back (*this);
+ }
+
+ ~frame_info_ptr ()
+ {
+ /* If this node has static storage, it should be be deleted before
+ frame_list. */
+ frame_list.erase (frame_list.iterator_to (*this));
+ }
+
+ frame_info_ptr &operator= (const frame_info_ptr &other)
+ {
+ m_ptr = other.m_ptr;
+ m_cached_id = other.m_cached_id;
+ m_cached_level = other.m_cached_level;
+ return *this;
+ }
+
+ frame_info_ptr &operator= (std::nullptr_t)
+ {
+ m_ptr = nullptr;
+ m_cached_id = null_frame_id;
+ m_cached_level = invalid_level;
+ return *this;
+ }
+
+ frame_info_ptr &operator= (frame_info_ptr &&other)
+ {
+ m_ptr = other.m_ptr;
+ m_cached_id = other.m_cached_id;
+ m_cached_level = other.m_cached_level;
+ other.m_ptr = nullptr;
+ other.m_cached_id = null_frame_id;
+ other.m_cached_level = invalid_level;
+ return *this;
+ }
+
+ frame_info *operator-> () const
+ { return this->reinflate (); }
+
+ /* Fetch the underlying pointer. Note that new code should
+ generally not use this -- avoid it if at all possible. */
+ frame_info *get () const
+ {
+ if (this->is_null ())
+ return nullptr;
+
+ return this->reinflate ();
+ }
+
+ /* Return true if this object is empty (does not wrap a frame_info
+ object). */
+
+ bool is_null () const
+ {
+ return m_cached_level == this->invalid_level;
+ };
+
+ /* This exists for compatibility with pre-existing code that checked
+ a "frame_info *" using "!". */
+ bool operator! () const
+ {
+ return this->is_null ();
+ }
+
+ /* This exists for compatibility with pre-existing code that checked
+ a "frame_info *" like "if (ptr)". */
+ explicit operator bool () const
+ {
+ return !this->is_null ();
+ }
+
+ /* Invalidate this pointer. */
+ void invalidate ()
+ {
+ m_ptr = nullptr;
+ }
+
+private:
+ /* We sometimes need to construct frame_info_ptr objects around the
+ sentinel_frame, which has level -1. Therefore, make the invalid frame
+ level value -2. */
+ static constexpr int invalid_level = -2;
+
+ /* Use the cached frame level and id to reinflate the pointer, and return
+ it. */
+ frame_info *reinflate () const;
+
+ /* The underlying pointer. */
+ mutable frame_info *m_ptr = nullptr;
+
+ /* The frame_id of the underlying pointer.
+
+ For the current target frames (frames with level 0, obtained through
+ get_current_frame), we don't save the frame id, we leave it at
+ null_frame_id. For user-created frames (also with level 0, but created
+ with create_new_frame), we do save the id. */
+ frame_id m_cached_id = null_frame_id;
+
+ /* The frame level of the underlying pointer. */
+ int m_cached_level = invalid_level;
+
+ /* All frame_info_ptr objects are kept on an intrusive list.
+ This keeps their construction and destruction costs
+ reasonably small. */
+ static intrusive_list<frame_info_ptr> frame_list;
+
+ /* A friend so it can invalidate the pointers. */
+ friend void reinit_frame_cache ();
+};
+
+static inline bool
+operator== (const frame_info *self, const frame_info_ptr &other)
+{
+ if (self == nullptr || other.is_null ())
+ return self == nullptr && other.is_null ();
+
+ return self == other.get ();
+}
+
+static inline bool
+operator== (const frame_info_ptr &self, const frame_info_ptr &other)
+{
+ if (self.is_null () || other.is_null ())
+ return self.is_null () && other.is_null ();
+
+ return self.get () == other.get ();
+}
+
+static inline bool
+operator== (const frame_info_ptr &self, const frame_info *other)
+{
+ if (self.is_null () || other == nullptr)
+ return self.is_null () && other == nullptr;
+
+ return self.get () == other;
+}
+
+static inline bool
+operator!= (const frame_info *self, const frame_info_ptr &other)
+{
+ return !(self == other);
+}
+
+static inline bool
+operator!= (const frame_info_ptr &self, const frame_info_ptr &other)
+{
+ return !(self == other);
+}
+
+static inline bool
+operator!= (const frame_info_ptr &self, const frame_info *other)
+{
+ return !(self == other);
+}
+
/* 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 GDB
and then return that thread's previously selected frame. */
extern frame_info_ptr get_selected_frame (const char *message = nullptr);
-/* Select a specific frame. NULL implies re-select the inner most
- frame. */
-extern void select_frame (frame_info_ptr );
+/* Select a specific frame. */
+extern void select_frame (const frame_info_ptr &);
/* Save the frame ID and frame level of the selected frame in FRAME_ID
and FRAME_LEVEL, to be restored later with restore_selected_frame.
extern void restore_selected_frame (frame_id frame_id, int frame_level)
noexcept;
-/* Lookup the frame_info object for the selected frame FRAME_ID /
- FRAME_LEVEL and cache the result.
-
- If FRAME_LEVEL > 0 and the originally selected frame isn't found,
- warn and select the innermost (current) frame. */
-extern void lookup_selected_frame (frame_id frame_id, int frame_level);
-
/* Given a FRAME, return the next (more inner, younger) or previous
(more outer, older) frame. */
-extern frame_info_ptr get_prev_frame (frame_info_ptr );
-extern frame_info_ptr get_next_frame (frame_info_ptr );
+extern frame_info_ptr get_prev_frame (const frame_info_ptr &);
+extern frame_info_ptr get_next_frame (const frame_info_ptr &);
/* Like get_next_frame(), but allows return of the sentinel frame. NULL
is never returned. */
-extern frame_info_ptr get_next_frame_sentinel_okay (frame_info_ptr );
+extern frame_info_ptr get_next_frame_sentinel_okay (const frame_info_ptr &);
/* 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 frame_info_ptr get_prev_frame_always (frame_info_ptr );
+extern frame_info_ptr get_prev_frame_always (const frame_info_ptr &);
+
+/* Given a frame's ID, relocate the frame. Returns NULL if the frame
+ is not found. */
+extern frame_info_ptr frame_find_by_id (frame_id id);
/* Base attributes of a frame: */
this frame.
This replaced: frame->pc; */
-extern CORE_ADDR get_frame_pc (frame_info_ptr );
+extern CORE_ADDR get_frame_pc (const frame_info_ptr &);
/* Same as get_frame_pc, but return a boolean indication of whether
the PC is actually available, instead of throwing an error. */
-extern bool get_frame_pc_if_available (frame_info_ptr frame, CORE_ADDR *pc);
+extern bool get_frame_pc_if_available (const frame_info_ptr &frame, CORE_ADDR *pc);
/* An address (not necessarily aligned to an instruction boundary)
that falls within THIS frame's code block.
function returns the frame's PC-1 which "should" be an address in
the frame's block. */
-extern CORE_ADDR get_frame_address_in_block (frame_info_ptr this_frame);
+extern CORE_ADDR get_frame_address_in_block (const frame_info_ptr &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 bool get_frame_address_in_block_if_available (frame_info_ptr this_frame,
+extern bool get_frame_address_in_block_if_available (const frame_info_ptr &this_frame,
CORE_ADDR *pc);
/* The frame's inner-most bound. AKA the stack-pointer. Confusingly
known as top-of-stack. */
-extern CORE_ADDR get_frame_sp (frame_info_ptr );
+extern CORE_ADDR get_frame_sp (const frame_info_ptr &);
/* Following on from the `resume' address. Return the entry point
address of the function containing that resume address, or zero if
that function isn't known. */
-extern CORE_ADDR get_frame_func (frame_info_ptr fi);
+extern CORE_ADDR get_frame_func (const frame_info_ptr &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 bool get_frame_func_if_available (frame_info_ptr fi, CORE_ADDR *);
+extern bool get_frame_func_if_available (const frame_info_ptr &fi, CORE_ADDR *);
/* Closely related to the resume address, various symbol table
attributes that are determined by the PC. Note that for a normal
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 symtab_and_line find_frame_sal (frame_info_ptr frame);
+extern symtab_and_line find_frame_sal (const frame_info_ptr &frame);
/* Set the current source and line to the location given by frame
FRAME, if possible. */
-void set_current_sal_from_frame (frame_info_ptr );
+void set_current_sal_from_frame (const frame_info_ptr &);
/* Return the frame base (what ever that is) (DEPRECATED).
This replaced: frame->frame; */
-extern CORE_ADDR get_frame_base (frame_info_ptr );
+extern CORE_ADDR get_frame_base (const frame_info_ptr &);
-/* Return the per-frame unique identifer. Can be used to relocate a
+/* Return the per-frame unique identifier. Can be used to relocate a
frame after a frame cache flush (and other similar operations). If
FI is NULL, return the null_frame_id. */
-extern struct frame_id get_frame_id (frame_info_ptr fi);
-extern struct frame_id get_stack_frame_id (frame_info_ptr fi);
-extern struct frame_id frame_unwind_caller_id (frame_info_ptr next_frame);
+extern frame_id get_frame_id (const frame_info_ptr &fi);
+extern frame_id get_stack_frame_id (const frame_info_ptr &fi);
+extern frame_id frame_unwind_caller_id (const frame_info_ptr &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
meaningful to the frame's high-level debug info. */
-extern CORE_ADDR get_frame_base_address (frame_info_ptr );
+extern CORE_ADDR get_frame_base_address (const frame_info_ptr &);
/* Assuming that a frame is `normal', return the base-address of the
local variables, or 0 if the information isn't available. NOTE:
This address is really only meaningful to the frame's high-level
debug info. Typically, the argument and locals share a single
base-address. */
-extern CORE_ADDR get_frame_locals_address (frame_info_ptr );
+extern CORE_ADDR get_frame_locals_address (const frame_info_ptr &);
/* Assuming that a frame is `normal', return the base-address of the
parameter list, or 0 if that information isn't available. NOTE:
This address is really only meaningful to the frame's high-level
debug info. Typically, the argument and locals share a single
base-address. */
-extern CORE_ADDR get_frame_args_address (frame_info_ptr );
+extern CORE_ADDR get_frame_args_address (const frame_info_ptr &);
/* The frame's level: 0 for innermost, 1 for its caller, ...; or -1
for an invalid frame). */
-extern int frame_relative_level (frame_info_ptr fi);
+extern int frame_relative_level (const frame_info_ptr &fi);
/* Return the frame's type. */
-extern enum frame_type get_frame_type (frame_info_ptr );
+extern enum frame_type get_frame_type (const frame_info_ptr &);
/* Return the frame's program space. */
-extern struct program_space *get_frame_program_space (frame_info_ptr );
+extern struct program_space *get_frame_program_space (const frame_info_ptr &);
/* Unwind THIS frame's program space from the NEXT frame. */
-extern struct program_space *frame_unwind_program_space (frame_info_ptr );
+extern struct program_space *frame_unwind_program_space (const frame_info_ptr &);
class address_space;
/* Return the frame's address space. */
-extern const address_space *get_frame_address_space (frame_info_ptr );
+extern const address_space *get_frame_address_space (const frame_info_ptr &);
+
+/* A frame may have a "static link". That is, in some languages, a
+ nested function may have access to variables from the enclosing
+ block and frame. This function looks for a frame's static link.
+ If found, returns the corresponding frame; otherwise, returns a
+ null frame_info_ptr. */
+extern frame_info_ptr frame_follow_static_link (const frame_info_ptr &frame);
/* For frames where we can not unwind further, describe why. */
/* Return the reason why we can't unwind past this frame. */
-enum unwind_stop_reason get_frame_unwind_stop_reason (frame_info_ptr );
+enum unwind_stop_reason get_frame_unwind_stop_reason (const frame_info_ptr &);
/* Translate a reason code to an informative string. This converts the
generic stop reason codes into a generic string describing the code.
Should only be called for frames that don't have a previous frame. */
-const char *frame_stop_reason_string (frame_info_ptr );
+const char *frame_stop_reason_string (const frame_info_ptr &);
/* 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 (frame_info_ptr frame, int regnum,
+extern void frame_register_unwind (const frame_info_ptr &frame, int regnum,
int *optimizedp, int *unavailablep,
enum lval_type *lvalp,
CORE_ADDR *addrp, int *realnump,
fetch fails. The value methods never return NULL, but usually
do return a lazy value. */
-extern void frame_unwind_register (frame_info_ptr next_frame,
+extern void frame_unwind_register (const frame_info_ptr &next_frame,
int regnum, gdb_byte *buf);
-extern void get_frame_register (frame_info_ptr frame,
+extern void get_frame_register (const frame_info_ptr &frame,
int regnum, gdb_byte *buf);
-struct value *frame_unwind_register_value (frame_info_ptr next_frame,
+struct value *frame_unwind_register_value (const frame_info_ptr &next_frame,
int regnum);
-struct value *get_frame_register_value (frame_info_ptr frame,
+struct value *get_frame_register_value (const frame_info_ptr &frame,
int regnum);
-extern LONGEST frame_unwind_register_signed (frame_info_ptr next_frame,
+extern LONGEST frame_unwind_register_signed (const frame_info_ptr &next_frame,
int regnum);
-extern LONGEST get_frame_register_signed (frame_info_ptr frame,
+extern LONGEST get_frame_register_signed (const frame_info_ptr &frame,
int regnum);
-extern ULONGEST frame_unwind_register_unsigned (frame_info_ptr frame,
- int regnum);
-extern ULONGEST get_frame_register_unsigned (frame_info_ptr frame,
+extern ULONGEST frame_unwind_register_unsigned
+ (const frame_info_ptr &next_frame, int regnum);
+extern ULONGEST get_frame_register_unsigned (const frame_info_ptr &frame,
int regnum);
/* Read a register from this, or unwind a register from the next
get_frame_register_value, that do not throw if the result is
optimized out or unavailable. */
-extern bool read_frame_register_unsigned (frame_info_ptr frame,
+extern bool read_frame_register_unsigned (const frame_info_ptr &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
- (get_next_frame (FRAME))''. As per frame_register_unwind(), if
- VALUEP is NULL, the registers value is not fetched/computed. */
-
-extern void frame_register (frame_info_ptr frame, int regnum,
- int *optimizedp, int *unavailablep,
- enum lval_type *lvalp,
- CORE_ADDR *addrp, int *realnump,
- gdb_byte *valuep);
-
-/* The reverse. Store a register value relative to the specified
- frame. Note: this call makes the frame's state undefined. The
- register and frame caches must be flushed. */
-extern void put_frame_register (frame_info_ptr 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. If the register
- contents are optimized out or unavailable, set *OPTIMIZEDP,
- *UNAVAILABLEP accordingly. */
-extern bool get_frame_register_bytes (frame_info_ptr frame, int regnum,
- CORE_ADDR offset,
+/* The reverse. Store a register value relative to NEXT_FRAME's previous frame.
+ Note: this call makes the frame's state undefined. The register and frame
+ caches must be flushed. */
+extern void put_frame_register (const frame_info_ptr &next_frame, int regnum,
+ gdb::array_view<const gdb_byte> buf);
+
+/* Read LEN bytes from one or multiple registers starting with REGNUM in
+ NEXT_FRAME's previous frame, starting at OFFSET, into BUF. If the register
+ contents are optimized out or unavailable, set *OPTIMIZEDP, *UNAVAILABLEP
+ accordingly. */
+extern bool get_frame_register_bytes (const frame_info_ptr &next_frame,
+ int regnum, CORE_ADDR offset,
gdb::array_view<gdb_byte> buffer,
int *optimizedp, int *unavailablep);
/* Write bytes from BUFFER to one or multiple registers starting with REGNUM
- in frame FRAME, starting at OFFSET. */
-extern void put_frame_register_bytes (frame_info_ptr frame, int regnum,
- CORE_ADDR offset,
+ in NEXT_FRAME's previous frame, starting at OFFSET. */
+extern void put_frame_register_bytes (const frame_info_ptr &next_frame,
+ int regnum, CORE_ADDR offset,
gdb::array_view<const gdb_byte> buffer);
/* 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_unwind_caller_pc (frame_info_ptr frame);
+extern CORE_ADDR frame_unwind_caller_pc (const frame_info_ptr &next_frame);
/* Discard the specified frame. Restoring the registers to the state
of the caller. */
-extern void frame_pop (frame_info_ptr frame);
+extern void frame_pop (const frame_info_ptr &frame);
/* Return memory from the specified frame. A frame knows its thread /
LWP and hence can find its way down to a target. The assumption
If architecture / memory changes are always separated by special
adaptor frames this should be ok. */
-extern void get_frame_memory (frame_info_ptr this_frame, CORE_ADDR addr,
+extern void get_frame_memory (const frame_info_ptr &this_frame, CORE_ADDR addr,
gdb::array_view<gdb_byte> buffer);
-extern LONGEST get_frame_memory_signed (frame_info_ptr this_frame,
+extern LONGEST get_frame_memory_signed (const frame_info_ptr &this_frame,
CORE_ADDR memaddr, int len);
-extern ULONGEST get_frame_memory_unsigned (frame_info_ptr this_frame,
+extern ULONGEST get_frame_memory_unsigned (const frame_info_ptr &this_frame,
CORE_ADDR memaddr, int len);
/* Same as above, but return true zero when the entire memory read
succeeds, false otherwise. */
-extern bool safe_frame_unwind_memory (frame_info_ptr this_frame, CORE_ADDR addr,
+extern bool safe_frame_unwind_memory (const frame_info_ptr &this_frame, CORE_ADDR addr,
gdb::array_view<gdb_byte> buffer);
/* Return this frame's architecture. */
-extern struct gdbarch *get_frame_arch (frame_info_ptr this_frame);
+extern gdbarch *get_frame_arch (const frame_info_ptr &this_frame);
/* Return the previous frame's architecture. */
-extern struct gdbarch *frame_unwind_arch (frame_info_ptr next_frame);
+extern gdbarch *frame_unwind_arch (const frame_info_ptr &next_frame);
/* Return the previous frame's architecture, skipping inline functions. */
-extern struct gdbarch *frame_unwind_caller_arch (frame_info_ptr frame);
+extern gdbarch *frame_unwind_caller_arch (const frame_info_ptr &next_frame);
/* Values for the source flag to be used in print_frame_info ().
class readonly_detached_regcache;
/* Create a regcache, and copy the frame's registers into it. */
std::unique_ptr<readonly_detached_regcache> frame_save_as_regcache
- (frame_info_ptr this_frame);
+ (const frame_info_ptr &this_frame);
-extern const struct block *get_frame_block (frame_info_ptr ,
+extern const struct block *get_frame_block (const frame_info_ptr &,
CORE_ADDR *addr_in_block);
/* Return the `struct block' that belongs to the selected thread's
extern const struct block *get_selected_block (CORE_ADDR *addr_in_block);
-extern struct symbol *get_frame_function (frame_info_ptr );
+extern struct symbol *get_frame_function (const frame_info_ptr &);
extern CORE_ADDR get_pc_function_start (CORE_ADDR);
-extern frame_info_ptr find_relative_frame (frame_info_ptr , int *);
+extern frame_info_ptr find_relative_frame (frame_info_ptr, int *);
/* Wrapper over print_stack_frame modifying current_uiout with UIOUT for
the function call. */
extern void print_stack_frame_to_uiout (struct ui_out *uiout,
- frame_info_ptr , int print_level,
+ const frame_info_ptr &, int print_level,
enum print_what print_what,
int set_current_sal);
-extern void print_stack_frame (frame_info_ptr , int print_level,
+extern void print_stack_frame (const frame_info_ptr &, int print_level,
enum print_what print_what,
int set_current_sal);
extern void print_frame_info (const frame_print_options &fp_opts,
- frame_info_ptr , int print_level,
+ const frame_info_ptr &, int print_level,
enum print_what print_what, int args,
int set_current_sal);
extern frame_info_ptr block_innermost_frame (const struct block *);
-extern bool deprecated_frame_register_read (frame_info_ptr frame, int regnum,
+extern bool deprecated_frame_register_read (const frame_info_ptr &frame, int regnum,
gdb_byte *buf);
/* From stack.c. */
struct value *val = nullptr;
/* String containing the error message, it is more usually NULL indicating no
- error occured reading this parameter. */
+ error occurred reading this parameter. */
gdb::unique_xmalloc_ptr<char> error;
/* One of the print_entry_values_* entries as appropriate specifically for
};
extern void read_frame_arg (const frame_print_options &fp_opts,
- symbol *sym, frame_info_ptr frame,
+ symbol *sym, const frame_info_ptr &frame,
struct frame_arg *argp,
struct frame_arg *entryargp);
-extern void read_frame_local (struct symbol *sym, frame_info_ptr frame,
+extern void read_frame_local (struct symbol *sym, const frame_info_ptr &frame,
struct frame_arg *argp);
extern void info_args_command (const char *, int);
If sniffing fails, the caller should be sure to call
frame_cleanup_after_sniffer. */
-extern void frame_prepare_for_sniffer (frame_info_ptr frame,
+extern void frame_prepare_for_sniffer (const frame_info_ptr &frame,
const struct frame_unwind *unwind);
/* Clean up after a failed (wrong unwinder) attempt to unwind past
FRAME. */
-extern void frame_cleanup_after_sniffer (frame_info_ptr frame);
+extern void frame_cleanup_after_sniffer (const frame_info_ptr &frame);
/* Notes (cagney/2002-11-27, drow/2003-09-06):
/* Return true if the frame unwinder for frame FI is UNWINDER; false
otherwise. */
-extern bool frame_unwinder_is (frame_info_ptr fi, const frame_unwind *unwinder);
+extern bool frame_unwinder_is (const frame_info_ptr &fi, const frame_unwind *unwinder);
/* Return the language of FRAME. */
-extern enum language get_frame_language (frame_info_ptr frame);
+extern enum language get_frame_language (const frame_info_ptr &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 frame_info_ptr skip_tailcall_frames (frame_info_ptr frame);
+extern frame_info_ptr skip_tailcall_frames (const frame_info_ptr &frame);
/* Return the first frame above FRAME or FRAME of which the code is
writable. */
-extern frame_info_ptr skip_unwritable_frames (frame_info_ptr frame);
+extern frame_info_ptr skip_unwritable_frames (const frame_info_ptr &frame);
/* Data for the "set backtrace" settings. */
/* Mark that the PC value is masked for the previous frame. */
-extern void set_frame_previous_pc_masked (frame_info_ptr frame);
+extern void set_frame_previous_pc_masked (const frame_info_ptr &frame);
/* Get whether the PC value is masked for the given frame. */
-extern bool get_frame_pc_masked (frame_info_ptr frame);
+extern bool get_frame_pc_masked (const frame_info_ptr &frame);
#endif /* !defined (FRAME_H) */
projects / thirdparty / binutils-gdb.git / blobdiff