28#include "gdbsupport/gdb_obstack.h"
206 gdb_assert (frame->
next !=
nullptr);
279 gdb_assert (frame->
level >= 0);
288 if (*slot !=
nullptr)
305 dummy.this_id.value = id;
352 _(
"Whether backtraces should "
353 "continue past \"main\" is %s.\n"),
363 gdb_printf (file, _(
"Whether backtraces should continue past the "
364 "entry point of a program is %s.\n"),
375 _(
"An upper bound on the number "
376 "of backtrace levels is %s.\n"),
387 std::string res =
"{";
392 res +=
"stack=<unavailable>";
394 res +=
"stack=<sentinel>";
396 res +=
"stack=<outer>";
398 res += std::string (
"stack=") + hex_string (
id.
stack_addr);
401 auto field_to_string = [] (
const char *n,
bool p, CORE_ADDR a) -> std::string
404 return std::string (n) +
"=" + core_addr_to_string (a);
406 return std::string (
"!") + std::string (n);
409 res += (std::string (
",")
428 return "NORMAL_FRAME";
431 return "DUMMY_FRAME";
434 return "INLINE_FRAME";
437 return "TAILCALL_FRAME";
440 return "SIGTRAMP_FRAME";
446 return "SENTINEL_FRAME";
449 return "<unknown type>";
462 res += string_printf (
"{level=%d,", fi->
level);
467 res +=
"type=<unknown>,";
470 res += string_printf (
"unwinder=\"%s\",", fi->
unwind->
name);
472 res +=
"unwinder=<unknown>,";
475 res +=
"pc=<unknown>,";
480 res +=
"pc=<not saved>,";
482 res +=
"pc=<unavailable>,";
485 res +=
"id=<not computed>,";
487 res +=
"id=<computing>,";
489 res += string_printf (
"id=%s,", fi->
this_id.
value.to_string ().c_str ());
494 res +=
"func=<unknown>";
591 catch (
const gdb_exception &ex)
623 gdb_assert (fi->level == 0);
631 gdb_assert (stashed);
634 return fi->this_id.value;
654 if (next_frame == NULL)
677 id.code_addr_p =
true;
679 id.special_addr_p =
true;
692 id.code_addr_p =
true;
706 id.code_addr_p =
true;
708 id.special_addr_p =
true;
720 id.code_addr_p =
true;
837 const struct block *lb, *rb;
844 if (lb == NULL || rb == NULL)
951 catch (
const gdb_exception_error &ex)
953 if (ex.error == NOT_AVAILABLE_ERROR)
960 else if (ex.error == OPTIMIZED_OUT_ERROR)
985 throw_error (NOT_AVAILABLE_ERROR, _(
"PC not available"));
987 throw_error (OPTIMIZED_OUT_ERROR, _(
"PC not saved"));
989 internal_error (
"unexpected prev_pc status: %d",
1001 gdb_assert (this_frame != NULL);
1013 CORE_ADDR addr_in_block;
1055 throw_error (NOT_AVAILABLE_ERROR, _(
"PC not available"));
1060std::unique_ptr<readonly_detached_regcache>
1063 auto cooked_read = [this_frame] (
int regnum, gdb_byte *buf)
1066 return REG_UNAVAILABLE;
1071 std::unique_ptr<readonly_detached_regcache>
regcache
1094 error (_(
"Cannot pop the initial frame."));
1100 if (prev_frame == NULL)
1101 error (_(
"Cannot find the caller frame."));
1107 std::unique_ptr<readonly_detached_regcache> scratch
1128 int *optimizedp,
int *unavailablep,
1129 enum lval_type *lvalp, CORE_ADDR *addrp,
1130 int *realnump, gdb_byte *bufferp)
1136 gdb_assert (optimizedp != NULL);
1137 gdb_assert (lvalp != NULL);
1138 gdb_assert (addrp != NULL);
1139 gdb_assert (realnump != NULL);
1144 gdb_assert (
value != NULL);
1157 if (!*optimizedp && !*unavailablep)
1176 int *optimizedp,
int *unavailablep,
enum lval_type *lvalp,
1177 CORE_ADDR *addrp,
int *realnump, gdb_byte *bufferp)
1181 gdb_assert (optimizedp != NULL);
1182 gdb_assert (lvalp != NULL);
1183 gdb_assert (addrp != NULL);
1184 gdb_assert (realnump != NULL);
1189 gdb_assert (frame != NULL && frame->
next != NULL);
1191 unavailablep, lvalp, addrp, realnump, bufferp);
1204 &
lval, &addr, &realnum, buf);
1207 throw_error (OPTIMIZED_OUT_ERROR,
1208 _(
"Register %d was not saved"),
regnum);
1210 throw_error (NOT_AVAILABLE_ERROR,
1211 _(
"Register %d is not available"),
regnum);
1216 int regnum, gdb_byte *buf)
1226 gdb_assert (next_frame != NULL);
1233 if (next_frame->
unwind == NULL)
1297 gdb_assert (
value != NULL);
1301 throw_error (OPTIMIZED_OUT_ERROR,
1302 _(
"Register %d was not saved"),
regnum);
1306 throw_error (NOT_AVAILABLE_ERROR,
1307 _(
"Register %d is not available"),
regnum);
1330 gdb_assert (
value != NULL);
1334 throw_error (OPTIMIZED_OUT_ERROR,
1335 _(
"Register %d was not saved"),
regnum);
1339 throw_error (NOT_AVAILABLE_ERROR,
1340 _(
"Register %d is not available"),
regnum);
1379 const gdb_byte *buf)
1389 &lval, &addr, &realnum, NULL);
1391 error (_(
"Attempt to assign to a register that was not saved."));
1403 error (_(
"Attempt to assign to an unmodifiable value."));
1426 &lval, &addr, &realnum, myaddr);
1428 return !optimized && !unavailable;
1434 gdb::array_view<gdb_byte> buffer,
1435 int *optimizedp,
int *unavailablep)
1453 for (i =
regnum; i < numregs; i++)
1459 maxsize += thissize;
1462 int len = buffer.size ();
1464 error (_(
"Bad debug information detected: "
1465 "Attempt to read %d bytes from registers."), len);
1475 gdb_byte *myaddr = buffer.data ();
1484 &lval, &addr, &realnum, myaddr);
1485 if (*optimizedp || *unavailablep)
1493 gdb_assert (
value != NULL);
1497 if (*optimizedp || *unavailablep)
1523 gdb::array_view<const gdb_byte> buffer)
1534 int len = buffer.size ();
1543 const gdb_byte *myaddr = buffer.data ();
1553 gdb_assert (
value != NULL);
1587 frame->
next = frame;
1608 memset (data, 0,
size);
1625 error (_(
"No registers."));
1627 error (_(
"No stack."));
1629 error (_(
"No memory."));
1650 gdb_assert (current_frame != NULL);
1652 return current_frame;
1700 gdb_assert (frame_level != 0);
1728 if (frame_level == -1)
1736 gdb_assert (frame_level > 0);
1742 count = frame_level;
1773 warning (_(
"Couldn't restore frame #%d in "
1774 "current thread. Bottom (innermost) frame selected:"),
1818 error ((
"%s"), message);
1854 gdb_assert (fi !=
nullptr);
1970 if (this_frame->
level > 0)
1983 gdb_assert (this_frame != NULL);
2013 if (fi->prologue_cache && fi->unwind->dealloc_cache)
2014 fi->unwind->dealloc_cache (fi, fi->prologue_cache);
2015 if (fi->base_cache && fi->base->unwind->dealloc_cache)
2016 fi->base->unwind->dealloc_cache (fi, fi->base_cache);
2043 CORE_ADDR *addrp,
int *realnump)
2045 gdb_assert (this_frame == NULL || this_frame->
level >= 0);
2047 while (this_frame != NULL)
2052 lvalp, addrp, realnump, NULL);
2098 if (prev_frame->
level == 0)
2129 gdb_assert (cycle_detection_p
2130 || (this_frame->
level > 0
2133 || (this_frame->
level == 0
2149 prev_frame->
next = NULL;
2150 this_frame->
prev = NULL;
2154 catch (
const gdb_exception &ex)
2158 prev_frame->
next = NULL;
2159 this_frame->
prev = NULL;
2177 gdb_assert (this_frame != NULL);
2181 if (this_frame != NULL)
2192 if (this_frame->
prev !=
nullptr)
2197 (
" -> nullptr // %s // cached",
2206 if (this_frame->
unwind == NULL)
2209 this_frame->
prev_p =
true;
2234 if (this_frame->
level == 0)
2246 (
" -> nullptr // %s",
2261 CORE_ADDR this_pc_in_block;
2263 const char *morestack_name = NULL;
2270 if (!morestack_name || strcmp (morestack_name,
"__morestack") != 0)
2292 if (this_frame->
level > 0
2298 int optimized, realnum, nrealnum;
2300 CORE_ADDR addr, naddr;
2304 &optimized, &lval, &addr, &realnum);
2307 &optimized, &nlval, &naddr, &nrealnum);
2309 if ((lval ==
lval_memory && lval == nlval && addr == naddr)
2310 || (lval ==
lval_register && lval == nlval && realnum == nrealnum))
2314 this_frame->
prev = NULL;
2337 catch (
const gdb_exception_error &ex)
2339 if (ex.error == MEMORY_ERROR)
2342 if (ex.message != NULL)
2351 size = ex.message->size () + 1;
2353 memcpy (stop_string, ex.what (),
size);
2411 this_frame->
prev = prev_frame;
2412 prev_frame->
next = this_frame.
get ();
2427 if (this_frame != NULL)
2447 if (msymbol.
minsym ==
nullptr)
2453 if (bs.
symbol ==
nullptr)
2457 gdb_assert (
block !=
nullptr);
2476 CORE_ADDR entry_point;
2504 gdb_assert (this_frame != NULL);
2518 if (this_frame->
level >= 0
2565 if (this_frame->
level >= 0
2578 if (this_frame->
level > 0
2582 && frame_pc_p && frame_pc == 0)
2594 gdb_assert (frame->
next != NULL);
2602 gdb_assert (frame->
next != NULL);
2608 catch (
const gdb_exception_error &ex)
2610 if (ex.error == NOT_AVAILABLE_ERROR)
2690 catch (
const gdb_exception_error &ex)
2692 if (ex.error == NOT_AVAILABLE_ERROR)
2725 if (sym->
line () != 0)
2771 if (fi->
base == NULL)
2786 if (fi->
base == NULL)
2801 if (fi->
base == NULL)
2816 if (fi->
unwind ==
nullptr)
2819 return fi->
unwind == unwinder;
2837 if (frame->
unwind == NULL)
2853 gdb_assert (this_frame);
2858 return this_frame->
pspace;
2871 gdb::array_view<gdb_byte> buffer)
2873 read_memory (addr, buffer.data (), buffer.size ());
2898 CORE_ADDR addr, gdb::array_view<gdb_byte> buffer)
2919 if (next_frame->
unwind == NULL)
2946 gdb_assert (next_frame != NULL);
2959 gdb_assert (frame!= NULL);
2975 catch (
const gdb_exception_error &ex)
2977 if (ex.error != NOT_AVAILABLE_ERROR)
3011 gdb_assert (frame->
prev_p);
3023#define SET(name, description) \
3024 case name: return _(description);
3025#include "unwind_stop_reasons.def"
3029 internal_error (
"Invalid frame stop reason");
3037 gdb_assert (fi->
prev == NULL);
3055#define SET(name, description) \
3056 case name: return #name;
3057#include "unwind_stop_reasons.def"
3061 internal_error (
"Invalid frame stop reason");
3077 gdb_assert (!frame->
prev_p);
3102 gdb_assert (frame->
unwind == NULL);
3121 N_(
"Set whether backtraces should continue past \"main\"."),
3122 N_(
"Show whether backtraces should continue past \"main\"."),
3123 N_(
"Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
3124the backtrace at \"main\". Set this if you need to see the rest\n\
3125of the stack trace."),
3132 N_(
"Set whether backtraces should continue past the entry point of a program."),
3133 N_(
"Show whether backtraces should continue past the entry point of a program."),
3134 N_(
"Normally there are no callers beyond the entry point of a program, so GDB\n\
3135will terminate the backtrace there. Set this if you need to see\n\
3136the rest of the stack trace."),
3149 if (args ==
nullptr)
3158 gdb_assert (frame !=
nullptr);
3177Set backtrace specific variables.\n\
3178Configure backtrace variables such as the backtrace limit"),
3180Show backtrace specific variables.\n\
3181Show backtrace variables such as the backtrace limit."),
3187Set an upper bound on the number of backtrace levels."), _(
"\
3188Show the upper bound on the number of backtrace levels."), _(
"\
3189No more than the specified number of frames can be displayed or examined.\n\
3190Literal \"unlimited\" or zero means no limit."),
3202Set frame debugging."), _(
"\
3203Show frame debugging."), _(
"\
3204When non-zero, frame specific internal debugging is enabled."),
3210 _(
"Print the current frame-id."),
void annotate_frames_invalid(void)
bool contained_in(const struct block *a, const struct block *b, bool allow_nested)
const struct block * block_for_pc(CORE_ADDR pc)
struct symbol * get_frame_function(frame_info_ptr frame)
CORE_ADDR get_pc_function_start(CORE_ADDR pc)
static intrusive_list< frame_info_ptr > frame_list
void cooked_write(int regnum, const gdb_byte *buf)
const address_space * aspace() const
void restore(readonly_detached_regcache *src)
scoped_restore_selected_frame()
~scoped_restore_selected_frame()
const char * c_str() const
struct cmd_list_element * showlist
struct cmd_list_element * maintenanceprintlist
struct cmd_list_element * setlist
struct cmd_list_element * showdebuglist
struct cmd_list_element * setdebuglist
set_show_commands add_setshow_uinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
set_show_commands add_setshow_prefix_cmd(const char *name, command_class theclass, const char *set_doc, const char *show_doc, cmd_list_element **set_subcommands_list, cmd_list_element **show_subcommands_list, cmd_list_element **set_list, cmd_list_element **show_list)
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
LONGEST read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
static LONGEST extract_signed_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
void dummy_frame_pop(frame_id dummy_id, thread_info *thread)
struct value * parse_and_eval(const char *exp)
const struct frame_base * frame_base_find_by_frame(frame_info_ptr this_frame)
const struct frame_id null_frame_id
void frame_unwind_find_by_frame(frame_info_ptr this_frame, void **this_cache)
const struct frame_id null_frame_id
frame_info_ptr get_next_frame(frame_info_ptr this_frame)
enum unwind_stop_reason get_frame_unwind_stop_reason(frame_info_ptr frame)
static frame_info_ptr skip_artificial_frames(frame_info_ptr frame)
struct program_space * get_frame_program_space(frame_info_ptr frame)
int frame_relative_level(frame_info_ptr fi)
struct value * get_frame_register_value(frame_info_ptr frame, int regnum)
static frame_info_ptr get_prev_frame_raw(frame_info_ptr this_frame)
const char * frame_stop_reason_string(frame_info_ptr fi)
ULONGEST get_frame_register_unsigned(frame_info_ptr frame, int regnum)
void frame_cleanup_after_sniffer(frame_info_ptr frame)
ULONGEST frame_unwind_register_unsigned(frame_info_ptr next_frame, int regnum)
static void maintenance_print_frame_id(const char *args, int from_tty)
void restore_selected_frame(frame_id frame_id, int frame_level) noexcept
frame_info_ptr skip_unwritable_frames(frame_info_ptr frame)
static struct cmd_list_element * set_backtrace_cmdlist
frame_info_ptr deprecated_safe_get_selected_frame(void)
LONGEST get_frame_register_signed(frame_info_ptr frame, int regnum)
LONGEST get_frame_memory_signed(frame_info_ptr this_frame, CORE_ADDR addr, int len)
void select_frame(frame_info_ptr fi)
CORE_ADDR frame_unwind_caller_pc(frame_info_ptr this_frame)
CORE_ADDR get_frame_pc(frame_info_ptr frame)
std::unique_ptr< readonly_detached_regcache > frame_save_as_regcache(frame_info_ptr this_frame)
static const char * frame_type_str(frame_type type)
const struct frame_id sentinel_frame_id
void get_frame_memory(frame_info_ptr this_frame, CORE_ADDR addr, gdb::array_view< gdb_byte > buffer)
bool read_frame_register_unsigned(frame_info_ptr frame, int regnum, ULONGEST *val)
CORE_ADDR get_frame_sp(frame_info_ptr this_frame)
void reinit_frame_cache(void)
static void compute_frame_id(frame_info_ptr fi)
void frame_pop(frame_info_ptr this_frame)
struct frame_id get_stack_frame_id(frame_info_ptr next_frame)
static bool inside_main_func(frame_info_ptr this_frame)
CORE_ADDR get_frame_base_address(frame_info_ptr fi)
static void invalidate_selected_frame()
frame_info_ptr get_prev_frame_always(frame_info_ptr this_frame)
set_backtrace_options user_set_backtrace_options
const address_space * get_frame_address_space(frame_info_ptr frame)
static struct obstack frame_cache_obstack
static frame_info_ptr selected_frame
LONGEST frame_unwind_register_signed(frame_info_ptr next_frame, int regnum)
static const char * frame_stop_reason_symbol_string(enum unwind_stop_reason reason)
bool frame_id_p(frame_id l)
static frame_info_ptr get_prev_frame_always_1(frame_info_ptr this_frame)
struct frame_id frame_id_build_special(CORE_ADDR stack_addr, CORE_ADDR code_addr, CORE_ADDR special_addr)
void get_frame_register(frame_info_ptr frame, int regnum, gdb_byte *buf)
bool get_frame_func_if_available(frame_info_ptr this_frame, CORE_ADDR *pc)
bool frame_id_artificial_p(frame_id l)
const char * unwind_stop_reason_to_string(enum unwind_stop_reason reason)
static void frame_observer_target_changed(struct target_ops *target)
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
struct frame_id frame_id_build_wild(CORE_ADDR stack_addr)
static bool frame_id_inner(struct gdbarch *gdbarch, struct frame_id l, struct frame_id r)
void save_selected_frame(frame_id *frame_id, int *frame_level) noexcept
static unsigned int frame_cache_generation
struct frame_id frame_id_build_unavailable_stack_special(CORE_ADDR code_addr, CORE_ADDR special_addr)
static void frame_stash_invalidate(void)
struct gdbarch * frame_unwind_arch(frame_info_ptr next_frame)
const gdb::option::option_def set_backtrace_option_defs[]
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
static bool frame_stash_add(frame_info *frame)
static void frame_stash_create(void)
struct value * frame_unwind_register_value(frame_info_ptr next_frame, int regnum)
enum frame_type get_frame_type(frame_info_ptr frame)
static void show_frame_debug(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
struct frame_id frame_unwind_caller_id(frame_info_ptr next_frame)
bool get_frame_pc_masked(frame_info_ptr frame)
void frame_prepare_for_sniffer(frame_info_ptr frame, const struct frame_unwind *unwind)
struct program_space * frame_unwind_program_space(frame_info_ptr this_frame)
bool frame_unwinder_is(frame_info_ptr fi, const frame_unwind *unwinder)
bool get_frame_pc_if_available(frame_info_ptr frame, CORE_ADDR *pc)
CORE_ADDR get_frame_args_address(frame_info_ptr fi)
bool get_frame_address_in_block_if_available(frame_info_ptr this_frame, CORE_ADDR *pc)
static frame_info_ptr frame_stash_find(struct frame_id id)
CORE_ADDR get_frame_locals_address(frame_info_ptr fi)
void frame_unwind_register(frame_info_ptr next_frame, int regnum, gdb_byte *buf)
static void frame_register(frame_info_ptr frame, int regnum, int *optimizedp, int *unavailablep, enum lval_type *lvalp, CORE_ADDR *addrp, int *realnump, gdb_byte *bufferp)
ULONGEST get_frame_memory_unsigned(frame_info_ptr this_frame, CORE_ADDR addr, int len)
struct frame_id frame_id_build_unavailable_stack(CORE_ADDR code_addr)
void * frame_obstack_zalloc(unsigned long size)
const struct frame_id outer_frame_id
static bool inside_entry_func(frame_info_ptr this_frame)
CORE_ADDR get_frame_func(frame_info_ptr this_frame)
static frame_info * sentinel_frame
static hashval_t frame_addr_hash(const void *ap)
static void show_backtrace_past_entry(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
void put_frame_register_bytes(frame_info_ptr frame, int regnum, CORE_ADDR offset, gdb::array_view< const gdb_byte > buffer)
frame_info_ptr get_selected_frame(const char *message)
static CORE_ADDR frame_unwind_pc(frame_info_ptr this_frame)
frame_info_ptr frame_find_by_id(struct frame_id id)
bool get_frame_register_bytes(frame_info_ptr frame, int regnum, CORE_ADDR offset, gdb::array_view< gdb_byte > buffer, int *optimizedp, int *unavailablep)
static frame_id selected_frame_id
static void show_backtrace_past_main(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
static void frame_debug_got_null_frame(frame_info_ptr this_frame, const char *reason)
bool deprecated_frame_register_read(frame_info_ptr frame, int regnum, gdb_byte *myaddr)
static void show_backtrace_limit(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
static struct cmd_list_element * show_backtrace_cmdlist
void set_frame_previous_pc_masked(frame_info_ptr frame)
enum language get_frame_language(frame_info_ptr frame)
unsigned int get_frame_cache_generation()
void 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)
frame_info_ptr get_current_frame(void)
frame_info_ptr skip_tailcall_frames(frame_info_ptr frame)
static void frame_register_unwind_location(frame_info_ptr this_frame, int regnum, int *optimizedp, enum lval_type *lvalp, CORE_ADDR *addrp, int *realnump)
static int selected_frame_level
CORE_ADDR get_frame_address_in_block(frame_info_ptr this_frame)
frame_info_ptr create_new_frame(CORE_ADDR addr, CORE_ADDR pc)
static htab_t frame_stash
static frame_info_ptr get_prev_frame_maybe_check_cycle(frame_info_ptr this_frame)
static void lookup_selected_frame(struct frame_id a_frame_id, int frame_level)
struct frame_id get_frame_id(frame_info_ptr fi)
bool safe_frame_unwind_memory(frame_info_ptr this_frame, CORE_ADDR addr, gdb::array_view< gdb_byte > buffer)
frame_info_ptr get_prev_frame(frame_info_ptr this_frame)
void put_frame_register(frame_info_ptr frame, int regnum, const gdb_byte *buf)
symtab_and_line find_frame_sal(frame_info_ptr frame)
struct gdbarch * frame_unwind_caller_arch(frame_info_ptr next_frame)
frame_info_ptr get_next_frame_sentinel_okay(frame_info_ptr this_frame)
CORE_ADDR get_frame_base(frame_info_ptr fi)
static int frame_addr_hash_eq(const void *a, const void *b)
static frame_info * create_sentinel_frame(struct program_space *pspace, struct regcache *regcache)
void restore_selected_frame(frame_id frame_id, int frame_level) noexcept
void save_selected_frame(frame_id *frame_id, int *frame_level) noexcept
#define frame_debug_printf(fmt,...)
void print_stack_frame(frame_info_ptr, int print_level, enum print_what print_what, int set_current_sal)
#define FRAME_SCOPED_DEBUG_ENTER_EXIT
frame_info_ptr find_relative_frame(frame_info_ptr, int *)
#define FRAME_OBSTACK_ZALLOC(TYPE)
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
CORE_ADDR gdbarch_unwind_pc(struct gdbarch *gdbarch, frame_info_ptr next_frame)
CORE_ADDR gdbarch_unwind_sp(struct gdbarch *gdbarch, frame_info_ptr next_frame)
int gdbarch_code_of_frame_writable(struct gdbarch *gdbarch, frame_info_ptr frame)
int gdbarch_inner_than(struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
CORE_ADDR gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
static int gdbarch_num_cooked_regs(gdbarch *arch)
void validate_registers_access(void)
struct thread_info * inferior_thread(void)
struct inferior * current_inferior(void)
int frame_inlined_callees(frame_info_ptr this_frame)
struct symbol * inline_skipped_symbol(thread_info *thread)
const struct language_defn * current_language
enum language set_language(enum language lang)
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
observable< struct target_ops * > target_changed
void add_setshow_cmds_for_options(command_class cmd_class, void *data, gdb::array_view< const option_def > options, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
int entry_point_address_query(CORE_ADDR *entry_p)
struct program_space * current_program_space
int register_size(struct gdbarch *gdbarch, int regnum)
struct regcache * get_current_regcache(void)
const struct frame_unwind sentinel_frame_unwind
void * sentinel_frame_cache(struct regcache *regcache)
CORE_ADDR value_address() const
struct minimal_symbol * minsym
enum language language() const
frame_this_args_ftype * this_args
frame_this_base_ftype * this_base
frame_this_locals_ftype * this_locals
const struct frame_unwind * unwind
std::string to_string() const
unsigned int special_addr_p
bool operator==(const frame_id &r) const
__extension__ enum frame_id_stack_status stack_status
cached_copy_status status
struct program_space * pspace
struct frame_info::@57 prev_func
struct frame_info::@58 this_id
struct frame_info::@56 prev_pc
const struct frame_unwind * unwind
struct frame_info::@55 prev_arch
const struct frame_base * base
enum unwind_stop_reason stop_reason
std::string to_string() const
const address_space * aspace
frame_this_id_ftype * this_id
frame_prev_arch_ftype * prev_arch
frame_unwind_stop_reason_ftype * stop_reason
frame_prev_register_ftype * prev_register
const char * linkage_name() const
enum language la_language
struct objfile * symfile_object_file
bool backtrace_past_entry
unsigned int backtrace_limit
const block * value_block() const
unsigned short line() const
struct program_space * pspace
std::vector< range > unavailable
struct compunit_symtab * find_pc_compunit_symtab(CORE_ADDR pc)
struct block_symbol lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
int target_has_registers()
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
int get_traceframe_number(void)
const char * user_reg_map_regnum_to_name(struct gdbarch *gdbarch, int regnum)
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
void gdb_printf(struct ui_file *stream, const char *format,...)
void val_print_not_saved(struct ui_file *stream)
struct type * value_type(const struct value *value)
int value_entirely_available(struct value *value)
gdb::array_view< const gdb_byte > value_contents_all(struct value *value)
int value_lazy(const struct value *value)
CORE_ADDR value_address(const struct value *value)
gdb::array_view< gdb_byte > value_contents_raw(struct value *value)
gdb::array_view< const gdb_byte > value_contents(struct value *value)
gdb::array_view< gdb_byte > value_contents_writeable(struct value *value)
LONGEST value_as_long(struct value *val)
int value_optimized_out(struct value *value)
value_ref_ptr release_value(struct value *val)
#define VALUE_REGNUM(val)