asection *sec;
bfd_byte *sec_info_ptr;
+ /* A pointer to the memory block allocated for info_ptr. Neither
+ info_ptr nor sec_info_ptr are guaranteed to stay pointing to the
+ beginning of the malloc block. This is used only to free the
+ memory later. */
+ bfd_byte *info_ptr_memory;
+
/* Pointer to the symbol table. */
asymbol **syms;
bfd_byte *dwarf_abbrev_buffer;
/* Length of the loaded .debug_abbrev section. */
- unsigned long dwarf_abbrev_size;
+ bfd_size_type dwarf_abbrev_size;
/* Buffer for decode_line_info. */
bfd_byte *dwarf_line_buffer;
/* Length of the loaded .debug_line section. */
- unsigned long dwarf_line_size;
+ bfd_size_type dwarf_line_size;
/* Pointer to the .debug_str section loaded into memory. */
bfd_byte *dwarf_str_buffer;
/* Length of the loaded .debug_str section. */
- unsigned long dwarf_str_size;
+ bfd_size_type dwarf_str_size;
/* Pointer to the .debug_ranges section loaded into memory. */
bfd_byte *dwarf_ranges_buffer;
/* Length of the loaded .debug_ranges section. */
- unsigned long dwarf_ranges_size;
+ bfd_size_type dwarf_ranges_size;
/* If the most recent call to bfd_find_nearest_line was given an
address in an inlined function, preserve a pointer into the
return entry ? entry->head : NULL;
}
+/* Read a section into its appropriate place in the dwarf2_debug
+ struct (indicated by SECTION_BUFFER and SECTION_SIZE). If syms is
+ not NULL, use bfd_simple_get_relocated_section_contents to read the
+ section contents, otherwise use bfd_get_section_contents. */
+
+static bfd_boolean
+read_section (bfd *abfd,
+ const char* section_name, const char* compressed_section_name,
+ asymbol** syms, bfd_uint64_t offset,
+ bfd_byte **section_buffer, bfd_size_type *section_size)
+{
+ asection *msec;
+ bfd_boolean section_is_compressed = FALSE;
+
+ /* read_section is a noop if the section has already been read. */
+ if (*section_buffer)
+ return TRUE;
+
+ msec = bfd_get_section_by_name (abfd, section_name);
+ if (! msec && compressed_section_name)
+ {
+ msec = bfd_get_section_by_name (abfd, compressed_section_name);
+ section_is_compressed = TRUE;
+ }
+ if (! msec)
+ {
+ (*_bfd_error_handler) (_("Dwarf Error: Can't find %s section."), section_name);
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
+ }
+
+ if (syms)
+ {
+ *section_size = msec->size;
+ *section_buffer
+ = bfd_simple_get_relocated_section_contents (abfd, msec, NULL, syms);
+ if (! *section_buffer)
+ return FALSE;
+ }
+ else
+ {
+ *section_size = msec->rawsize ? msec->rawsize : msec->size;
+ *section_buffer = bfd_malloc (*section_size);
+ if (! *section_buffer)
+ return FALSE;
+ if (! bfd_get_section_contents (abfd, msec, *section_buffer,
+ 0, *section_size))
+ return FALSE;
+ }
+
+ if (section_is_compressed)
+ {
+ if (! bfd_uncompress_section_contents (section_buffer, section_size))
+ {
+ (*_bfd_error_handler) (_("Dwarf Error: unable to decompress %s section."), compressed_section_name);
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
+ }
+ }
+
+ /* It is possible to get a bad value for the offset into the section
+ * that the client wants. Validate it here to avoid trouble later. */
+ if (offset != 0 && offset >= *section_size)
+ {
+ (*_bfd_error_handler) (_("Dwarf Error: Offset (%lu) greater than or equal to %s size (%lu)."),
+ offset, section_name, *section_size);
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
/* VERBATIM
The following function up to the END VERBATIM mark are
copied directly from dwarf2read.c. */
offset = read_8_bytes (unit->abfd, buf);
*bytes_read_ptr = unit->offset_size;
- if (! stash->dwarf_str_buffer)
- {
- asection *msec;
- bfd *abfd = unit->abfd;
- bfd_size_type sz;
-
- msec = bfd_get_section_by_name (abfd, ".debug_str");
- if (! msec)
- {
- (*_bfd_error_handler)
- (_("Dwarf Error: Can't find .debug_str section."));
- bfd_set_error (bfd_error_bad_value);
- return NULL;
- }
-
- sz = msec->rawsize ? msec->rawsize : msec->size;
- stash->dwarf_str_size = sz;
- stash->dwarf_str_buffer = bfd_alloc (abfd, sz);
- if (! stash->dwarf_str_buffer)
- return NULL;
-
- if (! bfd_get_section_contents (abfd, msec, stash->dwarf_str_buffer,
- 0, sz))
- return NULL;
- }
-
- if (offset >= stash->dwarf_str_size)
- {
- (*_bfd_error_handler) (_("Dwarf Error: DW_FORM_strp offset (%lu) greater than or equal to .debug_str size (%lu)."),
- (unsigned long) offset, stash->dwarf_str_size);
- bfd_set_error (bfd_error_bad_value);
- return NULL;
- }
+ if (! read_section (unit->abfd, ".debug_str", ".zdebug_str",
+ 0, offset,
+ &stash->dwarf_str_buffer, &stash->dwarf_str_size))
+ return 0;
str = (char *) stash->dwarf_str_buffer + offset;
if (*str == '\0')
unsigned int abbrev_form, hash_number;
bfd_size_type amt;
- if (! stash->dwarf_abbrev_buffer)
- {
- asection *msec;
-
- msec = bfd_get_section_by_name (abfd, ".debug_abbrev");
- if (! msec)
- {
- (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_abbrev section."));
- bfd_set_error (bfd_error_bad_value);
- return 0;
- }
-
- stash->dwarf_abbrev_size = msec->size;
- stash->dwarf_abbrev_buffer
- = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
- stash->syms);
- if (! stash->dwarf_abbrev_buffer)
- return 0;
- }
-
- if (offset >= stash->dwarf_abbrev_size)
- {
- (*_bfd_error_handler) (_("Dwarf Error: Abbrev offset (%lu) greater than or equal to .debug_abbrev size (%lu)."),
- (unsigned long) offset, stash->dwarf_abbrev_size);
- bfd_set_error (bfd_error_bad_value);
- return 0;
- }
+ if (! read_section (abfd, ".debug_abbrev", ".zdebug_abbrev",
+ stash->syms, offset,
+ &stash->dwarf_abbrev_buffer, &stash->dwarf_abbrev_size))
+ return 0;
amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
abbrevs = bfd_zalloc (abfd, amt);
while (abbrev)
{
- struct abbrev_info * a = abbrev;
-
- abbrev = a->next;
- if (a->attrs)
- free (abbrev->attrs);
- free (a);
+ free (abbrev->attrs);
+ abbrev = abbrev->next;
}
}
-
- free (abbrevs);
return NULL;
}
cur_abbrev->attrs = tmp;
first_arange->next = arange;
}
-/* Decode the line number information for UNIT.
- Note: this function allocates memory. It is the caller's
- responsibility to free it. */
+/* Decode the line number information for UNIT. */
-static struct line_info_table *
+static struct line_info_table*
decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
{
bfd *abfd = unit->abfd;
unsigned char op_code, extended_op, adj_opcode;
bfd_size_type amt;
- if (! stash->dwarf_line_buffer)
- {
- asection *msec;
-
- msec = bfd_get_section_by_name (abfd, ".debug_line");
- if (! msec)
- {
- (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_line section."));
- bfd_set_error (bfd_error_bad_value);
- return 0;
- }
-
- stash->dwarf_line_size = msec->size;
- stash->dwarf_line_buffer
- = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
- stash->syms);
- if (! stash->dwarf_line_buffer)
- return 0;
- }
-
- /* It is possible to get a bad value for the line_offset. Validate
- it here so that we won't get a segfault below. */
- if (unit->line_offset >= stash->dwarf_line_size)
- {
- (*_bfd_error_handler) (_("Dwarf Error: Line offset (%lu) greater than or equal to .debug_line size (%lu)."),
- unit->line_offset, stash->dwarf_line_size);
- bfd_set_error (bfd_error_bad_value);
- return 0;
- }
+ if (! read_section (abfd, ".debug_line", ".zdebug_line",
+ stash->syms, unit->line_offset,
+ &stash->dwarf_line_buffer, &stash->dwarf_line_size))
+ return 0;
amt = sizeof (struct line_info_table);
table = bfd_alloc (abfd, amt);
if (tmp == NULL)
{
free (table->dirs);
- free (table);
return NULL;
}
table->dirs = tmp;
{
free (table->files);
free (table->dirs);
- free (table);
return NULL;
}
table->files = tmp;
{
free (table->files);
free (table->dirs);
- free (table);
free (filename);
return NULL;
}
free (filename);
free (table->files);
free (table->dirs);
- free (table);
return NULL;
}
break;
read_debug_ranges (struct comp_unit *unit)
{
struct dwarf2_debug *stash = unit->stash;
- if (! stash->dwarf_ranges_buffer)
- {
- bfd *abfd = unit->abfd;
- asection *msec;
-
- msec = bfd_get_section_by_name (abfd, ".debug_ranges");
- if (! msec)
- {
- (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_ranges section."));
- bfd_set_error (bfd_error_bad_value);
- return FALSE;
- }
-
- stash->dwarf_ranges_size = msec->size;
- stash->dwarf_ranges_buffer
- = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
- stash->syms);
- if (! stash->dwarf_ranges_buffer)
- return FALSE;
- }
- return TRUE;
+ return read_section (unit->abfd, ".debug_ranges", ".zdebug_ranges",
+ stash->syms, 0,
+ &stash->dwarf_ranges_buffer, &stash->dwarf_ranges_size);
}
/* Function table functions. */
/* DWARF2 Compilation unit functions. */
/* Scan over each die in a comp. unit looking for functions to add
- to the function table and variables to the variable table.
- Returns TRUE upon success, FALSE otherwise. Allocates memory
- blocks to the unit->function_table and unit->variable_table fields.
- It is the caller's responsibility to free this memory. */
+ to the function table and variables to the variable table. */
static bfd_boolean
scan_unit_for_symbols (struct comp_unit *unit)
nested_funcs = bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *));
if (nested_funcs == NULL)
return FALSE;
- nested_funcs[nesting_level] = NULL;
+ nested_funcs[nesting_level] = 0;
while (nesting_level)
{
|| abbrev->tag == DW_TAG_inlined_subroutine)
{
bfd_size_type amt = sizeof (struct funcinfo);
-
func = bfd_zalloc (abfd, amt);
func->tag = abbrev->tag;
func->prev_func = unit->function_table;
if (abbrev->tag == DW_TAG_variable)
{
bfd_size_type amt = sizeof (struct varinfo);
-
var = bfd_zalloc (abfd, amt);
var->tag = abbrev->tag;
var->stack = 1;
identify and discard duplicate debugging sections for different
compilation units. */
#define DWARF2_DEBUG_INFO ".debug_info"
+#define DWARF2_COMPRESSED_DEBUG_INFO ".zdebug_info"
#define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
static asection *
if (strcmp (msec->name, DWARF2_DEBUG_INFO) == 0)
return msec;
+ if (strcmp (msec->name, DWARF2_COMPRESSED_DEBUG_INFO) == 0)
+ return msec;
+
if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
return msec;
else
debug_bfd = abfd;
- /* There can be more than one DWARF2 info section in a BFD these days.
- Read them all in and produce one large stash. We do this in two
- passes - in the first pass we just accumulate the section sizes.
- In the second pass we read in the section's contents. The allows
- us to avoid reallocing the data as we add sections to the stash. */
- for (total_size = 0; msec; msec = find_debug_info (debug_bfd, msec))
- total_size += msec->size;
-
- stash->info_ptr = bfd_alloc (debug_bfd, total_size);
- if (stash->info_ptr == NULL)
- goto done;
-
- stash->info_ptr_end = stash->info_ptr;
-
- for (msec = find_debug_info (debug_bfd, NULL);
- msec;
- msec = find_debug_info (debug_bfd, msec))
- {
- bfd_size_type size;
- bfd_size_type start;
-
- size = msec->size;
- if (size == 0)
- continue;
-
- start = stash->info_ptr_end - stash->info_ptr;
-
- if ((bfd_simple_get_relocated_section_contents
- (debug_bfd, msec, stash->info_ptr + start, symbols)) == NULL)
- continue;
-
- stash->info_ptr_end = stash->info_ptr + start + size;
- }
-
- BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size);
+ /* There can be more than one DWARF2 info section in a BFD these
+ days. First handle the easy case when there's only one. If
+ there's more than one, try case two: none of the sections is
+ compressed. In that case, read them all in and produce one
+ large stash. We do this in two passes - in the first pass we
+ just accumulate the section sizes, and in the second pass we
+ read in the section's contents. (The allows us to avoid
+ reallocing the data as we add sections to the stash.) If
+ some or all sections are compressed, then do things the slow
+ way, with a bunch of reallocs. */
+
+ if (! find_debug_info (debug_bfd, msec))
+ {
+ /* Case 1: only one info section. */
+ total_size = msec->size;
+ if (! read_section (debug_bfd, ".debug_info", ".zdebug_info",
+ symbols, 0,
+ &stash->info_ptr_memory, &total_size))
+ goto done;
+ stash->info_ptr = stash->info_ptr_memory;
+ stash->info_ptr_end = stash->info_ptr + total_size;
+ }
+ else
+ {
+ int all_uncompressed = 1;
+ for (total_size = 0; msec; msec = find_debug_info (debug_bfd, msec))
+ {
+ total_size += msec->size;
+ if (strcmp (msec->name, DWARF2_COMPRESSED_DEBUG_INFO) == 0)
+ all_uncompressed = 0;
+ }
+ if (all_uncompressed)
+ {
+ /* Case 2: multiple sections, but none is compressed. */
+ stash->info_ptr_memory = bfd_malloc (total_size);
+ if (stash->info_ptr_memory == NULL)
+ goto done;
+
+ stash->info_ptr = stash->info_ptr_memory;
+ stash->info_ptr_end = stash->info_ptr;
+
+ for (msec = find_debug_info (debug_bfd, NULL);
+ msec;
+ msec = find_debug_info (debug_bfd, msec))
+ {
+ bfd_size_type size;
+ bfd_size_type start;
+
+ size = msec->size;
+ if (size == 0)
+ continue;
+
+ start = stash->info_ptr_end - stash->info_ptr;
+
+ if ((bfd_simple_get_relocated_section_contents
+ (debug_bfd, msec, stash->info_ptr + start, symbols))
+ == NULL)
+ continue;
+
+ stash->info_ptr_end = stash->info_ptr + start + size;
+ }
+
+ BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size);
+ }
+ else
+ {
+ /* Case 3: multiple sections, some or all compressed. */
+ stash->info_ptr_memory = bfd_malloc (1);
+ stash->info_ptr = stash->info_ptr_memory;
+ stash->info_ptr_end = stash->info_ptr;
+ for (msec = find_debug_info (debug_bfd, NULL);
+ msec;
+ msec = find_debug_info (debug_bfd, msec))
+ {
+ bfd_size_type size = msec->size;
+ bfd_byte* buffer
+ = (bfd_simple_get_relocated_section_contents
+ (debug_bfd, msec, NULL, symbols));
+ if (! buffer)
+ continue;
+ if (strcmp (msec->name, DWARF2_COMPRESSED_DEBUG_INFO) == 0)
+ {
+ if (! bfd_uncompress_section_contents (&buffer, &size))
+ continue;
+ }
+ stash->info_ptr = bfd_realloc (stash->info_ptr,
+ stash->info_ptr_end
+ - stash->info_ptr + size);
+ memcpy (stash->info_ptr_end, buffer, size);
+ free (buffer);
+ stash->info_ptr_end += size;
+ }
+ }
+ }
stash->sec = find_debug_info (debug_bfd, NULL);
stash->sec_info_ptr = stash->info_ptr;
for (each = stash->all_comp_units; each; each = each->next_unit)
{
- struct funcinfo * function_table = each->function_table;
- struct varinfo * variable_table = each->variable_table;
+ struct abbrev_info **abbrevs = each->abbrevs;
+ struct funcinfo *function_table = each->function_table;
+ struct varinfo *variable_table = each->variable_table;
+ size_t i;
- if (each->abbrevs != NULL)
+ for (i = 0; i < ABBREV_HASH_SIZE; i++)
{
- size_t i;
+ struct abbrev_info *abbrev = abbrevs[i];
- for (i = 0; i < ABBREV_HASH_SIZE; i++)
+ while (abbrev)
{
- struct abbrev_info *abbrev = each->abbrevs[i];
-
- while (abbrev)
- {
- struct abbrev_info * a = abbrev;
-
- abbrev = a->next;
- if (a->attrs)
- free (a->attrs);
- free (a);
- }
+ free (abbrev->attrs);
+ abbrev = abbrev->next;
}
-
- free (each->abbrevs);
- each->abbrevs = NULL;
}
if (each->line_table)
{
- /* FIXME: We should free the line_info structures as well. */
- if (each->line_table->dirs)
- free (each->line_table->dirs);
-
- if (each->line_table->files)
- free (each->line_table->files);
-
- free (each->line_table);
- each->line_table = NULL;
+ free (each->line_table->dirs);
+ free (each->line_table->files);
}
while (function_table)
{
- struct funcinfo * f = function_table;
-
- function_table = f->prev_func;
-
- if (f->file)
- free (f->file);
-
- if (f->caller_file)
- free (f->caller_file);
+ if (function_table->file)
+ {
+ free (function_table->file);
+ function_table->file = NULL;
+ }
- free (f);
+ if (function_table->caller_file)
+ {
+ free (function_table->caller_file);
+ function_table->caller_file = NULL;
+ }
+ function_table = function_table->prev_func;
}
- each->function_table = NULL;
-
while (variable_table)
{
- struct varinfo * v = variable_table;
+ if (variable_table->file)
+ {
+ free (variable_table->file);
+ variable_table->file = NULL;
+ }
variable_table = variable_table->prev_var;
-
- if (v->file)
- free (v->file);
-
- free (v);
}
-
- each->variable_table = NULL;
}
free (stash->dwarf_abbrev_buffer);
free (stash->dwarf_line_buffer);
free (stash->dwarf_ranges_buffer);
+ free (stash->info_ptr_memory);
}
projects / deliverable / binutils-gdb.git / blobdiff