"const gdb_byte *".
(struct dwarf2_fde): Make instructions, end "const gdb_byte *".
(execute_cfa_program): Update to match API of leb128 functions.
(read_1_byte, read_4_bytes, read_8_bytes): Make buf parameter
"const gdb_byte *".
(read_unsigned_leb128, read_signed_leb128): Delete.
(read_initial_length): Change type of buf argument to
"const gdb_byte *".
(read_encoded_value): Update to match API of leb128 functions.
(decode_frame_entry): Change result to "const gdb_byte *", and
similarly for "start" parameter.
(decode_frame_entry_1): Ditto. Use new leb128 reader functions.
(dwarf2_build_frame_info): Change local frame_ptr to
"const gdb_byte *".
* dwarf2expr.c (safe_read_uleb128, safe_read_sleb128): Replaces
read_uleb128, read_sleb128. All callers updated.
(safe_skip_leb128): New function.
(dwarf_block_to_dwarf_reg): Update to match API of leb128 functions.
Call gdb_read_uleb128, gdb_skip_leb128 instead of read_uleb128.
(dwarf_block_to_dwarf_reg_deref): Update to match API of leb128
functions. Call gdb_read_uleb128, gdb_read_sleb128 instead of
read_uleb128, read_sleb128.
(dwarf_block_to_fb_offset, dwarf_block_to_sp_offset): Ditto.
(execute_stack_op): Update to match API of leb128 functions.
* dwarf2expr.h: #include "leb128.h".
(read_uleb128, read_sleb128): Delete.
(gdb_read_uleb128, gdb_read_sleb128, gdb_skip_leb128): New functions.
(safe_read_uleb128, safe_read_sleb128, safe_skip_leb128): Declare.
* dwarf2loc.c (debug_loc_kind): New enum.
(decode_debug_loc_addresses): New function.
(decode_debug_loc_dwo_addresses): New function.
(dwarf2_find_location_expression): Rewrite.
(dwarf2_compile_expr_to_ax): Update to match API of leb128 functions.
(locexpr_describe_location_piece): Ditto.
(disassemble_dwarf_expression): Ditto.
(locexpr_describe_location_1): Ditto.
(loclist_describe_location): Rewrite.
* dwarf2loc.h (dwarf2_loclist_baton): New member "from_dwo".
* dwarf2read.c (die_reader_specs): New member "buffer_end".
(dwarf2_section_buffer_overflow_complaint): Renamed from
dwarf2_macros_too_long_complaint. All callers updated.
(skip_leb128): Delete.
(init_cu_die_reader): Initialize reader->buffer_end.
(skip_one_die): Replace call to skip_leb128 with safe_skip_leb128.
(skip_form_bytes): New arg buffer_end. All callers updated.
Replace call to skip_leb128 with gdb_skip_leb128.
(skip_unknown_opcode): New arg mac_end. All callers updated.
(fill_in_loclist_baton): Initialize baton->from_dwo.
+2012-05-22 Doug Evans <dje@google.com>
+
+ * dwarf2-frame.c (struct dwarf2_cie): Make initial_instructions, end
+ "const gdb_byte *".
+ (struct dwarf2_fde): Make instructions, end "const gdb_byte *".
+ (execute_cfa_program): Update to match API of leb128 functions.
+ (read_1_byte, read_4_bytes, read_8_bytes): Make buf parameter
+ "const gdb_byte *".
+ (read_unsigned_leb128, read_signed_leb128): Delete.
+ (read_initial_length): Change type of buf argument to
+ "const gdb_byte *".
+ (read_encoded_value): Update to match API of leb128 functions.
+ (decode_frame_entry): Change result to "const gdb_byte *", and
+ similarly for "start" parameter.
+ (decode_frame_entry_1): Ditto. Use new leb128 reader functions.
+ (dwarf2_build_frame_info): Change local frame_ptr to
+ "const gdb_byte *".
+ * dwarf2expr.c (safe_read_uleb128, safe_read_sleb128): Replaces
+ read_uleb128, read_sleb128. All callers updated.
+ (safe_skip_leb128): New function.
+ (dwarf_block_to_dwarf_reg): Update to match API of leb128 functions.
+ Call gdb_read_uleb128, gdb_skip_leb128 instead of read_uleb128.
+ (dwarf_block_to_dwarf_reg_deref): Update to match API of leb128
+ functions. Call gdb_read_uleb128, gdb_read_sleb128 instead of
+ read_uleb128, read_sleb128.
+ (dwarf_block_to_fb_offset, dwarf_block_to_sp_offset): Ditto.
+ (execute_stack_op): Update to match API of leb128 functions.
+ * dwarf2expr.h: #include "leb128.h".
+ (read_uleb128, read_sleb128): Delete.
+ (gdb_read_uleb128, gdb_read_sleb128, gdb_skip_leb128): New functions.
+ (safe_read_uleb128, safe_read_sleb128, safe_skip_leb128): Declare.
+ * dwarf2loc.c (debug_loc_kind): New enum.
+ (decode_debug_loc_addresses): New function.
+ (decode_debug_loc_dwo_addresses): New function.
+ (dwarf2_find_location_expression): Rewrite.
+ (dwarf2_compile_expr_to_ax): Update to match API of leb128 functions.
+ (locexpr_describe_location_piece): Ditto.
+ (disassemble_dwarf_expression): Ditto.
+ (locexpr_describe_location_1): Ditto.
+ (loclist_describe_location): Rewrite.
+ * dwarf2loc.h (dwarf2_loclist_baton): New member "from_dwo".
+ * dwarf2read.c (die_reader_specs): New member "buffer_end".
+ (dwarf2_section_buffer_overflow_complaint): Renamed from
+ dwarf2_macros_too_long_complaint. All callers updated.
+ (skip_leb128): Delete.
+ (init_cu_die_reader): Initialize reader->buffer_end.
+ (skip_one_die): Replace call to skip_leb128 with safe_skip_leb128.
+ (skip_form_bytes): New arg buffer_end. All callers updated.
+ Replace call to skip_leb128 with gdb_skip_leb128.
+ (skip_unknown_opcode): New arg mac_end. All callers updated.
+ (fill_in_loclist_baton): Initialize baton->from_dwo.
+
2012-05-22 Maciej W. Rozycki <macro@codesourcery.com>
* mips-linux-nat.c (mips_linux_read_description): Use a more
ULONGEST return_address_register;
/* Instruction sequence to initialize a register set. */
- gdb_byte *initial_instructions;
- gdb_byte *end;
+ const gdb_byte *initial_instructions;
+ const gdb_byte *end;
/* Saved augmentation, in case it's needed later. */
char *augmentation;
CORE_ADDR address_range;
/* Instruction sequence. */
- gdb_byte *instructions;
- gdb_byte *end;
+ const gdb_byte *instructions;
+ const gdb_byte *end;
/* True if this FDE is read from a .eh_frame instead of a .debug_frame
section. */
while (insn_ptr < insn_end && fs->pc <= pc)
{
gdb_byte insn = *insn_ptr++;
- ULONGEST utmp, reg;
- LONGEST offset;
+ unsigned long long utmp, reg;
+ long long offset;
if ((insn & 0xc0) == DW_CFA_advance_loc)
fs->pc += (insn & 0x3f) * fs->code_align;
{
reg = insn & 0x3f;
reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
- insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+ insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
offset = utmp * fs->data_align;
dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
break;
case DW_CFA_offset_extended:
- insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
+ insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
- insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+ insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
offset = utmp * fs->data_align;
dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
break;
case DW_CFA_restore_extended:
- insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
+ insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
break;
case DW_CFA_undefined:
- insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
+ 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.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
break;
case DW_CFA_same_value:
- insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
+ 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.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
break;
case DW_CFA_register:
- insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
+ insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
- insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+ 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.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
break;
case DW_CFA_def_cfa:
- insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
- insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+ insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
+ fs->regs.cfa_reg = reg;
+ insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
if (fs->armcc_cfa_offsets_sf)
utmp *= fs->data_align;
break;
case DW_CFA_def_cfa_register:
- insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
- fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch,
- fs->regs.cfa_reg,
+ insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
+ fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch, reg,
eh_frame_p);
fs->regs.cfa_how = CFA_REG_OFFSET;
break;
case DW_CFA_def_cfa_offset:
- insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+ insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
if (fs->armcc_cfa_offsets_sf)
utmp *= fs->data_align;
break;
case DW_CFA_def_cfa_expression:
- insn_ptr = read_uleb128 (insn_ptr, insn_end,
- &fs->regs.cfa_exp_len);
+ insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
+ fs->regs.cfa_exp_len = utmp;
fs->regs.cfa_exp = insn_ptr;
fs->regs.cfa_how = CFA_EXP;
insn_ptr += fs->regs.cfa_exp_len;
break;
case DW_CFA_expression:
- insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
+ 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);
- insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+ 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].how = DWARF2_FRAME_REG_SAVED_EXP;
break;
case DW_CFA_offset_extended_sf:
- insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
+ insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
- insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
+ 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.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
break;
case DW_CFA_val_offset:
- insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
+ insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
- insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+ 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;
fs->regs.reg[reg].loc.offset = offset;
break;
case DW_CFA_val_offset_sf:
- insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
+ insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
- insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
+ 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;
fs->regs.reg[reg].loc.offset = offset;
break;
case DW_CFA_val_expression:
- insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
+ insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
- insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+ 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].how = DWARF2_FRAME_REG_SAVED_VAL_EXP;
break;
case DW_CFA_def_cfa_sf:
- insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
- fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch,
- fs->regs.cfa_reg,
+ insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
+ fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch, reg,
eh_frame_p);
- insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
+ insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
fs->regs.cfa_offset = offset * fs->data_align;
fs->regs.cfa_how = CFA_REG_OFFSET;
break;
case DW_CFA_def_cfa_offset_sf:
- insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
+ insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
fs->regs.cfa_offset = offset * fs->data_align;
/* cfa_how deliberately not set. */
break;
case DW_CFA_GNU_args_size:
/* Ignored. */
- insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
+ insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
break;
case DW_CFA_GNU_negative_offset_extended:
- insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
+ insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
- insn_ptr = read_uleb128 (insn_ptr, insn_end, &offset);
+ insn_ptr = safe_read_uleb128 (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;
const struct objfile_data *dwarf2_frame_objfile_data;
static unsigned int
-read_1_byte (bfd *abfd, gdb_byte *buf)
+read_1_byte (bfd *abfd, const gdb_byte *buf)
{
return bfd_get_8 (abfd, buf);
}
static unsigned int
-read_4_bytes (bfd *abfd, gdb_byte *buf)
+read_4_bytes (bfd *abfd, const gdb_byte *buf)
{
return bfd_get_32 (abfd, buf);
}
static ULONGEST
-read_8_bytes (bfd *abfd, gdb_byte *buf)
+read_8_bytes (bfd *abfd, const gdb_byte *buf)
{
return bfd_get_64 (abfd, buf);
}
static ULONGEST
-read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
-{
- ULONGEST result;
- unsigned int num_read;
- int shift;
- gdb_byte byte;
-
- result = 0;
- shift = 0;
- num_read = 0;
-
- do
- {
- byte = bfd_get_8 (abfd, (bfd_byte *) buf);
- buf++;
- num_read++;
- result |= ((byte & 0x7f) << shift);
- shift += 7;
- }
- while (byte & 0x80);
-
- *bytes_read_ptr = num_read;
-
- return result;
-}
-
-static LONGEST
-read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
-{
- LONGEST result;
- int shift;
- unsigned int num_read;
- gdb_byte byte;
-
- result = 0;
- shift = 0;
- num_read = 0;
-
- do
- {
- byte = bfd_get_8 (abfd, (bfd_byte *) buf);
- buf++;
- num_read++;
- result |= ((byte & 0x7f) << shift);
- shift += 7;
- }
- while (byte & 0x80);
-
- if (shift < 8 * sizeof (result) && (byte & 0x40))
- result |= -(((LONGEST)1) << shift);
-
- *bytes_read_ptr = num_read;
-
- return result;
-}
-
-static ULONGEST
-read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
+read_initial_length (bfd *abfd, const gdb_byte *buf,
+ unsigned int *bytes_read_ptr)
{
LONGEST result;
{
case DW_EH_PE_uleb128:
{
- ULONGEST value;
+ unsigned long long value;
const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
- *bytes_read_ptr += read_uleb128 (buf, end_buf, &value) - buf;
+ *bytes_read_ptr += safe_read_uleb128 (buf, end_buf, &value) - buf;
return base + value;
}
case DW_EH_PE_udata2:
return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
case DW_EH_PE_sleb128:
{
- LONGEST value;
+ long long value;
const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
- *bytes_read_ptr += read_sleb128 (buf, end_buf, &value) - buf;
+ *bytes_read_ptr += safe_read_sleb128 (buf, end_buf, &value) - buf;
return base + value;
}
case DW_EH_PE_sdata2:
EH_CIE_OR_FDE_TYPE_ID = EH_CIE_TYPE_ID | EH_FDE_TYPE_ID
};
-static gdb_byte *decode_frame_entry (struct comp_unit *unit, gdb_byte *start,
- int eh_frame_p,
- struct dwarf2_cie_table *cie_table,
- struct dwarf2_fde_table *fde_table,
- enum eh_frame_type entry_type);
+static const gdb_byte *decode_frame_entry (struct comp_unit *unit,
+ const gdb_byte *start,
+ int eh_frame_p,
+ struct dwarf2_cie_table *cie_table,
+ struct dwarf2_fde_table *fde_table,
+ enum eh_frame_type entry_type);
/* Decode the next CIE or FDE, entry_type specifies the expected type.
Return NULL if invalid input, otherwise the next byte to be processed. */
-static gdb_byte *
-decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p,
+static const gdb_byte *
+decode_frame_entry_1 (struct comp_unit *unit, const gdb_byte *start,
+ int eh_frame_p,
struct dwarf2_cie_table *cie_table,
struct dwarf2_fde_table *fde_table,
enum eh_frame_type entry_type)
{
struct gdbarch *gdbarch = get_objfile_arch (unit->objfile);
- gdb_byte *buf, *end;
+ const gdb_byte *buf, *end;
LONGEST length;
unsigned int bytes_read;
int dwarf64_p;
ULONGEST cie_id;
ULONGEST cie_pointer;
+ long long sleb128;
+ unsigned long long uleb128;
buf = start;
length = read_initial_length (unit->abfd, buf, &bytes_read);
else
cie->ptr_size = cie->addr_size;
- cie->code_alignment_factor =
- read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
- buf += bytes_read;
+ buf = gdb_read_uleb128 (buf, end, &uleb128);
+ if (buf == NULL)
+ return NULL;
+ cie->code_alignment_factor = uleb128;
- cie->data_alignment_factor =
- read_signed_leb128 (unit->abfd, buf, &bytes_read);
- buf += bytes_read;
+ buf = gdb_read_sleb128 (buf, end, &sleb128);
+ if (buf == NULL)
+ return NULL;
+ cie->data_alignment_factor = sleb128;
if (cie_version == 1)
{
cie->return_address_register = read_1_byte (unit->abfd, buf);
- bytes_read = 1;
+ ++buf;
}
else
- cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
- &bytes_read);
+ {
+ buf = gdb_read_uleb128 (buf, end, &uleb128);
+ if (buf == NULL)
+ return NULL;
+ cie->return_address_register = uleb128;
+ }
+
cie->return_address_register
= dwarf2_frame_adjust_regnum (gdbarch,
cie->return_address_register,
eh_frame_p);
- buf += bytes_read;
-
cie->saw_z_augmentation = (*augmentation == 'z');
if (cie->saw_z_augmentation)
{
- ULONGEST length;
+ unsigned long long length;
- length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
- buf += bytes_read;
- if (buf > end)
+ buf = gdb_read_uleb128 (buf, end, &length);
+ if (buf == NULL)
return NULL;
cie->initial_instructions = buf + length;
augmentation++;
can skip the whole thing. */
if (fde->cie->saw_z_augmentation)
{
- ULONGEST length;
+ unsigned long long length;
- length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
- buf += bytes_read + length;
+ buf = gdb_read_uleb128 (buf, end, &length);
+ if (buf == NULL)
+ return NULL;
+ buf += length;
if (buf > end)
return NULL;
}
/* Read a CIE or FDE in BUF and decode it. Entry_type specifies whether we
expect an FDE or a CIE. */
-static gdb_byte *
-decode_frame_entry (struct comp_unit *unit, gdb_byte *start, int eh_frame_p,
+static const gdb_byte *
+decode_frame_entry (struct comp_unit *unit, const gdb_byte *start,
+ int eh_frame_p,
struct dwarf2_cie_table *cie_table,
struct dwarf2_fde_table *fde_table,
enum eh_frame_type entry_type)
{
enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
- gdb_byte *ret;
+ const gdb_byte *ret;
ptrdiff_t start_offset;
while (1)
dwarf2_build_frame_info (struct objfile *objfile)
{
struct comp_unit *unit;
- gdb_byte *frame_ptr;
+ const gdb_byte *frame_ptr;
struct dwarf2_cie_table cie_table;
struct dwarf2_fde_table fde_table;
struct dwarf2_fde_table *fde_table2;
gdb_assert (ctx->recursion_depth == old_recursion_depth);
}
-/* Decode the unsigned LEB128 constant at BUF into the variable pointed to
- by R, and return the new value of BUF. Verify that it doesn't extend
- past BUF_END. R can be NULL, the constant is then only skipped. */
+/* Helper to read a uleb128 value or throw an error. */
const gdb_byte *
-read_uleb128 (const gdb_byte *buf, const gdb_byte *buf_end, ULONGEST * r)
+safe_read_uleb128 (const gdb_byte *buf, const gdb_byte *buf_end,
+ unsigned long long *r)
{
- unsigned shift = 0;
- ULONGEST result = 0;
- gdb_byte byte;
-
- while (1)
- {
- if (buf >= buf_end)
- error (_("read_uleb128: Corrupted DWARF expression."));
-
- byte = *buf++;
- result |= ((ULONGEST) (byte & 0x7f)) << shift;
- if ((byte & 0x80) == 0)
- break;
- shift += 7;
- }
- if (r)
- *r = result;
+ buf = gdb_read_uleb128 (buf, buf_end, r);
+ if (buf == NULL)
+ error (_("DWARF expression error: ran off end of buffer reading uleb128 value"));
return buf;
}
-/* Decode the signed LEB128 constant at BUF into the variable pointed to
- by R, and return the new value of BUF. Verify that it doesn't extend
- past BUF_END. R can be NULL, the constant is then only skipped. */
+/* Helper to read a sleb128 value or throw an error. */
const gdb_byte *
-read_sleb128 (const gdb_byte *buf, const gdb_byte *buf_end, LONGEST * r)
+safe_read_sleb128 (const gdb_byte *buf, const gdb_byte *buf_end,
+ long long *r)
{
- unsigned shift = 0;
- LONGEST result = 0;
- gdb_byte byte;
-
- while (1)
- {
- if (buf >= buf_end)
- error (_("read_sleb128: Corrupted DWARF expression."));
-
- byte = *buf++;
- result |= ((ULONGEST) (byte & 0x7f)) << shift;
- shift += 7;
- if ((byte & 0x80) == 0)
- break;
- }
- if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0)
- result |= -(((LONGEST) 1) << shift);
+ buf = gdb_read_sleb128 (buf, buf_end, r);
+ if (buf == NULL)
+ error (_("DWARF expression error: ran off end of buffer reading sleb128 value"));
+ return buf;
+}
- if (r)
- *r = result;
+const gdb_byte *
+safe_skip_leb128 (const gdb_byte *buf, const gdb_byte *buf_end)
+{
+ buf = gdb_skip_leb128 (buf, buf_end);
+ if (buf == NULL)
+ error (_("DWARF expression error: ran off end of buffer reading leb128 value"));
return buf;
}
\f
int
dwarf_block_to_dwarf_reg (const gdb_byte *buf, const gdb_byte *buf_end)
{
- ULONGEST dwarf_reg;
+ unsigned long long dwarf_reg;
if (buf_end <= buf)
return -1;
if (*buf == DW_OP_GNU_regval_type)
{
buf++;
- buf = read_uleb128 (buf, buf_end, &dwarf_reg);
- buf = read_uleb128 (buf, buf_end, NULL);
+ buf = gdb_read_uleb128 (buf, buf_end, &dwarf_reg);
+ if (buf == NULL)
+ return -1;
+ buf = gdb_skip_leb128 (buf, buf_end);
+ if (buf == NULL)
+ return -1;
}
else if (*buf == DW_OP_regx)
{
buf++;
- buf = read_uleb128 (buf, buf_end, &dwarf_reg);
+ buf = gdb_read_uleb128 (buf, buf_end, &dwarf_reg);
+ if (buf == NULL)
+ return -1;
}
else
return -1;
dwarf_block_to_dwarf_reg_deref (const gdb_byte *buf, const gdb_byte *buf_end,
CORE_ADDR *deref_size_return)
{
- ULONGEST dwarf_reg;
- LONGEST offset;
+ unsigned long long dwarf_reg;
+ long long offset;
if (buf_end <= buf)
return -1;
+
if (*buf >= DW_OP_breg0 && *buf <= DW_OP_breg31)
{
dwarf_reg = *buf - DW_OP_breg0;
buf++;
+ if (buf >= buf_end)
+ return -1;
}
else if (*buf == DW_OP_bregx)
{
buf++;
- buf = read_uleb128 (buf, buf_end, &dwarf_reg);
+ buf = gdb_read_uleb128 (buf, buf_end, &dwarf_reg);
+ if (buf == NULL)
+ return -1;
if ((int) dwarf_reg != dwarf_reg)
return -1;
}
else
return -1;
- buf = read_sleb128 (buf, buf_end, &offset);
- if (offset != 0)
+ buf = gdb_read_sleb128 (buf, buf_end, &offset);
+ if (buf == NULL)
return -1;
-
- if (buf >= buf_end)
+ if (offset != 0)
return -1;
if (*buf == DW_OP_deref)
dwarf_block_to_fb_offset (const gdb_byte *buf, const gdb_byte *buf_end,
CORE_ADDR *fb_offset_return)
{
- LONGEST fb_offset;
+ long long fb_offset;
if (buf_end <= buf)
return 0;
return 0;
buf++;
- buf = read_sleb128 (buf, buf_end, &fb_offset);
+ buf = gdb_read_sleb128 (buf, buf_end, &fb_offset);
+ if (buf == NULL)
+ return 0;
*fb_offset_return = fb_offset;
if (buf != buf_end || fb_offset != (LONGEST) *fb_offset_return)
return 0;
dwarf_block_to_sp_offset (struct gdbarch *gdbarch, const gdb_byte *buf,
const gdb_byte *buf_end, CORE_ADDR *sp_offset_return)
{
- ULONGEST dwarf_reg;
- LONGEST sp_offset;
+ unsigned long long dwarf_reg;
+ long long sp_offset;
if (buf_end <= buf)
return 0;
if (*buf != DW_OP_bregx)
return 0;
buf++;
- buf = read_uleb128 (buf, buf_end, &dwarf_reg);
+ buf = gdb_read_uleb128 (buf, buf_end, &dwarf_reg);
+ if (buf == NULL)
+ return 0;
}
if (gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_reg)
!= gdbarch_sp_regnum (gdbarch))
return 0;
- buf = read_sleb128 (buf, buf_end, &sp_offset);
+ buf = gdb_read_sleb128 (buf, buf_end, &sp_offset);
+ if (buf == NULL)
+ return 0;
*sp_offset_return = sp_offset;
if (buf != buf_end || sp_offset != (LONGEST) *sp_offset_return)
return 0;
This is just an optimization, so it's always ok to punt
and leave this as 0. */
int in_stack_memory = 0;
- ULONGEST uoffset, reg;
- LONGEST offset;
+ unsigned long long uoffset, reg;
+ long long offset;
struct value *result_val = NULL;
/* The DWARF expression might have a bug causing an infinite
break;
case DW_OP_GNU_addr_index:
- op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
result = (ctx->funcs->get_addr_index) (ctx->baton, uoffset);
result_val = value_from_ulongest (address_type, result);
break;
op_ptr += 8;
break;
case DW_OP_constu:
- op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
result = uoffset;
result_val = value_from_ulongest (address_type, result);
break;
case DW_OP_consts:
- op_ptr = read_sleb128 (op_ptr, op_end, &offset);
+ op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
result = offset;
result_val = value_from_ulongest (address_type, result);
break;
break;
case DW_OP_regx:
- op_ptr = read_uleb128 (op_ptr, op_end, ®);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, ®);
dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
result = reg;
case DW_OP_implicit_value:
{
- ULONGEST len;
+ unsigned long long len;
- op_ptr = read_uleb128 (op_ptr, op_end, &len);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, &len);
if (op_ptr + len > op_end)
error (_("DW_OP_implicit_value: too few bytes available."));
ctx->len = len;
case DW_OP_GNU_implicit_pointer:
{
- LONGEST len;
+ long long len;
if (ctx->ref_addr_size == -1)
error (_("DWARF-2 expression error: DW_OP_GNU_implicit_pointer "
op_ptr += ctx->ref_addr_size;
/* The byte offset into the data. */
- op_ptr = read_sleb128 (op_ptr, op_end, &len);
+ op_ptr = safe_read_sleb128 (op_ptr, op_end, &len);
result = (ULONGEST) len;
result_val = value_from_ulongest (address_type, result);
case DW_OP_breg30:
case DW_OP_breg31:
{
- op_ptr = read_sleb128 (op_ptr, op_end, &offset);
+ op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
result = (ctx->funcs->read_reg) (ctx->baton, op - DW_OP_breg0);
result += offset;
result_val = value_from_ulongest (address_type, result);
break;
case DW_OP_bregx:
{
- op_ptr = read_uleb128 (op_ptr, op_end, ®);
- op_ptr = read_sleb128 (op_ptr, op_end, &offset);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, ®);
+ op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
result = (ctx->funcs->read_reg) (ctx->baton, reg);
result += offset;
result_val = value_from_ulongest (address_type, result);
size_t datalen;
unsigned int before_stack_len;
- op_ptr = read_sleb128 (op_ptr, op_end, &offset);
+ op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
/* Rather than create a whole new context, we simply
record the stack length before execution, then reset it
afterwards, effectively erasing whatever the recursive
{
cu_offset type_die;
- op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
type_die.cu_off = uoffset;
type = dwarf_get_base_type (ctx, type_die, 0);
}
case DW_OP_plus_uconst:
dwarf_require_integral (value_type (result_val));
result = value_as_long (result_val);
- op_ptr = read_uleb128 (op_ptr, op_end, ®);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, ®);
result += reg;
result_val = value_from_ulongest (address_type, result);
break;
case DW_OP_piece:
{
- ULONGEST size;
+ unsigned long long size;
/* Record the piece. */
- op_ptr = read_uleb128 (op_ptr, op_end, &size);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, &size);
add_piece (ctx, 8 * size, 0);
/* Pop off the address/regnum, and reset the location
case DW_OP_bit_piece:
{
- ULONGEST size, offset;
+ unsigned long long size, offset;
/* Record the piece. */
- op_ptr = read_uleb128 (op_ptr, op_end, &size);
- op_ptr = read_uleb128 (op_ptr, op_end, &offset);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, &size);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, &offset);
add_piece (ctx, size, offset);
/* Pop off the address/regnum, and reset the location
case DW_OP_GNU_entry_value:
{
- ULONGEST len;
+ unsigned long long len;
int dwarf_reg;
CORE_ADDR deref_size;
- op_ptr = read_uleb128 (op_ptr, op_end, &len);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, &len);
if (op_ptr + len > op_end)
error (_("DW_OP_GNU_entry_value: too few bytes available."));
const gdb_byte *data;
struct type *type;
- op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
type_die.cu_off = uoffset;
n = *op_ptr++;
data = op_ptr;
cu_offset type_die;
struct type *type;
- op_ptr = read_uleb128 (op_ptr, op_end, ®);
- op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, ®);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
type_die.cu_off = uoffset;
type = dwarf_get_base_type (ctx, type_die, 0);
cu_offset type_die;
struct type *type;
- op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
type_die.cu_off = uoffset;
if (type_die.cu_off == 0)
#if !defined (DWARF2EXPR_H)
#define DWARF2EXPR_H
+#include "leb128.h"
+
struct dwarf_expr_context;
/* Offset relative to the start of its containing CU (compilation unit). */
CORE_ADDR dwarf_expr_fetch_address (struct dwarf_expr_context *ctx, int n);
int dwarf_expr_fetch_in_stack_memory (struct dwarf_expr_context *ctx, int n);
-
-const gdb_byte *read_uleb128 (const gdb_byte *buf, const gdb_byte *buf_end,
- ULONGEST * r);
-const gdb_byte *read_sleb128 (const gdb_byte *buf, const gdb_byte *buf_end,
- LONGEST * r);
-
void dwarf_expr_require_composition (const gdb_byte *, const gdb_byte *,
const char *);
const gdb_byte *buf_end,
CORE_ADDR *sp_offset_return);
+/* Wrappers around the leb128 reader routines to simplify them for our
+ purposes. */
+
+static inline const gdb_byte *
+gdb_read_uleb128 (const gdb_byte *buf, const gdb_byte *buf_end,
+ unsigned long long *r)
+{
+ size_t bytes_read = read_uleb128_to_ull (buf, buf_end, r);
+
+ if (bytes_read == 0)
+ return NULL;
+ return buf + bytes_read;
+}
+
+static inline const gdb_byte *
+gdb_read_sleb128 (const gdb_byte *buf, const gdb_byte *buf_end,
+ long long *r)
+{
+ size_t bytes_read = read_sleb128_to_ll (buf, buf_end, r);
+
+ if (bytes_read == 0)
+ return NULL;
+ return buf + bytes_read;
+}
+
+static inline const gdb_byte *
+gdb_skip_leb128 (const gdb_byte *buf, const gdb_byte *buf_end)
+{
+ size_t bytes_read = skip_leb128 (buf, buf_end);
+
+ if (bytes_read == 0)
+ return NULL;
+ return buf + bytes_read;
+}
+
+extern const gdb_byte *safe_read_uleb128 (const gdb_byte *buf,
+ const gdb_byte *buf_end,
+ unsigned long long *r);
+
+extern const gdb_byte *safe_read_sleb128 (const gdb_byte *buf,
+ const gdb_byte *buf_end,
+ long long *r);
+
+extern const gdb_byte *safe_skip_leb128 (const gdb_byte *buf,
+ const gdb_byte *buf_end);
+
#endif /* dwarf2expr.h */
struct dwarf2_per_cu_data *per_cu,
LONGEST byte_offset);
+/* Until these have formal names, we define these here.
+ ref: http://gcc.gnu.org/wiki/DebugFission
+ Each entry in .debug_loc.dwo begins with a byte that describes the entry,
+ and is then followed by data specific to that entry. */
+
+enum debug_loc_kind
+{
+ /* Indicates the end of the list of entries. */
+ DEBUG_LOC_END_OF_LIST = 0,
+
+ /* This is followed by an unsigned LEB128 number that is an index into
+ .debug_addr and specifies the base address for all following entries. */
+ DEBUG_LOC_BASE_ADDRESS = 1,
+
+ /* This is followed by two unsigned LEB128 numbers that are indices into
+ .debug_addr and specify the beginning and ending addresses, and then
+ a normal location expression as in .debug_loc. */
+ DEBUG_LOC_NORMAL = 2,
+
+ /* An internal value indicating there is insufficient data. */
+ DEBUG_LOC_BUFFER_OVERFLOW = -1,
+
+ /* An internal value indicating an invalid kind of entry was found. */
+ DEBUG_LOC_INVALID_ENTRY = -2
+};
+
+/* Decode the addresses in a non-dwo .debug_loc entry.
+ A pointer to the next byte to examine is returned in *NEW_PTR.
+ The encoded low,high addresses are return in *LOW,*HIGH.
+ The result indicates the kind of entry found. */
+
+static enum debug_loc_kind
+decode_debug_loc_addresses (const gdb_byte *loc_ptr, const gdb_byte *buf_end,
+ const gdb_byte **new_ptr,
+ CORE_ADDR *low, CORE_ADDR *high,
+ enum bfd_endian byte_order,
+ unsigned int addr_size,
+ int signed_addr_p)
+{
+ CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
+
+ if (buf_end - loc_ptr < 2 * addr_size)
+ return DEBUG_LOC_BUFFER_OVERFLOW;
+
+ if (signed_addr_p)
+ *low = extract_signed_integer (loc_ptr, addr_size, byte_order);
+ else
+ *low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
+ loc_ptr += addr_size;
+
+ if (signed_addr_p)
+ *high = extract_signed_integer (loc_ptr, addr_size, byte_order);
+ else
+ *high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
+ loc_ptr += addr_size;
+
+ *new_ptr = loc_ptr;
+
+ /* A base-address-selection entry. */
+ if ((*low & base_mask) == base_mask)
+ return DEBUG_LOC_BASE_ADDRESS;
+
+ /* An end-of-list entry. */
+ if (*low == 0 && *high == 0)
+ return DEBUG_LOC_END_OF_LIST;
+
+ return DEBUG_LOC_NORMAL;
+}
+
+/* Decode the addresses in .debug_loc.dwo entry.
+ A pointer to the next byte to examine is returned in *NEW_PTR.
+ The encoded low,high addresses are return in *LOW,*HIGH.
+ The result indicates the kind of entry found. */
+
+static enum debug_loc_kind
+decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data *per_cu,
+ const gdb_byte *loc_ptr,
+ const gdb_byte *buf_end,
+ const gdb_byte **new_ptr,
+ CORE_ADDR *low, CORE_ADDR *high)
+{
+ unsigned long long low_index, high_index;
+
+ if (loc_ptr == buf_end)
+ return DEBUG_LOC_BUFFER_OVERFLOW;
+
+ switch (*loc_ptr++)
+ {
+ case DEBUG_LOC_END_OF_LIST:
+ *new_ptr = loc_ptr;
+ return DEBUG_LOC_END_OF_LIST;
+ case DEBUG_LOC_BASE_ADDRESS:
+ *low = 0;
+ loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &high_index);
+ if (loc_ptr == NULL)
+ return DEBUG_LOC_BUFFER_OVERFLOW;
+ *high = dwarf2_read_addr_index (per_cu, high_index);
+ *new_ptr = loc_ptr;
+ return DEBUG_LOC_BASE_ADDRESS;
+ case DEBUG_LOC_NORMAL:
+ loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &low_index);
+ if (loc_ptr == NULL)
+ return DEBUG_LOC_BUFFER_OVERFLOW;
+ *low = dwarf2_read_addr_index (per_cu, low_index);
+ loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &high_index);
+ if (loc_ptr == NULL)
+ return DEBUG_LOC_BUFFER_OVERFLOW;
+ *high = dwarf2_read_addr_index (per_cu, high_index);
+ *new_ptr = loc_ptr;
+ return DEBUG_LOC_NORMAL;
+ default:
+ return DEBUG_LOC_INVALID_ENTRY;
+ }
+}
+
/* A function for dealing with location lists. Given a
symbol baton (BATON) and a pc value (PC), find the appropriate
location expression, set *LOCEXPR_LENGTH, and return a pointer
dwarf2_find_location_expression (struct dwarf2_loclist_baton *baton,
size_t *locexpr_length, CORE_ADDR pc)
{
- CORE_ADDR low, high;
- const gdb_byte *loc_ptr, *buf_end;
- int length;
struct objfile *objfile = dwarf2_per_cu_objfile (baton->per_cu);
struct gdbarch *gdbarch = get_objfile_arch (objfile);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
unsigned int addr_size = dwarf2_per_cu_addr_size (baton->per_cu);
int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
- CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
/* Adjust base_address for relocatable objects. */
CORE_ADDR base_offset = dwarf2_per_cu_text_offset (baton->per_cu);
CORE_ADDR base_address = baton->base_address + base_offset;
+ const gdb_byte *loc_ptr, *buf_end;
loc_ptr = baton->data;
buf_end = baton->data + baton->size;
while (1)
{
- if (buf_end - loc_ptr < 2 * addr_size)
- error (_("dwarf2_find_location_expression: "
- "Corrupted DWARF expression."));
-
- if (signed_addr_p)
- low = extract_signed_integer (loc_ptr, addr_size, byte_order);
- else
- low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
- loc_ptr += addr_size;
-
- if (signed_addr_p)
- high = extract_signed_integer (loc_ptr, addr_size, byte_order);
+ CORE_ADDR low = 0, high = 0; /* init for gcc -Wall */
+ int length;
+ enum debug_loc_kind kind;
+ const gdb_byte *new_ptr = NULL; /* init for gcc -Wall */
+
+ if (baton->from_dwo)
+ kind = decode_debug_loc_dwo_addresses (baton->per_cu,
+ loc_ptr, buf_end, &new_ptr,
+ &low, &high);
else
- high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
- loc_ptr += addr_size;
-
- /* A base-address-selection entry. */
- if ((low & base_mask) == base_mask)
- {
- base_address = high + base_offset;
- continue;
- }
-
- /* An end-of-list entry. */
- if (low == 0 && high == 0)
+ kind = decode_debug_loc_addresses (loc_ptr, buf_end, &new_ptr,
+ &low, &high,
+ byte_order, addr_size,
+ signed_addr_p);
+ loc_ptr = new_ptr;
+ switch (kind)
{
+ case DEBUG_LOC_END_OF_LIST:
*locexpr_length = 0;
return NULL;
+ case DEBUG_LOC_BASE_ADDRESS:
+ base_address = high + base_offset;
+ continue;
+ case DEBUG_LOC_NORMAL:
+ break;
+ case DEBUG_LOC_BUFFER_OVERFLOW:
+ case DEBUG_LOC_INVALID_ENTRY:
+ error (_("dwarf2_find_location_expression: "
+ "Corrupted DWARF expression."));
+ default:
+ gdb_assert_not_reached ("bad debug_loc_kind");
}
/* Otherwise, a location expression entry. */
while (op_ptr < op_end)
{
enum dwarf_location_atom op = *op_ptr;
- ULONGEST uoffset, reg;
- LONGEST offset;
+ unsigned long long uoffset, reg;
+ long long offset;
int i;
offsets[op_ptr - base] = expr->len;
op_ptr += 8;
break;
case DW_OP_constu:
- op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
ax_const_l (expr, uoffset);
break;
case DW_OP_consts:
- op_ptr = read_sleb128 (op_ptr, op_end, &offset);
+ op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
ax_const_l (expr, offset);
break;
break;
case DW_OP_regx:
- op_ptr = read_uleb128 (op_ptr, op_end, ®);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, ®);
dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
loc->u.reg = translate_register (arch, reg);
loc->kind = axs_lvalue_register;
case DW_OP_implicit_value:
{
- ULONGEST len;
+ unsigned long long len;
- op_ptr = read_uleb128 (op_ptr, op_end, &len);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, &len);
if (op_ptr + len > op_end)
error (_("DW_OP_implicit_value: too few bytes available."));
if (len > sizeof (ULONGEST))
case DW_OP_breg29:
case DW_OP_breg30:
case DW_OP_breg31:
- op_ptr = read_sleb128 (op_ptr, op_end, &offset);
+ op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
i = translate_register (arch, op - DW_OP_breg0);
ax_reg (expr, i);
if (offset != 0)
break;
case DW_OP_bregx:
{
- op_ptr = read_uleb128 (op_ptr, op_end, ®);
- op_ptr = read_sleb128 (op_ptr, op_end, &offset);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, ®);
+ op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
i = translate_register (arch, reg);
ax_reg (expr, i);
if (offset != 0)
dwarf_expr_frame_base_1 (framefunc, expr->scope,
&datastart, &datalen);
- op_ptr = read_sleb128 (op_ptr, op_end, &offset);
+ op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size, datastart,
datastart + datalen, per_cu);
break;
case DW_OP_plus_uconst:
- op_ptr = read_uleb128 (op_ptr, op_end, ®);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, ®);
/* It would be really weird to emit `DW_OP_plus_uconst 0',
but we micro-optimize anyhow. */
if (reg != 0)
case DW_OP_piece:
case DW_OP_bit_piece:
{
- ULONGEST size, offset;
+ unsigned long long size, offset;
if (op_ptr - 1 == previous_piece)
error (_("Cannot translate empty pieces to agent expressions"));
previous_piece = op_ptr - 1;
- op_ptr = read_uleb128 (op_ptr, op_end, &size);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, &size);
if (op == DW_OP_piece)
{
size *= 8;
offset = 0;
}
else
- op_ptr = read_uleb128 (op_ptr, op_end, &offset);
+ op_ptr = safe_read_uleb128 (op_ptr, op_end, &offset);
if (bits_collected + size > 8 * sizeof (LONGEST))
error (_("Expression pieces exceed word size"));
/* Nicely describe a single piece of a location, returning an updated
position in the bytecode sequence. This function cannot recognize
all locations; if a location is not recognized, it simply returns
- DATA. */
+ DATA. If there is an error during reading, e.g. we run off the end
+ of the buffer, an error is thrown. */
static const gdb_byte *
locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream,
}
else if (data[0] == DW_OP_regx)
{
- ULONGEST reg;
+ unsigned long long reg;
- data = read_uleb128 (data + 1, end, ®);
+ data = safe_read_uleb128 (data + 1, end, ®);
fprintf_filtered (stream, _("a variable in $%s"),
locexpr_regname (gdbarch, reg));
}
struct block *b;
struct symbol *framefunc;
int frame_reg = 0;
- LONGEST frame_offset;
+ long long frame_offset;
const gdb_byte *base_data, *new_data, *save_data = data;
size_t base_size;
- LONGEST base_offset = 0;
+ long long base_offset = 0;
- new_data = read_sleb128 (data + 1, end, &frame_offset);
+ new_data = safe_read_sleb128 (data + 1, end, &frame_offset);
if (!piece_end_p (new_data, end))
return data;
data = new_data;
const gdb_byte *buf_end;
frame_reg = base_data[0] - DW_OP_breg0;
- buf_end = read_sleb128 (base_data + 1,
- base_data + base_size, &base_offset);
+ buf_end = safe_read_sleb128 (base_data + 1, base_data + base_size,
+ &base_offset);
if (buf_end != base_data + base_size)
error (_("Unexpected opcode after "
"DW_OP_breg%u for symbol \"%s\"."),
else if (data[0] >= DW_OP_breg0 && data[0] <= DW_OP_breg31
&& piece_end_p (data, end))
{
- LONGEST offset;
+ long long offset;
- data = read_sleb128 (data + 1, end, &offset);
+ data = safe_read_sleb128 (data + 1, end, &offset);
fprintf_filtered (stream,
_("a variable at offset %s from base reg $%s"),
/* Disassemble an expression, stopping at the end of a piece or at the
end of the expression. Returns a pointer to the next unread byte
in the input expression. If ALL is nonzero, then this function
- will keep going until it reaches the end of the expression. */
+ will keep going until it reaches the end of the expression.
+ If there is an error during reading, e.g. we run off the end
+ of the buffer, an error is thrown. */
static const gdb_byte *
disassemble_dwarf_expression (struct ui_file *stream,
|| (data[0] != DW_OP_piece && data[0] != DW_OP_bit_piece)))
{
enum dwarf_location_atom op = *data++;
- ULONGEST ul;
- LONGEST l;
+ unsigned long long ul;
+ long long l;
const char *name;
name = get_DW_OP_name (op);
fprintf_filtered (stream, " %s", plongest (l));
break;
case DW_OP_constu:
- data = read_uleb128 (data, end, &ul);
+ data = safe_read_uleb128 (data, end, &ul);
fprintf_filtered (stream, " %s", pulongest (ul));
break;
case DW_OP_consts:
- data = read_sleb128 (data, end, &l);
+ data = safe_read_sleb128 (data, end, &l);
fprintf_filtered (stream, " %s", plongest (l));
break;
break;
case DW_OP_regx:
- data = read_uleb128 (data, end, &ul);
+ data = safe_read_uleb128 (data, end, &ul);
fprintf_filtered (stream, " %s [$%s]", pulongest (ul),
locexpr_regname (arch, (int) ul));
break;
case DW_OP_implicit_value:
- data = read_uleb128 (data, end, &ul);
+ data = safe_read_uleb128 (data, end, &ul);
data += ul;
fprintf_filtered (stream, " %s", pulongest (ul));
break;
case DW_OP_breg29:
case DW_OP_breg30:
case DW_OP_breg31:
- data = read_sleb128 (data, end, &l);
+ data = safe_read_sleb128 (data, end, &l);
fprintf_filtered (stream, " %s [$%s]", plongest (l),
locexpr_regname (arch, op - DW_OP_breg0));
break;
case DW_OP_bregx:
- data = read_uleb128 (data, end, &ul);
- data = read_sleb128 (data, end, &l);
+ data = safe_read_uleb128 (data, end, &ul);
+ data = safe_read_sleb128 (data, end, &l);
fprintf_filtered (stream, " register %s [$%s] offset %s",
pulongest (ul),
locexpr_regname (arch, (int) ul),
break;
case DW_OP_fbreg:
- data = read_sleb128 (data, end, &l);
+ data = safe_read_sleb128 (data, end, &l);
fprintf_filtered (stream, " %s", plongest (l));
break;
break;
case DW_OP_plus_uconst:
- data = read_uleb128 (data, end, &ul);
+ data = safe_read_uleb128 (data, end, &ul);
fprintf_filtered (stream, " %s", pulongest (ul));
break;
break;
case DW_OP_piece:
- data = read_uleb128 (data, end, &ul);
+ data = safe_read_uleb128 (data, end, &ul);
fprintf_filtered (stream, " %s (bytes)", pulongest (ul));
break;
case DW_OP_bit_piece:
{
- ULONGEST offset;
+ unsigned long long offset;
- data = read_uleb128 (data, end, &ul);
- data = read_uleb128 (data, end, &offset);
+ data = safe_read_uleb128 (data, end, &ul);
+ data = safe_read_uleb128 (data, end, &offset);
fprintf_filtered (stream, " size %s offset %s (bits)",
pulongest (ul), pulongest (offset));
}
gdbarch_byte_order (arch));
data += offset_size;
- data = read_sleb128 (data, end, &l);
+ data = safe_read_sleb128 (data, end, &l);
fprintf_filtered (stream, " DIE %s offset %s",
phex_nz (ul, offset_size),
cu_offset offset;
struct type *type;
- data = read_uleb128 (data, end, &ul);
+ data = safe_read_uleb128 (data, end, &ul);
offset.cu_off = ul;
type = dwarf2_get_die_type (offset, per_cu);
fprintf_filtered (stream, "<");
cu_offset type_die;
struct type *type;
- data = read_uleb128 (data, end, &ul);
+ data = safe_read_uleb128 (data, end, &ul);
type_die.cu_off = ul;
type = dwarf2_get_die_type (type_die, per_cu);
fprintf_filtered (stream, "<");
case DW_OP_GNU_regval_type:
{
- ULONGEST reg;
+ unsigned long long reg;
cu_offset type_die;
struct type *type;
- data = read_uleb128 (data, end, ®);
- data = read_uleb128 (data, end, &ul);
+ data = safe_read_uleb128 (data, end, ®);
+ data = safe_read_uleb128 (data, end, &ul);
type_die.cu_off = ul;
type = dwarf2_get_die_type (type_die, per_cu);
{
cu_offset type_die;
- data = read_uleb128 (data, end, &ul);
+ data = safe_read_uleb128 (data, end, &ul);
type_die.cu_off = ul;
if (type_die.cu_off == 0)
break;
case DW_OP_GNU_entry_value:
- data = read_uleb128 (data, end, &ul);
+ data = safe_read_uleb128 (data, end, &ul);
fputc_filtered ('\n', stream);
disassemble_dwarf_expression (stream, arch, addr_size, offset_size,
start, data, data + ul, indent + 2,
fprintf_filtered (stream, " ");
if (data[0] == DW_OP_piece)
{
- ULONGEST bytes;
+ unsigned long long bytes;
- data = read_uleb128 (data + 1, end, &bytes);
+ data = safe_read_uleb128 (data + 1, end, &bytes);
if (empty)
fprintf_filtered (stream, _("an empty %s-byte piece"),
}
else if (data[0] == DW_OP_bit_piece)
{
- ULONGEST bits, offset;
+ unsigned long long bits, offset;
- data = read_uleb128 (data + 1, end, &bits);
- data = read_uleb128 (data, end, &offset);
+ data = safe_read_uleb128 (data + 1, end, &bits);
+ data = safe_read_uleb128 (data, end, &offset);
if (empty)
fprintf_filtered (stream,
struct ui_file *stream)
{
struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
- CORE_ADDR low, high;
const gdb_byte *loc_ptr, *buf_end;
- int length, first = 1;
+ int first = 1;
struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
struct gdbarch *gdbarch = get_objfile_arch (objfile);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
- CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
/* Adjust base_address for relocatable objects. */
CORE_ADDR base_offset = dwarf2_per_cu_text_offset (dlbaton->per_cu);
CORE_ADDR base_address = dlbaton->base_address + base_offset;
+ int done = 0;
loc_ptr = dlbaton->data;
buf_end = dlbaton->data + dlbaton->size;
fprintf_filtered (stream, _("multi-location:\n"));
/* Iterate through locations until we run out. */
- while (1)
+ while (!done)
{
- if (buf_end - loc_ptr < 2 * addr_size)
- error (_("Corrupted DWARF expression for symbol \"%s\"."),
- SYMBOL_PRINT_NAME (symbol));
-
- if (signed_addr_p)
- low = extract_signed_integer (loc_ptr, addr_size, byte_order);
- else
- low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
- loc_ptr += addr_size;
-
- if (signed_addr_p)
- high = extract_signed_integer (loc_ptr, addr_size, byte_order);
+ CORE_ADDR low = 0, high = 0; /* init for gcc -Wall */
+ int length;
+ enum debug_loc_kind kind;
+ const gdb_byte *new_ptr = NULL; /* init for gcc -Wall */
+
+ if (dlbaton->from_dwo)
+ kind = decode_debug_loc_dwo_addresses (dlbaton->per_cu,
+ loc_ptr, buf_end, &new_ptr,
+ &low, &high);
else
- high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
- loc_ptr += addr_size;
-
- /* A base-address-selection entry. */
- if ((low & base_mask) == base_mask)
+ kind = decode_debug_loc_addresses (loc_ptr, buf_end, &new_ptr,
+ &low, &high,
+ byte_order, addr_size,
+ signed_addr_p);
+ loc_ptr = new_ptr;
+ switch (kind)
{
+ case DEBUG_LOC_END_OF_LIST:
+ done = 1;
+ continue;
+ case DEBUG_LOC_BASE_ADDRESS:
base_address = high + base_offset;
fprintf_filtered (stream, _(" Base address %s"),
paddress (gdbarch, base_address));
continue;
+ case DEBUG_LOC_NORMAL:
+ break;
+ case DEBUG_LOC_BUFFER_OVERFLOW:
+ case DEBUG_LOC_INVALID_ENTRY:
+ error (_("Corrupted DWARF expression for symbol \"%s\"."),
+ SYMBOL_PRINT_NAME (symbol));
+ default:
+ gdb_assert_not_reached ("bad debug_loc_kind");
}
- /* An end-of-list entry. */
- if (low == 0 && high == 0)
- break;
-
/* Otherwise, a location expression entry. */
low += base_address;
high += base_address;
/* The compilation unit containing the symbol whose location
we're computing. */
struct dwarf2_per_cu_data *per_cu;
+
+ /* Non-zero if the location list lives in .debug_loc.dwo.
+ The format of entries in this section are different. */
+ unsigned char from_dwo;
};
extern const struct symbol_computed_ops dwarf2_locexpr_funcs;
/* die_section->buffer. */
gdb_byte *buffer;
+
+ /* The end of the buffer. */
+ const gdb_byte *buffer_end;
};
/* Type of function passed to init_cutu_and_read_dies, et.al. */
}
static void
-dwarf2_macros_too_long_complaint (struct dwarf2_section_info *section)
+dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info *section)
{
complaint (&symfile_complaints,
- _("macro info runs off end of `%s' section"),
- section->asection->name);
+ _("debug info runs off end of %s section"
+ " [in module %s]"),
+ section->asection->name,
+ bfd_get_filename (section->asection->owner));
}
static void
static char *read_str_index (const struct die_reader_specs *reader,
struct dwarf2_cu *cu, ULONGEST str_index);
-static gdb_byte *skip_leb128 (bfd *, gdb_byte *);
-
static void set_cu_language (unsigned int, struct dwarf2_cu *);
static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
reader->dwo_file = dwo_file;
reader->die_section = section;
reader->buffer = section->buffer;
+ reader->buffer_end = section->buffer + section->size;
}
/* Find the base address of the compilation unit for range lists and
bfd *abfd = reader->abfd;
struct dwarf2_cu *cu = reader->cu;
gdb_byte *buffer = reader->buffer;
+ const gdb_byte *buffer_end = reader->buffer_end;
+ gdb_byte *start_info_ptr = info_ptr;
unsigned int form, i;
for (i = 0; i < abbrev->num_attrs; i++)
case DW_FORM_ref_udata:
case DW_FORM_GNU_addr_index:
case DW_FORM_GNU_str_index:
- info_ptr = skip_leb128 (abfd, info_ptr);
+ info_ptr = (gdb_byte *) safe_skip_leb128 (info_ptr, buffer_end);
break;
case DW_FORM_indirect:
form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
return (char *) (sections->str.buffer + str_offset);
}
-/* Return a pointer to just past the end of an LEB128 number in BUF. */
-
-static gdb_byte *
-skip_leb128 (bfd *abfd, gdb_byte *buf)
-{
- int byte;
-
- while (1)
- {
- byte = bfd_get_8 (abfd, buf);
- buf++;
- if ((byte & 128) == 0)
- return buf;
- }
-}
-
/* Return the length of an LEB128 number in BUF. */
static int
Returns the new pointer. */
static gdb_byte *
-skip_form_bytes (bfd *abfd, gdb_byte *bytes,
+skip_form_bytes (bfd *abfd, gdb_byte *bytes, gdb_byte *buffer_end,
enum dwarf_form form,
unsigned int offset_size,
struct dwarf2_section_info *section)
case DW_FORM_udata:
case DW_FORM_GNU_addr_index:
case DW_FORM_GNU_str_index:
- bytes = skip_leb128 (abfd, bytes);
+ bytes = (gdb_byte *) gdb_skip_leb128 (bytes, buffer_end);
+ if (bytes == NULL)
+ {
+ dwarf2_section_buffer_overflow_complaint (section);
+ return NULL;
+ }
break;
default:
static gdb_byte *
skip_unknown_opcode (unsigned int opcode,
gdb_byte **opcode_definitions,
- gdb_byte *mac_ptr,
+ gdb_byte *mac_ptr, gdb_byte *mac_end,
bfd *abfd,
unsigned int offset_size,
struct dwarf2_section_info *section)
for (i = 0; i < arg; ++i)
{
- mac_ptr = skip_form_bytes (abfd, mac_ptr, defn[i], offset_size, section);
+ mac_ptr = skip_form_bytes (abfd, mac_ptr, mac_end, defn[i], offset_size,
+ section);
if (mac_ptr == NULL)
{
/* skip_form_bytes already issued the complaint. */
/* Do we at least have room for a macinfo type byte? */
if (mac_ptr >= mac_end)
{
- dwarf2_macros_too_long_complaint (section);
+ dwarf2_section_buffer_overflow_complaint (section);
break;
}
/* Do we at least have room for a macinfo type byte? */
if (mac_ptr >= mac_end)
{
- dwarf2_macros_too_long_complaint (section);
+ dwarf2_section_buffer_overflow_complaint (section);
return;
}
default:
mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
- mac_ptr, abfd, offset_size,
+ mac_ptr, mac_end, abfd, offset_size,
section);
if (mac_ptr == NULL)
return;
default:
mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
- mac_ptr, abfd, offset_size,
+ mac_ptr, mac_end, abfd, offset_size,
section);
if (mac_ptr == NULL)
return;
baton->size = section->size - DW_UNSND (attr);
baton->data = section->buffer + DW_UNSND (attr);
baton->base_address = cu->base_address;
+ baton->from_dwo = cu->dwo_unit != NULL;
}
static void
projects / binutils-gdb.git / commitdiff