/* Frame unwinder for frames with DWARF Call Frame Information.
- Copyright (C) 2003-2016 Free Software Foundation, Inc.
+ Copyright (C) 2003-2017 Free Software Foundation, Inc.
Contributed by Mark Kettenis.
#include "ax.h"
#include "dwarf2loc.h"
#include "dwarf2-frame-tailcall.h"
+#if GDB_SELF_TEST
+#include "selftest.h"
+#include "selftest-arch.h"
+#endif
struct comp_unit;
CORE_ADDR func_base);
\f
-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 regs;
-
- /* The PC described by the current frame state. */
- CORE_ADDR pc;
-
- /* Initial register set from the CIE.
- Used to implement DW_CFA_restore. */
- struct dwarf2_frame_state_reg_info initial;
-
- /* The information we care about from the CIE. */
- LONGEST data_align;
- ULONGEST code_align;
- ULONGEST retaddr_column;
-
- /* Flags for known producer quirks. */
-
- /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
- and DW_CFA_def_cfa_offset takes a factored offset. */
- int armcc_cfa_offsets_sf;
-
- /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
- the CFA is defined as REG - OFFSET rather than REG + OFFSET. */
- int armcc_cfa_offsets_reversed;
-};
-
/* Store the length the expression for the CFA in the `cfa_reg' field,
which is unused in that case. */
#define cfa_exp_len cfa_reg
-/* Assert that the register set RS is large enough to store gdbarch_num_regs
- columns. If necessary, enlarge the register set. */
-
-static void
-dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info *rs,
- int num_regs)
-{
- size_t size = sizeof (struct dwarf2_frame_state_reg);
-
- if (num_regs <= rs->num_regs)
- return;
-
- rs->reg = (struct dwarf2_frame_state_reg *)
- xrealloc (rs->reg, num_regs * size);
-
- /* Initialize newly allocated registers. */
- memset (rs->reg + rs->num_regs, 0, (num_regs - rs->num_regs) * size);
- rs->num_regs = num_regs;
-}
-
-/* Copy the register columns in register set RS into newly allocated
- memory and return a pointer to this newly created copy. */
-
-static struct dwarf2_frame_state_reg *
-dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info *rs)
-{
- size_t size = rs->num_regs * sizeof (struct dwarf2_frame_state_reg);
- struct dwarf2_frame_state_reg *reg;
-
- reg = (struct dwarf2_frame_state_reg *) xmalloc (size);
- memcpy (reg, rs->reg, size);
-
- return reg;
-}
-
-/* Release the memory allocated to register set RS. */
-
-static void
-dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info *rs)
-{
- if (rs)
- {
- dwarf2_frame_state_free_regs (rs->prev);
-
- xfree (rs->reg);
- xfree (rs);
- }
-}
-
-/* Release the memory allocated to the frame state FS. */
-
-static void
-dwarf2_frame_state_free (void *p)
+dwarf2_frame_state::dwarf2_frame_state (CORE_ADDR pc_, struct dwarf2_cie *cie)
+ : pc (pc_), data_align (cie->data_alignment_factor),
+ code_align (cie->code_alignment_factor),
+ retaddr_column (cie->return_address_register)
{
- 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);
- xfree (fs->initial.reg);
- xfree (fs->regs.reg);
- xfree (fs);
}
\f
/* 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 = 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 = dwarf_reg_to_regnum_or_error (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
gdb_assert (fs->initial.reg);
reg = dwarf2_frame_adjust_regnum (gdbarch, reg_num, eh_frame_p);
- dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
+ fs->regs.alloc_regs (reg + 1);
/* Check if this register was explicitly initialized in the
CIE initial instructions. If not, default the rule to
}
}
-/* 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 initial, int initial_in_stack_memory)
{
CORE_ADDR result;
- struct cleanup *old_chain;
- dwarf_expr_context ctx;
- old_chain = make_cleanup_value_free_to_mark (value_mark ());
+ 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.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);
+ ctx.push_address (initial, initial_in_stack_memory);
+ ctx.eval (exp, len);
if (ctx.location == DWARF_VALUE_MEMORY)
- result = dwarf_expr_fetch_address (&ctx, 0);
+ result = ctx.fetch_address (0);
else if (ctx.location == DWARF_VALUE_REGISTER)
- result = read_addr_from_reg (this_frame,
- value_as_long (dwarf_expr_fetch (&ctx, 0)));
+ 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
reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
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.alloc_regs (reg + 1);
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
fs->regs.reg[reg].loc.offset = offset;
}
reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
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.alloc_regs (reg + 1);
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
fs->regs.reg[reg].loc.offset = offset;
break;
case DW_CFA_undefined:
insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
- dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
+ fs->regs.alloc_regs (reg + 1);
fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
break;
case DW_CFA_same_value:
insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
- dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
+ fs->regs.alloc_regs (reg + 1);
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
break;
reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
utmp = dwarf2_frame_adjust_regnum (gdbarch, utmp, eh_frame_p);
- dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
+ fs->regs.alloc_regs (reg + 1);
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
fs->regs.reg[reg].loc.reg = utmp;
break;
{
struct dwarf2_frame_state_reg_info *new_rs;
- new_rs = XNEW (struct dwarf2_frame_state_reg_info);
- *new_rs = fs->regs;
- fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs);
+ new_rs = new dwarf2_frame_state_reg_info (fs->regs);
fs->regs.prev = new_rs;
}
break;
paddress (gdbarch, fs->pc));
}
else
- {
- xfree (fs->regs.reg);
- fs->regs = *old_rs;
- xfree (old_rs);
- }
+ fs->regs = std::move (*old_rs);
}
break;
case DW_CFA_expression:
insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
- dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
+ fs->regs.alloc_regs (reg + 1);
insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
- fs->regs.reg[reg].loc.exp = insn_ptr;
- fs->regs.reg[reg].exp_len = utmp;
+ fs->regs.reg[reg].loc.exp.start = insn_ptr;
+ fs->regs.reg[reg].loc.exp.len = utmp;
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP;
insn_ptr += utmp;
break;
reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
offset *= fs->data_align;
- dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
+ fs->regs.alloc_regs (reg + 1);
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
fs->regs.reg[reg].loc.offset = offset;
break;
case DW_CFA_val_offset:
insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
- dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
+ fs->regs.alloc_regs (reg + 1);
insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
offset = utmp * fs->data_align;
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
case DW_CFA_val_offset_sf:
insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
- dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
+ fs->regs.alloc_regs (reg + 1);
insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
offset *= fs->data_align;
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
case DW_CFA_val_expression:
insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
- dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
+ fs->regs.alloc_regs (reg + 1);
insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
- fs->regs.reg[reg].loc.exp = insn_ptr;
- fs->regs.reg[reg].exp_len = utmp;
+ fs->regs.reg[reg].loc.exp.start = insn_ptr;
+ fs->regs.reg[reg].loc.exp.len = utmp;
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_EXP;
insn_ptr += utmp;
break;
/* cfa_how deliberately not set. */
break;
- case DW_CFA_GNU_window_save:
- /* This is SPARC-specific code, and contains hard-coded
- constants for the register numbering scheme used by
- GCC. Rather than having a architecture-specific
- operation that's only ever used by a single
- architecture, we provide the implementation here.
- Incidentally that's what GCC does too in its
- unwinder. */
- {
- int size = register_size (gdbarch, 0);
-
- dwarf2_frame_state_alloc_regs (&fs->regs, 32);
- for (reg = 8; reg < 16; reg++)
- {
- fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
- fs->regs.reg[reg].loc.reg = reg + 16;
- }
- for (reg = 16; reg < 32; reg++)
- {
- fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
- fs->regs.reg[reg].loc.offset = (reg - 16) * size;
- }
- }
- break;
-
case DW_CFA_GNU_args_size:
/* Ignored. */
insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
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.alloc_regs (reg + 1);
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
fs->regs.reg[reg].loc.offset = -offset;
break;
default:
- internal_error (__FILE__, __LINE__,
- _("Unknown CFI encountered."));
+ if (insn >= DW_CFA_lo_user && insn <= DW_CFA_hi_user)
+ {
+ /* Handle vendor-specific CFI for different architectures. */
+ if (!gdbarch_execute_dwarf_cfa_vendor_op (gdbarch, insn, fs))
+ error (_("Call Frame Instruction op %d in vendor extension "
+ "space is not handled on this architecture."),
+ insn);
+ }
+ else
+ internal_error (__FILE__, __LINE__,
+ _("Unknown CFI encountered."));
}
}
}
if (fs->initial.reg == NULL)
{
/* Don't allow remember/restore between CIE and FDE programs. */
- dwarf2_frame_state_free_regs (fs->regs.prev);
+ delete fs->regs.prev;
fs->regs.prev = NULL;
}
return insn_ptr;
}
+
+#if GDB_SELF_TEST
+
+namespace selftests {
+
+/* Unit test to function execute_cfa_program. */
+
+static void
+execute_cfa_program_test (struct gdbarch *gdbarch)
+{
+ struct dwarf2_fde fde;
+ struct dwarf2_cie cie;
+
+ memset (&fde, 0, sizeof fde);
+ memset (&cie, 0, sizeof cie);
+
+ cie.data_alignment_factor = -4;
+ cie.code_alignment_factor = 2;
+ fde.cie = &cie;
+
+ dwarf2_frame_state fs (0, fde.cie);
+
+ gdb_byte insns[] =
+ {
+ DW_CFA_def_cfa, 1, 4, /* DW_CFA_def_cfa: r1 ofs 4 */
+ DW_CFA_offset | 0x2, 1, /* DW_CFA_offset: r2 at cfa-4 */
+ DW_CFA_remember_state,
+ DW_CFA_restore_state,
+ };
+
+ const gdb_byte *insn_end = insns + sizeof (insns);
+ const gdb_byte *out = execute_cfa_program (&fde, insns, insn_end, gdbarch,
+ 0, &fs);
+
+ SELF_CHECK (out == insn_end);
+ SELF_CHECK (fs.pc == 0);
+
+ /* The instructions above only use r1 and r2, but the register numbers
+ used are adjusted by dwarf2_frame_adjust_regnum. */
+ auto r1 = dwarf2_frame_adjust_regnum (gdbarch, 1, fde.eh_frame_p);
+ auto r2 = dwarf2_frame_adjust_regnum (gdbarch, 2, fde.eh_frame_p);
+
+ SELF_CHECK (fs.regs.num_regs == (std::max (r1, r2) + 1));
+
+ SELF_CHECK (fs.regs.reg[r2].how == DWARF2_FRAME_REG_SAVED_OFFSET);
+ SELF_CHECK (fs.regs.reg[r2].loc.offset == -4);
+
+ for (auto i = 0; i < fs.regs.num_regs; i++)
+ if (i != r2)
+ SELF_CHECK (fs.regs.reg[i].how == DWARF2_FRAME_REG_UNSPECIFIED);
+
+ SELF_CHECK (fs.regs.cfa_reg == 1);
+ SELF_CHECK (fs.regs.cfa_offset == 4);
+ SELF_CHECK (fs.regs.cfa_how == CFA_REG_OFFSET);
+ SELF_CHECK (fs.regs.cfa_exp == NULL);
+ SELF_CHECK (fs.regs.prev == NULL);
+}
+
+} // namespace selftests
+#endif /* GDB_SELF_TEST */
+
\f
/* Architecture-specific operations. */
{
struct dwarf2_fde *fde;
CORE_ADDR text_offset;
- struct dwarf2_frame_state fs;
-
- memset (&fs, 0, sizeof (struct dwarf2_frame_state));
-
- fs.pc = pc;
+ CORE_ADDR pc1 = pc;
/* Find the correct FDE. */
- fde = dwarf2_frame_find_fde (&fs.pc, &text_offset);
+ fde = dwarf2_frame_find_fde (&pc1, &text_offset);
if (fde == NULL)
error (_("Could not compute CFA; needed to translate this expression"));
- /* Extract any interesting information from the CIE. */
- fs.data_align = fde->cie->data_alignment_factor;
- fs.code_align = fde->cie->code_alignment_factor;
- fs.retaddr_column = fde->cie->return_address_register;
+ dwarf2_frame_state fs (pc1, fde->cie);
/* Check for "quirks" - known bugs in producers. */
dwarf2_frame_find_quirks (&fs, fde);
/* Save the initialized register set. */
fs.initial = fs.regs;
- fs.initial.reg = dwarf2_frame_state_copy_regs (&fs.regs);
/* Then decode the insns in the FDE up to our target PC. */
execute_cfa_program (fde, fde->instructions, fde->end, gdbarch, pc, &fs);
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 *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;
CORE_ADDR entry_pc;
const gdb_byte *instr;
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 = XCNEW (struct dwarf2_frame_state);
- old_chain = make_cleanup (dwarf2_frame_state_free, fs);
/* Unwind the PC.
get_frame_address_in_block does just this. It's not clear how
reliable the method is though; there is the potential for the
register state pre-call being different to that on return. */
- fs->pc = get_frame_address_in_block (this_frame);
+ CORE_ADDR pc1 = get_frame_address_in_block (this_frame);
/* Find the correct FDE. */
- fde = dwarf2_frame_find_fde (&fs->pc, &cache->text_offset);
+ fde = dwarf2_frame_find_fde (&pc1, &cache->text_offset);
gdb_assert (fde != NULL);
- /* Extract any interesting information from the CIE. */
- fs->data_align = fde->cie->data_alignment_factor;
- fs->code_align = fde->cie->code_alignment_factor;
- fs->retaddr_column = fde->cie->return_address_register;
+ /* Allocate and initialize the frame state. */
+ struct dwarf2_frame_state fs (pc1, fde->cie);
+
cache->addr_size = fde->cie->addr_size;
/* Check for "quirks" - known bugs in producers. */
- dwarf2_frame_find_quirks (fs, fde);
+ dwarf2_frame_find_quirks (&fs, fde);
/* First decode all the insns in the CIE. */
execute_cfa_program (fde, fde->cie->initial_instructions,
fde->cie->end, gdbarch,
- get_frame_address_in_block (this_frame), fs);
+ get_frame_address_in_block (this_frame), &fs);
/* Save the initialized register set. */
- fs->initial = fs->regs;
- fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
+ fs.initial = fs.regs;
if (get_frame_func_if_available (this_frame, &entry_pc))
{
/* Decode the insns in the FDE up to the entry PC. */
instr = execute_cfa_program (fde, fde->instructions, fde->end, gdbarch,
- entry_pc, fs);
+ entry_pc, &fs);
- if (fs->regs.cfa_how == CFA_REG_OFFSET
- && (dwarf_reg_to_regnum (gdbarch, fs->regs.cfa_reg)
+ if (fs.regs.cfa_how == CFA_REG_OFFSET
+ && (dwarf_reg_to_regnum (gdbarch, fs.regs.cfa_reg)
== gdbarch_sp_regnum (gdbarch)))
{
- cache->entry_cfa_sp_offset = fs->regs.cfa_offset;
+ cache->entry_cfa_sp_offset = fs.regs.cfa_offset;
cache->entry_cfa_sp_offset_p = 1;
}
}
/* Then decode the insns in the FDE up to our target PC. */
execute_cfa_program (fde, instr, fde->end, gdbarch,
- get_frame_address_in_block (this_frame), fs);
+ get_frame_address_in_block (this_frame), &fs);
TRY
{
/* Calculate the CFA. */
- switch (fs->regs.cfa_how)
+ switch (fs.regs.cfa_how)
{
case CFA_REG_OFFSET:
- cache->cfa = read_addr_from_reg (this_frame, fs->regs.cfa_reg);
- if (fs->armcc_cfa_offsets_reversed)
- cache->cfa -= fs->regs.cfa_offset;
+ 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
- cache->cfa += fs->regs.cfa_offset;
+ cache->cfa += fs.regs.cfa_offset;
break;
case CFA_EXP:
cache->cfa =
- execute_stack_op (fs->regs.cfa_exp, fs->regs.cfa_exp_len,
+ execute_stack_op (fs.regs.cfa_exp, fs.regs.cfa_exp_len,
cache->addr_size, cache->text_offset,
this_frame, 0, 0);
break;
if (ex.error == NOT_AVAILABLE_ERROR)
{
cache->unavailable_retaddr = 1;
- do_cleanups (old_chain);
- discard_cleanups (reset_cache_cleanup);
return cache;
}
{
int column; /* CFI speak for "register number". */
- for (column = 0; column < fs->regs.num_regs; column++)
+ for (column = 0; column < fs.regs.num_regs; column++)
{
/* Use the GDB register number as the destination index. */
int regnum = dwarf_reg_to_regnum (gdbarch, column);
problems when a debug info register falls outside of the
table. We need a way of iterating through all the valid
DWARF2 register numbers. */
- if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
+ if (fs.regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
{
if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
complaint (&symfile_complaints, _("\
incomplete CFI data; unspecified registers (e.g., %s) at %s"),
gdbarch_register_name (gdbarch, regnum),
- paddress (gdbarch, fs->pc));
+ paddress (gdbarch, fs.pc));
}
else
- cache->reg[regnum] = fs->regs.reg[column];
+ cache->reg[regnum] = fs.regs.reg[column];
}
}
|| cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
{
struct dwarf2_frame_state_reg *retaddr_reg =
- &fs->regs.reg[fs->retaddr_column];
+ &fs.regs.reg[fs.retaddr_column];
/* It seems rather bizarre to specify an "empty" column as
the return adress column. However, this is exactly
register corresponding to the return address column.
Incidentally, that's how we should treat a return
address column specifying "same value" too. */
- if (fs->retaddr_column < fs->regs.num_regs
+ if (fs.retaddr_column < fs.regs.num_regs
&& retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
&& retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
{
{
if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
{
- cache->reg[regnum].loc.reg = fs->retaddr_column;
+ cache->reg[regnum].loc.reg = fs.retaddr_column;
cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
}
else
{
- cache->retaddr_reg.loc.reg = fs->retaddr_column;
+ cache->retaddr_reg.loc.reg = fs.retaddr_column;
cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
}
}
}
}
- if (fs->retaddr_column < fs->regs.num_regs
- && fs->regs.reg[fs->retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
+ if (fs.retaddr_column < fs.regs.num_regs
+ && fs.regs.reg[fs.retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
cache->undefined_retaddr = 1;
- do_cleanups (old_chain);
- discard_cleanups (reset_cache_cleanup);
return cache;
}
return frame_unwind_got_register (this_frame, regnum, realnum);
case DWARF2_FRAME_REG_SAVED_EXP:
- addr = execute_stack_op (cache->reg[regnum].loc.exp,
- cache->reg[regnum].exp_len,
+ addr = execute_stack_op (cache->reg[regnum].loc.exp.start,
+ cache->reg[regnum].loc.exp.len,
cache->addr_size, cache->text_offset,
this_frame, cache->cfa, 1);
return frame_unwind_got_memory (this_frame, regnum, addr);
return frame_unwind_got_constant (this_frame, regnum, addr);
case DWARF2_FRAME_REG_SAVED_VAL_EXP:
- addr = execute_stack_op (cache->reg[regnum].loc.exp,
- cache->reg[regnum].exp_len,
+ addr = execute_stack_op (cache->reg[regnum].loc.exp.start,
+ cache->reg[regnum].loc.exp.len,
cache->addr_size, cache->text_offset,
this_frame, cache->cfa, 1);
return frame_unwind_got_constant (this_frame, regnum, addr);
set_objfile_data (objfile, dwarf2_frame_objfile_data, fde_table2);
}
-/* Provide a prototype to silence -Wmissing-prototypes. */
-void _initialize_dwarf2_frame (void);
-
void
_initialize_dwarf2_frame (void)
{
dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
dwarf2_frame_objfile_data = register_objfile_data ();
+
+#if GDB_SELF_TEST
+ selftests::register_test_foreach_arch ("execute_cfa_program",
+ selftests::execute_cfa_program_test);
+#endif
}
projects / deliverable / binutils-gdb.git / blobdiff