/* Frame unwinder for frames with DWARF Call Frame Information.
- Copyright 2003 Free Software Foundation, Inc.
+ Copyright 2003, 2004, 2005 Free Software Foundation, Inc.
Contributed by Mark Kettenis.
/* Structure describing a frame state. */
-enum dwarf2_reg_rule
-{
- /* Make certain that 0 maps onto the correct enum value; the
- corresponding structure is being initialized using memset zero.
- This indicates that CFI didn't provide any information at all
- about a register, leaving how to obtain its value totally
- unspecified. */
- REG_UNSPECIFIED = 0,
-
- /* The term "undefined" comes from the DWARF2 CFI spec which this
- code is moddeling; it indicates that the register's value is
- "undefined". GCC uses the less formal term "unsaved". Its
- definition is a combination of REG_UNDEFINED and REG_UNSPECIFIED.
- The failure to differentiate the two helps explain a few problems
- with the CFI generated by GCC. */
- REG_UNDEFINED,
- REG_SAVED_OFFSET,
- REG_SAVED_REG,
- REG_SAVED_EXP,
- REG_SAME_VALUE,
-
- /* These aren't defined by the DWARF2 CFI specification, but are
- used internally by GDB. */
- REG_RA, /* Return Address. */
- REG_CFA /* Call Frame Address. */
-};
-
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
- {
- union {
- LONGEST offset;
- ULONGEST reg;
- unsigned char *exp;
- } loc;
- ULONGEST exp_len;
- enum dwarf2_reg_rule 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);
}
no_get_frame_base (void *baton, unsigned char **start, size_t *length)
{
internal_error (__FILE__, __LINE__,
- "Support for DW_OP_fbreg is unimplemented");
+ _("Support for DW_OP_fbreg is unimplemented"));
}
static CORE_ADDR
no_get_tls_address (void *baton, CORE_ADDR offset)
{
internal_error (__FILE__, __LINE__,
- "Support for DW_OP_GNU_push_tls_address is unimplemented");
+ _("Support for DW_OP_GNU_push_tls_address is unimplemented"));
}
static CORE_ADDR
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_UNDEFINED;
+ 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_SAME_VALUE;
+ 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 = REG_SAVED_REG;
+ 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;
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_offset_extended_sf:
insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
- offset += fs->data_align;
+ offset *= 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;
/* 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. */
+ {
+ struct gdbarch *gdbarch = get_frame_arch (next_frame);
+ 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 = read_uleb128 (insn_ptr, insn_end, &utmp);
break;
default:
- internal_error (__FILE__, __LINE__, "Unknown CFI encountered.");
+ internal_error (__FILE__, __LINE__, _("Unknown CFI encountered."));
}
}
}
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
{
/* DWARF Call Frame Address. */
CORE_ADDR cfa;
+ /* Set if the return address column was marked as undefined. */
+ int undefined_retaddr;
+
/* Saved registers, indexed by GDB register number, not by DWARF
register number. */
struct dwarf2_frame_state_reg *reg;
+
+ /* Return address register. */
+ struct dwarf2_frame_state_reg retaddr_reg;
};
static struct dwarf2_frame_cache *
dwarf2_frame_cache (struct frame_info *next_frame, void **this_cache)
{
struct cleanup *old_chain;
+ 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;
break;
default:
- internal_error (__FILE__, __LINE__, "Unknown CFA rule.");
+ internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
}
- /* Initialize the register rules. 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 unwind 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). For those targets we should
- override the defaults given here. */
+ /* Initialize the register state. */
{
int regnum;
for (regnum = 0; regnum < num_regs; regnum++)
- {
- if (regnum == PC_REGNUM)
- cache->reg[regnum].how = REG_RA;
- else if (regnum == SP_REGNUM)
- cache->reg[regnum].how = REG_CFA;
- else
- cache->reg[regnum].how = REG_UNSPECIFIED;
- }
+ dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum]);
}
/* Go through the DWARF2 CFI generated table and save its register
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 == REG_UNSPECIFIED)
- complaint (&symfile_complaints,
- "Incomplete CFI data; unspecified registers at 0x%s",
- paddr (fs->pc));
+ 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 REG_RA rules. */
+ /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
+ we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
{
int regnum;
for (regnum = 0; regnum < num_regs; regnum++)
{
- if (cache->reg[regnum].how == REG_RA)
+ if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
+ || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
{
+ 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. */
+ Incidentally, that's how we should treat a return
+ address column specifying "same value" too. */
if (fs->retaddr_column < fs->regs.num_regs
- && fs->regs.reg[fs->retaddr_column].how != REG_UNSPECIFIED
- && fs->regs.reg[fs->retaddr_column].how != REG_SAME_VALUE)
- cache->reg[regnum] = fs->regs.reg[fs->retaddr_column];
+ && 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] = *retaddr_reg;
+ else
+ cache->retaddr_reg = *retaddr_reg;
+ }
else
{
- cache->reg[regnum].loc.reg = fs->retaddr_column;
- cache->reg[regnum].how = REG_SAVED_REG;
+ if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
+ {
+ 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.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)
+ cache->undefined_retaddr = 1;
+
do_cleanups (old_chain);
*this_cache = cache;
struct dwarf2_frame_cache *cache =
dwarf2_frame_cache (next_frame, this_cache);
+ if (cache->undefined_retaddr)
+ return;
+
(*this_id) = frame_id_build (cache->cfa, frame_func_unwind (next_frame));
}
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_UNDEFINED:
+ 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;
}
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_UNSPECIFIED:
+ 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
"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. */
- frame_register_unwind (next_frame, regnum,
- optimizedp, lvalp, addrp, realnump, valuep);
+ *optimizedp = 0;
+ *lvalp = lval_register;
+ *addrp = 0;
+ *realnump = regnum;
+ if (valuep)
+ frame_unwind_register (next_frame, (*realnump), valuep);
break;
- case REG_SAME_VALUE:
- frame_register_unwind (next_frame, regnum,
- optimizedp, lvalp, addrp, realnump, valuep);
+ 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 REG_CFA:
+ case DWARF2_FRAME_REG_CFA:
*optimizedp = 0;
*lvalp = not_lval;
*addrp = 0;
}
break;
+ case DWARF2_FRAME_REG_RA_OFFSET:
+ *optimizedp = 0;
+ *lvalp = not_lval;
+ *addrp = 0;
+ *realnump = -1;
+ if (valuep)
+ {
+ CORE_ADDR pc = cache->reg[regnum].loc.offset;
+
+ regnum = DWARF2_REG_TO_REGNUM (cache->retaddr_reg.loc.reg);
+ pc += frame_unwind_register_unsigned (next_frame, regnum);
+ store_typed_address (valuep, builtin_type_void_func_ptr, pc);
+ }
+ break;
+
default:
- internal_error (__FILE__, __LINE__, "Unknown register rule.");
+ internal_error (__FILE__, __LINE__, _("Unknown register rule."));
}
}
dwarf2_frame_prev_register
};
+static const struct frame_unwind dwarf2_signal_frame_unwind =
+{
+ SIGTRAMP_FRAME,
+ dwarf2_frame_this_id,
+ dwarf2_frame_prev_register
+};
+
const struct frame_unwind *
dwarf2_frame_sniffer (struct frame_info *next_frame)
{
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 &dwarf2_frame_unwind;
+ if (!dwarf2_frame_find_fde (&block_addr))
+ return NULL;
- 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
/* 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;
bfd_vma tbase;
};
-const struct objfile_data *dwarf2_frame_data;
+const struct objfile_data *dwarf2_frame_objfile_data;
static unsigned int
read_1_byte (bfd *bfd, char *buf)
case 8:
return DW_EH_PE_udata8;
default:
- internal_error (__FILE__, __LINE__, "Unsupported address size");
+ internal_error (__FILE__, __LINE__, _("Unsupported address size"));
}
}
case DW_EH_PE_udata8:
return 8;
default:
- internal_error (__FILE__, __LINE__, "Invalid or unsupported encoding");
+ internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
}
}
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;
FDE's. */
if (encoding & DW_EH_PE_indirect)
internal_error (__FILE__, __LINE__,
- "Unsupported encoding: DW_EH_PE_indirect");
+ _("Unsupported encoding: DW_EH_PE_indirect"));
*bytes_read_ptr = 0;
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;
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 = buf - unit->dwarf_frame_buffer;
+ offset = (char *) buf - unit->dwarf_frame_buffer;
if ((offset % ptr_len) != 0)
{
*bytes_read_ptr = ptr_len - (offset % ptr_len);
}
break;
default:
- internal_error (__FILE__, __LINE__, "Invalid or unsupported encoding");
+ internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
}
- if ((encoding & 0x0f) == 0x00)
+ 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;
return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
case DW_EH_PE_udata8:
*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;
return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
*bytes_read_ptr += 8;
return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
default:
- internal_error (__FILE__, __LINE__, "Invalid or unsupported encoding");
+ internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
}
}
\f
struct dwarf2_fde *fde;
CORE_ADDR offset;
- fde = objfile_data (objfile, dwarf2_frame_data);
+ fde = objfile_data (objfile, dwarf2_frame_objfile_data);
if (fde == NULL)
continue;
static void
add_fde (struct comp_unit *unit, struct dwarf2_fde *fde)
{
- fde->next = objfile_data (unit->objfile, dwarf2_frame_data);
- set_objfile_data (unit->objfile, dwarf2_frame_data, 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
/* 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. */
- if (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;
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;
cie->saw_z_augmentation = (*augmentation == 'z');
if (cie->saw_z_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++;
}
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)
case ALIGN4:
complaint (&symfile_complaints,
- "Corrupt data in %s:%s; align 4 workaround apparently succeeded",
+ _("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",
+ _("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",
+ _("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
/* 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;
unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
dwarf_eh_frame_section);
- unit.dwarf_frame_size
- = bfd_get_section_size_before_reloc (dwarf_eh_frame_section);
+ 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
unit.cie = NULL;
unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
dwarf_frame_section);
- unit.dwarf_frame_size
- = bfd_get_section_size_before_reloc (dwarf_frame_section);
+ unit.dwarf_frame_size = bfd_get_section_size (dwarf_frame_section);
unit.dwarf_frame_section = dwarf_frame_section;
frame_ptr = unit.dwarf_frame_buffer;
void
_initialize_dwarf2_frame (void)
{
- dwarf2_frame_data = register_objfile_data ();
+ dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
+ dwarf2_frame_objfile_data = register_objfile_data ();
}