/* Frame unwinder for frames with DWARF Call Frame Information.
- Copyright 2003 Free Software Foundation, Inc.
+ Copyright 2003, 2004 Free Software Foundation, Inc.
Contributed by Mark Kettenis.
#include "gdb_assert.h"
#include "gdb_string.h"
+#include "complaints.h"
#include "dwarf2-frame.h"
/* Call Frame Information (CFI). */
/* Encoding of addresses. */
unsigned char encoding;
+ /* True if a 'z' augmentation existed. */
+ unsigned char saw_z_augmentation;
+
struct dwarf2_cie *next;
};
another register, or a location expression. */
struct dwarf2_frame_state_reg_info
{
- struct dwarf2_frame_state_reg
- {
- union {
- LONGEST offset;
- ULONGEST reg;
- unsigned char *exp;
- } loc;
- ULONGEST exp_len;
- enum {
- REG_UNSAVED,
- REG_SAVED_OFFSET,
- REG_SAVED_REG,
- REG_SAVED_EXP,
- REG_UNMODIFIED
- } how;
- } *reg;
+ struct dwarf2_frame_state_reg *reg;
int num_regs;
/* Used to implement DW_CFA_remember_state. */
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_info);
+ 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);
read_reg (void *baton, int reg)
{
struct frame_info *next_frame = (struct frame_info *) baton;
+ struct gdbarch *gdbarch = get_frame_arch (next_frame);
int regnum;
char *buf;
regnum = DWARF2_REG_TO_REGNUM (reg);
- buf = (char *) alloca (register_size (current_gdbarch, regnum));
+ buf = (char *) alloca (register_size (gdbarch, regnum));
frame_unwind_register (next_frame, regnum, buf);
return extract_typed_address (buf, builtin_type_void_data_ptr);
}
insn_ptr = 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 = REG_SAVED_OFFSET;
+ fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
fs->regs.reg[reg].loc.offset = offset;
}
else if ((insn & 0xc0) == DW_CFA_restore)
insn_ptr = 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 = REG_SAVED_OFFSET;
+ fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
fs->regs.reg[reg].loc.offset = offset;
break;
case DW_CFA_undefined:
insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
- fs->regs.reg[reg].how = REG_UNSAVED;
+ fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
break;
case DW_CFA_same_value:
insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
- fs->regs.reg[reg].how = REG_UNMODIFIED;
+ fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
break;
case DW_CFA_register:
insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
dwarf2_frame_state_alloc_regs (&fs->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 *old_rs = fs->regs.prev;
- gdb_assert (old_rs);
-
- xfree (fs->regs.reg);
- fs->regs = *old_rs;
- xfree (old_rs);
+ if (old_rs == NULL)
+ {
+ complaint (&symfile_complaints, "\
+bad CFI data; mismatched DW_CFA_restore_state at 0x%s", paddr (fs->pc));
+ }
+ else
+ {
+ xfree (fs->regs.reg);
+ fs->regs = *old_rs;
+ xfree (old_rs);
+ }
}
break;
/* cfa_how deliberately not set. */
break;
+ case DW_CFA_nop:
+ break;
+
case DW_CFA_def_cfa_expression:
insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_exp_len);
fs->cfa_exp = insn_ptr;
insn_ptr = 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].how = REG_SAVED_EXP;
+ fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP;
insn_ptr += utmp;
break;
- case DW_CFA_nop:
+ case DW_CFA_offset_extended_sf:
+ insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
+ insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
+ offset *= 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;
+ break;
+
+ case DW_CFA_def_cfa_sf:
+ insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
+ insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
+ fs->cfa_offset = offset * fs->data_align;
+ fs->cfa_how = CFA_REG_OFFSET;
+ break;
+
+ case DW_CFA_def_cfa_offset_sf:
+ insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
+ fs->cfa_offset = offset * fs->data_align;
+ /* cfa_how deliberately not set. */
break;
case DW_CFA_GNU_args_size:
dwarf2_frame_state_free_regs (fs->regs.prev);
fs->regs.prev = NULL;
}
+\f
+
+/* Architecture-specific operations. */
+
+/* Per-architecture data key. */
+static struct gdbarch_data *dwarf2_frame_data;
+
+struct dwarf2_frame_ops
+{
+ /* Pre-initialize the register state REG for register REGNUM. */
+ void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *);
+
+ /* Check whether the frame preceding NEXT_FRAME will be a signal
+ trampoline. */
+ int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
+};
+
+/* Default architecture-specific register state initialization
+ function. */
+
+static void
+dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
+ struct dwarf2_frame_state_reg *reg)
+{
+ /* If we have a register that acts as a program counter, mark it as
+ a destination for the return address. If we have a register that
+ serves as the stack pointer, arrange for it to be filled with the
+ call frame address (CFA). The other registers are marked as
+ unspecified.
+
+ We copy the return address to the program counter, since many
+ parts in GDB assume that it is possible to get the return address
+ by unwinding the program counter register. However, on ISA's
+ with a dedicated return address register, the CFI usually only
+ contains information to unwind that return address register.
+
+ The reason we're treating the stack pointer special here is
+ because in many cases GCC doesn't emit CFI for the stack pointer
+ and implicitly assumes that it is equal to the CFA. This makes
+ some sense since the DWARF specification (version 3, draft 8,
+ p. 102) says that:
+
+ "Typically, the CFA is defined to be the value of the stack
+ pointer at the call site in the previous frame (which may be
+ different from its value on entry to the current frame)."
+
+ However, this isn't true for all platforms supported by GCC
+ (e.g. IBM S/390 and zSeries). Those architectures should provide
+ their own architecture-specific initialization function. */
+
+ if (regnum == PC_REGNUM)
+ reg->how = DWARF2_FRAME_REG_RA;
+ else if (regnum == SP_REGNUM)
+ reg->how = DWARF2_FRAME_REG_CFA;
+}
+
+/* Return a default for the architecture-specific operations. */
+
+static void *
+dwarf2_frame_init (struct obstack *obstack)
+{
+ struct dwarf2_frame_ops *ops;
+
+ ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops);
+ ops->init_reg = dwarf2_frame_default_init_reg;
+ return ops;
+}
+
+/* Set the architecture-specific register state initialization
+ function for GDBARCH to INIT_REG. */
+
+void
+dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
+ void (*init_reg) (struct gdbarch *, int,
+ struct dwarf2_frame_state_reg *))
+{
+ struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
+
+ ops->init_reg = init_reg;
+}
+
+/* Pre-initialize the register state REG for register REGNUM. */
+
+static void
+dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
+ struct dwarf2_frame_state_reg *reg)
+{
+ struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
+
+ ops->init_reg (gdbarch, regnum, reg);
+}
+
+/* Set the architecture-specific signal trampoline recognition
+ function for GDBARCH to SIGNAL_FRAME_P. */
+
+void
+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);
+
+ ops->signal_frame_p = signal_frame_p;
+}
+
+/* Query the architecture-specific signal frame recognizer for
+ NEXT_FRAME. */
+
+static int
+dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
+ struct frame_info *next_frame)
+{
+ struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
+
+ if (ops->signal_frame_p == NULL)
+ return 0;
+ return ops->signal_frame_p (gdbarch, next_frame);
+}
+\f
struct dwarf2_frame_cache
{
struct dwarf2_frame_state_reg *reg;
};
-struct dwarf2_frame_cache *
+static struct dwarf2_frame_cache *
dwarf2_frame_cache (struct frame_info *next_frame, void **this_cache)
{
struct cleanup *old_chain;
- int num_regs = NUM_REGS + NUM_PSEUDO_REGS;
+ struct gdbarch *gdbarch = get_frame_arch (next_frame);
+ const int num_regs = NUM_REGS + NUM_PSEUDO_REGS;
struct dwarf2_frame_cache *cache;
struct dwarf2_frame_state *fs;
struct dwarf2_fde *fde;
- int reg;
if (*this_cache)
return *this_cache;
to abort), the compiler might optimize away the instruction at
NEXT_FRAME's return address. As a result the return address will
point at some random instruction, and the CFI for that
- instruction is probably wortless to us. GCC's unwinder solves
+ instruction is probably worthless to us. GCC's unwinder solves
this problem by substracting 1 from the return address to get an
address in the middle of a presumed call instruction (or the
instruction in the associated delay slot). This should only be
done for "normal" frames and not for resume-type frames (signal
- handlers, sentinel frames, dummy frames).
-
- We don't do what GCC's does here (yet). It's not clear how
- reliable the method is. There's also a problem with finding the
- right FDE; see the comment in dwarf_frame_p. If dwarf_frame_p
- selected this frame unwinder because it found the FDE for the
- next function, using the adjusted return address might not yield
- a FDE at all. The problem isn't specific to DWARF CFI; other
- unwinders loose in similar ways. Therefore it's probably
- acceptable to leave things slightly broken for now. */
- fs->pc = frame_pc_unwind (next_frame);
+ handlers, sentinel frames, dummy frames). The function
+ frame_unwind_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 = frame_unwind_address_in_block (next_frame);
/* Find the correct FDE. */
fde = dwarf2_frame_find_fde (&fs->pc);
internal_error (__FILE__, __LINE__, "Unknown CFA rule.");
}
- /* Save the register info in the cache. */
- for (reg = 0; reg < fs->regs.num_regs; reg++)
- {
- int regnum;
-
- /* Skip the return address column. */
- if (reg == fs->retaddr_column)
- continue;
-
- /* Use the GDB register number as index. */
- regnum = DWARF2_REG_TO_REGNUM (reg);
-
- if (regnum >= 0 && regnum < num_regs)
- cache->reg[regnum] = fs->regs.reg[reg];
- }
-
- /* Store the location of the return addess. If the return address
- column (adjusted) is not the same as gdb's PC_REGNUM, then this
- implies a copy from the ra column register. */
- if (fs->retaddr_column < fs->regs.num_regs
- && fs->regs.reg[fs->retaddr_column].how != REG_UNSAVED)
- cache->reg[PC_REGNUM] = fs->regs.reg[fs->retaddr_column];
- else
- {
- reg = DWARF2_REG_TO_REGNUM (fs->retaddr_column);
- if (reg != PC_REGNUM)
- {
- cache->reg[PC_REGNUM].loc.reg = reg;
- cache->reg[PC_REGNUM].how = REG_SAVED_REG;
- }
- }
+ /* Initialize the register state. */
+ {
+ int regnum;
+
+ for (regnum = 0; regnum < num_regs; regnum++)
+ dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum]);
+ }
+
+ /* 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,
+ DWARF2_REG_TO_REGNUM should be defined to return a number outside
+ the range [0, NUM_REGS). */
+ {
+ 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 = DWARF2_REG_TO_REGNUM (column);
+
+ /* If there's no corresponding GDB register, ignore it. */
+ if (regnum < 0 || regnum >= num_regs)
+ continue;
+
+ /* NOTE: cagney/2003-09-05: CFI should specify the disposition
+ of all debug info registers. If it doesn't, complain (but
+ not too loudly). It turns out that GCC assumes that an
+ unspecified register implies "same value" when CFI (draft
+ 7) specifies nothing at all. Such a register could equally
+ be interpreted as "undefined". Also note that this check
+ isn't sufficient; it only checks that all registers in the
+ range [0 .. max column] are specified, and won't detect
+ 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 (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
+ complaint (&symfile_complaints, "\
+incomplete CFI data; unspecified registers (e.g., %s) at 0x%s",
+ gdbarch_register_name (gdbarch, regnum),
+ paddr_nz (fs->pc));
+ }
+ else
+ cache->reg[regnum] = fs->regs.reg[column];
+ }
+ }
+
+ /* Eliminate any DWARF2_FRAME_REG_RA rules. */
+ {
+ int regnum;
+
+ for (regnum = 0; regnum < num_regs; regnum++)
+ {
+ if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
+ {
+ struct dwarf2_frame_state_reg *retaddr_reg =
+ &fs->regs.reg[fs->retaddr_column];
+
+ /* It seems rather bizarre to specify an "empty" column as
+ the return adress column. However, this is exactly
+ what GCC does on some targets. It turns out that GCC
+ assumes that the return address can be found in the
+ register corresponding to the return address column.
+ Incidentally, that's how should treat a return address
+ column specifying "same value" too. */
+ if (fs->retaddr_column < fs->regs.num_regs
+ && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
+ && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
+ cache->reg[regnum] = *retaddr_reg;
+ else
+ {
+ cache->reg[regnum].loc.reg = fs->retaddr_column;
+ cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
+ }
+ }
+ }
+ }
do_cleanups (old_chain);
enum lval_type *lvalp, CORE_ADDR *addrp,
int *realnump, void *valuep)
{
+ struct gdbarch *gdbarch = get_frame_arch (next_frame);
struct dwarf2_frame_cache *cache =
dwarf2_frame_cache (next_frame, this_cache);
switch (cache->reg[regnum].how)
{
- case REG_UNSAVED:
+ case DWARF2_FRAME_REG_UNDEFINED:
+ /* If CFI explicitly specified that the value isn't defined,
+ mark it as optimized away; the value isn't available. */
*optimizedp = 1;
*lvalp = not_lval;
*addrp = 0;
*realnump = -1;
- if (regnum == SP_REGNUM)
- {
- /* GCC defines the CFA as the value of the stack pointer
- just before the call instruction is executed. Do other
- compilers use the same definition? */
- *optimizedp = 0;
- if (valuep)
- {
- /* Store the value. */
- store_typed_address (valuep, builtin_type_void_data_ptr,
- cache->cfa);
- }
- }
- else if (valuep)
+ if (valuep)
{
/* In some cases, for example %eflags on the i386, we have
to provide a sane value, even though this register wasn't
}
break;
- case REG_SAVED_OFFSET:
+ case DWARF2_FRAME_REG_SAVED_OFFSET:
*optimizedp = 0;
*lvalp = lval_memory;
*addrp = cache->cfa + cache->reg[regnum].loc.offset;
if (valuep)
{
/* Read the value in from memory. */
- read_memory (*addrp, valuep,
- register_size (current_gdbarch, regnum));
+ read_memory (*addrp, valuep, register_size (gdbarch, regnum));
}
break;
- case REG_SAVED_REG:
- regnum = DWARF2_REG_TO_REGNUM (cache->reg[regnum].loc.reg);
- frame_register_unwind (next_frame, regnum,
- optimizedp, lvalp, addrp, realnump, valuep);
+ case DWARF2_FRAME_REG_SAVED_REG:
+ *optimizedp = 0;
+ *lvalp = lval_register;
+ *addrp = 0;
+ *realnump = DWARF2_REG_TO_REGNUM (cache->reg[regnum].loc.reg);
+ if (valuep)
+ frame_unwind_register (next_frame, (*realnump), valuep);
break;
- case REG_SAVED_EXP:
+ case DWARF2_FRAME_REG_SAVED_EXP:
*optimizedp = 0;
*lvalp = lval_memory;
*addrp = execute_stack_op (cache->reg[regnum].loc.exp,
if (valuep)
{
/* Read the value in from memory. */
- read_memory (*addrp, valuep,
- register_size (current_gdbarch, regnum));
+ read_memory (*addrp, valuep, register_size (gdbarch, regnum));
}
break;
- case REG_UNMODIFIED:
- frame_register_unwind (next_frame, regnum,
- optimizedp, lvalp, addrp, realnump, valuep);
+ case DWARF2_FRAME_REG_UNSPECIFIED:
+ /* GCC, in its infinite wisdom decided to not provide unwind
+ information for registers that are "same value". Since
+ DWARF2 (3 draft 7) doesn't define such behavior, said
+ registers are actually undefined (which is different to CFI
+ "undefined"). Code above issues a complaint about this.
+ Here just fudge the books, assume GCC, and that the value is
+ more inner on the stack. */
+ *optimizedp = 0;
+ *lvalp = lval_register;
+ *addrp = 0;
+ *realnump = regnum;
+ if (valuep)
+ frame_unwind_register (next_frame, (*realnump), valuep);
+ break;
+
+ case DWARF2_FRAME_REG_SAME_VALUE:
+ *optimizedp = 0;
+ *lvalp = lval_register;
+ *addrp = 0;
+ *realnump = regnum;
+ if (valuep)
+ frame_unwind_register (next_frame, (*realnump), valuep);
+ break;
+
+ case DWARF2_FRAME_REG_CFA:
+ *optimizedp = 0;
+ *lvalp = not_lval;
+ *addrp = 0;
+ *realnump = -1;
+ if (valuep)
+ {
+ /* Store the value. */
+ store_typed_address (valuep, builtin_type_void_data_ptr, cache->cfa);
+ }
break;
default:
dwarf2_frame_prev_register
};
-const struct frame_unwind *
-dwarf2_frame_p (CORE_ADDR pc)
+static const struct frame_unwind dwarf2_signal_frame_unwind =
{
- /* The way GDB works, this function can be called with PC just after
- the last instruction of the function we're supposed to return the
- unwind methods for. In that case we won't find the correct FDE;
- instead we find the FDE for the next function, or we won't find
- an FDE at all. There is a possible solution (see the comment in
- dwarf2_frame_cache), GDB doesn't pass us enough information to
- implement it. */
- if (dwarf2_frame_find_fde (&pc))
- return &dwarf2_frame_unwind;
+ SIGTRAMP_FRAME,
+ dwarf2_frame_this_id,
+ dwarf2_frame_prev_register
+};
- return NULL;
+const struct frame_unwind *
+dwarf2_frame_sniffer (struct frame_info *next_frame)
+{
+ /* Grab an address that is guarenteed to reside somewhere within the
+ function. frame_pc_unwind(), for a no-return next function, can
+ end up returning something past the end of this function's body. */
+ CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame);
+ if (!dwarf2_frame_find_fde (&block_addr))
+ return NULL;
+
+ /* On some targets, signal trampolines may have unwind information.
+ We need to recognize them so that we set the frame type
+ correctly. */
+
+ if (dwarf2_frame_signal_frame_p (get_frame_arch (next_frame),
+ next_frame))
+ return &dwarf2_signal_frame_unwind;
+
+ return &dwarf2_frame_unwind;
}
\f
};
const struct frame_base *
-dwarf2_frame_base_p (CORE_ADDR pc)
+dwarf2_frame_base_sniffer (struct frame_info *next_frame)
{
+ CORE_ADDR pc = frame_pc_unwind (next_frame);
if (dwarf2_frame_find_fde (&pc))
return &dwarf2_frame_base;
/* Linked list of CIEs for this object. */
struct dwarf2_cie *cie;
- /* Address size for this unit - from unit header. */
- unsigned char addr_size;
-
/* Pointer to the .debug_frame section loaded into memory. */
char *dwarf_frame_buffer;
/* Pointer to the .debug_frame section. */
asection *dwarf_frame_section;
+
+ /* Base for DW_EH_PE_datarel encodings. */
+ bfd_vma dbase;
+
+ /* Base for DW_EH_PE_textrel encodings. */
+ bfd_vma tbase;
};
+const struct objfile_data *dwarf2_frame_objfile_data;
+
static unsigned int
read_1_byte (bfd *bfd, char *buf)
{
static CORE_ADDR
read_encoded_value (struct comp_unit *unit, unsigned char encoding,
- char *buf, unsigned int *bytes_read_ptr)
+ unsigned char *buf, unsigned int *bytes_read_ptr)
{
+ int ptr_len = size_of_encoded_value (DW_EH_PE_absptr);
+ ptrdiff_t offset;
CORE_ADDR base;
/* GCC currently doesn't generate DW_EH_PE_indirect encodings for
internal_error (__FILE__, __LINE__,
"Unsupported encoding: DW_EH_PE_indirect");
+ *bytes_read_ptr = 0;
+
switch (encoding & 0x70)
{
case DW_EH_PE_absptr:
break;
case DW_EH_PE_pcrel:
base = bfd_get_section_vma (unit->bfd, unit->dwarf_frame_section);
- base += (buf - unit->dwarf_frame_buffer);
+ base += ((char *) buf - unit->dwarf_frame_buffer);
+ break;
+ case DW_EH_PE_datarel:
+ base = unit->dbase;
+ break;
+ case DW_EH_PE_textrel:
+ base = unit->tbase;
+ break;
+ case DW_EH_PE_funcrel:
+ /* FIXME: kettenis/20040501: For now just pretend
+ DW_EH_PE_funcrel is equivalent to DW_EH_PE_absptr. For
+ reading the initial location of an FDE it should be treated
+ as such, and currently that's the only place where this code
+ is used. */
+ base = 0;
+ break;
+ case DW_EH_PE_aligned:
+ base = 0;
+ offset = (char *) buf - unit->dwarf_frame_buffer;
+ if ((offset % ptr_len) != 0)
+ {
+ *bytes_read_ptr = ptr_len - (offset % ptr_len);
+ buf += *bytes_read_ptr;
+ }
break;
default:
internal_error (__FILE__, __LINE__, "Invalid or unsupported encoding");
}
- if ((encoding & 0x0f) == 0x00)
- encoding |= encoding_for_size (TYPE_LENGTH(builtin_type_void_data_ptr));
+ if ((encoding & 0x07) == 0x00)
+ encoding |= encoding_for_size (ptr_len);
switch (encoding & 0x0f)
{
+ case DW_EH_PE_uleb128:
+ {
+ ULONGEST value;
+ unsigned char *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
+ *bytes_read_ptr += read_uleb128 (buf, end_buf, &value) - buf;
+ return base + value;
+ }
case DW_EH_PE_udata2:
- *bytes_read_ptr = 2;
+ *bytes_read_ptr += 2;
return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
case DW_EH_PE_udata4:
- *bytes_read_ptr = 4;
+ *bytes_read_ptr += 4;
return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
case DW_EH_PE_udata8:
- *bytes_read_ptr = 8;
+ *bytes_read_ptr += 8;
return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
+ case DW_EH_PE_sleb128:
+ {
+ LONGEST value;
+ char *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
+ *bytes_read_ptr += read_sleb128 (buf, end_buf, &value) - buf;
+ return base + value;
+ }
case DW_EH_PE_sdata2:
- *bytes_read_ptr = 2;
+ *bytes_read_ptr += 2;
return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
case DW_EH_PE_sdata4:
- *bytes_read_ptr = 4;
+ *bytes_read_ptr += 4;
return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
case DW_EH_PE_sdata8:
- *bytes_read_ptr = 8;
+ *bytes_read_ptr += 8;
return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
default:
internal_error (__FILE__, __LINE__, "Invalid or unsupported encoding");
struct dwarf2_fde *fde;
CORE_ADDR offset;
+ fde = objfile_data (objfile, dwarf2_frame_objfile_data);
+ if (fde == NULL)
+ continue;
+
+ gdb_assert (objfile->section_offsets);
offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
-
- fde = objfile->sym_private;
+
while (fde)
{
if (*pc >= fde->initial_location + offset
static void
add_fde (struct comp_unit *unit, struct dwarf2_fde *fde)
{
- fde->next = unit->objfile->sym_private;
- unit->objfile->sym_private = fde;
+ fde->next = objfile_data (unit->objfile, dwarf2_frame_objfile_data);
+ set_objfile_data (unit->objfile, dwarf2_frame_objfile_data, fde);
}
#ifdef CC_HAS_LONG_LONG
#define DW64_CIE_ID ~0
#endif
-/* Read a CIE or FDE in BUF and decode it. */
+static char *decode_frame_entry (struct comp_unit *unit, char *start,
+ int eh_frame_p);
+/* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
+ the next byte to be processed. */
static char *
-decode_frame_entry (struct comp_unit *unit, char *buf, int eh_frame_p)
+decode_frame_entry_1 (struct comp_unit *unit, char *start, int eh_frame_p)
{
+ char *buf;
LONGEST length;
unsigned int bytes_read;
- int dwarf64_p = 0;
- ULONGEST cie_id = DW_CIE_ID;
+ int dwarf64_p;
+ ULONGEST cie_id;
ULONGEST cie_pointer;
- char *start = buf;
char *end;
+ buf = start;
length = read_initial_length (unit->abfd, buf, &bytes_read);
buf += bytes_read;
end = buf + length;
+ /* Are we still within the section? */
+ if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
+ return NULL;
+
if (length == 0)
return end;
- if (bytes_read == 12)
- dwarf64_p = 1;
+ /* Distinguish between 32 and 64-bit encoded frame info. */
+ dwarf64_p = (bytes_read == 12);
- /* In a .eh_frame section, zero is used to distinguish CIEs from
- FDEs. */
+ /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
if (eh_frame_p)
cie_id = 0;
else if (dwarf64_p)
cie_id = DW64_CIE_ID;
+ else
+ cie_id = DW_CIE_ID;
if (dwarf64_p)
{
/* This is a CIE. */
struct dwarf2_cie *cie;
char *augmentation;
+ unsigned int cie_version;
/* Record the offset into the .debug_frame section of this CIE. */
cie_pointer = start - unit->dwarf_frame_buffer;
return end;
cie = (struct dwarf2_cie *)
- obstack_alloc (&unit->objfile->psymbol_obstack,
+ obstack_alloc (&unit->objfile->objfile_obstack,
sizeof (struct dwarf2_cie));
cie->initial_instructions = NULL;
cie->cie_pointer = cie_pointer;
/* The encoding for FDE's in a normal .debug_frame section
- depends on the target address size as specified in the
- Compilation Unit Header. */
- cie->encoding = encoding_for_size (unit->addr_size);
+ depends on the target address size. */
+ cie->encoding = DW_EH_PE_absptr;
/* Check version number. */
- gdb_assert (read_1_byte (unit->abfd, buf) == DW_CIE_VERSION);
+ cie_version = read_1_byte (unit->abfd, buf);
+ if (cie_version != 1 && cie_version != 3)
+ return NULL;
buf += 1;
/* Interpret the interesting bits of the augmentation. */
read_signed_leb128 (unit->abfd, buf, &bytes_read);
buf += bytes_read;
- cie->return_address_register = read_1_byte (unit->abfd, buf);
- buf += 1;
+ if (cie_version == 1)
+ {
+ cie->return_address_register = read_1_byte (unit->abfd, buf);
+ bytes_read = 1;
+ }
+ else
+ cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
+ &bytes_read);
+ buf += bytes_read;
- if (*augmentation == 'z')
+ cie->saw_z_augmentation = (*augmentation == 'z');
+ if (cie->saw_z_augmentation)
{
ULONGEST length;
length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
buf += bytes_read;
+ if (buf > end)
+ return NULL;
cie->initial_instructions = buf + length;
augmentation++;
}
/* "P" indicates a personality routine in the CIE augmentation. */
else if (*augmentation == 'P')
{
- /* Skip. */
- buf += size_of_encoded_value (*buf++);
+ /* Skip. Avoid indirection since we throw away the result. */
+ unsigned char encoding = (*buf++) & ~DW_EH_PE_indirect;
+ read_encoded_value (unit, encoding, buf, &bytes_read);
+ buf += bytes_read;
augmentation++;
}
/* This is a FDE. */
struct dwarf2_fde *fde;
+ /* In an .eh_frame section, the CIE pointer is the delta between the
+ address within the FDE where the CIE pointer is stored and the
+ address of the CIE. Convert it to an offset into the .eh_frame
+ section. */
if (eh_frame_p)
{
- /* In an .eh_frame section, the CIE pointer is the delta
- between the address within the FDE where the CIE pointer
- is stored and the address of the CIE. Convert it to an
- offset into the .eh_frame section. */
cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
cie_pointer -= (dwarf64_p ? 8 : 4);
}
+ /* In either case, validate the result is still within the section. */
+ if (cie_pointer >= unit->dwarf_frame_size)
+ return NULL;
+
fde = (struct dwarf2_fde *)
- obstack_alloc (&unit->objfile->psymbol_obstack,
+ obstack_alloc (&unit->objfile->objfile_obstack,
sizeof (struct dwarf2_fde));
fde->cie = find_cie (unit, cie_pointer);
if (fde->cie == NULL)
read_encoded_value (unit, fde->cie->encoding & 0x0f, buf, &bytes_read);
buf += bytes_read;
+ /* A 'z' augmentation in the CIE implies the presence of an
+ augmentation field in the FDE as well. The only thing known
+ to be in here at present is the LSDA entry for EH. So we
+ can skip the whole thing. */
+ if (fde->cie->saw_z_augmentation)
+ {
+ ULONGEST length;
+
+ length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
+ buf += bytes_read + length;
+ if (buf > end)
+ return NULL;
+ }
+
fde->instructions = buf;
fde->end = end;
return end;
}
+
+/* Read a CIE or FDE in BUF and decode it. */
+static char *
+decode_frame_entry (struct comp_unit *unit, char *start, int eh_frame_p)
+{
+ enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
+ char *ret;
+ const char *msg;
+ ptrdiff_t start_offset;
+
+ while (1)
+ {
+ ret = decode_frame_entry_1 (unit, start, eh_frame_p);
+ if (ret != NULL)
+ break;
+
+ /* We have corrupt input data of some form. */
+
+ /* ??? Try, weakly, to work around compiler/assembler/linker bugs
+ and mismatches wrt padding and alignment of debug sections. */
+ /* Note that there is no requirement in the standard for any
+ alignment at all in the frame unwind sections. Testing for
+ alignment before trying to interpret data would be incorrect.
+
+ However, GCC traditionally arranged for frame sections to be
+ sized such that the FDE length and CIE fields happen to be
+ aligned (in theory, for performance). This, unfortunately,
+ was done with .align directives, which had the side effect of
+ forcing the section to be aligned by the linker.
+
+ This becomes a problem when you have some other producer that
+ creates frame sections that are not as strictly aligned. That
+ produces a hole in the frame info that gets filled by the
+ linker with zeros.
+
+ The GCC behaviour is arguably a bug, but it's effectively now
+ part of the ABI, so we're now stuck with it, at least at the
+ object file level. A smart linker may decide, in the process
+ of compressing duplicate CIE information, that it can rewrite
+ the entire output section without this extra padding. */
+
+ start_offset = start - unit->dwarf_frame_buffer;
+ if (workaround < ALIGN4 && (start_offset & 3) != 0)
+ {
+ start += 4 - (start_offset & 3);
+ workaround = ALIGN4;
+ continue;
+ }
+ if (workaround < ALIGN8 && (start_offset & 7) != 0)
+ {
+ start += 8 - (start_offset & 7);
+ workaround = ALIGN8;
+ continue;
+ }
+
+ /* Nothing left to try. Arrange to return as if we've consumed
+ the entire input section. Hopefully we'll get valid info from
+ the other of .debug_frame/.eh_frame. */
+ workaround = FAIL;
+ ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
+ break;
+ }
+
+ switch (workaround)
+ {
+ case NONE:
+ break;
+
+ case ALIGN4:
+ complaint (&symfile_complaints,
+ "Corrupt data in %s:%s; align 4 workaround apparently succeeded",
+ unit->dwarf_frame_section->owner->filename,
+ unit->dwarf_frame_section->name);
+ break;
+
+ case ALIGN8:
+ complaint (&symfile_complaints,
+ "Corrupt data in %s:%s; align 8 workaround apparently succeeded",
+ unit->dwarf_frame_section->owner->filename,
+ unit->dwarf_frame_section->name);
+ break;
+
+ default:
+ complaint (&symfile_complaints,
+ "Corrupt data in %s:%s",
+ unit->dwarf_frame_section->owner->filename,
+ unit->dwarf_frame_section->name);
+ break;
+ }
+
+ return ret;
+}
\f
/* FIXME: kettenis/20030504: This still needs to be integrated with
dwarf2read.c in a better way. */
/* Imported from dwarf2read.c. */
-extern file_ptr dwarf_frame_offset;
-extern unsigned int dwarf_frame_size;
extern asection *dwarf_frame_section;
-extern file_ptr dwarf_eh_frame_offset;
-extern unsigned int dwarf_eh_frame_size;
extern asection *dwarf_eh_frame_section;
/* Imported from dwarf2read.c. */
-extern char *dwarf2_read_section (struct objfile *objfile, file_ptr offset,
- unsigned int size, asection *sectp);
+extern char *dwarf2_read_section (struct objfile *objfile, asection *sectp);
void
dwarf2_build_frame_info (struct objfile *objfile)
/* Build a minimal decoding of the DWARF2 compilation unit. */
unit.abfd = objfile->obfd;
unit.objfile = objfile;
- unit.addr_size = objfile->obfd->arch_info->bits_per_address / 8;
+ unit.dbase = 0;
+ unit.tbase = 0;
/* First add the information from the .eh_frame section. That way,
the FDEs from that section are searched last. */
- if (dwarf_eh_frame_offset)
+ if (dwarf_eh_frame_section)
{
+ asection *got, *txt;
+
unit.cie = NULL;
unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
- dwarf_eh_frame_offset,
- dwarf_eh_frame_size,
dwarf_eh_frame_section);
- unit.dwarf_frame_size = dwarf_eh_frame_size;
+ unit.dwarf_frame_size = bfd_get_section_size (dwarf_eh_frame_section);
unit.dwarf_frame_section = dwarf_eh_frame_section;
+ /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
+ that is used for the i386/amd64 target, which currently is
+ the only target in GCC that supports/uses the
+ DW_EH_PE_datarel encoding. */
+ got = bfd_get_section_by_name (unit.abfd, ".got");
+ if (got)
+ unit.dbase = got->vma;
+
+ /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
+ so far. */
+ txt = bfd_get_section_by_name (unit.abfd, ".text");
+ if (txt)
+ unit.tbase = txt->vma;
+
frame_ptr = unit.dwarf_frame_buffer;
while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size)
frame_ptr = decode_frame_entry (&unit, frame_ptr, 1);
}
- if (dwarf_frame_offset)
+ if (dwarf_frame_section)
{
unit.cie = NULL;
unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
- dwarf_frame_offset,
- dwarf_frame_size,
dwarf_frame_section);
- unit.dwarf_frame_size = dwarf_frame_size;
+ unit.dwarf_frame_size = bfd_get_section_size (dwarf_frame_section);
unit.dwarf_frame_section = dwarf_frame_section;
frame_ptr = unit.dwarf_frame_buffer;
frame_ptr = decode_frame_entry (&unit, frame_ptr, 0);
}
}
+
+/* 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 ();
+}