static void
aarch64_fbsd_sigframe_init (const struct tramp_frame *self,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
static void
aarch64_linux_sigframe_init (const struct tramp_frame *self,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
static CORE_ADDR
aarch64_frame_unmask_lr (aarch64_gdbarch_tdep *tdep,
- struct frame_info *this_frame, CORE_ADDR addr)
+ 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 *frame, CORE_ADDR pc)
+aarch64_get_pc_address_flags (frame_info_ptr frame, CORE_ADDR pc)
{
if (pc != 0 && get_frame_pc_masked (frame))
return "PAC";
cache CACHE. */
static void
-aarch64_scan_prologue (struct frame_info *this_frame,
+aarch64_scan_prologue (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 (struct frame_info *this_frame,
+aarch64_make_prologue_cache_1 (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 (struct frame_info *this_frame, void **this_cache)
+aarch64_make_prologue_cache (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 (struct frame_info *this_frame,
+aarch64_prologue_frame_unwind_stop_reason (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 (struct frame_info *this_frame,
+aarch64_prologue_this_id (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 (struct frame_info *this_frame,
+aarch64_prologue_prev_register (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 (struct frame_info *this_frame, void **this_cache)
+aarch64_make_stub_cache (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 (struct frame_info *this_frame,
+aarch64_stub_frame_unwind_stop_reason (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 (struct frame_info *this_frame,
+aarch64_stub_this_id (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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame, void **this_cache)
+aarch64_normal_frame_base (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 (struct frame_info *this_frame,
+aarch64_dwarf2_prev_register (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,
- struct frame_info *this_frame)
+ 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 (struct frame_info *frame, CORE_ADDR *pc)
+aarch64_get_longjmp_target (frame_info_ptr frame, CORE_ADDR *pc)
{
CORE_ADDR jb_addr;
gdb_byte buf[X_REGISTER_SIZE];
/* Callback function for user_reg_add. */
static struct value *
-value_of_aarch64_user_reg (struct frame_info *frame, const void *baton)
+value_of_aarch64_user_reg (frame_info_ptr frame, const void *baton)
{
const int *reg_p = (const int *) baton;
to most users. */
static int
-is_known_support_routine (struct frame_info *frame)
+is_known_support_routine (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 (struct frame_info *fi)
+ada_find_printable_frame (frame_info_ptr fi)
{
for (; fi != NULL; fi = get_prev_frame (fi))
{
ada_unhandled_exception_name_addr_from_raise (void)
{
int frame_level;
- struct frame_info *fi;
+ frame_info_ptr fi;
struct ada_inferior_data *data = get_ada_inferior_data (current_inferior ());
/* To determine the name of this exception, we need to select
static void
ada_add_exceptions_from_frame (compiled_regex *preg,
- struct frame_info *frame,
+ 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,
- struct frame_info *frame) const override
+ frame_info_ptr frame) const override
{
/* The only case where default_read_var_value is not sufficient
is when VAR is a renaming... */
#if !defined (ADA_LANG_H)
#define ADA_LANG_H 1
-struct frame_info;
+class frame_info_ptr;
struct inferior;
struct type_print_options;
struct parser_state;
const char **,
int *, const char **);
-extern void ada_find_printable_frame (struct frame_info *fi);
+extern void ada_find_printable_frame (frame_info_ptr fi);
extern char *ada_breakpoint_rewrite (char *, int *);
}
static CORE_ADDR
-alpha_linux_sigcontext_addr (struct frame_info *this_frame)
+alpha_linux_sigcontext_addr (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 (struct frame_info *this_frame,
+alpha_mdebug_frame_unwind_cache (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 (struct frame_info *this_frame,
+alpha_mdebug_frame_this_id (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 (struct frame_info *this_frame,
+alpha_mdebug_frame_prev_register (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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame,
+alpha_mdebug_frame_base_address (frame_info_ptr this_frame,
void **this_prologue_cache)
{
struct alpha_mdebug_unwind_cache *info
}
static CORE_ADDR
-alpha_mdebug_frame_locals_address (struct frame_info *this_frame,
+alpha_mdebug_frame_locals_address (frame_info_ptr this_frame,
void **this_prologue_cache)
{
struct alpha_mdebug_unwind_cache *info
}
static CORE_ADDR
-alpha_mdebug_frame_args_address (struct frame_info *this_frame,
+alpha_mdebug_frame_args_address (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 (struct frame_info *this_frame)
+alpha_mdebug_frame_base_sniffer (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 (struct frame_info *frame)
+alphanbsd_sigcontext_addr (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 (struct frame_info *this_frame)
+alphaobsd_sigcontext_addr (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 (struct frame_info *frame, int regnum,
+alpha_register_to_value (frame_info_ptr frame, int regnum,
struct type *valtype, gdb_byte *out,
int *optimizedp, int *unavailablep)
{
}
static void
-alpha_value_to_register (struct frame_info *frame, int regnum,
+alpha_value_to_register (frame_info_ptr frame, int regnum,
struct type *valtype, const gdb_byte *in)
{
gdb_byte out[ALPHA_REGISTER_SIZE];
into the "pc". This routine returns true on success. */
static int
-alpha_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
+alpha_get_longjmp_target (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 (struct frame_info *this_frame,
+alpha_sigtramp_frame_unwind_cache (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 (struct frame_info *this_frame,
+alpha_sigtramp_frame_this_id (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 (struct frame_info *this_frame,
+alpha_sigtramp_frame_prev_register (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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame,
+alpha_heuristic_frame_unwind_cache (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 (struct frame_info *this_frame,
+alpha_heuristic_frame_this_id (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 (struct frame_info *this_frame,
+alpha_heuristic_frame_prev_register (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 (struct frame_info *this_frame,
+alpha_heuristic_frame_base_address (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) (struct frame_info *) = nullptr;
+ CORE_ADDR (*sigcontext_addr) (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 (struct frame_info *this_frame)
+amd64_darwin_sigcontext_addr (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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame)
+amd64_linux_sigtramp_start (frame_info_ptr this_frame)
{
struct gdbarch *gdbarch;
const gdb_byte *sigtramp_code;
routine. */
static int
-amd64_linux_sigtramp_p (struct frame_info *this_frame)
+amd64_linux_sigtramp_p (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 (struct frame_info *this_frame)
+amd64_linux_sigcontext_addr (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 (struct frame_info *this_frame)
+amd64nbsd_sigtramp_p (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 (struct frame_info *this_frame)
+amd64nbsd_mcontext_addr (frame_info_ptr this_frame)
{
CORE_ADDR addr;
routine. */
static int
-amd64obsd_sigtramp_p (struct frame_info *this_frame)
+amd64obsd_sigtramp_p (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 (struct frame_info *this_frame)
+amd64obsd_sigcontext_addr (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 (struct frame_info *this_frame, void **this_cache)
+amd64obsd_trapframe_cache (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 (struct frame_info *this_frame,
+amd64obsd_trapframe_this_id (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 (struct frame_info *this_frame,
+amd64obsd_trapframe_prev_register (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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame)
+amd64_sol2_mcontext_addr (frame_info_ptr this_frame)
{
CORE_ADDR sp, ucontext_addr;
/* Normal frames. */
static void
-amd64_frame_cache_1 (struct frame_info *this_frame,
+amd64_frame_cache_1 (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 (struct frame_info *this_frame, void **this_cache)
+amd64_frame_cache (frame_info_ptr this_frame, void **this_cache)
{
struct amd64_frame_cache *cache;
}
static enum unwind_stop_reason
-amd64_frame_unwind_stop_reason (struct frame_info *this_frame,
+amd64_frame_unwind_stop_reason (frame_info_ptr this_frame,
void **this_cache)
{
struct amd64_frame_cache *cache =
}
static void
-amd64_frame_this_id (struct frame_info *this_frame, void **this_cache,
+amd64_frame_this_id (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 (struct frame_info *this_frame, void **this_cache,
+amd64_frame_prev_register (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 (struct frame_info *this_frame, void **this_cache)
+amd64_sigtramp_frame_cache (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 (struct frame_info *this_frame,
+amd64_sigtramp_frame_unwind_stop_reason (frame_info_ptr this_frame,
void **this_cache)
{
struct amd64_frame_cache *cache =
}
static void
-amd64_sigtramp_frame_this_id (struct frame_info *this_frame,
+amd64_sigtramp_frame_this_id (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 (struct frame_info *this_frame,
+amd64_sigtramp_frame_prev_register (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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_cache)
{
gdbarch *arch = get_frame_arch (this_frame);
\f
static CORE_ADDR
-amd64_frame_base_address (struct frame_info *this_frame, void **this_cache)
+amd64_frame_base_address (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 (const struct frame_unwind *self,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_prologue_cache)
{
if (frame_relative_level (this_frame) == 0)
}
static struct amd64_frame_cache *
-amd64_epilogue_frame_cache (struct frame_info *this_frame, void **this_cache)
+amd64_epilogue_frame_cache (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 (struct frame_info *this_frame,
+amd64_epilogue_frame_unwind_stop_reason (frame_info_ptr this_frame,
void **this_cache)
{
struct amd64_frame_cache *cache
}
static void
-amd64_epilogue_frame_this_id (struct frame_info *this_frame,
+amd64_epilogue_frame_this_id (frame_info_ptr this_frame,
void **this_cache,
struct frame_id *this_id)
{
};
static struct frame_id
-amd64_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
+amd64_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
{
CORE_ADDR fp;
success. */
static int
-amd64_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
+amd64_get_longjmp_target (frame_info_ptr frame, CORE_ADDR *pc)
{
gdb_byte buf[8];
CORE_ADDR jb_addr;
#define AMD64_TDEP_H
struct gdbarch;
-struct frame_info;
+class frame_info_ptr;
struct regcache;
#include "i386-tdep.h"
Return 1 if an epilogue sequence was recognized, 0 otherwise. */
static int
-amd64_windows_frame_decode_epilogue (struct frame_info *this_frame,
+amd64_windows_frame_decode_epilogue (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 (struct frame_info *this_frame,
+amd64_windows_frame_decode_insns (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 (struct frame_info *this_frame, void **this_cache)
+amd64_windows_frame_cache (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 (struct frame_info *this_frame,
+amd64_windows_frame_prev_register (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 (struct frame_info *this_frame, void **this_cache,
+amd64_windows_frame_this_id (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 (struct frame_info *frame, CORE_ADDR pc)
+amd64_windows_skip_trampoline_code (frame_info_ptr frame, CORE_ADDR pc)
{
CORE_ADDR destination = 0;
struct gdbarch *gdbarch = get_frame_arch (frame);
Returns TRUE if this is a sigtramp frame. */
static bool
-arc_linux_is_sigtramp (struct frame_info *this_frame)
+arc_linux_is_sigtramp (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 (struct frame_info *this_frame)
+arc_linux_sigcontext_addr (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 (struct frame_info *frame, CORE_ADDR *pc)
+arc_get_longjmp_target (frame_info_ptr frame, CORE_ADDR *pc)
{
arc_debug_printf ("called");
frame pointer. */
static CORE_ADDR
-arc_frame_base_address (struct frame_info *this_frame, void **prologue_cache)
+arc_frame_base_address (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 (struct frame_info *this_frame)
+arc_make_frame_cache (frame_info_ptr this_frame)
{
arc_debug_printf ("called");
/* Implement the "this_id" frame_unwind method. */
static void
-arc_frame_this_id (struct frame_info *this_frame, void **this_cache,
+arc_frame_this_id (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 (struct frame_info *this_frame,
+arc_frame_prev_register (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,
- struct frame_info *info)
+ 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 (struct frame_info *this_frame)
+arc_make_sigtramp_frame_cache (frame_info_ptr this_frame)
{
arc_debug_printf ("called");
frames. */
static void
-arc_sigtramp_frame_this_id (struct frame_info *this_frame,
+arc_sigtramp_frame_this_id (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 (struct frame_info *this_frame,
+arc_sigtramp_frame_prev_register (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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_cache)
{
arc_debug_printf ("called");
bool has_hw_loops = false;
/* Detect sigtramp. */
- bool (*is_sigtramp) (struct frame_info *) = nullptr;
+ bool (*is_sigtramp) (frame_info_ptr ) = nullptr;
/* Get address of sigcontext for sigtramp. */
- CORE_ADDR (*sigcontext_addr) (struct frame_info *) = nullptr;
+ CORE_ADDR (*sigcontext_addr) (frame_info_ptr ) = nullptr;
/* Offset of registers in `struct sigcontext'. */
const int *sc_reg_offset = nullptr;
}
CORE_ADDR
-generic_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
+generic_skip_trampoline_code (frame_info_ptr frame, CORE_ADDR pc)
{
return 0;
}
int
default_code_of_frame_writable (struct gdbarch *gdbarch,
- struct frame_info *frame)
+ frame_info_ptr frame)
{
return 1;
}
/* See arch-utils.h. */
std::string
-default_get_pc_address_flags (frame_info *frame, CORE_ADDR pc)
+default_get_pc_address_flags (frame_info_ptr frame, CORE_ADDR pc)
{
return "";
}
#include "gdbarch.h"
-struct frame_info;
+class frame_info_ptr;
struct minimal_symbol;
struct type;
struct gdbarch_info;
struct value *address,
memtag_type tag_type);
-extern CORE_ADDR generic_skip_trampoline_code (struct frame_info *frame,
+extern CORE_ADDR generic_skip_trampoline_code (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,
- struct frame_info *frame);
+ 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 *frame,
+extern std::string default_get_pc_address_flags (frame_info_ptr frame,
CORE_ADDR pc);
/* Default implementation of gdbarch read_core_file_mappings method. */
static void
arm_fbsd_sigframe_init (const struct tramp_frame *self,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
};
static void
-arm_linux_sigtramp_cache (struct frame_info *this_frame,
+arm_linux_sigtramp_cache (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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *frame,
+arm_linux_sigreturn_return_addr (frame_info_ptr frame,
unsigned long svc_number,
CORE_ADDR *pc, int *is_thumb)
{
{
CORE_ADDR return_to = 0;
- struct frame_info *frame;
+ frame_info_ptr frame;
unsigned int svc_number = displaced_read_reg (regs, dsc, 7);
int is_sigreturn = 0;
int is_thumb;
/* Implement the skip_trampoline_code gdbarch method. */
static CORE_ADDR
-arm_linux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
+arm_linux_skip_trampoline_code (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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
struct trad_frame_cache *cache,
CORE_ADDR func)
{
static inline void
arm_cache_init_sp (int regnum, CORE_ADDR* member,
struct arm_prologue_cache *cache,
- struct frame_info *frame)
+ frame_info_ptr frame)
{
CORE_ADDR val = get_frame_register_unsigned (frame, regnum);
if (val == cache->sp)
/* Similar to the previous function, but extracts GDBARCH from FRAME. */
static void
-arm_cache_init (struct arm_prologue_cache *cache, struct frame_info *frame)
+arm_cache_init (struct arm_prologue_cache *cache, 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 (struct frame_info *frame)
+arm_frame_is_thumb (frame_info_ptr frame)
{
/* Check the architecture of FRAME. */
struct gdbarch *gdbarch = get_frame_arch (frame);
}
static void
-arm_scan_prologue (struct frame_info *this_frame,
+arm_scan_prologue (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 (struct frame_info *this_frame)
+arm_make_prologue_cache (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 (struct frame_info *this_frame,
+arm_prologue_unwind_stop_reason (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 (struct frame_info *this_frame,
+arm_prologue_this_id (frame_info_ptr this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-arm_prologue_prev_register (struct frame_info *this_frame,
+arm_prologue_prev_register (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 (struct frame_info *this_frame, gdb_byte *entry)
+arm_exidx_fill_cache (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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame)
+arm_make_epilogue_frame_cache (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 (struct frame_info *this_frame,
+arm_epilogue_frame_this_id (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 (struct frame_info *this_frame,
+arm_epilogue_frame_prev_register (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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *frame, CORE_ADDR pc)
+arm_skip_bx_reg (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 (struct frame_info *this_frame)
+arm_make_stub_cache (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 (struct frame_info *this_frame,
+arm_stub_this_id (frame_info_ptr this_frame,
void **this_cache,
struct frame_id *this_id)
{
static int
arm_stub_unwind_sniffer (const struct frame_unwind *self,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_prologue_cache)
{
CORE_ADDR addr_in_block;
returned. */
static struct arm_prologue_cache *
-arm_m_exception_cache (struct frame_info *this_frame)
+arm_m_exception_cache (frame_info_ptr this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
arm_gdbarch_tdep *tdep = gdbarch_tdep<arm_gdbarch_tdep> (gdbarch);
'struct frame_uwnind'. */
static void
-arm_m_exception_this_id (struct frame_info *this_frame,
+arm_m_exception_this_id (frame_info_ptr this_frame,
void **this_cache,
struct frame_id *this_id)
{
'struct frame_uwnind'. */
static struct value *
-arm_m_exception_prev_register (struct frame_info *this_frame,
+arm_m_exception_prev_register (frame_info_ptr this_frame,
void **this_cache,
int prev_regnum)
{
static int
arm_m_exception_unwind_sniffer (const struct frame_unwind *self,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_prologue_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
};
static CORE_ADDR
-arm_normal_frame_base (struct frame_info *this_frame, void **this_cache)
+arm_normal_frame_base (frame_info_ptr this_frame, void **this_cache)
{
struct arm_prologue_cache *cache;
};
static struct value *
-arm_dwarf2_prev_register (struct frame_info *this_frame, void **this_cache,
+arm_dwarf2_prev_register (frame_info_ptr this_frame, void **this_cache,
int regnum)
{
struct gdbarch * gdbarch = get_frame_arch (this_frame);
if (override_with_sp_value)
{
/* Use value of SP from previous frame. */
- struct frame_info *prev_frame = get_prev_frame (this_frame);
+ frame_info_ptr prev_frame = get_prev_frame (this_frame);
if (prev_frame)
val = get_frame_register_unsigned (prev_frame, ARM_SP_REGNUM);
else
(if present) or emulator. */
static void
arm_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
- struct frame_info *frame, const char *args)
+ 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,
- struct frame_info *this_frame)
+ frame_info_ptr this_frame)
{
arm_gdbarch_tdep *tdep = gdbarch_tdep<arm_gdbarch_tdep> (gdbarch);
static int
-arm_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
+arm_get_longjmp_target (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 (struct frame_info *frame, CORE_ADDR pc)
+arm_skip_stub (frame_info_ptr frame, CORE_ADDR pc)
{
const char *name;
int namelen;
}
static struct value *
-value_of_arm_user_reg (struct frame_info *frame, const void *baton)
+value_of_arm_user_reg (frame_info_ptr frame, const void *baton)
{
const int *reg_p = (const int *) baton;
return value_of_register (*reg_p, frame);
/* Implement the code_of_frame_writable gdbarch method. */
static int
-arm_code_of_frame_writable (struct gdbarch *gdbarch, struct frame_info *frame)
+arm_code_of_frame_writable (struct gdbarch *gdbarch, 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 *frame, CORE_ADDR pc)
+arm_get_pc_address_flags (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 (struct frame_info *, CORE_ADDR);
+CORE_ADDR arm_skip_stub (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 (struct frame_info *frame);
+int arm_frame_is_thumb (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 (struct frame_info *frame, CORE_ADDR pc)
+arm_pe_skip_trampoline_code (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 (struct frame_info *this_frame,
+avr_frame_unwind_cache (frame_info_ptr this_frame,
void **this_prologue_cache)
{
CORE_ADDR start_pc, current_pc;
}
static CORE_ADDR
-avr_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
+avr_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
{
ULONGEST pc;
}
static CORE_ADDR
-avr_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
+avr_unwind_sp (struct gdbarch *gdbarch, 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 (struct frame_info *this_frame,
+avr_frame_this_id (frame_info_ptr this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
}
static struct value *
-avr_frame_prev_register (struct frame_info *this_frame,
+avr_frame_prev_register (frame_info_ptr this_frame,
void **this_prologue_cache, int regnum)
{
struct avr_unwind_cache *info
};
static CORE_ADDR
-avr_frame_base_address (struct frame_info *this_frame, void **this_cache)
+avr_frame_base_address (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, struct frame_info *this_frame)
+avr_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
{
ULONGEST base;
static void
maint_agent_printf_command (const char *cmdrest, int from_tty)
{
- struct frame_info *fi = get_current_frame (); /* need current scope */
+ frame_info_ptr fi = get_current_frame (); /* need current scope */
const char *format_start, *format_end;
/* We don't deal with overlay debugging at the moment. We need to
static void
bfin_linux_sigframe_init (const struct tramp_frame *self,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
}
static struct bfin_frame_cache *
-bfin_frame_cache (struct frame_info *this_frame, void **this_cache)
+bfin_frame_cache (frame_info_ptr this_frame, void **this_cache)
{
struct bfin_frame_cache *cache;
int i;
}
static void
-bfin_frame_this_id (struct frame_info *this_frame,
+bfin_frame_this_id (frame_info_ptr this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-bfin_frame_prev_register (struct frame_info *this_frame,
+bfin_frame_prev_register (frame_info_ptr this_frame,
void **this_cache,
int regnum)
{
}
static CORE_ADDR
-bfin_frame_base_address (struct frame_info *this_frame, void **this_cache)
+bfin_frame_base_address (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 (struct frame_info *this_frame, void **this_cache)
+bfin_frame_local_address (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 (struct frame_info *this_frame, void **this_cache)
+bfin_frame_args_address (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 (struct frame_info *frame, CORE_ADDR *addr_in_block)
+get_frame_block (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 (struct frame_info *frame)
+get_frame_function (frame_info_ptr frame)
{
const struct block *bl = get_frame_block (frame, 0);
at least as old as the selected frame. Return NULL if there is no
such frame. If BLOCK is NULL, just return NULL. */
-struct frame_info *
+frame_info_ptr
block_innermost_frame (const struct block *block)
{
if (block == NULL)
return NULL;
- frame_info *frame = get_selected_frame ();
+ frame_info_ptr frame = get_selected_frame ();
while (frame != NULL)
{
const struct block *frame_block = get_frame_block (frame, NULL);
/* Given THIS_FRAME, return its ID. */
static void
-bpf_frame_this_id (struct frame_info *this_frame,
+bpf_frame_this_id (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 (struct frame_info *this_frame,
+bpf_frame_unwind_stop_reason (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 (struct frame_info *this_frame,
+bpf_frame_prev_register (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, struct frame_info *this_frame)
+bpf_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
{
CORE_ADDR sp = get_frame_register_unsigned (this_frame,
gdbarch_sp_regnum (gdbarch));
static void
fetch_probe_arguments (struct value **arg0, struct value **arg1)
{
- struct frame_info *frame = get_selected_frame (_("No frame selected"));
+ frame_info_ptr frame = get_selected_frame (_("No frame selected"));
CORE_ADDR pc = get_frame_pc (frame);
struct bound_probe pc_probe;
unsigned n_args;
within_current_scope = 1;
else
{
- struct frame_info *fi = get_current_frame ();
+ frame_info_ptr fi = get_current_frame ();
struct gdbarch *frame_arch = get_frame_arch (fi);
CORE_ADDR frame_pc = get_frame_pc (fi);
watchpoint_check (bpstat *bs)
{
struct watchpoint *b;
- struct frame_info *fr;
+ frame_info_ptr fr;
int within_current_scope;
/* BS is built from an existing struct breakpoint. */
within_current_scope = 1;
else
{
- struct frame_info *frame = get_current_frame ();
+ frame_info_ptr frame = get_current_frame ();
struct gdbarch *frame_arch = get_frame_arch (frame);
CORE_ADDR frame_pc = get_frame_pc (frame);
select_frame (get_current_frame ());
else
{
- struct frame_info *frame;
+ frame_info_ptr frame;
/* For local watchpoint expressions, which particular
instance of a local is being watched matters, so we
original dummy frame, hence frame_id_inner can't be used. See
the comments on frame_id_inner for more details. */
bool unwind_finished_unexpectedly = false;
- for (struct frame_info *fi = get_current_frame (); fi != nullptr; )
+ for (frame_info_ptr fi = get_current_frame (); fi != nullptr; )
{
- struct frame_info *prev = get_prev_frame (fi);
+ frame_info_ptr prev = get_prev_frame (fi);
if (prev == nullptr)
{
/* FI is the last stack frame. Why did this frame not
if (*tok)
error (_("Junk at end of command."));
- frame_info *wp_frame = block_innermost_frame (exp_valid_block);
+ frame_info_ptr wp_frame = block_innermost_frame (exp_valid_block);
/* Save this because create_internal_breakpoint below invalidates
'wp_frame'. */
void
until_break_command (const char *arg, int from_tty, int anywhere)
{
- struct frame_info *frame;
+ frame_info_ptr frame;
struct gdbarch *frame_gdbarch;
struct frame_id stack_frame_id;
struct frame_id caller_frame_id;
if (!next_pcs.empty ())
{
- struct frame_info *frame = get_current_frame ();
+ frame_info_ptr frame = get_current_frame ();
const address_space *aspace = get_frame_address_space (frame);
for (CORE_ADDR pc : next_pcs)
/* See language.h. */
- CORE_ADDR skip_trampoline (struct frame_info *fi,
+ CORE_ADDR skip_trampoline (frame_info_ptr fi,
CORE_ADDR pc) const override
{
return cplus_skip_trampoline (fi, pc);
static void
disassemble_current_function (gdb_disassembly_flags flags)
{
- struct frame_info *frame;
+ frame_info_ptr frame;
struct gdbarch *gdbarch;
CORE_ADDR low, high, pc;
const char *name;
by their name. */
{
struct value *val;
- struct frame_info *frame = NULL;
+ frame_info_ptr frame = NULL;
if (symbol_read_needs_frame (sym.symbol))
{
by their name. */
{
struct value *val;
- struct frame_info *frame = nullptr;
+ frame_info_ptr frame = nullptr;
if (symbol_read_needs_frame (sym.symbol))
{
offset by hand seemed too hackish. */
if (is_tls)
{
- struct frame_info *frame = get_selected_frame (NULL);
+ frame_info_ptr frame = get_selected_frame (NULL);
struct value *val;
if (frame == NULL)
}
CORE_ADDR
-cplus_skip_trampoline (struct frame_info *frame,
+cplus_skip_trampoline (frame_info_ptr frame,
CORE_ADDR stop_pc)
{
if (current_cp_abi.skip_trampoline == NULL)
struct type;
struct value;
struct ui_file;
-struct frame_info;
+class frame_info_ptr;
/* The functions here that attempt to determine what sort of thing a
mangled name refers to may well be revised in the future. It would
address of the routine we are thunking to and continue to there
instead. */
-CORE_ADDR cplus_skip_trampoline (struct frame_info *frame,
+CORE_ADDR cplus_skip_trampoline (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) (struct frame_info *, CORE_ADDR);
+ CORE_ADDR (*skip_trampoline) (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 (struct frame_info *this_frame)
+cris_sigtramp_start (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 (struct frame_info *this_frame)
+cris_rt_sigtramp_start (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 (struct frame_info *this_frame)
+cris_sigcontext_addr (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 (struct frame_info *this_frame,
+cris_sigtramp_frame_unwind_cache (frame_info_ptr this_frame,
void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
static void
-cris_sigtramp_frame_this_id (struct frame_info *this_frame, void **this_cache,
+cris_sigtramp_frame_this_id (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 (struct frame_info *this_frame,
+static struct value *cris_frame_prev_register (frame_info_ptr this_frame,
void **this_cache, int regnum);
static struct value *
-cris_sigtramp_frame_prev_register (struct frame_info *this_frame,
+cris_sigtramp_frame_prev_register (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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_cache)
{
if (cris_sigtramp_start (this_frame)
static int
crisv32_single_step_through_delay (struct gdbarch *gdbarch,
- struct frame_info *this_frame)
+ 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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
struct cris_unwind_cache *info);
static CORE_ADDR crisv32_scan_prologue (CORE_ADDR pc,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame,
+cris_frame_unwind_cache (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 (struct frame_info *this_frame,
+cris_frame_this_id (frame_info_ptr this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
}
static struct value *
-cris_frame_prev_register (struct frame_info *this_frame,
+cris_frame_prev_register (frame_info_ptr this_frame,
void **this_prologue_cache, int regnum)
{
struct cris_unwind_cache *info
};
static CORE_ADDR
-cris_frame_base_address (struct frame_info *this_frame, void **this_cache)
+cris_frame_base_address (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, struct frame_info *this_frame,
+cris_scan_prologue (CORE_ADDR pc, 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, struct frame_info *this_frame,
+crisv32_scan_prologue (CORE_ADDR pc, 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,
- struct frame_info *this_frame)
+ 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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame)
+csky_frame_unwind_cache (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 (struct frame_info *this_frame,
+csky_frame_this_id (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 (struct frame_info *this_frame,
+csky_frame_prev_register (frame_info_ptr this_frame,
void **this_prologue_cache, int regnum)
{
struct csky_unwind_cache *cache;
};
static CORE_ADDR
-csky_check_long_branch (struct frame_info *frame, CORE_ADDR pc)
+csky_check_long_branch (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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_prologue_cache)
{
CORE_ADDR addr_in_block, pc;
}
static struct csky_unwind_cache *
-csky_make_stub_cache (struct frame_info *this_frame)
+csky_make_stub_cache (frame_info_ptr this_frame)
{
struct csky_unwind_cache *cache;
}
static void
-csky_stub_this_id (struct frame_info *this_frame,
+csky_stub_this_id (frame_info_ptr this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-csky_stub_prev_register (struct frame_info *this_frame,
+csky_stub_prev_register (frame_info_ptr this_frame,
void **this_cache,
int prev_regnum)
{
for the normal unwinder. */
static CORE_ADDR
-csky_frame_base_address (struct frame_info *this_frame, void **this_cache)
+csky_frame_base_address (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,
- struct frame_info *this_frame)
+ frame_info_ptr this_frame)
{
if (regnum == gdbarch_pc_regnum (gdbarch))
reg->how = DWARF2_FRAME_REG_RA;
struct symtab;
struct breakpoint;
-struct frame_info;
+class frame_info_ptr;
struct gdbarch;
struct value;
/* See probe.h. */
struct value *evaluate_argument (unsigned n,
- struct frame_info *frame) override;
+ frame_info_ptr frame) override;
/* See probe.h. */
void compile_to_ax (struct agent_expr *aexpr,
struct value *
dtrace_probe::evaluate_argument (unsigned n,
- struct frame_info *frame)
+ 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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame,
+dummy_frame_prev_register (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 (struct frame_info *this_frame,
+dummy_frame_this_id (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, struct frame_info *this_frame)
+default_dummy_id (struct gdbarch *gdbarch, 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,
- struct frame_info *this_frame);
+ frame_info_ptr this_frame);
#endif /* !defined (DUMMY_FRAME_H) */
/* Ensure that a FRAME is defined, throw an exception otherwise. */
static void
-ensure_have_frame (frame_info *frame, const char *op_name)
+ensure_have_frame (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 *frame, int reg)
+read_addr_from_reg (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 *frame)
+ frame_info_ptr frame)
{
piece_closure *c = new piece_closure;
{
case DWARF_VALUE_REGISTER:
{
- frame_info *frame = frame_find_by_id (c->frame_id);
+ frame_info_ptr frame = frame_find_by_id (c->frame_id);
gdbarch *arch = get_frame_arch (frame);
int gdb_regnum = dwarf_reg_to_regnum_or_error (arch, p->v.regno);
ULONGEST reg_bits = 8 * register_size (arch, gdb_regnum);
}
gdb_assert (piece != NULL && c->per_cu != nullptr);
- frame_info *frame = get_selected_frame (_("No frame selected."));
+ frame_info_ptr frame = get_selected_frame (_("No frame selected."));
/* This is an offset requested by GDB, such as value subscripts.
However, due to how synthetic pointers are implemented, this is
{
const piece_closure *closure
= (piece_closure *) value_computed_closure (value);
- frame_info *frame
+ frame_info_ptr frame
= get_selected_frame (_("No frame selected."));
/* gdb represents synthetic pointers as pieced values with a single
}
struct type *type = lookup_pointer_type (die_type);
- frame_info *frame = get_selected_frame (_("No frame selected."));
+ frame_info_ptr frame = get_selected_frame (_("No frame selected."));
return indirect_synthetic_pointer (sect_off, 0, per_cu, per_objfile, frame,
type, true);
}
{
ensure_have_per_cu (this->m_per_cu, "DW_OP_call");
- frame_info *frame = this->m_frame;
+ frame_info_ptr frame = this->m_frame;
auto get_pc_from_frame = [frame] ()
{
dwarf2_per_cu_data *caller_per_cu;
dwarf2_per_objfile *caller_per_objfile;
- frame_info *caller_frame = get_prev_frame (this->m_frame);
+ frame_info_ptr caller_frame = get_prev_frame (this->m_frame);
call_site_parameter *parameter
= dwarf_expr_reg_to_entry_parameter (this->m_frame, kind, kind_u,
&caller_per_cu,
value *
dwarf_expr_context::evaluate (const gdb_byte *addr, size_t len, bool as_lval,
- dwarf2_per_cu_data *per_cu, frame_info *frame,
+ dwarf2_per_cu_data *per_cu, 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 *frame,
+ dwarf2_per_cu_data *per_cu, frame_info_ptr frame,
const struct property_addr_info *addr_info = nullptr,
struct type *type = nullptr,
struct type *subobj_type = nullptr,
dwarf2_per_objfile *m_per_objfile;
/* Frame information used for the evaluation. */
- frame_info *m_frame = nullptr;
+ frame_info_ptr m_frame = nullptr;
/* Compilation unit used for the evaluation. */
dwarf2_per_cu_data *m_per_cu = 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 *frame, int reg);
+CORE_ADDR read_addr_from_reg (frame_info_ptr frame, int reg);
void dwarf_expr_require_composition (const gdb_byte *, const gdb_byte *,
const char *);
struct tailcall_cache
{
/* It must be the first one of this struct. It is the furthest callee. */
- struct frame_info *next_bottom_frame;
+ frame_info *next_bottom_frame;
/* Reference count. The whole chain of virtual tail call frames shares one
tailcall_cache. */
tailcall_cache. */
static struct tailcall_cache *
-cache_new_ref1 (struct frame_info *next_bottom_frame)
+cache_new_ref1 (frame_info_ptr next_bottom_frame)
{
struct tailcall_cache *cache = XCNEW (struct tailcall_cache);
void **slot;
- cache->next_bottom_frame = next_bottom_frame;
+ cache->next_bottom_frame = next_bottom_frame.get ();
cache->refc = 1;
slot = htab_find_slot (cache_htab, cache, INSERT);
return 0. */
static int
-frame_is_tailcall (struct frame_info *fi)
+frame_is_tailcall (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 (struct frame_info *fi)
+cache_find (frame_info_ptr fi)
{
struct tailcall_cache *cache;
+ struct tailcall_cache search;
void **slot;
while (frame_is_tailcall (fi))
gdb_assert (fi != NULL);
}
- slot = htab_find_slot (cache_htab, &fi, NO_INSERT);
+ search.next_bottom_frame = fi.get();
+ search.refc = 1;
+ slot = htab_find_slot (cache_htab, &search, NO_INSERT);
if (slot == NULL)
return NULL;
If THIS_FRAME is CACHE-> NEXT_BOTTOM_FRAME return -1. */
static int
-existing_next_levels (struct frame_info *this_frame,
+existing_next_levels (frame_info_ptr this_frame,
struct tailcall_cache *cache)
{
int retval = (frame_relative_level (this_frame)
- - frame_relative_level (cache->next_bottom_frame) - 1);
+ - frame_relative_level (frame_info_ptr (cache->next_bottom_frame)) - 1);
gdb_assert (retval >= -1);
Specific virtual tail call frames are tracked by INLINE_DEPTH. */
static void
-tailcall_frame_this_id (struct frame_info *this_frame, void **this_cache,
+tailcall_frame_this_id (frame_info_ptr this_frame, void **this_cache,
struct frame_id *this_id)
{
struct tailcall_cache *cache = (struct tailcall_cache *) *this_cache;
- struct frame_info *next_frame;
+ frame_info_ptr next_frame;
/* Tail call does not make sense for a sentinel frame. */
next_frame = get_next_frame (this_frame);
CACHE. */
static CORE_ADDR
-pretend_pc (struct frame_info *this_frame, struct tailcall_cache *cache)
+pretend_pc (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 (struct frame_info *this_frame,
+dwarf2_tailcall_prev_register_first (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 (struct frame_info *this_frame,
+tailcall_frame_prev_register (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,
- struct frame_info *this_frame, void **this_cache)
+ frame_info_ptr this_frame, void **this_cache)
{
- struct frame_info *next_frame;
+ frame_info_ptr next_frame;
int next_levels;
struct tailcall_cache *cache;
address pushed on the stack. */
void
-dwarf2_tailcall_sniffer_first (struct frame_info *this_frame,
+dwarf2_tailcall_sniffer_first (frame_info_ptr this_frame,
void **tailcall_cachep,
const LONGEST *entry_cfa_sp_offsetp)
{
TAILCALL_FRAME. */
static void
-tailcall_frame_dealloc_cache (struct frame_info *self, void *this_cache)
+tailcall_frame_dealloc_cache (frame_info *self, void *this_cache)
{
struct tailcall_cache *cache = (struct tailcall_cache *) this_cache;
call frames have gdbarch of the bottom (callee) frame. */
static struct gdbarch *
-tailcall_frame_prev_arch (struct frame_info *this_frame,
+tailcall_frame_prev_arch (frame_info_ptr this_frame,
void **this_prologue_cache)
{
struct tailcall_cache *cache = (struct tailcall_cache *) *this_prologue_cache;
- return get_frame_arch (cache->next_bottom_frame);
+ return get_frame_arch (frame_info_ptr (cache->next_bottom_frame));
}
/* Virtual tail call frame unwinder if dwarf2_tailcall_sniffer_first finds
#ifndef DWARF2_FRAME_TAILCALL_H
#define DWARF2_FRAME_TAILCALL_H 1
-struct frame_info;
+class frame_info_ptr;
struct frame_unwind;
/* The tail call frame unwinder. */
extern void
- dwarf2_tailcall_sniffer_first (struct frame_info *this_frame,
+ dwarf2_tailcall_sniffer_first (frame_info_ptr this_frame,
void **tailcall_cachep,
const LONGEST *entry_cfa_sp_offsetp);
extern struct value *
- dwarf2_tailcall_prev_register_first (struct frame_info *this_frame,
+ dwarf2_tailcall_prev_register_first (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,
- struct frame_info *this_frame, CORE_ADDR initial,
+ 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,
- struct frame_info *this_frame);
+ 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 *,
- struct frame_info *)
+ frame_info_ptr)
= dwarf2_frame_default_init_reg;
/* Check whether the THIS_FRAME is a signal trampoline. */
- int (*signal_frame_p) (struct gdbarch *, struct frame_info *) = nullptr;
+ int (*signal_frame_p) (struct gdbarch *, 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,
- struct frame_info *this_frame)
+ 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 *,
- struct frame_info *))
+ 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,
- struct frame_info *this_frame)
+ 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 *,
- struct frame_info *))
+ frame_info_ptr ))
{
struct dwarf2_frame_ops *ops = get_frame_ops (gdbarch);
static int
dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
- struct frame_info *this_frame)
+ frame_info_ptr this_frame)
{
struct dwarf2_frame_ops *ops = get_frame_ops (gdbarch);
};
static struct dwarf2_frame_cache *
-dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache)
+dwarf2_frame_cache (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 (struct frame_info *this_frame,
+dwarf2_frame_unwind_stop_reason (frame_info_ptr this_frame,
void **this_cache)
{
struct dwarf2_frame_cache *cache
}
static void
-dwarf2_frame_this_id (struct frame_info *this_frame, void **this_cache,
+dwarf2_frame_this_id (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 (struct frame_info *this_frame, void **this_cache,
+dwarf2_frame_prev_register (frame_info_ptr this_frame, void **this_cache,
int regnum)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
call frames chain. */
static void
-dwarf2_frame_dealloc_cache (struct frame_info *self, void *this_cache)
+dwarf2_frame_dealloc_cache (frame_info *self, void *this_cache)
{
- struct dwarf2_frame_cache *cache = dwarf2_frame_cache (self, &this_cache);
+ struct dwarf2_frame_cache *cache
+ = dwarf2_frame_cache (frame_info_ptr (self), &this_cache);
if (cache->tailcall_cache)
dwarf2_tailcall_frame_unwind.dealloc_cache (self, cache->tailcall_cache);
static int
dwarf2_frame_sniffer (const struct frame_unwind *self,
- struct frame_info *this_frame, void **this_cache)
+ 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 (struct frame_info *this_frame, void **this_cache)
+dwarf2_frame_base_address (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 (struct frame_info *this_frame)
+dwarf2_frame_base_sniffer (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 (struct frame_info *this_frame)
+dwarf2_frame_cfa (frame_info_ptr this_frame)
{
if (frame_unwinder_is (this_frame, &record_btrace_tailcall_frame_unwind)
|| frame_unwinder_is (this_frame, &record_btrace_frame_unwind))
#define DWARF2_FRAME_H 1
struct gdbarch;
-struct frame_info;
+class frame_info_ptr;
struct dwarf2_per_cu_data;
struct agent_expr;
struct axs_value;
const gdb_byte *start;
ULONGEST len;
} exp;
- struct value *(*fn) (struct frame_info *this_frame, void **this_cache,
+ struct value *(*fn) (frame_info_ptr this_frame, void **this_cache,
int regnum);
} loc;
enum dwarf2_frame_reg_rule how;
extern void dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
void (*init_reg) (struct gdbarch *, int,
struct dwarf2_frame_state_reg *,
- struct frame_info *));
+ 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 *,
- struct frame_info *));
+ 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 (struct frame_info *this_frame);
+ dwarf2_frame_base_sniffer (frame_info_ptr this_frame);
/* Compute the DWARF CFA for a frame. */
-CORE_ADDR dwarf2_frame_cfa (struct frame_info *this_frame);
+CORE_ADDR dwarf2_frame_cfa (frame_info_ptr this_frame);
/* Find the CFA information for PC.
#include "gdbsupport/byte-vector.h"
static struct value *dwarf2_evaluate_loc_desc_full
- (struct type *type, struct frame_info *frame, const gdb_byte *data,
+ (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,
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, struct frame_info *frame)
+locexpr_get_frame_base (struct symbol *framefunc, 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, struct frame_info *frame)
+loclist_get_frame_base (struct symbol *framefunc, frame_info_ptr frame)
{
struct gdbarch *gdbarch;
struct type *type;
call_site_target::iterate_over_addresses
(struct gdbarch *call_site_gdbarch,
const struct call_site *call_site,
- struct frame_info *caller_frame,
+ 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 (struct frame_info *frame,
+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,
{
CORE_ADDR func_addr, caller_pc;
struct gdbarch *gdbarch;
- struct frame_info *caller_frame;
+ frame_info_ptr caller_frame;
struct call_site *call_site;
int iparams;
/* Initialize it just to avoid a GCC false warning. */
static struct value *
dwarf_entry_parameter_to_value (struct call_site_parameter *parameter,
CORE_ADDR deref_size, struct type *type,
- struct frame_info *caller_frame,
+ frame_info_ptr caller_frame,
dwarf2_per_cu_data *per_cu,
dwarf2_per_objfile *per_objfile)
{
cannot resolve the parameter for any reason. */
static struct value *
-value_of_dwarf_reg_entry (struct type *type, struct frame_info *frame,
+value_of_dwarf_reg_entry (struct type *type, frame_info_ptr frame,
enum call_site_parameter_kind kind,
union call_site_parameter_u kind_u)
{
struct type *checked_type = check_typedef (type);
struct type *target_type = checked_type->target_type ();
- struct frame_info *caller_frame = get_prev_frame (frame);
+ frame_info_ptr caller_frame = get_prev_frame (frame);
struct value *outer_val, *target_val, *val;
struct call_site_parameter *parameter;
dwarf2_per_cu_data *caller_per_cu;
cannot resolve the parameter for any reason. */
static struct value *
-value_of_dwarf_block_entry (struct type *type, struct frame_info *frame,
+value_of_dwarf_block_entry (struct type *type, 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,
- struct frame_info *frame, struct type *type,
+ 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, struct frame_info *frame,
+dwarf2_evaluate_loc_desc_full (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,
passes 0 as the byte_offset. */
struct value *
-dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
+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)
static int
dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton,
- struct frame_info *frame,
+ frame_info_ptr frame,
const struct property_addr_info *addr_stack,
CORE_ADDR *valp,
gdb::array_view<CORE_ADDR> push_values,
bool
dwarf2_evaluate_property (const struct dynamic_prop *prop,
- struct frame_info *frame,
+ frame_info_ptr frame,
const struct property_addr_info *addr_stack,
CORE_ADDR *value,
gdb::array_view<CORE_ADDR> push_values)
/* 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, struct frame_info *frame)
+locexpr_read_variable (struct symbol *symbol, 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, struct frame_info *frame)
+locexpr_read_variable_at_entry (struct symbol *symbol, 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, struct frame_info *frame)
+loclist_read_variable (struct symbol *symbol, 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, struct frame_info *frame)
+loclist_read_variable_at_entry (struct symbol *symbol, frame_info_ptr frame)
{
struct dwarf2_loclist_baton *dlbaton
= (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (symbol);
otherwise. */
struct call_site_parameter *dwarf_expr_reg_to_entry_parameter
- (struct frame_info *frame, enum call_site_parameter_kind kind,
+ (frame_info_ptr frame, enum call_site_parameter_kind kind,
union call_site_parameter_u kind_u, dwarf2_per_cu_data **per_cu_return,
dwarf2_per_objfile **per_objfile_return);
be a value or a location description. */
struct value *dwarf2_evaluate_loc_desc (struct type *type,
- struct frame_info *frame,
+ frame_info_ptr frame,
const gdb_byte *data,
size_t size,
dwarf2_per_cu_data *per_cu,
bottom of the stack. */
bool dwarf2_evaluate_property (const struct dynamic_prop *prop,
- struct frame_info *frame,
+ frame_info_ptr frame,
const struct 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, struct frame_info *frame,
+ dwarf2_per_objfile *per_objfile, frame_info_ptr frame,
struct type *type, bool resolve_abstract_p = false);
#endif /* DWARF2LOC_H */
elf_gnu_ifunc_resolver_stop (code_breakpoint *b)
{
struct breakpoint *b_return;
- struct frame_info *prev_frame = get_prev_frame (get_current_frame ());
+ frame_info_ptr prev_frame = get_prev_frame (get_current_frame ());
struct frame_id prev_frame_id = get_stack_frame_id (prev_frame);
CORE_ADDR prev_pc = get_frame_pc (prev_frame);
int thread_id = inferior_thread ()->global_num;
error (_("Symbol \"%s\" does not have any specific entry value"),
sym->print_name ());
- struct frame_info *frame = get_selected_frame (NULL);
+ frame_info_ptr frame = get_selected_frame (NULL);
return SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry (sym, frame);
}
or SCR_BT_COMPLETED on success. */
enum ext_lang_bt_status (*apply_frame_filter)
(const struct extension_language_defn *,
- struct frame_info *frame, frame_filter_flags flags,
+ 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 (struct frame_info *frame,
+apply_ext_lang_frame_filter (frame_info_ptr frame,
frame_filter_flags flags,
enum ext_lang_frame_args args_type,
struct ui_out *out,
struct breakpoint;
struct command_line;
-struct frame_info;
+class frame_info_ptr;
struct language_defn;
struct objfile;
struct extension_language_defn;
const struct language_defn *language);
extern enum ext_lang_bt_status apply_ext_lang_frame_filter
- (struct frame_info *frame, frame_filter_flags flags,
+ (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);
static void
info_common_command (const char *comname, int from_tty)
{
- struct frame_info *fi;
+ frame_info_ptr fi;
const struct block *block;
int values_printed = 0;
determined by register_type (). */
struct value *
-value_of_register (int regnum, struct frame_info *frame)
+value_of_register (int regnum, frame_info_ptr frame)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
struct value *reg_val;
determined by register_type (). The value is not fetched. */
struct value *
-value_of_register_lazy (struct frame_info *frame, int regnum)
+value_of_register_lazy (frame_info_ptr frame, int regnum)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
struct value *reg_val;
- struct frame_info *next_frame;
+ frame_info_ptr next_frame;
gdb_assert (regnum < gdbarch_num_cooked_regs (gdbarch));
the static links points to and return it. Return NULL if we could not find
such a frame. */
-static struct frame_info *
-follow_static_link (struct frame_info *frame,
+static frame_info_ptr
+follow_static_link (frame_info_ptr frame,
const struct dynamic_prop *static_link)
{
CORE_ADDR upper_frame_base;
For backward compatibility purposes (with old compilers), we then look for
the first frame that can host it. */
-static struct frame_info *
+static frame_info_ptr
get_hosting_frame (struct symbol *var, const struct block *var_block,
- struct frame_info *frame)
+ frame_info_ptr frame)
{
const struct block *frame_block = NULL;
struct value *
language_defn::read_var_value (struct symbol *var,
const struct block *var_block,
- struct frame_info *frame) const
+ frame_info_ptr frame) const
{
struct value *v;
struct type *type = var->type ();
struct value *
read_var_value (struct symbol *var, const struct block *var_block,
- struct frame_info *frame)
+ frame_info_ptr frame)
{
const struct language_defn *lang = language_def (var->language ());
{
int len = type->length ();
struct value *value = allocate_value (type);
- struct frame_info *frame;
+ frame_info_ptr frame;
VALUE_LVAL (value) = lval_register;
frame = frame_find_by_id (frame_id);
complete resulting value as optimized out. */
void
-read_frame_register_value (struct value *value, struct frame_info *frame)
+read_frame_register_value (struct value *value, frame_info_ptr frame)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
LONGEST offset = 0;
/* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
struct value *
-value_from_register (struct type *type, int regnum, struct frame_info *frame)
+value_from_register (struct type *type, int regnum, 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, struct frame_info *frame)
+address_from_register (int regnum, frame_info_ptr frame)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
struct type *type = builtin_type (gdbarch)->builtin_data_ptr;
really need to override this. */
static CORE_ADDR
-default_frame_base_address (struct frame_info *this_frame, void **this_cache)
+default_frame_base_address (frame_info_ptr this_frame, void **this_cache)
{
return get_frame_base (this_frame); /* sigh! */
}
static CORE_ADDR
-default_frame_locals_address (struct frame_info *this_frame, void **this_cache)
+default_frame_locals_address (frame_info_ptr this_frame, void **this_cache)
{
return default_frame_base_address (this_frame, this_cache);
}
static CORE_ADDR
-default_frame_args_address (struct frame_info *this_frame, void **this_cache)
+default_frame_args_address (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 (struct frame_info *this_frame)
+frame_base_find_by_frame (frame_info_ptr this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct frame_base_table *table = get_frame_base_table (gdbarch);
#if !defined (FRAME_BASE_H)
#define FRAME_BASE_H 1
-struct frame_info;
+class frame_info_ptr;
struct frame_id;
struct frame_unwind;
struct frame_base;
/* A generic base address. */
-typedef CORE_ADDR (frame_this_base_ftype) (struct frame_info *this_frame,
+typedef CORE_ADDR (frame_this_base_ftype) (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) (struct frame_info *this_frame,
+typedef CORE_ADDR (frame_this_locals_ftype) (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) (struct frame_info *this_frame,
+typedef CORE_ADDR (frame_this_args_ftype) (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) (struct frame_info *this_frame);
+typedef const struct frame_base *(frame_base_sniffer_ftype) (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 (struct frame_info *this_frame);
+extern const struct frame_base *frame_base_find_by_frame (frame_info_ptr this_frame);
#endif
unchanged and returns 0. */
static int
-frame_unwind_try_unwinder (struct frame_info *this_frame, void **this_cache,
+frame_unwind_try_unwinder (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 (struct frame_info *this_frame, void **this_cache)
+frame_unwind_find_by_frame (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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame,
+default_frame_unwind_stop_reason (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, struct frame_info *next_frame)
+default_unwind_pc (struct gdbarch *gdbarch, 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, struct frame_info *next_frame)
+default_unwind_sp (struct gdbarch *gdbarch, 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 (struct frame_info *frame, int regnum)
+frame_unwind_got_optimized (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 (struct frame_info *frame,
+frame_unwind_got_register (frame_info_ptr frame,
int regnum, int new_regnum)
{
return value_of_register_lazy (frame, new_regnum);
ADDR. */
struct value *
-frame_unwind_got_memory (struct frame_info *frame, int regnum, CORE_ADDR addr)
+frame_unwind_got_memory (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 (struct frame_info *frame, int regnum,
+frame_unwind_got_constant (frame_info_ptr frame, int regnum,
ULONGEST val)
{
struct gdbarch *gdbarch = frame_unwind_arch (frame);
}
struct value *
-frame_unwind_got_bytes (struct frame_info *frame, int regnum, const gdb_byte *buf)
+frame_unwind_got_bytes (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 (struct frame_info *frame, int regnum,
+frame_unwind_got_address (frame_info_ptr frame, int regnum,
CORE_ADDR addr)
{
struct gdbarch *gdbarch = frame_unwind_arch (frame);
#define FRAME_UNWIND_H 1
struct frame_data;
-struct frame_info;
+class frame_info_ptr;
struct frame_id;
struct frame_unwind;
struct gdbarch;
to set *THIS_PROLOGUE_CACHE to NULL. */
typedef int (frame_sniffer_ftype) (const struct frame_unwind *self,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_prologue_cache);
typedef enum unwind_stop_reason (frame_unwind_stop_reason_ftype)
- (struct frame_info *this_frame, void **this_prologue_cache);
+ (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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame,
+ default_frame_unwind_stop_reason (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,
- struct frame_info *next_frame);
+ 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,
- struct frame_info *next_frame);
+ 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) (struct frame_info *this_frame,
+typedef void (frame_this_id_ftype) (frame_info_ptr this_frame,
void **this_prologue_cache,
struct frame_id *this_id);
allocated using FRAME_OBSTACK_ZALLOC(). */
typedef struct value * (frame_prev_register_ftype)
- (struct frame_info *this_frame, void **this_prologue_cache,
+ (frame_info_ptr this_frame, void **this_prologue_cache,
int regnum);
/* Deallocate extra memory associated with the frame cache if any. */
-typedef void (frame_dealloc_cache_ftype) (struct frame_info *self,
+typedef void (frame_dealloc_cache_ftype) (frame_info *self,
void *this_cache);
/* Assuming the frame chain: (outer) prev <-> this <-> next (inner);
use THIS frame, and implicitly the NEXT frame's register unwind
method, return PREV frame's architecture. */
-typedef struct gdbarch *(frame_prev_arch_ftype) (struct frame_info *this_frame,
+typedef struct gdbarch *(frame_prev_arch_ftype) (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 (struct frame_info *this_frame,
+extern void frame_unwind_find_by_frame (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 (struct frame_info *frame,
+struct value *frame_unwind_got_optimized (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 (struct frame_info *frame, int regnum,
+struct value *frame_unwind_got_register (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 (struct frame_info *frame, int regnum,
+struct value *frame_unwind_got_memory (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 (struct frame_info *frame, int regnum,
+struct value *frame_unwind_got_constant (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 (struct frame_info *frame, int regnum,
+struct value *frame_unwind_got_bytes (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 (struct frame_info *frame, int regnum,
+struct value *frame_unwind_got_address (frame_info_ptr frame, int regnum,
CORE_ADDR addr);
#endif
The current frame, which is the innermost frame, can be found at
sentinel_frame->prev. */
-static struct frame_info *sentinel_frame;
+static frame_info *sentinel_frame;
/* Number of calls to reinit_frame_cache. */
static unsigned int frame_cache_generation = 0;
/* The values behind the global "set backtrace ..." settings. */
set_backtrace_options user_set_backtrace_options;
-static struct frame_info *get_prev_frame_raw (struct frame_info *this_frame);
+static frame_info_ptr get_prev_frame_raw (frame_info_ptr this_frame);
static const char *frame_stop_reason_symbol_string (enum unwind_stop_reason reason);
/* Status of some values cached in the frame_info object. */
/* See frame.h. */
void
-set_frame_previous_pc_masked (struct frame_info *frame)
+set_frame_previous_pc_masked (frame_info_ptr frame)
{
frame->prev_pc.masked = true;
}
/* See frame.h. */
bool
-get_frame_pc_masked (const struct frame_info *frame)
+get_frame_pc_masked (frame_info_ptr frame)
{
gdb_assert (frame->next != nullptr);
gdb_assert (frame->next->prev_pc.status == CC_VALUE);
static hashval_t
frame_addr_hash (const void *ap)
{
- const struct frame_info *frame = (const struct frame_info *) ap;
+ const frame_info *frame = (const frame_info *) ap;
const struct frame_id f_id = frame->this_id.value;
hashval_t hash = 0;
static int
frame_addr_hash_eq (const void *a, const void *b)
{
- const struct frame_info *f_entry = (const struct frame_info *) a;
- const struct frame_info *f_element = (const struct frame_info *) b;
+ const frame_info *f_entry = (const frame_info *) a;
+ const frame_info *f_element = (const frame_info *) b;
return f_entry->this_id.value == f_element->this_id.value;
}
/* Do not try to stash the sentinel frame. */
gdb_assert (frame->level >= 0);
- frame_info **slot = (struct frame_info **) htab_find_slot (frame_stash,
- frame, INSERT);
+ frame_info **slot = (frame_info **) htab_find_slot (frame_stash,
+ frame, INSERT);
/* If we already have a frame in the stack with the same id, we
either have a stack cycle (corrupted stack?), or some bug
given frame ID. If found, return that frame. Otherwise return
NULL. */
-static struct frame_info *
+static frame_info_ptr
frame_stash_find (struct frame_id id)
{
struct frame_info dummy;
- struct frame_info *frame;
+ frame_info *frame;
dummy.this_id.value = id;
- frame = (struct frame_info *) htab_find (frame_stash, &dummy);
- return frame;
+ frame = (frame_info *) htab_find (frame_stash, &dummy);
+ return frame_info_ptr (frame);
}
/* Internal function to invalidate the frame stash by removing all
Return FRAME if FRAME is a non-artificial frame.
Return NULL if FRAME is the start of an artificial-only chain. */
-static struct frame_info *
-skip_artificial_frames (struct frame_info *frame)
+static frame_info_ptr
+skip_artificial_frames (frame_info_ptr frame)
{
/* Note we use get_prev_frame_always, and not get_prev_frame. The
latter will truncate the frame chain, leading to this function
return frame;
}
-struct frame_info *
-skip_unwritable_frames (struct frame_info *frame)
+frame_info_ptr
+skip_unwritable_frames (frame_info_ptr frame)
{
while (gdbarch_code_of_frame_writable (get_frame_arch (frame), frame) == 0)
{
/* See frame.h. */
-struct frame_info *
-skip_tailcall_frames (struct frame_info *frame)
+frame_info_ptr
+skip_tailcall_frames (frame_info_ptr frame)
{
while (get_frame_type (frame) == TAILCALL_FRAME)
{
frame. */
static void
-compute_frame_id (struct frame_info *fi)
+compute_frame_id (frame_info_ptr fi)
{
FRAME_SCOPED_DEBUG_ENTER_EXIT;
frame. */
struct frame_id
-get_frame_id (struct frame_info *fi)
+get_frame_id (frame_info_ptr fi)
{
if (fi == NULL)
return null_frame_id;
/* Since this is the first frame in the chain, this should
always succeed. */
- bool stashed = frame_stash_add (fi);
+ bool stashed = frame_stash_add (fi.get ());
gdb_assert (stashed);
}
}
struct frame_id
-get_stack_frame_id (struct frame_info *next_frame)
+get_stack_frame_id (frame_info_ptr next_frame)
{
return get_frame_id (skip_artificial_frames (next_frame));
}
struct frame_id
-frame_unwind_caller_id (struct frame_info *next_frame)
+frame_unwind_caller_id (frame_info_ptr next_frame)
{
- struct frame_info *this_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
return inner;
}
-struct frame_info *
+frame_info_ptr
frame_find_by_id (struct frame_id id)
{
- struct frame_info *frame, *prev_frame;
+ frame_info_ptr frame, prev_frame;
/* ZERO denotes the null frame, let the caller decide what to do
about it. Should it instead return get_current_frame()? */
/* Check for the sentinel frame. */
if (id == sentinel_frame_id)
- return sentinel_frame;
+ return frame_info_ptr (sentinel_frame);
/* Try using the frame stash first. Finding it there removes the need
to perform the search by looping over all frames, which can be very
}
static CORE_ADDR
-frame_unwind_pc (struct frame_info *this_frame)
+frame_unwind_pc (frame_info_ptr this_frame)
{
if (this_frame->prev_pc.status == CC_UNKNOWN)
{
}
CORE_ADDR
-frame_unwind_caller_pc (struct frame_info *this_frame)
+frame_unwind_caller_pc (frame_info_ptr this_frame)
{
this_frame = skip_artificial_frames (this_frame);
}
bool
-get_frame_func_if_available (frame_info *this_frame, CORE_ADDR *pc)
+get_frame_func_if_available (frame_info_ptr this_frame, CORE_ADDR *pc)
{
- struct frame_info *next_frame = this_frame->next;
+ frame_info *next_frame = this_frame->next;
if (next_frame->prev_func.status == CC_UNKNOWN)
{
}
CORE_ADDR
-get_frame_func (struct frame_info *this_frame)
+get_frame_func (frame_info_ptr this_frame)
{
CORE_ADDR pc;
}
std::unique_ptr<readonly_detached_regcache>
-frame_save_as_regcache (struct frame_info *this_frame)
+frame_save_as_regcache (frame_info_ptr this_frame)
{
auto cooked_read = [this_frame] (int regnum, gdb_byte *buf)
{
}
void
-frame_pop (struct frame_info *this_frame)
+frame_pop (frame_info_ptr this_frame)
{
- struct frame_info *prev_frame;
+ frame_info_ptr prev_frame;
if (get_frame_type (this_frame) == DUMMY_FRAME)
{
}
void
-frame_register_unwind (frame_info *next_frame, int regnum,
+frame_register_unwind (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_register (struct frame_info *frame, int regnum,
+frame_register (frame_info_ptr frame, int regnum,
int *optimizedp, int *unavailablep, enum lval_type *lvalp,
CORE_ADDR *addrp, int *realnump, gdb_byte *bufferp)
{
/* Obtain the register value by unwinding the register from the next
(more inner frame). */
gdb_assert (frame != NULL && frame->next != NULL);
- frame_register_unwind (frame->next, regnum, optimizedp, unavailablep,
- lvalp, addrp, realnump, bufferp);
+ frame_register_unwind (frame_info_ptr (frame->next), regnum, optimizedp,
+ unavailablep, lvalp, addrp, realnump, bufferp);
}
void
-frame_unwind_register (frame_info *next_frame, int regnum, gdb_byte *buf)
+frame_unwind_register (frame_info_ptr next_frame, int regnum, gdb_byte *buf)
{
int optimized;
int unavailable;
}
void
-get_frame_register (struct frame_info *frame,
+get_frame_register (frame_info_ptr frame,
int regnum, gdb_byte *buf)
{
- frame_unwind_register (frame->next, regnum, buf);
+ frame_unwind_register (frame_info_ptr (frame->next), regnum, buf);
}
struct value *
-frame_unwind_register_value (frame_info *next_frame, int regnum)
+frame_unwind_register_value (frame_info_ptr next_frame, int regnum)
{
FRAME_SCOPED_DEBUG_ENTER_EXIT;
}
struct value *
-get_frame_register_value (struct frame_info *frame, int regnum)
+get_frame_register_value (frame_info_ptr frame, int regnum)
{
- return frame_unwind_register_value (frame->next, regnum);
+ return frame_unwind_register_value (frame_info_ptr (frame->next), regnum);
}
LONGEST
-frame_unwind_register_signed (frame_info *next_frame, int regnum)
+frame_unwind_register_signed (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 (struct frame_info *frame, int regnum)
+get_frame_register_signed (frame_info_ptr frame, int regnum)
{
- return frame_unwind_register_signed (frame->next, regnum);
+ return frame_unwind_register_signed (frame_info_ptr (frame->next), regnum);
}
ULONGEST
-frame_unwind_register_unsigned (frame_info *next_frame, int regnum)
+frame_unwind_register_unsigned (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 (struct frame_info *frame, int regnum)
+get_frame_register_unsigned (frame_info_ptr frame, int regnum)
{
- return frame_unwind_register_unsigned (frame->next, regnum);
+ return frame_unwind_register_unsigned (frame_info_ptr (frame->next), regnum);
}
bool
-read_frame_register_unsigned (frame_info *frame, int regnum,
+read_frame_register_unsigned (frame_info_ptr frame, int regnum,
ULONGEST *val)
{
struct value *regval = get_frame_register_value (frame, regnum);
}
void
-put_frame_register (struct frame_info *frame, int regnum,
+put_frame_register (frame_info_ptr frame, int regnum,
const gdb_byte *buf)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
Returns 0 if the register value could not be found. */
bool
-deprecated_frame_register_read (frame_info *frame, int regnum,
+deprecated_frame_register_read (frame_info_ptr frame, int regnum,
gdb_byte *myaddr)
{
int optimized;
}
bool
-get_frame_register_bytes (frame_info *frame, int regnum,
+get_frame_register_bytes (frame_info_ptr frame, int regnum,
CORE_ADDR offset,
gdb::array_view<gdb_byte> buffer,
int *optimizedp, int *unavailablep)
}
else
{
- struct value *value = frame_unwind_register_value (frame->next,
- regnum);
+ struct value *value
+ = frame_unwind_register_value (frame_info_ptr (frame->next),
+ regnum);
gdb_assert (value != NULL);
*optimizedp = value_optimized_out (value);
*unavailablep = !value_entirely_available (value);
}
void
-put_frame_register_bytes (struct frame_info *frame, int regnum,
+put_frame_register_bytes (frame_info_ptr frame, int regnum,
CORE_ADDR offset,
gdb::array_view<const gdb_byte> buffer)
{
}
else
{
- struct value *value = frame_unwind_register_value (frame->next,
- regnum);
+ struct value *value
+ = frame_unwind_register_value (frame_info_ptr (frame->next),
+ regnum);
gdb_assert (value != NULL);
memcpy ((char *) value_contents_writeable (value).data () + offset,
/* Create a sentinel frame. */
-static struct frame_info *
+static frame_info *
create_sentinel_frame (struct program_space *pspace, struct regcache *regcache)
{
- struct frame_info *frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
+ frame_info *frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
frame->level = -1;
frame->pspace = pspace;
return data;
}
-static struct frame_info *get_prev_frame_always_1 (struct frame_info *this_frame);
+static frame_info_ptr get_prev_frame_always_1 (frame_info_ptr this_frame);
-struct frame_info *
+frame_info_ptr
get_current_frame (void)
{
- struct frame_info *current_frame;
+ frame_info_ptr current_frame;
/* First check, and report, the lack of registers. Having GDB
report "No stack!" or "No memory" when the target doesn't even
want to leave with the current frame created and linked in --
we should never end up with the sentinel frame as outermost
frame. */
- current_frame = get_prev_frame_always_1 (sentinel_frame);
+ current_frame = get_prev_frame_always_1 (frame_info_ptr (sentinel_frame));
gdb_assert (current_frame != NULL);
return current_frame;
/* The cached frame_info object pointing to the selected frame.
Looked up on demand by get_selected_frame. */
-static struct frame_info *selected_frame;
+static frame_info_ptr selected_frame;
/* See frame.h. */
void
lookup_selected_frame (struct frame_id a_frame_id, int frame_level)
{
- struct frame_info *frame = NULL;
+ frame_info_ptr frame = NULL;
int count;
/* This either means there was no selected frame, or the selected
/* See frame.h. */
-struct frame_info *
+frame_info_ptr
get_selected_frame (const char *message)
{
if (selected_frame == NULL)
the inferior does not have a frame; in that case it will return
NULL instead of calling error(). */
-struct frame_info *
+frame_info_ptr
deprecated_safe_get_selected_frame (void)
{
if (!has_stack_frames ())
/* Select frame FI (or NULL - to invalidate the selected frame). */
void
-select_frame (struct frame_info *fi)
+select_frame (frame_info_ptr fi)
{
selected_frame = fi;
selected_frame_level = frame_relative_level (fi);
/* Create an arbitrary (i.e. address specified by user) or innermost frame.
Always returns a non-NULL value. */
-struct frame_info *
+frame_info_ptr
create_new_frame (CORE_ADDR addr, CORE_ADDR pc)
{
- struct frame_info *fi;
+ frame_info *fi;
frame_debug_printf ("addr=%s, pc=%s", hex_string (addr), hex_string (pc));
/* Select/initialize both the unwind function and the frame's type
based on the PC. */
- frame_unwind_find_by_frame (fi, &fi->prologue_cache);
+ frame_unwind_find_by_frame (frame_info_ptr (fi), &fi->prologue_cache);
fi->this_id.p = frame_id_status::COMPUTED;
fi->this_id.value = frame_id_build (addr, pc);
frame_debug_printf (" -> %s", fi->to_string ().c_str ());
- return fi;
+ return frame_info_ptr (fi);
}
/* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
innermost frame). Be careful to not fall off the bottom of the
frame chain and onto the sentinel frame. */
-struct frame_info *
-get_next_frame (struct frame_info *this_frame)
+frame_info_ptr
+get_next_frame (frame_info_ptr this_frame)
{
if (this_frame->level > 0)
- return this_frame->next;
+ return frame_info_ptr (this_frame->next);
else
return NULL;
}
innermost (i.e. current) frame, return the sentinel frame. Thus,
unlike get_next_frame(), NULL will never be returned. */
-struct frame_info *
-get_next_frame_sentinel_okay (struct frame_info *this_frame)
+frame_info_ptr
+get_next_frame_sentinel_okay (frame_info_ptr this_frame)
{
gdb_assert (this_frame != NULL);
is likely a coding error. */
gdb_assert (this_frame != sentinel_frame);
- return this_frame->next;
+ return frame_info_ptr (this_frame->next);
}
/* Observer for the target_changed event. */
void
reinit_frame_cache (void)
{
- struct frame_info *fi;
-
++frame_cache_generation;
/* Tear down all frame caches. */
- for (fi = sentinel_frame; fi != NULL; fi = fi->prev)
+ for (frame_info *fi = sentinel_frame; fi != NULL; fi = fi->prev)
{
if (fi->prologue_cache && fi->unwind->dealloc_cache)
fi->unwind->dealloc_cache (fi, fi->prologue_cache);
relative to this particular frame. */
static void
-frame_register_unwind_location (struct frame_info *this_frame, int regnum,
+frame_register_unwind_location (frame_info_ptr this_frame, int regnum,
int *optimizedp, enum lval_type *lvalp,
CORE_ADDR *addrp, int *realnump)
{
then the frame_id of the inline frame, calculated based off the frame_id
of the previous frame, should also be a duplicate. */
-static struct frame_info *
-get_prev_frame_maybe_check_cycle (struct frame_info *this_frame)
+static frame_info_ptr
+get_prev_frame_maybe_check_cycle (frame_info_ptr this_frame)
{
- struct frame_info *prev_frame = get_prev_frame_raw (this_frame);
+ frame_info_ptr prev_frame = get_prev_frame_raw (this_frame);
/* Don't compute the frame id of the current frame yet. Unwinding
the sentinel frame can fail (e.g., if the thread is gone and we
PREV_FRAME into the cache; if PREV_FRAME is unique then we do want
it in the cache, but if it is a duplicate and CYCLE_DETECTION_P is
false, then we don't want to unlink it. */
- if (!frame_stash_add (prev_frame) && cycle_detection_p)
+ if (!frame_stash_add (prev_frame.get ()) && cycle_detection_p)
{
/* Another frame with the same id was already in the stash. We just
detected a cycle. */
TRY_CATCH block. Return the frame that called THIS_FRAME or NULL if
there is no such frame. This may throw an exception. */
-static struct frame_info *
-get_prev_frame_always_1 (struct frame_info *this_frame)
+static frame_info_ptr
+get_prev_frame_always_1 (frame_info_ptr this_frame)
{
FRAME_SCOPED_DEBUG_ENTER_EXIT;
frame_debug_printf
(" -> nullptr // %s // cached",
frame_stop_reason_symbol_string (this_frame->stop_reason));
- return this_frame->prev;
+ return frame_info_ptr (this_frame->prev);
}
/* If the frame unwinder hasn't been selected yet, we must do so
See the comment at frame_id_inner for details. */
if (get_frame_type (this_frame) == NORMAL_FRAME
&& this_frame->next->unwind->type == NORMAL_FRAME
- && frame_id_inner (get_frame_arch (this_frame->next),
+ && frame_id_inner (get_frame_arch (frame_info_ptr (this_frame->next)),
get_frame_id (this_frame),
- get_frame_id (this_frame->next)))
+ get_frame_id (frame_info_ptr (this_frame->next))))
{
CORE_ADDR this_pc_in_block;
struct minimal_symbol *morestack_msym;
if (this_frame->level > 0
&& gdbarch_pc_regnum (gdbarch) >= 0
&& get_frame_type (this_frame) == NORMAL_FRAME
- && (get_frame_type (this_frame->next) == NORMAL_FRAME
- || get_frame_type (this_frame->next) == INLINE_FRAME))
+ && (get_frame_type (frame_info_ptr (this_frame->next)) == NORMAL_FRAME
+ || get_frame_type (frame_info_ptr (this_frame->next)) == INLINE_FRAME))
{
int optimized, realnum, nrealnum;
enum lval_type lval, nlval;
Unlike get_prev_frame, this function always tries to unwind the
frame. */
-struct frame_info *
-get_prev_frame_always (struct frame_info *this_frame)
+frame_info_ptr
+get_prev_frame_always (frame_info_ptr this_frame)
{
- struct frame_info *prev_frame = NULL;
+ frame_info_ptr prev_frame = NULL;
try
{
/* Construct a new "struct frame_info" and link it previous to
this_frame. */
-static struct frame_info *
-get_prev_frame_raw (struct frame_info *this_frame)
+static frame_info_ptr
+get_prev_frame_raw (frame_info_ptr this_frame)
{
- struct frame_info *prev_frame;
+ frame_info *prev_frame;
/* Allocate the new frame but do not wire it in to the frame chain.
Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
/* Link it in. */
this_frame->prev = prev_frame;
- prev_frame->next = this_frame;
+ prev_frame->next = this_frame.get ();
frame_debug_printf (" -> %s", prev_frame->to_string ().c_str ());
- return prev_frame;
+ return frame_info_ptr (prev_frame);
}
/* Debug routine to print a NULL frame being returned. */
static void
-frame_debug_got_null_frame (struct frame_info *this_frame,
+frame_debug_got_null_frame (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 *this_frame)
+inside_main_func (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 *this_frame)
+inside_entry_func (frame_info_ptr this_frame)
{
CORE_ADDR entry_point;
This function should not contain target-dependent tests, such as
checking whether the program-counter is zero. */
-struct frame_info *
-get_prev_frame (struct frame_info *this_frame)
+frame_info_ptr
+get_prev_frame (frame_info_ptr this_frame)
{
FRAME_SCOPED_DEBUG_ENTER_EXIT;
}
CORE_ADDR
-get_frame_pc (struct frame_info *frame)
+get_frame_pc (frame_info_ptr frame)
{
gdb_assert (frame->next != NULL);
- return frame_unwind_pc (frame->next);
+ return frame_unwind_pc (frame_info_ptr (frame->next));
}
bool
-get_frame_pc_if_available (frame_info *frame, CORE_ADDR *pc)
+get_frame_pc_if_available (frame_info_ptr frame, CORE_ADDR *pc)
{
gdb_assert (frame->next != NULL);
try
{
- *pc = frame_unwind_pc (frame->next);
+ *pc = frame_unwind_pc (frame_info_ptr (frame->next));
}
catch (const gdb_exception_error &ex)
{
/* Return an address that falls within THIS_FRAME's code block. */
CORE_ADDR
-get_frame_address_in_block (struct frame_info *this_frame)
+get_frame_address_in_block (frame_info_ptr this_frame)
{
/* A draft address. */
CORE_ADDR pc = get_frame_pc (this_frame);
- struct frame_info *next_frame = this_frame->next;
+ frame_info_ptr next_frame (this_frame->next);
/* Calling get_frame_pc returns the resume address for THIS_FRAME.
Normally the resume address is inside the body of the function
"calling" normal function should not be adjusted either. */
while (get_frame_type (next_frame) == INLINE_FRAME)
- next_frame = next_frame->next;
+ next_frame = frame_info_ptr (next_frame->next);
if ((get_frame_type (next_frame) == NORMAL_FRAME
|| get_frame_type (next_frame) == TAILCALL_FRAME)
}
bool
-get_frame_address_in_block_if_available (frame_info *this_frame,
+get_frame_address_in_block_if_available (frame_info_ptr this_frame,
CORE_ADDR *pc)
{
}
symtab_and_line
-find_frame_sal (frame_info *frame)
+find_frame_sal (frame_info_ptr frame)
{
- struct frame_info *next_frame;
+ frame_info_ptr next_frame;
int notcurrent;
CORE_ADDR pc;
/* Per "frame.h", return the ``address'' of the frame. Code should
really be using get_frame_id(). */
CORE_ADDR
-get_frame_base (struct frame_info *fi)
+get_frame_base (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 (struct frame_info *fi)
+get_frame_base_address (frame_info_ptr fi)
{
if (get_frame_type (fi) != NORMAL_FRAME)
return 0;
}
CORE_ADDR
-get_frame_locals_address (struct frame_info *fi)
+get_frame_locals_address (frame_info_ptr fi)
{
if (get_frame_type (fi) != NORMAL_FRAME)
return 0;
}
CORE_ADDR
-get_frame_args_address (struct frame_info *fi)
+get_frame_args_address (frame_info_ptr fi)
{
if (get_frame_type (fi) != NORMAL_FRAME)
return 0;
otherwise. */
bool
-frame_unwinder_is (frame_info *fi, const frame_unwind *unwinder)
+frame_unwinder_is (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 (struct frame_info *fi)
+frame_relative_level (frame_info_ptr fi)
{
if (fi == NULL)
return -1;
}
enum frame_type
-get_frame_type (struct frame_info *frame)
+get_frame_type (frame_info_ptr frame)
{
if (frame->unwind == NULL)
/* Initialize the frame's unwinder because that's what
}
struct program_space *
-get_frame_program_space (struct frame_info *frame)
+get_frame_program_space (frame_info_ptr frame)
{
return frame->pspace;
}
struct program_space *
-frame_unwind_program_space (struct frame_info *this_frame)
+frame_unwind_program_space (frame_info_ptr this_frame)
{
gdb_assert (this_frame);
}
const address_space *
-get_frame_address_space (struct frame_info *frame)
+get_frame_address_space (frame_info_ptr frame)
{
return frame->aspace;
}
/* Memory access methods. */
void
-get_frame_memory (struct frame_info *this_frame, CORE_ADDR addr,
+get_frame_memory (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 (struct frame_info *this_frame, CORE_ADDR addr,
+get_frame_memory_signed (frame_info_ptr this_frame, CORE_ADDR addr,
int len)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
ULONGEST
-get_frame_memory_unsigned (struct frame_info *this_frame, CORE_ADDR addr,
+get_frame_memory_unsigned (frame_info_ptr this_frame, CORE_ADDR addr,
int len)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
bool
-safe_frame_unwind_memory (struct frame_info *this_frame,
+safe_frame_unwind_memory (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 (struct frame_info *this_frame)
+get_frame_arch (frame_info_ptr this_frame)
{
- return frame_unwind_arch (this_frame->next);
+ return frame_unwind_arch (frame_info_ptr (this_frame->next));
}
struct gdbarch *
-frame_unwind_arch (struct frame_info *next_frame)
+frame_unwind_arch (frame_info_ptr next_frame)
{
if (!next_frame->prev_arch.p)
{
}
struct gdbarch *
-frame_unwind_caller_arch (struct frame_info *next_frame)
+frame_unwind_caller_arch (frame_info_ptr next_frame)
{
next_frame = skip_artificial_frames (next_frame);
/* Gets the language of FRAME. */
enum language
-get_frame_language (struct frame_info *frame)
+get_frame_language (frame_info_ptr frame)
{
CORE_ADDR pc = 0;
bool pc_p = false;
/* Stack pointer methods. */
CORE_ADDR
-get_frame_sp (struct frame_info *this_frame)
+get_frame_sp (frame_info_ptr this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
/* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
operate on THIS_FRAME now. */
- return gdbarch_unwind_sp (gdbarch, this_frame->next);
+ return gdbarch_unwind_sp (gdbarch, frame_info_ptr (this_frame->next));
}
/* Return the reason why we can't unwind past FRAME. */
enum unwind_stop_reason
-get_frame_unwind_stop_reason (struct frame_info *frame)
+get_frame_unwind_stop_reason (frame_info_ptr frame)
{
/* Fill-in STOP_REASON. */
get_prev_frame_always (frame);
}
const char *
-frame_stop_reason_string (struct frame_info *fi)
+frame_stop_reason_string (frame_info_ptr fi)
{
gdb_assert (fi->prev_p);
gdb_assert (fi->prev == NULL);
FRAME. */
void
-frame_cleanup_after_sniffer (struct frame_info *frame)
+frame_cleanup_after_sniffer (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 (struct frame_info *frame,
+frame_prepare_for_sniffer (frame_info_ptr frame,
const struct frame_unwind *unwind)
{
gdb_assert (frame->unwind == NULL);
static void
maintenance_print_frame_id (const char *args, int from_tty)
{
- struct frame_info *frame;
+ frame_info_ptr frame;
/* Use the currently selected frame, or select a frame based on the level
number passed by the user. */
/* The frame object. */
-struct frame_info;
+class frame_info_ptr;
/* The frame object's ID. This provides a per-frame unique identifier
that can be used to relocate a `struct frame_info' after a target
/* On demand, create the inner most frame using information found in
the inferior. If the inner most frame can't be created, throw an
error. */
-extern struct frame_info *get_current_frame (void);
+extern frame_info_ptr get_current_frame (void);
/* Does the current target interface have enough state to be able to
query the current inferior for frame info, and is the inferior in a
It should instead, when a thread has previously had its frame
selected (but not resumed) and the frame cache invalidated, find
and then return that thread's previously selected frame. */
-extern struct frame_info *get_selected_frame (const char *message = nullptr);
+extern frame_info_ptr get_selected_frame (const char *message = nullptr);
/* Select a specific frame. NULL implies re-select the inner most
frame. */
-extern void select_frame (struct frame_info *);
+extern void select_frame (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 struct frame_info *get_prev_frame (struct frame_info *);
-extern struct frame_info *get_next_frame (struct frame_info *);
+extern frame_info_ptr get_prev_frame (frame_info_ptr );
+extern frame_info_ptr get_next_frame (frame_info_ptr );
/* Like get_next_frame(), but allows return of the sentinel frame. NULL
is never returned. */
-extern struct frame_info *get_next_frame_sentinel_okay (struct frame_info *);
+extern frame_info_ptr get_next_frame_sentinel_okay (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 struct frame_info *get_prev_frame_always (struct frame_info *);
+extern frame_info_ptr get_prev_frame_always (frame_info_ptr );
/* Given a frame's ID, relocate the frame. Returns NULL if the frame
is not found. */
-extern struct frame_info *frame_find_by_id (struct frame_id id);
+extern frame_info_ptr frame_find_by_id (struct frame_id id);
/* Base attributes of a frame: */
this frame.
This replaced: frame->pc; */
-extern CORE_ADDR get_frame_pc (struct frame_info *);
+extern CORE_ADDR get_frame_pc (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 *frame, CORE_ADDR *pc);
+extern bool get_frame_pc_if_available (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 (struct frame_info *this_frame);
+extern CORE_ADDR get_frame_address_in_block (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 *this_frame,
+extern bool get_frame_address_in_block_if_available (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 (struct frame_info *);
+extern CORE_ADDR get_frame_sp (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 (struct frame_info *fi);
+extern CORE_ADDR get_frame_func (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 *fi, CORE_ADDR *);
+extern bool get_frame_func_if_available (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 *frame);
+extern symtab_and_line find_frame_sal (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 (struct frame_info *);
+void set_current_sal_from_frame (frame_info_ptr );
/* Return the frame base (what ever that is) (DEPRECATED).
This replaced: frame->frame; */
-extern CORE_ADDR get_frame_base (struct frame_info *);
+extern CORE_ADDR get_frame_base (frame_info_ptr );
/* Return the per-frame unique identifer. 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 (struct frame_info *fi);
-extern struct frame_id get_stack_frame_id (struct frame_info *fi);
-extern struct frame_id frame_unwind_caller_id (struct frame_info *next_frame);
+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);
/* 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 (struct frame_info *);
+extern CORE_ADDR get_frame_base_address (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 (struct frame_info *);
+extern CORE_ADDR get_frame_locals_address (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 (struct frame_info *);
+extern CORE_ADDR get_frame_args_address (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 (struct frame_info *fi);
+extern int frame_relative_level (frame_info_ptr fi);
/* Return the frame's type. */
-extern enum frame_type get_frame_type (struct frame_info *);
+extern enum frame_type get_frame_type (frame_info_ptr );
/* Return the frame's program space. */
-extern struct program_space *get_frame_program_space (struct frame_info *);
+extern struct program_space *get_frame_program_space (frame_info_ptr );
/* Unwind THIS frame's program space from the NEXT frame. */
-extern struct program_space *frame_unwind_program_space (struct frame_info *);
+extern struct program_space *frame_unwind_program_space (frame_info_ptr );
class address_space;
/* Return the frame's address space. */
-extern const address_space *get_frame_address_space (struct frame_info *);
+extern const address_space *get_frame_address_space (frame_info_ptr );
/* 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 (struct frame_info *);
+enum unwind_stop_reason get_frame_unwind_stop_reason (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 (struct frame_info *);
+const char *frame_stop_reason_string (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 *frame, int regnum,
+extern void frame_register_unwind (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 *next_frame,
+extern void frame_unwind_register (frame_info_ptr next_frame,
int regnum, gdb_byte *buf);
-extern void get_frame_register (struct frame_info *frame,
+extern void get_frame_register (frame_info_ptr frame,
int regnum, gdb_byte *buf);
-struct value *frame_unwind_register_value (frame_info *next_frame,
+struct value *frame_unwind_register_value (frame_info_ptr next_frame,
int regnum);
-struct value *get_frame_register_value (struct frame_info *frame,
+struct value *get_frame_register_value (frame_info_ptr frame,
int regnum);
-extern LONGEST frame_unwind_register_signed (frame_info *next_frame,
+extern LONGEST frame_unwind_register_signed (frame_info_ptr next_frame,
int regnum);
-extern LONGEST get_frame_register_signed (struct frame_info *frame,
+extern LONGEST get_frame_register_signed (frame_info_ptr frame,
int regnum);
-extern ULONGEST frame_unwind_register_unsigned (frame_info *frame,
+extern ULONGEST frame_unwind_register_unsigned (frame_info_ptr frame,
int regnum);
-extern ULONGEST get_frame_register_unsigned (struct frame_info *frame,
+extern ULONGEST get_frame_register_unsigned (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 *frame,
+extern bool read_frame_register_unsigned (frame_info_ptr frame,
int regnum, ULONGEST *val);
/* Get the value of the register that belongs to this FRAME. This
(get_next_frame (FRAME))''. As per frame_register_unwind(), if
VALUEP is NULL, the registers value is not fetched/computed. */
-extern void frame_register (struct frame_info *frame, int regnum,
+extern void frame_register (frame_info_ptr frame, int regnum,
int *optimizedp, int *unavailablep,
enum lval_type *lvalp,
CORE_ADDR *addrp, int *realnump,
/* The reverse. Store a register value relative to the specified
frame. Note: this call makes the frame's state undefined. The
register and frame caches must be flushed. */
-extern void put_frame_register (struct frame_info *frame, int regnum,
+extern void put_frame_register (frame_info_ptr frame, int regnum,
const gdb_byte *buf);
/* Read LEN bytes from one or multiple registers starting with REGNUM
in frame FRAME, starting at OFFSET, into BUF. If the register
contents are optimized out or unavailable, set *OPTIMIZEDP,
*UNAVAILABLEP accordingly. */
-extern bool get_frame_register_bytes (frame_info *frame, int regnum,
+extern bool get_frame_register_bytes (frame_info_ptr frame, int regnum,
CORE_ADDR offset,
gdb::array_view<gdb_byte> buffer,
int *optimizedp, int *unavailablep);
/* Write bytes from BUFFER to one or multiple registers starting with REGNUM
in frame FRAME, starting at OFFSET. */
-extern void put_frame_register_bytes (struct frame_info *frame, int regnum,
+extern void put_frame_register_bytes (frame_info_ptr frame, int regnum,
CORE_ADDR offset,
gdb::array_view<const gdb_byte> buffer);
calling frame. For GDB, `pc' is the resume address and not a
specific register. */
-extern CORE_ADDR frame_unwind_caller_pc (struct frame_info *frame);
+extern CORE_ADDR frame_unwind_caller_pc (frame_info_ptr frame);
/* Discard the specified frame. Restoring the registers to the state
of the caller. */
-extern void frame_pop (struct frame_info *frame);
+extern void frame_pop (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 (struct frame_info *this_frame, CORE_ADDR addr,
+extern void get_frame_memory (frame_info_ptr this_frame, CORE_ADDR addr,
gdb::array_view<gdb_byte> buffer);
-extern LONGEST get_frame_memory_signed (struct frame_info *this_frame,
+extern LONGEST get_frame_memory_signed (frame_info_ptr this_frame,
CORE_ADDR memaddr, int len);
-extern ULONGEST get_frame_memory_unsigned (struct frame_info *this_frame,
+extern ULONGEST get_frame_memory_unsigned (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 *this_frame, CORE_ADDR addr,
+extern bool safe_frame_unwind_memory (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 (struct frame_info *this_frame);
+extern struct gdbarch *get_frame_arch (frame_info_ptr this_frame);
/* Return the previous frame's architecture. */
-extern struct gdbarch *frame_unwind_arch (frame_info *next_frame);
+extern struct gdbarch *frame_unwind_arch (frame_info_ptr next_frame);
/* Return the previous frame's architecture, skipping inline functions. */
-extern struct gdbarch *frame_unwind_caller_arch (struct frame_info *frame);
+extern struct gdbarch *frame_unwind_caller_arch (frame_info_ptr 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
- (struct frame_info *this_frame);
+ (frame_info_ptr this_frame);
-extern const struct block *get_frame_block (struct frame_info *,
+extern const struct block *get_frame_block (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 (struct frame_info *);
+extern struct symbol *get_frame_function (frame_info_ptr );
extern CORE_ADDR get_pc_function_start (CORE_ADDR);
-extern struct frame_info *find_relative_frame (struct frame_info *, int *);
+extern frame_info_ptr find_relative_frame (frame_info_ptr , int *);
/* Wrapper over print_stack_frame modifying current_uiout with UIOUT for
the function call. */
extern void print_stack_frame_to_uiout (struct ui_out *uiout,
- struct frame_info *, int print_level,
+ frame_info_ptr , int print_level,
enum print_what print_what,
int set_current_sal);
-extern void print_stack_frame (struct frame_info *, int print_level,
+extern void print_stack_frame (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,
- struct frame_info *, int print_level,
+ frame_info_ptr , int print_level,
enum print_what print_what, int args,
int set_current_sal);
-extern struct frame_info *block_innermost_frame (const struct block *);
+extern frame_info_ptr block_innermost_frame (const struct block *);
-extern bool deprecated_frame_register_read (frame_info *frame, int regnum,
+extern bool deprecated_frame_register_read (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 *frame,
+ symbol *sym, frame_info_ptr frame,
struct frame_arg *argp,
struct frame_arg *entryargp);
-extern void read_frame_local (struct symbol *sym, struct frame_info *frame,
+extern void read_frame_local (struct symbol *sym, 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 (struct frame_info *frame,
+extern void frame_prepare_for_sniffer (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 (struct frame_info *frame);
+extern void frame_cleanup_after_sniffer (frame_info_ptr frame);
/* Notes (cagney/2002-11-27, drow/2003-09-06):
This function calls get_selected_frame if the inferior should have a
frame, or returns NULL otherwise. */
-extern struct frame_info *deprecated_safe_get_selected_frame (void);
+extern frame_info_ptr deprecated_safe_get_selected_frame (void);
/* Create a frame using the specified BASE and PC. */
-extern struct frame_info *create_new_frame (CORE_ADDR base, CORE_ADDR pc);
+extern frame_info_ptr create_new_frame (CORE_ADDR base, CORE_ADDR pc);
/* Return true if the frame unwinder for frame FI is UNWINDER; false
otherwise. */
-extern bool frame_unwinder_is (frame_info *fi, const frame_unwind *unwinder);
+extern bool frame_unwinder_is (frame_info_ptr fi, const frame_unwind *unwinder);
/* Return the language of FRAME. */
-extern enum language get_frame_language (struct frame_info *frame);
+extern enum language get_frame_language (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 struct frame_info *skip_tailcall_frames (struct frame_info *frame);
+extern frame_info_ptr skip_tailcall_frames (frame_info_ptr frame);
/* Return the first frame above FRAME or FRAME of which the code is
writable. */
-extern struct frame_info *skip_unwritable_frames (struct frame_info *frame);
+extern frame_info_ptr skip_unwritable_frames (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 (struct frame_info *frame);
+extern void set_frame_previous_pc_masked (frame_info_ptr frame);
/* Get whether the PC value is masked for the given frame. */
-extern bool get_frame_pc_masked (const struct frame_info *frame);
+extern bool get_frame_pc_masked (frame_info_ptr frame);
#endif /* !defined (FRAME_H) */
} __attribute__((aligned(8))); */
static LONGEST
-frv_linux_sigcontext_reg_addr (struct frame_info *this_frame, int regno,
+frv_linux_sigcontext_reg_addr (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 (struct frame_info *this_frame,
+frv_linux_sigtramp_frame_cache (frame_info_ptr this_frame,
void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
static void
-frv_linux_sigtramp_frame_this_id (struct frame_info *this_frame,
+frv_linux_sigtramp_frame_this_id (frame_info_ptr this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-frv_linux_sigtramp_frame_prev_register (struct frame_info *this_frame,
+frv_linux_sigtramp_frame_prev_register (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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame,
+frv_frame_unwind_cache (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 (struct frame_info *this_frame,
+frv_frame_this_id (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 (struct frame_info *this_frame,
+frv_frame_prev_register (frame_info_ptr this_frame,
void **this_prologue_cache, int regnum)
{
struct frv_unwind_cache *info
};
static CORE_ADDR
-frv_frame_base_address (struct frame_info *this_frame, void **this_cache)
+frv_frame_base_address (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 (struct frame_info *this_frame, void **this_cache)
+ft32_frame_cache (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 (struct frame_info *this_frame,
+ft32_frame_this_id (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 (struct frame_info *this_frame,
+ft32_frame_prev_register (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 (struct frame_info *this_frame, void **this_cache)
+ft32_frame_base_address (frame_info_ptr this_frame, void **this_cache)
{
struct ft32_frame_cache *cache = ft32_frame_cache (this_frame,
this_cache);
static int
derive_stack_segment (bfd_vma *bottom, bfd_vma *top)
{
- struct frame_info *fi, *tmp_fi;
+ frame_info_ptr fi, tmp_fi;
gdb_assert (bottom);
gdb_assert (top);
""",
type="struct frame_id",
name="dummy_id",
- params=[("struct frame_info *", "this_frame")],
+ params=[("frame_info_ptr ", "this_frame")],
predefault="default_dummy_id",
invalid=False,
)
""",
type="int",
name="code_of_frame_writable",
- params=[("struct frame_info *", "frame")],
+ params=[("frame_info_ptr ", "frame")],
predefault="default_code_of_frame_writable",
invalid=False,
)
name="print_registers_info",
params=[
("struct ui_file *", "file"),
- ("struct frame_info *", "frame"),
+ ("frame_info_ptr ", "frame"),
("int", "regnum"),
("int", "all"),
],
name="print_float_info",
params=[
("struct ui_file *", "file"),
- ("struct frame_info *", "frame"),
+ ("frame_info_ptr ", "frame"),
("const char *", "args"),
],
predefault="default_print_float_info",
name="print_vector_info",
params=[
("struct ui_file *", "file"),
- ("struct frame_info *", "frame"),
+ ("frame_info_ptr ", "frame"),
("const char *", "args"),
],
predicate=True,
""",
type="int",
name="get_longjmp_target",
- params=[("struct frame_info *", "frame"), ("CORE_ADDR *", "pc")],
+ params=[("frame_info_ptr ", "frame"), ("CORE_ADDR *", "pc")],
predicate=True,
invalid=True,
)
type="int",
name="register_to_value",
params=[
- ("struct frame_info *", "frame"),
+ ("frame_info_ptr ", "frame"),
("int", "regnum"),
("struct type *", "type"),
("gdb_byte *", "buf"),
type="void",
name="value_to_register",
params=[
- ("struct frame_info *", "frame"),
+ ("frame_info_ptr ", "frame"),
("int", "regnum"),
("struct type *", "type"),
("const gdb_byte *", "buf"),
Method(
type="CORE_ADDR",
name="unwind_pc",
- params=[("struct frame_info *", "next_frame")],
+ params=[("frame_info_ptr ", "next_frame")],
predefault="default_unwind_pc",
invalid=False,
)
Method(
type="CORE_ADDR",
name="unwind_sp",
- params=[("struct frame_info *", "next_frame")],
+ params=[("frame_info_ptr ", "next_frame")],
predefault="default_unwind_sp",
invalid=False,
)
""",
type="int",
name="frame_num_args",
- params=[("struct frame_info *", "frame")],
+ params=[("frame_info_ptr ", "frame")],
predicate=True,
invalid=True,
)
""",
type="int",
name="single_step_through_delay",
- params=[("struct frame_info *", "frame")],
+ params=[("frame_info_ptr ", "frame")],
predicate=True,
invalid=True,
)
Function(
type="CORE_ADDR",
name="skip_trampoline_code",
- params=[("struct frame_info *", "frame"), ("CORE_ADDR", "pc")],
+ params=[("frame_info_ptr ", "frame"), ("CORE_ADDR", "pc")],
predefault="generic_skip_trampoline_code",
invalid=False,
)
type="CORE_ADDR",
name="fetch_pointer_argument",
params=[
- ("struct frame_info *", "frame"),
+ ("frame_info_ptr ", "frame"),
("int", "argi"),
("struct type *", "type"),
],
""",
type="std::string",
name="get_pc_address_flags",
- params=[("frame_info *", "frame"), ("CORE_ADDR", "pc")],
+ params=[("frame_info_ptr ", "frame"), ("CORE_ADDR", "pc")],
predefault="default_get_pc_address_flags",
invalid=False,
)
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, struct frame_info *this_frame);
-extern struct frame_id gdbarch_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_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);
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, struct frame_info *frame);
-extern int gdbarch_code_of_frame_writable (struct gdbarch *gdbarch, struct frame_info *frame);
+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);
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, struct frame_info *frame, int regnum, int all);
-extern void gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all);
+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);
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, struct frame_info *frame, const char *args);
-extern void gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args);
+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);
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, struct frame_info *frame, const char *args);
-extern void gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args);
+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);
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) (struct frame_info *frame, CORE_ADDR *pc);
-extern int gdbarch_get_longjmp_target (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR *pc);
+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);
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) (struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep);
-extern int gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep);
+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);
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) (struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf);
-extern void gdbarch_value_to_register (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf);
+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);
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
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, struct frame_info *next_frame);
-extern CORE_ADDR gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame);
+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);
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, struct frame_info *next_frame);
-extern CORE_ADDR gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame);
+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);
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) (struct frame_info *frame);
-extern int gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame);
+typedef int (gdbarch_frame_num_args_ftype) (frame_info_ptr frame);
+extern int gdbarch_frame_num_args (struct gdbarch *gdbarch, 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, struct frame_info *frame);
-extern int gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame);
+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);
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) (struct frame_info *frame, CORE_ADDR pc);
-extern CORE_ADDR gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc);
+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);
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) (struct frame_info *frame, int argi, struct type *type);
-extern CORE_ADDR gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type);
+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);
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 *frame, CORE_ADDR pc);
-extern std::string gdbarch_get_pc_address_flags (struct gdbarch *gdbarch, frame_info *frame, CORE_ADDR pc);
+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);
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 */
scoped_mock_context<test_target_ops> mockctx (gdbarch);
- struct frame_info *frame = get_current_frame ();
+ frame_info_ptr frame = get_current_frame ();
const int num_regs = gdbarch_num_cooked_regs (gdbarch);
/* Test gdbarch methods register_to_value and value_to_register with
}
struct frame_id
-gdbarch_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
+gdbarch_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->dummy_id != NULL);
}
int
-gdbarch_code_of_frame_writable (struct gdbarch *gdbarch, struct frame_info *frame)
+gdbarch_code_of_frame_writable (struct gdbarch *gdbarch, 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, struct frame_info *frame, int regnum, int all)
+gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, 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, struct frame_info *frame, const char *args)
+gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, 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, struct frame_info *frame, const char *args)
+gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, 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, struct frame_info *frame, CORE_ADDR *pc)
+gdbarch_get_longjmp_target (struct gdbarch *gdbarch, 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, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep)
+gdbarch_register_to_value (struct gdbarch *gdbarch, 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, struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf)
+gdbarch_value_to_register (struct gdbarch *gdbarch, 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_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
+gdbarch_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->unwind_pc != NULL);
}
CORE_ADDR
-gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
+gdbarch_unwind_sp (struct gdbarch *gdbarch, frame_info_ptr next_frame)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->unwind_sp != NULL);
}
int
-gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
+gdbarch_frame_num_args (struct gdbarch *gdbarch, frame_info_ptr frame)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->frame_num_args != NULL);
}
int
-gdbarch_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame)
+gdbarch_single_step_through_delay (struct gdbarch *gdbarch, 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, struct frame_info *frame, CORE_ADDR pc)
+gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, 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, struct frame_info *frame, int argi, struct type *type)
+gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, 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 *frame, CORE_ADDR pc)
+gdbarch_get_pc_address_flags (struct gdbarch *gdbarch, frame_info_ptr frame, CORE_ADDR pc)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->get_pc_address_flags != NULL);
#include "dwarf2.h"
#include "gdbsupport/gdb_obstack.h"
#include "gmp-utils.h"
+#include "frame-info.h"
/* Forward declarations for prototypes. */
struct field;
void iterate_over_addresses (struct gdbarch *call_site_gdbarch,
const struct call_site *call_site,
- struct frame_info *caller_frame,
+ frame_info_ptr caller_frame,
iterate_ftype callback) const;
private:
throw NO_ENTRY_VALUE_ERROR. */
void iterate_over_addresses (struct gdbarch *call_site_gdbarch,
- struct frame_info *caller_frame,
+ frame_info_ptr caller_frame,
call_site_target::iterate_ftype callback)
const
{
of the routine we are thunking to and continue to there instead. */
static CORE_ADDR
-gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
+gnuv3_skip_trampoline (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);
const frame_smob *a = (const frame_smob *) ap;
const frame_smob *b = (const frame_smob *) bp;
- return (a->frame_id == b->frame_id
+ return (frame_id_eq (a->frame_id, b->frame_id)
&& a->inferior == b->inferior
&& a->inferior != NULL);
}
}
static struct h8300_frame_cache *
-h8300_frame_cache (struct frame_info *this_frame, void **this_cache)
+h8300_frame_cache (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 (struct frame_info *this_frame, void **this_cache,
+h8300_frame_this_id (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 (struct frame_info *this_frame, void **this_cache,
+h8300_frame_prev_register (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 (struct frame_info *this_frame, void **this_cache)
+h8300_frame_base_address (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,
- struct frame_info *frame, int regno)
+ 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,
- struct frame_info *frame, int regno, int cpregs)
+ 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,
- struct frame_info *this_frame)
+ 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 (struct frame_info *this_frame,
+hppa_linux_sigtramp_frame_unwind_cache (frame_info_ptr this_frame,
void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
static void
-hppa_linux_sigtramp_frame_this_id (struct frame_info *this_frame,
+hppa_linux_sigtramp_frame_this_id (frame_info_ptr this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
}
static struct value *
-hppa_linux_sigtramp_frame_prev_register (struct frame_info *this_frame,
+hppa_linux_sigtramp_frame_prev_register (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,
- struct frame_info *this_frame,
+ 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 *,
- struct frame_info *,
+ frame_info_ptr ,
struct trad_frame_cache *,
CORE_ADDR);
static void
hppanbsd_sigtramp_cache_init (const struct tramp_frame *self,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame)
+hppa_find_unwind_entry_in_block (frame_info_ptr this_frame)
{
CORE_ADDR pc = get_frame_address_in_block (this_frame);
};
static struct hppa_frame_cache *
-hppa_frame_cache (struct frame_info *this_frame, void **this_cache)
+hppa_frame_cache (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 (struct frame_info *this_frame, void **this_cache,
+hppa_frame_this_id (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 (struct frame_info *this_frame,
+hppa_frame_prev_register (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,
- struct frame_info *this_frame, void **this_cache)
+ 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 (struct frame_info *this_frame, void **this_cache)
+hppa_fallback_frame_cache (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 (struct frame_info *this_frame, void **this_cache,
+hppa_fallback_frame_this_id (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 (struct frame_info *this_frame,
+hppa_fallback_frame_prev_register (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 (struct frame_info *this_frame,
+hppa_stub_frame_unwind_cache (frame_info_ptr this_frame,
void **this_cache)
{
struct hppa_stub_unwind_cache *info;
}
static void
-hppa_stub_frame_this_id (struct frame_info *this_frame,
+hppa_stub_frame_this_id (frame_info_ptr this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
}
static struct value *
-hppa_stub_frame_prev_register (struct frame_info *this_frame,
+hppa_stub_frame_prev_register (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,
- struct frame_info *this_frame,
+ 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, struct frame_info *next_frame)
+hppa_unwind_pc (struct gdbarch *gdbarch, 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 (struct frame_info *frame, int argi,
+hppa_fetch_pointer_argument (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 (struct frame_info *this_frame,
+hppa_frame_prev_register_helper (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 (struct frame_info *frame, CORE_ADDR pc)
+hppa_skip_trampoline_code (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) (struct frame_info *this_frame, CORE_ADDR base,
+ void (*unwind_adjust_stub) (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 (struct frame_info *this_frame,
+ hppa_frame_prev_register_helper (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,
- struct frame_info *next_frame);
+ frame_info_ptr next_frame);
extern struct bound_minimal_symbol
hppa_lookup_stub_minimal_symbol (const char *name,
extern int hppa_in_solib_call_trampoline (struct gdbarch *gdbarch,
CORE_ADDR pc);
-extern CORE_ADDR hppa_skip_trampoline_code (struct frame_info *, CORE_ADDR pc);
+extern CORE_ADDR hppa_skip_trampoline_code (frame_info_ptr , CORE_ADDR pc);
#endif /* hppa-tdep.h */
address of the associated sigcontext structure. */
static CORE_ADDR
-i386bsd_sigcontext_addr (struct frame_info *this_frame)
+i386bsd_sigcontext_addr (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 (struct frame_info *this_frame)
+i386_darwin_sigcontext_addr (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,
- struct frame_info *this_frame)
+ 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 *, struct frame_info *);
+int darwin_dwarf_signal_frame_p (struct gdbarch *, frame_info_ptr );
#endif /* I386_DARWIN_TDEP_H */
static void
i386_fbsd_sigframe_init (const struct tramp_frame *self,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame)
+i386_gnu_sigtramp_start (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 (struct frame_info *this_frame)
+i386_gnu_sigtramp_p (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 (struct frame_info *this_frame)
+i386_gnu_sigcontext_addr (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 (struct frame_info *this_frame)
+i386_linux_sigtramp_start (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 (struct frame_info *this_frame)
+i386_linux_rt_sigtramp_start (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 (struct frame_info *this_frame)
+i386_linux_sigtramp_p (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,
- struct frame_info *this_frame)
+ 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 (struct frame_info *this_frame)
+i386_linux_sigcontext_addr (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 *,
- struct frame_info *,
+ frame_info_ptr ,
struct trad_frame_cache *,
CORE_ADDR);
static void
i386nbsd_sigtramp_cache_init (const struct tramp_frame *self,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
routine. */
static int
-i386nto_sigtramp_p (struct frame_info *this_frame)
+i386nto_sigtramp_p (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 (struct frame_info *this_frame)
+i386nto_sigcontext_addr (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 (struct frame_info *this_frame)
+i386obsd_sigtramp_p (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 (struct frame_info *this_frame, void **this_cache)
+i386obsd_trapframe_cache (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 (struct frame_info *this_frame,
+i386obsd_trapframe_this_id (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 (struct frame_info *this_frame,
+i386obsd_trapframe_prev_register (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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame)
+i386_sol2_mcontext_addr (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, struct frame_info *next_frame)
+i386_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
{
gdb_byte buf[8];
/* Normal frames. */
static void
-i386_frame_cache_1 (struct frame_info *this_frame,
+i386_frame_cache_1 (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 (struct frame_info *this_frame, void **this_cache)
+i386_frame_cache (frame_info_ptr this_frame, void **this_cache)
{
struct i386_frame_cache *cache;
}
static void
-i386_frame_this_id (struct frame_info *this_frame, void **this_cache,
+i386_frame_this_id (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 (struct frame_info *this_frame,
+i386_frame_unwind_stop_reason (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 (struct frame_info *this_frame, void **this_cache,
+i386_frame_prev_register (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 (const struct frame_unwind *self,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_prologue_cache)
{
if (frame_relative_level (this_frame) == 0)
}
static struct i386_frame_cache *
-i386_epilogue_frame_cache (struct frame_info *this_frame, void **this_cache)
+i386_epilogue_frame_cache (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 (struct frame_info *this_frame,
+i386_epilogue_frame_unwind_stop_reason (frame_info_ptr this_frame,
void **this_cache)
{
struct i386_frame_cache *cache =
}
static void
-i386_epilogue_frame_this_id (struct frame_info *this_frame,
+i386_epilogue_frame_this_id (frame_info_ptr this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-i386_epilogue_frame_prev_register (struct frame_info *this_frame,
+i386_epilogue_frame_prev_register (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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame, void **this_cache)
+i386_sigtramp_frame_cache (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 (struct frame_info *this_frame,
+i386_sigtramp_frame_unwind_stop_reason (frame_info_ptr this_frame,
void **this_cache)
{
struct i386_frame_cache *cache =
}
static void
-i386_sigtramp_frame_this_id (struct frame_info *this_frame, void **this_cache,
+i386_sigtramp_frame_this_id (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 (struct frame_info *this_frame,
+i386_sigtramp_frame_prev_register (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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_prologue_cache)
{
gdbarch *arch = get_frame_arch (this_frame);
\f
static CORE_ADDR
-i386_frame_base_address (struct frame_info *this_frame, void **this_cache)
+i386_frame_base_address (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, struct frame_info *this_frame)
+i386_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
{
CORE_ADDR fp;
success. */
static int
-i386_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
+i386_get_longjmp_target (frame_info_ptr frame, CORE_ADDR *pc)
{
gdb_byte buf[4];
CORE_ADDR sp, jb_addr;
return its contents in TO. */
static int
-i386_register_to_value (struct frame_info *frame, int regnum,
+i386_register_to_value (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 (struct frame_info *frame, int regnum,
+i386_value_to_register (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 (struct frame_info *frame,
+i386_pe_skip_trampoline_code (frame_info_ptr frame,
CORE_ADDR pc, char *name)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
routine. */
int
-i386_sigtramp_p (struct frame_info *this_frame)
+i386_sigtramp_p (frame_info_ptr this_frame)
{
CORE_ADDR pc = get_frame_pc (this_frame);
const char *name;
routine. */
static int
-i386_svr4_sigtramp_p (struct frame_info *this_frame)
+i386_svr4_sigtramp_p (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 (struct frame_info *this_frame)
+i386_svr4_sigcontext_addr (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 (struct frame_info *frame, int argi,
+i386_fetch_pointer_argument (frame_info_ptr frame, int argi,
struct type *type)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
#include "infrun.h"
#include "expression.h"
-struct frame_info;
+class frame_info_ptr;
struct gdbarch;
struct reggroup;
struct regset;
CORE_ADDR sigtramp_end = 0;
/* Detect sigtramp. */
- int (*sigtramp_p) (struct frame_info *) = nullptr;
+ int (*sigtramp_p) (frame_info_ptr ) = nullptr;
/* Get address of sigcontext for sigtramp. */
- CORE_ADDR (*sigcontext_addr) (struct frame_info *) = nullptr;
+ CORE_ADDR (*sigcontext_addr) (frame_info_ptr ) = nullptr;
/* Offset of registers in `struct sigcontext'. */
int *sc_reg_offset = 0;
#define I386_MAX_INSN_LEN (16)
/* Functions exported from i386-tdep.c. */
-extern CORE_ADDR i386_pe_skip_trampoline_code (struct frame_info *frame,
+extern CORE_ADDR i386_pe_skip_trampoline_code (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 (struct frame_info *this_frame);
+extern int i386_sigtramp_p (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 (struct frame_info *frame, CORE_ADDR pc)
+i386_windows_skip_trampoline_code (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,
- struct frame_info *frame, const char *args)
+ 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 (struct frame_info *frame, int regnum,
+i387_register_to_value (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 (struct frame_info *frame, int regnum,
+i387_value_to_register (frame_info_ptr frame, int regnum,
struct type *type, const gdb_byte *from)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
#define I387_TDEP_H
struct gdbarch;
-struct frame_info;
+class frame_info_ptr;
struct regcache;
struct type;
struct ui_file;
extern void i387_print_float_info (struct gdbarch *gdbarch,
struct ui_file *file,
- struct frame_info *frame,
+ 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 (struct frame_info *frame, int regnum,
+extern int i387_register_to_value (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 (struct frame_info *frame, int regnum,
+extern void i387_value_to_register (frame_info_ptr frame, int regnum,
struct type *type, const gdb_byte *from);
\f
}
static struct libunwind_frame_cache *
-libunwind_frame_cache (struct frame_info *this_frame, void **this_cache)
+libunwind_frame_cache (frame_info_ptr this_frame, void **this_cache)
{
unw_accessors_t *acc;
unw_addr_space_t as;
}
void
-libunwind_frame_dealloc_cache (struct frame_info *self, void *this_cache)
+libunwind_frame_dealloc_cache (frame_info_ptr self, void *this_cache)
{
struct libunwind_frame_cache *cache
= (struct libunwind_frame_cache *) this_cache;
libunwind frame unwinding. */
int
libunwind_frame_sniffer (const struct frame_unwind *self,
- struct frame_info *this_frame, void **this_cache)
+ frame_info_ptr this_frame, void **this_cache)
{
unw_cursor_t cursor;
unw_accessors_t *acc;
}
void
-libunwind_frame_this_id (struct frame_info *this_frame, void **this_cache,
+libunwind_frame_this_id (frame_info_ptr this_frame, void **this_cache,
struct frame_id *this_id)
{
struct libunwind_frame_cache *cache =
}
struct value *
-libunwind_frame_prev_register (struct frame_info *this_frame,
+libunwind_frame_prev_register (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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_cache)
{
unw_cursor_t cursor;
#ifndef IA64_LIBUNWIND_TDEP_H
#define IA64_LIBUNWIND_TDEP_H 1
-struct frame_info;
+class frame_info_ptr;
struct frame_id;
struct regcache;
struct gdbarch;
};
int libunwind_frame_sniffer (const struct frame_unwind *self,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_cache);
int libunwind_sigtramp_frame_sniffer (const struct frame_unwind *self,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame, void **this_cache,
+void libunwind_frame_this_id (frame_info_ptr this_frame, void **this_cache,
struct frame_id *this_id);
-struct value *libunwind_frame_prev_register (struct frame_info *this_frame,
+struct value *libunwind_frame_prev_register (frame_info_ptr this_frame,
void **this_cache, int regnum);
-void libunwind_frame_dealloc_cache (struct frame_info *self, void *cache);
+void libunwind_frame_dealloc_cache (frame_info_ptr self, void *cache);
int libunwind_is_initialized (void);
}
static int
-ia64_register_to_value (struct frame_info *frame, int regnum,
+ia64_register_to_value (frame_info_ptr frame, int regnum,
struct type *valtype, gdb_byte *out,
int *optimizedp, int *unavailablep)
{
}
static void
-ia64_value_to_register (struct frame_info *frame, int regnum,
+ia64_value_to_register (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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
struct ia64_frame_cache *cache)
{
CORE_ADDR next_pc;
/* Normal frames. */
static struct ia64_frame_cache *
-ia64_frame_cache (struct frame_info *this_frame, void **this_cache)
+ia64_frame_cache (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 (struct frame_info *this_frame, void **this_cache,
+ia64_frame_this_id (frame_info_ptr this_frame, void **this_cache,
struct frame_id *this_id)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
paddress (gdbarch, this_id->code_addr),
paddress (gdbarch, this_id->stack_addr),
paddress (gdbarch, cache->bsp),
- host_address_to_string (this_frame));
+ host_address_to_string (this_frame.get ()));
}
static struct value *
-ia64_frame_prev_register (struct frame_info *this_frame, void **this_cache,
+ia64_frame_prev_register (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 (struct frame_info *this_frame,
+ia64_sigtramp_frame_init_saved_regs (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 (struct frame_info *this_frame, void **this_cache)
+ia64_sigtramp_frame_cache (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 (struct frame_info *this_frame,
+ia64_sigtramp_frame_this_id (frame_info_ptr this_frame,
void **this_cache, struct frame_id *this_id)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
paddress (gdbarch, this_id->code_addr),
paddress (gdbarch, this_id->stack_addr),
paddress (gdbarch, cache->bsp),
- host_address_to_string (this_frame));
+ host_address_to_string (this_frame.get ()));
}
static struct value *
-ia64_sigtramp_frame_prev_register (struct frame_info *this_frame,
+ia64_sigtramp_frame_prev_register (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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_cache)
{
gdbarch *arch = get_frame_arch (this_frame);
\f
static CORE_ADDR
-ia64_frame_base_address (struct frame_info *this_frame, void **this_cache)
+ia64_frame_base_address (frame_info_ptr this_frame, void **this_cache)
{
struct ia64_frame_cache *cache = ia64_frame_cache (this_frame, this_cache);
{
int regnum = ia64_uw2gdb_regnum (uw_regnum);
unw_word_t bsp, sof, cfm, psr, ip;
- struct frame_info *this_frame = (struct frame_info *) arg;
+ struct frame_info *this_frame = (frame_info *) arg;
struct gdbarch *gdbarch = get_frame_arch (this_frame);
ia64_gdbarch_tdep *tdep = gdbarch_tdep<ia64_gdbarch_tdep> (gdbarch);
unw_fpreg_t *val, int write, void *arg)
{
int regnum = ia64_uw2gdb_regnum (uw_regnum);
- struct frame_info *this_frame = (struct frame_info *) arg;
+ frame_info_ptr this_frame = (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 (struct frame_info *this_frame, void **this_cache,
+ia64_libunwind_frame_this_id (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 (struct frame_info *this_frame,
+ia64_libunwind_frame_prev_register (frame_info_ptr this_frame,
void **this_cache, int regnum)
{
int reg = regnum;
static int
ia64_libunwind_frame_sniffer (const struct frame_unwind *self,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_cache)
{
if (libunwind_is_initialized ()
};
static void
-ia64_libunwind_sigtramp_frame_this_id (struct frame_info *this_frame,
+ia64_libunwind_sigtramp_frame_this_id (frame_info_ptr this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-ia64_libunwind_sigtramp_frame_prev_register (struct frame_info *this_frame,
+ia64_libunwind_sigtramp_frame_prev_register (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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_cache)
{
if (libunwind_is_initialized ())
};
static struct frame_id
-ia64_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
+ia64_dummy_id (struct gdbarch *gdbarch, 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, struct frame_info *next_frame)
+ia64_unwind_pc (struct gdbarch *gdbarch, 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 (struct frame_info *this_frame, ULONGEST cfm)
+ia64_size_of_register_frame (frame_info_ptr this_frame, ULONGEST cfm)
{
return (cfm & 0x7f);
}
#define IA64_NAT32_REGNUM (IA64_NAT0_REGNUM + 32)
#define IA64_NAT127_REGNUM (IA64_NAT0_REGNUM + 127)
-struct frame_info;
+class frame_info_ptr;
struct regcache;
/* A struction containing pointers to all the target-dependent operations
Normally, the size of the register frame is always obtained by
extracting the lowest 7 bits ("cfm & 0x7f"). */
- int (*size_of_register_frame) (struct frame_info *this_frame, ULONGEST cfm)
+ int (*size_of_register_frame) (frame_info_ptr this_frame, ULONGEST cfm)
= nullptr;
/* Determine the function address FADDR belongs to a shared library.
static CORE_ADDR
reserve_stack_space (const type *values_type, CORE_ADDR &sp)
{
- struct frame_info *frame = get_current_frame ();
+ frame_info_ptr frame = get_current_frame ();
struct gdbarch *gdbarch = get_frame_arch (frame);
CORE_ADDR addr = 0;
CORE_ADDR real_pc;
CORE_ADDR bp_addr;
struct frame_id dummy_id;
- struct frame_info *frame;
+ frame_info_ptr frame;
struct gdbarch *gdbarch;
ptid_t call_thread_ptid;
struct gdb_exception e;
inferior_ptid value. */
gdb_assert (inferior_ptid == tp->ptid);
- frame_info *frame = get_current_frame ();
+ frame_info_ptr frame = get_current_frame ();
symtab_and_line sal = find_frame_sal (frame);
set_step_info (tp, frame, sal);
if (sm->count > 0)
{
- struct frame_info *frame = get_current_frame ();
+ frame_info_ptr frame = get_current_frame ();
set_step_frame (tp);
static void
until_next_command (int from_tty)
{
- struct frame_info *frame;
+ frame_info_ptr frame;
CORE_ADDR pc;
struct symbol *func;
struct symtab_and_line sal;
if (sal.pc != pc)
{
- struct frame_info *frame = get_selected_frame (NULL);
+ frame_info_ptr frame = get_selected_frame (NULL);
struct gdbarch *gdbarch = get_frame_arch (frame);
/* Set a step-resume at the function's entry point. Once that's
frame that called the function we're about to step out of. */
static void
-finish_forward (struct finish_command_fsm *sm, struct frame_info *frame)
+finish_forward (struct finish_command_fsm *sm, 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 struct frame_info *
-skip_finish_frames (struct frame_info *frame)
+static frame_info_ptr
+skip_finish_frames (frame_info_ptr frame)
{
- struct frame_info *start;
+ frame_info_ptr start;
do
{
static void
finish_command (const char *arg, int from_tty)
{
- struct frame_info *frame;
+ frame_info_ptr frame;
int async_exec;
struct finish_command_fsm *sm;
struct thread_info *tp;
void
default_print_registers_info (struct gdbarch *gdbarch,
struct ui_file *file,
- struct frame_info *frame,
+ frame_info_ptr frame,
int regnum, int print_all)
{
int i;
void
registers_info (const char *addr_exp, int fpregs)
{
- struct frame_info *frame;
+ frame_info_ptr frame;
struct gdbarch *gdbarch;
if (!target_has_registers ())
static void
print_vector_info (struct ui_file *file,
- struct frame_info *frame, const char *args)
+ 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,
- struct frame_info *frame, const char *args)
+ frame_info_ptr frame, const char *args)
{
int regnum;
int printed_something = 0;
static void
info_float_command (const char *args, int from_tty)
{
- struct frame_info *frame;
+ frame_info_ptr frame;
if (!target_has_registers ())
error (_("The program has no registers now."));
#include <list>
struct target_waitstatus;
-struct frame_info;
+class frame_info_ptr;
struct ui_file;
struct type;
struct gdbarch;
extern void default_print_registers_info (struct gdbarch *gdbarch,
struct ui_file *file,
- struct frame_info *frame,
+ 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,
- struct frame_info *frame,
+ frame_info_ptr frame,
const char *args);
extern void child_terminal_info (struct target_ops *self, const char *, int);
static bool currently_stepping (struct thread_info *tp);
-static void insert_hp_step_resume_breakpoint_at_frame (struct frame_info *);
+static void insert_hp_step_resume_breakpoint_at_frame (frame_info_ptr );
-static void insert_step_resume_breakpoint_at_caller (struct frame_info *);
+static void insert_step_resume_breakpoint_at_caller (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 *,
- struct frame_info *);
+ 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, struct frame_info *frame,
+set_step_info (thread_info *tp, 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 (struct frame_info *frame, struct frame_id step_frame_id)
+stepped_in_from (frame_info_ptr frame, struct frame_id step_frame_id)
{
for (frame = get_prev_frame (frame);
frame != NULL;
static bool
inline_frame_is_marked_for_skip (bool prev_frame, struct thread_info *tp)
{
- struct frame_info *frame = get_current_frame ();
+ frame_info_ptr frame = get_current_frame ();
if (prev_frame)
frame = get_prev_frame (frame);
static void
handle_signal_stop (struct execution_control_state *ecs)
{
- struct frame_info *frame;
+ frame_info_ptr frame;
struct gdbarch *gdbarch;
int stopped_by_watchpoint;
enum stop_kind stop_soon;
process_event_stop_test (struct execution_control_state *ecs)
{
struct symtab_and_line stop_pc_sal;
- struct frame_info *frame;
+ frame_info_ptr frame;
struct gdbarch *gdbarch;
CORE_ADDR jmp_buf_pc;
struct bpstat_what what;
case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME:
{
- struct frame_info *init_frame;
+ frame_info_ptr init_frame;
/* There are several cases to consider.
static bool
keep_going_stepped_thread (struct thread_info *tp)
{
- struct frame_info *frame;
+ frame_info_ptr frame;
struct execution_control_state ecss;
struct execution_control_state *ecs = &ecss;
RETURN_FRAME.pc. */
static void
-insert_hp_step_resume_breakpoint_at_frame (struct frame_info *return_frame)
+insert_hp_step_resume_breakpoint_at_frame (frame_info_ptr return_frame)
{
gdb_assert (return_frame != NULL);
of frame_unwind_caller_id for an example). */
static void
-insert_step_resume_breakpoint_at_caller (struct frame_info *next_frame)
+insert_step_resume_breakpoint_at_caller (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,
- struct frame_info *frame,
+ frame_info_ptr frame,
struct symbol *sym)
{
try
static void
insert_exception_resume_from_probe (struct thread_info *tp,
const struct bound_probe *probe,
- struct frame_info *frame)
+ frame_info_ptr frame)
{
struct value *arg_value;
CORE_ADDR handler;
static void
check_exception_resume (struct execution_control_state *ecs,
- struct frame_info *frame)
+ frame_info_ptr frame)
{
struct bound_probe probe;
struct symbol *func;
/* Pop the empty frame that contains the stack dummy. This
also restores inferior state prior to the call (struct
infcall_suspend_state). */
- struct frame_info *frame = get_current_frame ();
+ frame_info_ptr frame = get_current_frame ();
gdb_assert (get_frame_type (frame) == DUMMY_FRAME);
frame_pop (frame);
#include "gdbsupport/intrusive_list.h"
struct target_waitstatus;
-struct frame_info;
+class frame_info_ptr;
struct address_space;
struct return_value_info;
struct process_stratum_target;
/* Record in TP the frame and location we're currently stepping through. */
extern void set_step_info (thread_info *tp,
- struct frame_info *frame,
+ frame_info_ptr frame,
struct symtab_and_line sal);
/* Several print_*_reason helper functions to print why the inferior
}
static void
-inline_frame_this_id (struct frame_info *this_frame,
+inline_frame_this_id (frame_info_ptr this_frame,
void **this_cache,
struct frame_id *this_id)
{
function, there must be previous frames, so this is safe - as
long as we're careful not to create any cycles. See related
comments in get_prev_frame_always_1. */
- frame_info *prev_frame = get_prev_frame_always (this_frame);
+ frame_info_ptr prev_frame = get_prev_frame_always (this_frame);
if (prev_frame == nullptr)
error (_("failed to find previous frame when computing inline frame id"));
*this_id = get_frame_id (prev_frame);
}
static struct value *
-inline_frame_prev_register (struct frame_info *this_frame, void **this_cache,
+inline_frame_prev_register (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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_cache)
{
CORE_ADDR this_pc;
const struct block *frame_block, *cur_block;
int depth;
- struct frame_info *next_frame;
+ frame_info_ptr next_frame;
struct inline_state *state = find_inline_frame_state (inferior_thread ());
this_pc = get_frame_address_in_block (this_frame);
skip_inline_frames). */
int
-frame_inlined_callees (struct frame_info *this_frame)
+frame_inlined_callees (frame_info_ptr this_frame)
{
- struct frame_info *next_frame;
+ frame_info_ptr next_frame;
int inline_count = 0;
/* First count how many inlined functions at this PC have frames
#if !defined (INLINE_FRAME_H)
#define INLINE_FRAME_H 1
-struct frame_info;
+class frame_info_ptr;
struct frame_unwind;
struct bpstat;
struct process_stratum_target;
the callees may not have associated frames (see
skip_inline_frames). */
-int frame_inlined_callees (struct frame_info *this_frame);
+int frame_inlined_callees (frame_info_ptr this_frame);
#endif /* !defined (INLINE_FRAME_H) */
iq2000_scan_prologue (struct gdbarch *gdbarch,
CORE_ADDR scan_start,
CORE_ADDR scan_end,
- struct frame_info *fi,
+ 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 (struct frame_info *this_frame, void **this_cache)
+iq2000_frame_cache (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 (struct frame_info *this_frame, void **this_cache,
+iq2000_frame_prev_register (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 (struct frame_info *this_frame, void **this_cache,
+iq2000_frame_this_id (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 (struct frame_info *this_frame, void **this_cache)
+iq2000_frame_base_address (frame_info_ptr this_frame, void **this_cache)
{
struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame,
this_cache);
std::unique_ptr<detached_regcache> regcache;
/* The frame being unwound. */
- struct frame_info *this_frame;
+ frame_info_ptr this_frame;
};
/* Sets the value of a particular register in this frame. */
saved register value. */
static void
-jit_dealloc_cache (struct frame_info *this_frame, void *cache)
+jit_dealloc_cache (frame_info *this_frame, void *cache)
{
struct jit_unwind_private *priv_data = (struct jit_unwind_private *) cache;
delete priv_data;
static int
jit_frame_sniffer (const struct frame_unwind *self,
- struct frame_info *this_frame, void **cache)
+ frame_info_ptr this_frame, void **cache)
{
struct jit_unwind_private *priv_data;
struct gdb_unwind_callbacks callbacks;
jit_debug_printf ("Could not unwind frame using JIT reader.");
- jit_dealloc_cache (this_frame, *cache);
+ jit_dealloc_cache (this_frame.get (), *cache);
*cache = NULL;
return 0;
the loaded plugin. */
static void
-jit_frame_this_id (struct frame_info *this_frame, void **cache,
+jit_frame_this_id (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 (struct frame_info *this_frame, void **cache, int reg)
+jit_frame_prev_register (frame_info_ptr this_frame, void **cache, int reg)
{
struct jit_unwind_private *priv = (struct jit_unwind_private *) *cache;
struct gdbarch *gdbarch;
if (has_stack_frames ())
{
- struct frame_info *frame;
+ frame_info_ptr frame;
frame = get_selected_frame (NULL);
flang = get_frame_language (frame);
language_mode = language_mode_auto;
try
{
- struct frame_info *frame;
+ frame_info_ptr frame;
frame = get_selected_frame (NULL);
flang = get_frame_language (frame);
Return the result from the first that returns non-zero, or 0 if all
`fail'. */
CORE_ADDR
-skip_language_trampoline (struct frame_info *frame, CORE_ADDR pc)
+skip_language_trampoline (frame_info_ptr frame, CORE_ADDR pc)
{
for (const auto &lang : language_defn::languages)
{
/* Forward decls for prototypes. */
struct value;
struct objfile;
-struct frame_info;
+class frame_info_ptr;
struct ui_file;
struct value_print_options;
struct type_print_options;
virtual struct value *read_var_value (struct symbol *var,
const struct block *var_block,
- struct frame_info *frame) const;
+ frame_info_ptr frame) const;
/* Return information about whether TYPE should be passed
(and returned) by reference at the language level. The default
If that PC falls in a trampoline belonging to this language, return
the address of the first pc in the real function, or 0 if it isn't a
language tramp for this language. */
- virtual CORE_ADDR skip_trampoline (struct frame_info *fi, CORE_ADDR pc) const
+ virtual CORE_ADDR skip_trampoline (frame_info_ptr fi, CORE_ADDR pc) const
{
return (CORE_ADDR) 0;
}
/* Check for a language-specific trampoline. */
-extern CORE_ADDR skip_language_trampoline (struct frame_info *, CORE_ADDR pc);
+extern CORE_ADDR skip_language_trampoline (frame_info_ptr , CORE_ADDR pc);
/* Return demangled language symbol, or NULL. */
extern gdb::unique_xmalloc_ptr<char> language_demangle
for it IS the sp for the next frame. */
static struct lm32_frame_cache *
-lm32_frame_cache (struct frame_info *this_frame, void **this_prologue_cache)
+lm32_frame_cache (frame_info_ptr this_frame, void **this_prologue_cache)
{
CORE_ADDR current_pc;
ULONGEST prev_sp;
}
static void
-lm32_frame_this_id (struct frame_info *this_frame, void **this_cache,
+lm32_frame_this_id (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 (struct frame_info *this_frame,
+lm32_frame_prev_register (frame_info_ptr this_frame,
void **this_prologue_cache, int regnum)
{
struct lm32_frame_cache *info;
};
static CORE_ADDR
-lm32_frame_base_address (struct frame_info *this_frame, void **this_cache)
+lm32_frame_base_address (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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *frame)
+loongarch_linux_syscall_next_pc (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, struct frame_info *this_frame,
+ CORE_ADDR limit_pc, frame_info_ptr this_frame,
struct trad_frame_cache *this_cache)
{
CORE_ADDR cur_pc = start_pc, prologue_end = 0;
/* Generate, or return the cached frame cache for frame unwinder. */
static struct trad_frame_cache *
-loongarch_frame_cache (struct frame_info *this_frame, void **this_cache)
+loongarch_frame_cache (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 (struct frame_info *this_frame, void **prologue_cache,
+loongarch_frame_this_id (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 (struct frame_info *this_frame,
+loongarch_frame_prev_register (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) (struct frame_info *frame) = nullptr;
+ CORE_ADDR (*syscall_next_pc) (frame_info_ptr frame) = nullptr;
};
#endif /* LOONGARCH_TDEP_H */
/* Stack unwinding. */
static struct m32c_prologue *
-m32c_analyze_frame_prologue (struct frame_info *this_frame,
+m32c_analyze_frame_prologue (frame_info_ptr this_frame,
void **this_prologue_cache)
{
if (! *this_prologue_cache)
static CORE_ADDR
-m32c_frame_base (struct frame_info *this_frame,
+m32c_frame_base (frame_info_ptr this_frame,
void **this_prologue_cache)
{
struct m32c_prologue *p
static void
-m32c_this_id (struct frame_info *this_frame,
+m32c_this_id (frame_info_ptr this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
static struct value *
-m32c_prev_register (struct frame_info *this_frame,
+m32c_prev_register (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 (struct frame_info *frame, CORE_ADDR stop_pc)
+m32c_skip_trampoline_code (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, struct frame_info *this_frame)
+m32r_linux_sigtramp_start (CORE_ADDR pc, 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, struct frame_info *this_frame)
+m32r_linux_rt_sigtramp_start (CORE_ADDR pc, frame_info_ptr this_frame)
{
gdb_byte buf[4];
static int
m32r_linux_pc_in_sigtramp (CORE_ADDR pc, const char *name,
- struct frame_info *this_frame)
+ 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 (struct frame_info *this_frame,
+m32r_linux_sigtramp_frame_cache (frame_info_ptr this_frame,
void **this_cache)
{
struct m32r_frame_cache *cache;
}
static void
-m32r_linux_sigtramp_frame_this_id (struct frame_info *this_frame,
+m32r_linux_sigtramp_frame_this_id (frame_info_ptr this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-m32r_linux_sigtramp_frame_prev_register (struct frame_info *this_frame,
+m32r_linux_sigtramp_frame_prev_register (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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame,
+m32r_frame_unwind_cache (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 (struct frame_info *this_frame,
+m32r_frame_this_id (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 (struct frame_info *this_frame,
+m32r_frame_prev_register (frame_info_ptr this_frame,
void **this_prologue_cache, int regnum)
{
struct m32r_unwind_cache *info
};
static CORE_ADDR
-m32r_frame_base_address (struct frame_info *this_frame, void **this_cache)
+m32r_frame_base_address (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 (struct frame_info *this_frame,
+m68hc11_frame_unwind_cache (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 (struct frame_info *this_frame,
+m68hc11_frame_this_id (frame_info_ptr this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
}
static struct value *
-m68hc11_frame_prev_register (struct frame_info *this_frame,
+m68hc11_frame_prev_register (frame_info_ptr this_frame,
void **this_prologue_cache, int regnum)
{
struct value *value;
};
static CORE_ADDR
-m68hc11_frame_base_address (struct frame_info *this_frame, void **this_cache)
+m68hc11_frame_base_address (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 (struct frame_info *this_frame, void **this_cache)
+m68hc11_frame_args_address (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, struct frame_info *this_frame)
+m68hc11_dummy_id (struct gdbarch *gdbarch, 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,
- struct frame_info *frame, int regno)
+ 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,
- struct frame_info *frame, int regno, int cpregs)
+ frame_info_ptr frame, int regno, int cpregs)
{
if (regno >= 0)
{
non-RT and RT signal trampolines. */
static int
-m68k_linux_pc_in_sigtramp (struct frame_info *this_frame)
+m68k_linux_pc_in_sigtramp (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 (struct frame_info *this_frame)
+m68k_linux_get_sigtramp_info (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 (struct frame_info *this_frame,
+m68k_linux_sigtramp_frame_cache (frame_info_ptr this_frame,
void **this_cache)
{
struct frame_id this_id;
}
static void
-m68k_linux_sigtramp_frame_this_id (struct frame_info *this_frame,
+m68k_linux_sigtramp_frame_this_id (frame_info_ptr this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-m68k_linux_sigtramp_frame_prev_register (struct frame_info *this_frame,
+m68k_linux_sigtramp_frame_prev_register (frame_info_ptr this_frame,
void **this_cache,
int regnum)
{
static int
m68k_linux_sigtramp_frame_sniffer (const struct frame_unwind *self,
- struct frame_info *this_frame,
+ 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 (struct frame_info *frame, int regnum,
+m68k_register_to_value (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 (struct frame_info *frame, int regnum,
+m68k_value_to_register (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, struct frame_info *next_frame)
+m68k_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
{
gdb_byte buf[8];
/* Normal frames. */
static struct m68k_frame_cache *
-m68k_frame_cache (struct frame_info *this_frame, void **this_cache)
+m68k_frame_cache (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 (struct frame_info *this_frame, void **this_cache,
+m68k_frame_this_id (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 (struct frame_info *this_frame, void **this_cache,
+m68k_frame_prev_register (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 (struct frame_info *this_frame, void **this_cache)
+m68k_frame_base_address (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, struct frame_info *this_frame)
+m68k_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
{
CORE_ADDR fp;
This routine returns true on success. */
static int
-m68k_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
+m68k_get_longjmp_target (frame_info_ptr frame, CORE_ADDR *pc)
{
gdb_byte *buf;
CORE_ADDR sp, jb_addr;
#include "gdbarch.h"
-struct frame_info;
+class frame_info_ptr;
/* Register numbers of various important registers. */
{
struct symtab_and_line sal;
gdb::unique_xmalloc_ptr<struct macro_scope> ms;
- struct frame_info *frame;
+ frame_info_ptr frame;
CORE_ADDR pc;
/* If there's a selected frame, use its PC. */
static struct mep_prologue *
-mep_analyze_frame_prologue (struct frame_info *this_frame,
+mep_analyze_frame_prologue (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 (struct frame_info *this_frame,
+mep_frame_base (frame_info_ptr this_frame,
void **this_prologue_cache)
{
struct mep_prologue *p
static void
-mep_frame_this_id (struct frame_info *this_frame,
+mep_frame_this_id (frame_info_ptr this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
static struct value *
-mep_frame_prev_register (struct frame_info *this_frame,
+mep_frame_prev_register (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,
- struct frame_info *fi,
+ 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 (struct frame_info *frame,
+mi_apply_ext_lang_frame_filter (frame_info_ptr frame,
frame_filter_flags flags,
enum print_values print_values,
struct ui_out *out,
int frame_low;
int frame_high;
int i;
- struct frame_info *fi;
+ frame_info_ptr fi;
enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
int raw_arg = 0;
int oind = 0;
{
int frame_high;
int i;
- struct frame_info *fi;
+ frame_info_ptr fi;
if (argc > 1)
error (_("-stack-info-depth: Usage: [MAX_DEPTH]"));
void
mi_cmd_stack_list_locals (const char *command, char **argv, int argc)
{
- struct frame_info *frame;
+ frame_info_ptr frame;
int raw_arg = 0;
enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
enum print_values print_value;
int frame_low;
int frame_high;
int i;
- struct frame_info *fi;
+ frame_info_ptr fi;
enum print_values print_values;
struct ui_out *uiout = current_uiout;
int raw_arg = 0;
void
mi_cmd_stack_list_variables (const char *command, char **argv, int argc)
{
- struct frame_info *frame;
+ frame_info_ptr frame;
int raw_arg = 0;
enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
enum print_values print_value;
static void
list_args_or_locals (const frame_print_options &fp_opts,
enum what_to_list what, enum print_values values,
- struct frame_info *fi, int skip_unavailable)
+ frame_info_ptr fi, int skip_unavailable)
{
const struct block *block;
struct symbol *sym;
manual, this feature is supported here purely for backward
compatibility. */
-static struct frame_info *
+static frame_info_ptr
parse_frame_specification (const char *frame_exp)
{
gdb_assert (frame_exp != NULL);
struct value *arg = parse_and_eval (frame_exp);
/* Assume ARG is an integer, and try using that to select a frame. */
- struct frame_info *fid;
+ frame_info_ptr fid;
int level = value_as_long (arg);
fid = find_relative_frame (get_current_frame (), &level);
{
if (id == get_frame_id (fid))
{
- struct frame_info *prev_frame;
+ frame_info_ptr prev_frame;
while (1)
{
char **argv, int argc);
static bool register_changed_p (int regnum, readonly_detached_regcache *,
readonly_detached_regcache *);
-static void output_register (struct frame_info *, int regnum, int format,
+static void output_register (frame_info_ptr , int regnum, int format,
int skip_unavailable);
/* Controls whether the frontend wants MI in async mode. */
mi_cmd_data_list_register_values (const char *command, char **argv, int argc)
{
struct ui_out *uiout = current_uiout;
- struct frame_info *frame;
+ frame_info_ptr frame;
struct gdbarch *gdbarch;
int regnum, numregs, format;
int i;
unavailable. */
static void
-output_register (struct frame_info *frame, int regnum, int format,
+output_register (frame_info_ptr frame, int regnum, int format,
int skip_unavailable)
{
struct ui_out *uiout = current_uiout;
gdb::optional<scoped_restore_selected_frame> frame_saver;
if (parse->frame != -1)
{
- struct frame_info *fid;
+ frame_info_ptr fid;
int frame = parse->frame;
fid = find_relative_frame (get_current_frame (), &frame);
the trace frame info, but instead consult the register cache for
register availability. */
{
- struct frame_info *frame;
+ frame_info_ptr frame;
struct gdbarch *gdbarch;
int regnum;
int numregs;
}
static void
-microblaze_linux_sigtramp_cache (struct frame_info *next_frame,
+microblaze_linux_sigtramp_cache (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,
- struct frame_info *next_frame,
+ frame_info_ptr next_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
}
static CORE_ADDR
-microblaze_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
+microblaze_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
{
gdb_byte buf[4];
CORE_ADDR pc;
/* Normal frames. */
static struct microblaze_frame_cache *
-microblaze_frame_cache (struct frame_info *next_frame, void **this_cache)
+microblaze_frame_cache (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 (struct frame_info *next_frame, void **this_cache,
+microblaze_frame_this_id (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 (struct frame_info *this_frame,
+microblaze_frame_prev_register (frame_info_ptr this_frame,
void **this_cache, int regnum)
{
struct microblaze_frame_cache *cache =
};
\f
static CORE_ADDR
-microblaze_frame_base_address (struct frame_info *next_frame,
+microblaze_frame_base_address (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 (struct frame_info *frame, CORE_ADDR pc)
+find_solib_trampoline_target (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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
struct trad_frame_cache *cache,
CORE_ADDR func)
{
static void
mips64_fbsd_sigframe_init (const struct tramp_frame *self,
- struct frame_info *this_frame,
+ 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 (struct frame_info *frame, CORE_ADDR *pc)
+mips_linux_get_longjmp_target (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 (struct frame_info *frame, CORE_ADDR *pc)
+mips64_linux_get_longjmp_target (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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
CORE_ADDR *pc);
static int micromips_linux_sigframe_validate (const struct tramp_frame *self,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *frame)
+mips_linux_syscall_next_pc (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 (struct frame_info *frame, CORE_ADDR *pc)
+mipsnbsd_get_longjmp_target (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 (struct frame_info *this_frame, void **this_cache)
+mips_sde_frame_cache (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 (struct frame_info *this_frame, void **this_cache,
+mips_sde_frame_this_id (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 (struct frame_info *this_frame,
+mips_sde_frame_prev_register (frame_info_ptr this_frame,
void **this_cache,
int prev_regnum)
{
static int
mips_sde_frame_sniffer (const struct frame_unwind *self,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame, void **this_cache)
+mips_sde_frame_base_address (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 (struct frame_info *this_frame)
+mips_sde_frame_base_sniffer (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 *,
- struct frame_info *, const char *);
+ 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 (struct frame_info *frame)
+mips2_fp_compat (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 (struct frame_info *frame, int regnum,
+mips_register_to_value (frame_info_ptr frame, int regnum,
struct type *type, gdb_byte *to,
int *optimizedp, int *unavailablep)
{
}
static void
-mips_value_to_register (struct frame_info *frame, int regnum,
+mips_value_to_register (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, struct frame_info *next_frame)
+mips_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
{
CORE_ADDR pc;
}
static CORE_ADDR
-mips_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
+mips_unwind_sp (struct gdbarch *gdbarch, 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, struct frame_info *this_frame)
+mips_dummy_id (struct gdbarch *gdbarch, 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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame, void **this_cache)
+mips_insn16_frame_cache (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 (struct frame_info *this_frame, void **this_cache,
+mips_insn16_frame_this_id (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 (struct frame_info *this_frame,
+mips_insn16_frame_prev_register (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,
- struct frame_info *this_frame, void **this_cache)
+ 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 (struct frame_info *this_frame,
+mips_insn16_frame_base_address (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 (struct frame_info *this_frame)
+mips_insn16_frame_base_sniffer (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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame, void **this_cache)
+mips_micro_frame_cache (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 (struct frame_info *this_frame, void **this_cache,
+mips_micro_frame_this_id (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 (struct frame_info *this_frame,
+mips_micro_frame_prev_register (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,
- struct frame_info *this_frame, void **this_cache)
+ 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 (struct frame_info *this_frame,
+mips_micro_frame_base_address (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 (struct frame_info *this_frame)
+mips_micro_frame_base_sniffer (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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame, void **this_cache)
+mips_insn32_frame_cache (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 (struct frame_info *this_frame, void **this_cache,
+mips_insn32_frame_this_id (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 (struct frame_info *this_frame,
+mips_insn32_frame_prev_register (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,
- struct frame_info *this_frame, void **this_cache)
+ 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 (struct frame_info *this_frame,
+mips_insn32_frame_base_address (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 (struct frame_info *this_frame)
+mips_insn32_frame_base_sniffer (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 (struct frame_info *this_frame, void **this_cache)
+mips_stub_frame_cache (frame_info_ptr this_frame, void **this_cache)
{
CORE_ADDR pc;
CORE_ADDR start_addr;
}
static void
-mips_stub_frame_this_id (struct frame_info *this_frame, void **this_cache,
+mips_stub_frame_this_id (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 (struct frame_info *this_frame,
+mips_stub_frame_prev_register (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,
- struct frame_info *this_frame, void **this_cache)
+ 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 (struct frame_info *this_frame,
+mips_stub_frame_base_address (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 (struct frame_info *this_frame)
+mips_stub_frame_base_sniffer (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 (struct frame_info *frame, int regno,
+mips_read_fp_register_single (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 (struct frame_info *frame, int regno,
+mips_read_fp_register_double (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, struct frame_info *frame,
+mips_print_fp_register (struct ui_file *file, 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, struct frame_info *frame,
+mips_print_register (struct ui_file *file, 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,
- struct frame_info *frame, const char *args)
+ 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, struct frame_info *frame,
+print_fp_register_row (struct ui_file *file, 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, struct frame_info *frame,
+print_gp_register_row (struct ui_file *file, 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,
- struct frame_info *frame, int regnum, int all)
+ 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,
- struct frame_info *frame)
+ 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 (struct frame_info *frame, CORE_ADDR pc)
+mips_get_mips16_fn_stub_pc (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 (struct frame_info *frame, CORE_ADDR pc)
+mips_skip_mips16_trampoline_code (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 (struct frame_info *frame, CORE_ADDR pc)
+mips_skip_pic_trampoline_code (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 (struct frame_info *frame, CORE_ADDR pc)
+mips_skip_trampoline_code (frame_info_ptr frame, CORE_ADDR pc)
{
CORE_ADDR requested_pc = pc;
CORE_ADDR target_pc;
}
static struct value *
-value_of_mips_user_reg (struct frame_info *frame, const void *baton)
+value_of_mips_user_reg (frame_info_ptr frame, const void *baton)
{
const int *reg_p = (const int *) baton;
return value_of_register (*reg_p, frame);
/* Return the expected next PC if FRAME is stopped at a syscall
instruction. */
- CORE_ADDR (*syscall_next_pc) (struct frame_info *frame) = nullptr;
+ CORE_ADDR (*syscall_next_pc) (frame_info_ptr frame) = nullptr;
};
/* Register numbers of various important registers. */
static void
mips64obsd_sigframe_init (const struct tramp_frame *self,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame,
+mn10300_analyze_frame_prologue (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 (struct frame_info *this_frame, void **this_prologue_cache)
+mn10300_frame_base (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 (struct frame_info *this_frame,
+mn10300_frame_this_id (frame_info_ptr this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
}
static struct value *
-mn10300_frame_prev_register (struct frame_info *this_frame,
+mn10300_frame_prev_register (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 (struct frame_info *this_frame, void **this_cache)
+moxie_frame_cache (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 (struct frame_info *this_frame,
+moxie_frame_this_id (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 (struct frame_info *this_frame,
+moxie_frame_prev_register (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 (struct frame_info *this_frame, void **this_cache)
+moxie_frame_base_address (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 (struct frame_info *this_frame,
+msp430_analyze_frame_prologue (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 (struct frame_info *this_frame, void **this_prologue_cache)
+msp430_frame_base (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 (struct frame_info *this_frame,
+msp430_this_id (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 (struct frame_info *this_frame,
+msp430_prev_register (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 (struct frame_info *frame, CORE_ADDR pc)
+msp430_skip_trampoline_code (frame_info_ptr frame, CORE_ADDR pc)
{
struct bound_minimal_symbol bms;
const char *stub_name;
register. */
static struct value *
-value_of_nds32_reg (struct frame_info *frame, const void *baton)
+value_of_nds32_reg (frame_info_ptr frame, const void *baton)
{
return value_of_register ((int) (intptr_t) baton, frame);
}
a pointer to the current nds32_frame_cache in *THIS_CACHE. */
static struct nds32_frame_cache *
-nds32_frame_cache (struct frame_info *this_frame, void **this_cache)
+nds32_frame_cache (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 (struct frame_info *this_frame,
+nds32_frame_this_id (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 (struct frame_info *this_frame, void **this_cache,
+nds32_frame_prev_register (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 (struct frame_info *this_frame, void **this_cache)
+nds32_frame_base_address (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,
- struct frame_info *this_frame, void **this_cache)
+ 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 (struct frame_info *this_frame, void **this_cache)
+nds32_epilogue_frame_cache (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 (struct frame_info *this_frame,
+nds32_epilogue_frame_this_id (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 (struct frame_info *this_frame,
+nds32_epilogue_frame_prev_register (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 (struct frame_info *frame, CORE_ADDR *pc)
+nds32_get_longjmp_target (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,
- struct frame_info *next_frame,
+ 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 (struct frame_info *frame,
+nios2_linux_syscall_next_pc (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,
- struct frame_info *this_frame)
+ 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, struct frame_info *next_frame)
+nios2_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
{
gdb_byte buf[4];
*THIS_PROLOGUE_CACHE first. */
static struct nios2_unwind_cache *
-nios2_frame_unwind_cache (struct frame_info *this_frame,
+nios2_frame_unwind_cache (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 (struct frame_info *this_frame, void **this_cache,
+nios2_frame_this_id (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 (struct frame_info *this_frame, void **this_cache,
+nios2_frame_prev_register (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 (struct frame_info *this_frame, void **this_cache)
+nios2_frame_base_address (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 (struct frame_info *this_frame, void **this_cache)
+nios2_stub_frame_cache (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 (struct frame_info *this_frame, void **this_cache,
+nios2_stub_frame_this_id (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 (struct frame_info *this_frame,
+nios2_stub_frame_prev_register (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,
- struct frame_info *this_frame, void **cache)
+ 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 (struct frame_info *frame, CORE_ADDR *pc)
+nios2_get_longjmp_target (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) (struct frame_info *frame,
+ CORE_ADDR (*syscall_next_pc) (frame_info_ptr frame,
const struct nios2_opcode *op) = nullptr;
/* Returns true if PC points to a kernel helper function. */
/* See language.h. */
- CORE_ADDR skip_trampoline (struct frame_info *frame,
+ CORE_ADDR skip_trampoline (frame_info_ptr frame,
CORE_ADDR stop_pc) const override
{
struct gdbarch *gdbarch = get_frame_arch (frame);
static int
resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc)
{
- struct frame_info *frame = get_current_frame ();
+ frame_info_ptr frame = get_current_frame ();
struct gdbarch *gdbarch = get_frame_arch (frame);
struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
static int
resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
{
- struct frame_info *frame = get_current_frame ();
+ frame_info_ptr frame = get_current_frame ();
struct gdbarch *gdbarch = get_frame_arch (frame);
struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
static int
resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc)
{
- struct frame_info *frame = get_current_frame ();
+ frame_info_ptr frame = get_current_frame ();
struct gdbarch *gdbarch = get_frame_arch (frame);
struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
static int
resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
{
- struct frame_info *frame = get_current_frame ();
+ frame_info_ptr frame = get_current_frame ();
struct gdbarch *gdbarch = get_frame_arch (frame);
struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
inferior_call_post;
/* A register in the inferior has been modified by the gdb user. */
-extern observable<struct frame_info */* frame */, int /* regnum */>
+extern observable<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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
static int
or1k_single_step_through_delay (struct gdbarch *gdbarch,
- struct frame_info *this_frame)
+ 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, struct frame_info *next_frame)
+or1k_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
{
CORE_ADDR pc;
/* Implement the unwind_sp gdbarch method. */
static CORE_ADDR
-or1k_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
+or1k_unwind_sp (struct gdbarch *gdbarch, 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 (struct frame_info *this_frame, void **prologue_cache)
+or1k_frame_cache (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 (struct frame_info *this_frame,
+or1k_frame_this_id (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 (struct frame_info *this_frame,
+or1k_frame_prev_register (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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame, void **this_cache)
+ppcfbsd_sigtramp_frame_cache (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 (struct frame_info *this_frame,
+ppcfbsd_sigtramp_frame_this_id (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 (struct frame_info *this_frame,
+ppcfbsd_sigtramp_frame_prev_register (frame_info_ptr this_frame,
void **this_cache, int regnum)
{
struct trad_frame_cache *cache =
stub sequence. */
static CORE_ADDR
-ppc_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
+ppc_skip_trampoline_code (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 (struct frame_info *this_frame,
+ppc_linux_sigtramp_cache (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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame, void **this_cache)
+ppcobsd_sigtramp_frame_cache (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 (struct frame_info *this_frame,
+ppcobsd_sigtramp_frame_this_id (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 (struct frame_info *this_frame,
+ppcobsd_sigtramp_frame_prev_register (frame_info_ptr this_frame,
void **this_cache, int regnum)
{
struct trad_frame_cache *cache =
#include "gdbarch.h"
struct gdbarch;
-struct frame_info;
+class frame_info_ptr;
struct value;
struct regcache;
struct type;
int optional; /* If non-zero, this insn may be absent. */
};
-extern int ppc_insns_match_pattern (struct frame_info *frame, CORE_ADDR pc,
+extern int ppc_insns_match_pattern (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 (struct frame_info *frame, CORE_ADDR plt_off)
+ppc64_plt_entry_point (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 (struct frame_info *frame, CORE_ADDR plt_off,
+ppc64_plt_pcrel_entry_point (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 (struct frame_info *frame, unsigned int *insn)
+ppc64_standard_linkage1_target (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 (struct frame_info *frame, unsigned int *insn)
+ppc64_standard_linkage2_target (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 (struct frame_info *frame, unsigned int *insn)
+ppc64_standard_linkage3_target (frame_info_ptr frame, unsigned int *insn)
{
CORE_ADDR plt_off = ppc_insn_ds_field (insn[1]);
}
static CORE_ADDR
-ppc64_standard_linkage4_target (struct frame_info *frame, unsigned int *insn)
+ppc64_standard_linkage4_target (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 (struct frame_info *frame, unsigned int *insn,
+ppc64_pcrel_linkage1_target (frame_info_ptr frame, unsigned int *insn,
CORE_ADDR pc)
{
/* insn[0] is for the std instruction. */
}
static CORE_ADDR
-ppc64_pcrel_linkage2_target (struct frame_info *frame, unsigned int *insn,
+ppc64_pcrel_linkage2_target (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 (struct frame_info *frame, CORE_ADDR pc)
+ppc64_skip_trampoline_code_1 (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 (struct frame_info *frame, CORE_ADDR pc)
+ppc64_skip_trampoline_code (frame_info_ptr frame, CORE_ADDR pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
#define PPC64_TDEP_H
struct gdbarch;
-struct frame_info;
+class frame_info_ptr;
struct target_ops;
-extern CORE_ADDR ppc64_skip_trampoline_code (struct frame_info *frame,
+extern CORE_ADDR ppc64_skip_trampoline_code (frame_info_ptr frame,
CORE_ADDR pc);
extern CORE_ADDR ppc64_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
{
if (has_stack_frames ())
{
- struct frame_info *frame;
+ frame_info_ptr frame;
CORE_ADDR pc;
frame = get_selected_frame (NULL);
void
print_variable_and_value (const char *name, struct symbol *var,
- struct frame_info *frame,
+ frame_info_ptr frame,
struct ui_file *stream, int indent)
{
/* See comments in probe.h. */
struct value *
-probe_safe_evaluate_at_pc (struct frame_info *frame, unsigned n)
+probe_safe_evaluate_at_pc (frame_info_ptr frame, unsigned n)
{
struct bound_probe probe;
unsigned n_args;
compute_probe_arg (struct gdbarch *arch, struct internalvar *ivar,
void *data)
{
- struct frame_info *frame = get_selected_frame (_("No frame selected"));
+ frame_info_ptr frame = get_selected_frame (_("No frame selected"));
CORE_ADDR pc = get_frame_pc (frame);
int sel = (int) (uintptr_t) data;
struct bound_probe pc_probe;
corresponding to it. The argument number is represented N.
This function can throw an exception. */
virtual struct value *evaluate_argument (unsigned n,
- struct frame_info *frame) = 0;
+ 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 (struct frame_info *frame,
+extern struct value *probe_safe_evaluate_at_pc (frame_info_ptr frame,
unsigned n);
#endif /* !defined (PROBE_H) */
extern int emit_inferior_call_event (inferior_call_kind kind,
ptid_t thread, CORE_ADDR addr);
-extern int emit_register_changed_event (struct frame_info *frame,
+extern int emit_register_changed_event (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,
(struct finish_breakpoint_object *) self;
PyObject *frame_obj = NULL;
int thread;
- struct frame_info *frame = NULL; /* init for gcc -Wall */
- struct frame_info *prev_frame = NULL;
+ frame_info_ptr frame = NULL; /* init for gcc -Wall */
+ frame_info_ptr prev_frame = NULL;
struct frame_id frame_id;
PyObject *internal = NULL;
int internal_bp = 0;
object. If the frame doesn't exist anymore (the frame id doesn't
correspond to any frame in the inferior), returns NULL. */
-struct frame_info *
+frame_info_ptr
frame_object_to_frame_info (PyObject *obj)
{
frame_object *frame_obj = (frame_object *) obj;
- struct frame_info *frame;
+ frame_info_ptr frame;
frame = frame_find_by_id (frame_obj->frame_id);
if (frame == NULL)
static PyObject *
frapy_is_valid (PyObject *self, PyObject *args)
{
- struct frame_info *frame = NULL;
+ frame_info_ptr frame = NULL;
try
{
static PyObject *
frapy_name (PyObject *self, PyObject *args)
{
- struct frame_info *frame;
+ frame_info_ptr frame;
gdb::unique_xmalloc_ptr<char> name;
enum language lang;
PyObject *result;
static PyObject *
frapy_type (PyObject *self, PyObject *args)
{
- struct frame_info *frame;
+ frame_info_ptr frame;
enum frame_type type = NORMAL_FRAME;/* Initialize to appease gcc warning. */
try
static PyObject *
frapy_arch (PyObject *self, PyObject *args)
{
- struct frame_info *frame = NULL; /* Initialize to appease gcc warning. */
+ frame_info_ptr frame = NULL; /* Initialize to appease gcc warning. */
frame_object *obj = (frame_object *) self;
try
static PyObject *
frapy_unwind_stop_reason (PyObject *self, PyObject *args)
{
- struct frame_info *frame = NULL; /* Initialize to appease gcc warning. */
+ frame_info_ptr frame = NULL; /* Initialize to appease gcc warning. */
enum unwind_stop_reason stop_reason;
try
frapy_pc (PyObject *self, PyObject *args)
{
CORE_ADDR pc = 0; /* Initialize to appease gcc warning. */
- struct frame_info *frame;
+ frame_info_ptr frame;
try
{
return NULL;
try
{
- struct frame_info *frame;
+ frame_info_ptr frame;
int regnum;
FRAPY_REQUIRE_VALID (self, frame);
static PyObject *
frapy_block (PyObject *self, PyObject *args)
{
- struct frame_info *frame;
+ frame_info_ptr frame;
const struct block *block = NULL, *fn_block;
try
frapy_function (PyObject *self, PyObject *args)
{
struct symbol *sym = NULL;
- struct frame_info *frame;
+ frame_info_ptr frame;
try
{
Sets a Python exception and returns NULL on error. */
PyObject *
-frame_info_to_frame_object (struct frame_info *frame)
+frame_info_to_frame_object (frame_info_ptr frame)
{
gdbpy_ref<frame_object> frame_obj (PyObject_New (frame_object,
&frame_object_type));
static PyObject *
frapy_older (PyObject *self, PyObject *args)
{
- struct frame_info *frame, *prev = NULL;
+ frame_info_ptr frame, prev = NULL;
PyObject *prev_obj = NULL; /* Initialize to appease gcc warning. */
try
static PyObject *
frapy_newer (PyObject *self, PyObject *args)
{
- struct frame_info *frame, *next = NULL;
+ frame_info_ptr frame, next = NULL;
PyObject *next_obj = NULL; /* Initialize to appease gcc warning. */
try
static PyObject *
frapy_find_sal (PyObject *self, PyObject *args)
{
- struct frame_info *frame;
+ frame_info_ptr frame;
PyObject *sal_obj = NULL; /* Initialize to appease gcc warning. */
try
static PyObject *
frapy_read_var (PyObject *self, PyObject *args)
{
- struct frame_info *frame;
+ frame_info_ptr frame;
PyObject *sym_obj, *block_obj = NULL;
struct symbol *var = NULL; /* gcc-4.3.2 false warning. */
const struct block *block = NULL;
static PyObject *
frapy_select (PyObject *self, PyObject *args)
{
- struct frame_info *fi;
+ frame_info_ptr fi;
try
{
static PyObject *
frapy_level (PyObject *self, PyObject *args)
{
- struct frame_info *fi;
+ frame_info_ptr fi;
try
{
{
try
{
- struct frame_info *fi;
+ frame_info_ptr fi;
FRAPY_REQUIRE_VALID (self, fi);
enum language lang = get_frame_language (fi);
PyObject *
gdbpy_newest_frame (PyObject *self, PyObject *args)
{
- struct frame_info *frame = NULL;
+ frame_info_ptr frame = NULL;
try
{
PyObject *
gdbpy_selected_frame (PyObject *self, PyObject *args)
{
- struct frame_info *frame = NULL;
+ frame_info_ptr frame = NULL;
try
{
struct ui_out *out,
enum ext_lang_frame_args args_type,
int print_args_field,
- struct frame_info *frame)
+ frame_info_ptr frame)
{
struct value_print_options opts;
int indent,
enum ext_lang_frame_args args_type,
int print_args_field,
- struct frame_info *frame)
+ 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,
- struct frame_info *frame)
+ frame_info_ptr frame)
{
gdbpy_ref<> args_iter (get_py_iter_from_func (filter, "frame_args"));
if (args_iter == NULL)
struct ui_out *out,
enum ext_lang_frame_args args_type,
int indent,
- struct frame_info *frame)
+ frame_info_ptr frame)
{
gdbpy_ref<> locals_iter (get_py_iter_from_func (filter, "frame_locals"));
if (locals_iter == NULL)
py_print_args (PyObject *filter,
struct ui_out *out,
enum ext_lang_frame_args args_type,
- struct frame_info *frame)
+ frame_info_ptr frame)
{
gdbpy_ref<> args_iter (get_py_iter_from_func (filter, "frame_args"));
if (args_iter == NULL)
int has_addr = 0;
CORE_ADDR address = 0;
struct gdbarch *gdbarch = NULL;
- struct frame_info *frame = NULL;
+ frame_info_ptr frame = NULL;
struct value_print_options opts;
int print_level, print_frame_info, print_args, print_locals;
struct frame_info **slot;
int level;
- slot = (struct frame_info **) htab_find_slot (levels_printed,
- frame, INSERT);
+ slot = (frame_info **) htab_find_slot (levels_printed,
+ frame.get(), INSERT);
level = frame_relative_level (frame);
out->field_skip ("level");
else
{
- *slot = frame;
+ *slot = frame.get ();
annotate_frame_begin (print_level ? level : 0,
gdbarch, address);
out->text ("#");
frame FRAME. */
static PyObject *
-bootstrap_python_frame_filters (struct frame_info *frame,
+bootstrap_python_frame_filters (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,
- struct frame_info *frame, frame_filter_flags flags,
+ 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 (struct frame_info *frame, int regnum)
+python_on_register_change (frame_info_ptr frame, int regnum)
{
gdbpy_enter enter_py (target_gdbarch ());
register number. */
static gdbpy_ref<>
-create_register_changed_event_object (struct frame_info *frame,
+create_register_changed_event_object (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 (struct frame_info* frame, int regnum)
+emit_register_changed_event (frame_info_ptr frame, int regnum)
{
if (evregpy_no_listeners_p (gdb_py_events.register_changed))
return 0;
sympy_value (PyObject *self, PyObject *args)
{
struct symbol *symbol = NULL;
- struct frame_info *frame_info = NULL;
+ frame_info_ptr frame_info = NULL;
PyObject *frame_obj = NULL;
struct value *value = NULL;
block = block_object_to_block (block_obj);
else
{
- struct frame_info *selected_frame;
+ frame_info_ptr selected_frame;
try
{
const struct block *block = NULL;
try
{
- struct frame_info *selected_frame
+ frame_info_ptr selected_frame
= get_selected_frame (_("No frame selected."));
block = get_frame_block (selected_frame, NULL);
}
PyObject_HEAD
/* Frame we are unwinding. */
- struct frame_info *frame_info;
+ frame_info_ptr frame_info;
/* Its architecture, passed by the sniffer caller. */
struct gdbarch *gdbarch;
static PyObject *
pending_framepy_str (PyObject *self)
{
- struct frame_info *frame = ((pending_frame_object *) self)->frame_info;
+ frame_info_ptr frame = ((pending_frame_object *) self)->frame_info;
const char *sp_str = NULL;
const char *pc_str = NULL;
/* frame_unwind.this_id method. */
static void
-pyuw_this_id (struct frame_info *this_frame, void **cache_ptr,
+pyuw_this_id (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 (struct frame_info *this_frame, void **cache_ptr,
+pyuw_prev_register (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, struct frame_info *this_frame,
+pyuw_sniffer (const struct frame_unwind *self, frame_info_ptr this_frame,
void **cache_ptr)
{
PYUW_SCOPED_DEBUG_ENTER_EXIT;
/* Frame cache release shim. */
static void
-pyuw_dealloc_cache (struct frame_info *this_frame, void *cache)
+pyuw_dealloc_cache (frame_info *this_frame, void *cache)
{
PYUW_SCOPED_DEBUG_ENTER_EXIT;
cached_frame_info *cached_frame = (cached_frame_info *) cache;
const struct language_defn *language);
extern enum ext_lang_bt_status gdbpy_apply_frame_filter
(const struct extension_language_defn *,
- struct frame_info *frame, frame_filter_flags flags,
+ 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 *,
PyObject *value_to_value_object (struct value *v);
PyObject *value_to_value_object_no_release (struct value *v);
PyObject *type_to_type_object (struct type *);
-PyObject *frame_info_to_frame_object (struct frame_info *frame);
+PyObject *frame_info_to_frame_object (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 *);
struct type *type_object_to_type (PyObject *obj);
struct symtab *symtab_object_to_symtab (PyObject *obj);
struct symtab_and_line *sal_object_to_symtab_and_line (PyObject *obj);
-struct frame_info *frame_object_to_frame_info (PyObject *frame_obj);
+frame_info_ptr frame_object_to_frame_info (PyObject *frame_obj);
struct gdbarch *arch_object_to_gdbarch (PyObject *obj);
/* Convert Python object OBJ to a program_space pointer. OBJ must be a
struct thread_info *tp;
/* The frame info. */
- struct frame_info *frame;
+ frame_info *frame;
/* The branch trace function segment. */
const struct btrace_function *bfun;
/* Create a new btrace frame cache. */
static struct btrace_frame_cache *
-bfcache_new (struct frame_info *frame)
+bfcache_new (frame_info_ptr frame)
{
struct btrace_frame_cache *cache;
void **slot;
cache = FRAME_OBSTACK_ZALLOC (struct btrace_frame_cache);
- cache->frame = frame;
+ cache->frame = frame.get ();
slot = htab_find_slot (bfcache, cache, INSERT);
gdb_assert (*slot == NULL);
/* Extract the branch trace function from a branch trace frame. */
static const struct btrace_function *
-btrace_get_frame_function (struct frame_info *frame)
+btrace_get_frame_function (frame_info_ptr frame)
{
const struct btrace_frame_cache *cache;
struct btrace_frame_cache pattern;
void **slot;
- pattern.frame = frame;
+ pattern.frame = frame.get ();
slot = htab_find_slot (bfcache, &pattern, NO_INSERT);
if (slot == NULL)
/* Implement stop_reason method for record_btrace_frame_unwind. */
static enum unwind_stop_reason
-record_btrace_frame_unwind_stop_reason (struct frame_info *this_frame,
+record_btrace_frame_unwind_stop_reason (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 (struct frame_info *this_frame, void **this_cache,
+record_btrace_frame_this_id (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 (struct frame_info *this_frame,
+record_btrace_frame_prev_register (frame_info_ptr this_frame,
void **this_cache,
int regnum)
{
static int
record_btrace_frame_sniffer (const struct frame_unwind *self,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_cache)
{
const struct btrace_function *bfun;
struct btrace_frame_cache *cache;
struct thread_info *tp;
- struct frame_info *next;
+ frame_info_ptr next;
/* THIS_FRAME does not contain a reference to its thread. */
tp = inferior_thread ();
static int
record_btrace_tailcall_frame_sniffer (const struct frame_unwind *self,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_cache)
{
const struct btrace_function *bfun, *callee;
struct btrace_frame_cache *cache;
struct btrace_call_iterator it;
- struct frame_info *next;
+ frame_info_ptr next;
struct thread_info *tinfo;
next = get_next_frame (this_frame);
}
static void
-record_btrace_frame_dealloc_cache (struct frame_info *self, void *this_cache)
+record_btrace_frame_dealloc_cache (frame_info *self, void *this_cache)
{
struct btrace_frame_cache *cache;
void **slot;
static void
riscv_fbsd_sigframe_init (const struct tramp_frame *self,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *frame)
+riscv_linux_syscall_next_pc (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 (struct frame_info *frame, const void *baton)
+value_of_riscv_user_reg (frame_info_ptr frame, const void *baton)
{
const int *reg_p = (const int *) baton;
return value_of_register (*reg_p, frame);
static void
riscv_print_one_register_info (struct gdbarch *gdbarch,
struct ui_file *file,
- struct frame_info *frame,
+ 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,
- struct frame_info *frame,
+ frame_info_ptr frame,
int regnum, int print_all)
{
if (regnum != -1)
unwinder. */
static struct riscv_unwind_cache *
-riscv_frame_cache (struct frame_info *this_frame, void **this_cache)
+riscv_frame_cache (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 (struct frame_info *this_frame,
+riscv_frame_this_id (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 (struct frame_info *this_frame,
+riscv_frame_prev_register (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) (struct frame_info *frame) = nullptr;
+ CORE_ADDR (*syscall_next_pc) (frame_info_ptr frame) = nullptr;
};
/* Implement the "unwind_pc" gdbarch method. */
static CORE_ADDR
-rl78_unwind_pc (struct gdbarch *arch, struct frame_info *next_frame)
+rl78_unwind_pc (struct gdbarch *arch, 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 (struct frame_info *this_frame,
+rl78_analyze_frame_prologue (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 (struct frame_info *this_frame, void **this_prologue_cache)
+rl78_frame_base (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 (struct frame_info *this_frame,
+rl78_this_id (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 (struct frame_info *this_frame,
+rl78_prev_register (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, struct frame_info *this_frame)
+rl78_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
{
return
frame_id_build (rl78_make_data_address
#define AIX_TEXT_SEGMENT_BASE 0x10000000
static struct trad_frame_cache *
-aix_sighandle_frame_cache (struct frame_info *this_frame,
+aix_sighandle_frame_cache (frame_info_ptr this_frame,
void **this_cache)
{
LONGEST backchain;
}
static void
-aix_sighandle_frame_this_id (struct frame_info *this_frame,
+aix_sighandle_frame_this_id (frame_info_ptr this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
}
static struct value *
-aix_sighandle_frame_prev_register (struct frame_info *this_frame,
+aix_sighandle_frame_prev_register (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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_prologue_cache)
{
CORE_ADDR pc = get_frame_pc (this_frame);
execution will return to the saved PC in the frame. */
if (dest < AIX_TEXT_SEGMENT_BASE)
{
- struct frame_info *frame = get_current_frame ();
+ frame_info_ptr frame = get_current_frame ();
dest = read_memory_unsigned_integer
(get_frame_base (frame) + SIG_FRAME_PC_OFFSET,
limit for the size of an epilogue. */
static int
-rs6000_in_function_epilogue_frame_p (struct frame_info *curfrm,
+rs6000_in_function_epilogue_frame_p (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 (struct frame_info *frame, int argi,
+rs6000_fetch_pointer_argument (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 (struct frame_info *frame, CORE_ADDR pc)
+rs6000_skip_trampoline_code (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 (struct frame_info *frame,
+rs6000_register_to_value (frame_info_ptr frame,
int regnum,
struct type *type,
gdb_byte *to,
}
static void
-rs6000_value_to_register (struct frame_info *frame,
+rs6000_value_to_register (frame_info_ptr frame,
int regnum,
struct type *type,
const gdb_byte *from)
};
static struct rs6000_frame_cache *
-rs6000_frame_cache (struct frame_info *this_frame, void **this_cache)
+rs6000_frame_cache (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 (struct frame_info *this_frame, void **this_cache,
+rs6000_frame_this_id (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 (struct frame_info *this_frame,
+rs6000_frame_prev_register (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 (struct frame_info *this_frame, void **this_cache)
+rs6000_epilogue_frame_cache (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 (struct frame_info *this_frame,
+rs6000_epilogue_frame_this_id (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 (struct frame_info *this_frame,
+rs6000_epilogue_frame_prev_register (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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_prologue_cache)
{
if (frame_relative_level (this_frame) == 0)
\f
static CORE_ADDR
-rs6000_frame_base_address (struct frame_info *this_frame, void **this_cache)
+rs6000_frame_base_address (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 (struct frame_info *this_frame)
+rs6000_frame_base_sniffer (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,
- struct frame_info *this_frame)
+ 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 (struct frame_info *frame, CORE_ADDR pc)
+read_insn (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 (struct frame_info *frame, CORE_ADDR pc,
+ppc_insns_match_pattern (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 (struct frame_info *this_frame,
+rx_analyze_frame_prologue (frame_info_ptr this_frame,
enum rx_frame_type frame_type,
void **this_prologue_cache)
{
instruction. */
static enum rx_frame_type
-rx_frame_type (struct frame_info *this_frame, void **this_cache)
+rx_frame_type (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 (struct frame_info *this_frame, void **this_cache)
+rx_frame_base (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 (struct frame_info *this_frame, void **this_cache,
+rx_frame_this_id (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 (struct frame_info *this_frame, void **this_cache,
+rx_frame_prev_register (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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame, void **prologue_cache)
+s12z_frame_cache (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 (struct frame_info *this_frame,
+s12z_frame_this_id (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 (struct frame_info *this_frame,
+s12z_frame_prev_register (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,
- struct frame_info *frame,
+ frame_info_ptr frame,
int reg)
{
struct value *v = value_of_register (reg, frame);
static void
s12z_print_registers_info (struct gdbarch *gdbarch,
struct ui_file *file,
- struct frame_info *frame,
+ 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 (struct frame_info *this_frame,
+s390_sigtramp_frame_unwind_cache (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 (struct frame_info *this_frame,
+s390_sigtramp_frame_this_id (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 (struct frame_info *this_frame,
+s390_sigtramp_frame_prev_register (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,
- struct frame_info *this_frame,
+ 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, struct frame_info *this_frame)
+s390_dummy_id (struct gdbarch *gdbarch, 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, struct frame_info *next_frame)
+s390_unwind_pc (struct gdbarch *gdbarch, 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, struct frame_info *next_frame)
+s390_unwind_sp (struct gdbarch *gdbarch, 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 (struct frame_info *this_frame, int regnum)
+s390_unwind_pseudo_register (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 (struct frame_info *this_frame, void **this_cache,
+s390_dwarf2_prev_register (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,
- struct frame_info *this_frame)
+ 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 (struct frame_info *this_frame,
+s390_trad_frame_prev_register (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 (struct frame_info *this_frame,
+s390_prologue_frame_unwind_cache (frame_info_ptr this_frame,
struct s390_unwind_cache *info)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
CORE_ADDR prev_sp;
int frame_pointer;
int size;
- struct frame_info *next_frame;
+ frame_info_ptr next_frame;
/* Try to find the function start address. If we can't find it, we don't
bother searching for it -- with modern compilers this would be mostly
back chain unwinding. Helper for s390_frame_unwind_cache. */
static void
-s390_backchain_frame_unwind_cache (struct frame_info *this_frame,
+s390_backchain_frame_unwind_cache (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 (struct frame_info *this_frame,
+s390_frame_unwind_cache (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 (struct frame_info *this_frame,
+s390_frame_this_id (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 (struct frame_info *this_frame,
+s390_frame_prev_register (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 (struct frame_info *this_frame,
+s390_stub_frame_unwind_cache (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 (struct frame_info *this_frame,
+s390_stub_frame_this_id (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 (struct frame_info *this_frame,
+s390_stub_frame_prev_register (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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_prologue_cache)
{
CORE_ADDR addr_in_block;
/* Frame base handling. */
static CORE_ADDR
-s390_frame_base_address (struct frame_info *this_frame, void **this_cache)
+s390_frame_base_address (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 (struct frame_info *this_frame, void **this_cache)
+s390_local_base_address (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
- (struct frame_info *this_frame, struct trad_frame_saved_reg saved_regs[],
+ (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 (struct frame_info *this_frame,
+sentinel_frame_prev_register (frame_info_ptr this_frame,
void **this_prologue_cache,
int regnum)
{
}
static void
-sentinel_frame_this_id (struct frame_info *this_frame,
+sentinel_frame_this_id (frame_info_ptr this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
}
static struct gdbarch *
-sentinel_frame_prev_arch (struct frame_info *this_frame,
+sentinel_frame_prev_arch (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 (struct frame_info *this_frame,
+sh_linux_sigtramp_cache (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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame)
+ 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 (struct frame_info *this_frame, void **this_cache)
+sh_frame_cache (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 (struct frame_info *this_frame,
+sh_frame_prev_register (frame_info_ptr this_frame,
void **this_cache, int regnum)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
static void
-sh_frame_this_id (struct frame_info *this_frame, void **this_cache,
+sh_frame_this_id (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 (struct frame_info *this_frame, void **this_cache)
+sh_frame_base_address (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 (struct frame_info *this_frame)
+sh_make_stub_cache (frame_info_ptr this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct sh_frame_cache *cache;
}
static void
-sh_stub_this_id (struct frame_info *this_frame, void **this_cache,
+sh_stub_this_id (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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_prologue_cache)
{
CORE_ADDR addr_in_block;
/* Default to the current function if no argument is given. */
if (arg == NULL)
{
- frame_info *fi = get_selected_frame (_("No default function now."));
+ frame_info_ptr fi = get_selected_frame (_("No default function now."));
struct symbol *sym = get_frame_function (fi);
const char *name = NULL;
/* Return whether THIS_FRAME corresponds to a Solaris sigtramp routine. */
int
-sol2_sigtramp_p (struct frame_info *this_frame)
+sol2_sigtramp_p (frame_info_ptr this_frame)
{
CORE_ADDR pc = get_frame_pc (this_frame);
const char *name;
struct gdbarch;
-int sol2_sigtramp_p (struct frame_info *this_frame);
+int sol2_sigtramp_p (frame_info_ptr this_frame);
void sol2_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch);
{
enum probe_action action;
unsigned probe_argc = 0;
- struct frame_info *frame = get_current_frame ();
+ frame_info_ptr frame = get_current_frame ();
action = pa->action;
if (action == DO_NOTHING || action == PROBES_INTERFACE_FAILED)
enum probe_action action;
struct value *val = NULL;
CORE_ADDR pc, debug_base, lm = 0;
- struct frame_info *frame = get_current_frame ();
+ frame_info_ptr frame = get_current_frame ();
/* Do nothing if not using the probes interface. */
if (info->probes_table == NULL)
/* Signal trampoline support. */
static void sparc32_linux_sigframe_init (const struct tramp_frame *self,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
address. */
static CORE_ADDR
-sparc32_linux_step_trap (struct frame_info *frame, unsigned long insn)
+sparc32_linux_step_trap (frame_info_ptr frame, unsigned long insn)
{
if (insn == 0x91d02010)
{
}
trad_frame_saved_reg *
-sparc32nbsd_sigcontext_saved_regs (struct frame_info *this_frame)
+sparc32nbsd_sigcontext_saved_regs (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 (struct frame_info *this_frame,
+sparc32nbsd_sigcontext_frame_cache (frame_info_ptr this_frame,
void **this_cache)
{
struct sparc_frame_cache *cache;
}
static void
-sparc32nbsd_sigcontext_frame_this_id (struct frame_info *this_frame,
+sparc32nbsd_sigcontext_frame_this_id (frame_info_ptr this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-sparc32nbsd_sigcontext_frame_prev_register (struct frame_info *this_frame,
+sparc32nbsd_sigcontext_frame_prev_register (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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_cache)
{
CORE_ADDR pc = get_frame_pc (this_frame);
address. */
CORE_ADDR
-sparcnbsd_step_trap (struct frame_info *frame, unsigned long insn)
+sparcnbsd_step_trap (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 (struct frame_info *this_frame,
+sparc32obsd_sigtramp_frame_cache (frame_info_ptr this_frame,
void **this_cache)
{
struct sparc_frame_cache *cache;
}
static void
-sparc32obsd_sigtramp_frame_this_id (struct frame_info *this_frame,
+sparc32obsd_sigtramp_frame_this_id (frame_info_ptr this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-sparc32obsd_sigtramp_frame_prev_register (struct frame_info *this_frame,
+sparc32obsd_sigtramp_frame_prev_register (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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame,
+sparc32_sol2_sigtramp_frame_cache (frame_info_ptr this_frame,
void **this_cache)
{
struct sparc_frame_cache *cache;
}
static void
-sparc32_sol2_sigtramp_frame_this_id (struct frame_info *this_frame,
+sparc32_sol2_sigtramp_frame_this_id (frame_info_ptr this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-sparc32_sol2_sigtramp_frame_prev_register (struct frame_info *this_frame,
+sparc32_sol2_sigtramp_frame_prev_register (frame_info_ptr this_frame,
void **this_cache,
int regnum)
{
static int
sparc32_sol2_sigtramp_frame_sniffer (const struct frame_unwind *self,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_cache)
{
return sol2_sigtramp_p (this_frame);
/* Normal frames. */
struct sparc_frame_cache *
-sparc_frame_cache (struct frame_info *this_frame, void **this_cache)
+sparc_frame_cache (frame_info_ptr this_frame, void **this_cache)
{
struct sparc_frame_cache *cache;
}
struct sparc_frame_cache *
-sparc32_frame_cache (struct frame_info *this_frame, void **this_cache)
+sparc32_frame_cache (frame_info_ptr this_frame, void **this_cache)
{
struct sparc_frame_cache *cache;
struct symbol *sym;
}
static void
-sparc32_frame_this_id (struct frame_info *this_frame, void **this_cache,
+sparc32_frame_this_id (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 (struct frame_info *this_frame,
+sparc32_frame_prev_register (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 (struct frame_info *this_frame, void **this_cache)
+sparc32_frame_base_address (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, struct frame_info *this_frame)
+sparc_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
{
CORE_ADDR sp;
}
static int
-sparc32_dwarf2_struct_return_p (struct frame_info *this_frame)
+sparc32_dwarf2_struct_return_p (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,
- struct frame_info *this_frame)
+ frame_info_ptr this_frame)
{
int off;
}
else if (X_OP (insn) == 2 && X_OP3 (insn) == 0x3a)
{
- struct frame_info *frame = get_current_frame ();
+ frame_info_ptr frame = get_current_frame ();
/* Trap instruction (TRAP). */
gdbarch *arch = regcache->arch ();
}
static CORE_ADDR
-sparc_step_trap (struct frame_info *frame, unsigned long insn)
+sparc_step_trap (frame_info_ptr frame, unsigned long insn)
{
return 0;
}
"l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7", \
"i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7"
-struct frame_info;
+class frame_info_ptr;
struct gdbarch;
struct regcache;
struct regset;
size_t plt_entry_size = 0;
/* Alternative location for trap return. Used for single-stepping. */
- CORE_ADDR (*step_trap) (struct frame_info *frame, unsigned long insn)
+ CORE_ADDR (*step_trap) (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 (struct frame_info *this_frame, void **this_cache);
+ sparc_frame_cache (frame_info_ptr this_frame, void **this_cache);
extern struct sparc_frame_cache *
- sparc32_frame_cache (struct frame_info *this_frame, void **this_cache);
+ sparc32_frame_cache (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 (struct frame_info *frame,
+extern CORE_ADDR sparcnbsd_step_trap (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 (struct frame_info *next_frame);
+ sparc32nbsd_sigcontext_saved_regs (frame_info_ptr next_frame);
#endif /* sparc-tdep.h */
}
static struct sparc_frame_cache *
-sparc64fbsd_sigtramp_frame_cache (struct frame_info *this_frame,
+sparc64fbsd_sigtramp_frame_cache (frame_info_ptr this_frame,
void **this_cache)
{
struct sparc_frame_cache *cache;
}
static void
-sparc64fbsd_sigtramp_frame_this_id (struct frame_info *this_frame,
+sparc64fbsd_sigtramp_frame_this_id (frame_info_ptr this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-sparc64fbsd_sigtramp_frame_prev_register (struct frame_info *this_frame,
+sparc64fbsd_sigtramp_frame_prev_register (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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
address. */
static CORE_ADDR
-sparc64_linux_step_trap (struct frame_info *frame, unsigned long insn)
+sparc64_linux_step_trap (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 (struct frame_info *frame, CORE_ADDR *pc)
+sparc64_linux_get_longjmp_target (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,
- struct frame_info *this_frame)
+ 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 (struct frame_info *this_frame,
+sparc64nbsd_sigcontext_frame_cache (frame_info_ptr this_frame,
void **this_cache)
{
struct sparc_frame_cache *cache;
}
static void
-sparc64nbsd_sigcontext_frame_this_id (struct frame_info *this_frame,
+sparc64nbsd_sigcontext_frame_this_id (frame_info_ptr this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-sparc64nbsd_sigcontext_frame_prev_register (struct frame_info *this_frame,
+sparc64nbsd_sigcontext_frame_prev_register (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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_cache)
{
CORE_ADDR pc = get_frame_pc (this_frame);
}
static struct sparc_frame_cache *
-sparc64obsd_frame_cache (struct frame_info *this_frame, void **this_cache)
+sparc64obsd_frame_cache (frame_info_ptr this_frame, void **this_cache)
{
struct sparc_frame_cache *cache;
CORE_ADDR addr;
}
static void
-sparc64obsd_frame_this_id (struct frame_info *this_frame, void **this_cache,
+sparc64obsd_frame_this_id (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 (struct frame_info *this_frame,
+sparc64obsd_frame_prev_register (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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *this_frame, void **this_cache)
+sparc64obsd_trapframe_cache (frame_info_ptr this_frame, void **this_cache)
{
struct sparc_frame_cache *cache;
CORE_ADDR sp, trapframe_addr;
}
static void
-sparc64obsd_trapframe_this_id (struct frame_info *this_frame,
+sparc64obsd_trapframe_this_id (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 (struct frame_info *this_frame,
+sparc64obsd_trapframe_prev_register (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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_cache)
{
CORE_ADDR pc;
\f
static struct sparc_frame_cache *
-sparc64_sol2_sigtramp_frame_cache (struct frame_info *this_frame,
+sparc64_sol2_sigtramp_frame_cache (frame_info_ptr this_frame,
void **this_cache)
{
struct sparc_frame_cache *cache;
}
static void
-sparc64_sol2_sigtramp_frame_this_id (struct frame_info *this_frame,
+sparc64_sol2_sigtramp_frame_this_id (frame_info_ptr this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-sparc64_sol2_sigtramp_frame_prev_register (struct frame_info *this_frame,
+sparc64_sol2_sigtramp_frame_prev_register (frame_info_ptr this_frame,
void **this_cache,
int regnum)
{
static int
sparc64_sol2_sigtramp_frame_sniffer (const struct frame_unwind *self,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_cache)
{
return sol2_sigtramp_p (this_frame);
/* Normal frames. */
static struct sparc_frame_cache *
-sparc64_frame_cache (struct frame_info *this_frame, void **this_cache)
+sparc64_frame_cache (frame_info_ptr this_frame, void **this_cache)
{
return sparc_frame_cache (this_frame, this_cache);
}
static void
-sparc64_frame_this_id (struct frame_info *this_frame, void **this_cache,
+sparc64_frame_this_id (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 (struct frame_info *this_frame, void **this_cache,
+sparc64_frame_prev_register (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 (struct frame_info *this_frame, void **this_cache)
+sparc64_frame_base_address (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,
- struct frame_info *this_frame)
+ frame_info_ptr this_frame)
{
switch (regnum)
{
#ifndef SPARC64_TDEP_H
#define SPARC64_TDEP_H 1
-struct frame_info;
+class frame_info_ptr;
struct gdbarch;
struct regcache;
struct sparc_gregmap;
extern struct trad_frame_saved_reg *
sparc64nbsd_sigcontext_saved_regs (CORE_ADDR sigcontext_addr,
- struct frame_info *next_frame);
+ frame_info_ptr next_frame);
extern const struct sparc_fpregmap sparc64_bsd_fpregmap;
/* Prototypes for local functions. */
-static void print_frame_local_vars (struct frame_info *frame,
+static void print_frame_local_vars (frame_info_ptr frame,
bool quiet,
const char *regexp, const char *t_regexp,
int num_tabs, struct ui_file *stream);
static void print_frame (const frame_print_options &opts,
- frame_info *frame, int print_level,
+ frame_info_ptr frame, int print_level,
enum print_what print_what, int print_args,
struct symtab_and_line sal);
-static struct frame_info *find_frame_for_function (const char *);
-static struct frame_info *find_frame_for_address (CORE_ADDR);
+static frame_info_ptr find_frame_for_function (const char *);
+static frame_info_ptr find_frame_for_address (CORE_ADDR);
/* Zero means do things normally; we are interacting directly with the
user. One means print the full filename and linenumber when a
/* See stack.h. */
bool
-frame_show_address (struct frame_info *frame,
+frame_show_address (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, struct frame_info *frame,
+print_stack_frame_to_uiout (struct ui_out *uiout, 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 (struct frame_info *frame, int print_level,
+print_stack_frame (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 (struct frame_info *frame, long start, int num,
+print_frame_nameless_args (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, struct frame_info *frame,
+read_frame_local (struct symbol *sym, 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 *frame,
+ symbol *sym, 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, struct frame_info *frame,
+ struct symbol *func, 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 (struct frame_info *frame)
+set_current_sal_from_frame (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 *frame,
+print_pc (struct ui_out *uiout, struct gdbarch *gdbarch, frame_info_ptr frame,
CORE_ADDR pc)
{
uiout->field_core_addr ("addr", gdbarch, pc);
void
print_frame_info (const frame_print_options &fp_opts,
- frame_info *frame, int print_level,
+ 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 (struct frame_info *frame, enum language *funlang,
+find_frame_funname (frame_info_ptr frame, enum language *funlang,
struct symbol **funcp)
{
struct symbol *func;
static void
print_frame (const frame_print_options &fp_opts,
- frame_info *frame, int print_level,
+ 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 (struct frame_info *fi, bool selected_frame_p)
+info_frame_command_core (frame_info_ptr fi, bool selected_frame_p)
{
struct symbol *func;
struct symtab *s;
- struct frame_info *calling_frame_info;
+ frame_info_ptr calling_frame_info;
int numregs;
const char *funname = 0;
enum language funlang = language_unknown;
/* Return the innermost frame at level LEVEL. */
-static struct frame_info *
+static frame_info_ptr
leading_innermost_frame (int level)
{
- struct frame_info *leading;
+ frame_info_ptr leading;
leading = get_current_frame ();
/* Return the starting frame needed to handle COUNT outermost frames. */
-static struct frame_info *
+static frame_info_ptr
trailing_outermost_frame (int count)
{
- struct frame_info *current;
- struct frame_info *trailing;
+ frame_info_ptr current;
+ frame_info_ptr trailing;
trailing = get_current_frame ();
SELECT_FRAME. */
static void
-select_frame_command_core (struct frame_info *fi, bool ignored)
+select_frame_command_core (frame_info_ptr fi, bool ignored)
{
- frame_info *prev_frame = get_selected_frame ();
+ frame_info_ptr prev_frame = get_selected_frame ();
select_frame (fi);
if (get_selected_frame () != prev_frame)
gdb::observers::user_selected_context_changed.notify (USER_SELECTED_FRAME);
reprint the current frame summary). */
static void
-frame_command_core (struct frame_info *fi, bool ignored)
+frame_command_core (frame_info_ptr fi, bool ignored)
{
- frame_info *prev_frame = get_selected_frame ();
+ frame_info_ptr prev_frame = get_selected_frame ();
select_frame (fi);
if (get_selected_frame () != prev_frame)
gdb::observers::user_selected_context_changed.notify (USER_SELECTED_FRAME);
'frame' will all cause SELECTED_FRAME_P to be true. In all other cases
SELECTED_FRAME_P is false. */
-template <void (*FPTR) (struct frame_info *fi, bool selected_frame_p)>
+template <void (*FPTR) (frame_info_ptr fi, bool selected_frame_p)>
class frame_command_helper
{
public:
level (const char *arg, int from_tty)
{
int level = value_as_long (parse_and_eval (arg));
- struct frame_info *fid
+ frame_info_ptr fid
= find_relative_frame (get_current_frame (), &level);
if (level != 0)
error (_("No frame at level %s."), arg);
address (const char *arg, int from_tty)
{
CORE_ADDR addr = value_as_address (parse_and_eval (arg));
- struct frame_info *fid = find_frame_for_address (addr);
+ frame_info_ptr fid = find_frame_for_address (addr);
if (fid == NULL)
error (_("No frame at address %s."), arg);
FPTR (fid, false);
static void
view (const char *args, int from_tty)
{
- struct frame_info *fid;
+ frame_info_ptr fid;
if (args == NULL)
error (_("Missing address argument to view a frame"));
{
if (arg == NULL)
error (_("Missing function name argument"));
- struct frame_info *fid = find_frame_for_function (arg);
+ frame_info_ptr fid = find_frame_for_function (arg);
if (fid == NULL)
error (_("No frame for function \"%s\"."), arg);
FPTR (fid, false);
const char *count_exp, int from_tty)
{
- struct frame_info *fi;
+ frame_info_ptr fi;
int count;
int py_start = 0, py_end = 0;
enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
"-no-filters" has been specified from the command. */
if (bt_opts.no_filters || result == EXT_LANG_BT_NO_FILTERS)
{
- struct frame_info *trailing;
+ frame_info_ptr trailing;
/* The following code must do two things. First, it must set the
variable TRAILING to the frame from which we should start
print_variable_and_value_data::operator() (const char *print_name,
struct symbol *sym)
{
- struct frame_info *frame;
+ frame_info_ptr frame;
if (preg.has_value ()
&& preg->exec (sym->natural_name (), 0, NULL, 0) != 0)
This function will invalidate FRAME. */
static void
-print_frame_local_vars (struct frame_info *frame,
+print_frame_local_vars (frame_info_ptr frame,
bool quiet,
const char *regexp, const char *t_regexp,
int num_tabs, struct ui_file *stream)
This function will invalidate FRAME. */
static void
-print_frame_arg_vars (struct frame_info *frame,
+print_frame_arg_vars (frame_info_ptr frame,
bool quiet,
const char *regexp, const char *t_regexp,
struct ui_file *stream)
but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
how much farther the original request asked to go. */
-struct frame_info *
-find_relative_frame (struct frame_info *frame, int *level_offset_ptr)
+frame_info_ptr
+find_relative_frame (frame_info_ptr frame, int *level_offset_ptr)
{
/* Going up is simple: just call get_prev_frame enough times or
until the initial frame is reached. */
while (*level_offset_ptr > 0)
{
- struct frame_info *prev = get_prev_frame (frame);
+ frame_info_ptr prev = get_prev_frame (frame);
if (!prev)
break;
/* Going down is just as simple. */
while (*level_offset_ptr < 0)
{
- struct frame_info *next = get_next_frame (frame);
+ frame_info_ptr next = get_next_frame (frame);
if (!next)
break;
static void
up_silently_base (const char *count_exp)
{
- struct frame_info *frame;
+ frame_info_ptr frame;
int count = 1;
if (count_exp)
static void
down_silently_base (const char *count_exp)
{
- struct frame_info *frame;
+ frame_info_ptr frame;
int count = -1;
if (count_exp)
{
/* Initialize it just to avoid a GCC false warning. */
enum return_value_convention rv_conv = RETURN_VALUE_STRUCT_CONVENTION;
- struct frame_info *thisframe;
+ frame_info_ptr thisframe;
struct gdbarch *gdbarch;
struct symbol *thisfun;
struct value *return_value = NULL;
/* Find the most inner frame in the current stack for a function called
FUNCTION_NAME. If no matching frame is found return NULL. */
-static struct frame_info *
+static frame_info_ptr
find_frame_for_function (const char *function_name)
{
/* Used to hold the lower and upper addresses for each of the
{
CORE_ADDR low, high;
};
- struct frame_info *frame;
+ frame_info_ptr frame;
bool found = false;
int level = 1;
static void
frame_apply_command_count (const char *which_command,
const char *cmd, int from_tty,
- struct frame_info *trailing, int count)
+ frame_info_ptr trailing, int count)
{
qcs_flags flags;
set_backtrace_options set_bt_opts = user_set_backtrace_options;
scoped_restore restore_set_backtrace_options
= make_scoped_restore (&user_set_backtrace_options, set_bt_opts);
- for (frame_info *fi = trailing; fi && count--; fi = get_prev_frame (fi))
+ for (frame_info_ptr fi = trailing; fi && count--; fi = get_prev_frame (fi))
{
QUIT;
frame_apply_command (const char* cmd, int from_tty)
{
int count;
- struct frame_info *trailing;
+ frame_info_ptr trailing;
if (!target_has_stack ())
error (_("No stack."));
/* Find inner-mode frame with frame address ADDRESS. Return NULL if no
matching frame can be found. */
-static struct frame_info *
+static frame_info_ptr
find_frame_for_address (CORE_ADDR address)
{
struct frame_id id;
- struct frame_info *fid;
+ frame_info_ptr fid;
id = frame_id_build_wild (address);
{
if (id == get_frame_id (fid))
{
- struct frame_info *prev_frame;
+ frame_info_ptr prev_frame;
while (1)
{
#ifndef STACK_H
#define STACK_H
-gdb::unique_xmalloc_ptr<char> find_frame_funname (struct frame_info *frame,
+gdb::unique_xmalloc_ptr<char> find_frame_funname (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 (struct frame_info *frame, struct symtab_and_line sal);
+bool frame_show_address (frame_info_ptr frame, struct symtab_and_line sal);
/* Forget the last sal we displayed. */
/* See probe.h. */
struct value *evaluate_argument (unsigned n,
- struct frame_info *frame) override;
+ 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, struct frame_info *frame)
+stap_probe::evaluate_argument (unsigned n, 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 (struct frame_info *frame, const void *baton)
+value_of_builtin_frame_fp_reg (frame_info_ptr frame, const void *baton)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
}
static struct value *
-value_of_builtin_frame_pc_reg (struct frame_info *frame, const void *baton)
+value_of_builtin_frame_pc_reg (frame_info_ptr frame, const void *baton)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
}
static struct value *
-value_of_builtin_frame_sp_reg (struct frame_info *frame, const void *baton)
+value_of_builtin_frame_sp_reg (frame_info_ptr frame, const void *baton)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
}
static struct value *
-value_of_builtin_frame_ps_reg (struct frame_info *frame, const void *baton)
+value_of_builtin_frame_ps_reg (frame_info_ptr frame, const void *baton)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
struct obstack;
struct block;
struct value;
-struct frame_info;
+class frame_info_ptr;
struct agent_expr;
struct axs_value;
class probe;
/* Opaque declarations. */
struct ui_file;
-struct frame_info;
+class frame_info_ptr;
struct symbol;
struct obstack;
struct objfile;
FRAME may be zero. */
struct value *(*read_variable) (struct symbol * symbol,
- struct frame_info * frame);
+ 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,
- struct frame_info *frame);
+ 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,
- struct frame_info *frame);
+ frame_info_ptr frame);
};
/* Functions used with LOC_REGISTER and LOC_REGPARM_ADDR. */
extern const struct gnu_ifunc_fns *gnu_ifunc_fns_p;
-extern CORE_ADDR find_solib_trampoline_target (struct frame_info *, CORE_ADDR);
+extern CORE_ADDR find_solib_trampoline_target (frame_info_ptr , CORE_ADDR);
struct symtab_and_line
{
static void
tic6x_linux_rt_sigreturn_init (const struct tramp_frame *self,
- struct frame_info *this_frame,
+ 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 (struct frame_info *frame)
+tic6x_linux_syscall_next_pc (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,
- struct frame_info *this_frame)
+ 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,
- struct frame_info *this_frame)
+ 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, struct frame_info *next_frame)
+tic6x_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
{
gdb_byte buf[8];
/* Frame base handling. */
static struct tic6x_unwind_cache*
-tic6x_frame_unwind_cache (struct frame_info *this_frame,
+tic6x_frame_unwind_cache (frame_info_ptr this_frame,
void **this_prologue_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
}
static void
-tic6x_frame_this_id (struct frame_info *this_frame, void **this_cache,
+tic6x_frame_this_id (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 (struct frame_info *this_frame, void **this_cache,
+tic6x_frame_prev_register (frame_info_ptr this_frame, void **this_cache,
int regnum)
{
struct tic6x_unwind_cache *cache =
}
static CORE_ADDR
-tic6x_frame_base_address (struct frame_info *this_frame, void **this_cache)
+tic6x_frame_base_address (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 (struct frame_info *this_frame)
+tic6x_make_stub_cache (frame_info_ptr this_frame)
{
struct tic6x_unwind_cache *cache;
}
static void
-tic6x_stub_this_id (struct frame_info *this_frame, void **this_cache,
+tic6x_stub_this_id (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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *frame, CORE_ADDR *pc)
+tic6x_get_longjmp_target (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) (struct frame_info *frame) = nullptr;
+ CORE_ADDR (*syscall_next_pc) (frame_info_ptr frame) = nullptr;
const gdb_byte *breakpoint = nullptr; /* Breakpoint instruction. */
static void
tilegx_linux_sigframe_init (const struct tramp_frame *self,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *next_frame)
+ 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 (struct frame_info *frame, CORE_ADDR *pc)
+tilegx_get_longjmp_target (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 (struct frame_info *this_frame, void **this_cache)
+tilegx_frame_cache (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 (struct frame_info *this_frame,
+tilegx_frame_prev_register (frame_info_ptr this_frame,
void **this_cache,
int regnum)
{
/* Build frame id. */
static void
-tilegx_frame_this_id (struct frame_info *this_frame, void **this_cache,
+tilegx_frame_this_id (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 (struct frame_info *this_frame, void **this_cache)
+tilegx_frame_base_address (frame_info_ptr this_frame, void **this_cache)
{
struct tilegx_frame_cache *cache =
tilegx_frame_cache (this_frame, this_cache);
check_frame_language_change (void)
{
static int warned = 0;
- struct frame_info *frame;
+ frame_info_ptr frame;
/* First make sure that a new frame has been selected, in case the
command or the hooks changed the program state. */
the traceframe context (line, function, file). */
static void
-set_traceframe_context (struct frame_info *trace_frame)
+set_traceframe_context (frame_info_ptr trace_frame)
{
CORE_ADDR trace_pc;
struct symbol *traceframe_fun;
struct trad_frame_cache
{
- struct frame_info *this_frame;
+ frame_info_ptr this_frame;
CORE_ADDR this_base;
trad_frame_saved_reg *prev_regs;
struct frame_id this_id;
};
struct trad_frame_cache *
-trad_frame_cache_zalloc (struct frame_info *this_frame)
+trad_frame_cache_zalloc (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 (struct frame_info *this_frame)
+trad_frame_alloc_saved_regs (frame_info_ptr this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct value *
-trad_frame_get_prev_register (struct frame_info *this_frame,
+trad_frame_get_prev_register (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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
int regnum)
{
return trad_frame_get_prev_register (this_frame, this_trad_cache->prev_regs,
#include "frame.h" /* For "struct frame_id". */
-struct frame_info;
+class frame_info_ptr;
struct regcache_map_entry;
struct trad_frame_cache;
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 (struct frame_info *);
+struct trad_frame_cache *trad_frame_cache_zalloc (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,
- struct frame_info *this_frame,
+ 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 (struct frame_info *);
+trad_frame_saved_reg *trad_frame_alloc_saved_regs (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 (struct frame_info *this_frame,
+struct value *trad_frame_get_prev_register (frame_info_ptr this_frame,
trad_frame_saved_reg this_saved_regs[],
int regnum);
};
static struct trad_frame_cache *
-tramp_frame_cache (struct frame_info *this_frame,
+tramp_frame_cache (frame_info_ptr this_frame,
void **this_cache)
{
struct tramp_frame_cache *tramp_cache
}
static void
-tramp_frame_this_id (struct frame_info *this_frame,
+tramp_frame_this_id (frame_info_ptr this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-tramp_frame_prev_register (struct frame_info *this_frame,
+tramp_frame_prev_register (frame_info_ptr this_frame,
void **this_cache,
int prev_regnum)
{
static CORE_ADDR
tramp_frame_start (const struct tramp_frame *tramp,
- struct frame_info *this_frame, CORE_ADDR pc)
+ 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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
void **this_cache)
{
const struct tramp_frame *tramp = self->unwind_data->tramp_frame;
#include "frame.h" /* For "enum frame_type". */
struct trad_frame;
-struct frame_info;
+class frame_info_ptr;
struct trad_frame_cache;
/* A trampoline consists of a small sequence of instructions placed at
/* 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,
- struct frame_info *this_frame,
+ 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,
- struct frame_info *this_frame,
+ frame_info_ptr this_frame,
CORE_ADDR *pc);
};
}
void
-tui_disasm_window::maybe_update (struct frame_info *fi, symtab_and_line sal)
+tui_disasm_window::maybe_update (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 (struct frame_info *fi, symtab_and_line sal) override;
+ void maybe_update (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 (struct frame_info *frame, int regno)
+tui_register_changed (frame_info_ptr frame, int regno)
{
- struct frame_info *fi;
+ frame_info_ptr fi;
if (!tui_is_window_visible (DATA_WIN))
return;
if (from_stack && has_stack_frames ())
{
- struct frame_info *fi = get_selected_frame (NULL);
+ frame_info_ptr fi = get_selected_frame (NULL);
/* Display the frame position (even if there is no symbols or
the PC is not known). */
representation of it. */
static std::string
-tui_register_format (struct frame_info *frame, int regnum)
+tui_register_format (frame_info_ptr frame, int regnum)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
display. When changep is set, check if the new register value has
changed with respect to the previous call. */
static void
-tui_get_register (struct frame_info *frame,
+tui_get_register (frame_info_ptr frame,
struct tui_data_item_window *data,
int regnum, bool *changedp)
{
void
tui_data_window::show_register_group (const reggroup *group,
- struct frame_info *frame,
+ frame_info_ptr frame,
bool refresh_values_only)
{
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 (struct frame_info *frame)
+tui_data_window::check_register_values (frame_info_ptr frame)
{
if (m_regs_content.empty ())
show_registers (m_current_group);
return DATA_NAME;
}
- void check_register_values (struct frame_info *frame);
+ void check_register_values (frame_info_ptr frame);
void show_registers (const reggroup *group);
void display_reg_element_at_line (int start_element_no, int start_line_no);
void show_register_group (const reggroup *group,
- struct frame_info *frame,
+ frame_info_ptr frame,
bool refresh_values_only);
/* Answer the number of the last line in the regs display. If there
if (cursal.symtab == NULL)
{
- struct frame_info *fi = get_selected_frame (NULL);
+ frame_info_ptr fi = get_selected_frame (NULL);
s = find_pc_line_symtab (get_frame_pc (fi));
arch = get_frame_arch (fi);
}
}
void
-tui_source_window::maybe_update (struct frame_info *fi, symtab_and_line sal)
+tui_source_window::maybe_update (frame_info_ptr fi, symtab_and_line sal)
{
int start_line = (sal.line - ((height - 2) / 2)) + 1;
if (start_line <= 0)
bool showing_source_p (const char *filename) const;
- void maybe_update (struct frame_info *fi, symtab_and_line sal) override;
+ void maybe_update (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 (struct frame_info *fi)
+tui_get_function_from_frame (frame_info_ptr fi)
{
static char name[256];
string_file stream;
subsequently refreshed), false otherwise. */
bool
-tui_show_frame_info (struct frame_info *fi)
+tui_show_frame_info (frame_info_ptr fi)
{
bool locator_changed_p;
#include "tui/tui-data.h"
-struct frame_info;
+class frame_info_ptr;
/* Locator window class. */
};
extern void tui_show_locator_content (void);
-extern bool tui_show_frame_info (struct frame_info *);
+extern bool tui_show_frame_info (frame_info_ptr );
#endif /* TUI_TUI_STACK_H */
{
struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
- struct frame_info *frame = deprecated_safe_get_selected_frame ();
+ frame_info_ptr frame = deprecated_safe_get_selected_frame ();
struct gdbarch *gdbarch = get_frame_arch (frame);
struct symtab *s = find_pc_line_symtab (get_frame_pc (frame));
sal = get_current_source_symtab_and_line ();
if (sal.symtab == NULL)
{
- struct frame_info *fi = deprecated_safe_get_selected_frame ();
+ frame_info_ptr fi = deprecated_safe_get_selected_frame ();
if (fi != nullptr)
sal = find_pc_line (get_frame_pc (fi), 0);
}
/* Update the window to display the given location. Does nothing if
the location is already displayed. */
- virtual void maybe_update (struct frame_info *fi, symtab_and_line sal) = 0;
+ virtual void maybe_update (frame_info_ptr fi, symtab_and_line sal) = 0;
void update_source_window_as_is (struct gdbarch *gdbarch,
const struct symtab_and_line &sal);
/* 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) (struct frame_info * frame, const void *baton);
+ struct value *(*xread) (frame_info_ptr frame, const void *baton);
const void *baton;
struct user_reg *next;
};
}
struct value *
-value_of_user_reg (int regnum, struct frame_info *frame)
+value_of_user_reg (int regnum, frame_info_ptr frame)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
int maxregs = gdbarch_num_cooked_regs (gdbarch);
of assumed to be read-only. Should it, for instance, return a
register descriptor that contains all the relevant access methods. */
-struct frame_info;
+class frame_info_ptr;
struct gdbarch;
/* Given an architecture, map a user visible register name onto its
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) (struct frame_info *frame,
+typedef struct value *(user_reg_read_ftype) (frame_info_ptr frame,
const void *baton);
-extern struct value *value_of_user_reg (int regnum, struct frame_info *frame);
+extern struct value *value_of_user_reg (int regnum, 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 (struct frame_info *this_frame)
+v850_alloc_frame_cache (frame_info_ptr this_frame)
{
struct v850_frame_cache *cache;
}
static struct v850_frame_cache *
-v850_frame_cache (struct frame_info *this_frame, void **this_cache)
+v850_frame_cache (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 (struct frame_info *this_frame,
+v850_frame_prev_register (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 (struct frame_info *this_frame, void **this_cache,
+v850_frame_this_id (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 (struct frame_info *this_frame, void **this_cache)
+v850_frame_base_address (frame_info_ptr this_frame, void **this_cache)
{
struct v850_frame_cache *cache = v850_frame_cache (this_frame, this_cache);
case lval_register:
{
- struct frame_info *frame;
+ frame_info_ptr frame;
struct gdbarch *gdbarch;
int value_reg;
re-find the previously selected frame automatically. */
{
- struct frame_info *fi = frame_find_by_id (old_frame);
+ frame_info_ptr fi = frame_find_by_id (old_frame);
if (fi != NULL)
select_frame (fi);
struct value *
value_of_variable (struct symbol *var, const struct block *b)
{
- struct frame_info *frame = NULL;
+ frame_info_ptr frame = NULL;
if (symbol_read_needs_frame (var))
frame = get_selected_frame (_("No frame selected."));
{
case lval_register:
{
- struct frame_info *frame;
+ frame_info_ptr frame;
const char *regname;
frame = frame_find_by_id (VALUE_NEXT_FRAME_ID (val));
{
struct block_symbol sym;
const struct block *b;
- struct frame_info *frame;
+ frame_info_ptr frame;
if (lang->name_of_this () == NULL)
error (_("no `this' in current language"));
static void
value_fetch_lazy_register (struct value *val)
{
- struct frame_info *next_frame;
+ frame_info_ptr next_frame;
int regnum;
struct type *type = check_typedef (value_type (val));
struct value *new_val = val, *mark = value_mark ();
if (frame_debug)
{
struct gdbarch *gdbarch;
- struct frame_info *frame;
+ frame_info_ptr frame;
frame = frame_find_by_id (VALUE_NEXT_FRAME_ID (val));
frame = get_prev_frame_always (frame);
regnum = VALUE_REGNUM (val);
#include "gdbtypes.h"
#include "expression.h"
-struct frame_info;
+class frame_info_ptr;
struct fn_field;
extern int print_address_demangle (const struct value_print_options *,
struct frame_id frame_id);
extern void read_frame_register_value (struct value *value,
- struct frame_info *frame);
+ frame_info_ptr frame);
extern struct value *value_from_register (struct type *type, int regnum,
- struct frame_info *frame);
+ frame_info_ptr frame);
extern CORE_ADDR address_from_register (int regnum,
- struct frame_info *frame);
+ frame_info_ptr frame);
extern struct value *value_of_variable (struct symbol *var,
const struct block *b);
extern struct value *address_of_variable (struct symbol *var,
const struct block *b);
-extern struct value *value_of_register (int regnum, struct frame_info *frame);
+extern struct value *value_of_register (int regnum, frame_info_ptr frame);
-struct value *value_of_register_lazy (struct frame_info *frame, int regnum);
+struct value *value_of_register_lazy (frame_info_ptr frame, int regnum);
/* Return the symbol's reading requirement. */
extern struct value *read_var_value (struct symbol *var,
const struct block *var_block,
- struct frame_info *frame);
+ frame_info_ptr frame);
extern struct value *allocate_value (struct type *type);
extern struct value *allocate_value_lazy (struct type *type);
extern void print_variable_and_value (const char *name,
struct symbol *var,
- struct frame_info *frame,
+ frame_info_ptr frame,
struct ui_file *stream,
int indent);
/* Return the full FRAME which corresponds to the given CORE_ADDR
or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
-static struct frame_info *
+static frame_info_ptr
find_frame_addr_in_frame_chain (CORE_ADDR frame_addr)
{
- struct frame_info *frame = NULL;
+ frame_info_ptr frame = NULL;
if (frame_addr == (CORE_ADDR) 0)
return NULL;
if (expression != NULL)
{
- struct frame_info *fi;
+ frame_info_ptr fi;
struct frame_id old_id = null_frame_id;
const struct block *block;
const char *p;
static bool
check_scope (const struct varobj *var)
{
- struct frame_info *fi;
+ frame_info_ptr fi;
bool scope;
fi = frame_find_by_id (var->root->frame);
}
static struct frame_id
-vax_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
+vax_dummy_id (struct gdbarch *gdbarch, frame_info_ptr this_frame)
{
CORE_ADDR fp;
};
static struct vax_frame_cache *
-vax_frame_cache (struct frame_info *this_frame, void **this_cache)
+vax_frame_cache (frame_info_ptr this_frame, void **this_cache)
{
struct vax_frame_cache *cache;
CORE_ADDR addr;
}
static void
-vax_frame_this_id (struct frame_info *this_frame, void **this_cache,
+vax_frame_this_id (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 (struct frame_info *this_frame,
+vax_frame_prev_register (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 (struct frame_info *this_frame, void **this_cache)
+vax_frame_base_address (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 (struct frame_info *this_frame, void **this_cache)
+vax_frame_args_address (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 (struct frame_info *frame)
+vax_frame_num_args (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,
- struct frame_info *this_frame)
+ 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 (struct frame_info *frame, CORE_ADDR pc)
+xstormy16_skip_trampoline_code (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 (struct frame_info *this_frame, void **this_cache)
+xstormy16_frame_cache (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 (struct frame_info *this_frame,
+xstormy16_frame_prev_register (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 (struct frame_info *this_frame, void **this_cache,
+xstormy16_frame_this_id (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 (struct frame_info *this_frame, void **this_cache)
+xstormy16_frame_base_address (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, struct frame_info *next_frame)
+xtensa_unwind_pc (struct gdbarch *gdbarch, frame_info_ptr next_frame)
{
gdb_byte buf[8];
CORE_ADDR pc;
DEBUGTRACE ("xtensa_unwind_pc (next_frame = %s)\n",
- host_address_to_string (next_frame));
+ host_address_to_string (next_frame.get ()));
frame_unwind_register (next_frame, gdbarch_pc_regnum (gdbarch), buf);
pc = extract_typed_address (buf, builtin_type (gdbarch)->builtin_func_ptr);
static struct frame_id
-xtensa_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
+xtensa_dummy_id (struct gdbarch *gdbarch, 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 (struct frame_info *this_frame,
+call0_frame_cache (frame_info_ptr this_frame,
xtensa_frame_cache_t *cache, CORE_ADDR pc);
static void
-xtensa_window_interrupt_frame_cache (struct frame_info *this_frame,
+xtensa_window_interrupt_frame_cache (frame_info_ptr this_frame,
xtensa_frame_cache_t *cache,
CORE_ADDR pc);
static struct xtensa_frame_cache *
-xtensa_frame_cache (struct frame_info *this_frame, void **this_cache)
+xtensa_frame_cache (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 (struct frame_info *this_frame,
+xtensa_frame_this_id (frame_info_ptr this_frame,
void **this_cache,
struct frame_id *this_id)
{
}
static struct value *
-xtensa_frame_prev_register (struct frame_info *this_frame,
+xtensa_frame_prev_register (frame_info_ptr this_frame,
void **this_cache,
int regnum)
{
};
static CORE_ADDR
-xtensa_frame_base_address (struct frame_info *this_frame, void **this_cache)
+xtensa_frame_base_address (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 (struct frame_info *this_frame,
+call0_frame_cache (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 (struct frame_info *this_frame,
+xtensa_window_interrupt_frame_cache (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 (struct frame_info *this_frame,
+z80_frame_unwind_cache (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 (struct frame_info *this_frame, void **this_cache,
+z80_frame_this_id (frame_info_ptr this_frame, void **this_cache,
struct frame_id *this_id)
{
struct frame_id id;
}
static struct value *
-z80_frame_prev_register (struct frame_info *this_frame,
+z80_frame_prev_register (frame_info_ptr this_frame,
void **this_prologue_cache, int regnum)
{
struct z80_unwind_cache *info
projects / binutils-gdb.git / commitdiff