We currently pass frames to function by value, as `frame_info_ptr`.
This is somewhat expensive:
- the size of `frame_info_ptr` is 64 bytes, which is a bit big to pass
by value
- the constructors and destructor link/unlink the object in the global
`frame_info_ptr::frame_list` list. This is an `intrusive_list`, so
it's not so bad: it's just assigning a few points, there's no memory
allocation as if it was `std::list`, but still it's useless to do
that over and over.
As suggested by Tom Tromey, change many function signatures to accept
`const frame_info_ptr &` instead of `frame_info_ptr`.
Some functions reassign their `frame_info_ptr` parameter, like:
void
the_func (frame_info_ptr frame)
{
for (; frame != nullptr; frame = get_prev_frame (frame))
{
...
}
}
I wondered what to do about them, do I leave them as-is or change them
(and need to introduce a separate local variable that can be
re-assigned). I opted for the later for consistency. It might not be
clear why some functions take `const frame_info_ptr &` while others take
`frame_info_ptr`. Also, if a function took a `frame_info_ptr` because
it did re-assign its parameter, I doubt that we would think to change it
to `const frame_info_ptr &` should the implementation change such that
it doesn't need to take `frame_info_ptr` anymore. It seems better to
have a simple rule and apply it everywhere.
Change-Id: I59d10addef687d157f82ccf4d54f5dde9a963fd0
Approved-By: Andrew Burgess <aburgess@redhat.com>
static void
aarch64_fbsd_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
- struct trad_frame_cache *this_cache,
- CORE_ADDR func)
+ const frame_info_ptr &this_frame,
+ struct trad_frame_cache *this_cache,
+ CORE_ADDR func)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
SIGNAL_FRAME. */
static void
-aarch64_linux_read_signal_frame_info (frame_info_ptr this_frame,
- struct aarch64_linux_sigframe &signal_frame)
+aarch64_linux_read_signal_frame_info (const frame_info_ptr &this_frame,
+ aarch64_linux_sigframe &signal_frame)
{
signal_frame.sp = get_frame_register_unsigned (this_frame, AARCH64_SP_REGNUM);
signal_frame.sigcontext_address
static void
aarch64_linux_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
/* Implements the "prev_arch" method of struct tramp_frame. */
static struct gdbarch *
-aarch64_linux_sigframe_prev_arch (frame_info_ptr this_frame,
+aarch64_linux_sigframe_prev_arch (const frame_info_ptr &this_frame,
void **frame_cache)
{
struct trad_frame_cache *cache
static CORE_ADDR
aarch64_frame_unmask_lr (aarch64_gdbarch_tdep *tdep,
- frame_info_ptr this_frame, CORE_ADDR addr)
+ const frame_info_ptr &this_frame, CORE_ADDR addr)
{
if (tdep->has_pauth ()
&& frame_unwind_register_unsigned (this_frame,
/* Implement the "get_pc_address_flags" gdbarch method. */
static std::string
-aarch64_get_pc_address_flags (frame_info_ptr frame, CORE_ADDR pc)
+aarch64_get_pc_address_flags (const frame_info_ptr &frame, CORE_ADDR pc)
{
if (pc != 0 && get_frame_pc_masked (frame))
return "PAC";
cache CACHE. */
static void
-aarch64_scan_prologue (frame_info_ptr this_frame,
+aarch64_scan_prologue (const frame_info_ptr &this_frame,
struct aarch64_prologue_cache *cache)
{
CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
not available. */
static void
-aarch64_make_prologue_cache_1 (frame_info_ptr this_frame,
+aarch64_make_prologue_cache_1 (const frame_info_ptr &this_frame,
struct aarch64_prologue_cache *cache)
{
CORE_ADDR unwound_fp;
*THIS_CACHE. */
static struct aarch64_prologue_cache *
-aarch64_make_prologue_cache (frame_info_ptr this_frame, void **this_cache)
+aarch64_make_prologue_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct aarch64_prologue_cache *cache;
/* Implement the "stop_reason" frame_unwind method. */
static enum unwind_stop_reason
-aarch64_prologue_frame_unwind_stop_reason (frame_info_ptr this_frame,
+aarch64_prologue_frame_unwind_stop_reason (const frame_info_ptr &this_frame,
void **this_cache)
{
struct aarch64_prologue_cache *cache
PC and the caller's SP when we were called. */
static void
-aarch64_prologue_this_id (frame_info_ptr this_frame,
+aarch64_prologue_this_id (const frame_info_ptr &this_frame,
void **this_cache, struct frame_id *this_id)
{
struct aarch64_prologue_cache *cache
/* Implement the "prev_register" frame_unwind method. */
static struct value *
-aarch64_prologue_prev_register (frame_info_ptr this_frame,
+aarch64_prologue_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int prev_regnum)
{
struct aarch64_prologue_cache *cache
*THIS_CACHE. */
static struct aarch64_prologue_cache *
-aarch64_make_stub_cache (frame_info_ptr this_frame, void **this_cache)
+aarch64_make_stub_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct aarch64_prologue_cache *cache;
/* Implement the "stop_reason" frame_unwind method. */
static enum unwind_stop_reason
-aarch64_stub_frame_unwind_stop_reason (frame_info_ptr this_frame,
+aarch64_stub_frame_unwind_stop_reason (const frame_info_ptr &this_frame,
void **this_cache)
{
struct aarch64_prologue_cache *cache
/* Our frame ID for a stub frame is the current SP and LR. */
static void
-aarch64_stub_this_id (frame_info_ptr this_frame,
+aarch64_stub_this_id (const frame_info_ptr &this_frame,
void **this_cache, struct frame_id *this_id)
{
struct aarch64_prologue_cache *cache
static int
aarch64_stub_unwind_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
CORE_ADDR addr_in_block;
/* Return the frame base address of *THIS_FRAME. */
static CORE_ADDR
-aarch64_normal_frame_base (frame_info_ptr this_frame, void **this_cache)
+aarch64_normal_frame_base (const frame_info_ptr &this_frame, void **this_cache)
{
struct aarch64_prologue_cache *cache
= aarch64_make_prologue_cache (this_frame, this_cache);
*THIS_FRAME. */
static struct value *
-aarch64_dwarf2_prev_register (frame_info_ptr this_frame,
+aarch64_dwarf2_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
gdbarch *arch = get_frame_arch (this_frame);
static void
aarch64_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
struct dwarf2_frame_state_reg *reg,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
aarch64_gdbarch_tdep *tdep = gdbarch_tdep<aarch64_gdbarch_tdep> (gdbarch);
/* Implement the "get_longjmp_target" gdbarch method. */
static int
-aarch64_get_longjmp_target (frame_info_ptr frame, CORE_ADDR *pc)
+aarch64_get_longjmp_target (const frame_info_ptr &frame, CORE_ADDR *pc)
{
CORE_ADDR jb_addr;
gdb_byte buf[X_REGISTER_SIZE];
/* Helper for aarch64_pseudo_read_value. */
static value *
-aarch64_pseudo_read_value_1 (frame_info_ptr next_frame,
+aarch64_pseudo_read_value_1 (const frame_info_ptr &next_frame,
const int pseudo_reg_num, int raw_regnum_offset)
{
unsigned v_regnum = AARCH64_V0_REGNUM + raw_regnum_offset;
/* Given REGNUM, a SME pseudo-register number, return its value in RESULT. */
static value *
-aarch64_sme_pseudo_register_read (gdbarch *gdbarch, frame_info_ptr next_frame,
+aarch64_sme_pseudo_register_read (gdbarch *gdbarch, const frame_info_ptr &next_frame,
const int pseudo_reg_num)
{
aarch64_gdbarch_tdep *tdep = gdbarch_tdep<aarch64_gdbarch_tdep> (gdbarch);
/* Implement the "pseudo_register_read_value" gdbarch method. */
static value *
-aarch64_pseudo_read_value (gdbarch *gdbarch, frame_info_ptr next_frame,
+aarch64_pseudo_read_value (gdbarch *gdbarch, const frame_info_ptr &next_frame,
const int pseudo_reg_num)
{
aarch64_gdbarch_tdep *tdep = gdbarch_tdep<aarch64_gdbarch_tdep> (gdbarch);
/* Helper for aarch64_pseudo_write. */
static void
-aarch64_pseudo_write_1 (gdbarch *gdbarch, frame_info_ptr next_frame,
+aarch64_pseudo_write_1 (gdbarch *gdbarch, const frame_info_ptr &next_frame,
int regnum_offset,
gdb::array_view<const gdb_byte> buf)
{
pseudo-register. */
static void
-aarch64_sme_pseudo_register_write (gdbarch *gdbarch, frame_info_ptr next_frame,
+aarch64_sme_pseudo_register_write (gdbarch *gdbarch, const frame_info_ptr &next_frame,
const int regnum,
gdb::array_view<const gdb_byte> data)
{
/* Implement the "pseudo_register_write" gdbarch method. */
static void
-aarch64_pseudo_write (gdbarch *gdbarch, frame_info_ptr next_frame,
+aarch64_pseudo_write (gdbarch *gdbarch, const frame_info_ptr &next_frame,
const int pseudo_reg_num,
gdb::array_view<const gdb_byte> buf)
{
/* Callback function for user_reg_add. */
static struct value *
-value_of_aarch64_user_reg (frame_info_ptr frame, const void *baton)
+value_of_aarch64_user_reg (const frame_info_ptr &frame, const void *baton)
{
const int *reg_p = (const int *) baton;
to most users. */
static int
-is_known_support_routine (frame_info_ptr frame)
+is_known_support_routine (const frame_info_ptr &frame)
{
enum language func_lang;
int i;
part of the Ada run-time, starting from FI and moving upward. */
void
-ada_find_printable_frame (frame_info_ptr fi)
+ada_find_printable_frame (const frame_info_ptr &initial_fi)
{
- for (; fi != NULL; fi = get_prev_frame (fi))
+ for (frame_info_ptr fi = initial_fi; fi != nullptr; fi = get_prev_frame (fi))
{
if (!is_known_support_routine (fi))
{
static void
ada_add_exceptions_from_frame (compiled_regex *preg,
- frame_info_ptr frame,
+ const frame_info_ptr &frame,
std::vector<ada_exc_info> *exceptions)
{
const struct block *block = get_frame_block (frame, 0);
struct value *read_var_value (struct symbol *var,
const struct block *var_block,
- frame_info_ptr frame) const override
+ const frame_info_ptr &frame) const override
{
/* The only case where default_read_var_value is not sufficient
is when VAR is a renaming... */
const char **,
int *, const char **);
-extern void ada_find_printable_frame (frame_info_ptr fi);
+extern void ada_find_printable_frame (const frame_info_ptr &fi);
extern const char *ada_main_name ();
}
static CORE_ADDR
-alpha_linux_sigcontext_addr (frame_info_ptr this_frame)
+alpha_linux_sigcontext_addr (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
CORE_ADDR pc;
and store the resulting register save locations in the structure. */
static struct alpha_mdebug_unwind_cache *
-alpha_mdebug_frame_unwind_cache (frame_info_ptr this_frame,
+alpha_mdebug_frame_unwind_cache (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
struct alpha_mdebug_unwind_cache *info;
frame. This will be used to create a new GDB frame struct. */
static void
-alpha_mdebug_frame_this_id (frame_info_ptr this_frame,
+alpha_mdebug_frame_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
/* Retrieve the value of REGNUM in FRAME. Don't give up! */
static struct value *
-alpha_mdebug_frame_prev_register (frame_info_ptr this_frame,
+alpha_mdebug_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
struct alpha_mdebug_unwind_cache *info
static int
alpha_mdebug_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
CORE_ADDR pc = get_frame_address_in_block (this_frame);
};
static CORE_ADDR
-alpha_mdebug_frame_base_address (frame_info_ptr this_frame,
+alpha_mdebug_frame_base_address (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
struct alpha_mdebug_unwind_cache *info
}
static CORE_ADDR
-alpha_mdebug_frame_locals_address (frame_info_ptr this_frame,
+alpha_mdebug_frame_locals_address (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
struct alpha_mdebug_unwind_cache *info
}
static CORE_ADDR
-alpha_mdebug_frame_args_address (frame_info_ptr this_frame,
+alpha_mdebug_frame_args_address (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
struct alpha_mdebug_unwind_cache *info
};
static const struct frame_base *
-alpha_mdebug_frame_base_sniffer (frame_info_ptr this_frame)
+alpha_mdebug_frame_base_sniffer (const frame_info_ptr &this_frame)
{
CORE_ADDR pc = get_frame_address_in_block (this_frame);
struct mdebug_extra_func_info *proc_desc;
}
static CORE_ADDR
-alphanbsd_sigcontext_addr (frame_info_ptr frame)
+alphanbsd_sigcontext_addr (const frame_info_ptr &frame)
{
/* FIXME: This is not correct for all versions of NetBSD/alpha.
We will probably need to disassemble the trampoline to figure
}
static CORE_ADDR
-alphaobsd_sigcontext_addr (frame_info_ptr this_frame)
+alphaobsd_sigcontext_addr (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
CORE_ADDR pc = get_frame_pc (this_frame);
}
static int
-alpha_register_to_value (frame_info_ptr frame, int regnum,
+alpha_register_to_value (const frame_info_ptr &frame, int regnum,
struct type *valtype, gdb_byte *out,
int *optimizedp, int *unavailablep)
{
}
static void
-alpha_value_to_register (frame_info_ptr frame, int regnum,
+alpha_value_to_register (const frame_info_ptr &frame, int regnum,
struct type *valtype, const gdb_byte *in)
{
int reg_size = register_size (get_frame_arch (frame), regnum);
into the "pc". This routine returns true on success. */
static int
-alpha_get_longjmp_target (frame_info_ptr frame, CORE_ADDR *pc)
+alpha_get_longjmp_target (const frame_info_ptr &frame, CORE_ADDR *pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
alpha_gdbarch_tdep *tdep = gdbarch_tdep<alpha_gdbarch_tdep> (gdbarch);
};
static struct alpha_sigtramp_unwind_cache *
-alpha_sigtramp_frame_unwind_cache (frame_info_ptr this_frame,
+alpha_sigtramp_frame_unwind_cache (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
struct alpha_sigtramp_unwind_cache *info;
frame. This will be used to create a new GDB frame struct. */
static void
-alpha_sigtramp_frame_this_id (frame_info_ptr this_frame,
+alpha_sigtramp_frame_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
/* Retrieve the value of REGNUM in FRAME. Don't give up! */
static struct value *
-alpha_sigtramp_frame_prev_register (frame_info_ptr this_frame,
+alpha_sigtramp_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
struct alpha_sigtramp_unwind_cache *info
static int
alpha_sigtramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
static struct alpha_heuristic_unwind_cache *
-alpha_heuristic_frame_unwind_cache (frame_info_ptr this_frame,
+alpha_heuristic_frame_unwind_cache (const frame_info_ptr &this_frame,
void **this_prologue_cache,
CORE_ADDR start_pc)
{
frame. This will be used to create a new GDB frame struct. */
static void
-alpha_heuristic_frame_this_id (frame_info_ptr this_frame,
+alpha_heuristic_frame_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
/* Retrieve the value of REGNUM in FRAME. Don't give up! */
static struct value *
-alpha_heuristic_frame_prev_register (frame_info_ptr this_frame,
+alpha_heuristic_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
struct alpha_heuristic_unwind_cache *info
};
static CORE_ADDR
-alpha_heuristic_frame_base_address (frame_info_ptr this_frame,
+alpha_heuristic_frame_base_address (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
struct alpha_heuristic_unwind_cache *info
/* Translate a signal handler stack base address into the address of
the sigcontext structure for that signal handler. */
- CORE_ADDR (*sigcontext_addr) (frame_info_ptr) = nullptr;
+ CORE_ADDR (*sigcontext_addr) (const frame_info_ptr &) = nullptr;
/* Does the PC fall in a signal trampoline. */
/* NOTE: cagney/2004-04-30: Do not copy/clone this code. Instead
address of the associated sigcontext structure. */
static CORE_ADDR
-amd64_darwin_sigcontext_addr (frame_info_ptr this_frame)
+amd64_darwin_sigcontext_addr (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
static void
amd64_fbsd_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
the routine. Otherwise, return 0. */
static CORE_ADDR
-amd64_linux_sigtramp_start (frame_info_ptr this_frame)
+amd64_linux_sigtramp_start (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch;
const gdb_byte *sigtramp_code;
routine. */
static int
-amd64_linux_sigtramp_p (frame_info_ptr this_frame)
+amd64_linux_sigtramp_p (const frame_info_ptr &this_frame)
{
CORE_ADDR pc = get_frame_pc (this_frame);
const char *name;
address of the associated sigcontext structure. */
static CORE_ADDR
-amd64_linux_sigcontext_addr (frame_info_ptr this_frame)
+amd64_linux_sigcontext_addr (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
routine. */
static int
-amd64nbsd_sigtramp_p (frame_info_ptr this_frame)
+amd64nbsd_sigtramp_p (const frame_info_ptr &this_frame)
{
CORE_ADDR pc = get_frame_pc (this_frame);
const char *name;
return the address of the associated mcontext structure. */
static CORE_ADDR
-amd64nbsd_mcontext_addr (frame_info_ptr this_frame)
+amd64nbsd_mcontext_addr (const frame_info_ptr &this_frame)
{
CORE_ADDR addr;
routine. */
static int
-amd64obsd_sigtramp_p (frame_info_ptr this_frame)
+amd64obsd_sigtramp_p (const frame_info_ptr &this_frame)
{
CORE_ADDR pc = get_frame_pc (this_frame);
CORE_ADDR start_pc = (pc & ~(amd64obsd_page_size - 1));
address of the associated sigcontext structure. */
static CORE_ADDR
-amd64obsd_sigcontext_addr (frame_info_ptr this_frame)
+amd64obsd_sigcontext_addr (const frame_info_ptr &this_frame)
{
CORE_ADDR pc = get_frame_pc (this_frame);
ULONGEST offset = (pc & (amd64obsd_page_size - 1));
#define amd64obsd_tf_reg_offset amd64obsd_sc_reg_offset
static struct trad_frame_cache *
-amd64obsd_trapframe_cache (frame_info_ptr this_frame, void **this_cache)
+amd64obsd_trapframe_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
}
static void
-amd64obsd_trapframe_this_id (frame_info_ptr this_frame,
+amd64obsd_trapframe_this_id (const frame_info_ptr &this_frame,
void **this_cache, struct frame_id *this_id)
{
struct trad_frame_cache *cache =
}
static struct value *
-amd64obsd_trapframe_prev_register (frame_info_ptr this_frame,
+amd64obsd_trapframe_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct trad_frame_cache *cache =
static int
amd64obsd_trapframe_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
ULONGEST cs;
'mcontext_t' that contains the saved set of machine registers. */
static CORE_ADDR
-amd64_sol2_mcontext_addr (frame_info_ptr this_frame)
+amd64_sol2_mcontext_addr (const frame_info_ptr &this_frame)
{
CORE_ADDR sp, ucontext_addr;
}
static value *
-amd64_pseudo_register_read_value (gdbarch *gdbarch, frame_info_ptr next_frame,
+amd64_pseudo_register_read_value (gdbarch *gdbarch, const frame_info_ptr &next_frame,
int regnum)
{
i386_gdbarch_tdep *tdep = gdbarch_tdep<i386_gdbarch_tdep> (gdbarch);
}
static void
-amd64_pseudo_register_write (gdbarch *gdbarch, frame_info_ptr next_frame,
+amd64_pseudo_register_write (gdbarch *gdbarch, const frame_info_ptr &next_frame,
int regnum, gdb::array_view<const gdb_byte> buf)
{
i386_gdbarch_tdep *tdep = gdbarch_tdep<i386_gdbarch_tdep> (gdbarch);
/* Normal frames. */
static void
-amd64_frame_cache_1 (frame_info_ptr this_frame,
+amd64_frame_cache_1 (const frame_info_ptr &this_frame,
struct amd64_frame_cache *cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
static struct amd64_frame_cache *
-amd64_frame_cache (frame_info_ptr this_frame, void **this_cache)
+amd64_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct amd64_frame_cache *cache;
}
static enum unwind_stop_reason
-amd64_frame_unwind_stop_reason (frame_info_ptr this_frame,
+amd64_frame_unwind_stop_reason (const frame_info_ptr &this_frame,
void **this_cache)
{
struct amd64_frame_cache *cache =
}
static void
-amd64_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+amd64_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct amd64_frame_cache *cache =
}
static struct value *
-amd64_frame_prev_register (frame_info_ptr this_frame, void **this_cache,
+amd64_frame_prev_register (const frame_info_ptr &this_frame, void **this_cache,
int regnum)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
on both platforms. */
static struct amd64_frame_cache *
-amd64_sigtramp_frame_cache (frame_info_ptr this_frame, void **this_cache)
+amd64_sigtramp_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
i386_gdbarch_tdep *tdep = gdbarch_tdep<i386_gdbarch_tdep> (gdbarch);
}
static enum unwind_stop_reason
-amd64_sigtramp_frame_unwind_stop_reason (frame_info_ptr this_frame,
+amd64_sigtramp_frame_unwind_stop_reason (const frame_info_ptr &this_frame,
void **this_cache)
{
struct amd64_frame_cache *cache =
}
static void
-amd64_sigtramp_frame_this_id (frame_info_ptr this_frame,
+amd64_sigtramp_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache, struct frame_id *this_id)
{
struct amd64_frame_cache *cache =
}
static struct value *
-amd64_sigtramp_frame_prev_register (frame_info_ptr this_frame,
+amd64_sigtramp_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
/* Make sure we've initialized the cache. */
static int
amd64_sigtramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
gdbarch *arch = get_frame_arch (this_frame);
\f
static CORE_ADDR
-amd64_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+amd64_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct amd64_frame_cache *cache =
amd64_frame_cache (this_frame, this_cache);
static int
amd64_epilogue_frame_sniffer_1 (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache, bool override_p)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
static int
amd64_epilogue_override_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
return amd64_epilogue_frame_sniffer_1 (self, this_frame, this_prologue_cache,
static int
amd64_epilogue_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
return amd64_epilogue_frame_sniffer_1 (self, this_frame, this_prologue_cache,
}
static struct amd64_frame_cache *
-amd64_epilogue_frame_cache (frame_info_ptr this_frame, void **this_cache)
+amd64_epilogue_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
}
static enum unwind_stop_reason
-amd64_epilogue_frame_unwind_stop_reason (frame_info_ptr this_frame,
+amd64_epilogue_frame_unwind_stop_reason (const frame_info_ptr &this_frame,
void **this_cache)
{
struct amd64_frame_cache *cache
}
static void
-amd64_epilogue_frame_this_id (frame_info_ptr this_frame,
+amd64_epilogue_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache,
struct frame_id *this_id)
{
};
static struct frame_id
-amd64_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
+amd64_dummy_id (struct gdbarch *gdbarch, const frame_info_ptr &this_frame)
{
CORE_ADDR fp;
success. */
static int
-amd64_get_longjmp_target (frame_info_ptr frame, CORE_ADDR *pc)
+amd64_get_longjmp_target (const frame_info_ptr &frame, CORE_ADDR *pc)
{
gdb_byte buf[8];
CORE_ADDR jb_addr;
Return 1 if an epilogue sequence was recognized, 0 otherwise. */
static int
-amd64_windows_frame_decode_epilogue (frame_info_ptr this_frame,
+amd64_windows_frame_decode_epilogue (const frame_info_ptr &this_frame,
struct amd64_windows_frame_cache *cache)
{
/* According to MSDN an epilogue "must consist of either an add RSP,constant
/* Decode and execute unwind insns at UNWIND_INFO. */
static void
-amd64_windows_frame_decode_insns (frame_info_ptr this_frame,
+amd64_windows_frame_decode_insns (const frame_info_ptr &this_frame,
struct amd64_windows_frame_cache *cache,
CORE_ADDR unwind_info)
{
for THIS_FRAME. */
static struct amd64_windows_frame_cache *
-amd64_windows_frame_cache (frame_info_ptr this_frame, void **this_cache)
+amd64_windows_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
using the standard Windows x64 SEH info. */
static struct value *
-amd64_windows_frame_prev_register (frame_info_ptr this_frame,
+amd64_windows_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
the standard Windows x64 SEH info. */
static void
-amd64_windows_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+amd64_windows_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct amd64_windows_frame_cache *cache =
/* Check Win64 DLL jmp trampolines and find jump destination. */
static CORE_ADDR
-amd64_windows_skip_trampoline_code (frame_info_ptr frame, CORE_ADDR pc)
+amd64_windows_skip_trampoline_code (const frame_info_ptr &frame, CORE_ADDR pc)
{
CORE_ADDR destination = 0;
struct gdbarch *gdbarch = get_frame_arch (frame);
};
static amdgpu_frame_cache *
-amdgpu_frame_cache (frame_info_ptr this_frame, void **this_cache)
+amdgpu_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
if (*this_cache != nullptr)
return (struct amdgpu_frame_cache *) *this_cache;
}
static void
-amdgpu_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+amdgpu_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
frame_id *this_id)
{
struct amdgpu_frame_cache *cache
}
static frame_id
-amdgpu_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
+amdgpu_dummy_id (struct gdbarch *gdbarch, const frame_info_ptr &this_frame)
{
return frame_id_build (0, get_frame_pc (this_frame));
}
static struct value *
-amdgpu_frame_prev_register (frame_info_ptr this_frame, void **this_cache,
+amdgpu_frame_prev_register (const frame_info_ptr &this_frame, void **this_cache,
int regnum)
{
return frame_unwind_got_register (this_frame, regnum, regnum);
Returns TRUE if this is a sigtramp frame. */
static bool
-arc_linux_is_sigtramp (frame_info_ptr this_frame)
+arc_linux_is_sigtramp (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
CORE_ADDR pc = get_frame_pc (this_frame);
etc) in GDB hardcode values. */
static CORE_ADDR
-arc_linux_sigcontext_addr (frame_info_ptr this_frame)
+arc_linux_sigcontext_addr (const frame_info_ptr &this_frame)
{
const int ucontext_offset = 0x80;
const int sigcontext_offset = 0x14;
/* Implement the "get_longjmp_target" gdbarch method. */
static int
-arc_get_longjmp_target (frame_info_ptr frame, CORE_ADDR *pc)
+arc_get_longjmp_target (const frame_info_ptr &frame, CORE_ADDR *pc)
{
arc_debug_printf ("called");
frame pointer. */
static CORE_ADDR
-arc_frame_base_address (frame_info_ptr this_frame, void **prologue_cache)
+arc_frame_base_address (const frame_info_ptr &this_frame, void **prologue_cache)
{
return (CORE_ADDR) get_frame_register_unsigned (this_frame, ARC_FP_REGNUM);
}
/* Frame unwinder for normal frames. */
static struct arc_frame_cache *
-arc_make_frame_cache (frame_info_ptr this_frame)
+arc_make_frame_cache (const frame_info_ptr &this_frame)
{
arc_debug_printf ("called");
/* Implement the "this_id" frame_unwind method. */
static void
-arc_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+arc_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
arc_debug_printf ("called");
/* Implement the "prev_register" frame_unwind method. */
static struct value *
-arc_frame_prev_register (frame_info_ptr this_frame,
+arc_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
if (*this_cache == NULL)
static void
arc_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
struct dwarf2_frame_state_reg *reg,
- frame_info_ptr info)
+ const frame_info_ptr &info)
{
if (regnum == gdbarch_pc_regnum (gdbarch))
/* The return address column. */
from within signal handlers. */
static struct arc_frame_cache *
-arc_make_sigtramp_frame_cache (frame_info_ptr this_frame)
+arc_make_sigtramp_frame_cache (const frame_info_ptr &this_frame)
{
arc_debug_printf ("called");
frames. */
static void
-arc_sigtramp_frame_this_id (frame_info_ptr this_frame,
+arc_sigtramp_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache, struct frame_id *this_id)
{
arc_debug_printf ("called");
/* Get a register from a signal handler frame. */
static struct value *
-arc_sigtramp_frame_prev_register (frame_info_ptr this_frame,
+arc_sigtramp_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
arc_debug_printf ("regnum = %d", regnum);
static int
arc_sigtramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
arc_debug_printf ("called");
bool has_hw_loops = false;
/* Detect sigtramp. */
- bool (*is_sigtramp) (frame_info_ptr) = nullptr;
+ bool (*is_sigtramp) (const frame_info_ptr &) = nullptr;
/* Get address of sigcontext for sigtramp. */
- CORE_ADDR (*sigcontext_addr) (frame_info_ptr) = nullptr;
+ CORE_ADDR (*sigcontext_addr) (const frame_info_ptr &) = nullptr;
/* Offset of registers in `struct sigcontext'. */
const int *sc_reg_offset = nullptr;
}
CORE_ADDR
-generic_skip_trampoline_code (frame_info_ptr frame, CORE_ADDR pc)
+generic_skip_trampoline_code (const frame_info_ptr &frame, CORE_ADDR pc)
{
return 0;
}
int
default_code_of_frame_writable (struct gdbarch *gdbarch,
- frame_info_ptr frame)
+ const frame_info_ptr &frame)
{
return 1;
}
/* See arch-utils.h. */
std::string
-default_get_pc_address_flags (frame_info_ptr frame, CORE_ADDR pc)
+default_get_pc_address_flags (const frame_info_ptr &frame, CORE_ADDR pc)
{
return "";
}
}
CORE_ADDR
-default_get_return_buf_addr (struct type *val_type, frame_info_ptr cur_frame)
+default_get_return_buf_addr (struct type *val_type,
+ const frame_info_ptr &cur_frame)
{
return 0;
}
struct value *address,
memtag_type tag_type);
-extern CORE_ADDR generic_skip_trampoline_code (frame_info_ptr frame,
+extern CORE_ADDR generic_skip_trampoline_code (const frame_info_ptr &frame,
CORE_ADDR pc);
extern CORE_ADDR generic_skip_solib_resolver (struct gdbarch *gdbarch,
CORE_ADDR pc);
extern int default_code_of_frame_writable (struct gdbarch *gdbarch,
- frame_info_ptr frame);
+ const frame_info_ptr &frame);
/* By default, registers are not convertible. */
extern int generic_convert_register_p (struct gdbarch *gdbarch, int regnum,
struct type *type);
/* Default implementation of gdbarch get_pc_address_flags method. */
-extern std::string default_get_pc_address_flags (frame_info_ptr frame,
+extern std::string default_get_pc_address_flags (const frame_info_ptr &frame,
CORE_ADDR pc);
/* Default implementation of gdbarch read_core_file_mappings method. */
/* Default implementation of gdbarch default_get_return_buf_addr method. */
extern CORE_ADDR default_get_return_buf_addr (struct type *val_typegdbarch,
- frame_info_ptr cur_frame);
+ const frame_info_ptr &cur_frame);
/* Default implementation of gdbarch default_dwarf2_omit_typedef_p method. */
extern bool default_dwarf2_omit_typedef_p (struct type *target_type,
static void
arm_fbsd_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
};
static void
-arm_linux_sigtramp_cache (frame_info_ptr this_frame,
+arm_linux_sigtramp_cache (const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func, int regs_offset)
{
/* See arm-linux.h for stack layout details. */
static void
arm_linux_sigreturn_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
static void
arm_linux_rt_sigreturn_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
static void
arm_linux_restart_syscall_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
will return to ARM or Thumb code. Return 0 if it is not a
rt_sigreturn/sigreturn syscall. */
static int
-arm_linux_sigreturn_return_addr (frame_info_ptr frame,
+arm_linux_sigreturn_return_addr (const frame_info_ptr &frame,
unsigned long svc_number,
CORE_ADDR *pc, int *is_thumb)
{
/* Implement the skip_trampoline_code gdbarch method. */
static CORE_ADDR
-arm_linux_skip_trampoline_code (frame_info_ptr frame, CORE_ADDR pc)
+arm_linux_skip_trampoline_code (const frame_info_ptr &frame, CORE_ADDR pc)
{
CORE_ADDR target_pc = arm_skip_stub (frame, pc);
static void
armobsd_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *cache,
CORE_ADDR func)
{
/* Similar to the previous function, but extracts GDBARCH from FRAME. */
static void
-arm_cache_init (struct arm_prologue_cache *cache, frame_info_ptr frame)
+arm_cache_init (struct arm_prologue_cache *cache, const frame_info_ptr &frame)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
arm_gdbarch_tdep *tdep = gdbarch_tdep<arm_gdbarch_tdep> (gdbarch);
frame. */
int
-arm_frame_is_thumb (frame_info_ptr frame)
+arm_frame_is_thumb (const frame_info_ptr &frame)
{
/* Check the architecture of FRAME. */
struct gdbarch *gdbarch = get_frame_arch (frame);
}
static void
-arm_scan_prologue (frame_info_ptr this_frame,
+arm_scan_prologue (const frame_info_ptr &this_frame,
struct arm_prologue_cache *cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
static struct arm_prologue_cache *
-arm_make_prologue_cache (frame_info_ptr this_frame)
+arm_make_prologue_cache (const frame_info_ptr &this_frame)
{
int reg;
struct arm_prologue_cache *cache;
/* Implementation of the stop_reason hook for arm_prologue frames. */
static enum unwind_stop_reason
-arm_prologue_unwind_stop_reason (frame_info_ptr this_frame,
+arm_prologue_unwind_stop_reason (const frame_info_ptr &this_frame,
void **this_cache)
{
struct arm_prologue_cache *cache;
and the caller's SP when we were called. */
static void
-arm_prologue_this_id (frame_info_ptr this_frame,
+arm_prologue_this_id (const frame_info_ptr &this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-arm_prologue_prev_register (frame_info_ptr this_frame,
+arm_prologue_prev_register (const frame_info_ptr &this_frame,
void **this_cache,
int prev_regnum)
{
for the ARM Architecture" document. */
static struct arm_prologue_cache *
-arm_exidx_fill_cache (frame_info_ptr this_frame, gdb_byte *entry)
+arm_exidx_fill_cache (const frame_info_ptr &this_frame, gdb_byte *entry)
{
CORE_ADDR vsp = 0;
int vsp_valid = 0;
static int
arm_exidx_unwind_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
};
static struct arm_prologue_cache *
-arm_make_epilogue_frame_cache (frame_info_ptr this_frame)
+arm_make_epilogue_frame_cache (const frame_info_ptr &this_frame)
{
struct arm_prologue_cache *cache;
int reg;
'struct frame_uwnind' for epilogue unwinder. */
static void
-arm_epilogue_frame_this_id (frame_info_ptr this_frame,
+arm_epilogue_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache,
struct frame_id *this_id)
{
'struct frame_uwnind' for epilogue unwinder. */
static struct value *
-arm_epilogue_frame_prev_register (frame_info_ptr this_frame,
+arm_epilogue_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
if (*this_cache == NULL)
static int
arm_epilogue_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
if (frame_relative_level (this_frame) == 0)
The trampoline 'bx r2' doesn't belong to main. */
static CORE_ADDR
-arm_skip_bx_reg (frame_info_ptr frame, CORE_ADDR pc)
+arm_skip_bx_reg (const frame_info_ptr &frame, CORE_ADDR pc)
{
/* The heuristics of recognizing such trampoline is that FRAME is
executing in Thumb mode and the instruction on PC is 'bx Rm'. */
}
static struct arm_prologue_cache *
-arm_make_stub_cache (frame_info_ptr this_frame)
+arm_make_stub_cache (const frame_info_ptr &this_frame)
{
struct arm_prologue_cache *cache;
/* Our frame ID for a stub frame is the current SP and LR. */
static void
-arm_stub_this_id (frame_info_ptr this_frame,
+arm_stub_this_id (const frame_info_ptr &this_frame,
void **this_cache,
struct frame_id *this_id)
{
static int
arm_stub_unwind_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
CORE_ADDR addr_in_block;
returned. */
static struct arm_prologue_cache *
-arm_m_exception_cache (frame_info_ptr this_frame)
+arm_m_exception_cache (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
arm_gdbarch_tdep *tdep = gdbarch_tdep<arm_gdbarch_tdep> (gdbarch);
/* Implementation of the stop_reason hook for arm_m_exception frames. */
static enum unwind_stop_reason
-arm_m_exception_frame_unwind_stop_reason (frame_info_ptr this_frame,
+arm_m_exception_frame_unwind_stop_reason (const frame_info_ptr &this_frame,
void **this_cache)
{
struct arm_prologue_cache *cache;
'struct frame_uwnind'. */
static void
-arm_m_exception_this_id (frame_info_ptr this_frame,
+arm_m_exception_this_id (const frame_info_ptr &this_frame,
void **this_cache,
struct frame_id *this_id)
{
'struct frame_uwnind'. */
static struct value *
-arm_m_exception_prev_register (frame_info_ptr this_frame,
+arm_m_exception_prev_register (const frame_info_ptr &this_frame,
void **this_cache,
int prev_regnum)
{
static int
arm_m_exception_unwind_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
};
static CORE_ADDR
-arm_normal_frame_base (frame_info_ptr this_frame, void **this_cache)
+arm_normal_frame_base (const frame_info_ptr &this_frame, void **this_cache)
{
struct arm_prologue_cache *cache;
};
static struct value *
-arm_dwarf2_prev_register (frame_info_ptr this_frame, void **this_cache,
+arm_dwarf2_prev_register (const frame_info_ptr &this_frame, void **this_cache,
int regnum)
{
struct gdbarch * gdbarch = get_frame_arch (this_frame);
(if present) or emulator. */
static void
arm_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
- frame_info_ptr frame, const char *args)
+ const frame_info_ptr &frame, const char *args)
{
unsigned long status = get_frame_register_unsigned (frame, ARM_FPS_REGNUM);
int type;
static void
arm_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
struct dwarf2_frame_state_reg *reg,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
arm_gdbarch_tdep *tdep = gdbarch_tdep<arm_gdbarch_tdep> (gdbarch);
static int
-arm_get_longjmp_target (frame_info_ptr frame, CORE_ADDR *pc)
+arm_get_longjmp_target (const frame_info_ptr &frame, CORE_ADDR *pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
arm_gdbarch_tdep *tdep = gdbarch_tdep<arm_gdbarch_tdep> (gdbarch);
return the target PC. Otherwise return 0. */
CORE_ADDR
-arm_skip_stub (frame_info_ptr frame, CORE_ADDR pc)
+arm_skip_stub (const frame_info_ptr &frame, CORE_ADDR pc)
{
const char *name;
int namelen;
register, in [0, 15]. */
static value *
-arm_neon_quad_read_value (gdbarch *gdbarch, frame_info_ptr next_frame,
+arm_neon_quad_read_value (gdbarch *gdbarch, const frame_info_ptr &next_frame,
int pseudo_reg_num, int quad_reg_index)
{
std::string raw_reg_name = string_printf ("d%d", quad_reg_index << 1);
/* Read the contents of the MVE pseudo register REGNUM and return it as a
value. */
static value *
-arm_mve_pseudo_read_value (gdbarch *gdbarch, frame_info_ptr next_frame,
+arm_mve_pseudo_read_value (gdbarch *gdbarch, const frame_info_ptr &next_frame,
int pseudo_reg_num)
{
arm_gdbarch_tdep *tdep = gdbarch_tdep<arm_gdbarch_tdep> (gdbarch);
}
static value *
-arm_pseudo_read_value (gdbarch *gdbarch, frame_info_ptr next_frame,
+arm_pseudo_read_value (gdbarch *gdbarch, const frame_info_ptr &next_frame,
const int pseudo_reg_num)
{
arm_gdbarch_tdep *tdep = gdbarch_tdep<arm_gdbarch_tdep> (gdbarch);
}
static void
-arm_neon_quad_write (gdbarch *gdbarch, frame_info_ptr next_frame,
+arm_neon_quad_write (gdbarch *gdbarch, const frame_info_ptr &next_frame,
int quad_reg_index, gdb::array_view<const gdb_byte> buf)
{
std::string raw_reg_name = string_printf ("d%d", quad_reg_index << 1);
/* Store the contents of BUF to the MVE pseudo register REGNUM. */
static void
-arm_mve_pseudo_write (gdbarch *gdbarch, frame_info_ptr next_frame,
+arm_mve_pseudo_write (gdbarch *gdbarch, const frame_info_ptr &next_frame,
int pseudo_reg_num, gdb::array_view<const gdb_byte> buf)
{
arm_gdbarch_tdep *tdep = gdbarch_tdep<arm_gdbarch_tdep> (gdbarch);
}
static void
-arm_pseudo_write (gdbarch *gdbarch, frame_info_ptr next_frame,
+arm_pseudo_write (gdbarch *gdbarch, const frame_info_ptr &next_frame,
const int pseudo_reg_num,
gdb::array_view<const gdb_byte> buf)
{
}
static struct value *
-value_of_arm_user_reg (frame_info_ptr frame, const void *baton)
+value_of_arm_user_reg (const frame_info_ptr &frame, const void *baton)
{
const int *reg_p = (const int *) baton;
return value_of_register (*reg_p, get_next_frame_sentinel_okay (frame));
/* Implement the code_of_frame_writable gdbarch method. */
static int
-arm_code_of_frame_writable (struct gdbarch *gdbarch, frame_info_ptr frame)
+arm_code_of_frame_writable (struct gdbarch *gdbarch, const frame_info_ptr &frame)
{
arm_gdbarch_tdep *tdep = gdbarch_tdep<arm_gdbarch_tdep> (gdbarch);
/* Implement the "get_pc_address_flags" gdbarch method. */
static std::string
-arm_get_pc_address_flags (frame_info_ptr frame, CORE_ADDR pc)
+arm_get_pc_address_flags (const frame_info_ptr &frame, CORE_ADDR pc)
{
if (get_frame_pc_masked (frame))
return "PAC";
arm_displaced_step_copy_insn_closure *dsc, int regno,
ULONGEST val, enum pc_write_style write_pc);
-CORE_ADDR arm_skip_stub (frame_info_ptr, CORE_ADDR);
+CORE_ADDR arm_skip_stub (const frame_info_ptr &, CORE_ADDR);
ULONGEST arm_get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr,
int len,
std::vector<CORE_ADDR> arm_software_single_step (struct regcache *);
int arm_is_thumb (struct regcache *regcache);
-int arm_frame_is_thumb (frame_info_ptr frame);
+int arm_frame_is_thumb (const frame_info_ptr &frame);
extern void arm_displaced_step_fixup (struct gdbarch *,
displaced_step_copy_insn_closure *,
#define ARM_WINCE_JB_PC 10
static CORE_ADDR
-arm_pe_skip_trampoline_code (frame_info_ptr frame, CORE_ADDR pc)
+arm_pe_skip_trampoline_code (const frame_info_ptr &frame, CORE_ADDR pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
for it IS the sp for the next frame. */
static struct avr_unwind_cache *
-avr_frame_unwind_cache (frame_info_ptr this_frame,
+avr_frame_unwind_cache (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
CORE_ADDR start_pc, current_pc;
}
static CORE_ADDR
-avr_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
+avr_unwind_pc (struct gdbarch *gdbarch, const frame_info_ptr &next_frame)
{
ULONGEST pc;
}
static CORE_ADDR
-avr_unwind_sp (struct gdbarch *gdbarch, frame_info_ptr next_frame)
+avr_unwind_sp (struct gdbarch *gdbarch, const frame_info_ptr &next_frame)
{
ULONGEST sp;
frame. This will be used to create a new GDB frame struct. */
static void
-avr_frame_this_id (frame_info_ptr this_frame,
+avr_frame_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
}
static struct value *
-avr_frame_prev_register (frame_info_ptr this_frame,
+avr_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
struct avr_unwind_cache *info
};
static CORE_ADDR
-avr_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+avr_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct avr_unwind_cache *info
= avr_frame_unwind_cache (this_frame, this_cache);
save_dummy_frame_tos(), and the PC match the dummy frame's breakpoint. */
static struct frame_id
-avr_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
+avr_dummy_id (struct gdbarch *gdbarch, const frame_info_ptr &this_frame)
{
ULONGEST base;
static void
bfin_linux_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
}
static struct bfin_frame_cache *
-bfin_frame_cache (frame_info_ptr this_frame, void **this_cache)
+bfin_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct bfin_frame_cache *cache;
int i;
}
static void
-bfin_frame_this_id (frame_info_ptr this_frame,
+bfin_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-bfin_frame_prev_register (frame_info_ptr this_frame,
+bfin_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache,
int regnum)
{
}
static CORE_ADDR
-bfin_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+bfin_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct bfin_frame_cache *cache = bfin_frame_cache (this_frame, this_cache);
}
static CORE_ADDR
-bfin_frame_local_address (frame_info_ptr this_frame, void **this_cache)
+bfin_frame_local_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct bfin_frame_cache *cache = bfin_frame_cache (this_frame, this_cache);
}
static CORE_ADDR
-bfin_frame_args_address (frame_info_ptr this_frame, void **this_cache)
+bfin_frame_args_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct bfin_frame_cache *cache = bfin_frame_cache (this_frame, this_cache);
slot instruction. */
const struct block *
-get_frame_block (frame_info_ptr frame, CORE_ADDR *addr_in_block)
+get_frame_block (const frame_info_ptr &frame, CORE_ADDR *addr_in_block)
{
CORE_ADDR pc;
const struct block *bl;
/* Return the symbol for the function executing in frame FRAME. */
struct symbol *
-get_frame_function (frame_info_ptr frame)
+get_frame_function (const frame_info_ptr &frame)
{
const struct block *bl = get_frame_block (frame, 0);
/* Given THIS_FRAME, return its ID. */
static void
-bpf_frame_this_id (frame_info_ptr this_frame,
+bpf_frame_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
/* Return the reason why we can't unwind past THIS_FRAME. */
static enum unwind_stop_reason
-bpf_frame_unwind_stop_reason (frame_info_ptr this_frame,
+bpf_frame_unwind_stop_reason (const frame_info_ptr &this_frame,
void **this_cache)
{
return UNWIND_OUTERMOST;
/* Ask THIS_FRAME to unwind its register. */
static struct value *
-bpf_frame_prev_register (frame_info_ptr this_frame,
+bpf_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
return frame_unwind_got_register (this_frame, regnum, regnum);
/* Assuming THIS_FRAME is a dummy frame, return its frame ID. */
static struct frame_id
-bpf_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
+bpf_dummy_id (struct gdbarch *gdbarch, const frame_info_ptr &this_frame)
{
CORE_ADDR sp = get_frame_register_unsigned (this_frame,
gdbarch_sp_regnum (gdbarch));
}
CORE_ADDR
-cplus_skip_trampoline (frame_info_ptr frame,
+cplus_skip_trampoline (const frame_info_ptr &frame,
CORE_ADDR stop_pc)
{
if (current_cp_abi.skip_trampoline == NULL)
address of the routine we are thunking to and continue to there
instead. */
-CORE_ADDR cplus_skip_trampoline (frame_info_ptr frame,
+CORE_ADDR cplus_skip_trampoline (const frame_info_ptr &frame,
CORE_ADDR stop_pc);
/* Return a struct that provides pass-by-reference information
struct type *(*get_typeid_type) (struct gdbarch *gdbarch);
struct type *(*get_type_from_type_info) (struct value *value);
std::string (*get_typename_from_type_info) (struct value *value);
- CORE_ADDR (*skip_trampoline) (frame_info_ptr, CORE_ADDR);
+ CORE_ADDR (*skip_trampoline) (const frame_info_ptr &, CORE_ADDR);
struct language_pass_by_ref_info (*pass_by_reference) (struct type *type);
};
the routine. Otherwise, return 0. */
static CORE_ADDR
-cris_sigtramp_start (frame_info_ptr this_frame)
+cris_sigtramp_start (const frame_info_ptr &this_frame)
{
CORE_ADDR pc = get_frame_pc (this_frame);
gdb_byte buf[SIGTRAMP_LEN];
the routine. Otherwise, return 0. */
static CORE_ADDR
-cris_rt_sigtramp_start (frame_info_ptr this_frame)
+cris_rt_sigtramp_start (const frame_info_ptr &this_frame)
{
CORE_ADDR pc = get_frame_pc (this_frame);
gdb_byte buf[SIGTRAMP_LEN];
return the address of the associated sigcontext structure. */
static CORE_ADDR
-cris_sigcontext_addr (frame_info_ptr this_frame)
+cris_sigcontext_addr (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
};
static struct cris_unwind_cache *
-cris_sigtramp_frame_unwind_cache (frame_info_ptr this_frame,
+cris_sigtramp_frame_unwind_cache (const frame_info_ptr &this_frame,
void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
static void
-cris_sigtramp_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+cris_sigtramp_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct cris_unwind_cache *cache =
/* Forward declaration. */
-static struct value *cris_frame_prev_register (frame_info_ptr this_frame,
+static struct value *cris_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum);
static struct value *
-cris_sigtramp_frame_prev_register (frame_info_ptr this_frame,
+cris_sigtramp_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
/* Make sure we've initialized the cache. */
static int
cris_sigtramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
if (cris_sigtramp_start (this_frame)
static int
crisv32_single_step_through_delay (struct gdbarch *gdbarch,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
cris_gdbarch_tdep *tdep = gdbarch_tdep<cris_gdbarch_tdep> (gdbarch);
ULONGEST erp;
struct cmd_list_element *c);
static CORE_ADDR cris_scan_prologue (CORE_ADDR pc,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct cris_unwind_cache *info);
static CORE_ADDR crisv32_scan_prologue (CORE_ADDR pc,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct cris_unwind_cache *info);
/* When arguments must be pushed onto the stack, they go on in reverse
for it IS the sp for the next frame. */
static struct cris_unwind_cache *
-cris_frame_unwind_cache (frame_info_ptr this_frame,
+cris_frame_unwind_cache (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
frame. This will be used to create a new GDB frame struct. */
static void
-cris_frame_this_id (frame_info_ptr this_frame,
+cris_frame_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
}
static struct value *
-cris_frame_prev_register (frame_info_ptr this_frame,
+cris_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
struct cris_unwind_cache *info
};
static CORE_ADDR
-cris_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+cris_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct cris_unwind_cache *info
= cris_frame_unwind_cache (this_frame, this_cache);
determine that it is a prologue (1). */
static CORE_ADDR
-cris_scan_prologue (CORE_ADDR pc, frame_info_ptr this_frame,
+cris_scan_prologue (CORE_ADDR pc, const frame_info_ptr &this_frame,
struct cris_unwind_cache *info)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
static CORE_ADDR
-crisv32_scan_prologue (CORE_ADDR pc, frame_info_ptr this_frame,
+crisv32_scan_prologue (CORE_ADDR pc, const frame_info_ptr &this_frame,
struct cris_unwind_cache *info)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
static void
cris_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
struct dwarf2_frame_state_reg *reg,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
/* The return address column. */
if (regnum == gdbarch_pc_regnum (gdbarch))
static void
csky_linux_rt_sigreturn_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
static void
csky_linux_rt_sigreturn_init_pt_regs (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
CORE_ADDR start_pc,
CORE_ADDR limit_pc,
CORE_ADDR end_pc,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct csky_unwind_cache *this_cache,
lr_type_t lr_type)
{
/* Heuristic unwinder. */
static struct csky_unwind_cache *
-csky_frame_unwind_cache (frame_info_ptr this_frame)
+csky_frame_unwind_cache (const frame_info_ptr &this_frame)
{
CORE_ADDR prologue_start, prologue_end, func_end, prev_pc, block_addr;
struct csky_unwind_cache *cache;
/* Implement the this_id function for the normal unwinder. */
static void
-csky_frame_this_id (frame_info_ptr this_frame,
+csky_frame_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache, struct frame_id *this_id)
{
struct csky_unwind_cache *cache;
/* Implement the prev_register function for the normal unwinder. */
static struct value *
-csky_frame_prev_register (frame_info_ptr this_frame,
+csky_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
struct csky_unwind_cache *cache;
};
static CORE_ADDR
-csky_check_long_branch (frame_info_ptr frame, CORE_ADDR pc)
+csky_check_long_branch (const frame_info_ptr &frame, CORE_ADDR pc)
{
gdb_byte buf[8];
struct gdbarch *gdbarch = get_frame_arch (frame);
static int
csky_stub_unwind_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
CORE_ADDR addr_in_block, pc;
}
static struct csky_unwind_cache *
-csky_make_stub_cache (frame_info_ptr this_frame)
+csky_make_stub_cache (const frame_info_ptr &this_frame)
{
struct csky_unwind_cache *cache;
}
static void
-csky_stub_this_id (frame_info_ptr this_frame,
+csky_stub_this_id (const frame_info_ptr &this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-csky_stub_prev_register (frame_info_ptr this_frame,
+csky_stub_prev_register (const frame_info_ptr &this_frame,
void **this_cache,
int prev_regnum)
{
for the normal unwinder. */
static CORE_ADDR
-csky_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+csky_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct csky_unwind_cache *cache;
static void
csky_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
struct dwarf2_frame_state_reg *reg,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
if (regnum == gdbarch_pc_regnum (gdbarch))
reg->how = DWARF2_FRAME_REG_RA;
/* See probe.h. */
struct value *evaluate_argument (unsigned n,
- frame_info_ptr frame) override;
+ const frame_info_ptr &frame) override;
/* See probe.h. */
void compile_to_ax (struct agent_expr *aexpr,
struct value *
dtrace_probe::evaluate_argument (unsigned n,
- frame_info_ptr frame)
+ const frame_info_ptr &frame)
{
struct gdbarch *gdbarch = this->get_gdbarch ();
struct dtrace_probe_arg *arg;
static int
dummy_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
/* When unwinding a normal frame, the stack structure is determined
register value is taken from the local copy of the register buffer. */
static struct value *
-dummy_frame_prev_register (frame_info_ptr this_frame,
+dummy_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache,
int regnum)
{
dummy cache is located and saved in THIS_PROLOGUE_CACHE. */
static void
-dummy_frame_this_id (frame_info_ptr this_frame,
+dummy_frame_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
/* See dummy-frame.h. */
struct frame_id
-default_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
+default_dummy_id (struct gdbarch *gdbarch, const frame_info_ptr &this_frame)
{
CORE_ADDR sp, pc;
for THIS_FRAME assuming that the frame is a dummy frame. */
extern struct frame_id default_dummy_id (struct gdbarch *gdbarch,
- frame_info_ptr this_frame);
+ const frame_info_ptr &this_frame);
#endif /* !defined (DUMMY_FRAME_H) */
/* Implement the read_variable method from symbol_computed_ops. */
static struct value *
-ada_imported_read_variable (struct symbol *symbol, frame_info_ptr frame)
+ada_imported_read_variable (struct symbol *symbol, const frame_info_ptr &frame)
{
const char *name = get_imported_name (symbol);
bound_minimal_symbol minsym = lookup_minimal_symbol_linkage (name, false);
void iterate_over_addresses (struct gdbarch *call_site_gdbarch,
const struct call_site *call_site,
- frame_info_ptr caller_frame,
+ const frame_info_ptr &caller_frame,
iterate_ftype callback) const;
private:
throw NO_ENTRY_VALUE_ERROR. */
void iterate_over_addresses (struct gdbarch *call_site_gdbarch,
- frame_info_ptr caller_frame,
+ const frame_info_ptr &caller_frame,
call_site_target::iterate_ftype callback)
const
{
/* Ensure that a FRAME is defined, throw an exception otherwise. */
static void
-ensure_have_frame (frame_info_ptr frame, const char *op_name)
+ensure_have_frame (const frame_info_ptr &frame, const char *op_name)
{
if (frame == nullptr)
throw_error (GENERIC_ERROR,
/* See expr.h. */
CORE_ADDR
-read_addr_from_reg (frame_info_ptr frame, int reg)
+read_addr_from_reg (const frame_info_ptr &frame, int reg)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
int regnum = dwarf_reg_to_regnum_or_error (gdbarch, reg);
allocate_piece_closure (dwarf2_per_cu_data *per_cu,
dwarf2_per_objfile *per_objfile,
std::vector<dwarf_expr_piece> &&pieces,
- frame_info_ptr frame)
+ const frame_info_ptr &frame)
{
piece_closure *c = new piece_closure;
value *
dwarf_expr_context::evaluate (const gdb_byte *addr, size_t len, bool as_lval,
- dwarf2_per_cu_data *per_cu, frame_info_ptr frame,
+ dwarf2_per_cu_data *per_cu, const frame_info_ptr &frame,
const struct property_addr_info *addr_info,
struct type *type, struct type *subobj_type,
LONGEST subobj_offset)
The ADDR_INFO property can be specified to override the range of
memory addresses with the passed in buffer. */
value *evaluate (const gdb_byte *addr, size_t len, bool as_lval,
- dwarf2_per_cu_data *per_cu, frame_info_ptr frame,
+ dwarf2_per_cu_data *per_cu, const frame_info_ptr &frame,
const struct property_addr_info *addr_info = nullptr,
struct type *type = nullptr,
struct type *subobj_type = nullptr,
/* Return the value of register number REG (a DWARF register number),
read as an address in a given FRAME. */
-CORE_ADDR read_addr_from_reg (frame_info_ptr frame, int reg);
+CORE_ADDR read_addr_from_reg (const frame_info_ptr &frame, int reg);
void dwarf_expr_require_composition (const gdb_byte *, const gdb_byte *,
const char *);
tailcall_cache. */
static struct tailcall_cache *
-cache_new_ref1 (frame_info_ptr next_bottom_frame)
+cache_new_ref1 (const frame_info_ptr &next_bottom_frame)
{
struct tailcall_cache *cache = XCNEW (struct tailcall_cache);
void **slot;
return 0. */
static int
-frame_is_tailcall (frame_info_ptr fi)
+frame_is_tailcall (const frame_info_ptr &fi)
{
return frame_unwinder_is (fi, &dwarf2_tailcall_frame_unwind);
}
call chain. Otherwise return NULL. No new reference is created. */
static struct tailcall_cache *
-cache_find (frame_info_ptr fi)
+cache_find (const frame_info_ptr &initial_fi)
{
struct tailcall_cache *cache;
struct tailcall_cache search;
void **slot;
+ frame_info_ptr fi = initial_fi;
while (frame_is_tailcall (fi))
{
fi = get_next_frame (fi);
If THIS_FRAME is CACHE-> NEXT_BOTTOM_FRAME return -1. */
static int
-existing_next_levels (frame_info_ptr this_frame,
+existing_next_levels (const frame_info_ptr &this_frame,
struct tailcall_cache *cache)
{
int retval = (frame_relative_level (this_frame)
Specific virtual tail call frames are tracked by INLINE_DEPTH. */
static void
-tailcall_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+tailcall_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct tailcall_cache *cache = (struct tailcall_cache *) *this_cache;
CACHE. */
static CORE_ADDR
-pretend_pc (frame_info_ptr this_frame, struct tailcall_cache *cache)
+pretend_pc (const frame_info_ptr &this_frame, struct tailcall_cache *cache)
{
int next_levels = existing_next_levels (this_frame, cache);
struct call_site_chain *chain = cache->chain;
frames unwind the NULL case differently. */
struct value *
-dwarf2_tailcall_prev_register_first (frame_info_ptr this_frame,
+dwarf2_tailcall_prev_register_first (const frame_info_ptr &this_frame,
void **tailcall_cachep, int regnum)
{
struct gdbarch *this_gdbarch = get_frame_arch (this_frame);
dwarf2_tailcall_prev_register_first. */
static struct value *
-tailcall_frame_prev_register (frame_info_ptr this_frame,
+tailcall_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct tailcall_cache *cache = (struct tailcall_cache *) *this_cache;
static int
tailcall_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame, void **this_cache)
+ const frame_info_ptr &this_frame, void **this_cache)
{
frame_info_ptr next_frame;
int next_levels;
address pushed on the stack. */
void
-dwarf2_tailcall_sniffer_first (frame_info_ptr this_frame,
+dwarf2_tailcall_sniffer_first (const frame_info_ptr &this_frame,
void **tailcall_cachep,
const LONGEST *entry_cfa_sp_offsetp)
{
call frames have gdbarch of the bottom (callee) frame. */
static struct gdbarch *
-tailcall_frame_prev_arch (frame_info_ptr this_frame,
+tailcall_frame_prev_arch (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
struct tailcall_cache *cache = (struct tailcall_cache *) *this_prologue_cache;
/* The tail call frame unwinder. */
extern void
- dwarf2_tailcall_sniffer_first (frame_info_ptr this_frame,
+ dwarf2_tailcall_sniffer_first (const frame_info_ptr &this_frame,
void **tailcall_cachep,
const LONGEST *entry_cfa_sp_offsetp);
extern struct value *
- dwarf2_tailcall_prev_register_first (frame_info_ptr this_frame,
+ dwarf2_tailcall_prev_register_first (const frame_info_ptr &this_frame,
void **tailcall_cachep, int regnum);
extern const struct frame_unwind dwarf2_tailcall_frame_unwind;
static CORE_ADDR
execute_stack_op (const gdb_byte *exp, ULONGEST len, int addr_size,
- frame_info_ptr this_frame, CORE_ADDR initial,
+ const frame_info_ptr &this_frame, CORE_ADDR initial,
int initial_in_stack_memory, dwarf2_per_objfile *per_objfile)
{
dwarf_expr_context ctx (per_objfile, addr_size);
static void dwarf2_frame_default_init_reg (struct gdbarch *gdbarch,
int regnum,
struct dwarf2_frame_state_reg *reg,
- frame_info_ptr this_frame);
+ const frame_info_ptr &this_frame);
struct dwarf2_frame_ops
{
/* Pre-initialize the register state REG for register REGNUM. */
void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *,
- frame_info_ptr)
+ const frame_info_ptr &)
= dwarf2_frame_default_init_reg;
/* Check whether the THIS_FRAME is a signal trampoline. */
- int (*signal_frame_p) (struct gdbarch *, frame_info_ptr) = nullptr;
+ int (*signal_frame_p) (struct gdbarch *, const frame_info_ptr &) = nullptr;
/* Convert .eh_frame register number to DWARF register number, or
adjust .debug_frame register number. */
static void
dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
struct dwarf2_frame_state_reg *reg,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
/* If we have a register that acts as a program counter, mark it as
a destination for the return address. If we have a register that
dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
void (*init_reg) (struct gdbarch *, int,
struct dwarf2_frame_state_reg *,
- frame_info_ptr))
+ const frame_info_ptr &))
{
struct dwarf2_frame_ops *ops = get_frame_ops (gdbarch);
static void
dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
struct dwarf2_frame_state_reg *reg,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
struct dwarf2_frame_ops *ops = get_frame_ops (gdbarch);
void
dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
int (*signal_frame_p) (struct gdbarch *,
- frame_info_ptr))
+ const frame_info_ptr &))
{
struct dwarf2_frame_ops *ops = get_frame_ops (gdbarch);
static int
dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
struct dwarf2_frame_ops *ops = get_frame_ops (gdbarch);
};
static struct dwarf2_frame_cache *
-dwarf2_frame_cache (frame_info_ptr this_frame, void **this_cache)
+dwarf2_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
const int num_regs = gdbarch_num_cooked_regs (gdbarch);
}
static enum unwind_stop_reason
-dwarf2_frame_unwind_stop_reason (frame_info_ptr this_frame,
+dwarf2_frame_unwind_stop_reason (const frame_info_ptr &this_frame,
void **this_cache)
{
struct dwarf2_frame_cache *cache
}
static void
-dwarf2_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+dwarf2_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct dwarf2_frame_cache *cache =
}
static struct value *
-dwarf2_frame_prev_register (frame_info_ptr this_frame, void **this_cache,
+dwarf2_frame_prev_register (const frame_info_ptr &this_frame, void **this_cache,
int regnum)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
/* See frame.h. */
void *
-dwarf2_frame_get_fn_data (frame_info_ptr this_frame, void **this_cache,
+dwarf2_frame_get_fn_data (const frame_info_ptr &this_frame, void **this_cache,
fn_prev_register cookie)
{
struct dwarf2_frame_fn_data *fn_data = nullptr;
/* See frame.h. */
void *
-dwarf2_frame_allocate_fn_data (frame_info_ptr this_frame, void **this_cache,
+dwarf2_frame_allocate_fn_data (const frame_info_ptr &this_frame, void **this_cache,
fn_prev_register cookie, unsigned long size)
{
struct dwarf2_frame_fn_data *fn_data = nullptr;
static int
dwarf2_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame, void **this_cache)
+ const frame_info_ptr &this_frame, void **this_cache)
{
if (!dwarf2_frame_unwinders_enabled_p)
return 0;
response to the "info frame" command. */
static CORE_ADDR
-dwarf2_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+dwarf2_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct dwarf2_frame_cache *cache =
dwarf2_frame_cache (this_frame, this_cache);
};
const struct frame_base *
-dwarf2_frame_base_sniffer (frame_info_ptr this_frame)
+dwarf2_frame_base_sniffer (const frame_info_ptr &this_frame)
{
CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
DW_OP_call_frame_cfa. */
CORE_ADDR
-dwarf2_frame_cfa (frame_info_ptr this_frame)
+dwarf2_frame_cfa (const frame_info_ptr &initial_this_frame)
{
+ frame_info_ptr this_frame = initial_this_frame;
+
if (frame_unwinder_is (this_frame, &record_btrace_tailcall_frame_unwind)
|| frame_unwinder_is (this_frame, &record_btrace_frame_unwind))
throw_error (NOT_AVAILABLE_ERROR,
/* Register state. */
-typedef struct value *(*fn_prev_register) (frame_info_ptr this_frame,
+typedef struct value *(*fn_prev_register) (const frame_info_ptr &this_frame,
void **this_cache, int regnum);
struct dwarf2_frame_state_reg
/* Set the architecture-specific register state initialization
function for GDBARCH to INIT_REG. */
-extern void dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
- void (*init_reg) (struct gdbarch *, int,
- struct dwarf2_frame_state_reg *,
- frame_info_ptr));
+extern void dwarf2_frame_set_init_reg (
+ gdbarch *gdbarch, void (*init_reg) (struct gdbarch *, int,
+ dwarf2_frame_state_reg *,
+ const frame_info_ptr &));
/* Set the architecture-specific signal trampoline recognition
function for GDBARCH to SIGNAL_FRAME_P. */
-extern void
- dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
- int (*signal_frame_p) (struct gdbarch *,
- frame_info_ptr));
+extern void dwarf2_frame_set_signal_frame_p
+ (gdbarch *gdbarch, int (*signal_frame_p) (struct gdbarch *,
+ const frame_info_ptr &));
/* Set the architecture-specific adjustment of .eh_frame and .debug_frame
register numbers. */
NULL if it can't be handled by the DWARF CFI frame unwinder. */
extern const struct frame_base *
- dwarf2_frame_base_sniffer (frame_info_ptr this_frame);
+ dwarf2_frame_base_sniffer (const frame_info_ptr &this_frame);
/* Compute the DWARF CFA for a frame. */
-CORE_ADDR dwarf2_frame_cfa (frame_info_ptr this_frame);
+CORE_ADDR dwarf2_frame_cfa (const frame_info_ptr &this_frame);
/* Find the CFA information for PC.
COOKIE is the key for the prev_function implementation.
SIZE is the size of the custom data object to allocate. */
-extern void *dwarf2_frame_allocate_fn_data (frame_info_ptr this_frame,
+extern void *dwarf2_frame_allocate_fn_data (const frame_info_ptr &this_frame,
void **this_cache,
fn_prev_register cookie,
unsigned long size);
THIS_CACHE is the dwarf2 cache object to store the pointer on.
COOKIE is the key for the prev_function implementation. */
-extern void *dwarf2_frame_get_fn_data (frame_info_ptr this_frame,
+extern void *dwarf2_frame_get_fn_data (const frame_info_ptr &this_frame,
void **this_cache,
fn_prev_register cookie);
#include "gdbsupport/byte-vector.h"
static struct value *dwarf2_evaluate_loc_desc_full
- (struct type *type, frame_info_ptr frame, const gdb_byte *data,
+ (struct type *type, const frame_info_ptr &frame, const gdb_byte *data,
size_t size, dwarf2_per_cu_data *per_cu, dwarf2_per_objfile *per_objfile,
struct type *subobj_type, LONGEST subobj_byte_offset, bool as_lval = true);
LOC_BLOCK functions using a DWARF expression as its DW_AT_frame_base. */
static CORE_ADDR
-locexpr_get_frame_base (struct symbol *framefunc, frame_info_ptr frame)
+locexpr_get_frame_base (struct symbol *framefunc, const frame_info_ptr &frame)
{
struct gdbarch *gdbarch;
struct type *type;
LOC_BLOCK functions using a DWARF location list as its DW_AT_frame_base. */
static CORE_ADDR
-loclist_get_frame_base (struct symbol *framefunc, frame_info_ptr frame)
+loclist_get_frame_base (struct symbol *framefunc, const frame_info_ptr &frame)
{
struct gdbarch *gdbarch;
struct type *type;
/* See gdbtypes.h. */
void
-call_site_target::iterate_over_addresses
- (struct gdbarch *call_site_gdbarch,
- const struct call_site *call_site,
- frame_info_ptr caller_frame,
- iterate_ftype callback) const
+call_site_target::iterate_over_addresses (gdbarch *call_site_gdbarch,
+ const call_site *call_site,
+ const frame_info_ptr &caller_frame,
+ iterate_ftype callback) const
{
switch (m_loc_kind)
{
/* See loc.h. */
struct call_site_parameter *
-dwarf_expr_reg_to_entry_parameter (frame_info_ptr frame,
- enum call_site_parameter_kind kind,
- union call_site_parameter_u kind_u,
+dwarf_expr_reg_to_entry_parameter (const frame_info_ptr &initial_frame,
+ call_site_parameter_kind kind,
+ call_site_parameter_u kind_u,
dwarf2_per_cu_data **per_cu_return,
dwarf2_per_objfile **per_objfile_return)
{
/* Initialize it just to avoid a GCC false warning. */
struct call_site_parameter *parameter = NULL;
CORE_ADDR target_addr;
+ frame_info_ptr frame = initial_frame;
while (get_frame_type (frame) == INLINE_FRAME)
{
static struct value *
dwarf_entry_parameter_to_value (struct call_site_parameter *parameter,
CORE_ADDR deref_size, struct type *type,
- frame_info_ptr caller_frame,
+ const frame_info_ptr &caller_frame,
dwarf2_per_cu_data *per_cu,
dwarf2_per_objfile *per_objfile)
{
/* See dwarf2/loc.h. */
struct value *
-value_of_dwarf_reg_entry (struct type *type, frame_info_ptr frame,
+value_of_dwarf_reg_entry (struct type *type, const frame_info_ptr &frame,
enum call_site_parameter_kind kind,
union call_site_parameter_u kind_u)
{
cannot resolve the parameter for any reason. */
static struct value *
-value_of_dwarf_block_entry (struct type *type, frame_info_ptr frame,
+value_of_dwarf_block_entry (struct type *type, const frame_info_ptr &frame,
const gdb_byte *block, size_t block_len)
{
union call_site_parameter_u kind_u;
indirect_synthetic_pointer (sect_offset die, LONGEST byte_offset,
dwarf2_per_cu_data *per_cu,
dwarf2_per_objfile *per_objfile,
- frame_info_ptr frame, struct type *type,
+ const frame_info_ptr &frame, struct type *type,
bool resolve_abstract_p)
{
/* Fetch the location expression of the DIE we're pointing to. */
SUBOBJ_BYTE_OFFSET within the variable of type TYPE. */
static struct value *
-dwarf2_evaluate_loc_desc_full (struct type *type, frame_info_ptr frame,
+dwarf2_evaluate_loc_desc_full (struct type *type, const frame_info_ptr &frame,
const gdb_byte *data, size_t size,
dwarf2_per_cu_data *per_cu,
dwarf2_per_objfile *per_objfile,
passes 0 as the byte_offset. */
struct value *
-dwarf2_evaluate_loc_desc (struct type *type, frame_info_ptr frame,
+dwarf2_evaluate_loc_desc (struct type *type, const frame_info_ptr &frame,
const gdb_byte *data, size_t size,
dwarf2_per_cu_data *per_cu,
dwarf2_per_objfile *per_objfile, bool as_lval)
static int
dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton,
- frame_info_ptr frame,
+ const frame_info_ptr &frame,
const struct property_addr_info *addr_stack,
CORE_ADDR *valp,
gdb::array_view<CORE_ADDR> push_values,
/* See dwarf2/loc.h. */
bool
-dwarf2_evaluate_property (const struct dynamic_prop *prop,
- frame_info_ptr frame,
- const struct property_addr_info *addr_stack,
+dwarf2_evaluate_property (const dynamic_prop *prop,
+ const frame_info_ptr &initial_frame,
+ const property_addr_info *addr_stack,
CORE_ADDR *value,
gdb::array_view<CORE_ADDR> push_values)
{
Without this here this could happen if the code below selects a
frame. */
scoped_restore_current_language save_language;
+ frame_info_ptr frame = initial_frame;
if (frame == NULL && has_stack_frames ())
frame = get_selected_frame (NULL);
/* Return the value of SYMBOL in FRAME using the DWARF-2 expression
evaluator to calculate the location. */
static struct value *
-locexpr_read_variable (struct symbol *symbol, frame_info_ptr frame)
+locexpr_read_variable (struct symbol *symbol, const frame_info_ptr &frame)
{
struct dwarf2_locexpr_baton *dlbaton
= (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol);
will be thrown. */
static struct value *
-locexpr_read_variable_at_entry (struct symbol *symbol, frame_info_ptr frame)
+locexpr_read_variable_at_entry (struct symbol *symbol, const frame_info_ptr &frame)
{
struct dwarf2_locexpr_baton *dlbaton
= (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol);
/* Return the value of SYMBOL in FRAME using the DWARF-2 expression
evaluator to calculate the location. */
static struct value *
-loclist_read_variable (struct symbol *symbol, frame_info_ptr frame)
+loclist_read_variable (struct symbol *symbol, const frame_info_ptr &frame)
{
struct dwarf2_loclist_baton *dlbaton
= (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (symbol);
if it cannot resolve the parameter for any reason. */
static struct value *
-loclist_read_variable_at_entry (struct symbol *symbol, frame_info_ptr frame)
+loclist_read_variable_at_entry (struct symbol *symbol, const frame_info_ptr &frame)
{
struct dwarf2_loclist_baton *dlbaton
= (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (symbol);
Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
otherwise. */
-struct call_site_parameter *dwarf_expr_reg_to_entry_parameter
- (frame_info_ptr frame, enum call_site_parameter_kind kind,
- union call_site_parameter_u kind_u, dwarf2_per_cu_data **per_cu_return,
+call_site_parameter *dwarf_expr_reg_to_entry_parameter
+ (const frame_info_ptr &frame, call_site_parameter_kind kind,
+ call_site_parameter_u kind_u, dwarf2_per_cu_data **per_cu_return,
dwarf2_per_objfile **per_objfile_return);
of FRAME. AS_LVAL defines if the resulting struct value is expected to
be a value or a location description. */
-struct value *dwarf2_evaluate_loc_desc (struct type *type,
- frame_info_ptr frame,
- const gdb_byte *data,
- size_t size,
- dwarf2_per_cu_data *per_cu,
- dwarf2_per_objfile *per_objfile,
- bool as_lval = true);
+value *dwarf2_evaluate_loc_desc (type *type, const frame_info_ptr &frame,
+ const gdb_byte *data, size_t size,
+ dwarf2_per_cu_data *per_cu,
+ dwarf2_per_objfile *per_objfile,
+ bool as_lval = true);
/* A chain of addresses that might be needed to resolve a dynamic
property. */
bottom of the stack. */
bool dwarf2_evaluate_property (const struct dynamic_prop *prop,
- frame_info_ptr frame,
- const struct property_addr_info *addr_stack,
+ const frame_info_ptr &frame,
+ const property_addr_info *addr_stack,
CORE_ADDR *value,
gdb::array_view<CORE_ADDR> push_values = {});
extern struct value *indirect_synthetic_pointer
(sect_offset die, LONGEST byte_offset, dwarf2_per_cu_data *per_cu,
- dwarf2_per_objfile *per_objfile, frame_info_ptr frame,
+ dwarf2_per_objfile *per_objfile, const frame_info_ptr &frame,
struct type *type, bool resolve_abstract_p = false);
/* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
it cannot resolve the parameter for any reason. */
extern struct value *value_of_dwarf_reg_entry (struct type *type,
- struct frame_info_ptr frame,
+ const frame_info_ptr &frame,
enum call_site_parameter_kind kind,
union call_site_parameter_u kind_u);
#endif /* DWARF2LOC_H */
or SCR_BT_COMPLETED on success. */
enum ext_lang_bt_status (*apply_frame_filter)
(const struct extension_language_defn *,
- frame_info_ptr frame, frame_filter_flags flags,
+ const frame_info_ptr &frame, frame_filter_flags flags,
enum ext_lang_frame_args args_type,
struct ui_out *out, int frame_low, int frame_high);
rather than trying filters in other extension languages. */
enum ext_lang_bt_status
-apply_ext_lang_frame_filter (frame_info_ptr frame,
+apply_ext_lang_frame_filter (const frame_info_ptr &frame,
frame_filter_flags flags,
enum ext_lang_frame_args args_type,
struct ui_out *out,
const struct language_defn *language);
extern enum ext_lang_bt_status apply_ext_lang_frame_filter
- (frame_info_ptr frame, frame_filter_flags flags,
+ (const frame_info_ptr &frame, frame_filter_flags flags,
enum ext_lang_frame_args args_type,
struct ui_out *out, int frame_low, int frame_high);
/* See value.h. */
value *
-value_of_register (int regnum, frame_info_ptr next_frame)
+value_of_register (int regnum, const frame_info_ptr &next_frame)
{
gdbarch *gdbarch = frame_unwind_arch (next_frame);
/* See value.h. */
value *
-value_of_register_lazy (frame_info_ptr next_frame, int regnum)
+value_of_register_lazy (const frame_info_ptr &next_frame, int regnum)
{
gdbarch *gdbarch = frame_unwind_arch (next_frame);
static frame_info_ptr
get_hosting_frame (struct symbol *var, const struct block *var_block,
- frame_info_ptr frame)
+ const frame_info_ptr &initial_frame)
{
const struct block *frame_block = NULL;
synthetic symbols. Without block information, we must assume they are
local to FRAME. In this case, there is nothing to do. */
else if (var_block == NULL)
- return frame;
+ return initial_frame;
/* We currently assume that all symbols with a location list need a frame.
This is true in practice because selecting the location description
We want to get <optimized out> instead of <frame required> when evaluating
them so return a frame instead of raising an error. */
else if (var_block->is_global_block () || var_block->is_static_block ())
- return frame;
+ return initial_frame;
/* We have to handle the "my_func::my_local_var" notation. This requires us
to look for upper frames when we find no block for the current frame: here
and below, handle when frame_block == NULL. */
- if (frame != NULL)
- frame_block = get_frame_block (frame, NULL);
+ if (initial_frame != nullptr)
+ frame_block = get_frame_block (initial_frame, NULL);
/* Climb up the call stack until reaching the frame we are looking for. */
+ frame_info_ptr frame = initial_frame;
while (frame != NULL && frame_block != var_block)
{
/* Stacks can be quite deep: give the user a chance to stop this. */
struct value *
language_defn::read_var_value (struct symbol *var,
const struct block *var_block,
- frame_info_ptr frame) const
+ const frame_info_ptr &frame_param) const
{
struct value *v;
struct type *type = var->type ();
CORE_ADDR addr;
enum symbol_needs_kind sym_need;
+ frame_info_ptr frame = frame_param;
/* Call check_typedef on our type to make sure that, if TYPE is
a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
struct value *
read_var_value (struct symbol *var, const struct block *var_block,
- frame_info_ptr frame)
+ const frame_info_ptr &frame)
{
const struct language_defn *lang = language_def (var->language ());
/* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
struct value *
-value_from_register (struct type *type, int regnum, frame_info_ptr frame)
+value_from_register (struct type *type, int regnum, const frame_info_ptr &frame)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
struct type *type1 = check_typedef (type);
Will abort if register value is not available. */
CORE_ADDR
-address_from_register (int regnum, frame_info_ptr frame)
+address_from_register (int regnum, const frame_info_ptr &frame)
{
type *type = builtin_type (get_frame_arch (frame))->builtin_data_ptr;
value_ref_ptr v = release_value (value_from_register (type, regnum, frame));
really need to override this. */
static CORE_ADDR
-default_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+default_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
return get_frame_base (this_frame); /* sigh! */
}
static CORE_ADDR
-default_frame_locals_address (frame_info_ptr this_frame, void **this_cache)
+default_frame_locals_address (const frame_info_ptr &this_frame, void **this_cache)
{
return default_frame_base_address (this_frame, this_cache);
}
static CORE_ADDR
-default_frame_args_address (frame_info_ptr this_frame, void **this_cache)
+default_frame_args_address (const frame_info_ptr &this_frame, void **this_cache)
{
return default_frame_base_address (this_frame, this_cache);
}
}
const struct frame_base *
-frame_base_find_by_frame (frame_info_ptr this_frame)
+frame_base_find_by_frame (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct frame_base_table *table = get_frame_base_table (gdbarch);
/* A generic base address. */
-typedef CORE_ADDR (frame_this_base_ftype) (frame_info_ptr this_frame,
+typedef CORE_ADDR (frame_this_base_ftype) (const frame_info_ptr &this_frame,
void **this_base_cache);
/* The base address of the frame's local variables. */
-typedef CORE_ADDR (frame_this_locals_ftype) (frame_info_ptr this_frame,
+typedef CORE_ADDR (frame_this_locals_ftype) (const frame_info_ptr &this_frame,
void **this_base_cache);
/* The base address of the frame's arguments / parameters. */
-typedef CORE_ADDR (frame_this_args_ftype) (frame_info_ptr this_frame,
+typedef CORE_ADDR (frame_this_args_ftype) (const frame_info_ptr &this_frame,
void **this_base_cache);
struct frame_base
/* Given THIS frame, return the frame base methods for THIS frame,
or NULL if it can't handle THIS frame. */
-typedef const struct frame_base *(frame_base_sniffer_ftype) (frame_info_ptr this_frame);
+typedef const struct frame_base *(frame_base_sniffer_ftype) (const frame_info_ptr &this_frame);
/* Append a frame base sniffer to the list. The sniffers are polled
in the order that they are appended. */
/* Iterate through the list of frame base handlers until one returns
an implementation. */
-extern const struct frame_base *frame_base_find_by_frame (frame_info_ptr this_frame);
+extern const struct frame_base *frame_base_find_by_frame (const frame_info_ptr &this_frame);
#endif
unchanged and returns 0. */
static int
-frame_unwind_try_unwinder (frame_info_ptr this_frame, void **this_cache,
+frame_unwind_try_unwinder (const frame_info_ptr &this_frame, void **this_cache,
const struct frame_unwind *unwinder)
{
int res = 0;
by this function. Possibly initialize THIS_CACHE. */
void
-frame_unwind_find_by_frame (frame_info_ptr this_frame, void **this_cache)
+frame_unwind_find_by_frame (const frame_info_ptr &this_frame, void **this_cache)
{
FRAME_SCOPED_DEBUG_ENTER_EXIT;
frame_debug_printf ("this_frame=%d", frame_relative_level (this_frame));
int
default_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
return 1;
/* The default frame unwinder stop_reason callback. */
enum unwind_stop_reason
-default_frame_unwind_stop_reason (frame_info_ptr this_frame,
+default_frame_unwind_stop_reason (const frame_info_ptr &this_frame,
void **this_cache)
{
struct frame_id this_id = get_frame_id (this_frame);
/* See frame-unwind.h. */
CORE_ADDR
-default_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
+default_unwind_pc (struct gdbarch *gdbarch, const frame_info_ptr &next_frame)
{
int pc_regnum = gdbarch_pc_regnum (gdbarch);
CORE_ADDR pc = frame_unwind_register_unsigned (next_frame, pc_regnum);
/* See frame-unwind.h. */
CORE_ADDR
-default_unwind_sp (struct gdbarch *gdbarch, frame_info_ptr next_frame)
+default_unwind_sp (struct gdbarch *gdbarch, const frame_info_ptr &next_frame)
{
int sp_regnum = gdbarch_sp_regnum (gdbarch);
return frame_unwind_register_unsigned (next_frame, sp_regnum);
/* Return a value which indicates that FRAME did not save REGNUM. */
struct value *
-frame_unwind_got_optimized (frame_info_ptr frame, int regnum)
+frame_unwind_got_optimized (const frame_info_ptr &frame, int regnum)
{
struct gdbarch *gdbarch = frame_unwind_arch (frame);
struct type *type = register_type (gdbarch, regnum);
register NEW_REGNUM. */
struct value *
-frame_unwind_got_register (frame_info_ptr frame,
+frame_unwind_got_register (const frame_info_ptr &frame,
int regnum, int new_regnum)
{
return value_of_register_lazy (get_next_frame_sentinel_okay (frame),
ADDR. */
struct value *
-frame_unwind_got_memory (frame_info_ptr frame, int regnum, CORE_ADDR addr)
+frame_unwind_got_memory (const frame_info_ptr &frame, int regnum, CORE_ADDR addr)
{
struct gdbarch *gdbarch = frame_unwind_arch (frame);
struct value *v = value_at_lazy (register_type (gdbarch, regnum), addr);
REGNUM has a known constant (computed) value of VAL. */
struct value *
-frame_unwind_got_constant (frame_info_ptr frame, int regnum,
+frame_unwind_got_constant (const frame_info_ptr &frame, int regnum,
ULONGEST val)
{
struct gdbarch *gdbarch = frame_unwind_arch (frame);
}
struct value *
-frame_unwind_got_bytes (frame_info_ptr frame, int regnum, const gdb_byte *buf)
+frame_unwind_got_bytes (const frame_info_ptr &frame, int regnum, const gdb_byte *buf)
{
struct gdbarch *gdbarch = frame_unwind_arch (frame);
struct value *reg_val;
CORE_ADDR to a target address if necessary. */
struct value *
-frame_unwind_got_address (frame_info_ptr frame, int regnum,
+frame_unwind_got_address (const frame_info_ptr &frame, int regnum,
CORE_ADDR addr)
{
struct gdbarch *gdbarch = frame_unwind_arch (frame);
to set *THIS_PROLOGUE_CACHE to NULL. */
typedef int (frame_sniffer_ftype) (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache);
-typedef enum unwind_stop_reason (frame_unwind_stop_reason_ftype)
- (frame_info_ptr this_frame, void **this_prologue_cache);
+typedef unwind_stop_reason (frame_unwind_stop_reason_ftype)
+ (const frame_info_ptr &this_frame, void **this_prologue_cache);
/* A default frame sniffer which always accepts the frame. Used by
fallback prologue unwinders. */
int default_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache);
/* A default stop_reason callback which always claims the frame is
unwindable. */
enum unwind_stop_reason
- default_frame_unwind_stop_reason (frame_info_ptr this_frame,
+ default_frame_unwind_stop_reason (const frame_info_ptr &this_frame,
void **this_cache);
/* A default unwind_pc callback that simply unwinds the register identified
by GDBARCH_PC_REGNUM. */
extern CORE_ADDR default_unwind_pc (struct gdbarch *gdbarch,
- frame_info_ptr next_frame);
+ const frame_info_ptr &next_frame);
/* A default unwind_sp callback that simply unwinds the register identified
by GDBARCH_SP_REGNUM. */
extern CORE_ADDR default_unwind_sp (struct gdbarch *gdbarch,
- frame_info_ptr next_frame);
+ const frame_info_ptr &next_frame);
/* Assuming the frame chain: (outer) prev <-> this <-> next (inner);
use THIS frame, and through it the NEXT frame's register unwind
with the other unwind methods. Memory for that cache should be
allocated using FRAME_OBSTACK_ZALLOC(). */
-typedef void (frame_this_id_ftype) (frame_info_ptr this_frame,
+typedef void (frame_this_id_ftype) (const frame_info_ptr &this_frame,
void **this_prologue_cache,
struct frame_id *this_id);
with the other unwind methods. Memory for that cache should be
allocated using FRAME_OBSTACK_ZALLOC(). */
-typedef struct value * (frame_prev_register_ftype)
- (frame_info_ptr this_frame, void **this_prologue_cache,
- int regnum);
+typedef value *(frame_prev_register_ftype) (const frame_info_ptr &this_frame,
+ void **this_prologue_cache,
+ int regnum);
/* Deallocate extra memory associated with the frame cache if any. */
use THIS frame, and implicitly the NEXT frame's register unwind
method, return PREV frame's architecture. */
-typedef struct gdbarch *(frame_prev_arch_ftype) (frame_info_ptr this_frame,
- void **this_prologue_cache);
+typedef gdbarch *(frame_prev_arch_ftype) (const frame_info_ptr &this_frame,
+ void **this_prologue_cache);
struct frame_unwind
{
unwinder implementation. THIS_FRAME->UNWIND must be NULL, it will get set
by this function. Possibly initialize THIS_CACHE. */
-extern void frame_unwind_find_by_frame (frame_info_ptr this_frame,
+extern void frame_unwind_find_by_frame (const frame_info_ptr &this_frame,
void **this_cache);
/* Helper functions for value-based register unwinding. These return
/* Return a value which indicates that FRAME did not save REGNUM. */
-struct value *frame_unwind_got_optimized (frame_info_ptr frame,
- int regnum);
+value *frame_unwind_got_optimized (const frame_info_ptr &frame, int regnum);
/* Return a value which indicates that FRAME copied REGNUM into
register NEW_REGNUM. */
-struct value *frame_unwind_got_register (frame_info_ptr frame, int regnum,
- int new_regnum);
+value *frame_unwind_got_register (const frame_info_ptr &frame, int regnum,
+ int new_regnum);
/* Return a value which indicates that FRAME saved REGNUM in memory at
ADDR. */
-struct value *frame_unwind_got_memory (frame_info_ptr frame, int regnum,
- CORE_ADDR addr);
+value *frame_unwind_got_memory (const frame_info_ptr &frame, int regnum,
+ CORE_ADDR addr);
/* Return a value which indicates that FRAME's saved version of
REGNUM has a known constant (computed) value of VAL. */
-struct value *frame_unwind_got_constant (frame_info_ptr frame, int regnum,
- ULONGEST val);
+value *frame_unwind_got_constant (const frame_info_ptr &frame, int regnum,
+ ULONGEST val);
/* Return a value which indicates that FRAME's saved version of
REGNUM has a known constant (computed) value which is stored
inside BUF. */
-struct value *frame_unwind_got_bytes (frame_info_ptr frame, int regnum,
- const gdb_byte *buf);
+value *frame_unwind_got_bytes (const frame_info_ptr &frame, int regnum,
+ const gdb_byte *buf);
/* Return a value which indicates that FRAME's saved version of REGNUM
has a known constant (computed) value of ADDR. Convert the
CORE_ADDR to a target address if necessary. */
-struct value *frame_unwind_got_address (frame_info_ptr frame, int regnum,
- CORE_ADDR addr);
+value *frame_unwind_got_address (const frame_info_ptr &frame, int regnum,
+ CORE_ADDR addr);
#endif
/* The values behind the global "set backtrace ..." settings. */
set_backtrace_options user_set_backtrace_options;
-static frame_info_ptr get_prev_frame_raw (frame_info_ptr this_frame);
+static frame_info_ptr get_prev_frame_raw (const frame_info_ptr &this_frame);
static const char *frame_stop_reason_symbol_string (enum unwind_stop_reason reason);
static frame_info_ptr create_new_frame (frame_id id);
/* See frame.h. */
void
-set_frame_previous_pc_masked (frame_info_ptr frame)
+set_frame_previous_pc_masked (const frame_info_ptr &frame)
{
frame->prev_pc.masked = true;
}
/* See frame.h. */
bool
-get_frame_pc_masked (frame_info_ptr frame)
+get_frame_pc_masked (const frame_info_ptr &frame)
{
gdb_assert (frame->next != nullptr);
gdb_assert (frame->next->prev_pc.status == CC_VALUE);
Return NULL if FRAME is the start of an artificial-only chain. */
static frame_info_ptr
-skip_artificial_frames (frame_info_ptr frame)
+skip_artificial_frames (const frame_info_ptr &initial_frame)
{
/* Note we use get_prev_frame_always, and not get_prev_frame. The
latter will truncate the frame chain, leading to this function
Note that for record targets we may get a frame chain that consists
of artificial frames only. */
+ frame_info_ptr frame = initial_frame;
while (get_frame_type (frame) == INLINE_FRAME
|| get_frame_type (frame) == TAILCALL_FRAME)
{
}
frame_info_ptr
-skip_unwritable_frames (frame_info_ptr frame)
+skip_unwritable_frames (const frame_info_ptr &initial_frame)
{
+ frame_info_ptr frame = initial_frame;
while (gdbarch_code_of_frame_writable (get_frame_arch (frame), frame) == 0)
{
frame = get_prev_frame (frame);
/* See frame.h. */
frame_info_ptr
-skip_tailcall_frames (frame_info_ptr frame)
+skip_tailcall_frames (const frame_info_ptr &initial_frame)
{
+ frame_info_ptr frame = initial_frame;
while (get_frame_type (frame) == TAILCALL_FRAME)
{
/* Note that for record targets we may get a frame chain that consists of
frame. */
static void
-compute_frame_id (frame_info_ptr fi)
+compute_frame_id (const frame_info_ptr &fi)
{
FRAME_SCOPED_DEBUG_ENTER_EXIT;
frame. */
struct frame_id
-get_frame_id (frame_info_ptr fi)
+get_frame_id (const frame_info_ptr &fi)
{
if (fi == NULL)
return null_frame_id;
}
struct frame_id
-get_stack_frame_id (frame_info_ptr next_frame)
+get_stack_frame_id (const frame_info_ptr &next_frame)
{
return get_frame_id (skip_artificial_frames (next_frame));
}
struct frame_id
-frame_unwind_caller_id (frame_info_ptr next_frame)
+frame_unwind_caller_id (const frame_info_ptr &initial_next_frame)
{
- frame_info_ptr this_frame;
-
/* Use get_prev_frame_always, and not get_prev_frame. The latter
will truncate the frame chain, leading to this function
unintentionally returning a null_frame_id (e.g., when a caller
requests the frame ID of "main()"s caller. */
- next_frame = skip_artificial_frames (next_frame);
+ frame_info_ptr next_frame = skip_artificial_frames (initial_next_frame);
if (next_frame == NULL)
return null_frame_id;
- this_frame = get_prev_frame_always (next_frame);
+ frame_info_ptr this_frame = get_prev_frame_always (next_frame);
if (this_frame)
return get_frame_id (skip_artificial_frames (this_frame));
else
}
static CORE_ADDR
-frame_unwind_pc (frame_info_ptr this_frame)
+frame_unwind_pc (const frame_info_ptr &this_frame)
{
if (this_frame->prev_pc.status == CC_UNKNOWN)
{
}
CORE_ADDR
-frame_unwind_caller_pc (frame_info_ptr this_frame)
+frame_unwind_caller_pc (const frame_info_ptr &initial_this_frame)
{
- this_frame = skip_artificial_frames (this_frame);
+ frame_info_ptr this_frame = skip_artificial_frames (initial_this_frame);
/* We must have a non-artificial frame. The caller is supposed to check
the result of frame_unwind_caller_id (), which returns NULL_FRAME_ID
in this case. */
- gdb_assert (this_frame != NULL);
+ gdb_assert (this_frame != nullptr);
return frame_unwind_pc (this_frame);
}
bool
-get_frame_func_if_available (frame_info_ptr this_frame, CORE_ADDR *pc)
+get_frame_func_if_available (const frame_info_ptr &this_frame, CORE_ADDR *pc)
{
frame_info *next_frame = this_frame->next;
}
CORE_ADDR
-get_frame_func (frame_info_ptr this_frame)
+get_frame_func (const frame_info_ptr &this_frame)
{
CORE_ADDR pc;
}
std::unique_ptr<readonly_detached_regcache>
-frame_save_as_regcache (frame_info_ptr this_frame)
+frame_save_as_regcache (const frame_info_ptr &this_frame)
{
auto cooked_read = [this_frame] (int regnum, gdb::array_view<gdb_byte> buf)
{
}
void
-frame_pop (frame_info_ptr this_frame)
+frame_pop (const frame_info_ptr &this_frame)
{
frame_info_ptr prev_frame;
}
void
-frame_register_unwind (frame_info_ptr next_frame, int regnum,
+frame_register_unwind (const frame_info_ptr &next_frame, int regnum,
int *optimizedp, int *unavailablep,
enum lval_type *lvalp, CORE_ADDR *addrp,
int *realnump, gdb_byte *bufferp)
}
void
-frame_unwind_register (frame_info_ptr next_frame, int regnum, gdb_byte *buf)
+frame_unwind_register (const frame_info_ptr &next_frame, int regnum, gdb_byte *buf)
{
int optimized;
int unavailable;
}
void
-get_frame_register (frame_info_ptr frame,
+get_frame_register (const frame_info_ptr &frame,
int regnum, gdb_byte *buf)
{
frame_unwind_register (frame_info_ptr (frame->next), regnum, buf);
}
struct value *
-frame_unwind_register_value (frame_info_ptr next_frame, int regnum)
+frame_unwind_register_value (const frame_info_ptr &next_frame, int regnum)
{
FRAME_SCOPED_DEBUG_ENTER_EXIT;
}
struct value *
-get_frame_register_value (frame_info_ptr frame, int regnum)
+get_frame_register_value (const frame_info_ptr &frame, int regnum)
{
return frame_unwind_register_value (frame_info_ptr (frame->next), regnum);
}
LONGEST
-frame_unwind_register_signed (frame_info_ptr next_frame, int regnum)
+frame_unwind_register_signed (const frame_info_ptr &next_frame, int regnum)
{
struct gdbarch *gdbarch = frame_unwind_arch (next_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
}
LONGEST
-get_frame_register_signed (frame_info_ptr frame, int regnum)
+get_frame_register_signed (const frame_info_ptr &frame, int regnum)
{
return frame_unwind_register_signed (frame_info_ptr (frame->next), regnum);
}
ULONGEST
-frame_unwind_register_unsigned (frame_info_ptr next_frame, int regnum)
+frame_unwind_register_unsigned (const frame_info_ptr &next_frame, int regnum)
{
struct gdbarch *gdbarch = frame_unwind_arch (next_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
}
ULONGEST
-get_frame_register_unsigned (frame_info_ptr frame, int regnum)
+get_frame_register_unsigned (const frame_info_ptr &frame, int regnum)
{
return frame_unwind_register_unsigned (frame_info_ptr (frame->next), regnum);
}
bool
-read_frame_register_unsigned (frame_info_ptr frame, int regnum,
+read_frame_register_unsigned (const frame_info_ptr &frame, int regnum,
ULONGEST *val)
{
struct value *regval = get_frame_register_value (frame, regnum);
}
void
-put_frame_register (frame_info_ptr next_frame, int regnum,
+put_frame_register (const frame_info_ptr &next_frame, int regnum,
gdb::array_view<const gdb_byte> buf)
{
gdbarch *gdbarch = frame_unwind_arch (next_frame);
Returns 0 if the register value could not be found. */
bool
-deprecated_frame_register_read (frame_info_ptr frame, int regnum,
+deprecated_frame_register_read (const frame_info_ptr &frame, int regnum,
gdb_byte *myaddr)
{
int optimized;
}
bool
-get_frame_register_bytes (frame_info_ptr next_frame, int regnum,
+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)
{
}
void
-put_frame_register_bytes (frame_info_ptr next_frame, int regnum,
+put_frame_register_bytes (const frame_info_ptr &next_frame, int regnum,
CORE_ADDR offset,
gdb::array_view<const gdb_byte> buffer)
{
return data;
}
-static frame_info_ptr get_prev_frame_always_1 (frame_info_ptr this_frame);
+static frame_info_ptr get_prev_frame_always_1 (const frame_info_ptr &this_frame);
frame_info_ptr
get_current_frame (void)
/* See frame.h. */
void
-select_frame (frame_info_ptr fi)
+select_frame (const frame_info_ptr &fi)
{
gdb_assert (fi != nullptr);
frame chain and onto the sentinel frame. */
frame_info_ptr
-get_next_frame (frame_info_ptr this_frame)
+get_next_frame (const frame_info_ptr &this_frame)
{
if (this_frame->level > 0)
return frame_info_ptr (this_frame->next);
unlike get_next_frame(), NULL will never be returned. */
frame_info_ptr
-get_next_frame_sentinel_okay (frame_info_ptr this_frame)
+get_next_frame_sentinel_okay (const frame_info_ptr &this_frame)
{
gdb_assert (this_frame != NULL);
relative to this particular frame. */
static void
-frame_register_unwind_location (frame_info_ptr this_frame, int regnum,
- int *optimizedp, enum lval_type *lvalp,
+frame_register_unwind_location (const frame_info_ptr &initial_this_frame,
+ int regnum, int *optimizedp, lval_type *lvalp,
CORE_ADDR *addrp, int *realnump)
{
- gdb_assert (this_frame == NULL || this_frame->level >= 0);
+ gdb_assert (initial_this_frame == nullptr || initial_this_frame->level >= 0);
+ frame_info_ptr this_frame = initial_this_frame;
while (this_frame != NULL)
{
int unavailable;
of the previous frame, should also be a duplicate. */
static frame_info_ptr
-get_prev_frame_maybe_check_cycle (frame_info_ptr this_frame)
+get_prev_frame_maybe_check_cycle (const frame_info_ptr &this_frame)
{
frame_info_ptr prev_frame = get_prev_frame_raw (this_frame);
there is no such frame. This may throw an exception. */
static frame_info_ptr
-get_prev_frame_always_1 (frame_info_ptr this_frame)
+get_prev_frame_always_1 (const frame_info_ptr &this_frame)
{
FRAME_SCOPED_DEBUG_ENTER_EXIT;
frame. */
frame_info_ptr
-get_prev_frame_always (frame_info_ptr this_frame)
+get_prev_frame_always (const frame_info_ptr &this_frame)
{
frame_info_ptr prev_frame = NULL;
this_frame. */
static frame_info_ptr
-get_prev_frame_raw (frame_info_ptr this_frame)
+get_prev_frame_raw (const frame_info_ptr &this_frame)
{
frame_info *prev_frame;
/* Debug routine to print a NULL frame being returned. */
static void
-frame_debug_got_null_frame (frame_info_ptr this_frame,
+frame_debug_got_null_frame (const frame_info_ptr &this_frame,
const char *reason)
{
if (frame_debug)
/* Is this (non-sentinel) frame in the "main"() function? */
static bool
-inside_main_func (frame_info_ptr this_frame)
+inside_main_func (const frame_info_ptr &this_frame)
{
if (current_program_space->symfile_object_file == nullptr)
return false;
/* Test whether THIS_FRAME is inside the process entry point function. */
static bool
-inside_entry_func (frame_info_ptr this_frame)
+inside_entry_func (const frame_info_ptr &this_frame)
{
CORE_ADDR entry_point;
checking whether the program-counter is zero. */
frame_info_ptr
-get_prev_frame (frame_info_ptr this_frame)
+get_prev_frame (const frame_info_ptr &this_frame)
{
FRAME_SCOPED_DEBUG_ENTER_EXIT;
}
CORE_ADDR
-get_frame_pc (frame_info_ptr frame)
+get_frame_pc (const frame_info_ptr &frame)
{
gdb_assert (frame->next != NULL);
return frame_unwind_pc (frame_info_ptr (frame->next));
}
bool
-get_frame_pc_if_available (frame_info_ptr frame, CORE_ADDR *pc)
+get_frame_pc_if_available (const frame_info_ptr &frame, CORE_ADDR *pc)
{
gdb_assert (frame->next != NULL);
/* Return an address that falls within THIS_FRAME's code block. */
CORE_ADDR
-get_frame_address_in_block (frame_info_ptr this_frame)
+get_frame_address_in_block (const frame_info_ptr &this_frame)
{
/* A draft address. */
CORE_ADDR pc = get_frame_pc (this_frame);
}
bool
-get_frame_address_in_block_if_available (frame_info_ptr this_frame,
+get_frame_address_in_block_if_available (const frame_info_ptr &this_frame,
CORE_ADDR *pc)
{
}
symtab_and_line
-find_frame_sal (frame_info_ptr frame)
+find_frame_sal (const frame_info_ptr &frame)
{
frame_info_ptr next_frame;
int notcurrent;
/* Per "frame.h", return the ``address'' of the frame. Code should
really be using get_frame_id(). */
CORE_ADDR
-get_frame_base (frame_info_ptr fi)
+get_frame_base (const frame_info_ptr &fi)
{
return get_frame_id (fi).stack_addr;
}
/* High-level offsets into the frame. Used by the debug info. */
CORE_ADDR
-get_frame_base_address (frame_info_ptr fi)
+get_frame_base_address (const frame_info_ptr &fi)
{
if (get_frame_type (fi) != NORMAL_FRAME)
return 0;
}
CORE_ADDR
-get_frame_locals_address (frame_info_ptr fi)
+get_frame_locals_address (const frame_info_ptr &fi)
{
if (get_frame_type (fi) != NORMAL_FRAME)
return 0;
}
CORE_ADDR
-get_frame_args_address (frame_info_ptr fi)
+get_frame_args_address (const frame_info_ptr &fi)
{
if (get_frame_type (fi) != NORMAL_FRAME)
return 0;
otherwise. */
bool
-frame_unwinder_is (frame_info_ptr fi, const frame_unwind *unwinder)
+frame_unwinder_is (const frame_info_ptr &fi, const frame_unwind *unwinder)
{
if (fi->unwind == nullptr)
frame_unwind_find_by_frame (fi, &fi->prologue_cache);
or -1 for a NULL frame. */
int
-frame_relative_level (frame_info_ptr fi)
+frame_relative_level (const frame_info_ptr &fi)
{
if (fi == NULL)
return -1;
}
enum frame_type
-get_frame_type (frame_info_ptr frame)
+get_frame_type (const frame_info_ptr &frame)
{
if (frame->unwind == NULL)
/* Initialize the frame's unwinder because that's what
}
struct program_space *
-get_frame_program_space (frame_info_ptr frame)
+get_frame_program_space (const frame_info_ptr &frame)
{
return frame->pspace;
}
struct program_space *
-frame_unwind_program_space (frame_info_ptr this_frame)
+frame_unwind_program_space (const frame_info_ptr &this_frame)
{
gdb_assert (this_frame);
}
const address_space *
-get_frame_address_space (frame_info_ptr frame)
+get_frame_address_space (const frame_info_ptr &frame)
{
return frame->aspace;
}
/* Memory access methods. */
void
-get_frame_memory (frame_info_ptr this_frame, CORE_ADDR addr,
+get_frame_memory (const frame_info_ptr &this_frame, CORE_ADDR addr,
gdb::array_view<gdb_byte> buffer)
{
read_memory (addr, buffer.data (), buffer.size ());
}
LONGEST
-get_frame_memory_signed (frame_info_ptr this_frame, CORE_ADDR addr,
+get_frame_memory_signed (const frame_info_ptr &this_frame, CORE_ADDR addr,
int len)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
ULONGEST
-get_frame_memory_unsigned (frame_info_ptr this_frame, CORE_ADDR addr,
+get_frame_memory_unsigned (const frame_info_ptr &this_frame, CORE_ADDR addr,
int len)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
bool
-safe_frame_unwind_memory (frame_info_ptr this_frame,
+safe_frame_unwind_memory (const frame_info_ptr &this_frame,
CORE_ADDR addr, gdb::array_view<gdb_byte> buffer)
{
/* NOTE: target_read_memory returns zero on success! */
/* Architecture methods. */
struct gdbarch *
-get_frame_arch (frame_info_ptr this_frame)
+get_frame_arch (const frame_info_ptr &this_frame)
{
return frame_unwind_arch (frame_info_ptr (this_frame->next));
}
struct gdbarch *
-frame_unwind_arch (frame_info_ptr next_frame)
+frame_unwind_arch (const frame_info_ptr &next_frame)
{
if (!next_frame->prev_arch.p)
{
}
struct gdbarch *
-frame_unwind_caller_arch (frame_info_ptr next_frame)
+frame_unwind_caller_arch (const frame_info_ptr &initial_next_frame)
{
- next_frame = skip_artificial_frames (next_frame);
+ frame_info_ptr next_frame = skip_artificial_frames (initial_next_frame);
/* We must have a non-artificial frame. The caller is supposed to check
the result of frame_unwind_caller_id (), which returns NULL_FRAME_ID
in this case. */
- gdb_assert (next_frame != NULL);
+ gdb_assert (next_frame != nullptr);
return frame_unwind_arch (next_frame);
}
/* Gets the language of FRAME. */
enum language
-get_frame_language (frame_info_ptr frame)
+get_frame_language (const frame_info_ptr &frame)
{
CORE_ADDR pc = 0;
bool pc_p = false;
/* Stack pointer methods. */
CORE_ADDR
-get_frame_sp (frame_info_ptr this_frame)
+get_frame_sp (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
/* See frame.h. */
frame_info_ptr
-frame_follow_static_link (frame_info_ptr frame)
+frame_follow_static_link (const frame_info_ptr &initial_frame)
{
- const block *frame_block = get_frame_block (frame, nullptr);
+ const block *frame_block = get_frame_block (initial_frame, nullptr);
if (frame_block == nullptr)
return {};
CORE_ADDR upper_frame_base;
- if (!dwarf2_evaluate_property (static_link, frame, NULL, &upper_frame_base))
+ if (!dwarf2_evaluate_property (static_link, initial_frame, NULL, &upper_frame_base))
return {};
/* Now climb up the stack frame until we reach the frame we are interested
in. */
+ frame_info_ptr frame = initial_frame;
for (; frame != nullptr; frame = get_prev_frame (frame))
{
struct symbol *framefunc = get_frame_function (frame);
/* Return the reason why we can't unwind past FRAME. */
enum unwind_stop_reason
-get_frame_unwind_stop_reason (frame_info_ptr frame)
+get_frame_unwind_stop_reason (const frame_info_ptr &frame)
{
/* Fill-in STOP_REASON. */
get_prev_frame_always (frame);
}
const char *
-frame_stop_reason_string (frame_info_ptr fi)
+frame_stop_reason_string (const frame_info_ptr &fi)
{
gdb_assert (fi->prev_p);
gdb_assert (fi->prev == NULL);
FRAME. */
void
-frame_cleanup_after_sniffer (frame_info_ptr frame)
+frame_cleanup_after_sniffer (const frame_info_ptr &frame)
{
/* The sniffer should not allocate a prologue cache if it did not
match this frame. */
frame_cleanup_after_sniffer. */
void
-frame_prepare_for_sniffer (frame_info_ptr frame,
+frame_prepare_for_sniffer (const frame_info_ptr &frame,
const struct frame_unwind *unwind)
{
gdb_assert (frame->unwind == NULL);
extern frame_info_ptr get_selected_frame (const char *message = nullptr);
/* Select a specific frame. */
-extern void select_frame (frame_info_ptr);
+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.
/* 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. */
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 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 (frame_info_ptr frame);
+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 next_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);
/* 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 (frame_info_ptr next_frame, int regnum,
+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 (frame_info_ptr next_frame, int regnum,
- CORE_ADDR offset,
+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 NEXT_FRAME's previous frame, starting at OFFSET. */
-extern void put_frame_register_bytes (frame_info_ptr next_frame, int regnum,
- CORE_ADDR 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);
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. */
};
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) */
} __attribute__((aligned(8))); */
static LONGEST
-frv_linux_sigcontext_reg_addr (frame_info_ptr this_frame, int regno,
+frv_linux_sigcontext_reg_addr (const frame_info_ptr &this_frame, int regno,
CORE_ADDR *sc_addr_cache_ptr)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
/* Signal trampolines. */
static struct trad_frame_cache *
-frv_linux_sigtramp_frame_cache (frame_info_ptr this_frame,
+frv_linux_sigtramp_frame_cache (const frame_info_ptr &this_frame,
void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
static void
-frv_linux_sigtramp_frame_this_id (frame_info_ptr this_frame,
+frv_linux_sigtramp_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-frv_linux_sigtramp_frame_prev_register (frame_info_ptr this_frame,
+frv_linux_sigtramp_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
/* Make sure we've initialized the cache. */
static int
frv_linux_sigtramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
prologue analysis. */
static CORE_ADDR
frv_analyze_prologue (struct gdbarch *gdbarch, CORE_ADDR pc,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct frv_unwind_cache *info)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
static struct frv_unwind_cache *
-frv_frame_unwind_cache (frame_info_ptr this_frame,
+frv_frame_unwind_cache (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
frame. This will be used to create a new GDB frame struct. */
static void
-frv_frame_this_id (frame_info_ptr this_frame,
+frv_frame_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache, struct frame_id *this_id)
{
struct frv_unwind_cache *info
}
static struct value *
-frv_frame_prev_register (frame_info_ptr this_frame,
+frv_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
struct frv_unwind_cache *info
};
static CORE_ADDR
-frv_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+frv_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct frv_unwind_cache *info
= frv_frame_unwind_cache (this_frame, this_cache);
/* Populate a ft32_frame_cache object for this_frame. */
static struct ft32_frame_cache *
-ft32_frame_cache (frame_info_ptr this_frame, void **this_cache)
+ft32_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct ft32_frame_cache *cache;
CORE_ADDR current_pc;
frame. This will be used to create a new GDB frame struct. */
static void
-ft32_frame_this_id (frame_info_ptr this_frame,
+ft32_frame_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache, struct frame_id *this_id)
{
struct ft32_frame_cache *cache = ft32_frame_cache (this_frame,
/* Get the value of register regnum in the previous stack frame. */
static struct value *
-ft32_frame_prev_register (frame_info_ptr this_frame,
+ft32_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
struct ft32_frame_cache *cache = ft32_frame_cache (this_frame,
/* Return the base address of this_frame. */
static CORE_ADDR
-ft32_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+ft32_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct ft32_frame_cache *cache = ft32_frame_cache (this_frame,
this_cache);
extern bool gdbarch_pseudo_register_read_value_p (struct gdbarch *gdbarch);
-typedef struct value * (gdbarch_pseudo_register_read_value_ftype) (struct gdbarch *gdbarch, frame_info_ptr next_frame, int cookednum);
-extern struct value * gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch, frame_info_ptr next_frame, int cookednum);
+typedef struct value * (gdbarch_pseudo_register_read_value_ftype) (struct gdbarch *gdbarch, const frame_info_ptr &next_frame, int cookednum);
+extern struct value * gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch, const frame_info_ptr &next_frame, int cookednum);
extern void set_gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch, gdbarch_pseudo_register_read_value_ftype *pseudo_register_read_value);
/* Write bytes in BUF to pseudo register with number PSEUDO_REG_NUM.
extern bool gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch);
-typedef void (gdbarch_pseudo_register_write_ftype) (struct gdbarch *gdbarch, frame_info_ptr next_frame, int pseudo_reg_num, gdb::array_view<const gdb_byte> buf);
-extern void gdbarch_pseudo_register_write (struct gdbarch *gdbarch, frame_info_ptr next_frame, int pseudo_reg_num, gdb::array_view<const gdb_byte> buf);
+typedef void (gdbarch_pseudo_register_write_ftype) (struct gdbarch *gdbarch, const frame_info_ptr &next_frame, int pseudo_reg_num, gdb::array_view<const gdb_byte> buf);
+extern void gdbarch_pseudo_register_write (struct gdbarch *gdbarch, const frame_info_ptr &next_frame, int pseudo_reg_num, gdb::array_view<const gdb_byte> buf);
extern void set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch, gdbarch_pseudo_register_write_ftype *pseudo_register_write);
/* Write bytes to a pseudo register.
should match the address at which the breakpoint was set in the dummy
frame. */
-typedef struct frame_id (gdbarch_dummy_id_ftype) (struct gdbarch *gdbarch, frame_info_ptr this_frame);
-extern struct frame_id gdbarch_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame);
+typedef struct frame_id (gdbarch_dummy_id_ftype) (struct gdbarch *gdbarch, const frame_info_ptr &this_frame);
+extern struct frame_id gdbarch_dummy_id (struct gdbarch *gdbarch, const frame_info_ptr &this_frame);
extern void set_gdbarch_dummy_id (struct gdbarch *gdbarch, gdbarch_dummy_id_ftype *dummy_id);
/* Implement DUMMY_ID and PUSH_DUMMY_CALL, then delete
/* Return true if the code of FRAME is writable. */
-typedef int (gdbarch_code_of_frame_writable_ftype) (struct gdbarch *gdbarch, frame_info_ptr frame);
-extern int gdbarch_code_of_frame_writable (struct gdbarch *gdbarch, frame_info_ptr frame);
+typedef int (gdbarch_code_of_frame_writable_ftype) (struct gdbarch *gdbarch, const frame_info_ptr &frame);
+extern int gdbarch_code_of_frame_writable (struct gdbarch *gdbarch, const frame_info_ptr &frame);
extern void set_gdbarch_code_of_frame_writable (struct gdbarch *gdbarch, gdbarch_code_of_frame_writable_ftype *code_of_frame_writable);
-typedef void (gdbarch_print_registers_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, frame_info_ptr frame, int regnum, int all);
-extern void gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, frame_info_ptr frame, int regnum, int all);
+typedef void (gdbarch_print_registers_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, const frame_info_ptr &frame, int regnum, int all);
+extern void gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, const frame_info_ptr &frame, int regnum, int all);
extern void set_gdbarch_print_registers_info (struct gdbarch *gdbarch, gdbarch_print_registers_info_ftype *print_registers_info);
-typedef void (gdbarch_print_float_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, frame_info_ptr frame, const char *args);
-extern void gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, frame_info_ptr frame, const char *args);
+typedef void (gdbarch_print_float_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, const frame_info_ptr &frame, const char *args);
+extern void gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, const frame_info_ptr &frame, const char *args);
extern void set_gdbarch_print_float_info (struct gdbarch *gdbarch, gdbarch_print_float_info_ftype *print_float_info);
extern bool gdbarch_print_vector_info_p (struct gdbarch *gdbarch);
-typedef void (gdbarch_print_vector_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, frame_info_ptr frame, const char *args);
-extern void gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, frame_info_ptr frame, const char *args);
+typedef void (gdbarch_print_vector_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, const frame_info_ptr &frame, const char *args);
+extern void gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, const frame_info_ptr &frame, const char *args);
extern void set_gdbarch_print_vector_info (struct gdbarch *gdbarch, gdbarch_print_vector_info_ftype *print_vector_info);
/* MAP a GDB RAW register number onto a simulator register number. See
extern bool gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch);
-typedef int (gdbarch_get_longjmp_target_ftype) (frame_info_ptr frame, CORE_ADDR *pc);
-extern int gdbarch_get_longjmp_target (struct gdbarch *gdbarch, frame_info_ptr frame, CORE_ADDR *pc);
+typedef int (gdbarch_get_longjmp_target_ftype) (const frame_info_ptr &frame, CORE_ADDR *pc);
+extern int gdbarch_get_longjmp_target (struct gdbarch *gdbarch, const frame_info_ptr &frame, CORE_ADDR *pc);
extern void set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch, gdbarch_get_longjmp_target_ftype *get_longjmp_target);
extern int gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch);
extern int gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type);
extern void set_gdbarch_convert_register_p (struct gdbarch *gdbarch, gdbarch_convert_register_p_ftype *convert_register_p);
-typedef int (gdbarch_register_to_value_ftype) (frame_info_ptr frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep);
-extern int gdbarch_register_to_value (struct gdbarch *gdbarch, frame_info_ptr frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep);
+typedef int (gdbarch_register_to_value_ftype) (const frame_info_ptr &frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep);
+extern int gdbarch_register_to_value (struct gdbarch *gdbarch, const frame_info_ptr &frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep);
extern void set_gdbarch_register_to_value (struct gdbarch *gdbarch, gdbarch_register_to_value_ftype *register_to_value);
-typedef void (gdbarch_value_to_register_ftype) (frame_info_ptr frame, int regnum, struct type *type, const gdb_byte *buf);
-extern void gdbarch_value_to_register (struct gdbarch *gdbarch, frame_info_ptr frame, int regnum, struct type *type, const gdb_byte *buf);
+typedef void (gdbarch_value_to_register_ftype) (const frame_info_ptr &frame, int regnum, struct type *type, const gdb_byte *buf);
+extern void gdbarch_value_to_register (struct gdbarch *gdbarch, const frame_info_ptr &frame, int regnum, struct type *type, const gdb_byte *buf);
extern void set_gdbarch_value_to_register (struct gdbarch *gdbarch, gdbarch_value_to_register_ftype *value_to_register);
/* Construct a value representing the contents of register REGNUM in
May return 0 when unable to determine that address. */
-typedef CORE_ADDR (gdbarch_get_return_buf_addr_ftype) (struct type *val_type, frame_info_ptr cur_frame);
-extern CORE_ADDR gdbarch_get_return_buf_addr (struct gdbarch *gdbarch, struct type *val_type, frame_info_ptr cur_frame);
+typedef CORE_ADDR (gdbarch_get_return_buf_addr_ftype) (struct type *val_type, const frame_info_ptr &cur_frame);
+extern CORE_ADDR gdbarch_get_return_buf_addr (struct gdbarch *gdbarch, struct type *val_type, const frame_info_ptr &cur_frame);
extern void set_gdbarch_get_return_buf_addr (struct gdbarch *gdbarch, gdbarch_get_return_buf_addr_ftype *get_return_buf_addr);
/* Return true if the typedef record needs to be replaced.".
extern CORE_ADDR gdbarch_frame_args_skip (struct gdbarch *gdbarch);
extern void set_gdbarch_frame_args_skip (struct gdbarch *gdbarch, CORE_ADDR frame_args_skip);
-typedef CORE_ADDR (gdbarch_unwind_pc_ftype) (struct gdbarch *gdbarch, frame_info_ptr next_frame);
-extern CORE_ADDR gdbarch_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame);
+typedef CORE_ADDR (gdbarch_unwind_pc_ftype) (struct gdbarch *gdbarch, const frame_info_ptr &next_frame);
+extern CORE_ADDR gdbarch_unwind_pc (struct gdbarch *gdbarch, const frame_info_ptr &next_frame);
extern void set_gdbarch_unwind_pc (struct gdbarch *gdbarch, gdbarch_unwind_pc_ftype *unwind_pc);
-typedef CORE_ADDR (gdbarch_unwind_sp_ftype) (struct gdbarch *gdbarch, frame_info_ptr next_frame);
-extern CORE_ADDR gdbarch_unwind_sp (struct gdbarch *gdbarch, frame_info_ptr next_frame);
+typedef CORE_ADDR (gdbarch_unwind_sp_ftype) (struct gdbarch *gdbarch, const frame_info_ptr &next_frame);
+extern CORE_ADDR gdbarch_unwind_sp (struct gdbarch *gdbarch, const frame_info_ptr &next_frame);
extern void set_gdbarch_unwind_sp (struct gdbarch *gdbarch, gdbarch_unwind_sp_ftype *unwind_sp);
/* DEPRECATED_FRAME_LOCALS_ADDRESS as been replaced by the per-frame
extern bool gdbarch_frame_num_args_p (struct gdbarch *gdbarch);
-typedef int (gdbarch_frame_num_args_ftype) (frame_info_ptr frame);
-extern int gdbarch_frame_num_args (struct gdbarch *gdbarch, frame_info_ptr frame);
+typedef int (gdbarch_frame_num_args_ftype) (const frame_info_ptr &frame);
+extern int gdbarch_frame_num_args (struct gdbarch *gdbarch, const frame_info_ptr &frame);
extern void set_gdbarch_frame_num_args (struct gdbarch *gdbarch, gdbarch_frame_num_args_ftype *frame_num_args);
extern bool gdbarch_frame_align_p (struct gdbarch *gdbarch);
extern bool gdbarch_single_step_through_delay_p (struct gdbarch *gdbarch);
-typedef int (gdbarch_single_step_through_delay_ftype) (struct gdbarch *gdbarch, frame_info_ptr frame);
-extern int gdbarch_single_step_through_delay (struct gdbarch *gdbarch, frame_info_ptr frame);
+typedef int (gdbarch_single_step_through_delay_ftype) (struct gdbarch *gdbarch, const frame_info_ptr &frame);
+extern int gdbarch_single_step_through_delay (struct gdbarch *gdbarch, const frame_info_ptr &frame);
extern void set_gdbarch_single_step_through_delay (struct gdbarch *gdbarch, gdbarch_single_step_through_delay_ftype *single_step_through_delay);
/* FIXME: cagney/2003-08-28: Need to find a better way of selecting the
extern int gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info);
extern void set_gdbarch_print_insn (struct gdbarch *gdbarch, gdbarch_print_insn_ftype *print_insn);
-typedef CORE_ADDR (gdbarch_skip_trampoline_code_ftype) (frame_info_ptr frame, CORE_ADDR pc);
-extern CORE_ADDR gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, frame_info_ptr frame, CORE_ADDR pc);
+typedef CORE_ADDR (gdbarch_skip_trampoline_code_ftype) (const frame_info_ptr &frame, CORE_ADDR pc);
+extern CORE_ADDR gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, const frame_info_ptr &frame, CORE_ADDR pc);
extern void set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype *skip_trampoline_code);
/* Vtable of solib operations functions. */
extern bool gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch);
-typedef CORE_ADDR (gdbarch_fetch_pointer_argument_ftype) (frame_info_ptr frame, int argi, struct type *type);
-extern CORE_ADDR gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, frame_info_ptr frame, int argi, struct type *type);
+typedef CORE_ADDR (gdbarch_fetch_pointer_argument_ftype) (const frame_info_ptr &frame, int argi, struct type *type);
+extern CORE_ADDR gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, const frame_info_ptr &frame, int argi, struct type *type);
extern void set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument);
/* Iterate over all supported register notes in a core file. For each
/* Return a string containing any flags for the given PC in the given FRAME. */
-typedef std::string (gdbarch_get_pc_address_flags_ftype) (frame_info_ptr frame, CORE_ADDR pc);
-extern std::string gdbarch_get_pc_address_flags (struct gdbarch *gdbarch, frame_info_ptr frame, CORE_ADDR pc);
+typedef std::string (gdbarch_get_pc_address_flags_ftype) (const frame_info_ptr &frame, CORE_ADDR pc);
+extern std::string gdbarch_get_pc_address_flags (struct gdbarch *gdbarch, const frame_info_ptr &frame, CORE_ADDR pc);
extern void set_gdbarch_get_pc_address_flags (struct gdbarch *gdbarch, gdbarch_get_pc_address_flags_ftype *get_pc_address_flags);
/* Read core file mappings */
}
struct value *
-gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch, frame_info_ptr next_frame, int cookednum)
+gdbarch_pseudo_register_read_value (struct gdbarch *gdbarch, const frame_info_ptr &next_frame, int cookednum)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->pseudo_register_read_value != NULL);
}
void
-gdbarch_pseudo_register_write (struct gdbarch *gdbarch, frame_info_ptr next_frame, int pseudo_reg_num, gdb::array_view<const gdb_byte> buf)
+gdbarch_pseudo_register_write (struct gdbarch *gdbarch, const frame_info_ptr &next_frame, int pseudo_reg_num, gdb::array_view<const gdb_byte> buf)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->pseudo_register_write != NULL);
}
struct frame_id
-gdbarch_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
+gdbarch_dummy_id (struct gdbarch *gdbarch, const frame_info_ptr &this_frame)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->dummy_id != NULL);
}
int
-gdbarch_code_of_frame_writable (struct gdbarch *gdbarch, frame_info_ptr frame)
+gdbarch_code_of_frame_writable (struct gdbarch *gdbarch, const frame_info_ptr &frame)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->code_of_frame_writable != NULL);
}
void
-gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, frame_info_ptr frame, int regnum, int all)
+gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, const frame_info_ptr &frame, int regnum, int all)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->print_registers_info != NULL);
}
void
-gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, frame_info_ptr frame, const char *args)
+gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, const frame_info_ptr &frame, const char *args)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->print_float_info != NULL);
}
void
-gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, frame_info_ptr frame, const char *args)
+gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, const frame_info_ptr &frame, const char *args)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->print_vector_info != NULL);
}
int
-gdbarch_get_longjmp_target (struct gdbarch *gdbarch, frame_info_ptr frame, CORE_ADDR *pc)
+gdbarch_get_longjmp_target (struct gdbarch *gdbarch, const frame_info_ptr &frame, CORE_ADDR *pc)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->get_longjmp_target != NULL);
}
int
-gdbarch_register_to_value (struct gdbarch *gdbarch, frame_info_ptr frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep)
+gdbarch_register_to_value (struct gdbarch *gdbarch, const frame_info_ptr &frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->register_to_value != NULL);
}
void
-gdbarch_value_to_register (struct gdbarch *gdbarch, frame_info_ptr frame, int regnum, struct type *type, const gdb_byte *buf)
+gdbarch_value_to_register (struct gdbarch *gdbarch, const frame_info_ptr &frame, int regnum, struct type *type, const gdb_byte *buf)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->value_to_register != NULL);
}
CORE_ADDR
-gdbarch_get_return_buf_addr (struct gdbarch *gdbarch, struct type *val_type, frame_info_ptr cur_frame)
+gdbarch_get_return_buf_addr (struct gdbarch *gdbarch, struct type *val_type, const frame_info_ptr &cur_frame)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->get_return_buf_addr != NULL);
}
CORE_ADDR
-gdbarch_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
+gdbarch_unwind_pc (struct gdbarch *gdbarch, const frame_info_ptr &next_frame)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->unwind_pc != NULL);
}
CORE_ADDR
-gdbarch_unwind_sp (struct gdbarch *gdbarch, frame_info_ptr next_frame)
+gdbarch_unwind_sp (struct gdbarch *gdbarch, const frame_info_ptr &next_frame)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->unwind_sp != NULL);
}
int
-gdbarch_frame_num_args (struct gdbarch *gdbarch, frame_info_ptr frame)
+gdbarch_frame_num_args (struct gdbarch *gdbarch, const frame_info_ptr &frame)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->frame_num_args != NULL);
}
int
-gdbarch_single_step_through_delay (struct gdbarch *gdbarch, frame_info_ptr frame)
+gdbarch_single_step_through_delay (struct gdbarch *gdbarch, const frame_info_ptr &frame)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->single_step_through_delay != NULL);
}
CORE_ADDR
-gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, frame_info_ptr frame, CORE_ADDR pc)
+gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, const frame_info_ptr &frame, CORE_ADDR pc)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->skip_trampoline_code != NULL);
}
CORE_ADDR
-gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, frame_info_ptr frame, int argi, struct type *type)
+gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, const frame_info_ptr &frame, int argi, struct type *type)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->fetch_pointer_argument != NULL);
}
std::string
-gdbarch_get_pc_address_flags (struct gdbarch *gdbarch, frame_info_ptr frame, CORE_ADDR pc)
+gdbarch_get_pc_address_flags (struct gdbarch *gdbarch, const frame_info_ptr &frame, CORE_ADDR pc)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->get_pc_address_flags != NULL);
""",
type="struct value *",
name="pseudo_register_read_value",
- params=[("frame_info_ptr", "next_frame"), ("int", "cookednum")],
+ params=[("const frame_info_ptr &", "next_frame"), ("int", "cookednum")],
predicate=True,
)
type="void",
name="pseudo_register_write",
params=[
- ("frame_info_ptr", "next_frame"),
+ ("const frame_info_ptr &", "next_frame"),
("int", "pseudo_reg_num"),
("gdb::array_view<const gdb_byte>", "buf"),
],
""",
type="struct frame_id",
name="dummy_id",
- params=[("frame_info_ptr", "this_frame")],
+ params=[("const frame_info_ptr &", "this_frame")],
predefault="default_dummy_id",
invalid=False,
)
""",
type="int",
name="code_of_frame_writable",
- params=[("frame_info_ptr", "frame")],
+ params=[("const frame_info_ptr &", "frame")],
predefault="default_code_of_frame_writable",
invalid=False,
)
name="print_registers_info",
params=[
("struct ui_file *", "file"),
- ("frame_info_ptr", "frame"),
+ ("const frame_info_ptr &", "frame"),
("int", "regnum"),
("int", "all"),
],
name="print_float_info",
params=[
("struct ui_file *", "file"),
- ("frame_info_ptr", "frame"),
+ ("const frame_info_ptr &", "frame"),
("const char *", "args"),
],
predefault="default_print_float_info",
name="print_vector_info",
params=[
("struct ui_file *", "file"),
- ("frame_info_ptr", "frame"),
+ ("const frame_info_ptr &", "frame"),
("const char *", "args"),
],
predicate=True,
""",
type="int",
name="get_longjmp_target",
- params=[("frame_info_ptr", "frame"), ("CORE_ADDR *", "pc")],
+ params=[("const frame_info_ptr &", "frame"), ("CORE_ADDR *", "pc")],
predicate=True,
)
type="int",
name="register_to_value",
params=[
- ("frame_info_ptr", "frame"),
+ ("const frame_info_ptr &", "frame"),
("int", "regnum"),
("struct type *", "type"),
("gdb_byte *", "buf"),
type="void",
name="value_to_register",
params=[
- ("frame_info_ptr", "frame"),
+ ("const frame_info_ptr &", "frame"),
("int", "regnum"),
("struct type *", "type"),
("const gdb_byte *", "buf"),
May return 0 when unable to determine that address.""",
type="CORE_ADDR",
name="get_return_buf_addr",
- params=[("struct type *", "val_type"), ("frame_info_ptr", "cur_frame")],
+ params=[("struct type *", "val_type"), ("const frame_info_ptr &", "cur_frame")],
predefault="default_get_return_buf_addr",
invalid=False,
)
Method(
type="CORE_ADDR",
name="unwind_pc",
- params=[("frame_info_ptr", "next_frame")],
+ params=[("const frame_info_ptr &", "next_frame")],
predefault="default_unwind_pc",
invalid=False,
)
Method(
type="CORE_ADDR",
name="unwind_sp",
- params=[("frame_info_ptr", "next_frame")],
+ params=[("const frame_info_ptr &", "next_frame")],
predefault="default_unwind_sp",
invalid=False,
)
""",
type="int",
name="frame_num_args",
- params=[("frame_info_ptr", "frame")],
+ params=[("const frame_info_ptr &", "frame")],
predicate=True,
)
""",
type="int",
name="single_step_through_delay",
- params=[("frame_info_ptr", "frame")],
+ params=[("const frame_info_ptr &", "frame")],
predicate=True,
)
Function(
type="CORE_ADDR",
name="skip_trampoline_code",
- params=[("frame_info_ptr", "frame"), ("CORE_ADDR", "pc")],
+ params=[("const frame_info_ptr &", "frame"), ("CORE_ADDR", "pc")],
predefault="generic_skip_trampoline_code",
invalid=False,
)
type="CORE_ADDR",
name="fetch_pointer_argument",
params=[
- ("frame_info_ptr", "frame"),
+ ("const frame_info_ptr &", "frame"),
("int", "argi"),
("struct type *", "type"),
],
""",
type="std::string",
name="get_pc_address_flags",
- params=[("frame_info_ptr", "frame"), ("CORE_ADDR", "pc")],
+ params=[("const frame_info_ptr &", "frame"), ("CORE_ADDR", "pc")],
predefault="default_get_pc_address_flags",
invalid=False,
)
of the routine we are thunking to and continue to there instead. */
static CORE_ADDR
-gnuv3_skip_trampoline (frame_info_ptr frame, CORE_ADDR stop_pc)
+gnuv3_skip_trampoline (const frame_info_ptr &frame, CORE_ADDR stop_pc)
{
CORE_ADDR real_stop_pc, method_stop_pc, func_addr;
struct gdbarch *gdbarch = get_frame_arch (frame);
}
static struct h8300_frame_cache *
-h8300_frame_cache (frame_info_ptr this_frame, void **this_cache)
+h8300_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct h8300_frame_cache *cache;
}
static void
-h8300_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+h8300_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct h8300_frame_cache *cache =
}
static struct value *
-h8300_frame_prev_register (frame_info_ptr this_frame, void **this_cache,
+h8300_frame_prev_register (const frame_info_ptr &this_frame, void **this_cache,
int regnum)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
};
static CORE_ADDR
-h8300_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+h8300_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct h8300_frame_cache *cache = h8300_frame_cache (this_frame, this_cache);
return cache->base;
static void
h8300_print_register (struct gdbarch *gdbarch, struct ui_file *file,
- frame_info_ptr frame, int regno)
+ const frame_info_ptr &frame, int regno)
{
LONGEST rval;
const char *name = gdbarch_register_name (gdbarch, regno);
static void
h8300_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
- frame_info_ptr frame, int regno, int cpregs)
+ const frame_info_ptr &frame, int regno, int cpregs)
{
if (regno < 0)
{
static void
hppabsd_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
struct dwarf2_frame_state_reg *reg,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
if (regnum == HPPA_PCOQ_HEAD_REGNUM)
reg->how = DWARF2_FRAME_REG_RA;
};
static struct hppa_linux_sigtramp_unwind_cache *
-hppa_linux_sigtramp_frame_unwind_cache (frame_info_ptr this_frame,
+hppa_linux_sigtramp_frame_unwind_cache (const frame_info_ptr &this_frame,
void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
static void
-hppa_linux_sigtramp_frame_this_id (frame_info_ptr this_frame,
+hppa_linux_sigtramp_frame_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
}
static struct value *
-hppa_linux_sigtramp_frame_prev_register (frame_info_ptr this_frame,
+hppa_linux_sigtramp_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache,
int regnum)
{
we can find the beginning of the struct rt_sigframe. */
static int
hppa_linux_sigtramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
};
static void hppanbsd_sigtramp_cache_init (const struct tramp_frame *,
- frame_info_ptr,
+ const frame_info_ptr &,
struct trad_frame_cache *,
CORE_ADDR);
static void
hppanbsd_sigtramp_cache_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
/* Return an unwind entry that falls within the frame's code block. */
static struct unwind_table_entry *
-hppa_find_unwind_entry_in_block (frame_info_ptr this_frame)
+hppa_find_unwind_entry_in_block (const frame_info_ptr &this_frame)
{
CORE_ADDR pc = get_frame_address_in_block (this_frame);
};
static struct hppa_frame_cache *
-hppa_frame_cache (frame_info_ptr this_frame, void **this_cache)
+hppa_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
}
static void
-hppa_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+hppa_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct hppa_frame_cache *info;
}
static struct value *
-hppa_frame_prev_register (frame_info_ptr this_frame,
+hppa_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct hppa_frame_cache *info = hppa_frame_cache (this_frame, this_cache);
static int
hppa_frame_unwind_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame, void **this_cache)
+ const frame_info_ptr &this_frame, void **this_cache)
{
if (hppa_find_unwind_entry_in_block (this_frame))
return 1;
identify the stack and pc for the frame. */
static struct hppa_frame_cache *
-hppa_fallback_frame_cache (frame_info_ptr this_frame, void **this_cache)
+hppa_fallback_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
}
static void
-hppa_fallback_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+hppa_fallback_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct hppa_frame_cache *info =
}
static struct value *
-hppa_fallback_frame_prev_register (frame_info_ptr this_frame,
+hppa_fallback_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct hppa_frame_cache *info
};
static struct hppa_stub_unwind_cache *
-hppa_stub_frame_unwind_cache (frame_info_ptr this_frame,
+hppa_stub_frame_unwind_cache (const frame_info_ptr &this_frame,
void **this_cache)
{
struct hppa_stub_unwind_cache *info;
}
static void
-hppa_stub_frame_this_id (frame_info_ptr this_frame,
+hppa_stub_frame_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
}
static struct value *
-hppa_stub_frame_prev_register (frame_info_ptr this_frame,
+hppa_stub_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
struct hppa_stub_unwind_cache *info
static int
hppa_stub_unwind_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
CORE_ADDR pc = get_frame_address_in_block (this_frame);
};
CORE_ADDR
-hppa_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
+hppa_unwind_pc (struct gdbarch *gdbarch, const frame_info_ptr &next_frame)
{
ULONGEST ipsw;
CORE_ADDR pc;
/* Get the ARGIth function argument for the current function. */
static CORE_ADDR
-hppa_fetch_pointer_argument (frame_info_ptr frame, int argi,
+hppa_fetch_pointer_argument (const frame_info_ptr &frame, int argi,
struct type *type)
{
return get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 26 - argi);
}
struct value *
-hppa_frame_prev_register_helper (frame_info_ptr this_frame,
+hppa_frame_prev_register_helper (const frame_info_ptr &this_frame,
trad_frame_saved_reg saved_regs[],
int regnum)
{
systems: $$dyncall, import stubs and PLT stubs. */
CORE_ADDR
-hppa_skip_trampoline_code (frame_info_ptr frame, CORE_ADDR pc)
+hppa_skip_trampoline_code (const frame_info_ptr &frame, CORE_ADDR pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
struct type *func_ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
not interested in them. If we detect that we are returning to a stub,
adjust the pc to the real caller. This improves the behavior of commands
that traverse frames such as "up" and "finish". */
- void (*unwind_adjust_stub) (frame_info_ptr this_frame, CORE_ADDR base,
+ void (*unwind_adjust_stub) (const frame_info_ptr &this_frame, CORE_ADDR base,
trad_frame_saved_reg *saved_regs) = nullptr;
/* These are solib-dependent methods. They are really HPUX only, but
CORE_ADDR hppa_symbol_address(const char *sym);
extern struct value *
- hppa_frame_prev_register_helper (frame_info_ptr this_frame,
+ hppa_frame_prev_register_helper (const frame_info_ptr &this_frame,
trad_frame_saved_reg *saved_regs,
int regnum);
extern CORE_ADDR hppa_read_pc (struct regcache *regcache);
extern void hppa_write_pc (struct regcache *regcache, CORE_ADDR pc);
extern CORE_ADDR hppa_unwind_pc (struct gdbarch *gdbarch,
- frame_info_ptr next_frame);
+ const frame_info_ptr &next_frame);
extern int hppa_in_solib_call_trampoline (struct gdbarch *gdbarch,
CORE_ADDR pc);
-extern CORE_ADDR hppa_skip_trampoline_code (frame_info_ptr, CORE_ADDR pc);
+extern CORE_ADDR hppa_skip_trampoline_code (const frame_info_ptr &, CORE_ADDR pc);
#endif /* hppa-tdep.h */
address of the associated sigcontext structure. */
static CORE_ADDR
-i386bsd_sigcontext_addr (frame_info_ptr this_frame)
+i386bsd_sigcontext_addr (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
address of the associated sigcontext structure. */
static CORE_ADDR
-i386_darwin_sigcontext_addr (frame_info_ptr this_frame)
+i386_darwin_sigcontext_addr (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int
darwin_dwarf_signal_frame_p (struct gdbarch *gdbarch,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
return i386_sigtramp_p (this_frame);
}
extern int i386_darwin_thread_state_reg_offset[];
extern const int i386_darwin_thread_state_num_regs;
-int darwin_dwarf_signal_frame_p (struct gdbarch *, frame_info_ptr);
+int darwin_dwarf_signal_frame_p (struct gdbarch *, const frame_info_ptr &);
#endif /* I386_DARWIN_TDEP_H */
static void
i386_fbsd_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
start of the routine. Otherwise, return 0. */
static CORE_ADDR
-i386_gnu_sigtramp_start (frame_info_ptr this_frame)
+i386_gnu_sigtramp_start (const frame_info_ptr &this_frame)
{
CORE_ADDR pc = get_frame_pc (this_frame);
gdb_byte buf[GNU_SIGTRAMP_LEN];
routine. */
static int
-i386_gnu_sigtramp_p (frame_info_ptr this_frame)
+i386_gnu_sigtramp_p (const frame_info_ptr &this_frame)
{
CORE_ADDR pc = get_frame_pc (this_frame);
const char *name;
address of the associated sigcontext structure. */
static CORE_ADDR
-i386_gnu_sigcontext_addr (frame_info_ptr this_frame)
+i386_gnu_sigcontext_addr (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
start of the routine. Otherwise, return 0. */
static CORE_ADDR
-i386_linux_sigtramp_start (frame_info_ptr this_frame)
+i386_linux_sigtramp_start (const frame_info_ptr &this_frame)
{
CORE_ADDR pc = get_frame_pc (this_frame);
gdb_byte buf[LINUX_SIGTRAMP_LEN];
start of the routine. Otherwise, return 0. */
static CORE_ADDR
-i386_linux_rt_sigtramp_start (frame_info_ptr this_frame)
+i386_linux_rt_sigtramp_start (const frame_info_ptr &this_frame)
{
CORE_ADDR pc = get_frame_pc (this_frame);
gdb_byte buf[LINUX_RT_SIGTRAMP_LEN];
routine. */
static int
-i386_linux_sigtramp_p (frame_info_ptr this_frame)
+i386_linux_sigtramp_p (const frame_info_ptr &this_frame)
{
CORE_ADDR pc = get_frame_pc (this_frame);
const char *name;
static int
i386_linux_dwarf_signal_frame_p (struct gdbarch *gdbarch,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
CORE_ADDR pc = get_frame_pc (this_frame);
const char *name;
address of the associated sigcontext structure. */
static CORE_ADDR
-i386_linux_sigcontext_addr (frame_info_ptr this_frame)
+i386_linux_sigcontext_addr (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
};
static void i386nbsd_sigtramp_cache_init (const struct tramp_frame *,
- frame_info_ptr,
+ const frame_info_ptr &,
struct trad_frame_cache *,
CORE_ADDR);
static void
i386nbsd_sigtramp_cache_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
routine. */
static int
-i386nto_sigtramp_p (frame_info_ptr this_frame)
+i386nto_sigtramp_p (const frame_info_ptr &this_frame)
{
CORE_ADDR pc = get_frame_pc (this_frame);
const char *name;
address of the associated sigcontext structure. */
static CORE_ADDR
-i386nto_sigcontext_addr (frame_info_ptr this_frame)
+i386nto_sigcontext_addr (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
routine. */
static int
-i386obsd_sigtramp_p (frame_info_ptr this_frame)
+i386obsd_sigtramp_p (const frame_info_ptr &this_frame)
{
CORE_ADDR pc = get_frame_pc (this_frame);
CORE_ADDR start_pc = (pc & ~(i386obsd_page_size - 1));
};
static struct trad_frame_cache *
-i386obsd_trapframe_cache (frame_info_ptr this_frame, void **this_cache)
+i386obsd_trapframe_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
}
static void
-i386obsd_trapframe_this_id (frame_info_ptr this_frame,
+i386obsd_trapframe_this_id (const frame_info_ptr &this_frame,
void **this_cache, struct frame_id *this_id)
{
struct trad_frame_cache *cache =
}
static struct value *
-i386obsd_trapframe_prev_register (frame_info_ptr this_frame,
+i386obsd_trapframe_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct trad_frame_cache *cache =
static int
i386obsd_trapframe_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
ULONGEST cs;
`mcontext_t' that contains the saved set of machine registers. */
static CORE_ADDR
-i386_sol2_mcontext_addr (frame_info_ptr this_frame)
+i386_sol2_mcontext_addr (const frame_info_ptr &this_frame)
{
CORE_ADDR sp, ucontext_addr;
/* This function is 64-bit safe. */
static CORE_ADDR
-i386_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
+i386_unwind_pc (struct gdbarch *gdbarch, const frame_info_ptr &next_frame)
{
gdb_byte buf[8];
/* Normal frames. */
static void
-i386_frame_cache_1 (frame_info_ptr this_frame,
+i386_frame_cache_1 (const frame_info_ptr &this_frame,
struct i386_frame_cache *cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
static struct i386_frame_cache *
-i386_frame_cache (frame_info_ptr this_frame, void **this_cache)
+i386_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct i386_frame_cache *cache;
}
static void
-i386_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+i386_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct i386_frame_cache *cache = i386_frame_cache (this_frame, this_cache);
}
static enum unwind_stop_reason
-i386_frame_unwind_stop_reason (frame_info_ptr this_frame,
+i386_frame_unwind_stop_reason (const frame_info_ptr &this_frame,
void **this_cache)
{
struct i386_frame_cache *cache = i386_frame_cache (this_frame, this_cache);
}
static struct value *
-i386_frame_prev_register (frame_info_ptr this_frame, void **this_cache,
+i386_frame_prev_register (const frame_info_ptr &this_frame, void **this_cache,
int regnum)
{
struct i386_frame_cache *cache = i386_frame_cache (this_frame, this_cache);
static int
i386_epilogue_frame_sniffer_1 (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache, bool override_p)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
static int
i386_epilogue_override_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
return i386_epilogue_frame_sniffer_1 (self, this_frame, this_prologue_cache,
static int
i386_epilogue_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
return i386_epilogue_frame_sniffer_1 (self, this_frame, this_prologue_cache,
}
static struct i386_frame_cache *
-i386_epilogue_frame_cache (frame_info_ptr this_frame, void **this_cache)
+i386_epilogue_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct i386_frame_cache *cache;
CORE_ADDR sp;
}
static enum unwind_stop_reason
-i386_epilogue_frame_unwind_stop_reason (frame_info_ptr this_frame,
+i386_epilogue_frame_unwind_stop_reason (const frame_info_ptr &this_frame,
void **this_cache)
{
struct i386_frame_cache *cache =
}
static void
-i386_epilogue_frame_this_id (frame_info_ptr this_frame,
+i386_epilogue_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-i386_epilogue_frame_prev_register (frame_info_ptr this_frame,
+i386_epilogue_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
/* Make sure we've initialized the cache. */
static int
i386_stack_tramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
if (frame_relative_level (this_frame) == 0)
/* Signal trampolines. */
static struct i386_frame_cache *
-i386_sigtramp_frame_cache (frame_info_ptr this_frame, void **this_cache)
+i386_sigtramp_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
i386_gdbarch_tdep *tdep = gdbarch_tdep<i386_gdbarch_tdep> (gdbarch);
}
static enum unwind_stop_reason
-i386_sigtramp_frame_unwind_stop_reason (frame_info_ptr this_frame,
+i386_sigtramp_frame_unwind_stop_reason (const frame_info_ptr &this_frame,
void **this_cache)
{
struct i386_frame_cache *cache =
}
static void
-i386_sigtramp_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+i386_sigtramp_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct i386_frame_cache *cache =
}
static struct value *
-i386_sigtramp_frame_prev_register (frame_info_ptr this_frame,
+i386_sigtramp_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
/* Make sure we've initialized the cache. */
static int
i386_sigtramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
gdbarch *arch = get_frame_arch (this_frame);
\f
static CORE_ADDR
-i386_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+i386_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct i386_frame_cache *cache = i386_frame_cache (this_frame, this_cache);
};
static struct frame_id
-i386_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
+i386_dummy_id (struct gdbarch *gdbarch, const frame_info_ptr &this_frame)
{
CORE_ADDR fp;
success. */
static int
-i386_get_longjmp_target (frame_info_ptr frame, CORE_ADDR *pc)
+i386_get_longjmp_target (const frame_info_ptr &frame, CORE_ADDR *pc)
{
gdb_byte buf[4];
CORE_ADDR sp, jb_addr;
the MMX registers need to be mapped onto floating point registers. */
static int
-i386_mmx_regnum_to_fp_regnum (frame_info_ptr next_frame, int regnum)
+i386_mmx_regnum_to_fp_regnum (const frame_info_ptr &next_frame, int regnum)
{
gdbarch *arch = frame_unwind_arch (next_frame);
i386_gdbarch_tdep *tdep = gdbarch_tdep<i386_gdbarch_tdep> (arch);
the data into an already-allocated value. */
value *
-i386_pseudo_register_read_value (gdbarch *gdbarch, frame_info_ptr next_frame,
+i386_pseudo_register_read_value (gdbarch *gdbarch, const frame_info_ptr &next_frame,
const int pseudo_reg_num)
{
if (i386_mmx_regnum_p (gdbarch, pseudo_reg_num))
}
void
-i386_pseudo_register_write (gdbarch *gdbarch, frame_info_ptr next_frame,
+i386_pseudo_register_write (gdbarch *gdbarch, const frame_info_ptr &next_frame,
const int pseudo_reg_num,
gdb::array_view<const gdb_byte> buf)
{
return its contents in TO. */
static int
-i386_register_to_value (frame_info_ptr frame, int regnum,
+i386_register_to_value (const frame_info_ptr &frame, int regnum,
struct type *type, gdb_byte *to,
int *optimizedp, int *unavailablep)
{
REGNUM in frame FRAME. */
static void
-i386_value_to_register (frame_info_ptr frame, int regnum,
+i386_value_to_register (const frame_info_ptr &frame, int regnum,
struct type *type, const gdb_byte *from)
{
int len = type->length ();
/* Stuff for WIN32 PE style DLL's but is pretty generic really. */
CORE_ADDR
-i386_pe_skip_trampoline_code (frame_info_ptr frame,
+i386_pe_skip_trampoline_code (const frame_info_ptr &frame,
CORE_ADDR pc, char *name)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
routine. */
int
-i386_sigtramp_p (frame_info_ptr this_frame)
+i386_sigtramp_p (const frame_info_ptr &this_frame)
{
CORE_ADDR pc = get_frame_pc (this_frame);
const char *name;
routine. */
static int
-i386_svr4_sigtramp_p (frame_info_ptr this_frame)
+i386_svr4_sigtramp_p (const frame_info_ptr &this_frame)
{
CORE_ADDR pc = get_frame_pc (this_frame);
const char *name;
address of the associated sigcontext (ucontext) structure. */
static CORE_ADDR
-i386_svr4_sigcontext_addr (frame_info_ptr this_frame)
+i386_svr4_sigcontext_addr (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
/* Get the ARGIth function argument for the current function. */
static CORE_ADDR
-i386_fetch_pointer_argument (frame_info_ptr frame, int argi,
+i386_fetch_pointer_argument (const frame_info_ptr &frame, int argi,
struct type *type)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
CORE_ADDR sigtramp_end = 0;
/* Detect sigtramp. */
- int (*sigtramp_p) (frame_info_ptr) = nullptr;
+ int (*sigtramp_p) (const frame_info_ptr &) = nullptr;
/* Get address of sigcontext for sigtramp. */
- CORE_ADDR (*sigcontext_addr) (frame_info_ptr) = nullptr;
+ CORE_ADDR (*sigcontext_addr) (const frame_info_ptr &) = nullptr;
/* Offset of registers in `struct sigcontext'. */
int *sc_reg_offset = 0;
int regnum);
extern value *i386_pseudo_register_read_value (gdbarch *gdbarch,
- frame_info_ptr next_frame,
+ const frame_info_ptr &next_frame,
int regnum);
extern void i386_pseudo_register_write (gdbarch *gdbarch,
- frame_info_ptr next_frame, int regnum,
+ const frame_info_ptr &next_frame, int regnum,
gdb::array_view<const gdb_byte> buf);
extern int i386_ax_pseudo_register_collect (struct gdbarch *gdbarch,
#define I386_MAX_INSN_LEN (16)
/* Functions exported from i386-tdep.c. */
-extern CORE_ADDR i386_pe_skip_trampoline_code (frame_info_ptr frame,
+extern CORE_ADDR i386_pe_skip_trampoline_code (const frame_info_ptr &frame,
CORE_ADDR pc, char *name);
extern CORE_ADDR i386_skip_main_prologue (struct gdbarch *gdbarch,
CORE_ADDR pc);
bool thiscall);
/* Return whether the THIS_FRAME corresponds to a sigtramp routine. */
-extern int i386_sigtramp_p (frame_info_ptr this_frame);
+extern int i386_sigtramp_p (const frame_info_ptr &this_frame);
/* Return non-zero if REGNUM is a member of the specified group. */
extern int i386_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
#define I386_WINDOWS_SIZEOF_GREGSET 716
static CORE_ADDR
-i386_windows_skip_trampoline_code (frame_info_ptr frame, CORE_ADDR pc)
+i386_windows_skip_trampoline_code (const frame_info_ptr &frame, CORE_ADDR pc)
{
return i386_pe_skip_trampoline_code (frame, pc, NULL);
}
void
i387_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
- frame_info_ptr frame, const char *args)
+ const frame_info_ptr &frame, const char *args)
{
i386_gdbarch_tdep *tdep = gdbarch_tdep<i386_gdbarch_tdep> (gdbarch);
ULONGEST fctrl;
return its contents in TO. */
int
-i387_register_to_value (frame_info_ptr frame, int regnum,
+i387_register_to_value (const frame_info_ptr &frame, int regnum,
struct type *type, gdb_byte *to,
int *optimizedp, int *unavailablep)
{
REGNUM in frame FRAME. */
void
-i387_value_to_register (frame_info_ptr frame, int regnum,
+i387_value_to_register (const frame_info_ptr &frame, int regnum,
struct type *type, const gdb_byte *from)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
extern void i387_print_float_info (struct gdbarch *gdbarch,
struct ui_file *file,
- frame_info_ptr frame,
+ const frame_info_ptr &frame,
const char *args);
/* Return nonzero if a value of type TYPE stored in register REGNUM
/* Read a value of type TYPE from register REGNUM in frame FRAME, and
return its contents in TO. */
-extern int i387_register_to_value (frame_info_ptr frame, int regnum,
+extern int i387_register_to_value (const frame_info_ptr &frame, int regnum,
struct type *type, gdb_byte *to,
int *optimizedp, int *unavailablep);
/* Write the contents FROM of a value of type TYPE into register
REGNUM in frame FRAME. */
-extern void i387_value_to_register (frame_info_ptr frame, int regnum,
+extern void i387_value_to_register (const frame_info_ptr &frame, int regnum,
struct type *type, const gdb_byte *from);
\f
}
static struct libunwind_frame_cache *
-libunwind_frame_cache (frame_info_ptr this_frame, void **this_cache)
+libunwind_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
unw_accessors_t *acc;
unw_addr_space_t as;
libunwind frame unwinding. */
int
libunwind_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame, void **this_cache)
+ const frame_info_ptr &this_frame, void **this_cache)
{
unw_cursor_t cursor;
unw_accessors_t *acc;
}
void
-libunwind_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+libunwind_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct libunwind_frame_cache *cache =
}
struct value *
-libunwind_frame_prev_register (frame_info_ptr this_frame,
+libunwind_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct libunwind_frame_cache *cache =
/* Verify if we are in a sigtramp frame and we can use libunwind to unwind. */
int
libunwind_sigtramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
unw_cursor_t cursor;
};
int libunwind_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache);
int libunwind_sigtramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache);
void libunwind_frame_set_descr (struct gdbarch *arch,
struct libunwind_descr *descr);
-void libunwind_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+void libunwind_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id);
-struct value *libunwind_frame_prev_register (frame_info_ptr this_frame,
+struct value *libunwind_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum);
void libunwind_frame_dealloc_cache (frame_info_ptr self, void *cache);
}
static int
-ia64_register_to_value (frame_info_ptr frame, int regnum,
+ia64_register_to_value (const frame_info_ptr &frame, int regnum,
struct type *valtype, gdb_byte *out,
int *optimizedp, int *unavailablep)
{
}
static void
-ia64_value_to_register (frame_info_ptr frame, int regnum,
+ia64_value_to_register (const frame_info_ptr &frame, int regnum,
struct type *valtype, const gdb_byte *in)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
static CORE_ADDR
examine_prologue (CORE_ADDR pc, CORE_ADDR lim_pc,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct ia64_frame_cache *cache)
{
CORE_ADDR next_pc;
/* Normal frames. */
static struct ia64_frame_cache *
-ia64_frame_cache (frame_info_ptr this_frame, void **this_cache)
+ia64_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
}
static void
-ia64_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+ia64_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
static struct value *
-ia64_frame_prev_register (frame_info_ptr this_frame, void **this_cache,
+ia64_frame_prev_register (const frame_info_ptr &this_frame, void **this_cache,
int regnum)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
/* Signal trampolines. */
static void
-ia64_sigtramp_frame_init_saved_regs (frame_info_ptr this_frame,
+ia64_sigtramp_frame_init_saved_regs (const frame_info_ptr &this_frame,
struct ia64_frame_cache *cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
static struct ia64_frame_cache *
-ia64_sigtramp_frame_cache (frame_info_ptr this_frame, void **this_cache)
+ia64_sigtramp_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
}
static void
-ia64_sigtramp_frame_this_id (frame_info_ptr this_frame,
+ia64_sigtramp_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache, struct frame_id *this_id)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
static struct value *
-ia64_sigtramp_frame_prev_register (frame_info_ptr this_frame,
+ia64_sigtramp_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct ia64_frame_cache *cache =
static int
ia64_sigtramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
gdbarch *arch = get_frame_arch (this_frame);
\f
static CORE_ADDR
-ia64_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+ia64_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct ia64_frame_cache *cache = ia64_frame_cache (this_frame, this_cache);
unw_fpreg_t *val, int write, void *arg)
{
int regnum = ia64_uw2gdb_regnum (uw_regnum);
- frame_info_ptr this_frame = (frame_info_ptr) arg;
+ frame_info_ptr this_frame = (const frame_info_ptr &) arg;
/* We never call any libunwind routines that need to write registers. */
gdb_assert (!write);
/* Frame interface functions for libunwind. */
static void
-ia64_libunwind_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+ia64_libunwind_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
static struct value *
-ia64_libunwind_frame_prev_register (frame_info_ptr this_frame,
+ia64_libunwind_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
int reg = regnum;
static int
ia64_libunwind_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
if (libunwind_is_initialized ()
};
static void
-ia64_libunwind_sigtramp_frame_this_id (frame_info_ptr this_frame,
+ia64_libunwind_sigtramp_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-ia64_libunwind_sigtramp_frame_prev_register (frame_info_ptr this_frame,
+ia64_libunwind_sigtramp_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
static int
ia64_libunwind_sigtramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
if (libunwind_is_initialized ())
};
static struct frame_id
-ia64_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
+ia64_dummy_id (struct gdbarch *gdbarch, const frame_info_ptr &this_frame)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
gdb_byte buf[8];
}
static CORE_ADDR
-ia64_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
+ia64_unwind_pc (struct gdbarch *gdbarch, const frame_info_ptr &next_frame)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
gdb_byte buf[8];
/* The default "size_of_register_frame" gdbarch_tdep routine for ia64. */
static int
-ia64_size_of_register_frame (frame_info_ptr this_frame, ULONGEST cfm)
+ia64_size_of_register_frame (const frame_info_ptr &this_frame, ULONGEST cfm)
{
return (cfm & 0x7f);
}
Normally, the size of the register frame is always obtained by
extracting the lowest 7 bits ("cfm & 0x7f"). */
- int (*size_of_register_frame) (frame_info_ptr this_frame, ULONGEST cfm)
+ int (*size_of_register_frame) (const frame_info_ptr &this_frame, ULONGEST cfm)
= nullptr;
/* Determine the function address FADDR belongs to a shared library.
frame that called the function we're about to step out of. */
static void
-finish_forward (struct finish_command_fsm *sm, frame_info_ptr frame)
+finish_forward (struct finish_command_fsm *sm, const frame_info_ptr &frame)
{
struct frame_id frame_id = get_frame_id (frame);
struct gdbarch *gdbarch = get_frame_arch (frame);
/* Skip frames for "finish". */
static frame_info_ptr
-skip_finish_frames (frame_info_ptr frame)
+skip_finish_frames (const frame_info_ptr &initial_frame)
{
frame_info_ptr start;
+ frame_info_ptr frame = initial_frame;
do
{
void
default_print_registers_info (struct gdbarch *gdbarch,
struct ui_file *file,
- frame_info_ptr frame,
+ const frame_info_ptr &frame,
int regnum, int print_all)
{
int i;
static void
print_vector_info (struct ui_file *file,
- frame_info_ptr frame, const char *args)
+ const frame_info_ptr &frame, const char *args)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
void
default_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
- frame_info_ptr frame, const char *args)
+ const frame_info_ptr &frame, const char *args)
{
int regnum;
int printed_something = 0;
extern void default_print_registers_info (struct gdbarch *gdbarch,
struct ui_file *file,
- frame_info_ptr frame,
+ const frame_info_ptr &frame,
int regnum, int all);
/* Default implementation of gdbarch_print_float_info. Print
extern void default_print_float_info (struct gdbarch *gdbarch,
struct ui_file *file,
- frame_info_ptr frame,
+ const frame_info_ptr &frame,
const char *args);
/* Try to determine whether TTY is GDB's input terminal. Returns
static bool currently_stepping (struct thread_info *tp);
-static void insert_hp_step_resume_breakpoint_at_frame (frame_info_ptr);
+static void insert_hp_step_resume_breakpoint_at_frame (const frame_info_ptr &);
-static void insert_step_resume_breakpoint_at_caller (frame_info_ptr);
+static void insert_step_resume_breakpoint_at_caller (const frame_info_ptr &);
static void insert_longjmp_resume_breakpoint (struct gdbarch *, CORE_ADDR);
struct execution_control_state *ecs);
static void handle_signal_stop (struct execution_control_state *ecs);
static void check_exception_resume (struct execution_control_state *,
- frame_info_ptr);
+ const frame_info_ptr &);
static void end_stepping_range (struct execution_control_state *ecs);
static void stop_waiting (struct execution_control_state *ecs);
/* See infrun.h. */
void
-set_step_info (thread_info *tp, frame_info_ptr frame,
+set_step_info (thread_info *tp, const frame_info_ptr &frame,
struct symtab_and_line sal)
{
/* This can be removed once this function no longer implicitly relies on the
}
static bool
-stepped_in_from (frame_info_ptr frame, struct frame_id step_frame_id)
+stepped_in_from (const frame_info_ptr &initial_frame, frame_id step_frame_id)
{
+ frame_info_ptr frame = initial_frame;
+
for (frame = get_prev_frame (frame);
frame != nullptr;
frame = get_prev_frame (frame))
RETURN_FRAME.pc. */
static void
-insert_hp_step_resume_breakpoint_at_frame (frame_info_ptr return_frame)
+insert_hp_step_resume_breakpoint_at_frame (const frame_info_ptr &return_frame)
{
gdb_assert (return_frame != nullptr);
of frame_unwind_caller_id for an example). */
static void
-insert_step_resume_breakpoint_at_caller (frame_info_ptr next_frame)
+insert_step_resume_breakpoint_at_caller (const frame_info_ptr &next_frame)
{
/* We shouldn't have gotten here if we don't know where the call site
is. */
static void
insert_exception_resume_breakpoint (struct thread_info *tp,
const struct block *b,
- frame_info_ptr frame,
+ const frame_info_ptr &frame,
struct symbol *sym)
{
try
static void
insert_exception_resume_from_probe (struct thread_info *tp,
const struct bound_probe *probe,
- frame_info_ptr frame)
+ const frame_info_ptr &frame)
{
struct value *arg_value;
CORE_ADDR handler;
static void
check_exception_resume (struct execution_control_state *ecs,
- frame_info_ptr frame)
+ const frame_info_ptr &frame)
{
struct bound_probe probe;
struct symbol *func;
/* Record in TP the frame and location we're currently stepping through. */
extern void set_step_info (thread_info *tp,
- frame_info_ptr frame,
+ const frame_info_ptr &frame,
struct symtab_and_line sal);
/* Notify interpreters and observers that the current inferior has stopped with
}
static void
-inline_frame_this_id (frame_info_ptr this_frame,
+inline_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-inline_frame_prev_register (frame_info_ptr this_frame, void **this_cache,
+inline_frame_prev_register (const frame_info_ptr &this_frame, void **this_cache,
int regnum)
{
/* Use get_frame_register_value instead of
static int
inline_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
CORE_ADDR this_pc;
skip_inline_frames). */
int
-frame_inlined_callees (frame_info_ptr this_frame)
+frame_inlined_callees (const frame_info_ptr &this_frame)
{
frame_info_ptr next_frame;
int inline_count = 0;
the callees may not have associated frames (see
skip_inline_frames). */
-int frame_inlined_callees (frame_info_ptr this_frame);
+int frame_inlined_callees (const frame_info_ptr &this_frame);
#endif /* !defined (INLINE_FRAME_H) */
iq2000_scan_prologue (struct gdbarch *gdbarch,
CORE_ADDR scan_start,
CORE_ADDR scan_end,
- frame_info_ptr fi,
+ const frame_info_ptr &fi,
struct iq2000_frame_cache *cache)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
}
static struct iq2000_frame_cache *
-iq2000_frame_cache (frame_info_ptr this_frame, void **this_cache)
+iq2000_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct iq2000_frame_cache *cache;
}
static struct value *
-iq2000_frame_prev_register (frame_info_ptr this_frame, void **this_cache,
+iq2000_frame_prev_register (const frame_info_ptr &this_frame, void **this_cache,
int regnum)
{
struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame,
}
static void
-iq2000_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+iq2000_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame,
};
static CORE_ADDR
-iq2000_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+iq2000_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame,
this_cache);
static int
jit_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame, void **cache)
+ const frame_info_ptr &this_frame, void **cache)
{
struct jit_unwind_private *priv_data;
struct gdb_unwind_callbacks callbacks;
the loaded plugin. */
static void
-jit_frame_this_id (frame_info_ptr this_frame, void **cache,
+jit_frame_this_id (const frame_info_ptr &this_frame, void **cache,
struct frame_id *this_id)
{
struct jit_unwind_private priv;
the register from the cache. */
static struct value *
-jit_frame_prev_register (frame_info_ptr this_frame, void **cache, int reg)
+jit_frame_prev_register (const frame_info_ptr &this_frame, void **cache, int reg)
{
struct jit_unwind_private *priv = (struct jit_unwind_private *) *cache;
struct gdbarch *gdbarch;
virtual struct value *read_var_value (struct symbol *var,
const struct block *var_block,
- frame_info_ptr frame) const;
+ const frame_info_ptr &frame) const;
/* Return information about whether TYPE should be passed
(and returned) by reference at the language level. The default
for it IS the sp for the next frame. */
static struct lm32_frame_cache *
-lm32_frame_cache (frame_info_ptr this_frame, void **this_prologue_cache)
+lm32_frame_cache (const frame_info_ptr &this_frame, void **this_prologue_cache)
{
CORE_ADDR current_pc;
ULONGEST prev_sp;
}
static void
-lm32_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+lm32_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct lm32_frame_cache *cache = lm32_frame_cache (this_frame, this_cache);
}
static struct value *
-lm32_frame_prev_register (frame_info_ptr this_frame,
+lm32_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
struct lm32_frame_cache *info;
};
static CORE_ADDR
-lm32_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+lm32_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct lm32_frame_cache *info = lm32_frame_cache (this_frame, this_cache);
static void
loongarch_linux_rt_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
instruction to be executed. */
static CORE_ADDR
-loongarch_linux_syscall_next_pc (frame_info_ptr frame)
+loongarch_linux_syscall_next_pc (const frame_info_ptr &frame)
{
const CORE_ADDR pc = get_frame_pc (frame);
ULONGEST a7 = get_frame_register_unsigned (frame, LOONGARCH_A7_REGNUM);
static CORE_ADDR
loongarch_scan_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc,
- CORE_ADDR limit_pc, frame_info_ptr this_frame,
+ CORE_ADDR limit_pc, const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache)
{
CORE_ADDR cur_pc = start_pc, prologue_end = 0;
/* Callback function for user_reg_add. */
static struct value *
-value_of_loongarch_user_reg (frame_info_ptr frame, const void *baton)
+value_of_loongarch_user_reg (const frame_info_ptr &frame, const void *baton)
{
return value_of_register ((long long) baton,
get_next_frame_sentinel_okay (frame));
/* Generate, or return the cached frame cache for frame unwinder. */
static struct trad_frame_cache *
-loongarch_frame_cache (frame_info_ptr this_frame, void **this_cache)
+loongarch_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct trad_frame_cache *cache;
CORE_ADDR pc;
/* Implement the this_id callback for frame unwinder. */
static void
-loongarch_frame_this_id (frame_info_ptr this_frame, void **prologue_cache,
+loongarch_frame_this_id (const frame_info_ptr &this_frame, void **prologue_cache,
struct frame_id *this_id)
{
struct trad_frame_cache *info;
/* Implement the prev_register callback for frame unwinder. */
static struct value *
-loongarch_frame_prev_register (frame_info_ptr this_frame,
+loongarch_frame_prev_register (const frame_info_ptr &this_frame,
void **prologue_cache, int regnum)
{
struct trad_frame_cache *info;
struct loongarch_gdbarch_features abi_features;
/* Return the expected next PC if FRAME is stopped at a syscall instruction. */
- CORE_ADDR (*syscall_next_pc) (frame_info_ptr frame) = nullptr;
+ CORE_ADDR (*syscall_next_pc) (const frame_info_ptr &frame) = nullptr;
};
#endif /* LOONGARCH_TDEP_H */
/* Stack unwinding. */
static struct m32c_prologue *
-m32c_analyze_frame_prologue (frame_info_ptr this_frame,
+m32c_analyze_frame_prologue (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
if (! *this_prologue_cache)
static CORE_ADDR
-m32c_frame_base (frame_info_ptr this_frame,
+m32c_frame_base (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
struct m32c_prologue *p
static void
-m32c_this_id (frame_info_ptr this_frame,
+m32c_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
static struct value *
-m32c_prev_register (frame_info_ptr this_frame,
+m32c_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
gdbarch *arch = get_frame_arch (this_frame);
code sequence seems more fragile. */
static CORE_ADDR
-m32c_skip_trampoline_code (frame_info_ptr frame, CORE_ADDR stop_pc)
+m32c_skip_trampoline_code (const frame_info_ptr &frame, CORE_ADDR stop_pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
m32c_gdbarch_tdep *tdep = gdbarch_tdep<m32c_gdbarch_tdep> (gdbarch);
the routine. Otherwise, return 0. */
static CORE_ADDR
-m32r_linux_sigtramp_start (CORE_ADDR pc, frame_info_ptr this_frame)
+m32r_linux_sigtramp_start (CORE_ADDR pc, const frame_info_ptr &this_frame)
{
gdb_byte buf[4];
of the routine. Otherwise, return 0. */
static CORE_ADDR
-m32r_linux_rt_sigtramp_start (CORE_ADDR pc, frame_info_ptr this_frame)
+m32r_linux_rt_sigtramp_start (CORE_ADDR pc, const frame_info_ptr &this_frame)
{
gdb_byte buf[4];
static int
m32r_linux_pc_in_sigtramp (CORE_ADDR pc, const char *name,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
/* If we have NAME, we can optimize the search. The trampolines are
named __restore and __restore_rt. However, they aren't dynamically
};
static struct m32r_frame_cache *
-m32r_linux_sigtramp_frame_cache (frame_info_ptr this_frame,
+m32r_linux_sigtramp_frame_cache (const frame_info_ptr &this_frame,
void **this_cache)
{
struct m32r_frame_cache *cache;
}
static void
-m32r_linux_sigtramp_frame_this_id (frame_info_ptr this_frame,
+m32r_linux_sigtramp_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-m32r_linux_sigtramp_frame_prev_register (frame_info_ptr this_frame,
+m32r_linux_sigtramp_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct m32r_frame_cache *cache =
static int
m32r_linux_sigtramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
CORE_ADDR pc = get_frame_pc (this_frame);
for it IS the sp for the next frame. */
static struct m32r_unwind_cache *
-m32r_frame_unwind_cache (frame_info_ptr this_frame,
+m32r_frame_unwind_cache (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
CORE_ADDR pc, scan_limit;
frame. This will be used to create a new GDB frame struct. */
static void
-m32r_frame_this_id (frame_info_ptr this_frame,
+m32r_frame_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache, struct frame_id *this_id)
{
struct m32r_unwind_cache *info
}
static struct value *
-m32r_frame_prev_register (frame_info_ptr this_frame,
+m32r_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
struct m32r_unwind_cache *info
};
static CORE_ADDR
-m32r_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+m32r_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct m32r_unwind_cache *info
= m32r_frame_unwind_cache (this_frame, this_cache);
for it IS the sp for the next frame. */
static struct m68hc11_unwind_cache *
-m68hc11_frame_unwind_cache (frame_info_ptr this_frame,
+m68hc11_frame_unwind_cache (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
frame. This will be used to create a new GDB frame struct. */
static void
-m68hc11_frame_this_id (frame_info_ptr this_frame,
+m68hc11_frame_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
}
static struct value *
-m68hc11_frame_prev_register (frame_info_ptr this_frame,
+m68hc11_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
struct value *value;
};
static CORE_ADDR
-m68hc11_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+m68hc11_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct m68hc11_unwind_cache *info
= m68hc11_frame_unwind_cache (this_frame, this_cache);
}
static CORE_ADDR
-m68hc11_frame_args_address (frame_info_ptr this_frame, void **this_cache)
+m68hc11_frame_args_address (const frame_info_ptr &this_frame, void **this_cache)
{
CORE_ADDR addr;
struct m68hc11_unwind_cache *info
save_dummy_frame_tos(), and the PC match the dummy frame's breakpoint. */
static struct frame_id
-m68hc11_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
+m68hc11_dummy_id (struct gdbarch *gdbarch, const frame_info_ptr &this_frame)
{
ULONGEST tos;
CORE_ADDR pc = get_frame_pc (this_frame);
/* Get and print the register from the given frame. */
static void
m68hc11_print_register (struct gdbarch *gdbarch, struct ui_file *file,
- frame_info_ptr frame, int regno)
+ const frame_info_ptr &frame, int regno)
{
LONGEST rval;
/* Same as 'info reg' but prints the registers in a different way. */
static void
m68hc11_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
- frame_info_ptr frame, int regno, int cpregs)
+ const frame_info_ptr &frame, int regno, int cpregs)
{
if (regno >= 0)
{
non-RT and RT signal trampolines. */
static int
-m68k_linux_pc_in_sigtramp (frame_info_ptr this_frame)
+m68k_linux_pc_in_sigtramp (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
}
static struct m68k_linux_sigtramp_info
-m68k_linux_get_sigtramp_info (frame_info_ptr this_frame)
+m68k_linux_get_sigtramp_info (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
/* Signal trampolines. */
static struct trad_frame_cache *
-m68k_linux_sigtramp_frame_cache (frame_info_ptr this_frame,
+m68k_linux_sigtramp_frame_cache (const frame_info_ptr &this_frame,
void **this_cache)
{
struct frame_id this_id;
}
static void
-m68k_linux_sigtramp_frame_this_id (frame_info_ptr this_frame,
+m68k_linux_sigtramp_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-m68k_linux_sigtramp_frame_prev_register (frame_info_ptr this_frame,
+m68k_linux_sigtramp_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache,
int regnum)
{
static int
m68k_linux_sigtramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
return m68k_linux_pc_in_sigtramp (this_frame);
return its contents in TO. */
static int
-m68k_register_to_value (frame_info_ptr frame, int regnum,
+m68k_register_to_value (const frame_info_ptr &frame, int regnum,
struct type *type, gdb_byte *to,
int *optimizedp, int *unavailablep)
{
REGNUM in frame FRAME. */
static void
-m68k_value_to_register (frame_info_ptr frame, int regnum,
+m68k_value_to_register (const frame_info_ptr &frame, int regnum,
struct type *type, const gdb_byte *from)
{
gdb_byte to[M68K_MAX_REGISTER_SIZE];
}
static CORE_ADDR
-m68k_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
+m68k_unwind_pc (struct gdbarch *gdbarch, const frame_info_ptr &next_frame)
{
gdb_byte buf[8];
/* Normal frames. */
static struct m68k_frame_cache *
-m68k_frame_cache (frame_info_ptr this_frame, void **this_cache)
+m68k_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
}
static void
-m68k_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+m68k_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache);
}
static struct value *
-m68k_frame_prev_register (frame_info_ptr this_frame, void **this_cache,
+m68k_frame_prev_register (const frame_info_ptr &this_frame, void **this_cache,
int regnum)
{
struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache);
};
\f
static CORE_ADDR
-m68k_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+m68k_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache);
};
static struct frame_id
-m68k_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
+m68k_dummy_id (struct gdbarch *gdbarch, const frame_info_ptr &this_frame)
{
CORE_ADDR fp;
This routine returns true on success. */
static int
-m68k_get_longjmp_target (frame_info_ptr frame, CORE_ADDR *pc)
+m68k_get_longjmp_target (const frame_info_ptr &frame, CORE_ADDR *pc)
{
gdb_byte *buf;
CORE_ADDR sp, jb_addr;
static struct mep_prologue *
-mep_analyze_frame_prologue (frame_info_ptr this_frame,
+mep_analyze_frame_prologue (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
if (! *this_prologue_cache)
/* Given the next frame and a prologue cache, return this frame's
base. */
static CORE_ADDR
-mep_frame_base (frame_info_ptr this_frame,
+mep_frame_base (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
struct mep_prologue *p
static void
-mep_frame_this_id (frame_info_ptr this_frame,
+mep_frame_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
static struct value *
-mep_frame_prev_register (frame_info_ptr this_frame,
+mep_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
struct mep_prologue *p
static void list_args_or_locals (const frame_print_options &fp_opts,
enum what_to_list what,
enum print_values values,
- frame_info_ptr fi,
+ const frame_info_ptr &fi,
int skip_unavailable);
/* True if we want to allow Python-based frame filters. */
/* Like apply_ext_lang_frame_filter, but take a print_values */
static enum ext_lang_bt_status
-mi_apply_ext_lang_frame_filter (frame_info_ptr frame,
+mi_apply_ext_lang_frame_filter (const frame_info_ptr &frame,
frame_filter_flags flags,
enum print_values print_values,
struct ui_out *out,
static void
list_args_or_locals (const frame_print_options &fp_opts,
enum what_to_list what, enum print_values values,
- frame_info_ptr fi, int skip_unavailable)
+ const frame_info_ptr &fi, int skip_unavailable)
{
const struct block *block;
const char *name_of_result;
const char *const *argv, int argc);
static bool register_changed_p (int regnum, readonly_detached_regcache *,
readonly_detached_regcache *);
-static void output_register (frame_info_ptr, int regnum, int format,
+static void output_register (const frame_info_ptr &, int regnum, int format,
int skip_unavailable);
/* Controls whether the frontend wants MI in async mode. */
unavailable. */
static void
-output_register (frame_info_ptr frame, int regnum, int format,
+output_register (const frame_info_ptr &frame, int regnum, int format,
int skip_unavailable)
{
struct ui_out *uiout = current_uiout;
}
static void
-microblaze_linux_sigtramp_cache (frame_info_ptr next_frame,
+microblaze_linux_sigtramp_cache (const frame_info_ptr &next_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func, LONGEST offset,
int bias)
static void
microblaze_linux_sighandler_cache_init (const struct tramp_frame *self,
- frame_info_ptr next_frame,
+ const frame_info_ptr &next_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
}
static CORE_ADDR
-microblaze_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
+microblaze_unwind_pc (struct gdbarch *gdbarch, const frame_info_ptr &next_frame)
{
gdb_byte buf[4];
CORE_ADDR pc;
/* Normal frames. */
static struct microblaze_frame_cache *
-microblaze_frame_cache (frame_info_ptr next_frame, void **this_cache)
+microblaze_frame_cache (const frame_info_ptr &next_frame, void **this_cache)
{
struct microblaze_frame_cache *cache;
struct gdbarch *gdbarch = get_frame_arch (next_frame);
}
static void
-microblaze_frame_this_id (frame_info_ptr next_frame, void **this_cache,
+microblaze_frame_this_id (const frame_info_ptr &next_frame, void **this_cache,
struct frame_id *this_id)
{
struct microblaze_frame_cache *cache =
}
static struct value *
-microblaze_frame_prev_register (frame_info_ptr this_frame,
+microblaze_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct microblaze_frame_cache *cache =
};
\f
static CORE_ADDR
-microblaze_frame_base_address (frame_info_ptr next_frame,
+microblaze_frame_base_address (const frame_info_ptr &next_frame,
void **this_cache)
{
struct microblaze_frame_cache *cache =
a duplicate function in case this matters someday. */
CORE_ADDR
-find_solib_trampoline_target (frame_info_ptr frame, CORE_ADDR pc)
+find_solib_trampoline_target (const frame_info_ptr &frame, CORE_ADDR pc)
{
struct minimal_symbol *tsymbol = lookup_solib_trampoline_symbol_by_pc (pc);
static void
mips_fbsd_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *cache,
CORE_ADDR func)
{
static void
mips64_fbsd_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *cache,
CORE_ADDR func)
{
#define MIPS_LINUX_JB_PC 0
static int
-mips_linux_get_longjmp_target (frame_info_ptr frame, CORE_ADDR *pc)
+mips_linux_get_longjmp_target (const frame_info_ptr &frame, CORE_ADDR *pc)
{
CORE_ADDR jb_addr;
struct gdbarch *gdbarch = get_frame_arch (frame);
#define MIPS64_LINUX_JB_PC 0
static int
-mips64_linux_get_longjmp_target (frame_info_ptr frame, CORE_ADDR *pc)
+mips64_linux_get_longjmp_target (const frame_info_ptr &frame, CORE_ADDR *pc)
{
CORE_ADDR jb_addr;
struct gdbarch *gdbarch = get_frame_arch (frame);
efficient way, but simplest. First, declare all the unwinders. */
static void mips_linux_o32_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func);
static void mips_linux_n32n64_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func);
static int mips_linux_sigframe_validate (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
CORE_ADDR *pc);
static int micromips_linux_sigframe_validate (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
CORE_ADDR *pc);
#define MIPS_NR_LINUX 4000
static void
mips_linux_o32_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
static void
mips_linux_n32n64_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
static int
mips_linux_sigframe_validate (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
CORE_ADDR *pc)
{
return mips_pc_is_mips (*pc);
static int
micromips_linux_sigframe_validate (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
CORE_ADDR *pc)
{
if (mips_pc_is_micromips (get_frame_arch (this_frame), *pc))
instruction to be executed. */
static CORE_ADDR
-mips_linux_syscall_next_pc (frame_info_ptr frame)
+mips_linux_syscall_next_pc (const frame_info_ptr &frame)
{
CORE_ADDR pc = get_frame_pc (frame);
ULONGEST v0 = get_frame_register_unsigned (frame, MIPS_V0_REGNUM);
NBSD_MIPS_JB_ELEMENT_SIZE (gdbarch))
static int
-mipsnbsd_get_longjmp_target (frame_info_ptr frame, CORE_ADDR *pc)
+mipsnbsd_get_longjmp_target (const frame_info_ptr &frame, CORE_ADDR *pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
in the SDE frame unwinder. */
static struct trad_frame_cache *
-mips_sde_frame_cache (frame_info_ptr this_frame, void **this_cache)
+mips_sde_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
const struct mips_regnum *regs = mips_regnum (gdbarch);
/* Implement the this_id function for the SDE frame unwinder. */
static void
-mips_sde_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+mips_sde_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct trad_frame_cache *this_trad_cache
/* Implement the prev_register function for the SDE frame unwinder. */
static struct value *
-mips_sde_frame_prev_register (frame_info_ptr this_frame,
+mips_sde_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache,
int prev_regnum)
{
static int
mips_sde_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
CORE_ADDR pc = get_frame_pc (this_frame);
for the normal unwinder. */
static CORE_ADDR
-mips_sde_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+mips_sde_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct trad_frame_cache *this_trad_cache
= mips_sde_frame_cache (this_frame, this_cache);
};
static const struct frame_base *
-mips_sde_frame_base_sniffer (frame_info_ptr this_frame)
+mips_sde_frame_base_sniffer (const frame_info_ptr &this_frame)
{
if (mips_sde_frame_sniffer (&mips_sde_frame_unwind, this_frame, NULL))
return &mips_sde_frame_base;
CORE_ADDR addr, int mustbe32);
static void mips_print_float_info (struct gdbarch *, struct ui_file *,
- frame_info_ptr, const char *);
+ const frame_info_ptr &, const char *);
/* A useful bit in the CP0 status register (MIPS_PS_REGNUM). */
/* This bit is set if we are emulating 32-bit FPRs on a 64-bit chip. */
physical 64-bit registers, but should treat them as 32-bit registers. */
static int
-mips2_fp_compat (frame_info_ptr frame)
+mips2_fp_compat (const frame_info_ptr &frame)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
/* MIPS1 and MIPS2 have only 32 bit FPRs, and the FR bit is not
}
static int
-mips_register_to_value (frame_info_ptr frame, int regnum,
+mips_register_to_value (const frame_info_ptr &frame, int regnum,
struct type *type, gdb_byte *to,
int *optimizedp, int *unavailablep)
{
}
static void
-mips_value_to_register (frame_info_ptr frame, int regnum,
+mips_value_to_register (const frame_info_ptr &frame, int regnum,
struct type *type, const gdb_byte *from)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
}
static CORE_ADDR
-mips_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
+mips_unwind_pc (struct gdbarch *gdbarch, const frame_info_ptr &next_frame)
{
CORE_ADDR pc;
}
static CORE_ADDR
-mips_unwind_sp (struct gdbarch *gdbarch, frame_info_ptr next_frame)
+mips_unwind_sp (struct gdbarch *gdbarch, const frame_info_ptr &next_frame)
{
return frame_unwind_register_signed
(next_frame, gdbarch_num_regs (gdbarch) + MIPS_SP_REGNUM);
breakpoint. */
static struct frame_id
-mips_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
+mips_dummy_id (struct gdbarch *gdbarch, const frame_info_ptr &this_frame)
{
return frame_id_build
(get_frame_register_signed (this_frame,
static CORE_ADDR
mips16_scan_prologue (struct gdbarch *gdbarch,
CORE_ADDR start_pc, CORE_ADDR limit_pc,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct mips_frame_cache *this_cache)
{
int prev_non_prologue_insn = 0;
mips_insn32 unwinder. */
static struct mips_frame_cache *
-mips_insn16_frame_cache (frame_info_ptr this_frame, void **this_cache)
+mips_insn16_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct mips_frame_cache *cache;
}
static void
-mips_insn16_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+mips_insn16_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct mips_frame_cache *info = mips_insn16_frame_cache (this_frame,
}
static struct value *
-mips_insn16_frame_prev_register (frame_info_ptr this_frame,
+mips_insn16_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct mips_frame_cache *info = mips_insn16_frame_cache (this_frame,
static int
mips_insn16_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame, void **this_cache)
+ const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
CORE_ADDR pc = get_frame_pc (this_frame);
};
static CORE_ADDR
-mips_insn16_frame_base_address (frame_info_ptr this_frame,
+mips_insn16_frame_base_address (const frame_info_ptr &this_frame,
void **this_cache)
{
struct mips_frame_cache *info = mips_insn16_frame_cache (this_frame,
};
static const struct frame_base *
-mips_insn16_frame_base_sniffer (frame_info_ptr this_frame)
+mips_insn16_frame_base_sniffer (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
CORE_ADDR pc = get_frame_pc (this_frame);
static CORE_ADDR
micromips_scan_prologue (struct gdbarch *gdbarch,
CORE_ADDR start_pc, CORE_ADDR limit_pc,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct mips_frame_cache *this_cache)
{
CORE_ADDR end_prologue_addr;
mips_insn32 unwinder. Likewise MIPS16 and the mips_insn16 unwinder. */
static struct mips_frame_cache *
-mips_micro_frame_cache (frame_info_ptr this_frame, void **this_cache)
+mips_micro_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct mips_frame_cache *cache;
}
static void
-mips_micro_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+mips_micro_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct mips_frame_cache *info = mips_micro_frame_cache (this_frame,
}
static struct value *
-mips_micro_frame_prev_register (frame_info_ptr this_frame,
+mips_micro_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct mips_frame_cache *info = mips_micro_frame_cache (this_frame,
static int
mips_micro_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame, void **this_cache)
+ const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
CORE_ADDR pc = get_frame_pc (this_frame);
};
static CORE_ADDR
-mips_micro_frame_base_address (frame_info_ptr this_frame,
+mips_micro_frame_base_address (const frame_info_ptr &this_frame,
void **this_cache)
{
struct mips_frame_cache *info = mips_micro_frame_cache (this_frame,
};
static const struct frame_base *
-mips_micro_frame_base_sniffer (frame_info_ptr this_frame)
+mips_micro_frame_base_sniffer (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
CORE_ADDR pc = get_frame_pc (this_frame);
static CORE_ADDR
mips32_scan_prologue (struct gdbarch *gdbarch,
CORE_ADDR start_pc, CORE_ADDR limit_pc,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct mips_frame_cache *this_cache)
{
int prev_non_prologue_insn;
unwinder. Likewise microMIPS and the mips_micro unwinder. */
static struct mips_frame_cache *
-mips_insn32_frame_cache (frame_info_ptr this_frame, void **this_cache)
+mips_insn32_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct mips_frame_cache *cache;
}
static void
-mips_insn32_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+mips_insn32_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct mips_frame_cache *info = mips_insn32_frame_cache (this_frame,
}
static struct value *
-mips_insn32_frame_prev_register (frame_info_ptr this_frame,
+mips_insn32_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct mips_frame_cache *info = mips_insn32_frame_cache (this_frame,
static int
mips_insn32_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame, void **this_cache)
+ const frame_info_ptr &this_frame, void **this_cache)
{
CORE_ADDR pc = get_frame_pc (this_frame);
if (mips_pc_is_mips (pc))
};
static CORE_ADDR
-mips_insn32_frame_base_address (frame_info_ptr this_frame,
+mips_insn32_frame_base_address (const frame_info_ptr &this_frame,
void **this_cache)
{
struct mips_frame_cache *info = mips_insn32_frame_cache (this_frame,
};
static const struct frame_base *
-mips_insn32_frame_base_sniffer (frame_info_ptr this_frame)
+mips_insn32_frame_base_sniffer (const frame_info_ptr &this_frame)
{
CORE_ADDR pc = get_frame_pc (this_frame);
if (mips_pc_is_mips (pc))
}
static struct trad_frame_cache *
-mips_stub_frame_cache (frame_info_ptr this_frame, void **this_cache)
+mips_stub_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
CORE_ADDR pc;
CORE_ADDR start_addr;
}
static void
-mips_stub_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+mips_stub_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct trad_frame_cache *this_trad_cache
}
static struct value *
-mips_stub_frame_prev_register (frame_info_ptr this_frame,
+mips_stub_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct trad_frame_cache *this_trad_cache
static int
mips_stub_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame, void **this_cache)
+ const frame_info_ptr &this_frame, void **this_cache)
{
gdb_byte dummy[4];
CORE_ADDR pc = get_frame_address_in_block (this_frame);
};
static CORE_ADDR
-mips_stub_frame_base_address (frame_info_ptr this_frame,
+mips_stub_frame_base_address (const frame_info_ptr &this_frame,
void **this_cache)
{
struct trad_frame_cache *this_trad_cache
};
static const struct frame_base *
-mips_stub_frame_base_sniffer (frame_info_ptr this_frame)
+mips_stub_frame_base_sniffer (const frame_info_ptr &this_frame)
{
if (mips_stub_frame_sniffer (&mips_stub_frame_unwind, this_frame, NULL))
return &mips_stub_frame_base;
into rare_buffer. */
static void
-mips_read_fp_register_single (frame_info_ptr frame, int regno,
+mips_read_fp_register_single (const frame_info_ptr &frame, int regno,
gdb_byte *rare_buffer)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
register. */
static void
-mips_read_fp_register_double (frame_info_ptr frame, int regno,
+mips_read_fp_register_double (const frame_info_ptr &frame, int regno,
gdb_byte *rare_buffer)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
}
static void
-mips_print_fp_register (struct ui_file *file, frame_info_ptr frame,
+mips_print_fp_register (struct ui_file *file, const frame_info_ptr &frame,
int regnum)
{ /* Do values for FP (float) regs. */
struct gdbarch *gdbarch = get_frame_arch (frame);
}
static void
-mips_print_register (struct ui_file *file, frame_info_ptr frame,
+mips_print_register (struct ui_file *file, const frame_info_ptr &frame,
int regnum)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
static void
mips_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
- frame_info_ptr frame, const char *args)
+ const frame_info_ptr &frame, const char *args)
{
int fcsr = mips_regnum (gdbarch)->fp_control_status;
enum mips_fpu_type type = mips_get_fpu_type (gdbarch);
Print regs in pretty columns. */
static int
-print_fp_register_row (struct ui_file *file, frame_info_ptr frame,
+print_fp_register_row (struct ui_file *file, const frame_info_ptr &frame,
int regnum)
{
gdb_printf (file, " ");
/* Print a row's worth of GP (int) registers, with name labels above. */
static int
-print_gp_register_row (struct ui_file *file, frame_info_ptr frame,
+print_gp_register_row (struct ui_file *file, const frame_info_ptr &frame,
int start_regnum)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
static void
mips_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
- frame_info_ptr frame, int regnum, int all)
+ const frame_info_ptr &frame, int regnum, int all)
{
if (regnum != -1) /* Do one specified register. */
{
static int
mips_single_step_through_delay (struct gdbarch *gdbarch,
- frame_info_ptr frame)
+ const frame_info_ptr &frame)
{
CORE_ADDR pc = get_frame_pc (frame);
enum mips_isa isa;
The limit on the search is arbitrarily set to 20 instructions. FIXME. */
static CORE_ADDR
-mips_get_mips16_fn_stub_pc (frame_info_ptr frame, CORE_ADDR pc)
+mips_get_mips16_fn_stub_pc (const frame_info_ptr &frame, CORE_ADDR pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
gory details. */
static CORE_ADDR
-mips_skip_mips16_trampoline_code (frame_info_ptr frame, CORE_ADDR pc)
+mips_skip_mips16_trampoline_code (const frame_info_ptr &frame, CORE_ADDR pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
CORE_ADDR start_addr;
so that $t9 has the correct value at function entry. */
static CORE_ADDR
-mips_skip_pic_trampoline_code (frame_info_ptr frame, CORE_ADDR pc)
+mips_skip_pic_trampoline_code (const frame_info_ptr &frame, CORE_ADDR pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
}
static CORE_ADDR
-mips_skip_trampoline_code (frame_info_ptr frame, CORE_ADDR pc)
+mips_skip_trampoline_code (const frame_info_ptr &frame, CORE_ADDR pc)
{
CORE_ADDR requested_pc = pc;
CORE_ADDR target_pc;
}
static struct value *
-value_of_mips_user_reg (frame_info_ptr frame, const void *baton)
+value_of_mips_user_reg (const frame_info_ptr &frame, const void *baton)
{
const int *reg_p = (const int *) baton;
return value_of_register (*reg_p, get_next_frame_sentinel_okay (frame));
/* Return the expected next PC if FRAME is stopped at a syscall
instruction. */
- CORE_ADDR (*syscall_next_pc) (frame_info_ptr frame) = nullptr;
+ CORE_ADDR (*syscall_next_pc) (const frame_info_ptr &frame) = nullptr;
};
/* Register numbers of various important registers. */
static void
mips64obsd_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *cache,
CORE_ADDR func)
{
\f
static void
am33_linux_sigframe_cache_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func);
static void
am33_linux_sigframe_cache_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
use the current frame PC as the limit, then
invoke mn10300_analyze_prologue and return its result. */
static struct mn10300_prologue *
-mn10300_analyze_frame_prologue (frame_info_ptr this_frame,
+mn10300_analyze_frame_prologue (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
if (!*this_prologue_cache)
/* Given the next frame and a prologue cache, return this frame's
base. */
static CORE_ADDR
-mn10300_frame_base (frame_info_ptr this_frame, void **this_prologue_cache)
+mn10300_frame_base (const frame_info_ptr &this_frame, void **this_prologue_cache)
{
struct mn10300_prologue *p
= mn10300_analyze_frame_prologue (this_frame, this_prologue_cache);
}
static void
-mn10300_frame_this_id (frame_info_ptr this_frame,
+mn10300_frame_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
}
static struct value *
-mn10300_frame_prev_register (frame_info_ptr this_frame,
+mn10300_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
struct mn10300_prologue *p
/* Populate a moxie_frame_cache object for this_frame. */
static struct moxie_frame_cache *
-moxie_frame_cache (frame_info_ptr this_frame, void **this_cache)
+moxie_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct moxie_frame_cache *cache;
CORE_ADDR current_pc;
frame. This will be used to create a new GDB frame struct. */
static void
-moxie_frame_this_id (frame_info_ptr this_frame,
+moxie_frame_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache, struct frame_id *this_id)
{
struct moxie_frame_cache *cache = moxie_frame_cache (this_frame,
/* Get the value of register regnum in the previous stack frame. */
static struct value *
-moxie_frame_prev_register (frame_info_ptr this_frame,
+moxie_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
struct moxie_frame_cache *cache = moxie_frame_cache (this_frame,
/* Return the base address of this_frame. */
static CORE_ADDR
-moxie_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+moxie_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct moxie_frame_cache *cache = moxie_frame_cache (this_frame,
this_cache);
return that struct as the value of this function. */
static struct msp430_prologue *
-msp430_analyze_frame_prologue (frame_info_ptr this_frame,
+msp430_analyze_frame_prologue (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
if (!*this_prologue_cache)
/* Given a frame and a prologue cache, return this frame's base. */
static CORE_ADDR
-msp430_frame_base (frame_info_ptr this_frame, void **this_prologue_cache)
+msp430_frame_base (const frame_info_ptr &this_frame, void **this_prologue_cache)
{
struct msp430_prologue *p
= msp430_analyze_frame_prologue (this_frame, this_prologue_cache);
/* Implement the "frame_this_id" method for unwinding frames. */
static void
-msp430_this_id (frame_info_ptr this_frame,
+msp430_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache, struct frame_id *this_id)
{
*this_id = frame_id_build (msp430_frame_base (this_frame,
/* Implement the "frame_prev_register" method for unwinding frames. */
static struct value *
-msp430_prev_register (frame_info_ptr this_frame,
+msp430_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
struct msp430_prologue *p
/* Implement the "skip_trampoline_code" gdbarch method. */
static CORE_ADDR
-msp430_skip_trampoline_code (frame_info_ptr frame, CORE_ADDR pc)
+msp430_skip_trampoline_code (const frame_info_ptr &frame, CORE_ADDR pc)
{
struct bound_minimal_symbol bms;
const char *stub_name;
register. */
static struct value *
-value_of_nds32_reg (frame_info_ptr frame, const void *baton)
+value_of_nds32_reg (const frame_info_ptr &frame, const void *baton)
{
return value_of_register ((int) (intptr_t) baton,
get_next_frame_sentinel_okay (frame));
a pointer to the current nds32_frame_cache in *THIS_CACHE. */
static struct nds32_frame_cache *
-nds32_frame_cache (frame_info_ptr this_frame, void **this_cache)
+nds32_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct nds32_frame_cache *cache;
PC and the caller's SP when we were called. */
static void
-nds32_frame_this_id (frame_info_ptr this_frame,
+nds32_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache, struct frame_id *this_id)
{
struct nds32_frame_cache *cache = nds32_frame_cache (this_frame, this_cache);
/* Implement the "prev_register" frame_unwind method. */
static struct value *
-nds32_frame_prev_register (frame_info_ptr this_frame, void **this_cache,
+nds32_frame_prev_register (const frame_info_ptr &this_frame, void **this_cache,
int regnum)
{
struct nds32_frame_cache *cache = nds32_frame_cache (this_frame, this_cache);
/* Return the frame base address of *THIS_FRAME. */
static CORE_ADDR
-nds32_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+nds32_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct nds32_frame_cache *cache = nds32_frame_cache (this_frame, this_cache);
static int
nds32_epilogue_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame, void **this_cache)
+ const frame_info_ptr &this_frame, void **this_cache)
{
if (frame_relative_level (this_frame) == 0)
return nds32_stack_frame_destroyed_p (get_frame_arch (this_frame),
*THIS_CACHE. */
static struct nds32_frame_cache *
-nds32_epilogue_frame_cache (frame_info_ptr this_frame, void **this_cache)
+nds32_epilogue_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct nds32_frame_cache *cache;
/* Implement the "this_id" frame_unwind method. */
static void
-nds32_epilogue_frame_this_id (frame_info_ptr this_frame,
+nds32_epilogue_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache, struct frame_id *this_id)
{
struct nds32_frame_cache *cache
/* Implement the "prev_register" frame_unwind method. */
static struct value *
-nds32_epilogue_frame_prev_register (frame_info_ptr this_frame,
+nds32_epilogue_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct nds32_frame_cache *cache
/* Implement the "get_longjmp_target" gdbarch method. */
static int
-nds32_get_longjmp_target (frame_info_ptr frame, CORE_ADDR *pc)
+nds32_get_longjmp_target (const frame_info_ptr &frame, CORE_ADDR *pc)
{
gdb_byte buf[4];
CORE_ADDR jb_addr;
static void
nios2_linux_rt_sigreturn_init (const struct tramp_frame *self,
- frame_info_ptr next_frame,
+ const frame_info_ptr &next_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
instruction to be executed. */
static CORE_ADDR
-nios2_linux_syscall_next_pc (frame_info_ptr frame,
+nios2_linux_syscall_next_pc (const frame_info_ptr &frame,
const struct nios2_opcode *op)
{
CORE_ADDR pc = get_frame_pc (frame);
nios2_analyze_prologue (struct gdbarch *gdbarch, const CORE_ADDR start_pc,
const CORE_ADDR current_pc,
struct nios2_unwind_cache *cache,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
/* Maximum number of possibly-prologue instructions to check.
Note that this number should not be too large, else we can
/* Implement the unwind_pc gdbarch method. */
static CORE_ADDR
-nios2_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
+nios2_unwind_pc (struct gdbarch *gdbarch, const frame_info_ptr &next_frame)
{
gdb_byte buf[4];
*THIS_PROLOGUE_CACHE first. */
static struct nios2_unwind_cache *
-nios2_frame_unwind_cache (frame_info_ptr this_frame,
+nios2_frame_unwind_cache (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
/* Implement the this_id function for the normal unwinder. */
static void
-nios2_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+nios2_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct nios2_unwind_cache *cache =
/* Implement the prev_register function for the normal unwinder. */
static struct value *
-nios2_frame_prev_register (frame_info_ptr this_frame, void **this_cache,
+nios2_frame_prev_register (const frame_info_ptr &this_frame, void **this_cache,
int regnum)
{
struct nios2_unwind_cache *cache =
for the normal unwinder. */
static CORE_ADDR
-nios2_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+nios2_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct nios2_unwind_cache *info
= nios2_frame_unwind_cache (this_frame, this_cache);
in the stub unwinder. */
static struct trad_frame_cache *
-nios2_stub_frame_cache (frame_info_ptr this_frame, void **this_cache)
+nios2_stub_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
CORE_ADDR pc;
CORE_ADDR start_addr;
/* Implement the this_id function for the stub unwinder. */
static void
-nios2_stub_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+nios2_stub_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct trad_frame_cache *this_trad_cache
/* Implement the prev_register function for the stub unwinder. */
static struct value *
-nios2_stub_frame_prev_register (frame_info_ptr this_frame,
+nios2_stub_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct trad_frame_cache *this_trad_cache
static int
nios2_stub_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame, void **cache)
+ const frame_info_ptr &this_frame, void **cache)
{
gdb_byte dummy[4];
CORE_ADDR pc = get_frame_address_in_block (this_frame);
/* Implement the get_longjump_target gdbarch method. */
static int
-nios2_get_longjmp_target (frame_info_ptr frame, CORE_ADDR *pc)
+nios2_get_longjmp_target (const frame_info_ptr &frame, CORE_ADDR *pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
nios2_gdbarch_tdep *tdep = gdbarch_tdep<nios2_gdbarch_tdep> (gdbarch);
{
/* Assumes FRAME is stopped at a syscall (trap) instruction; returns
the expected next PC. */
- CORE_ADDR (*syscall_next_pc) (frame_info_ptr frame,
+ CORE_ADDR (*syscall_next_pc) (const frame_info_ptr &frame,
const struct nios2_opcode *op) = nullptr;
/* Returns true if PC points to a kernel helper function. */
inferior_call_post;
/* A register in the inferior has been modified by the gdb user. */
-extern observable<frame_info_ptr /* frame */, int /* regnum */>
+extern observable<const frame_info_ptr &/* frame */, int /* regnum */>
register_changed;
/* The user-selected inferior, thread and/or frame has changed. The
/* Signal trampoline support. */
static void or1k_linux_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func);
static void
or1k_linux_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
static int
or1k_single_step_through_delay (struct gdbarch *gdbarch,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
ULONGEST val;
CORE_ADDR ppc;
/* Implement the unwind_pc gdbarch method. */
static CORE_ADDR
-or1k_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
+or1k_unwind_pc (struct gdbarch *gdbarch, const frame_info_ptr &next_frame)
{
CORE_ADDR pc;
/* Implement the unwind_sp gdbarch method. */
static CORE_ADDR
-or1k_unwind_sp (struct gdbarch *gdbarch, frame_info_ptr next_frame)
+or1k_unwind_sp (struct gdbarch *gdbarch, const frame_info_ptr &next_frame)
{
CORE_ADDR sp;
Reportedly, this is only valid for frames less than 0x7fff in size. */
static struct trad_frame_cache *
-or1k_frame_cache (frame_info_ptr this_frame, void **prologue_cache)
+or1k_frame_cache (const frame_info_ptr &this_frame, void **prologue_cache)
{
struct gdbarch *gdbarch;
struct trad_frame_cache *info;
/* Implement the this_id function for the stub unwinder. */
static void
-or1k_frame_this_id (frame_info_ptr this_frame,
+or1k_frame_this_id (const frame_info_ptr &this_frame,
void **prologue_cache, struct frame_id *this_id)
{
struct trad_frame_cache *info = or1k_frame_cache (this_frame,
/* Implement the prev_register function for the stub unwinder. */
static struct value *
-or1k_frame_prev_register (frame_info_ptr this_frame,
+or1k_frame_prev_register (const frame_info_ptr &this_frame,
void **prologue_cache, int regnum)
{
struct trad_frame_cache *info = or1k_frame_cache (this_frame,
static int
ppcfbsd_sigtramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
static struct trad_frame_cache *
-ppcfbsd_sigtramp_frame_cache (frame_info_ptr this_frame, void **this_cache)
+ppcfbsd_sigtramp_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
}
static void
-ppcfbsd_sigtramp_frame_this_id (frame_info_ptr this_frame,
+ppcfbsd_sigtramp_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache, struct frame_id *this_id)
{
struct trad_frame_cache *cache =
}
static struct value *
-ppcfbsd_sigtramp_frame_prev_register (frame_info_ptr this_frame,
+ppcfbsd_sigtramp_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct trad_frame_cache *cache =
stub sequence. */
static CORE_ADDR
-ppc_skip_trampoline_code (frame_info_ptr frame, CORE_ADDR pc)
+ppc_skip_trampoline_code (const frame_info_ptr &frame, CORE_ADDR pc)
{
unsigned int insnbuf[POWERPC32_PLT_CHECK_LEN];
struct gdbarch *gdbarch = get_frame_arch (frame);
}
static void
-ppc_linux_sigtramp_cache (frame_info_ptr this_frame,
+ppc_linux_sigtramp_cache (const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func, LONGEST offset,
int bias)
static void
ppc32_linux_sigaction_cache_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
static void
ppc64_linux_sigaction_cache_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
static void
ppc32_linux_sighandler_cache_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
static void
ppc64_linux_sighandler_cache_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
static void
ppcnbsd_sigtramp_cache_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
static int
ppcobsd_sigtramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
static struct trad_frame_cache *
-ppcobsd_sigtramp_frame_cache (frame_info_ptr this_frame, void **this_cache)
+ppcobsd_sigtramp_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
}
static void
-ppcobsd_sigtramp_frame_this_id (frame_info_ptr this_frame,
+ppcobsd_sigtramp_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache, struct frame_id *this_id)
{
struct trad_frame_cache *cache =
}
static struct value *
-ppcobsd_sigtramp_frame_prev_register (frame_info_ptr this_frame,
+ppcobsd_sigtramp_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct trad_frame_cache *cache =
}
CORE_ADDR
-ppc_sysv_get_return_buf_addr (struct type *val_type, frame_info_ptr cur_frame)
+ppc_sysv_get_return_buf_addr (struct type *val_type,
+ const frame_info_ptr &cur_frame)
{
/* The PowerPC ABI specifies aggregates that are not returned by value
are returned in a storage buffer provided by the caller. The
/* Implementation of the gdbarch get_return_buf_addr hook. */
-extern CORE_ADDR ppc_sysv_get_return_buf_addr (type*, frame_info_ptr);
+extern CORE_ADDR ppc_sysv_get_return_buf_addr (type*, const frame_info_ptr &);
/* Private data that this module attaches to struct gdbarch. */
int optional; /* If non-zero, this insn may be absent. */
};
-extern int ppc_insns_match_pattern (frame_info_ptr frame, CORE_ADDR pc,
+extern int ppc_insns_match_pattern (const frame_info_ptr &frame, CORE_ADDR pc,
const struct ppc_insn_pattern *pattern,
unsigned int *insns);
extern CORE_ADDR ppc_insn_d_field (unsigned int insn);
Return the function's entry point. */
static CORE_ADDR
-ppc64_plt_entry_point (frame_info_ptr frame, CORE_ADDR plt_off)
+ppc64_plt_entry_point (const frame_info_ptr &frame, CORE_ADDR plt_off)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
}
static CORE_ADDR
-ppc64_plt_pcrel_entry_point (frame_info_ptr frame, CORE_ADDR plt_off,
+ppc64_plt_pcrel_entry_point (const frame_info_ptr &frame, CORE_ADDR plt_off,
CORE_ADDR pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
dynamic linker lazy symbol resolution stubs.) */
static CORE_ADDR
-ppc64_standard_linkage1_target (frame_info_ptr frame, unsigned int *insn)
+ppc64_standard_linkage1_target (const frame_info_ptr &frame, unsigned int *insn)
{
CORE_ADDR plt_off = ((ppc_insn_d_field (insn[0]) << 16)
+ ppc_insn_ds_field (insn[2]));
}
static CORE_ADDR
-ppc64_standard_linkage2_target (frame_info_ptr frame, unsigned int *insn)
+ppc64_standard_linkage2_target (const frame_info_ptr &frame, unsigned int *insn)
{
CORE_ADDR plt_off = ((ppc_insn_d_field (insn[1]) << 16)
+ ppc_insn_ds_field (insn[3]));
}
static CORE_ADDR
-ppc64_standard_linkage3_target (frame_info_ptr frame, unsigned int *insn)
+ppc64_standard_linkage3_target (const frame_info_ptr &frame, unsigned int *insn)
{
CORE_ADDR plt_off = ppc_insn_ds_field (insn[1]);
}
static CORE_ADDR
-ppc64_standard_linkage4_target (frame_info_ptr frame, unsigned int *insn)
+ppc64_standard_linkage4_target (const frame_info_ptr &frame, unsigned int *insn)
{
CORE_ADDR plt_off = ((ppc_insn_d_field (insn[1]) << 16)
+ ppc_insn_ds_field (insn[2]));
}
static CORE_ADDR
-ppc64_pcrel_linkage1_target (frame_info_ptr frame, unsigned int *insn,
+ppc64_pcrel_linkage1_target (const frame_info_ptr &frame, unsigned int *insn,
CORE_ADDR pc)
{
/* insn[0] is for the std instruction. */
}
static CORE_ADDR
-ppc64_pcrel_linkage2_target (frame_info_ptr frame, unsigned int *insn,
+ppc64_pcrel_linkage2_target (const frame_info_ptr &frame, unsigned int *insn,
CORE_ADDR pc)
{
CORE_ADDR plt_off;
check whether we are in the middle of a PLT stub. */
static CORE_ADDR
-ppc64_skip_trampoline_code_1 (frame_info_ptr frame, CORE_ADDR pc)
+ppc64_skip_trampoline_code_1 (const frame_info_ptr &frame, CORE_ADDR pc)
{
#define MAX(a,b) ((a) > (b) ? (a) : (b))
unsigned int insns[MAX (MAX (MAX (ARRAY_SIZE (ppc64_standard_linkage1),
ppc_elfv2_skip_entrypoint. */
CORE_ADDR
-ppc64_skip_trampoline_code (frame_info_ptr frame, CORE_ADDR pc)
+ppc64_skip_trampoline_code (const frame_info_ptr &frame, CORE_ADDR pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
class frame_info_ptr;
struct target_ops;
-extern CORE_ADDR ppc64_skip_trampoline_code (frame_info_ptr frame,
+extern CORE_ADDR ppc64_skip_trampoline_code (const frame_info_ptr &frame,
CORE_ADDR pc);
extern CORE_ADDR ppc64_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
void
print_variable_and_value (const char *name, struct symbol *var,
- frame_info_ptr frame,
+ const frame_info_ptr &frame,
struct ui_file *stream, int indent)
{
/* See comments in probe.h. */
struct value *
-probe_safe_evaluate_at_pc (frame_info_ptr frame, unsigned n)
+probe_safe_evaluate_at_pc (const frame_info_ptr &frame, unsigned n)
{
struct bound_probe probe;
unsigned n_args;
corresponding to it. The argument number is represented N.
This function can throw an exception. */
virtual struct value *evaluate_argument (unsigned n,
- frame_info_ptr frame) = 0;
+ const frame_info_ptr &frame) = 0;
/* Compile the Nth argument of the probe to an agent expression.
The argument number is represented by N. */
probe at that location, or if the probe does not have enough arguments,
this returns NULL. */
-extern struct value *probe_safe_evaluate_at_pc (frame_info_ptr frame,
+extern struct value *probe_safe_evaluate_at_pc (const frame_info_ptr &frame,
unsigned n);
/* Return true if the PROVIDER/NAME probe from OBJFILE_NAME needs to be
extern int emit_inferior_call_event (inferior_call_kind kind,
ptid_t thread, CORE_ADDR addr);
-extern int emit_register_changed_event (frame_info_ptr frame,
+extern int emit_register_changed_event (const frame_info_ptr &frame,
int regnum);
extern int emit_memory_changed_event (CORE_ADDR addr, ssize_t len);
extern int evpy_emit_event (PyObject *event,
Sets a Python exception and returns NULL on error. */
PyObject *
-frame_info_to_frame_object (frame_info_ptr frame)
+frame_info_to_frame_object (const frame_info_ptr &frame)
{
gdbpy_ref<frame_object> frame_obj (PyObject_New (frame_object,
&frame_object_type));
enum ext_lang_frame_args args_type,
bool raw_frame_args,
int print_args_field,
- frame_info_ptr frame)
+ const frame_info_ptr &frame)
{
struct value_print_options opts;
int indent,
enum ext_lang_frame_args args_type,
int print_args_field,
- frame_info_ptr frame)
+ const frame_info_ptr &frame)
{
struct value_print_options opts;
py_mi_print_variables (PyObject *filter, struct ui_out *out,
struct value_print_options *opts,
enum ext_lang_frame_args args_type,
- frame_info_ptr frame,
+ const frame_info_ptr &frame,
bool raw_frame_args_p)
{
gdbpy_ref<> args_iter (get_py_iter_from_func (filter, "frame_args"));
struct ui_out *out,
enum ext_lang_frame_args args_type,
int indent,
- frame_info_ptr frame)
+ const frame_info_ptr &frame)
{
gdbpy_ref<> locals_iter (get_py_iter_from_func (filter, "frame_locals"));
if (locals_iter == NULL)
struct ui_out *out,
enum ext_lang_frame_args args_type,
bool raw_frame_args,
- frame_info_ptr frame)
+ const frame_info_ptr &frame)
{
gdbpy_ref<> args_iter (get_py_iter_from_func (filter, "frame_args"));
if (args_iter == NULL)
frame FRAME. */
static PyObject *
-bootstrap_python_frame_filters (frame_info_ptr frame,
+bootstrap_python_frame_filters (const frame_info_ptr &frame,
int frame_low, int frame_high)
{
gdbpy_ref<> frame_obj (frame_info_to_frame_object (frame));
enum ext_lang_bt_status
gdbpy_apply_frame_filter (const struct extension_language_defn *extlang,
- frame_info_ptr frame, frame_filter_flags flags,
+ const frame_info_ptr &frame, frame_filter_flags flags,
enum ext_lang_frame_args args_type,
struct ui_out *out, int frame_low, int frame_high)
{
command). */
static void
-python_on_register_change (frame_info_ptr frame, int regnum)
+python_on_register_change (const frame_info_ptr &frame, int regnum)
{
gdbpy_enter enter_py (current_inferior ()->arch ());
register number. */
static gdbpy_ref<>
-create_register_changed_event_object (frame_info_ptr frame,
+create_register_changed_event_object (const frame_info_ptr &frame,
int regnum)
{
gdbpy_ref<> event = create_event_object (®ister_changed_event_object_type);
will create a new Python register changed event object. */
int
-emit_register_changed_event (frame_info_ptr frame, int regnum)
+emit_register_changed_event (const frame_info_ptr &frame, int regnum)
{
if (evregpy_no_listeners_p (gdb_py_events.register_changed))
return 0;
/* frame_unwind.this_id method. */
static void
-pyuw_this_id (frame_info_ptr this_frame, void **cache_ptr,
+pyuw_this_id (const frame_info_ptr &this_frame, void **cache_ptr,
struct frame_id *this_id)
{
*this_id = ((cached_frame_info *) *cache_ptr)->frame_id;
/* frame_unwind.prev_register. */
static struct value *
-pyuw_prev_register (frame_info_ptr this_frame, void **cache_ptr,
+pyuw_prev_register (const frame_info_ptr &this_frame, void **cache_ptr,
int regnum)
{
PYUW_SCOPED_DEBUG_ENTER_EXIT;
/* Frame sniffer dispatch. */
static int
-pyuw_sniffer (const struct frame_unwind *self, frame_info_ptr this_frame,
+pyuw_sniffer (const struct frame_unwind *self, const frame_info_ptr &this_frame,
void **cache_ptr)
{
PYUW_SCOPED_DEBUG_ENTER_EXIT;
const struct language_defn *language);
extern enum ext_lang_bt_status gdbpy_apply_frame_filter
(const struct extension_language_defn *,
- frame_info_ptr frame, frame_filter_flags flags,
+ const frame_info_ptr &frame, frame_filter_flags flags,
enum ext_lang_frame_args args_type,
struct ui_out *out, int frame_low, int frame_high);
extern void gdbpy_preserve_values (const struct extension_language_defn *,
struct objfile *objfile);
PyObject *value_to_value_object (struct value *v);
PyObject *type_to_type_object (struct type *);
-PyObject *frame_info_to_frame_object (frame_info_ptr frame);
+PyObject *frame_info_to_frame_object (const frame_info_ptr &frame);
PyObject *symtab_to_linetable_object (PyObject *symtab);
gdbpy_ref<> pspace_to_pspace_object (struct program_space *);
PyObject *pspy_get_printers (PyObject *, void *);
/* Create a new btrace frame cache. */
static struct btrace_frame_cache *
-bfcache_new (frame_info_ptr frame)
+bfcache_new (const frame_info_ptr &frame)
{
struct btrace_frame_cache *cache;
void **slot;
/* Extract the branch trace function from a branch trace frame. */
static const struct btrace_function *
-btrace_get_frame_function (frame_info_ptr frame)
+btrace_get_frame_function (const frame_info_ptr &frame)
{
const struct btrace_frame_cache *cache;
struct btrace_frame_cache pattern;
/* Implement stop_reason method for record_btrace_frame_unwind. */
static enum unwind_stop_reason
-record_btrace_frame_unwind_stop_reason (frame_info_ptr this_frame,
+record_btrace_frame_unwind_stop_reason (const frame_info_ptr &this_frame,
void **this_cache)
{
const struct btrace_frame_cache *cache;
/* Implement this_id method for record_btrace_frame_unwind. */
static void
-record_btrace_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+record_btrace_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
const struct btrace_frame_cache *cache;
/* Implement prev_register method for record_btrace_frame_unwind. */
static struct value *
-record_btrace_frame_prev_register (frame_info_ptr this_frame,
+record_btrace_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache,
int regnum)
{
static int
record_btrace_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
const struct btrace_function *bfun;
static int
record_btrace_tailcall_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
const struct btrace_function *bfun, *callee;
static void
riscv_fbsd_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
/* Signal trampoline support. */
static void riscv_linux_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func);
static void
riscv_linux_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
instruction to be executed. */
static CORE_ADDR
-riscv_linux_syscall_next_pc (frame_info_ptr frame)
+riscv_linux_syscall_next_pc (const frame_info_ptr &frame)
{
const CORE_ADDR pc = get_frame_pc (frame);
const ULONGEST a7 = get_frame_register_unsigned (frame, RISCV_A7_REGNUM);
/* Callback function for user_reg_add. */
static struct value *
-value_of_riscv_user_reg (frame_info_ptr frame, const void *baton)
+value_of_riscv_user_reg (const frame_info_ptr &frame, const void *baton)
{
const int *reg_p = (const int *) baton;
return value_of_register (*reg_p, get_next_frame_sentinel_okay (frame));
static void
riscv_print_one_register_info (struct gdbarch *gdbarch,
struct ui_file *file,
- frame_info_ptr frame,
+ const frame_info_ptr &frame,
int regnum)
{
const char *name = gdbarch_register_name (gdbarch, regnum);
static void
riscv_print_registers_info (struct gdbarch *gdbarch,
struct ui_file *file,
- frame_info_ptr frame,
+ const frame_info_ptr &frame,
int regnum, int print_all)
{
if (regnum != -1)
unwinder. */
static struct riscv_unwind_cache *
-riscv_frame_cache (frame_info_ptr this_frame, void **this_cache)
+riscv_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
CORE_ADDR pc, start_addr;
struct riscv_unwind_cache *cache;
/* Implement the this_id callback for RiscV frame unwinder. */
static void
-riscv_frame_this_id (frame_info_ptr this_frame,
+riscv_frame_this_id (const frame_info_ptr &this_frame,
void **prologue_cache,
struct frame_id *this_id)
{
/* Implement the prev_register callback for RiscV frame unwinder. */
static struct value *
-riscv_frame_prev_register (frame_info_ptr this_frame,
+riscv_frame_prev_register (const frame_info_ptr &this_frame,
void **prologue_cache,
int regnum)
{
/* Return the expected next PC assuming FRAME is stopped at a syscall
instruction. */
- CORE_ADDR (*syscall_next_pc) (frame_info_ptr frame) = nullptr;
+ CORE_ADDR (*syscall_next_pc) (const frame_info_ptr &frame) = nullptr;
};
/* Implement the "unwind_pc" gdbarch method. */
static CORE_ADDR
-rl78_unwind_pc (struct gdbarch *arch, frame_info_ptr next_frame)
+rl78_unwind_pc (struct gdbarch *arch, const frame_info_ptr &next_frame)
{
return rl78_addr_bits_remove
(arch, frame_unwind_register_unsigned (next_frame,
return that struct as the value of this function. */
static struct rl78_prologue *
-rl78_analyze_frame_prologue (frame_info_ptr this_frame,
+rl78_analyze_frame_prologue (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
if (!*this_prologue_cache)
/* Given a frame and a prologue cache, return this frame's base. */
static CORE_ADDR
-rl78_frame_base (frame_info_ptr this_frame, void **this_prologue_cache)
+rl78_frame_base (const frame_info_ptr &this_frame, void **this_prologue_cache)
{
struct rl78_prologue *p
= rl78_analyze_frame_prologue (this_frame, this_prologue_cache);
/* Implement the "frame_this_id" method for unwinding frames. */
static void
-rl78_this_id (frame_info_ptr this_frame,
+rl78_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache, struct frame_id *this_id)
{
*this_id = frame_id_build (rl78_frame_base (this_frame,
/* Implement the "frame_prev_register" method for unwinding frames. */
static struct value *
-rl78_prev_register (frame_info_ptr this_frame,
+rl78_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
struct rl78_prologue *p
/* Implement the "dummy_id" gdbarch method. */
static struct frame_id
-rl78_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
+rl78_dummy_id (struct gdbarch *gdbarch, const frame_info_ptr &this_frame)
{
return
frame_id_build (rl78_make_data_address
};
static struct trad_frame_cache *
-aix_sighandle_frame_cache (frame_info_ptr this_frame,
+aix_sighandle_frame_cache (const frame_info_ptr &this_frame,
void **this_cache)
{
LONGEST backchain;
}
static void
-aix_sighandle_frame_this_id (frame_info_ptr this_frame,
+aix_sighandle_frame_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
}
static struct value *
-aix_sighandle_frame_prev_register (frame_info_ptr this_frame,
+aix_sighandle_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
struct trad_frame_cache *this_trad_cache
static int
aix_sighandle_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
CORE_ADDR pc = get_frame_pc (this_frame);
limit for the size of an epilogue. */
static int
-rs6000_in_function_epilogue_frame_p (frame_info_ptr curfrm,
+rs6000_in_function_epilogue_frame_p (const frame_info_ptr &curfrm,
struct gdbarch *gdbarch, CORE_ADDR pc)
{
ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
/* Get the ith function argument for the current function. */
static CORE_ADDR
-rs6000_fetch_pointer_argument (frame_info_ptr frame, int argi,
+rs6000_fetch_pointer_argument (const frame_info_ptr &frame, int argi,
struct type *type)
{
return get_frame_register_unsigned (frame, 3 + argi);
code that should be skipped. */
static CORE_ADDR
-rs6000_skip_trampoline_code (frame_info_ptr frame, CORE_ADDR pc)
+rs6000_skip_trampoline_code (const frame_info_ptr &frame, CORE_ADDR pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
}
static int
-rs6000_register_to_value (frame_info_ptr frame,
+rs6000_register_to_value (const frame_info_ptr &frame,
int regnum,
struct type *type,
gdb_byte *to,
}
static void
-rs6000_value_to_register (frame_info_ptr frame,
+rs6000_value_to_register (const frame_info_ptr &frame,
int regnum,
struct type *type,
const gdb_byte *from)
};
static struct rs6000_frame_cache *
-rs6000_frame_cache (frame_info_ptr this_frame, void **this_cache)
+rs6000_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct rs6000_frame_cache *cache;
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
static void
-rs6000_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+rs6000_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct rs6000_frame_cache *info = rs6000_frame_cache (this_frame,
}
static struct value *
-rs6000_frame_prev_register (frame_info_ptr this_frame,
+rs6000_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct rs6000_frame_cache *info = rs6000_frame_cache (this_frame,
SP is restored and prev-PC is stored in LR. */
static struct rs6000_frame_cache *
-rs6000_epilogue_frame_cache (frame_info_ptr this_frame, void **this_cache)
+rs6000_epilogue_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct rs6000_frame_cache *cache;
struct gdbarch *gdbarch = get_frame_arch (this_frame);
Return the frame ID of an epilogue frame. */
static void
-rs6000_epilogue_frame_this_id (frame_info_ptr this_frame,
+rs6000_epilogue_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache, struct frame_id *this_id)
{
CORE_ADDR pc;
Return the register value of REGNUM in previous frame. */
static struct value *
-rs6000_epilogue_frame_prev_register (frame_info_ptr this_frame,
+rs6000_epilogue_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct rs6000_frame_cache *info =
static int
rs6000_epilogue_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
if (frame_relative_level (this_frame) == 0)
\f
static CORE_ADDR
-rs6000_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+rs6000_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct rs6000_frame_cache *info = rs6000_frame_cache (this_frame,
this_cache);
};
static const struct frame_base *
-rs6000_frame_base_sniffer (frame_info_ptr this_frame)
+rs6000_frame_base_sniffer (const frame_info_ptr &this_frame)
{
return &rs6000_frame_base;
}
static void
ppc_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
struct dwarf2_frame_state_reg *reg,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
/* Read a PPC instruction from memory. */
static unsigned int
-read_insn (frame_info_ptr frame, CORE_ADDR pc)
+read_insn (const frame_info_ptr &frame, CORE_ADDR pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
necessarily the i'th instruction in memory. */
int
-ppc_insns_match_pattern (frame_info_ptr frame, CORE_ADDR pc,
+ppc_insns_match_pattern (const frame_info_ptr &frame, CORE_ADDR pc,
const struct ppc_insn_pattern *pattern,
unsigned int *insns)
{
return that struct as the value of this function. */
static struct rx_prologue *
-rx_analyze_frame_prologue (frame_info_ptr this_frame,
+rx_analyze_frame_prologue (const frame_info_ptr &this_frame,
enum rx_frame_type frame_type,
void **this_prologue_cache)
{
instruction. */
static enum rx_frame_type
-rx_frame_type (frame_info_ptr this_frame, void **this_cache)
+rx_frame_type (const frame_info_ptr &this_frame, void **this_cache)
{
const char *name;
CORE_ADDR pc, start_pc, lim_pc;
base. */
static CORE_ADDR
-rx_frame_base (frame_info_ptr this_frame, void **this_cache)
+rx_frame_base (const frame_info_ptr &this_frame, void **this_cache)
{
enum rx_frame_type frame_type = rx_frame_type (this_frame, this_cache);
struct rx_prologue *p
/* Implement the "frame_this_id" method for unwinding frames. */
static void
-rx_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+rx_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
*this_id = frame_id_build (rx_frame_base (this_frame, this_cache),
/* Implement the "frame_prev_register" method for unwinding frames. */
static struct value *
-rx_frame_prev_register (frame_info_ptr this_frame, void **this_cache,
+rx_frame_prev_register (const frame_info_ptr &this_frame, void **this_cache,
int regnum)
{
enum rx_frame_type frame_type = rx_frame_type (this_frame, this_cache);
static int
rx_frame_sniffer_common (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache,
int (*sniff_p)(enum rx_frame_type) )
{
static int
rx_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
return rx_frame_sniffer_common (self, this_frame, this_cache,
static int
rx_exception_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
return rx_frame_sniffer_common (self, this_frame, this_cache,
/* Initialize a prologue cache. */
static struct trad_frame_cache *
-s12z_frame_cache (frame_info_ptr this_frame, void **prologue_cache)
+s12z_frame_cache (const frame_info_ptr &this_frame, void **prologue_cache)
{
struct trad_frame_cache *info;
/* Implement the this_id function for the stub unwinder. */
static void
-s12z_frame_this_id (frame_info_ptr this_frame,
+s12z_frame_this_id (const frame_info_ptr &this_frame,
void **prologue_cache, struct frame_id *this_id)
{
struct trad_frame_cache *info = s12z_frame_cache (this_frame,
/* Implement the prev_register function for the stub unwinder. */
static struct value *
-s12z_frame_prev_register (frame_info_ptr this_frame,
+s12z_frame_prev_register (const frame_info_ptr &this_frame,
void **prologue_cache, int regnum)
{
struct trad_frame_cache *info = s12z_frame_cache (this_frame,
static void
s12z_print_ccw_info (struct gdbarch *gdbarch,
struct ui_file *file,
- frame_info_ptr frame,
+ const frame_info_ptr &frame,
int reg)
{
value *v = value_of_register (reg, get_next_frame_sentinel_okay (frame));
static void
s12z_print_registers_info (struct gdbarch *gdbarch,
struct ui_file *file,
- frame_info_ptr frame,
+ const frame_info_ptr &frame,
int regnum, int print_all)
{
const int numregs = (gdbarch_num_regs (gdbarch)
s390_sigtramp_frame_unwind. */
static struct s390_sigtramp_unwind_cache *
-s390_sigtramp_frame_unwind_cache (frame_info_ptr this_frame,
+s390_sigtramp_frame_unwind_cache (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
/* Implement this_id frame_unwind method for s390_sigtramp_frame_unwind. */
static void
-s390_sigtramp_frame_this_id (frame_info_ptr this_frame,
+s390_sigtramp_frame_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
/* Implement prev_register frame_unwind method for sigtramp frames. */
static struct value *
-s390_sigtramp_frame_prev_register (frame_info_ptr this_frame,
+s390_sigtramp_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
struct s390_sigtramp_unwind_cache *info
static int
s390_sigtramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
CORE_ADDR pc = get_frame_pc (this_frame);
breakpoint. */
static struct frame_id
-s390_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
+s390_dummy_id (struct gdbarch *gdbarch, const frame_info_ptr &this_frame)
{
int word_size = gdbarch_ptr_bit (gdbarch) / 8;
CORE_ADDR sp = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
/* Implement unwind_pc gdbarch method. */
static CORE_ADDR
-s390_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
+s390_unwind_pc (struct gdbarch *gdbarch, const frame_info_ptr &next_frame)
{
s390_gdbarch_tdep *tdep = gdbarch_tdep<s390_gdbarch_tdep> (gdbarch);
ULONGEST pc;
/* Implement unwind_sp gdbarch method. */
static CORE_ADDR
-s390_unwind_sp (struct gdbarch *gdbarch, frame_info_ptr next_frame)
+s390_unwind_sp (struct gdbarch *gdbarch, const frame_info_ptr &next_frame)
{
ULONGEST sp;
sp = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);
/* Helper routine to unwind pseudo registers. */
static struct value *
-s390_unwind_pseudo_register (frame_info_ptr this_frame, int regnum)
+s390_unwind_pseudo_register (const frame_info_ptr &this_frame, int regnum)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
s390_gdbarch_tdep *tdep = gdbarch_tdep<s390_gdbarch_tdep> (gdbarch);
s390_dwarf2_frame_init_reg. */
static struct value *
-s390_dwarf2_prev_register (frame_info_ptr this_frame, void **this_cache,
+s390_dwarf2_prev_register (const frame_info_ptr &this_frame, void **this_cache,
int regnum)
{
return s390_unwind_pseudo_register (this_frame, regnum);
static void
s390_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
struct dwarf2_frame_state_reg *reg,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
/* The condition code (and thus PSW mask) is call-clobbered. */
if (regnum == S390_PSWM_REGNUM)
register translation. */
struct value *
-s390_trad_frame_prev_register (frame_info_ptr this_frame,
+s390_trad_frame_prev_register (const frame_info_ptr &this_frame,
trad_frame_saved_reg saved_regs[],
int regnum)
{
prologue analysis. Helper for s390_frame_unwind_cache. */
static int
-s390_prologue_frame_unwind_cache (frame_info_ptr this_frame,
+s390_prologue_frame_unwind_cache (const frame_info_ptr &this_frame,
struct s390_unwind_cache *info)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
back chain unwinding. Helper for s390_frame_unwind_cache. */
static void
-s390_backchain_frame_unwind_cache (frame_info_ptr this_frame,
+s390_backchain_frame_unwind_cache (const frame_info_ptr &this_frame,
struct s390_unwind_cache *info)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
s390_frame_unwind and s390_frame_base. */
static struct s390_unwind_cache *
-s390_frame_unwind_cache (frame_info_ptr this_frame,
+s390_frame_unwind_cache (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
struct s390_unwind_cache *info;
/* Implement this_id frame_unwind method for s390_frame_unwind. */
static void
-s390_frame_this_id (frame_info_ptr this_frame,
+s390_frame_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
/* Implement prev_register frame_unwind method for s390_frame_unwind. */
static struct value *
-s390_frame_prev_register (frame_info_ptr this_frame,
+s390_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
struct s390_unwind_cache *info
s390_stub_frame_unwind. */
static struct s390_stub_unwind_cache *
-s390_stub_frame_unwind_cache (frame_info_ptr this_frame,
+s390_stub_frame_unwind_cache (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
/* Implement this_id frame_unwind method for s390_stub_frame_unwind. */
static void
-s390_stub_frame_this_id (frame_info_ptr this_frame,
+s390_stub_frame_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
/* Implement prev_register frame_unwind method for s390_stub_frame_unwind. */
static struct value *
-s390_stub_frame_prev_register (frame_info_ptr this_frame,
+s390_stub_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
struct s390_stub_unwind_cache *info
static int
s390_stub_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
CORE_ADDR addr_in_block;
/* Frame base handling. */
static CORE_ADDR
-s390_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+s390_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct s390_unwind_cache *info
= s390_frame_unwind_cache (this_frame, this_cache);
}
static CORE_ADDR
-s390_local_base_address (frame_info_ptr this_frame, void **this_cache)
+s390_local_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct s390_unwind_cache *info
= s390_frame_unwind_cache (this_frame, this_cache);
/* Frame unwinding. */
extern struct value *s390_trad_frame_prev_register
- (frame_info_ptr this_frame, struct trad_frame_saved_reg saved_regs[],
+ (const frame_info_ptr &this_frame, struct trad_frame_saved_reg saved_regs[],
int regnum);
extern const struct target_desc *tdesc_s390_linux32;
/* Here the register value is taken direct from the register cache. */
static struct value *
-sentinel_frame_prev_register (frame_info_ptr this_frame,
+sentinel_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache,
int regnum)
{
}
static void
-sentinel_frame_this_id (frame_info_ptr this_frame,
+sentinel_frame_this_id (const frame_info_ptr &this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
}
static struct gdbarch *
-sentinel_frame_prev_arch (frame_info_ptr this_frame,
+sentinel_frame_prev_arch (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
struct frame_unwind_cache *cache
/* SH signal handler frame support. */
static void
-sh_linux_sigtramp_cache (frame_info_ptr this_frame,
+sh_linux_sigtramp_cache (const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func, int regs_offset)
{
static void
sh_linux_sigreturn_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
static void
sh_linux_rt_sigreturn_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
static void
sh_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
struct dwarf2_frame_state_reg *reg,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
/* Mark the PC as the destination for the return address. */
if (regnum == gdbarch_pc_regnum (gdbarch))
}
static struct sh_frame_cache *
-sh_frame_cache (frame_info_ptr this_frame, void **this_cache)
+sh_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct sh_frame_cache *cache;
}
static struct value *
-sh_frame_prev_register (frame_info_ptr this_frame,
+sh_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
static void
-sh_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+sh_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct sh_frame_cache *cache = sh_frame_cache (this_frame, this_cache);
};
static CORE_ADDR
-sh_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+sh_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct sh_frame_cache *cache = sh_frame_cache (this_frame, this_cache);
};
static struct sh_frame_cache *
-sh_make_stub_cache (frame_info_ptr this_frame)
+sh_make_stub_cache (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct sh_frame_cache *cache;
}
static void
-sh_stub_this_id (frame_info_ptr this_frame, void **this_cache,
+sh_stub_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct sh_frame_cache *cache;
static int
sh_stub_unwind_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
CORE_ADDR addr_in_block;
/* Return whether THIS_FRAME corresponds to a Solaris sigtramp routine. */
int
-sol2_sigtramp_p (frame_info_ptr this_frame)
+sol2_sigtramp_p (const frame_info_ptr &this_frame)
{
CORE_ADDR pc = get_frame_pc (this_frame);
const char *name;
struct gdbarch;
-int sol2_sigtramp_p (frame_info_ptr this_frame);
+int sol2_sigtramp_p (const frame_info_ptr &this_frame);
void sol2_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch);
/* Signal trampoline support. */
static void sparc32_linux_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func);
static void
sparc32_linux_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
address. */
static CORE_ADDR
-sparc32_linux_step_trap (frame_info_ptr frame, unsigned long insn)
+sparc32_linux_step_trap (const frame_info_ptr &frame, unsigned long insn)
{
if (insn == 0x91d02010)
{
}
trad_frame_saved_reg *
-sparc32nbsd_sigcontext_saved_regs (frame_info_ptr this_frame)
+sparc32nbsd_sigcontext_saved_regs (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
trad_frame_saved_reg *saved_regs;
}
static struct sparc_frame_cache *
-sparc32nbsd_sigcontext_frame_cache (frame_info_ptr this_frame,
+sparc32nbsd_sigcontext_frame_cache (const frame_info_ptr &this_frame,
void **this_cache)
{
struct sparc_frame_cache *cache;
}
static void
-sparc32nbsd_sigcontext_frame_this_id (frame_info_ptr this_frame,
+sparc32nbsd_sigcontext_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-sparc32nbsd_sigcontext_frame_prev_register (frame_info_ptr this_frame,
+sparc32nbsd_sigcontext_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct sparc_frame_cache *cache =
static int
sparc32nbsd_sigcontext_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
CORE_ADDR pc = get_frame_pc (this_frame);
address. */
CORE_ADDR
-sparcnbsd_step_trap (frame_info_ptr frame, unsigned long insn)
+sparcnbsd_step_trap (const frame_info_ptr &frame, unsigned long insn)
{
if ((X_I (insn) == 0 && X_RS1 (insn) == 0 && X_RS2 (insn) == 0)
|| (X_I (insn) == 1 && X_RS1 (insn) == 0 && (insn & 0x7f) == 0))
}
static struct sparc_frame_cache *
-sparc32obsd_sigtramp_frame_cache (frame_info_ptr this_frame,
+sparc32obsd_sigtramp_frame_cache (const frame_info_ptr &this_frame,
void **this_cache)
{
struct sparc_frame_cache *cache;
}
static void
-sparc32obsd_sigtramp_frame_this_id (frame_info_ptr this_frame,
+sparc32obsd_sigtramp_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-sparc32obsd_sigtramp_frame_prev_register (frame_info_ptr this_frame,
+sparc32obsd_sigtramp_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct sparc_frame_cache *cache =
static int
sparc32obsd_sigtramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
CORE_ADDR pc = get_frame_pc (this_frame);
\f
static struct sparc_frame_cache *
-sparc32_sol2_sigtramp_frame_cache (frame_info_ptr this_frame,
+sparc32_sol2_sigtramp_frame_cache (const frame_info_ptr &this_frame,
void **this_cache)
{
struct sparc_frame_cache *cache;
}
static void
-sparc32_sol2_sigtramp_frame_this_id (frame_info_ptr this_frame,
+sparc32_sol2_sigtramp_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-sparc32_sol2_sigtramp_frame_prev_register (frame_info_ptr this_frame,
+sparc32_sol2_sigtramp_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache,
int regnum)
{
static int
sparc32_sol2_sigtramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
return sol2_sigtramp_p (this_frame);
/* Normal frames. */
struct sparc_frame_cache *
-sparc_frame_cache (frame_info_ptr this_frame, void **this_cache)
+sparc_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct sparc_frame_cache *cache;
}
struct sparc_frame_cache *
-sparc32_frame_cache (frame_info_ptr this_frame, void **this_cache)
+sparc32_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct sparc_frame_cache *cache;
struct symbol *sym;
}
static void
-sparc32_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+sparc32_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct sparc_frame_cache *cache =
}
static struct value *
-sparc32_frame_prev_register (frame_info_ptr this_frame,
+sparc32_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
\f
static CORE_ADDR
-sparc32_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+sparc32_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct sparc_frame_cache *cache =
sparc32_frame_cache (this_frame, this_cache);
};
static struct frame_id
-sparc_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
+sparc_dummy_id (struct gdbarch *gdbarch, const frame_info_ptr &this_frame)
{
CORE_ADDR sp;
}
static int
-sparc32_dwarf2_struct_return_p (frame_info_ptr this_frame)
+sparc32_dwarf2_struct_return_p (const frame_info_ptr &this_frame)
{
CORE_ADDR pc = get_frame_address_in_block (this_frame);
struct symbol *sym = find_pc_function (pc);
static void
sparc32_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
struct dwarf2_frame_state_reg *reg,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
int off;
}
static CORE_ADDR
-sparc_step_trap (frame_info_ptr frame, unsigned long insn)
+sparc_step_trap (const frame_info_ptr &frame, unsigned long insn)
{
return 0;
}
size_t plt_entry_size = 0;
/* Alternative location for trap return. Used for single-stepping. */
- CORE_ADDR (*step_trap) (frame_info_ptr frame, unsigned long insn)
+ CORE_ADDR (*step_trap) (const frame_info_ptr &frame, unsigned long insn)
= nullptr;
/* ISA-specific data types. */
struct sparc_frame_cache *cache);
extern struct sparc_frame_cache *
- sparc_frame_cache (frame_info_ptr this_frame, void **this_cache);
+ sparc_frame_cache (const frame_info_ptr &this_frame, void **this_cache);
extern struct sparc_frame_cache *
- sparc32_frame_cache (frame_info_ptr this_frame, void **this_cache);
+ sparc32_frame_cache (const frame_info_ptr &this_frame, void **this_cache);
extern int
sparc_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc);
/* Return the address of a system call's alternative return
address. */
-extern CORE_ADDR sparcnbsd_step_trap (frame_info_ptr frame,
+extern CORE_ADDR sparcnbsd_step_trap (const frame_info_ptr &frame,
unsigned long insn);
extern void sparc32nbsd_init_abi (struct gdbarch_info info,
struct gdbarch *gdbarch);
extern struct trad_frame_saved_reg *
- sparc32nbsd_sigcontext_saved_regs (frame_info_ptr next_frame);
+ sparc32nbsd_sigcontext_saved_regs (const frame_info_ptr &next_frame);
#endif /* sparc-tdep.h */
}
static struct sparc_frame_cache *
-sparc64fbsd_sigtramp_frame_cache (frame_info_ptr this_frame,
+sparc64fbsd_sigtramp_frame_cache (const frame_info_ptr &this_frame,
void **this_cache)
{
struct sparc_frame_cache *cache;
}
static void
-sparc64fbsd_sigtramp_frame_this_id (frame_info_ptr this_frame,
+sparc64fbsd_sigtramp_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-sparc64fbsd_sigtramp_frame_prev_register (frame_info_ptr this_frame,
+sparc64fbsd_sigtramp_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct sparc_frame_cache *cache =
static int
sparc64fbsd_sigtramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
CORE_ADDR pc = get_frame_pc (this_frame);
/* Signal trampoline support. */
static void sparc64_linux_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func);
static void
sparc64_linux_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
address. */
static CORE_ADDR
-sparc64_linux_step_trap (frame_info_ptr frame, unsigned long insn)
+sparc64_linux_step_trap (const frame_info_ptr &frame, unsigned long insn)
{
/* __NR_rt_sigreturn is 101 */
if ((insn == 0x91d0206d)
/* Implement the "get_longjmp_target" gdbarch method. */
static int
-sparc64_linux_get_longjmp_target (frame_info_ptr frame, CORE_ADDR *pc)
+sparc64_linux_get_longjmp_target (const frame_info_ptr &frame, CORE_ADDR *pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
CORE_ADDR jb_addr;
trad_frame_saved_reg *
sparc64nbsd_sigcontext_saved_regs (CORE_ADDR sigcontext_addr,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
trad_frame_saved_reg *saved_regs;
}
static struct sparc_frame_cache *
-sparc64nbsd_sigcontext_frame_cache (frame_info_ptr this_frame,
+sparc64nbsd_sigcontext_frame_cache (const frame_info_ptr &this_frame,
void **this_cache)
{
struct sparc_frame_cache *cache;
}
static void
-sparc64nbsd_sigcontext_frame_this_id (frame_info_ptr this_frame,
+sparc64nbsd_sigcontext_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-sparc64nbsd_sigcontext_frame_prev_register (frame_info_ptr this_frame,
+sparc64nbsd_sigcontext_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct sparc_frame_cache *cache =
static int
sparc64nbsd_sigtramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
CORE_ADDR pc = get_frame_pc (this_frame);
}
static struct sparc_frame_cache *
-sparc64obsd_frame_cache (frame_info_ptr this_frame, void **this_cache)
+sparc64obsd_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct sparc_frame_cache *cache;
CORE_ADDR addr;
}
static void
-sparc64obsd_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+sparc64obsd_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct sparc_frame_cache *cache =
}
static struct value *
-sparc64obsd_frame_prev_register (frame_info_ptr this_frame,
+sparc64obsd_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct sparc_frame_cache *cache =
static int
sparc64obsd_sigtramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
CORE_ADDR pc = get_frame_pc (this_frame);
/* Kernel debugging support. */
static struct sparc_frame_cache *
-sparc64obsd_trapframe_cache (frame_info_ptr this_frame, void **this_cache)
+sparc64obsd_trapframe_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct sparc_frame_cache *cache;
CORE_ADDR sp, trapframe_addr;
}
static void
-sparc64obsd_trapframe_this_id (frame_info_ptr this_frame,
+sparc64obsd_trapframe_this_id (const frame_info_ptr &this_frame,
void **this_cache, struct frame_id *this_id)
{
struct sparc_frame_cache *cache =
}
static struct value *
-sparc64obsd_trapframe_prev_register (frame_info_ptr this_frame,
+sparc64obsd_trapframe_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct sparc_frame_cache *cache =
static int
sparc64obsd_trapframe_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
CORE_ADDR pc;
\f
static struct sparc_frame_cache *
-sparc64_sol2_sigtramp_frame_cache (frame_info_ptr this_frame,
+sparc64_sol2_sigtramp_frame_cache (const frame_info_ptr &this_frame,
void **this_cache)
{
struct sparc_frame_cache *cache;
}
static void
-sparc64_sol2_sigtramp_frame_this_id (frame_info_ptr this_frame,
+sparc64_sol2_sigtramp_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-sparc64_sol2_sigtramp_frame_prev_register (frame_info_ptr this_frame,
+sparc64_sol2_sigtramp_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache,
int regnum)
{
static int
sparc64_sol2_sigtramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
return sol2_sigtramp_p (this_frame);
/* Normal frames. */
static struct sparc_frame_cache *
-sparc64_frame_cache (frame_info_ptr this_frame, void **this_cache)
+sparc64_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
return sparc_frame_cache (this_frame, this_cache);
}
static void
-sparc64_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+sparc64_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct sparc_frame_cache *cache =
}
static struct value *
-sparc64_frame_prev_register (frame_info_ptr this_frame, void **this_cache,
+sparc64_frame_prev_register (const frame_info_ptr &this_frame, void **this_cache,
int regnum)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
\f
static CORE_ADDR
-sparc64_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+sparc64_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct sparc_frame_cache *cache =
sparc64_frame_cache (this_frame, this_cache);
static void
sparc64_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
struct dwarf2_frame_state_reg *reg,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
switch (regnum)
{
extern struct trad_frame_saved_reg *
sparc64nbsd_sigcontext_saved_regs (CORE_ADDR sigcontext_addr,
- frame_info_ptr next_frame);
+ const frame_info_ptr &next_frame);
extern const struct sparc_fpregmap sparc64_bsd_fpregmap;
/* Prototypes for local functions. */
-static void print_frame_local_vars (frame_info_ptr frame,
+static void print_frame_local_vars (const frame_info_ptr &frame,
bool quiet,
const char *regexp, const char *t_regexp,
int num_tabs, struct ui_file *stream);
static void print_frame (struct ui_out *uiout,
const frame_print_options &opts,
- frame_info_ptr frame, int print_level,
+ const frame_info_ptr &frame, int print_level,
enum print_what print_what, int print_args,
struct symtab_and_line sal);
/* See stack.h. */
bool
-frame_show_address (frame_info_ptr frame,
+frame_show_address (const frame_info_ptr &frame,
struct symtab_and_line sal)
{
/* If there is a line number, but no PC, then there is no location
/* See frame.h. */
void
-print_stack_frame_to_uiout (struct ui_out *uiout, frame_info_ptr frame,
+print_stack_frame_to_uiout (struct ui_out *uiout, const frame_info_ptr &frame,
int print_level, enum print_what print_what,
int set_current_sal)
{
source line, the actual PC is printed at the beginning. */
void
-print_stack_frame (frame_info_ptr frame, int print_level,
+print_stack_frame (const frame_info_ptr &frame, int print_level,
enum print_what print_what,
int set_current_sal)
{
argument (not just the first nameless argument). */
static void
-print_frame_nameless_args (frame_info_ptr frame, long start, int num,
+print_frame_nameless_args (const frame_info_ptr &frame, long start, int num,
int first, struct ui_file *stream)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
exception. */
void
-read_frame_local (struct symbol *sym, frame_info_ptr frame,
+read_frame_local (struct symbol *sym, const frame_info_ptr &frame,
struct frame_arg *argp)
{
argp->sym = sym;
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)
{
struct value *val = NULL, *entryval = NULL;
static void
print_frame_args (const frame_print_options &fp_opts,
- struct symbol *func, frame_info_ptr frame,
+ struct symbol *func, const frame_info_ptr &frame,
int num, struct ui_file *stream)
{
struct ui_out *uiout = current_uiout;
line is in the center of the next 'list'. */
void
-set_current_sal_from_frame (frame_info_ptr frame)
+set_current_sal_from_frame (const frame_info_ptr &frame)
{
symtab_and_line sal = find_frame_sal (frame);
if (sal.symtab != NULL)
/* Print the PC from FRAME, plus any flags, to UIOUT. */
static void
-print_pc (struct ui_out *uiout, struct gdbarch *gdbarch, frame_info_ptr frame,
+print_pc (struct ui_out *uiout, struct gdbarch *gdbarch, const frame_info_ptr &frame,
CORE_ADDR pc)
{
uiout->field_core_addr ("addr", gdbarch, pc);
static void
do_print_frame_info (struct ui_out *uiout, const frame_print_options &fp_opts,
- frame_info_ptr frame, int print_level,
+ const frame_info_ptr &frame, int print_level,
enum print_what print_what, int print_args,
int set_current_sal)
{
void
print_frame_info (const frame_print_options &fp_opts,
- frame_info_ptr frame, int print_level,
+ const frame_info_ptr &frame, int print_level,
enum print_what print_what, int print_args,
int set_current_sal)
{
corresponding to FRAME. */
gdb::unique_xmalloc_ptr<char>
-find_frame_funname (frame_info_ptr frame, enum language *funlang,
+find_frame_funname (const frame_info_ptr &frame, enum language *funlang,
struct symbol **funcp)
{
struct symbol *func;
static void
print_frame (struct ui_out *uiout,
const frame_print_options &fp_opts,
- frame_info_ptr frame, int print_level,
+ const frame_info_ptr &frame, int print_level,
enum print_what print_what, int print_args,
struct symtab_and_line sal)
{
level 1') then SELECTED_FRAME_P will be false. */
static void
-info_frame_command_core (frame_info_ptr fi, bool selected_frame_p)
+info_frame_command_core (const frame_info_ptr &fi, bool selected_frame_p)
{
struct symbol *func;
struct symtab *s;
SELECT_FRAME. */
static void
-select_frame_command_core (frame_info_ptr fi, bool ignored)
+select_frame_command_core (const frame_info_ptr &fi, bool ignored)
{
frame_info_ptr prev_frame = get_selected_frame ();
select_frame (fi);
reprint the current frame summary). */
static void
-frame_command_core (frame_info_ptr fi, bool ignored)
+frame_command_core (const frame_info_ptr &fi, bool ignored)
{
frame_info_ptr prev_frame = get_selected_frame ();
select_frame (fi);
'frame' will all cause SELECTED_FRAME_P to be true. In all other cases
SELECTED_FRAME_P is false. */
-template <void (*FPTR) (frame_info_ptr fi, bool selected_frame_p)>
+template <void (*FPTR) (const frame_info_ptr &fi, bool selected_frame_p)>
class frame_command_helper
{
public:
explaining why no local variables could be printed. */
static void
-print_frame_local_vars (frame_info_ptr frame,
+print_frame_local_vars (const frame_info_ptr &frame,
bool quiet,
const char *regexp, const char *t_regexp,
int num_tabs, struct ui_file *stream)
explaining why no argument variables could be printed. */
static void
-print_frame_arg_vars (frame_info_ptr frame,
+print_frame_arg_vars (const frame_info_ptr &frame,
bool quiet,
const char *regexp, const char *t_regexp,
struct ui_file *stream)
#ifndef STACK_H
#define STACK_H
-gdb::unique_xmalloc_ptr<char> find_frame_funname (frame_info_ptr frame,
+gdb::unique_xmalloc_ptr<char> find_frame_funname (const frame_info_ptr &frame,
enum language *funlang,
struct symbol **funcp);
/* Return true if we should display the address in addition to the location,
because we are in the middle of a statement. */
-bool frame_show_address (frame_info_ptr frame, struct symtab_and_line sal);
+bool frame_show_address (const frame_info_ptr &frame, struct symtab_and_line sal);
/* Forget the last sal we displayed. */
/* See probe.h. */
struct value *evaluate_argument (unsigned n,
- frame_info_ptr frame) override;
+ const frame_info_ptr &frame) override;
/* See probe.h. */
void compile_to_ax (struct agent_expr *aexpr,
corresponding to it. Assertion is thrown if N does not exist. */
struct value *
-stap_probe::evaluate_argument (unsigned n, frame_info_ptr frame)
+stap_probe::evaluate_argument (unsigned n, const frame_info_ptr &frame)
{
struct stap_probe_arg *arg;
struct gdbarch *gdbarch = get_frame_arch (frame);
#include "gdbarch.h"
static struct value *
-value_of_builtin_frame_fp_reg (frame_info_ptr frame, const void *baton)
+value_of_builtin_frame_fp_reg (const frame_info_ptr &frame, const void *baton)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
}
static struct value *
-value_of_builtin_frame_pc_reg (frame_info_ptr frame, const void *baton)
+value_of_builtin_frame_pc_reg (const frame_info_ptr &frame, const void *baton)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
}
static struct value *
-value_of_builtin_frame_sp_reg (frame_info_ptr frame, const void *baton)
+value_of_builtin_frame_sp_reg (const frame_info_ptr &frame, const void *baton)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
}
static struct value *
-value_of_builtin_frame_ps_reg (frame_info_ptr frame, const void *baton)
+value_of_builtin_frame_ps_reg (const frame_info_ptr &frame, const void *baton)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
FRAME may be zero. */
struct value *(*read_variable) (struct symbol * symbol,
- frame_info_ptr frame);
+ const frame_info_ptr &frame);
/* Read variable SYMBOL like read_variable at (callee) FRAME's function
entry. SYMBOL should be a function parameter, otherwise
NO_ENTRY_VALUE_ERROR will be thrown. */
struct value *(*read_variable_at_entry) (struct symbol *symbol,
- frame_info_ptr frame);
+ const frame_info_ptr &frame);
/* Find the "symbol_needs_kind" value for the given symbol. This
value determines whether reading the symbol needs memory (e.g., a
computed with DW_AT_static_link and this method must be used to compute
the corresponding DW_AT_frame_base attribute. */
CORE_ADDR (*get_frame_base) (struct symbol *framefunc,
- frame_info_ptr frame);
+ const frame_info_ptr &frame);
/* Return the block for this function. So far, this is used to
implement function aliases. So, if this is set, then it's not
extern const struct gnu_ifunc_fns *gnu_ifunc_fns_p;
-extern CORE_ADDR find_solib_trampoline_target (frame_info_ptr, CORE_ADDR);
+extern CORE_ADDR find_solib_trampoline_target (const frame_info_ptr &, CORE_ADDR);
struct symtab_and_line
{
static void
tic6x_linux_rt_sigreturn_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
instruction to be executed. */
static CORE_ADDR
-tic6x_linux_syscall_next_pc (frame_info_ptr frame)
+tic6x_linux_syscall_next_pc (const frame_info_ptr &frame)
{
ULONGEST syscall_number = get_frame_register_unsigned (frame,
TIC6X_B0_REGNUM);
tic6x_analyze_prologue (struct gdbarch *gdbarch, const CORE_ADDR start_pc,
const CORE_ADDR current_pc,
struct tic6x_unwind_cache *cache,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
unsigned int src_reg, base_reg, dst_reg;
int i;
static void
tic6x_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
struct dwarf2_frame_state_reg *reg,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
/* Mark the PC as the destination for the return address. */
if (regnum == gdbarch_pc_regnum (gdbarch))
/* This is the implementation of gdbarch method unwind_pc. */
static CORE_ADDR
-tic6x_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
+tic6x_unwind_pc (struct gdbarch *gdbarch, const frame_info_ptr &next_frame)
{
gdb_byte buf[8];
/* Frame base handling. */
static struct tic6x_unwind_cache*
-tic6x_frame_unwind_cache (frame_info_ptr this_frame,
+tic6x_frame_unwind_cache (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
static void
-tic6x_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+tic6x_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct tic6x_unwind_cache *cache =
}
static struct value *
-tic6x_frame_prev_register (frame_info_ptr this_frame, void **this_cache,
+tic6x_frame_prev_register (const frame_info_ptr &this_frame, void **this_cache,
int regnum)
{
struct tic6x_unwind_cache *cache =
}
static CORE_ADDR
-tic6x_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+tic6x_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct tic6x_unwind_cache *info
= tic6x_frame_unwind_cache (this_frame, this_cache);
static struct tic6x_unwind_cache *
-tic6x_make_stub_cache (frame_info_ptr this_frame)
+tic6x_make_stub_cache (const frame_info_ptr &this_frame)
{
struct tic6x_unwind_cache *cache;
}
static void
-tic6x_stub_this_id (frame_info_ptr this_frame, void **this_cache,
+tic6x_stub_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct tic6x_unwind_cache *cache;
static int
tic6x_stub_unwind_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
CORE_ADDR addr_in_block;
/* This is the implementation of gdbarch method get_longjmp_target. */
static int
-tic6x_get_longjmp_target (frame_info_ptr frame, CORE_ADDR *pc)
+tic6x_get_longjmp_target (const frame_info_ptr &frame, CORE_ADDR *pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
{
/* Return the expected next PC if FRAME is stopped at a syscall
instruction. */
- CORE_ADDR (*syscall_next_pc) (frame_info_ptr frame) = nullptr;
+ CORE_ADDR (*syscall_next_pc) (const frame_info_ptr &frame) = nullptr;
const gdb_byte *breakpoint = nullptr; /* Breakpoint instruction. */
static void
tilegx_linux_sigframe_init (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
tilegx_analyze_prologue (struct gdbarch* gdbarch,
CORE_ADDR start_addr, CORE_ADDR end_addr,
struct tilegx_frame_cache *cache,
- frame_info_ptr next_frame)
+ const frame_info_ptr &next_frame)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
CORE_ADDR next_addr;
/* This is the implementation of gdbarch method get_longjmp_target. */
static int
-tilegx_get_longjmp_target (frame_info_ptr frame, CORE_ADDR *pc)
+tilegx_get_longjmp_target (const frame_info_ptr &frame, CORE_ADDR *pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
/* Normal frames. */
static struct tilegx_frame_cache *
-tilegx_frame_cache (frame_info_ptr this_frame, void **this_cache)
+tilegx_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct tilegx_frame_cache *cache;
/* Retrieve the value of REGNUM in FRAME. */
static struct value*
-tilegx_frame_prev_register (frame_info_ptr this_frame,
+tilegx_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache,
int regnum)
{
/* Build frame id. */
static void
-tilegx_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+tilegx_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct tilegx_frame_cache *info =
}
static CORE_ADDR
-tilegx_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+tilegx_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct tilegx_frame_cache *cache =
tilegx_frame_cache (this_frame, this_cache);
the traceframe context (line, function, file). */
static void
-set_traceframe_context (frame_info_ptr trace_frame)
+set_traceframe_context (const frame_info_ptr &trace_frame)
{
CORE_ADDR trace_pc;
struct symbol *traceframe_fun;
};
struct trad_frame_cache *
-trad_frame_cache_zalloc (frame_info_ptr this_frame)
+trad_frame_cache_zalloc (const frame_info_ptr &this_frame)
{
struct trad_frame_cache *this_trad_cache;
for all potential instruction sequences). */
trad_frame_saved_reg *
-trad_frame_alloc_saved_regs (frame_info_ptr this_frame)
+trad_frame_alloc_saved_regs (const frame_info_ptr &this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct value *
-trad_frame_get_prev_register (frame_info_ptr this_frame,
+trad_frame_get_prev_register (const frame_info_ptr &this_frame,
trad_frame_saved_reg this_saved_regs[],
int regnum)
{
struct value *
trad_frame_get_register (struct trad_frame_cache *this_trad_cache,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
int regnum)
{
return trad_frame_get_prev_register (this_frame, this_trad_cache->prev_regs,
The entire cache is populated in a single pass and then generic
routines are used to extract the various cache values. */
-struct trad_frame_cache *trad_frame_cache_zalloc (frame_info_ptr);
+struct trad_frame_cache *trad_frame_cache_zalloc (const frame_info_ptr &);
/* This frame's ID. */
void trad_frame_set_id (struct trad_frame_cache *this_trad_cache,
gdb::array_view<const gdb_byte> bytes);
struct value *trad_frame_get_register (struct trad_frame_cache *this_trad_cache,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
int regnum);
/* Describes the kind of encoding a stored register has. */
trad_frame_saved_reg *regs);
/* Return a freshly allocated (and initialized) trad_frame array. */
-trad_frame_saved_reg *trad_frame_alloc_saved_regs (frame_info_ptr);
+trad_frame_saved_reg *trad_frame_alloc_saved_regs (const frame_info_ptr &);
trad_frame_saved_reg *trad_frame_alloc_saved_regs (struct gdbarch *);
/* Given the trad_frame info, return the location of the specified
register. */
-struct value *trad_frame_get_prev_register (frame_info_ptr this_frame,
+struct value *trad_frame_get_prev_register (const frame_info_ptr &this_frame,
trad_frame_saved_reg this_saved_regs[],
int regnum);
};
static struct trad_frame_cache *
-tramp_frame_cache (frame_info_ptr this_frame,
+tramp_frame_cache (const frame_info_ptr &this_frame,
void **this_cache)
{
struct tramp_frame_cache *tramp_cache
}
static void
-tramp_frame_this_id (frame_info_ptr this_frame,
+tramp_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-tramp_frame_prev_register (frame_info_ptr this_frame,
+tramp_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache,
int prev_regnum)
{
static CORE_ADDR
tramp_frame_start (const struct tramp_frame *tramp,
- frame_info_ptr this_frame, CORE_ADDR pc)
+ const frame_info_ptr &this_frame, CORE_ADDR pc)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
static int
tramp_frame_sniffer (const struct frame_unwind *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
void **this_cache)
{
const struct tramp_frame *tramp = self->unwind_data->tramp_frame;
/* Initialize a trad-frame cache corresponding to the tramp-frame.
FUNC is the address of the instruction TRAMP[0] in memory. */
void (*init) (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func);
/* Return non-zero if the tramp-frame is valid for the PC requested.
sequence against if required. If this is NULL, then the tramp-frame
is valid for any PC. */
int (*validate) (const struct tramp_frame *self,
- frame_info_ptr this_frame,
+ const frame_info_ptr &this_frame,
CORE_ADDR *pc);
/* Given the current frame in THIS_FRAME and a frame cache in FRAME_CACHE,
}
void
-tui_disasm_window::maybe_update (frame_info_ptr fi, symtab_and_line sal)
+tui_disasm_window::maybe_update (const frame_info_ptr &fi, symtab_and_line sal)
{
CORE_ADDR low;
bool location_matches_p (struct bp_location *loc, int line_no) override;
- void maybe_update (frame_info_ptr fi, symtab_and_line sal) override;
+ void maybe_update (const frame_info_ptr &fi, symtab_and_line sal) override;
void erase_source_content () override
{
/* Observer for the register_changed notification. */
static void
-tui_register_changed (frame_info_ptr frame, int regno)
+tui_register_changed (const frame_info_ptr &frame, int regno)
{
frame_info_ptr fi;
representation of it. */
static std::string
-tui_register_format (frame_info_ptr frame, int regnum)
+tui_register_format (const frame_info_ptr &frame, int regnum)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
given a particular frame. If the values have changed, they are
updated with the new value and highlighted. */
void
-tui_data_window::check_register_values (frame_info_ptr frame)
+tui_data_window::check_register_values (const frame_info_ptr &frame)
{
if (frame == nullptr)
set_register_group (nullptr);
return DATA_NAME;
}
- void check_register_values (frame_info_ptr frame);
+ void check_register_values (const frame_info_ptr &frame);
void set_register_group (const reggroup *group);
}
void
-tui_source_window::maybe_update (frame_info_ptr fi, symtab_and_line sal)
+tui_source_window::maybe_update (const frame_info_ptr &fi, symtab_and_line sal)
{
int start_line = (sal.line - ((height - box_size ()) / 2)) + 1;
if (start_line <= 0)
bool showing_source_p (const char *filename) const;
- void maybe_update (frame_info_ptr fi, symtab_and_line sal) override;
+ void maybe_update (const frame_info_ptr &fi, symtab_and_line sal) override;
void erase_source_content () override
{
name is demangled if demangling is turned on. Returns a pointer to
a static area holding the result. */
static char*
-tui_get_function_from_frame (frame_info_ptr fi)
+tui_get_function_from_frame (const frame_info_ptr &fi)
{
static char name[256];
string_file stream;
refresh. */
void
-tui_show_frame_info (frame_info_ptr fi)
+tui_show_frame_info (const frame_info_ptr &fi)
{
bool status_changed_p;
};
extern void tui_show_status_content (void);
-extern void tui_show_frame_info (frame_info_ptr);
+extern void tui_show_frame_info (const frame_info_ptr &);
#endif /* TUI_TUI_STATUS_H */
/* Update the window to display the given location. Does nothing if
the location is already displayed. */
- virtual void maybe_update (frame_info_ptr fi, symtab_and_line sal) = 0;
+ virtual void maybe_update (const frame_info_ptr &fi, symtab_and_line sal) = 0;
void update_source_window_as_is (struct gdbarch *gdbarch,
const struct symtab_and_line &sal);
}
static frame_info_ptr
-user_created_frame_callee (frame_info_ptr frame)
+user_created_frame_callee (const frame_info_ptr &frame)
{
validate_user_created_frame (get_frame_id (frame));
/* Avoid the "read" symbol name as it conflicts with a preprocessor symbol
in the NetBSD header for Stack Smashing Protection, that wraps the read(2)
syscall. */
- struct value *(*xread) (frame_info_ptr frame, const void *baton);
+ struct value *(*xread) (const frame_info_ptr &frame, const void *baton);
const void *baton;
struct user_reg *next;
};
}
struct value *
-value_of_user_reg (int regnum, frame_info_ptr frame)
+value_of_user_reg (int regnum, const frame_info_ptr &frame)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
int maxregs = gdbarch_num_cooked_regs (gdbarch);
bytes as, at the time the register is being added, the type needed
to describe the register has not bee initialized. */
-typedef struct value *(user_reg_read_ftype) (frame_info_ptr frame,
+typedef struct value *(user_reg_read_ftype) (const frame_info_ptr &frame,
const void *baton);
-extern struct value *value_of_user_reg (int regnum, frame_info_ptr frame);
+extern struct value *value_of_user_reg (int regnum, const frame_info_ptr &frame);
/* Add a builtin register (present in all architectures). */
extern void user_reg_add_builtin (const char *name,
}
static struct v850_frame_cache *
-v850_alloc_frame_cache (frame_info_ptr this_frame)
+v850_alloc_frame_cache (const frame_info_ptr &this_frame)
{
struct v850_frame_cache *cache;
}
static struct v850_frame_cache *
-v850_frame_cache (frame_info_ptr this_frame, void **this_cache)
+v850_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct v850_frame_cache *cache;
static struct value *
-v850_frame_prev_register (frame_info_ptr this_frame,
+v850_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct v850_frame_cache *cache = v850_frame_cache (this_frame, this_cache);
}
static void
-v850_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+v850_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct v850_frame_cache *cache = v850_frame_cache (this_frame, this_cache);
};
static CORE_ADDR
-v850_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+v850_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct v850_frame_cache *cache = v850_frame_cache (this_frame, this_cache);
e.g. in case the type is a variable length array. */
static struct value *
-get_value_at (struct type *type, CORE_ADDR addr, frame_info_ptr frame,
+get_value_at (struct type *type, CORE_ADDR addr, const frame_info_ptr &frame,
int lazy)
{
struct value *val;
e.g. in case the type is a variable length array. */
struct value *
-value_at_lazy (struct type *type, CORE_ADDR addr, frame_info_ptr frame)
+value_at_lazy (struct type *type, CORE_ADDR addr, const frame_info_ptr &frame)
{
return get_value_at (type, addr, frame, 1);
}
/* See value.h */
value *
-value::allocate_register_lazy (frame_info_ptr next_frame, int regnum,
- struct type *type)
+value::allocate_register_lazy (const frame_info_ptr &initial_next_frame,
+ int regnum, struct type *type)
{
if (type == nullptr)
- type = register_type (frame_unwind_arch (next_frame), regnum);
+ type = register_type (frame_unwind_arch (initial_next_frame), regnum);
value *result = value::allocate_lazy (type);
NEXT_FRAME will not have a valid frame id yet. Find the next non-inline
frame (possibly the sentinel frame). This is where registers are unwound
from anyway. */
+ frame_info_ptr next_frame = initial_next_frame;
while (get_frame_type (next_frame) == INLINE_FRAME)
next_frame = get_next_frame_sentinel_okay (next_frame);
/* See value.h */
value *
-value::allocate_register (frame_info_ptr next_frame, int regnum,
+value::allocate_register (const frame_info_ptr &next_frame, int regnum,
struct type *type)
{
value *result = value::allocate_register_lazy (next_frame, regnum, type);
value_from_contents_and_address (struct type *type,
const gdb_byte *valaddr,
CORE_ADDR address,
- frame_info_ptr frame)
+ const frame_info_ptr &frame)
{
gdb::array_view<const gdb_byte> view;
if (valaddr != nullptr)
/* See value.h. */
value *
-pseudo_from_raw_part (frame_info_ptr next_frame, int pseudo_reg_num,
+pseudo_from_raw_part (const frame_info_ptr &next_frame, int pseudo_reg_num,
int raw_reg_num, int raw_offset)
{
value *pseudo_reg_val
/* See value.h. */
void
-pseudo_to_raw_part (frame_info_ptr next_frame,
+pseudo_to_raw_part (const frame_info_ptr &next_frame,
gdb::array_view<const gdb_byte> pseudo_buf,
int raw_reg_num, int raw_offset)
{
/* See value.h. */
value *
-pseudo_from_concat_raw (frame_info_ptr next_frame, int pseudo_reg_num,
+pseudo_from_concat_raw (const frame_info_ptr &next_frame, int pseudo_reg_num,
int raw_reg_1_num, int raw_reg_2_num)
{
value *pseudo_reg_val
/* See value.h. */
void
-pseudo_to_concat_raw (frame_info_ptr next_frame,
+pseudo_to_concat_raw (const frame_info_ptr &next_frame,
gdb::array_view<const gdb_byte> pseudo_buf,
int raw_reg_1_num, int raw_reg_2_num)
{
/* See value.h. */
value *
-pseudo_from_concat_raw (frame_info_ptr next_frame, int pseudo_reg_num,
+pseudo_from_concat_raw (const frame_info_ptr &next_frame, int pseudo_reg_num,
int raw_reg_1_num, int raw_reg_2_num,
int raw_reg_3_num)
{
/* See value.h. */
void
-pseudo_to_concat_raw (frame_info_ptr next_frame,
+pseudo_to_concat_raw (const frame_info_ptr &next_frame,
gdb::array_view<const gdb_byte> pseudo_buf,
int raw_reg_1_num, int raw_reg_2_num, int raw_reg_3_num)
{
/* Allocate a lazy value representing register REGNUM in the frame previous
to NEXT_FRAME. If TYPE is non-nullptr, use it as the value type.
Otherwise, use `register_type` to obtain the type. */
- static struct value *allocate_register_lazy (frame_info_ptr next_frame,
- int regnum, type *type = nullptr);
+ static struct value *allocate_register_lazy (const frame_info_ptr &next_frame,
+ int regnum,
+ type *type = nullptr);
/* Same as `allocate_register_lazy`, but make the value non-lazy.
The caller is responsible for filling the value's contents. */
- static struct value *allocate_register (frame_info_ptr next_frame,
+ static struct value *allocate_register (const frame_info_ptr &next_frame,
int regnum, type *type = nullptr);
/* Create a computed lvalue, with type TYPE, function pointers
properties. */
extern struct value *value_at_lazy (struct type *type, CORE_ADDR addr,
- frame_info_ptr frame = nullptr);
+ const frame_info_ptr &frame = nullptr);
/* Like value_at, but ensures that the result is marked not_lval.
This can be important if the memory is "volatile". */
(struct type *, const gdb_byte *, CORE_ADDR);
extern struct value *value_from_contents_and_address
(struct type *, const gdb_byte *, CORE_ADDR,
- frame_info_ptr frame = nullptr);
+ const frame_info_ptr &frame = nullptr);
extern struct value *value_from_contents (struct type *, const gdb_byte *);
extern value *default_value_from_register (gdbarch *gdbarch, type *type,
const frame_info_ptr &this_frame);
extern struct value *value_from_register (struct type *type, int regnum,
- frame_info_ptr frame);
+ const frame_info_ptr &frame);
extern CORE_ADDR address_from_register (int regnum,
- frame_info_ptr frame);
+ const frame_info_ptr &frame);
extern struct value *value_of_variable (struct symbol *var,
const struct block *b);
/* Return a value with the contents of register REGNUM as found in the frame
previous to NEXT_FRAME. */
-extern value *value_of_register (int regnum, frame_info_ptr next_frame);
+extern value *value_of_register (int regnum, const frame_info_ptr &next_frame);
/* Same as the above, but the value is not fetched. */
-extern value *value_of_register_lazy (frame_info_ptr next_frame, int regnum);
+extern value *value_of_register_lazy (const frame_info_ptr &next_frame, int regnum);
/* Return the symbol's reading requirement. */
extern struct value *read_var_value (struct symbol *var,
const struct block *var_block,
- frame_info_ptr frame);
+ const frame_info_ptr &frame);
extern struct value *allocate_repeat_value (struct type *type, int count);
extern void print_variable_and_value (const char *name,
struct symbol *var,
- frame_info_ptr frame,
+ const frame_info_ptr &frame,
struct ui_file *stream,
int indent);
The size of the pseudo register specifies how many bytes to use. The
offset plus the size must not overflow the raw register's size. */
-value *pseudo_from_raw_part (frame_info_ptr next_frame, int pseudo_reg_num,
+value *pseudo_from_raw_part (const frame_info_ptr &next_frame, int pseudo_reg_num,
int raw_reg_num, int raw_offset);
/* Write PSEUDO_BUF, the contents of a pseudo register, to part of raw register
RAW_REG_NUM starting at RAW_OFFSET. */
-void pseudo_to_raw_part (frame_info_ptr next_frame,
+void pseudo_to_raw_part (const frame_info_ptr &next_frame,
gdb::array_view<const gdb_byte> pseudo_buf,
int raw_reg_num, int raw_offset);
The sum of the sizes of raw registers must be equal to the size of the
pseudo register. */
-value *pseudo_from_concat_raw (frame_info_ptr next_frame, int pseudo_reg_num,
+value *pseudo_from_concat_raw (const frame_info_ptr &next_frame, int pseudo_reg_num,
int raw_reg_1_num, int raw_reg_2_num);
/* Write PSEUDO_BUF, the contents of a pseudo register, to the two raw registers
RAW_REG_1_NUM and RAW_REG_2_NUM. */
-void pseudo_to_concat_raw (frame_info_ptr next_frame,
+void pseudo_to_concat_raw (const frame_info_ptr &next_frame,
gdb::array_view<const gdb_byte> pseudo_buf,
int raw_reg_1_num, int raw_reg_2_num);
/* Same as the above, but with three raw registers. */
-value *pseudo_from_concat_raw (frame_info_ptr next_frame, int pseudo_reg_num,
+value *pseudo_from_concat_raw (const frame_info_ptr &next_frame, int pseudo_reg_num,
int raw_reg_1_num, int raw_reg_2_num,
int raw_reg_3_num);
/* Write PSEUDO_BUF, the contents of a pseudo register, to the three raw
registers RAW_REG_1_NUM, RAW_REG_2_NUM and RAW_REG_3_NUM. */
-void pseudo_to_concat_raw (frame_info_ptr next_frame,
+void pseudo_to_concat_raw (const frame_info_ptr &next_frame,
gdb::array_view<const gdb_byte> pseudo_buf,
int raw_reg_1_num, int raw_reg_2_num,
int raw_reg_3_num);
}
static struct frame_id
-vax_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
+vax_dummy_id (struct gdbarch *gdbarch, const frame_info_ptr &this_frame)
{
CORE_ADDR fp;
};
static struct vax_frame_cache *
-vax_frame_cache (frame_info_ptr this_frame, void **this_cache)
+vax_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct vax_frame_cache *cache;
CORE_ADDR addr;
}
static void
-vax_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+vax_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
}
static struct value *
-vax_frame_prev_register (frame_info_ptr this_frame,
+vax_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
\f
static CORE_ADDR
-vax_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+vax_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
}
static CORE_ADDR
-vax_frame_args_address (frame_info_ptr this_frame, void **this_cache)
+vax_frame_args_address (const frame_info_ptr &this_frame, void **this_cache)
{
return get_frame_register_unsigned (this_frame, VAX_AP_REGNUM);
}
/* Return number of arguments for FRAME. */
static int
-vax_frame_num_args (frame_info_ptr frame)
+vax_frame_num_args (const frame_info_ptr &frame)
{
CORE_ADDR args;
xstormy16_analyze_prologue (struct gdbarch *gdbarch,
CORE_ADDR start_addr, CORE_ADDR end_addr,
struct xstormy16_frame_cache *cache,
- frame_info_ptr this_frame)
+ const frame_info_ptr &this_frame)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
CORE_ADDR next_addr;
}
static CORE_ADDR
-xstormy16_skip_trampoline_code (frame_info_ptr frame, CORE_ADDR pc)
+xstormy16_skip_trampoline_code (const frame_info_ptr &frame, CORE_ADDR pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
CORE_ADDR tmp = xstormy16_resolve_jmp_table_entry (gdbarch, pc);
}
static struct xstormy16_frame_cache *
-xstormy16_frame_cache (frame_info_ptr this_frame, void **this_cache)
+xstormy16_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct xstormy16_frame_cache *cache;
}
static struct value *
-xstormy16_frame_prev_register (frame_info_ptr this_frame,
+xstormy16_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache, int regnum)
{
struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
}
static void
-xstormy16_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+xstormy16_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
}
static CORE_ADDR
-xstormy16_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+xstormy16_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
this_cache);
static CORE_ADDR
-xtensa_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
+xtensa_unwind_pc (struct gdbarch *gdbarch, const frame_info_ptr &next_frame)
{
gdb_byte buf[8];
CORE_ADDR pc;
static struct frame_id
-xtensa_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
+xtensa_dummy_id (struct gdbarch *gdbarch, const frame_info_ptr &this_frame)
{
CORE_ADDR pc, fp;
xtensa_gdbarch_tdep *tdep = gdbarch_tdep<xtensa_gdbarch_tdep> (gdbarch);
cache->prev_sp = SP of the previous frame. */
static void
-call0_frame_cache (frame_info_ptr this_frame,
+call0_frame_cache (const frame_info_ptr &this_frame,
xtensa_frame_cache_t *cache, CORE_ADDR pc);
static void
-xtensa_window_interrupt_frame_cache (frame_info_ptr this_frame,
+xtensa_window_interrupt_frame_cache (const frame_info_ptr &this_frame,
xtensa_frame_cache_t *cache,
CORE_ADDR pc);
static struct xtensa_frame_cache *
-xtensa_frame_cache (frame_info_ptr this_frame, void **this_cache)
+xtensa_frame_cache (const frame_info_ptr &this_frame, void **this_cache)
{
xtensa_frame_cache_t *cache;
CORE_ADDR ra, wb, ws, pc, sp, ps;
static void
-xtensa_frame_this_id (frame_info_ptr this_frame,
+xtensa_frame_this_id (const frame_info_ptr &this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-xtensa_frame_prev_register (frame_info_ptr this_frame,
+xtensa_frame_prev_register (const frame_info_ptr &this_frame,
void **this_cache,
int regnum)
{
};
static CORE_ADDR
-xtensa_frame_base_address (frame_info_ptr this_frame, void **this_cache)
+xtensa_frame_base_address (const frame_info_ptr &this_frame, void **this_cache)
{
struct xtensa_frame_cache *cache =
xtensa_frame_cache (this_frame, this_cache);
/* Initialize frame cache for the current frame in CALL0 ABI. */
static void
-call0_frame_cache (frame_info_ptr this_frame,
+call0_frame_cache (const frame_info_ptr &this_frame,
xtensa_frame_cache_t *cache, CORE_ADDR pc)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
/* Handle Window Overflow / Underflow exception frames. */
static void
-xtensa_window_interrupt_frame_cache (frame_info_ptr this_frame,
+xtensa_window_interrupt_frame_cache (const frame_info_ptr &this_frame,
xtensa_frame_cache_t *cache,
CORE_ADDR pc)
{
/* function unwinds current stack frame and returns next one */
static struct z80_unwind_cache *
-z80_frame_unwind_cache (frame_info_ptr this_frame,
+z80_frame_unwind_cache (const frame_info_ptr &this_frame,
void **this_prologue_cache)
{
CORE_ADDR start_pc, current_pc;
/* Given a GDB frame, determine the address of the calling function's
frame. This will be used to create a new GDB frame struct. */
static void
-z80_frame_this_id (frame_info_ptr this_frame, void **this_cache,
+z80_frame_this_id (const frame_info_ptr &this_frame, void **this_cache,
struct frame_id *this_id)
{
struct frame_id id;
}
static struct value *
-z80_frame_prev_register (frame_info_ptr this_frame,
+z80_frame_prev_register (const frame_info_ptr &this_frame,
void **this_prologue_cache, int regnum)
{
struct z80_unwind_cache *info
projects / thirdparty / binutils-gdb.git / commitdiff
