X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fdwarf2-frame.c;h=2f6355ae512346aaeb66b10b88707f917fdfd90a;hb=b125bd17270aca2af4d945ce8477f981dbc27e7e;hp=96fa4516a65872b5dc61a05d9ea2aed5b64b3c53;hpb=f664829eae5325405ce4e7f064c7be02352ce1f6;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/dwarf2-frame.c b/gdb/dwarf2-frame.c index 96fa4516a6..2f6355ae51 100644 --- a/gdb/dwarf2-frame.c +++ b/gdb/dwarf2-frame.c @@ -1,6 +1,6 @@ /* Frame unwinder for frames with DWARF Call Frame Information. - Copyright (C) 2003-2005, 2007-2012 Free Software Foundation, Inc. + Copyright (C) 2003-2016 Free Software Foundation, Inc. Contributed by Mark Kettenis. @@ -31,15 +31,12 @@ #include "objfiles.h" #include "regcache.h" #include "value.h" - -#include "gdb_assert.h" -#include "gdb_string.h" +#include "record.h" #include "complaints.h" #include "dwarf2-frame.h" #include "ax.h" #include "dwarf2loc.h" -#include "exceptions.h" #include "dwarf2-frame-tailcall.h" struct comp_unit; @@ -141,7 +138,7 @@ struct comp_unit struct objfile *objfile; /* Pointer to the .debug_frame section loaded into memory. */ - gdb_byte *dwarf_frame_buffer; + const gdb_byte *dwarf_frame_buffer; /* Length of the loaded .debug_frame section. */ bfd_size_type dwarf_frame_size; @@ -168,29 +165,34 @@ static CORE_ADDR read_encoded_value (struct comp_unit *unit, gdb_byte encoding, CORE_ADDR func_base); +enum cfa_how_kind +{ + CFA_UNSET, + CFA_REG_OFFSET, + CFA_EXP +}; + +struct dwarf2_frame_state_reg_info +{ + struct dwarf2_frame_state_reg *reg; + int num_regs; + + LONGEST cfa_offset; + ULONGEST cfa_reg; + enum cfa_how_kind cfa_how; + const gdb_byte *cfa_exp; + + /* Used to implement DW_CFA_remember_state. */ + struct dwarf2_frame_state_reg_info *prev; +}; + /* Structure describing a frame state. */ struct dwarf2_frame_state { /* Each register save state can be described in terms of a CFA slot, another register, or a location expression. */ - struct dwarf2_frame_state_reg_info - { - struct dwarf2_frame_state_reg *reg; - int num_regs; - - LONGEST cfa_offset; - ULONGEST cfa_reg; - enum { - CFA_UNSET, - CFA_REG_OFFSET, - CFA_EXP - } cfa_how; - const gdb_byte *cfa_exp; - - /* Used to implement DW_CFA_remember_state. */ - struct dwarf2_frame_state_reg_info *prev; - } regs; + struct dwarf2_frame_state_reg_info regs; /* The PC described by the current frame state. */ CORE_ADDR pc; @@ -273,7 +275,7 @@ dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info *rs) static void dwarf2_frame_state_free (void *p) { - struct dwarf2_frame_state *fs = p; + struct dwarf2_frame_state *fs = (struct dwarf2_frame_state *) p; dwarf2_frame_state_free_regs (fs->initial.prev); dwarf2_frame_state_free_regs (fs->regs.prev); @@ -286,24 +288,25 @@ dwarf2_frame_state_free (void *p) /* Helper functions for execute_stack_op. */ static CORE_ADDR -read_reg (void *baton, int reg) +read_addr_from_reg (void *baton, int reg) { struct frame_info *this_frame = (struct frame_info *) baton; struct gdbarch *gdbarch = get_frame_arch (this_frame); - int regnum; - gdb_byte *buf; + int regnum = dwarf_reg_to_regnum_or_error (gdbarch, reg); + + return address_from_register (regnum, this_frame); +} - regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, reg); +/* Implement struct dwarf_expr_context_funcs' "get_reg_value" callback. */ - buf = alloca (register_size (gdbarch, regnum)); - get_frame_register (this_frame, regnum, buf); +static struct value * +get_reg_value (void *baton, struct type *type, int reg) +{ + struct frame_info *this_frame = (struct frame_info *) baton; + struct gdbarch *gdbarch = get_frame_arch (this_frame); + int regnum = dwarf_reg_to_regnum_or_error (gdbarch, reg); - /* Convert the register to an integer. This returns a LONGEST - rather than a CORE_ADDR, but unpack_pointer does the same thing - under the covers, and this makes more sense for non-pointer - registers. Maybe read_reg and the associated interfaces should - deal with "struct value" instead of CORE_ADDR. */ - return unpack_long (register_type (gdbarch, regnum), buf); + return value_from_register (type, regnum, this_frame); } static void @@ -333,20 +336,23 @@ dwarf2_restore_rule (struct gdbarch *gdbarch, ULONGEST reg_num, fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNSPECIFIED; if (fs->regs.reg[reg].how == DWARF2_FRAME_REG_UNSPECIFIED) - complaint (&symfile_complaints, _("\ + { + int regnum = dwarf_reg_to_regnum (gdbarch, reg); + + complaint (&symfile_complaints, _("\ incomplete CFI data; DW_CFA_restore unspecified\n\ register %s (#%d) at %s"), - gdbarch_register_name - (gdbarch, gdbarch_dwarf2_reg_to_regnum (gdbarch, reg)), - gdbarch_dwarf2_reg_to_regnum (gdbarch, reg), - paddress (gdbarch, fs->pc)); + gdbarch_register_name (gdbarch, regnum), regnum, + paddress (gdbarch, fs->pc)); + } } /* Virtual method table for execute_stack_op below. */ static const struct dwarf_expr_context_funcs dwarf2_frame_ctx_funcs = { - read_reg, + read_addr_from_reg, + get_reg_value, read_mem, ctx_no_get_frame_base, ctx_no_get_frame_cfa, @@ -384,7 +390,8 @@ execute_stack_op (const gdb_byte *exp, ULONGEST len, int addr_size, if (ctx->location == DWARF_VALUE_MEMORY) result = dwarf_expr_fetch_address (ctx, 0); else if (ctx->location == DWARF_VALUE_REGISTER) - result = read_reg (this_frame, value_as_long (dwarf_expr_fetch (ctx, 0))); + result = read_addr_from_reg (this_frame, + value_as_long (dwarf_expr_fetch (ctx, 0))); else { /* This is actually invalid DWARF, but if we ever do run across @@ -410,14 +417,14 @@ execute_cfa_program (struct dwarf2_fde *fde, const gdb_byte *insn_ptr, CORE_ADDR pc, struct dwarf2_frame_state *fs) { int eh_frame_p = fde->eh_frame_p; - int bytes_read; + unsigned int bytes_read; enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); while (insn_ptr < insn_end && fs->pc <= pc) { gdb_byte insn = *insn_ptr++; - unsigned long long utmp, reg; - long long offset; + uint64_t utmp, reg; + int64_t offset; if ((insn & 0xc0) == DW_CFA_advance_loc) fs->pc += (insn & 0x3f) * fs->code_align; @@ -509,7 +516,7 @@ execute_cfa_program (struct dwarf2_fde *fde, const gdb_byte *insn_ptr, { struct dwarf2_frame_state_reg_info *new_rs; - new_rs = XMALLOC (struct dwarf2_frame_state_reg_info); + new_rs = XNEW (struct dwarf2_frame_state_reg_info); *new_rs = fs->regs; fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs); fs->regs.prev = new_rs; @@ -672,8 +679,8 @@ bad CFI data; mismatched DW_CFA_restore_state at %s"), case DW_CFA_GNU_negative_offset_extended: insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®); reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p); - insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &offset); - offset *= fs->data_align; + insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp); + offset = utmp * fs->data_align; dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1); fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET; fs->regs.reg[reg].loc.offset = -offset; @@ -777,7 +784,8 @@ dwarf2_frame_set_init_reg (struct gdbarch *gdbarch, struct dwarf2_frame_state_reg *, struct frame_info *)) { - struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data); + struct dwarf2_frame_ops *ops + = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data); ops->init_reg = init_reg; } @@ -789,7 +797,8 @@ dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum, struct dwarf2_frame_state_reg *reg, struct frame_info *this_frame) { - struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data); + struct dwarf2_frame_ops *ops + = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data); ops->init_reg (gdbarch, regnum, reg, this_frame); } @@ -802,7 +811,8 @@ dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch, int (*signal_frame_p) (struct gdbarch *, struct frame_info *)) { - struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data); + struct dwarf2_frame_ops *ops + = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data); ops->signal_frame_p = signal_frame_p; } @@ -814,7 +824,8 @@ static int dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch, struct frame_info *this_frame) { - struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data); + struct dwarf2_frame_ops *ops + = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data); if (ops->signal_frame_p == NULL) return 0; @@ -829,7 +840,8 @@ dwarf2_frame_set_adjust_regnum (struct gdbarch *gdbarch, int (*adjust_regnum) (struct gdbarch *, int, int)) { - struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data); + struct dwarf2_frame_ops *ops + = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data); ops->adjust_regnum = adjust_regnum; } @@ -841,7 +853,8 @@ static int dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch, int regnum, int eh_frame_p) { - struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data); + struct dwarf2_frame_ops *ops + = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data); if (ops->adjust_regnum == NULL) return regnum; @@ -852,13 +865,13 @@ static void dwarf2_frame_find_quirks (struct dwarf2_frame_state *fs, struct dwarf2_fde *fde) { - struct symtab *s; + struct compunit_symtab *cust; - s = find_pc_symtab (fs->pc); - if (s == NULL) + cust = find_pc_compunit_symtab (fs->pc); + if (cust == NULL) return; - if (producer_is_realview (s->producer)) + if (producer_is_realview (COMPUNIT_PRODUCER (cust))) { if (fde->cie->version == 1) fs->armcc_cfa_offsets_sf = 1; @@ -873,7 +886,7 @@ dwarf2_frame_find_quirks (struct dwarf2_frame_state *fs, this problem is fixed (no quirk needed). If the armcc augmentation is missing, the quirk is needed. */ if (fde->cie->version == 3 - && (strncmp (fde->cie->augmentation, "armcc", 5) != 0 + && (!startswith (fde->cie->augmentation, "armcc") || strchr (fde->cie->augmentation + 5, '+') == NULL)) fs->armcc_cfa_offsets_reversed = 1; @@ -882,14 +895,16 @@ dwarf2_frame_find_quirks (struct dwarf2_frame_state *fs, } -void -dwarf2_compile_cfa_to_ax (struct agent_expr *expr, struct axs_value *loc, - struct gdbarch *gdbarch, - CORE_ADDR pc, - struct dwarf2_per_cu_data *data) +/* See dwarf2-frame.h. */ + +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) { - const int num_regs = gdbarch_num_regs (gdbarch) - + gdbarch_num_pseudo_regs (gdbarch); struct dwarf2_fde *fde; CORE_ADDR text_offset; struct dwarf2_frame_state fs; @@ -929,31 +944,21 @@ dwarf2_compile_cfa_to_ax (struct agent_expr *expr, struct axs_value *loc, { case CFA_REG_OFFSET: { - int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, fs.regs.cfa_reg); - - if (regnum == -1) - error (_("Unable to access DWARF register number %d"), - (int) fs.regs.cfa_reg); /* FIXME */ - ax_reg (expr, regnum); + int regnum = dwarf_reg_to_regnum_or_error (gdbarch, fs.regs.cfa_reg); - if (fs.regs.cfa_offset != 0) - { - if (fs.armcc_cfa_offsets_reversed) - ax_const_l (expr, -fs.regs.cfa_offset); - else - ax_const_l (expr, fs.regs.cfa_offset); - ax_simple (expr, aop_add); - } + *regnum_out = regnum; + if (fs.armcc_cfa_offsets_reversed) + *offset_out = -fs.regs.cfa_offset; + else + *offset_out = fs.regs.cfa_offset; + return 1; } - break; case CFA_EXP: - ax_const_l (expr, text_offset); - dwarf2_compile_expr_to_ax (expr, loc, gdbarch, addr_size, - fs.regs.cfa_exp, - fs.regs.cfa_exp + fs.regs.cfa_exp_len, - data); - break; + *text_offset_out = text_offset; + *cfa_start_out = fs.regs.cfa_exp; + *cfa_end_out = fs.regs.cfa_exp + fs.regs.cfa_exp_len; + return 0; default: internal_error (__FILE__, __LINE__, _("Unknown CFA rule.")); @@ -986,40 +991,58 @@ struct dwarf2_frame_cache /* The .text offset. */ CORE_ADDR text_offset; + /* True if we already checked whether this frame is the bottom frame + of a virtual tail call frame chain. */ + int checked_tailcall_bottom; + /* If not NULL then this frame is the bottom frame of a TAILCALL_FRAME sequence. If NULL then it is a normal case with no TAILCALL_FRAME involved. Non-bottom frames of a virtual tail call frames chain use dwarf2_tailcall_frame_unwind unwinder so this field does not apply for them. */ void *tailcall_cache; + + /* The number of bytes to subtract from TAILCALL_FRAME frames frame + base to get the SP, to simulate the return address pushed on the + stack. */ + LONGEST entry_cfa_sp_offset; + int entry_cfa_sp_offset_p; }; +/* A cleanup that sets a pointer to NULL. */ + +static void +clear_pointer_cleanup (void *arg) +{ + void **ptr = (void **) arg; + + *ptr = NULL; +} + static struct dwarf2_frame_cache * dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache) { - struct cleanup *old_chain; + struct cleanup *reset_cache_cleanup, *old_chain; struct gdbarch *gdbarch = get_frame_arch (this_frame); const int num_regs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch); struct dwarf2_frame_cache *cache; struct dwarf2_frame_state *fs; struct dwarf2_fde *fde; - volatile struct gdb_exception ex; CORE_ADDR entry_pc; - LONGEST entry_cfa_sp_offset; - int entry_cfa_sp_offset_p = 0; const gdb_byte *instr; if (*this_cache) - return *this_cache; + return (struct dwarf2_frame_cache *) *this_cache; /* Allocate a new cache. */ cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache); cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg); *this_cache = cache; + reset_cache_cleanup = make_cleanup (clear_pointer_cleanup, this_cache); /* Allocate and initialize the frame state. */ - fs = XZALLOC (struct dwarf2_frame_state); + fs = XCNEW (struct dwarf2_frame_state); old_chain = make_cleanup (dwarf2_frame_state_free, fs); /* Unwind the PC. @@ -1054,7 +1077,8 @@ dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache) /* First decode all the insns in the CIE. */ execute_cfa_program (fde, fde->cie->initial_instructions, - fde->cie->end, gdbarch, get_frame_pc (this_frame), fs); + fde->cie->end, gdbarch, + get_frame_address_in_block (this_frame), fs); /* Save the initialized register set. */ fs->initial = fs->regs; @@ -1067,11 +1091,11 @@ dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache) entry_pc, fs); if (fs->regs.cfa_how == CFA_REG_OFFSET - && (gdbarch_dwarf2_reg_to_regnum (gdbarch, fs->regs.cfa_reg) + && (dwarf_reg_to_regnum (gdbarch, fs->regs.cfa_reg) == gdbarch_sp_regnum (gdbarch))) { - entry_cfa_sp_offset = fs->regs.cfa_offset; - entry_cfa_sp_offset_p = 1; + cache->entry_cfa_sp_offset = fs->regs.cfa_offset; + cache->entry_cfa_sp_offset_p = 1; } } else @@ -1079,15 +1103,15 @@ dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache) /* Then decode the insns in the FDE up to our target PC. */ execute_cfa_program (fde, instr, fde->end, gdbarch, - get_frame_pc (this_frame), fs); + get_frame_address_in_block (this_frame), fs); - TRY_CATCH (ex, RETURN_MASK_ERROR) + TRY { /* Calculate the CFA. */ switch (fs->regs.cfa_how) { case CFA_REG_OFFSET: - cache->cfa = read_reg (this_frame, fs->regs.cfa_reg); + cache->cfa = read_addr_from_reg (this_frame, fs->regs.cfa_reg); if (fs->armcc_cfa_offsets_reversed) cache->cfa -= fs->regs.cfa_offset; else @@ -1105,16 +1129,19 @@ dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache) internal_error (__FILE__, __LINE__, _("Unknown CFA rule.")); } } - if (ex.reason < 0) + CATCH (ex, RETURN_MASK_ERROR) { if (ex.error == NOT_AVAILABLE_ERROR) { cache->unavailable_retaddr = 1; + do_cleanups (old_chain); + discard_cleanups (reset_cache_cleanup); return cache; } throw_exception (ex); } + END_CATCH /* Initialize the register state. */ { @@ -1127,19 +1154,16 @@ dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache) /* Go through the DWARF2 CFI generated table and save its register location information in the cache. Note that we don't skip the return address column; it's perfectly all right for it to - correspond to a real register. If it doesn't correspond to a - real register, or if we shouldn't treat it as such, - gdbarch_dwarf2_reg_to_regnum should be defined to return a number outside - the range [0, gdbarch_num_regs). */ + correspond to a real register. */ { int column; /* CFI speak for "register number". */ for (column = 0; column < fs->regs.num_regs; column++) { /* Use the GDB register number as the destination index. */ - int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, column); + int regnum = dwarf_reg_to_regnum (gdbarch, column); - /* If there's no corresponding GDB register, ignore it. */ + /* Protect against a target returning a bad register. */ if (regnum < 0 || regnum >= num_regs) continue; @@ -1218,13 +1242,7 @@ incomplete CFI data; unspecified registers (e.g., %s) at %s"), cache->undefined_retaddr = 1; do_cleanups (old_chain); - - /* Try to find a virtual tail call frames chain with bottom (callee) frame - starting at THIS_FRAME. */ - dwarf2_tailcall_sniffer_first (this_frame, &cache->tailcall_cache, - (entry_cfa_sp_offset_p - ? &entry_cfa_sp_offset : NULL)); - + discard_cleanups (reset_cache_cleanup); return cache; } @@ -1252,12 +1270,11 @@ dwarf2_frame_this_id (struct frame_info *this_frame, void **this_cache, dwarf2_frame_cache (this_frame, this_cache); if (cache->unavailable_retaddr) + (*this_id) = frame_id_build_unavailable_stack (get_frame_func (this_frame)); + else if (cache->undefined_retaddr) return; - - if (cache->undefined_retaddr) - return; - - (*this_id) = frame_id_build (cache->cfa, get_frame_func (this_frame)); + else + (*this_id) = frame_id_build (cache->cfa, get_frame_func (this_frame)); } static struct value * @@ -1270,6 +1287,16 @@ dwarf2_frame_prev_register (struct frame_info *this_frame, void **this_cache, CORE_ADDR addr; int realnum; + /* Check whether THIS_FRAME is the bottom frame of a virtual tail + call frame chain. */ + if (!cache->checked_tailcall_bottom) + { + cache->checked_tailcall_bottom = 1; + dwarf2_tailcall_sniffer_first (this_frame, &cache->tailcall_cache, + (cache->entry_cfa_sp_offset_p + ? &cache->entry_cfa_sp_offset : NULL)); + } + /* Non-bottom frames of a virtual tail call frames chain use dwarf2_tailcall_frame_unwind unwinder so this code does not apply for them. If dwarf2_tailcall_prev_register_first does not have specific value @@ -1298,8 +1325,8 @@ dwarf2_frame_prev_register (struct frame_info *this_frame, void **this_cache, return frame_unwind_got_memory (this_frame, regnum, addr); case DWARF2_FRAME_REG_SAVED_REG: - realnum - = gdbarch_dwarf2_reg_to_regnum (gdbarch, cache->reg[regnum].loc.reg); + realnum = dwarf_reg_to_regnum_or_error + (gdbarch, cache->reg[regnum].loc.reg); return frame_unwind_got_register (this_frame, regnum, realnum); case DWARF2_FRAME_REG_SAVED_EXP: @@ -1342,7 +1369,7 @@ dwarf2_frame_prev_register (struct frame_info *this_frame, void **this_cache, case DWARF2_FRAME_REG_RA_OFFSET: addr = cache->reg[regnum].loc.offset; - regnum = gdbarch_dwarf2_reg_to_regnum + regnum = dwarf_reg_to_regnum_or_error (gdbarch, cache->retaddr_reg.loc.reg); addr += get_frame_register_unsigned (this_frame, regnum); return frame_unwind_got_address (this_frame, regnum, addr); @@ -1396,10 +1423,6 @@ dwarf2_frame_sniffer (const struct frame_unwind *self, if (self->type != NORMAL_FRAME) return 0; - /* Preinitializa the cache so that TAILCALL_FRAME can find the record by - dwarf2_tailcall_sniffer_first. */ - dwarf2_frame_cache (this_frame, this_cache); - return 1; } @@ -1482,18 +1505,23 @@ dwarf2_frame_base_sniffer (struct frame_info *this_frame) CORE_ADDR dwarf2_frame_cfa (struct frame_info *this_frame) { + if (frame_unwinder_is (this_frame, &record_btrace_tailcall_frame_unwind) + || frame_unwinder_is (this_frame, &record_btrace_frame_unwind)) + throw_error (NOT_AVAILABLE_ERROR, + _("cfa not available for record btrace target")); + while (get_frame_type (this_frame) == INLINE_FRAME) this_frame = get_prev_frame (this_frame); - /* This restriction could be lifted if other unwinders are known to - compute the frame base in a way compatible with the DWARF - unwinder. */ - if (!frame_unwinder_is (this_frame, &dwarf2_frame_unwind) - && !frame_unwinder_is (this_frame, &dwarf2_tailcall_frame_unwind)) - error (_("can't compute CFA for this frame")); if (get_frame_unwind_stop_reason (this_frame) == UNWIND_UNAVAILABLE) throw_error (NOT_AVAILABLE_ERROR, - _("can't compute CFA for this frame: " - "required registers or memory are unavailable")); + _("can't compute CFA for this frame: " + "required registers or memory are unavailable")); + + if (get_frame_id (this_frame).stack_status != FID_STACK_VALID) + throw_error (NOT_AVAILABLE_ERROR, + _("can't compute CFA for this frame: " + "frame base not available")); + return get_frame_base (this_frame); } @@ -1628,7 +1656,7 @@ read_encoded_value (struct comp_unit *unit, gdb_byte encoding, { case DW_EH_PE_uleb128: { - unsigned long long value; + uint64_t value; const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7; *bytes_read_ptr += safe_read_uleb128 (buf, end_buf, &value) - buf; @@ -1645,7 +1673,7 @@ read_encoded_value (struct comp_unit *unit, gdb_byte encoding, return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf)); case DW_EH_PE_sleb128: { - long long value; + int64_t value; const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7; *bytes_read_ptr += safe_read_sleb128 (buf, end_buf, &value) - buf; @@ -1693,8 +1721,9 @@ find_cie (struct dwarf2_cie_table *cie_table, ULONGEST cie_pointer) return NULL; } - p_cie = bsearch (&cie_pointer, cie_table->entries, cie_table->num_entries, - sizeof (cie_table->entries[0]), bsearch_cie_cmp); + p_cie = ((struct dwarf2_cie **) + bsearch (&cie_pointer, cie_table->entries, cie_table->num_entries, + sizeof (cie_table->entries[0]), bsearch_cie_cmp)); if (p_cie != NULL) return *p_cie; return NULL; @@ -1709,8 +1738,8 @@ add_cie (struct dwarf2_cie_table *cie_table, struct dwarf2_cie *cie) gdb_assert (n < 1 || cie_table->entries[n - 1]->cie_pointer < cie->cie_pointer); - cie_table->entries = - xrealloc (cie_table->entries, (n + 1) * sizeof (cie_table->entries[0])); + cie_table->entries + = XRESIZEVEC (struct dwarf2_cie *, cie_table->entries, n + 1); cie_table->entries[n] = cie; cie_table->num_entries = n + 1; } @@ -1743,11 +1772,13 @@ dwarf2_frame_find_fde (CORE_ADDR *pc, CORE_ADDR *out_offset) CORE_ADDR offset; CORE_ADDR seek_pc; - fde_table = objfile_data (objfile, dwarf2_frame_objfile_data); + fde_table = ((struct dwarf2_fde_table *) + objfile_data (objfile, dwarf2_frame_objfile_data)); if (fde_table == NULL) { dwarf2_build_frame_info (objfile); - fde_table = objfile_data (objfile, dwarf2_frame_objfile_data); + fde_table = ((struct dwarf2_fde_table *) + objfile_data (objfile, dwarf2_frame_objfile_data)); } gdb_assert (fde_table != NULL); @@ -1762,8 +1793,9 @@ dwarf2_frame_find_fde (CORE_ADDR *pc, CORE_ADDR *out_offset) continue; seek_pc = *pc - offset; - p_fde = bsearch (&seek_pc, fde_table->entries, fde_table->num_entries, - sizeof (fde_table->entries[0]), bsearch_fde_cmp); + p_fde = ((struct dwarf2_fde **) + bsearch (&seek_pc, fde_table->entries, fde_table->num_entries, + sizeof (fde_table->entries[0]), bsearch_fde_cmp)); if (p_fde != NULL) { *pc = (*p_fde)->initial_location + offset; @@ -1784,17 +1816,12 @@ add_fde (struct dwarf2_fde_table *fde_table, struct dwarf2_fde *fde) return; fde_table->num_entries += 1; - fde_table->entries = - xrealloc (fde_table->entries, - fde_table->num_entries * sizeof (fde_table->entries[0])); + fde_table->entries = XRESIZEVEC (struct dwarf2_fde *, fde_table->entries, + fde_table->num_entries); fde_table->entries[fde_table->num_entries - 1] = fde; } -#ifdef CC_HAS_LONG_LONG #define DW64_CIE_ID 0xffffffffffffffffULL -#else -#define DW64_CIE_ID ~0 -#endif /* Defines the type of eh_frames that are expected to be decoded: CIE, FDE or any of them. */ @@ -1830,8 +1857,8 @@ decode_frame_entry_1 (struct comp_unit *unit, const gdb_byte *start, int dwarf64_p; ULONGEST cie_id; ULONGEST cie_pointer; - long long sleb128; - unsigned long long uleb128; + int64_t sleb128; + uint64_t uleb128; buf = start; length = read_initial_length (unit->abfd, buf, &bytes_read); @@ -1885,9 +1912,7 @@ decode_frame_entry_1 (struct comp_unit *unit, const gdb_byte *start, if (find_cie (cie_table, cie_pointer)) return end; - cie = (struct dwarf2_cie *) - obstack_alloc (&unit->objfile->objfile_obstack, - sizeof (struct dwarf2_cie)); + cie = XOBNEW (&unit->objfile->objfile_obstack, struct dwarf2_cie); cie->initial_instructions = NULL; cie->cie_pointer = cie_pointer; @@ -1912,7 +1937,7 @@ decode_frame_entry_1 (struct comp_unit *unit, const gdb_byte *start, /* Ignore armcc augmentations. We only use them for quirks, and that doesn't happen until later. */ - if (strncmp (augmentation, "armcc", 5) == 0) + if (startswith (augmentation, "armcc")) augmentation += strlen (augmentation); /* The GCC 2.x "eh" augmentation has a pointer immediately @@ -1978,7 +2003,7 @@ decode_frame_entry_1 (struct comp_unit *unit, const gdb_byte *start, cie->saw_z_augmentation = (*augmentation == 'z'); if (cie->saw_z_augmentation) { - unsigned long long length; + uint64_t length; buf = gdb_read_uleb128 (buf, end, &length); if (buf == NULL) @@ -2046,6 +2071,7 @@ decode_frame_entry_1 (struct comp_unit *unit, const gdb_byte *start, { /* This is a FDE. */ struct dwarf2_fde *fde; + CORE_ADDR addr; /* Check that an FDE was expected. */ if ((entry_type & EH_FDE_TYPE_ID) == 0) @@ -2065,9 +2091,7 @@ decode_frame_entry_1 (struct comp_unit *unit, const gdb_byte *start, if (cie_pointer >= unit->dwarf_frame_size) return NULL; - fde = (struct dwarf2_fde *) - obstack_alloc (&unit->objfile->objfile_obstack, - sizeof (struct dwarf2_fde)); + fde = XOBNEW (&unit->objfile->objfile_obstack, struct dwarf2_fde); fde->cie = find_cie (cie_table, cie_pointer); if (fde->cie == NULL) { @@ -2079,14 +2103,16 @@ decode_frame_entry_1 (struct comp_unit *unit, const gdb_byte *start, gdb_assert (fde->cie != NULL); - fde->initial_location = - read_encoded_value (unit, fde->cie->encoding, fde->cie->ptr_size, - buf, &bytes_read, 0); + addr = read_encoded_value (unit, fde->cie->encoding, fde->cie->ptr_size, + buf, &bytes_read, 0); + fde->initial_location = gdbarch_adjust_dwarf2_addr (gdbarch, addr); buf += bytes_read; fde->address_range = read_encoded_value (unit, fde->cie->encoding & 0x0f, fde->cie->ptr_size, buf, &bytes_read, 0); + addr = gdbarch_adjust_dwarf2_addr (gdbarch, addr + fde->address_range); + fde->address_range = addr - fde->initial_location; buf += bytes_read; /* A 'z' augmentation in the CIE implies the presence of an @@ -2095,7 +2121,7 @@ decode_frame_entry_1 (struct comp_unit *unit, const gdb_byte *start, can skip the whole thing. */ if (fde->cie->saw_z_augmentation) { - unsigned long long length; + uint64_t length; buf = gdb_read_uleb128 (buf, end, &length); if (buf == NULL) @@ -2243,7 +2269,6 @@ dwarf2_build_frame_info (struct objfile *objfile) struct dwarf2_cie_table cie_table; struct dwarf2_fde_table fde_table; struct dwarf2_fde_table *fde_table2; - volatile struct gdb_exception e; cie_table.num_entries = 0; cie_table.entries = NULL; @@ -2285,7 +2310,7 @@ dwarf2_build_frame_info (struct objfile *objfile) if (txt) unit->tbase = txt->vma; - TRY_CATCH (e, RETURN_MASK_ERROR) + TRY { frame_ptr = unit->dwarf_frame_buffer; while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size) @@ -2294,10 +2319,10 @@ dwarf2_build_frame_info (struct objfile *objfile) EH_CIE_OR_FDE_TYPE_ID); } - if (e.reason < 0) + CATCH (e, RETURN_MASK_ERROR) { warning (_("skipping .eh_frame info of %s: %s"), - objfile->name, e.message); + objfile_name (objfile), e.message); if (fde_table.num_entries != 0) { @@ -2307,6 +2332,7 @@ dwarf2_build_frame_info (struct objfile *objfile) } /* The cie_table is discarded by the next if. */ } + END_CATCH if (cie_table.num_entries != 0) { @@ -2326,7 +2352,7 @@ dwarf2_build_frame_info (struct objfile *objfile) { int num_old_fde_entries = fde_table.num_entries; - TRY_CATCH (e, RETURN_MASK_ERROR) + TRY { frame_ptr = unit->dwarf_frame_buffer; while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size) @@ -2334,10 +2360,10 @@ dwarf2_build_frame_info (struct objfile *objfile) &cie_table, &fde_table, EH_CIE_OR_FDE_TYPE_ID); } - if (e.reason < 0) + CATCH (e, RETURN_MASK_ERROR) { warning (_("skipping .debug_frame info of %s: %s"), - objfile->name, e.message); + objfile_name (objfile), e.message); if (fde_table.num_entries != 0) { @@ -2349,14 +2375,15 @@ dwarf2_build_frame_info (struct objfile *objfile) } else { - fde_table.entries = xrealloc (fde_table.entries, - fde_table.num_entries * - sizeof (fde_table.entries[0])); + fde_table.entries + = XRESIZEVEC (struct dwarf2_fde *, fde_table.entries, + fde_table.num_entries); } } fde_table.num_entries = num_old_fde_entries; /* The cie_table is discarded by the next if. */ } + END_CATCH } /* Discard the cie_table, it is no longer needed. */ @@ -2368,8 +2395,7 @@ dwarf2_build_frame_info (struct objfile *objfile) } /* Copy fde_table to obstack: it is needed at runtime. */ - fde_table2 = (struct dwarf2_fde_table *) - obstack_alloc (&objfile->objfile_obstack, sizeof (*fde_table2)); + fde_table2 = XOBNEW (&objfile->objfile_obstack, struct dwarf2_fde_table); if (fde_table.num_entries == 0) { @@ -2432,7 +2458,8 @@ dwarf2_build_frame_info (struct objfile *objfile) ++fde_table2->num_entries; fde_prev = fde; } - fde_table2->entries = obstack_finish (&objfile->objfile_obstack); + fde_table2->entries + = (struct dwarf2_fde **) obstack_finish (&objfile->objfile_obstack); /* Discard the original fde_table. */ xfree (fde_table.entries);