164 unsigned int *bytes_read_ptr,
222 #define cfa_exp_len cfa_reg
233 if (num_regs <= rs->num_regs)
254 memcpy (reg, rs->
reg, size);
302 static struct value *
340 incomplete CFI data; DW_CFA_restore unspecified\n\
341 register %s (#%d) at %s"),
368 CORE_ADDR initial,
int initial_in_stack_memory)
382 ctx->
baton = this_frame;
399 Not implemented: computing unwound register using explicit value operator"));
414 const gdb_byte *insn_end,
struct gdbarch *gdbarch,
418 unsigned int bytes_read;
421 while (insn_ptr < insn_end && fs->pc <= pc)
427 if ((insn & 0xc0) == DW_CFA_advance_loc)
429 else if ((insn & 0xc0) == DW_CFA_offset)
439 else if ((insn & 0xc0) == DW_CFA_restore)
455 insn_ptr += bytes_read;
458 case DW_CFA_advance_loc1:
463 case DW_CFA_advance_loc2:
468 case DW_CFA_advance_loc4:
474 case DW_CFA_offset_extended:
484 case DW_CFA_restore_extended:
489 case DW_CFA_undefined:
496 case DW_CFA_same_value:
503 case DW_CFA_register:
513 case DW_CFA_remember_state:
524 case DW_CFA_restore_state:
531 bad CFI data; mismatched DW_CFA_restore_state at %s"),
555 case DW_CFA_def_cfa_register:
562 case DW_CFA_def_cfa_offset:
575 case DW_CFA_def_cfa_expression:
577 fs->
regs.cfa_exp_len = utmp;
580 insn_ptr += fs->
regs.cfa_exp_len;
583 case DW_CFA_expression:
594 case DW_CFA_offset_extended_sf:
604 case DW_CFA_val_offset:
613 case DW_CFA_val_offset_sf:
622 case DW_CFA_val_expression:
632 case DW_CFA_def_cfa_sf:
641 case DW_CFA_def_cfa_offset_sf:
647 case DW_CFA_GNU_window_save:
659 for (reg = 8; reg < 16; reg++)
664 for (reg = 16; reg < 32; reg++)
672 case DW_CFA_GNU_args_size:
677 case DW_CFA_GNU_negative_offset_extended:
689 _(
"Unknown CFI encountered."));
781 void (*
init_reg) (
struct gdbarch *,
int,
799 ops->
init_reg (gdbarch, regnum, reg, this_frame);
847 int regnum,
int eh_frame_p)
895 int *regnum_out,
LONGEST *offset_out,
912 error (
_(
"Could not compute CFA; needed to translate this expression"));
925 fde->
cie->
end, gdbarch, pc, &fs);
942 error (
_(
"Unable to access DWARF register number %d"),
954 *text_offset_out = text_offset;
1021 struct cleanup *reset_cache_cleanup, *old_chain;
1037 *this_cache = cache;
1146 for (regnum = 0; regnum < num_regs; regnum++)
1166 if (regnum < 0 || regnum >= num_regs)
1184 incomplete CFI data; unspecified registers (e.g., %s) at %s"),
1198 for (regnum = 0; regnum < num_regs; regnum++)
1256 return UNWIND_UNAVAILABLE;
1259 return UNWIND_OUTERMOST;
1261 return UNWIND_NO_REASON;
1279 static struct value *
1315 switch (cache->
reg[regnum].
how)
1335 this_frame, cache->
cfa, 1);
1346 this_frame, cache->
cfa, 1);
1377 return cache->
reg[
regnum].
loc.
fn (this_frame, this_cache, regnum);
1398 struct frame_info *this_frame,
void **this_cache)
1486 dwarf2_frame_base_address
1510 _(
"cfa not available for record btrace target"));
1516 _(
"can't compute CFA for this frame: "
1517 "required registers or memory are unavailable"));
1521 _(
"can't compute CFA for this frame: "
1522 "frame base not available"));
1532 return bfd_get_8 (abfd, buf);
1538 return bfd_get_32 (abfd, buf);
1544 return bfd_get_64 (abfd, buf);
1549 unsigned int *bytes_read_ptr)
1553 result = bfd_get_32 (abfd, buf);
1554 if (result == 0xffffffff)
1556 result = bfd_get_64 (abfd, buf + 4);
1557 *bytes_read_ptr = 12;
1560 *bytes_read_ptr = 4;
1588 return DW_EH_PE_udata2;
1590 return DW_EH_PE_udata4;
1592 return DW_EH_PE_udata8;
1601 unsigned int *bytes_read_ptr,
1609 if (encoding & DW_EH_PE_indirect)
1611 _(
"Unsupported encoding: DW_EH_PE_indirect"));
1613 *bytes_read_ptr = 0;
1615 switch (encoding & 0x70)
1617 case DW_EH_PE_absptr:
1620 case DW_EH_PE_pcrel:
1624 case DW_EH_PE_datarel:
1627 case DW_EH_PE_textrel:
1630 case DW_EH_PE_funcrel:
1633 case DW_EH_PE_aligned:
1636 if ((offset % ptr_len) != 0)
1638 *bytes_read_ptr = ptr_len - (offset % ptr_len);
1639 buf += *bytes_read_ptr;
1644 _(
"Invalid or unsupported encoding"));
1647 if ((encoding & 0x07) == 0x00)
1650 if (bfd_get_sign_extend_vma (unit->
abfd))
1651 encoding |= DW_EH_PE_signed;
1654 switch (encoding & 0x0f)
1656 case DW_EH_PE_uleb128:
1659 const gdb_byte *end_buf = buf + (
sizeof (value) + 1) * 8 / 7;
1662 return base + value;
1664 case DW_EH_PE_udata2:
1665 *bytes_read_ptr += 2;
1666 return (base + bfd_get_16 (unit->
abfd, (bfd_byte *) buf));
1667 case DW_EH_PE_udata4:
1668 *bytes_read_ptr += 4;
1669 return (base + bfd_get_32 (unit->
abfd, (bfd_byte *) buf));
1670 case DW_EH_PE_udata8:
1671 *bytes_read_ptr += 8;
1672 return (base + bfd_get_64 (unit->
abfd, (bfd_byte *) buf));
1673 case DW_EH_PE_sleb128:
1676 const gdb_byte *end_buf = buf + (
sizeof (value) + 1) * 8 / 7;
1679 return base + value;
1681 case DW_EH_PE_sdata2:
1682 *bytes_read_ptr += 2;
1683 return (base + bfd_get_signed_16 (unit->
abfd, (bfd_byte *) buf));
1684 case DW_EH_PE_sdata4:
1685 *bytes_read_ptr += 4;
1686 return (base + bfd_get_signed_32 (unit->
abfd, (bfd_byte *) buf));
1687 case DW_EH_PE_sdata8:
1688 *bytes_read_ptr += 8;
1689 return (base + bfd_get_signed_64 (unit->
abfd, (bfd_byte *) buf));
1692 _(
"Invalid or unsupported encoding"));
1706 return (cie_pointer < cie->cie_pointer) ? -1 : 1;
1717 if (cie_table->
entries == NULL)
1773 fde_table = objfile_data (objfile, dwarf2_frame_objfile_data);
1774 if (fde_table == NULL)
1777 fde_table = objfile_data (objfile, dwarf2_frame_objfile_data);
1796 *pc = (*p_fde)->initial_location +
offset;
1820 #define DW64_CIE_ID 0xffffffffffffffffULL
1852 unsigned int bytes_read;
1872 dwarf64_p = (bytes_read == 12);
1893 if (cie_pointer == cie_id)
1898 unsigned int cie_version;
1902 error (
_(
"Found a CIE when not expecting it."));
1908 if (
find_cie (cie_table, cie_pointer))
1927 if (cie_version != 1 && cie_version != 3 && cie_version != 4)
1934 buf += (strlen (augmentation) + 1);
1939 augmentation += strlen (augmentation);
1944 if (augmentation[0] ==
'e' && augmentation[1] ==
'h')
1983 if (cie_version == 1)
2013 while (*augmentation)
2016 if (*augmentation ==
'L')
2024 else if (*augmentation ==
'R')
2031 else if (*augmentation ==
'P')
2036 buf, &bytes_read, 0);
2046 else if (*augmentation ==
'S')
2076 error (
_(
"Found an FDE when not expecting it."));
2085 cie_pointer -= (dwarf64_p ? 8 : 4);
2096 if (fde->
cie == NULL)
2099 eh_frame_p, cie_table, fde_table,
2107 buf, &bytes_read, 0);
2155 enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
2157 ptrdiff_t start_offset;
2162 cie_table, fde_table, entry_type);
2192 if (workaround < ALIGN4 && (start_offset & 3) != 0)
2194 start += 4 - (start_offset & 3);
2195 workaround = ALIGN4;
2198 if (workaround < ALIGN8 && (start_offset & 7) != 0)
2200 start += 8 - (start_offset & 7);
2201 workaround = ALIGN8;
2220 Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
2227 Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
2234 _(
"Corrupt data in %s:%s"),
2255 return (a < b) ? -1 : 1;
2297 asection *got, *txt;
2303 got = bfd_get_section_by_name (unit->
abfd,
".got");
2305 unit->
dbase = got->vma;
2309 txt = bfd_get_section_by_name (unit->
abfd,
".text");
2311 unit->
tbase = txt->vma;
2318 &cie_table, &fde_table,
2324 warning (
_(
"skipping .eh_frame info of %s: %s"),
2360 &cie_table, &fde_table,
2365 warning (
_(
"skipping .debug_frame info of %s: %s"),
2371 if (num_old_fde_entries == 0)
2380 sizeof (fde_table.
entries[0]));
2409 struct dwarf2_fde *first_non_zero_fde = NULL;
2434 first_non_zero_fde = fde;
2448 && first_non_zero_fde != NULL
2453 if (fde_prev != NULL
2458 sizeof (fde_table.
entries[0]));
2468 set_objfile_data (objfile, dwarf2_frame_objfile_data, fde_table2);
2478 dwarf2_frame_objfile_data = register_objfile_data ();
void dwarf_expr_push_address(struct dwarf_expr_context *ctx, CORE_ADDR value, int in_stack_memory)
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
const struct frame_unwind record_btrace_tailcall_frame_unwind
struct value * value_mark(void)
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
static void dwarf2_frame_state_free(void *p)
static gdb_byte encoding_for_size(unsigned int size)
CORE_ADDR get_frame_address_in_block(struct frame_info *this_frame)
static const struct frame_unwind dwarf2_frame_unwind
#define SECT_OFF_TEXT(objfile)
static void dwarf2_frame_state_free_regs(struct dwarf2_frame_state_reg_info *rs)
void dwarf2_build_frame_info(struct objfile *objfile)
int dwarf2_fetch_cfa_info(struct gdbarch *gdbarch, CORE_ADDR pc, struct dwarf2_per_cu_data *data, int *regnum_out, LONGEST *offset_out, CORE_ADDR *text_offset_out, const gdb_byte **cfa_start_out, const gdb_byte **cfa_end_out)
static void dwarf2_frame_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
static int dwarf2_frame_adjust_regnum(struct gdbarch *gdbarch, int regnum, int eh_frame_p)
CORE_ADDR ctx_no_get_frame_pc(void *baton)
struct objfile * separate_debug_objfile_backlink
static void add_fde(struct dwarf2_fde_table *fde_table, struct dwarf2_fde *fde)
static CORE_ADDR read_encoded_value(struct comp_unit *unit, gdb_byte encoding, int ptr_len, const gdb_byte *buf, unsigned int *bytes_read_ptr, CORE_ADDR func_base)
int checked_tailcall_bottom
struct frame_info * get_prev_frame(struct frame_info *this_frame)
LONGEST value_as_long(struct value *val)
struct value * frame_unwind_got_memory(struct frame_info *frame, int regnum, CORE_ADDR addr)
static void dwarf2_frame_state_alloc_regs(struct dwarf2_frame_state_reg_info *rs, int num_regs)
unsigned char segment_size
void warning(const char *fmt,...)
static void dwarf2_frame_init_reg(struct gdbarch *gdbarch, int regnum, struct dwarf2_frame_state_reg *reg, struct frame_info *this_frame)
static const gdb_byte * decode_frame_entry_1(struct comp_unit *unit, const gdb_byte *start, int eh_frame_p, struct dwarf2_cie_table *cie_table, struct dwarf2_fde_table *fde_table, enum eh_frame_type entry_type)
CORE_ADDR dwarf2_frame_cfa(struct frame_info *this_frame)
static void clear_pointer_cleanup(void *arg)
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
static const struct dwarf_expr_context_funcs dwarf2_frame_ctx_funcs
void * gdbarch_data(struct gdbarch *gdbarch, struct gdbarch_data *data)
struct frame_id frame_id_build_unavailable_stack(CORE_ADDR code_addr)
void internal_error(const char *file, int line, const char *fmt,...)
int armcc_cfa_offsets_reversed
struct type * ctx_no_get_base_type(struct dwarf_expr_context *ctx, cu_offset die)
union dwarf2_frame_state_reg::@51 loc
void ctx_no_get_frame_base(void *baton, const gdb_byte **start, size_t *length)
CORE_ADDR initial_location
static int bsearch_fde_cmp(const void *key, const void *element)
static enum unwind_stop_reason dwarf2_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
frame_dealloc_cache_ftype * dealloc_cache
void dwarf2_frame_set_signal_frame_p(struct gdbarch *gdbarch, int(*signal_frame_p)(struct gdbarch *, struct frame_info *))
const gdb_byte * safe_read_uleb128(const gdb_byte *buf, const gdb_byte *buf_end, uint64_t *r)
struct gdbarch_data * gdbarch_data_register_pre_init(gdbarch_data_pre_init_ftype *pre_init)
int gdbarch_num_regs(struct gdbarch *gdbarch)
struct dwarf2_frame_state_reg_info initial
const struct objfile_data * dwarf2_frame_objfile_data
int producer_is_realview(const char *producer)
struct dwarf2_cie ** entries
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
struct value * dwarf_expr_fetch(struct dwarf_expr_context *ctx, int n)
#define FRAME_OBSTACK_ZALLOC(TYPE)
const struct frame_unwind record_btrace_frame_unwind
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
CORE_ADDR ctx_no_get_addr_index(void *baton, unsigned int index)
struct value * frame_unwind_got_constant(struct frame_info *frame, int regnum, ULONGEST val)
struct compunit_symtab * find_pc_compunit_symtab(CORE_ADDR pc)
struct obstack objfile_obstack
static struct dwarf2_frame_cache * dwarf2_frame_cache(struct frame_info *this_frame, void **this_cache)
int gdbarch_num_pseudo_regs(struct gdbarch *gdbarch)
unsigned char signal_frame
struct value * value_from_register(struct type *type, int regnum, struct frame_info *frame)
#define ALL_OBJFILES(obj)
static void read_mem(void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
enum frame_type get_frame_type(struct frame_info *frame)
struct frame_id get_frame_id(struct frame_info *fi)
const struct frame_base * dwarf2_frame_base_sniffer(struct frame_info *this_frame)
bfd_size_type dwarf_frame_size
#define CATCH(EXCEPTION, MASK)
asection * dwarf_frame_section
const struct dwarf_expr_context_funcs * funcs
void dwarf2_frame_set_init_reg(struct gdbarch *gdbarch, void(*init_reg)(struct gdbarch *, int, struct dwarf2_frame_state_reg *, struct frame_info *))
struct dwarf2_fde ** entries
int gdbarch_sp_regnum(struct gdbarch *gdbarch)
enum unwind_stop_reason get_frame_unwind_stop_reason(struct frame_info *frame)
struct dwarf2_frame_state_reg * reg
static int dwarf2_frame_signal_frame_p(struct gdbarch *gdbarch, struct frame_info *this_frame)
static void dwarf2_frame_dealloc_cache(struct frame_info *self, void *this_cache)
int gdbarch_dwarf2_addr_size(struct gdbarch *gdbarch)
static struct dwarf2_frame_state_reg * dwarf2_frame_state_copy_regs(struct dwarf2_frame_state_reg_info *rs)
enum cfa_how_kind cfa_how
struct cleanup * make_cleanup_value_free_to_mark(struct value *mark)
void dwarf2_get_section_info(struct objfile *objfile, enum dwarf2_section_enum sect, asection **sectp, const gdb_byte **bufp, bfd_size_type *sizep)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
void complaint(struct complaints **complaints, const char *fmt,...)
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
#define ANOFFSET(secoff, whichone)
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
int entry_cfa_sp_offset_p
static const gdb_byte * execute_cfa_program(struct dwarf2_fde *fde, const gdb_byte *insn_ptr, const gdb_byte *insn_end, struct gdbarch *gdbarch, CORE_ADDR pc, struct dwarf2_frame_state *fs)
const gdb_byte * instructions
static unsigned int read_1_byte(bfd *abfd, const gdb_byte *buf)
static const gdb_byte * gdb_read_uleb128(const gdb_byte *buf, const gdb_byte *buf_end, uint64_t *r)
#define COMPUNIT_PRODUCER(cust)
CORE_ADDR ctx_no_get_tls_address(void *baton, CORE_ADDR offset)
void dwarf2_tailcall_sniffer_first(struct frame_info *this_frame, void **tailcall_cachep, const LONGEST *entry_cfa_sp_offsetp)
void _initialize_dwarf2_frame(void)
CORE_ADDR gdbarch_adjust_dwarf2_addr(struct gdbarch *gdbarch, CORE_ADDR pc)
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
struct dwarf_expr_context * new_dwarf_expr_context(void)
static const gdb_byte * decode_frame_entry(struct comp_unit *unit, const gdb_byte *start, int eh_frame_p, struct dwarf2_cie_table *cie_table, struct dwarf2_fde_table *fde_table, enum eh_frame_type entry_type)
static int startswith(const char *string, const char *pattern)
void(* init_reg)(struct gdbarch *, int, struct dwarf2_frame_state_reg *, struct frame_info *)
ULONGEST return_address_register
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
const char * objfile_name(const struct objfile *objfile)
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
LONGEST entry_cfa_sp_offset
static ULONGEST read_8_bytes(bfd *abfd, const gdb_byte *buf)
CORE_ADDR address_from_register(int regnum, struct frame_info *frame)
const gdb_byte * safe_read_sleb128(const gdb_byte *buf, const gdb_byte *buf_end, int64_t *r)
static void * dwarf2_frame_init(struct obstack *obstack)
static int dwarf2_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_cache)
const gdb_byte * initial_instructions
ULONGEST code_alignment_factor
PTR xrealloc(PTR ptr, size_t size)
int gdbarch_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, int dwarf2_regnr)
struct value * frame_unwind_got_optimized(struct frame_info *frame, int regnum)
static CORE_ADDR read_addr_from_reg(void *baton, int reg)
void throw_exception(struct gdb_exception exception)
const struct frame_unwind dwarf2_tailcall_frame_unwind
const char const char int
int get_frame_func_if_available(struct frame_info *this_frame, CORE_ADDR *pc)
void discard_cleanups(struct cleanup *old_chain)
static CORE_ADDR execute_stack_op(const gdb_byte *exp, ULONGEST len, int addr_size, CORE_ADDR offset, struct frame_info *this_frame, CORE_ADDR initial, int initial_in_stack_memory)
const gdb_byte * dwarf_frame_buffer
CORE_ADDR get_frame_base(struct frame_info *fi)
struct value * frame_unwind_got_register(struct frame_info *frame, int regnum, int new_regnum)
static unsigned int read_4_bytes(bfd *abfd, const gdb_byte *buf)
struct complaints * symfile_complaints
unsigned char saw_z_augmentation
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
static void dwarf2_restore_rule(struct gdbarch *gdbarch, ULONGEST reg_num, struct dwarf2_frame_state *fs, int eh_frame_p)
CORE_ADDR ctx_no_get_frame_cfa(void *baton)
static struct dwarf2_fde * dwarf2_frame_find_fde(CORE_ADDR *pc, CORE_ADDR *out_offset)
static const struct frame_base dwarf2_frame_base
struct value * dwarf2_tailcall_prev_register_first(struct frame_info *this_frame, void **tailcall_cachep, int regnum)
enum dwarf_value_location location
static struct gdbarch_data * dwarf2_frame_data
void ctx_no_push_dwarf_reg_entry_value(struct dwarf_expr_context *ctx, enum call_site_parameter_kind kind, union call_site_parameter_u kind_u, int deref_size)
static void dwarf2_frame_default_init_reg(struct gdbarch *gdbarch, int regnum, struct dwarf2_frame_state_reg *reg, struct frame_info *this_frame)
unsigned long long ULONGEST
static CORE_ADDR dwarf2_frame_base_address(struct frame_info *this_frame, void **this_cache)
struct value * frame_unwind_got_address(struct frame_info *frame, int regnum, CORE_ADDR addr)
int register_size(struct gdbarch *gdbarch, int regnum)
static const gdb_byte * gdb_read_sleb128(const gdb_byte *buf, const gdb_byte *buf_end, int64_t *r)
static ULONGEST read_initial_length(bfd *abfd, const gdb_byte *buf, unsigned int *bytes_read_ptr)
static struct value * dwarf2_frame_prev_register(struct frame_info *this_frame, void **this_cache, int regnum)
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
struct dwarf2_frame_state_reg retaddr_reg
CORE_ADDR dwarf_expr_fetch_address(struct dwarf_expr_context *ctx, int n)
struct dwarf2_frame_state_reg * reg
#define OBSTACK_ZALLOC(OBSTACK, TYPE)
struct dwarf2_frame_state_reg_info regs
LONGEST data_alignment_factor
struct section_offsets * section_offsets
void dwarf_expr_eval(struct dwarf_expr_context *ctx, const gdb_byte *addr, size_t len)
static int qsort_fde_cmp(const void *a, const void *b)
static void add_cie(struct dwarf2_cie_table *cie_table, struct dwarf2_cie *cie)
void ctx_no_dwarf_call(struct dwarf_expr_context *ctx, cu_offset die_offset)
CORE_ADDR get_frame_func(struct frame_info *this_frame)
static struct dwarf2_cie * find_cie(struct dwarf2_cie_table *cie_table, ULONGEST cie_pointer)
enum dwarf2_frame_reg_rule how
void error(const char *fmt,...)
int(* signal_frame_p)(struct gdbarch *, struct frame_info *)
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
#define FRAME_OBSTACK_CALLOC(NUMBER, TYPE)
void throw_error(enum errors error, const char *fmt,...)
void do_cleanups(struct cleanup *old_chain)
static int bsearch_cie_cmp(const void *key, const void *element)
static void dwarf2_frame_find_quirks(struct dwarf2_frame_state *fs, struct dwarf2_fde *fde)
int frame_unwinder_is(struct frame_info *fi, const struct frame_unwind *unwinder)
static struct value * get_reg_value(void *baton, struct type *type, int reg)
struct value *(* fn)(struct frame_info *this_frame, void **this_cache, int regnum)
struct dwarf2_frame_state_reg_info * prev
struct cleanup * make_cleanup_free_dwarf_expr_context(struct dwarf_expr_context *ctx)
void dwarf2_frame_set_adjust_regnum(struct gdbarch *gdbarch, int(*adjust_regnum)(struct gdbarch *, int, int))
int(* adjust_regnum)(struct gdbarch *, int, int)
const ULONGEST const LONGEST len