X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fdwarf2-frame.c;h=8fb2ac77718ff3b47b06269eaf142b9c5145bcbc;hb=a88d0bb33c28bc51c0f53cdd5c42d00217a1d771;hp=ec4edfaaf33a4eb0df8a12f406ce9d8347849460;hpb=c656bca57874f367618b35767e5bfc35545c7b1d;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/dwarf2-frame.c b/gdb/dwarf2-frame.c index ec4edfaaf3..8fb2ac7771 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-2013 Free Software Foundation, Inc. + Copyright (C) 2003-2015 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; @@ -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 = gdbarch_dwarf2_reg_to_regnum (gdbarch, reg); - regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, reg); + return address_from_register (regnum, this_frame); +} - buf = alloca (register_size (gdbarch, regnum)); - get_frame_register (this_frame, regnum, buf); +/* Implement struct dwarf_expr_context_funcs' "get_reg_value" callback. */ - /* 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); +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 = gdbarch_dwarf2_reg_to_regnum (gdbarch, reg); + + return value_from_register (type, regnum, this_frame); } static void @@ -346,7 +349,8 @@ register %s (#%d) at %s"), 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 +388,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,7 +415,7 @@ 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) @@ -509,7 +514,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 +677,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; @@ -852,13 +857,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 +878,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,11 +887,15 @@ 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) { struct dwarf2_fde *fde; CORE_ADDR text_offset; @@ -932,26 +941,20 @@ dwarf2_compile_cfa_to_ax (struct agent_expr *expr, struct axs_value *loc, if (regnum == -1) error (_("Unable to access DWARF register number %d"), (int) fs.regs.cfa_reg); /* FIXME */ - ax_reg (expr, regnum); - 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.")); @@ -984,12 +987,22 @@ 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. */ @@ -1012,10 +1025,7 @@ dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache) 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) @@ -1028,7 +1038,7 @@ dwarf2_frame_cache (struct frame_info *this_frame, void **this_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. @@ -1080,8 +1090,8 @@ dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache) && (gdbarch_dwarf2_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 @@ -1091,13 +1101,13 @@ dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache) execute_cfa_program (fde, instr, fde->end, gdbarch, 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 @@ -1115,7 +1125,7 @@ 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) { @@ -1127,6 +1137,7 @@ dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache) throw_exception (ex); } + END_CATCH /* Initialize the register state. */ { @@ -1230,13 +1241,6 @@ 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; } @@ -1265,12 +1269,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 * @@ -1283,6 +1286,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 @@ -1409,10 +1422,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; } @@ -1495,18 +1504,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); } @@ -1921,7 +1935,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 @@ -2055,6 +2069,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) @@ -2088,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 @@ -2252,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; @@ -2294,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) @@ -2303,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) { @@ -2316,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) { @@ -2335,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) @@ -2343,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) { @@ -2366,6 +2383,7 @@ dwarf2_build_frame_info (struct objfile *objfile) 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. */