/* Frame unwinder for frames with DWARF Call Frame Information.
- Copyright (C) 2003-2015 Free Software Foundation, Inc.
+ Copyright (C) 2003-2017 Free Software Foundation, Inc.
Contributed by Mark Kettenis.
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);
/* Helper functions for execute_stack_op. */
static CORE_ADDR
-read_addr_from_reg (void *baton, int reg)
+read_addr_from_reg (struct frame_info *this_frame, 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);
+ int regnum = dwarf_reg_to_regnum_or_error (gdbarch, reg);
return address_from_register (regnum, this_frame);
}
-/* Implement struct dwarf_expr_context_funcs' "get_reg_value" callback. */
-
-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
-read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
-{
- read_memory (addr, buf, len);
-}
-
/* Execute the required actions for both the DW_CFA_restore and
DW_CFA_restore_extended instructions. */
static void
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 =
+class dwarf_expr_executor : public dwarf_expr_context
{
- read_addr_from_reg,
- get_reg_value,
- read_mem,
- ctx_no_get_frame_base,
- ctx_no_get_frame_cfa,
- ctx_no_get_frame_pc,
- ctx_no_get_tls_address,
- ctx_no_dwarf_call,
- ctx_no_get_base_type,
- ctx_no_push_dwarf_reg_entry_value,
- ctx_no_get_addr_index
+ public:
+
+ struct frame_info *this_frame;
+
+ CORE_ADDR read_addr_from_reg (int reg) OVERRIDE
+ {
+ return ::read_addr_from_reg (this_frame, reg);
+ }
+
+ struct value *get_reg_value (struct type *type, int reg) OVERRIDE
+ {
+ struct gdbarch *gdbarch = get_frame_arch (this_frame);
+ int regnum = dwarf_reg_to_regnum_or_error (gdbarch, reg);
+
+ return value_from_register (type, regnum, this_frame);
+ }
+
+ void read_mem (gdb_byte *buf, CORE_ADDR addr, size_t len) OVERRIDE
+ {
+ read_memory (addr, buf, len);
+ }
+
+ void get_frame_base (const gdb_byte **start, size_t *length) OVERRIDE
+ {
+ invalid ("DW_OP_fbreg");
+ }
+
+ void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind,
+ union call_site_parameter_u kind_u,
+ int deref_size) OVERRIDE
+ {
+ invalid ("DW_OP_entry_value");
+ }
+
+ CORE_ADDR get_object_address () OVERRIDE
+ {
+ invalid ("DW_OP_push_object_address");
+ }
+
+ CORE_ADDR get_frame_cfa () OVERRIDE
+ {
+ invalid ("DW_OP_call_frame_cfa");
+ }
+
+ CORE_ADDR get_tls_address (CORE_ADDR offset) OVERRIDE
+ {
+ invalid ("DW_OP_form_tls_address");
+ }
+
+ void dwarf_call (cu_offset die_offset) OVERRIDE
+ {
+ invalid ("DW_OP_call*");
+ }
+
+ CORE_ADDR get_addr_index (unsigned int index)
+ {
+ invalid ("DW_OP_GNU_addr_index");
+ }
+
+ private:
+
+ void invalid (const char *op) ATTRIBUTE_NORETURN
+ {
+ error (_("%s is invalid in this context"), op);
+ }
};
static CORE_ADDR
CORE_ADDR offset, struct frame_info *this_frame,
CORE_ADDR initial, int initial_in_stack_memory)
{
- struct dwarf_expr_context *ctx;
CORE_ADDR result;
- struct cleanup *old_chain;
-
- ctx = new_dwarf_expr_context ();
- old_chain = make_cleanup_free_dwarf_expr_context (ctx);
- make_cleanup_value_free_to_mark (value_mark ());
-
- ctx->gdbarch = get_frame_arch (this_frame);
- ctx->addr_size = addr_size;
- ctx->ref_addr_size = -1;
- ctx->offset = offset;
- ctx->baton = this_frame;
- ctx->funcs = &dwarf2_frame_ctx_funcs;
-
- dwarf_expr_push_address (ctx, initial, initial_in_stack_memory);
- dwarf_expr_eval (ctx, exp, len);
-
- if (ctx->location == DWARF_VALUE_MEMORY)
- result = dwarf_expr_fetch_address (ctx, 0);
- else if (ctx->location == DWARF_VALUE_REGISTER)
- result = read_addr_from_reg (this_frame,
- value_as_long (dwarf_expr_fetch (ctx, 0)));
+
+ dwarf_expr_executor ctx;
+ scoped_value_mark free_values;
+
+ ctx.this_frame = this_frame;
+ ctx.gdbarch = get_frame_arch (this_frame);
+ ctx.addr_size = addr_size;
+ ctx.ref_addr_size = -1;
+ ctx.offset = offset;
+
+ ctx.push_address (initial, initial_in_stack_memory);
+ ctx.eval (exp, len);
+
+ if (ctx.location == DWARF_VALUE_MEMORY)
+ result = ctx.fetch_address (0);
+ else if (ctx.location == DWARF_VALUE_REGISTER)
+ result = ctx.read_addr_from_reg (value_as_long (ctx.fetch (0)));
else
{
/* This is actually invalid DWARF, but if we ever do run across
Not implemented: computing unwound register using explicit value operator"));
}
- do_cleanups (old_chain);
-
return result;
}
\f
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;
}
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);
}
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;
}
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;
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;
}
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;
struct dwarf2_fde *fde;
CORE_ADDR text_offset;
struct dwarf2_frame_state fs;
- int addr_size;
memset (&fs, 0, sizeof (struct dwarf2_frame_state));
fs.data_align = fde->cie->data_alignment_factor;
fs.code_align = fde->cie->code_alignment_factor;
fs.retaddr_column = fde->cie->return_address_register;
- addr_size = fde->cie->addr_size;
/* Check for "quirks" - known bugs in producers. */
dwarf2_frame_find_quirks (&fs, fde);
{
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 */
+ int regnum = dwarf_reg_to_regnum_or_error (gdbarch, fs.regs.cfa_reg);
*regnum_out = regnum;
if (fs.armcc_cfa_offsets_reversed)
static void
clear_pointer_cleanup (void *arg)
{
- void **ptr = arg;
+ void **ptr = (void **) arg;
*ptr = NULL;
}
struct dwarf2_frame_cache *cache;
struct dwarf2_frame_state *fs;
struct dwarf2_fde *fde;
- volatile struct gdb_exception ex;
CORE_ADDR entry_pc;
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);
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)))
{
cache->entry_cfa_sp_offset = fs->regs.cfa_offset;
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)
internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
}
}
- if (ex.reason < 0)
+ CATCH (ex, RETURN_MASK_ERROR)
{
if (ex.error == NOT_AVAILABLE_ERROR)
{
throw_exception (ex);
}
+ END_CATCH
/* Initialize the register state. */
{
/* 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;
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:
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);
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;
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;
}
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);
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;
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;
}
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;
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)
{
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;
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)
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 (objfile), e.message);
}
/* The cie_table is discarded by the next if. */
}
+ END_CATCH
if (cie_table.num_entries != 0)
{
{
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)
&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 (objfile), e.message);
}
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. */
}
/* 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)
{
++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);