27#include "gdbsupport/gdb_obstack.h"
210 gdb_assert (frame->
next !=
nullptr);
303 gdb_assert (frame->
level >= -1);
312 if (*slot !=
nullptr)
376 _(
"Whether backtraces should "
377 "continue past \"main\" is %s.\n"),
387 gdb_printf (file, _(
"Whether backtraces should continue past the "
388 "entry point of a program is %s.\n"),
399 _(
"An upper bound on the number "
400 "of backtrace levels is %s.\n"),
411 std::string res =
"{";
416 res +=
"stack=<unavailable>";
418 res +=
"stack=<sentinel>";
420 res +=
"stack=<outer>";
422 res += std::string (
"stack=") + hex_string (
id.
stack_addr);
425 auto field_to_string = [] (
const char *n,
bool p, CORE_ADDR a) -> std::string
428 return std::string (n) +
"=" + core_addr_to_string (a);
430 return std::string (
"!") + std::string (n);
433 res += (std::string (
",")
452 return "NORMAL_FRAME";
455 return "DUMMY_FRAME";
458 return "INLINE_FRAME";
461 return "TAILCALL_FRAME";
464 return "SIGTRAMP_FRAME";
470 return "SENTINEL_FRAME";
473 return "<unknown type>";
486 res += string_printf (
"{level=%d,", fi->
level);
491 res +=
"type=<unknown>,";
494 res += string_printf (
"unwinder=\"%s\",", fi->
unwind->
name);
496 res +=
"unwinder=<unknown>,";
499 res +=
"pc=<unknown>,";
504 res +=
"pc=<not saved>,";
506 res +=
"pc=<unavailable>,";
509 res +=
"id=<not computed>,";
511 res +=
"id=<computing>,";
513 res += string_printf (
"id=%s,", fi->
this_id.
value.to_string ().c_str ());
518 res +=
"func=<unknown>";
615 catch (
const gdb_exception &ex)
647 gdb_assert (fi->level == 0);
655 gdb_assert (stashed);
658 return fi->this_id.value;
678 if (next_frame == NULL)
700 id.code_addr_p =
true;
702 id.special_addr_p =
true;
715 id.code_addr_p =
true;
729 id.code_addr_p =
true;
731 id.special_addr_p =
true;
743 id.code_addr_p =
true;
765 id.special_addr_p = 1;
885 const struct block *lb, *rb;
892 if (lb == NULL || rb == NULL)
999 catch (
const gdb_exception_error &ex)
1001 if (ex.error == NOT_AVAILABLE_ERROR)
1008 else if (ex.error == OPTIMIZED_OUT_ERROR)
1033 throw_error (NOT_AVAILABLE_ERROR, _(
"PC not available"));
1035 throw_error (OPTIMIZED_OUT_ERROR, _(
"PC not saved"));
1037 internal_error (
"unexpected prev_pc status: %d",
1049 gdb_assert (this_frame != NULL);
1061 CORE_ADDR addr_in_block;
1103 throw_error (NOT_AVAILABLE_ERROR, _(
"PC not available"));
1108std::unique_ptr<readonly_detached_regcache>
1111 auto cooked_read = [this_frame] (
int regnum, gdb_byte *buf)
1114 return REG_UNAVAILABLE;
1119 std::unique_ptr<readonly_detached_regcache>
regcache
1142 error (_(
"Cannot pop the initial frame."));
1148 if (prev_frame == NULL)
1149 error (_(
"Cannot find the caller frame."));
1155 std::unique_ptr<readonly_detached_regcache> scratch
1176 int *optimizedp,
int *unavailablep,
1177 enum lval_type *lvalp, CORE_ADDR *addrp,
1178 int *realnump, gdb_byte *bufferp)
1184 gdb_assert (optimizedp != NULL);
1185 gdb_assert (lvalp != NULL);
1186 gdb_assert (addrp != NULL);
1187 gdb_assert (realnump != NULL);
1192 gdb_assert (
value != NULL);
1205 if (!*optimizedp && !*unavailablep)
1224 int *optimizedp,
int *unavailablep,
enum lval_type *lvalp,
1225 CORE_ADDR *addrp,
int *realnump, gdb_byte *bufferp)
1229 gdb_assert (optimizedp != NULL);
1230 gdb_assert (lvalp != NULL);
1231 gdb_assert (addrp != NULL);
1232 gdb_assert (realnump != NULL);
1237 gdb_assert (frame != NULL && frame->
next != NULL);
1239 unavailablep, lvalp, addrp, realnump, bufferp);
1252 &
lval, &addr, &realnum, buf);
1255 throw_error (OPTIMIZED_OUT_ERROR,
1256 _(
"Register %d was not saved"),
regnum);
1258 throw_error (NOT_AVAILABLE_ERROR,
1259 _(
"Register %d is not available"),
regnum);
1264 int regnum, gdb_byte *buf)
1274 gdb_assert (next_frame != NULL);
1281 if (next_frame->
unwind == NULL)
1345 gdb_assert (
value != NULL);
1349 throw_error (OPTIMIZED_OUT_ERROR,
1350 _(
"Register %d was not saved"),
regnum);
1354 throw_error (NOT_AVAILABLE_ERROR,
1355 _(
"Register %d is not available"),
regnum);
1378 gdb_assert (
value != NULL);
1382 throw_error (OPTIMIZED_OUT_ERROR,
1383 _(
"Register %d was not saved"),
regnum);
1387 throw_error (NOT_AVAILABLE_ERROR,
1388 _(
"Register %d is not available"),
regnum);
1427 const gdb_byte *buf)
1437 &lval, &addr, &realnum, NULL);
1439 error (_(
"Attempt to assign to a register that was not saved."));
1451 error (_(
"Attempt to assign to an unmodifiable value."));
1474 &lval, &addr, &realnum, myaddr);
1476 return !optimized && !unavailable;
1482 gdb::array_view<gdb_byte> buffer,
1483 int *optimizedp,
int *unavailablep)
1501 for (i =
regnum; i < numregs; i++)
1507 maxsize += thissize;
1510 int len = buffer.size ();
1512 error (_(
"Bad debug information detected: "
1513 "Attempt to read %d bytes from registers."), len);
1523 gdb_byte *myaddr = buffer.data ();
1532 &lval, &addr, &realnum, myaddr);
1533 if (*optimizedp || *unavailablep)
1541 gdb_assert (
value != NULL);
1545 if (*optimizedp || *unavailablep)
1571 gdb::array_view<const gdb_byte> buffer)
1582 int len = buffer.size ();
1591 const gdb_byte *myaddr = buffer.data ();
1601 gdb_assert (
value != NULL);
1624 CORE_ADDR stack_addr, CORE_ADDR code_addr)
1639 frame->
next = frame;
1663 memset (data, 0,
size);
1680 error (_(
"No registers."));
1682 error (_(
"No stack."));
1684 error (_(
"No memory."));
1706 gdb_assert (current_frame != NULL);
1708 return current_frame;
1794 if (frame_level == -1)
1802 if (frame_level == 0)
1811 gdb_assert (frame_level > 0);
1817 count = frame_level;
1848 warning (_(
"Couldn't restore frame #%d in "
1849 "current thread. Bottom (innermost) frame selected:"),
1893 error ((
"%s"), message);
1929 gdb_assert (fi !=
nullptr);
2009 gdb_assert (
id.user_created_p);
2011 gdb_assert (
id.code_addr_p);
2014 hex_string (
id.stack_addr), hex_string (
id.code_addr));
2019 if (frame !=
nullptr)
2026 id.stack_addr,
id.code_addr).
get ();
2058 id.user_created_p = 1;
2070 if (this_frame->
level > 0)
2083 gdb_assert (this_frame != NULL);
2123 if (current_frame !=
nullptr
2149 CORE_ADDR *addrp,
int *realnump)
2151 gdb_assert (this_frame == NULL || this_frame->
level >= 0);
2153 while (this_frame != NULL)
2158 lvalp, addrp, realnump, NULL);
2204 if (prev_frame->
level == 0)
2235 gdb_assert (cycle_detection_p
2236 || (this_frame->
level > 0
2239 || (this_frame->
level == 0
2255 prev_frame->
next = NULL;
2256 this_frame->
prev = NULL;
2260 catch (
const gdb_exception &ex)
2264 prev_frame->
next = NULL;
2265 this_frame->
prev = NULL;
2283 gdb_assert (this_frame != NULL);
2287 if (this_frame != NULL)
2298 if (this_frame->
prev !=
nullptr)
2303 (
" -> nullptr // %s // cached",
2312 if (this_frame->
unwind == NULL)
2315 this_frame->
prev_p =
true;
2340 if (this_frame->
level == 0)
2352 (
" -> nullptr // %s",
2367 CORE_ADDR this_pc_in_block;
2369 const char *morestack_name = NULL;
2376 if (!morestack_name || strcmp (morestack_name,
"__morestack") != 0)
2398 if (this_frame->
level > 0
2404 int optimized, realnum, nrealnum;
2406 CORE_ADDR addr, naddr;
2410 &optimized, &lval, &addr, &realnum);
2413 &optimized, &nlval, &naddr, &nrealnum);
2415 if ((lval ==
lval_memory && lval == nlval && addr == naddr)
2416 || (lval ==
lval_register && lval == nlval && realnum == nrealnum))
2420 this_frame->
prev = NULL;
2443 catch (
const gdb_exception_error &ex)
2445 if (ex.error == MEMORY_ERROR)
2448 if (ex.message != NULL)
2457 size = ex.message->size () + 1;
2459 memcpy (stop_string, ex.what (),
size);
2517 this_frame->
prev = prev_frame;
2518 prev_frame->
next = this_frame.
get ();
2533 if (this_frame != NULL)
2548 CORE_ADDR sym_addr = 0;
2554 if (msymbol.
minsym !=
nullptr)
2559 if (msymbol.
minsym ==
nullptr
2575 gdb_assert (
block !=
nullptr);
2578 else if (msymbol.
minsym ==
nullptr)
2596 CORE_ADDR entry_point;
2624 gdb_assert (this_frame != NULL);
2638 if (this_frame->
level >= 0
2685 if (this_frame->
level >= 0
2698 if (this_frame->
level > 0
2702 && frame_pc_p && frame_pc == 0)
2714 gdb_assert (frame->
next != NULL);
2722 gdb_assert (frame->
next != NULL);
2728 catch (
const gdb_exception_error &ex)
2730 if (ex.error == NOT_AVAILABLE_ERROR)
2810 catch (
const gdb_exception_error &ex)
2812 if (ex.error == NOT_AVAILABLE_ERROR)
2845 if (sym->
line () != 0)
2891 if (fi->
base == NULL)
2906 if (fi->
base == NULL)
2921 if (fi->
base == NULL)
2936 if (fi->
unwind ==
nullptr)
2939 return fi->
unwind == unwinder;
2957 if (frame->
unwind == NULL)
2973 gdb_assert (this_frame);
2978 return this_frame->
pspace;
2991 gdb::array_view<gdb_byte> buffer)
2993 read_memory (addr, buffer.data (), buffer.size ());
3018 CORE_ADDR addr, gdb::array_view<gdb_byte> buffer)
3039 if (next_frame->
unwind == NULL)
3066 gdb_assert (next_frame != NULL);
3079 gdb_assert (frame!= NULL);
3095 catch (
const gdb_exception_error &ex)
3097 if (ex.error != NOT_AVAILABLE_ERROR)
3133 if (static_link ==
nullptr)
3136 CORE_ADDR upper_frame_base;
3152 if (framefunc != NULL
3156 == upper_frame_base))
3170 gdb_assert (frame->
prev_p);
3182#define SET(name, description) \
3183 case name: return _(description);
3184#include "unwind_stop_reasons.def"
3188 internal_error (
"Invalid frame stop reason");
3196 gdb_assert (fi->
prev == NULL);
3214#define SET(name, description) \
3215 case name: return #name;
3216#include "unwind_stop_reasons.def"
3220 internal_error (
"Invalid frame stop reason");
3236 gdb_assert (!frame->
prev_p);
3261 gdb_assert (frame->
unwind == NULL);
3280 N_(
"Set whether backtraces should continue past \"main\"."),
3281 N_(
"Show whether backtraces should continue past \"main\"."),
3282 N_(
"Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
3283the backtrace at \"main\". Set this if you need to see the rest\n\
3284of the stack trace."),
3291 N_(
"Set whether backtraces should continue past the entry point of a program."),
3292 N_(
"Show whether backtraces should continue past the entry point of a program."),
3293 N_(
"Normally there are no callers beyond the entry point of a program, so GDB\n\
3294will terminate the backtrace there. Set this if you need to see\n\
3295the rest of the stack trace."),
3308 if (args ==
nullptr)
3317 gdb_assert (frame !=
nullptr);
3330 if (
m_ptr ==
nullptr)
3347 if (
m_ptr !=
nullptr)
3371 gdb_assert (
m_ptr !=
nullptr);
3388Set backtrace specific variables.\n\
3389Configure backtrace variables such as the backtrace limit"),
3391Show backtrace specific variables.\n\
3392Show backtrace variables such as the backtrace limit."),
3398Set an upper bound on the number of backtrace levels."), _(
"\
3399Show the upper bound on the number of backtrace levels."), _(
"\
3400No more than the specified number of frames can be displayed or examined.\n\
3401Literal \"unlimited\" or zero means no limit."),
3413Set frame debugging."), _(
"\
3414Show frame debugging."), _(
"\
3415When non-zero, frame specific internal debugging is enabled."),
3421 _(
"Print the current frame-id."),
void annotate_frames_invalid(void)
const struct block * block_for_pc(CORE_ADDR pc)
const struct block * get_frame_block(frame_info_ptr frame, CORE_ADDR *addr_in_block)
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
frame_info * reinflate() const
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
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_uinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const literal_def *extra_literals, 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)
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)
std::string to_string(cooked_index_flag flags)
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, parser_flags flags)
const struct frame_base * frame_base_find_by_frame(frame_info_ptr this_frame)
const struct frame_id null_frame_id
static bool is_sentinel_frame_id(frame_id 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)
frame_info_ptr frame_follow_static_link(frame_info_ptr frame)
static void frame_info_del(frame_info *frame)
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)
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 * frame_type_str(frame_type type)
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)
static htab_t frame_stash
frame_id frame_id_build_sentinel(CORE_ADDR stack_addr, CORE_ADDR code_addr)
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)
static frame_info_ptr create_new_frame(frame_id id)
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)
static frame_info_ptr create_sentinel_frame(struct program_space *pspace, struct regcache *regcache, CORE_ADDR stack_addr, CORE_ADDR code_addr)
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)
frame_info_ptr frame_find_by_id(frame_id id)
void restore_selected_frame(frame_id frame_id, int frame_level) noexcept
bool frame_id_p(frame_id l)
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 *)
frame_info_ptr get_current_frame(void)
frame_info_ptr create_new_frame(CORE_ADDR base, CORE_ADDR pc)
#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)
static void set_language(const char *language)
const struct language_defn * current_language
bool dwarf2_evaluate_property(const struct dynamic_prop *prop, frame_info_ptr frame, const struct property_addr_info *addr_stack, CORE_ADDR *value, gdb::array_view< CORE_ADDR > push_values)
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)
bool contains(const struct block *a, bool allow_nested=false) const
const struct block * function_block() const
struct dynamic_prop * static_link() const
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 user_created_p
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::@59 prev_arch
struct frame_info::@60 prev_pc
const struct frame_unwind * unwind
struct frame_info::@61 prev_func
const struct frame_base * base
struct frame_info::@62 this_id
enum unwind_stop_reason stop_reason
std::string to_string() const
const address_space * aspace
frame_dealloc_cache_ftype * dealloc_cache
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
address_class aclass() const
unsigned int line() const
struct program_space * pspace
gdb::array_view< const gdb_byte > contents_all()
gdb::array_view< gdb_byte > contents_writeable()
gdb::array_view< const gdb_byte > contents()
bool entirely_available()
gdb::array_view< gdb_byte > contents_raw()
struct type * type() const
enum lval_type lval() const
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)
#define SYMBOL_BLOCK_OPS(symbol)
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)
LONGEST value_as_long(struct value *val)
value_ref_ptr release_value(struct value *val)
#define VALUE_REGNUM(val)