int is_32bit_elf;
int have_frame_base;
int need_base_address;
-unsigned long saved_base_address;
+bfd_vma eh_addr_size;
struct group_list
{
}
}
+/* Return a pointer to section NAME, or NULL if no such section exists. */
+
+static Elf_Internal_Shdr *
+find_section (const char *name)
+{
+ unsigned int i;
+
+ for (i = 0; i < elf_header.e_shnum; i++)
+ if (streq (SECTION_NAME (section_headers + i), name))
+ return section_headers + i;
+
+ return NULL;
+}
+
/* Guess the relocation size commonly used by the specific machines. */
static int
if (section_headers != NULL)
{
Elf_Internal_Shdr *sec;
- unsigned int j;
-
- for (j = 0, sec = section_headers;
- j < elf_header.e_shnum;
- j++, sec++)
- if (streq (SECTION_NAME (sec), ".dynamic"))
- break;
- if (j == elf_header.e_shnum || sec->sh_size == 0)
+ sec = find_section (".dynamic");
+ if (sec == NULL || sec->sh_size == 0)
{
error (_("no .dynamic section in the dynamic segment"));
break;
dynamic_syminfo = NULL;
symtab_shndx_hdr = NULL;
+ eh_addr_size = is_32bit_elf ? 4 : 8;
+ switch (elf_header.e_machine)
+ {
+ case EM_MIPS:
+ case EM_MIPS_RS3_LE:
+ /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
+ FDE addresses. However, the ABI also has a semi-official ILP32
+ variant for which the normal FDE address size rules apply.
+
+ GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
+ section, where XX is the size of longs in bits. Unfortunately,
+ earlier compilers provided no way of distinguishing ILP32 objects
+ from LP64 objects, so if there's any doubt, we should assume that
+ the official LP64 form is being used. */
+ if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
+ && find_section (".gcc_compiled_long32") == NULL)
+ eh_addr_size = 8;
+ break;
+ }
+
for (i = 0, section = section_headers;
i < elf_header.e_shnum;
i++, section++)
static void
dump_ia64_unwind (struct ia64_unw_aux_info *aux)
{
- bfd_vma addr_size;
struct ia64_unw_table_entry *tp;
int in_body;
- addr_size = is_32bit_elf ? 4 : 8;
-
for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
{
bfd_vma stamp;
(unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
- (unsigned long) (addr_size * UNW_LENGTH (stamp)));
+ (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
if (UNW_VER (stamp) != 1)
{
}
in_body = 0;
- for (dp = head + 8; dp < head + 8 + addr_size * UNW_LENGTH (stamp);)
+ for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
dp = unw_decode (dp, in_body, & in_body);
}
}
struct ia64_unw_aux_info *aux,
Elf_Internal_Shdr *sec)
{
- unsigned long size, addr_size, nrelas, i;
+ unsigned long size, nrelas, i;
Elf_Internal_Phdr *seg;
struct ia64_unw_table_entry *tep;
Elf_Internal_Shdr *relsec;
Elf_Internal_Sym *sym;
const char *relname;
- addr_size = is_32bit_elf ? 4 : 8;
-
/* First, find the starting address of the segment that includes
this section: */
if (!table)
return 0;
- tep = aux->table = xmalloc (size / (3 * addr_size) * sizeof (aux->table[0]));
- for (tp = table; tp < table + size; tp += 3 * addr_size, ++tep)
+ aux->table = xmalloc (size / (3 * eh_addr_size) * sizeof (aux->table[0]));
+ tep = aux->table;
+ for (tp = table; tp < table + size; tp += 3 * eh_addr_size, ++tep)
{
tep->start.section = SHN_UNDEF;
tep->end.section = SHN_UNDEF;
continue;
}
- i = rp->r_offset / (3 * addr_size);
+ i = rp->r_offset / (3 * eh_addr_size);
- switch (rp->r_offset/addr_size % 3)
+ switch (rp->r_offset/eh_addr_size % 3)
{
case 0:
aux->table[i].start.section = sym->st_shndx;
free (rela);
}
- aux->table_len = size / (3 * addr_size);
+ aux->table_len = size / (3 * eh_addr_size);
return 1;
}
ia64_process_unwind (FILE *file)
{
Elf_Internal_Shdr *sec, *unwsec = NULL, *strsec;
- unsigned long i, addr_size, unwcount = 0, unwstart = 0;
+ unsigned long i, unwcount = 0, unwstart = 0;
struct ia64_unw_aux_info aux;
memset (& aux, 0, sizeof (aux));
- addr_size = is_32bit_elf ? 4 : 8;
-
for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
{
if (sec->sh_type == SHT_SYMTAB)
printf (_(" at offset 0x%lx contains %lu entries:\n"),
(unsigned long) unwsec->sh_offset,
- (unsigned long) (unwsec->sh_size / (3 * addr_size)));
+ (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
(void) slurp_ia64_unwind_table (file, & aux, unwsec);
static void
dump_hppa_unwind (struct hppa_unw_aux_info *aux)
{
- bfd_vma addr_size;
struct hppa_unw_table_entry *tp;
- addr_size = is_32bit_elf ? 4 : 8;
for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
{
bfd_vma offset;
struct hppa_unw_aux_info *aux,
Elf_Internal_Shdr *sec)
{
- unsigned long size, unw_ent_size, addr_size, nrelas, i;
+ unsigned long size, unw_ent_size, nrelas, i;
Elf_Internal_Phdr *seg;
struct hppa_unw_table_entry *tep;
Elf_Internal_Shdr *relsec;
Elf_Internal_Sym *sym;
const char *relname;
- addr_size = is_32bit_elf ? 4 : 8;
-
/* First, find the starting address of the segment that includes
this section. */
if (!table)
return 0;
- unw_ent_size = 2 * addr_size + 8;
+ unw_ent_size = 2 * eh_addr_size + 8;
tep = aux->table = xmalloc (size / unw_ent_size * sizeof (aux->table[0]));
- for (tp = table; tp < table + size; tp += (2 * addr_size + 8), ++tep)
+ for (tp = table; tp < table + size; tp += (2 * eh_addr_size + 8), ++tep)
{
unsigned int tmp1, tmp2;
i = rp->r_offset / unw_ent_size;
- switch ((rp->r_offset % unw_ent_size) / addr_size)
+ switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
{
case 0:
aux->table[i].start.section = sym->st_shndx;
Elf_Internal_Shdr *unwsec = NULL;
Elf_Internal_Shdr *strsec;
Elf_Internal_Shdr *sec;
- unsigned long addr_size;
unsigned long i;
memset (& aux, 0, sizeof (aux));
assert (string_table != NULL);
- addr_size = is_32bit_elf ? 4 : 8;
for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
{
printf (_(" at offset 0x%lx contains %lu entries:\n"),
(unsigned long) sec->sh_offset,
- (unsigned long) (sec->sh_size / (2 * addr_size + 8)));
+ (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
slurp_hppa_unwind_table (file, &aux, sec);
if (aux.table_len > 0)
return len;
}
-/* Finds section NAME inside FILE and returns a
- pointer to it, or NULL upon failure. */
-
-static Elf_Internal_Shdr *
-find_section (const char * name)
-{
- Elf_Internal_Shdr *sec;
- unsigned int i;
-
- for (i = elf_header.e_shnum, sec = section_headers + i - 1;
- i; --i, --sec)
- if (streq (SECTION_NAME (sec), name))
- break;
-
- if (i && sec && sec->sh_size != 0)
- return sec;
-
- return NULL;
-}
-
static const char *debug_str_contents;
static bfd_vma debug_str_size;
return need_frame_base;
}
-/* Decode a DW_AT_ranges attribute for 64bit DWARF3 . */
-
-static void
-decode_64bit_range (unsigned long offset, bfd_vma base_address)
-{
- const char * start = debug_range_contents + offset;
- const char * end = debug_range_contents + debug_range_size;
-
- do
- {
- bfd_vma a;
- bfd_vma b;
-
- a = byte_get ((unsigned char *) start, 8);
- b = byte_get ((unsigned char *) start + 8, 8);
-
- if (a == 0xffffffff)
- {
- base_address = b;
- }
- else if (a == 0 && b == 0)
- break;
- else if (a > b)
- printf (_(" [corrupt: start > end]"));
- else
- {
- printf (" ");
- print_vma (base_address + a, PREFIX_HEX);
- printf (" - ");
- print_vma (base_address + b, PREFIX_HEX);
- printf (", ");
- }
-
- start += 16;
- }
- while (start < end);
-}
-
-/* Decode a DW_AT_ranges attribute. */
-
-static void
-decode_range (unsigned long offset, bfd_vma base_address)
-{
- const char * start;
- const char * end;
-
- if (offset >= (debug_range_size - 8))
- {
- printf (_("[corrupt: offset is outside the .debug_ranges section]"));
- return;
- }
-
- /* Since all entries in the .debug_ranges section are pairs of either
- 4-byte integers (32-bit DWARF3) or 8-byte integers (64-bit DWARF3)
- the offset should always be a multiple of 8 bytes. */
- if (offset % 8)
- {
- printf (_("[corrupt: offset is not a multiple of 8]"));
- return;
- }
-
- start = debug_range_contents + offset;
-
- if (offset > 0
- /* Be paranoid - check to see if the previous
- two words were and end-of-range marker. */
- && (byte_get ((unsigned char *) start - 4, 4) != 0
- || byte_get ((unsigned char *) start - 8, 4) != 0))
- {
- printf (_("[corrupt: offset is not at the start of a range]"));
- return;
- }
-
- end = debug_range_contents + debug_range_size;
-
- printf ("(");
- do
- {
- unsigned long a;
- unsigned long b;
-
- a = byte_get ((unsigned char *) start, 4);
- b = byte_get ((unsigned char *) start + 4, 4);
-
- if (a == 0xffffffff)
- {
- if (b == 0xffffffff)
- {
- decode_64bit_range (offset, base_address);
- return;
- }
-
- base_address = b;
- }
- else if (a == 0 && b == 0)
- break;
- else if (a > b)
- printf (_("[corrupt: start > end]"));
- else
- {
- if (start > debug_range_contents + offset)
- printf (", ");
-
- printf (_("0x%lx - 0x%lx"),
- (unsigned long) base_address + a,
- (unsigned long) base_address + b);
- }
-
- start += 8;
- }
- while (start < end);
- printf (")");
-}
-
/* This structure records the information that
we extract from the.debug_info section. */
typedef struct
int *have_frame_base;
unsigned int num_loc_offsets;
unsigned int max_loc_offsets;
+ unsigned long *range_lists;
+ unsigned int num_range_lists;
+ unsigned int max_range_lists;
}
debug_info;
printf (" %lx", uvalue);
printf (" %lx", (unsigned long) byte_get (data + 4, 4));
}
- if ((do_loc || do_debug_loc)
+ if ((do_loc || do_debug_loc || do_debug_ranges)
&& num_debug_info_entries == 0)
{
if (sizeof (uvalue) == 8)
}
/* For some attributes we can display further information. */
- if ((do_loc || do_debug_loc)
+ if ((do_loc || do_debug_loc || do_debug_ranges)
&& num_debug_info_entries == 0)
{
switch (attribute)
debug_info_p->base_address = uvalue;
break;
+ case DW_AT_ranges:
+ if (form == DW_FORM_data4 || form == DW_FORM_data8)
+ {
+ /* Process range list. */
+ unsigned int max = debug_info_p->max_range_lists;
+ unsigned int num = debug_info_p->num_range_lists;
+
+ if (max == 0 || num >= max)
+ {
+ max += 1024;
+ debug_info_p->range_lists
+ = xrealloc (debug_info_p->range_lists,
+ max * sizeof (*debug_info_p->range_lists));
+ debug_info_p->max_range_lists = max;
+ }
+ debug_info_p->range_lists [num] = uvalue;
+ debug_info_p->num_range_lists++;
+ }
+ break;
+
default:
break;
}
break;
- case DW_AT_low_pc:
- if (need_base_address)
- saved_base_address = uvalue;
- break;
-
- case DW_AT_ranges:
- decode_range (uvalue, saved_base_address);
- break;
-
default:
break;
}
unsigned int unit;
unsigned int num_units = 0;
- if ((do_loc || do_debug_loc)
+ if ((do_loc || do_debug_loc || do_debug_ranges)
&& num_debug_info_entries == 0)
{
unsigned long length;
compunit.cu_pointer_size = byte_get (hdrptr, 1);
hdrptr += 1;
- if ((do_loc || do_debug_loc)
+ if ((do_loc || do_debug_loc || do_debug_ranges)
&& num_debug_info_entries == 0)
{
debug_information [unit].cu_offset = cu_offset;
debug_information [unit].have_frame_base = NULL;
debug_information [unit].max_loc_offsets = 0;
debug_information [unit].num_loc_offsets = 0;
+ debug_information [unit].range_lists = NULL;
+ debug_information [unit].max_range_lists= 0;
+ debug_information [unit].num_range_lists = 0;
}
tags = hdrptr;
break;
case DW_TAG_compile_unit:
need_base_address = 1;
- saved_base_address = 0;
break;
case DW_TAG_entry_point:
case DW_TAG_inlined_subroutine:
}
}
- /* Set num_debug_info_entries here so that it can be used
- to check if we need to proecess .debug_loc section. */
- if ((do_loc || do_debug_loc)
+ /* Set num_debug_info_entries here so that it can be used to check if
+ we need to proecess .debug_loc and .debug_ranges sections. */
+ if ((do_loc || do_debug_loc || do_debug_ranges)
&& num_debug_info_entries == 0)
num_debug_info_entries = num_units;
if (begin == -1UL && end != -1UL)
{
base_address = end;
+ printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
+ offset, begin, end);
continue;
}
start += length;
}
- if (j < debug_information [i].num_loc_offsets -1)
- printf (_(" <End of list>"));
- printf ("\n");
+ fputs (_(" <End of list>\n"), stdout);
}
}
return 1;
}
static int
-display_64bit_debug_ranges (unsigned char * start, unsigned char * end)
+display_debug_ranges (Elf_Internal_Shdr *section,
+ unsigned char *start,
+ FILE *file ATTRIBUTE_UNUSED)
{
- bfd_vma base_address = 0;
+ unsigned char *section_end;
+ unsigned long bytes;
+ unsigned char *section_begin = start;
+ unsigned int num_range_list = 0;
+ unsigned long last_offset = 0;
+ unsigned int first = 0;
+ unsigned int i;
+ unsigned int j;
+ int seen_first_offset = 0;
+ int use_debug_info = 1;
+ unsigned char *next;
- while (start < end)
+ bytes = section->sh_size;
+ section_end = start + bytes;
+
+ if (bytes == 0)
{
- bfd_vma a, b;
+ printf (_("\nThe .debug_ranges section is empty.\n"));
+ return 0;
+ }
- a = byte_get (start, 8);
- b = byte_get (start + 8, 8);
+ get_debug_info (file);
- if (a == 0xffffffffffffffffLL)
- {
- printf (_(" set base address to "));
- print_vma (b, PREFIX_HEX);
- base_address = b;
- }
- else if (a == 0 && b == 0)
- printf ( _("end of range"));
- else if (a > b)
- printf (_(" <corrupt range entry, start is greater than end>"));
- else if (base_address == 0)
- {
- printf ("range from base address + ");
- print_vma (a, PREFIX_HEX);
- printf (" to base address + ");
- print_vma (b, PREFIX_HEX);
- }
- else
+ /* Check the order of range list in .debug_info section. If
+ offsets of range lists are in the ascending order, we can
+ use `debug_information' directly. */
+ for (i = 0; i < num_debug_info_entries; i++)
+ {
+ unsigned int num;
+
+ num = debug_information [i].num_range_lists;
+ num_range_list += num;
+
+ /* Check if we can use `debug_information' directly. */
+ if (use_debug_info && num != 0)
{
- printf ("range from ");
- print_vma (base_address + a, PREFIX_HEX);
- printf (" to ");
- print_vma (base_address + b, PREFIX_HEX);
- }
+ if (!seen_first_offset)
+ {
+ /* This is the first range list. */
+ last_offset = debug_information [i].range_lists [0];
+ first = i;
+ seen_first_offset = 1;
+ j = 1;
+ }
+ else
+ j = 0;
- start += 16;
- printf ("\n");
+ for (; j < num; j++)
+ {
+ if (last_offset >
+ debug_information [i].range_lists [j])
+ {
+ use_debug_info = 0;
+ break;
+ }
+ last_offset = debug_information [i].range_lists [j];
+ }
+ }
}
- return 1;
-}
+ if (!use_debug_info)
+ /* FIXME: Should we handle this case? */
+ error (_("Range lists in .debug_info section aren't in ascending order!\n"));
-static int
-display_debug_ranges (Elf_Internal_Shdr *section,
- unsigned char *start,
- FILE *file ATTRIBUTE_UNUSED)
-{
- unsigned long base_address = 0;
- unsigned char *end = start + section->sh_size;
+ if (!seen_first_offset)
+ error (_("No range lists in .debug_info section!\n"));
- printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
+ if (debug_information [first].range_lists [0] != 0)
+ warn (_("Range lists in .debug_ranges section start at 0x%lx\n"),
+ debug_information [first].range_lists [0]);
- while (start < end)
+ printf (_("Contents of the .debug_ranges section:\n\n"));
+ printf (_(" Offset Begin End\n"));
+
+ seen_first_offset = 0;
+ for (i = first; i < num_debug_info_entries; i++)
{
- unsigned long a;
- unsigned long b;
+ unsigned long begin;
+ unsigned long end;
+ unsigned long offset;
+ unsigned int pointer_size;
+ unsigned long base_address;
- a = byte_get (start, 4);
- b = byte_get (start + 4, 4);
+ pointer_size = debug_information [i].pointer_size;
- if (a == 0xffffffff)
+ for (j = 0; j < debug_information [i].num_range_lists; j++)
{
- /* Attempt to handle 64-bit DWARF3 format. This assumes
- that in a 32-bit DWARF3 file the base address will
- never be 0xffffffff, and that the .debug_ranges section
- will never contain a mixture of 32-bit and 64-bit entries. */
- if (b == 0xffffffff)
- return display_64bit_debug_ranges (start, end);
-
- printf (_(" set base address to 0x%lx\n"), b);
- base_address = b;
- }
- else if (a == 0 && b == 0)
- printf (_(" end of range\n"));
- else if (a > b)
- printf (_(" <corrupt range entry, start is greater than end>\n"));
- else if (base_address == 0)
- printf (_(" range from base address + 0x%lx to base address + 0x%lx\n"), a, b);
- else
- printf (_(" range from 0x%lx to 0x%lx\n"), base_address + a, base_address + b);
+ offset = debug_information [i].range_lists [j];
+ next = section_begin + offset;
+ base_address = debug_information [i].base_address;
- start += 8;
- }
+ if (!seen_first_offset)
+ seen_first_offset = 1;
+ else
+ {
+ if (start < next)
+ warn (_("There is a hole [0x%lx - 0x%lx] in .debug_ranges section.\n"),
+ start - section_begin, next - section_begin);
+ else if (start > next)
+ warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_ranges section.\n"),
+ start - section_begin, next - section_begin);
+ }
+ start = next;
+
+ while (1)
+ {
+ begin = byte_get (start, pointer_size);
+ start += pointer_size;
+ end = byte_get (start, pointer_size);
+ start += pointer_size;
+ if (begin == 0 && end == 0)
+ break;
+
+ /* Check base address specifiers. */
+ if (begin == -1UL && end != -1UL)
+ {
+ base_address = end;
+ printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
+ offset, begin, end);
+ continue;
+ }
+
+ printf (" %8.8lx %8.8lx %8.8lx",
+ offset, begin + base_address, end + base_address);
+
+ if (begin == end)
+ fputs (_(" (start == end)"), stdout);
+ else if (begin > end)
+ fputs (_(" (start > end)"), stdout);
+
+ putchar ('\n');
+ }
+ fputs (_(" <End of list>\n"), stdout);
+ }
+ }
+ putchar ('\n');
return 1;
}
switch (encoding & 0x7)
{
default: /* ??? */
- case 0: return is_32bit_elf ? 4 : 8;
+ case 0: return eh_addr_size;
case 2: return 2;
case 3: return 4;
case 4: return 8;
int is_eh = streq (SECTION_NAME (section), ".eh_frame");
int length_return;
int max_regs = 0;
- int addr_size = is_32bit_elf ? 4 : 8;
printf (_("The section %s contains:\n"), SECTION_NAME (section));
int need_col_headers = 1;
unsigned char *augmentation_data = NULL;
unsigned long augmentation_data_len = 0;
- int encoded_ptr_size = addr_size;
+ int encoded_ptr_size = eh_addr_size;
int offset_size;
int initial_length_size;
}
else if (streq (fc->augmentation, "eh"))
{
- start += addr_size;
+ start += eh_addr_size;
fc->code_factor = LEB ();
fc->data_factor = SLEB ();
if (version == 1)
if (! do_debug_frames_interp)
{
printf (" DW_CFA_def_cfa_expression (");
- decode_location_expression (start, addr_size, ul, 0);
+ decode_location_expression (start, eh_addr_size, ul, 0);
printf (")\n");
}
fc->cfa_exp = 1;
if (! do_debug_frames_interp)
{
printf (" DW_CFA_expression: r%ld (", reg);
- decode_location_expression (start, addr_size, ul, 0);
+ decode_location_expression (start, eh_addr_size, ul, 0);
printf (")\n");
}
fc->col_type[reg] = DW_CFA_expression;
if (debug_information)
{
for (i = 0; i < num_debug_info_entries; i++)
- if (!debug_information [i].max_loc_offsets)
- {
- free (debug_information [i].loc_offsets);
- free (debug_information [i].have_frame_base);
- }
+ {
+ if (!debug_information [i].max_loc_offsets)
+ {
+ free (debug_information [i].loc_offsets);
+ free (debug_information [i].have_frame_base);
+ }
+ if (!debug_information [i].max_range_lists)
+ free (debug_information [i].range_lists);
+ }
free (debug_information);
debug_information = NULL;
num_debug_info_entries = 0;
projects / deliverable / binutils-gdb.git / blobdiff