/* DWARF 2 support.
Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
- 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
+ 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
Adapted from gdb/dwarf2read.c by Gavin Koch of Cygnus Solutions
(gavin@cygnus.com).
#include "libbfd.h"
#include "elf-bfd.h"
#include "elf/dwarf2.h"
-#include "arange-set.h"
/* The data in the .debug_line statement prologue looks like this. */
bfd_byte *data;
};
-struct loadable_section
+struct adjusted_section
{
asection *section;
bfd_vma adj_vma;
/* Last comp unit in list above. */
struct comp_unit *last_comp_unit;
- /* Number of comp units. */
- int comp_unit_count;
-
/* The next unread compilation unit within the .debug_info section.
Zero indicates that the .debug_info section has not been loaded
into a buffer yet. */
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
use. */
struct funcinfo *inliner_chain;
- /* Number of loadable sections. */
- unsigned int loadable_section_count;
+ /* Number of sections whose VMA we must adjust. */
+ unsigned int adjusted_section_count;
- /* Array of loadable sections. */
- struct loadable_section *loadable_sections;
+ /* Array of sections with adjusted VMA. */
+ struct adjusted_section *adjusted_sections;
/* Number of times find_line is called. This is used in
the heuristic for enabling the info hash tables. */
#define STASH_INFO_HASH_OFF 0
#define STASH_INFO_HASH_ON 1
#define STASH_INFO_HASH_DISABLED 2
-
- /* Arange-set for fast lookup. The aranges in this set have pointers
- to compilation units containing them. In the unlikely case that there
- are multiple compilation units associated with an arange, the arange-set
- is a NULL pointer and we need to fall back to sequential search. */
- arange_set comp_unit_arange_set;
-
- /* Status of global arange set. */
- int arange_set_status;
-#define STASH_ARANGE_SET_OFF 0
-#define STASH_ARANGE_SET_ON 1
-#define STASH_ARANGE_SET_DISABLED 2
-
- /* Build a whole binary arange-set for compilation unit look-up
- if there are at least this many compilation units. */
-#define STASH_ARANGE_SET_TRIGGER 500
};
-/* Simple singly linked list for aranges. We now use a more scalable
- arange-set for aranges in compilation units. For functions, we still
- use this since it is more efficient for simple cases. */
-
struct arange
{
struct arange *next;
- /* The lowest and highest addresses contained a compilation
- unit as specified in the compilation unit's header. */
bfd_vma low;
bfd_vma high;
};
/* Keep the bfd convenient (for memory allocation). */
bfd *abfd;
- /* The set of aranges in a compilation unit. */
- arange_set arange_set;
+ /* The lowest and highest addresses contained in this compilation
+ unit as specified in the compilation unit header. */
+ struct arange arange;
/* The DW_AT_name attribute (for error messages). */
char *name;
/* Pointer to dwarf2_debug structure. */
struct dwarf2_debug *stash;
+ /* DWARF format version for this unit - from unit header. */
+ int version;
+
/* Address size for this unit - from unit header. */
unsigned char addr_size;
/* Call the allocation method of the base class. */
ret = ((struct info_hash_entry *)
- bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
+ bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
/* Initialize the local fields here. */
if (ret)
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. Fail if
+ the located section does not contain at least OFFSET bytes. */
+
+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)
+ {
+ 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;
+ }
+
+ *section_size = msec->rawsize ? msec->rawsize : msec->size;
+ if (syms)
+ {
+ *section_buffer
+ = bfd_simple_get_relocated_section_contents (abfd, msec, NULL, syms);
+ if (! *section_buffer)
+ return FALSE;
+ }
+ else
+ {
+ *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)."),
+ (long) 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. */
bfd_byte *buf,
unsigned int size ATTRIBUTE_UNUSED)
{
- /* If the size of a host char is 8 bits, we can return a pointer
- to the buffer, otherwise we have to copy the data to a buffer
- allocated on the temporary obstack. */
return buf;
}
{
/* Return a pointer to the embedded string. */
char *str = (char *) buf;
+
if (*str == '\0')
{
*bytes_read_ptr = 1;
return str;
}
+/* END VERBATIM */
+
static char *
-read_indirect_string (struct comp_unit* unit,
- bfd_byte *buf,
- unsigned int *bytes_read_ptr)
+read_indirect_string (struct comp_unit * unit,
+ bfd_byte * buf,
+ unsigned int * bytes_read_ptr)
{
bfd_uint64_t offset;
struct dwarf2_debug *stash = unit->stash;
offset = read_4_bytes (unit->abfd, buf);
else
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;
- }
+ *bytes_read_ptr = unit->offset_size;
- 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",
+ stash->syms, offset,
+ &stash->dwarf_str_buffer, &stash->dwarf_str_size))
+ return NULL;
str = (char *) stash->dwarf_str_buffer + offset;
if (*str == '\0')
return str;
}
-/* END VERBATIM */
-
static bfd_uint64_t
read_address (struct comp_unit *unit, bfd_byte *buf)
{
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);
switch (form)
{
- case DW_FORM_addr:
- /* FIXME: DWARF3 draft says DW_FORM_ref_addr is offset_size. */
case DW_FORM_ref_addr:
+ /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
+ DWARF3. */
+ if (unit->version == 3)
+ {
+ if (unit->offset_size == 4)
+ attr->u.val = read_4_bytes (unit->abfd, info_ptr);
+ else
+ attr->u.val = read_8_bytes (unit->abfd, info_ptr);
+ info_ptr += unit->offset_size;
+ break;
+ }
+ /* FALLTHROUGH */
+ case DW_FORM_addr:
attr->u.val = read_address (unit, info_ptr);
info_ptr += unit->addr_size;
break;
char *comp_dir;
char **dirs;
struct fileinfo* files;
- struct line_info* last_line; /* Largest VMA. */
- struct line_info* lcl_head; /* Local head; used in 'add_line_info'. */
+ struct line_info* last_line; /* largest VMA */
+ struct line_info* lcl_head; /* local head; used in 'add_line_info' */
};
/* Remember some information about each function. If the function is
struct funcinfo
{
- struct funcinfo *prev_func; /* Pointer to previous function in list of all functions. */
- struct funcinfo *caller_func; /* Pointer to function one scope higher. */
- char *caller_file; /* Source location file name where caller_func inlines this func. */
- int caller_line; /* Source location line number where caller_func inlines this func. */
- char *file; /* Source location file name. */
- int line; /* Source location line number. */
+ struct funcinfo *prev_func; /* Pointer to previous function in list of all functions */
+ struct funcinfo *caller_func; /* Pointer to function one scope higher */
+ char *caller_file; /* Source location file name where caller_func inlines this func */
+ int caller_line; /* Source location line number where caller_func inlines this func */
+ char *file; /* Source location file name */
+ int line; /* Source location line number */
int tag;
char *name;
struct arange arange;
- asection *sec; /* Where the symbol is defined. */
+ asection *sec; /* Where the symbol is defined */
};
struct varinfo
{
- /* Pointer to previous variable in list of all variables. */
+ /* Pointer to previous variable in list of all variables */
struct varinfo *prev_var;
- /* Source location file name. */
+ /* Source location file name */
char *file;
- /* Source location line number. */
+ /* Source location line number */
int line;
int tag;
char *name;
bfd_vma addr;
- /* Where the symbol is defined. */
+ /* Where the symbol is defined */
asection *sec;
- /* Is this a stack variable? */
+ /* Is this a stack variable? */
unsigned int stack: 1;
};
-/* Arange-sets:
-
- To handle extremely large binaries, we want to use a more efficient data
- structure than a singly-linked list to represent aranges. So instead we
- use an arange-set, which supports efficient insertions and queries. We
- use a simple arange-set with no values attached to represent the aranges
- in a compilation unit and we also use a global arange-set to store all
- the aranges in all the compilation units. The global arange-set stores
- values which are pointers to the compilation units.
-
- Normally aranges in the global set do not overlap, but this can happen.
- To simplify things and to prevent excessive memory usage, an arange in
- the global set can only point to at most one compilation unit. In case
- of an overlap, the pointer is set to NULL, meaning that there are more
- than one compilation units containing that arange. Code that looks up
- the global set should fall back to searching all compilation units if
- that happens. */
-
-/* Allocate memory for an arange set. */
-
-static void *
-dwarf2_arange_set_allocate (int size, void *data)
-{
- return bfd_alloc ((bfd *) data, size);
-}
-
-/* Deallocate memory of an arange set. */
-
-static void
-dwarf2_arange_set_deallocate (void *object ATTRIBUTE_UNUSED,
- void *data ATTRIBUTE_UNUSED)
-{
- /* Do nothing. Let BFD clean up when it's done. */
-}
-
-/* Combine two comp unit pointers. If they are the same,
- return either one, otherwise return NULL. */
-
-static arange_value_type
-dwarf2_combine_arange_value (arange_value_type value1,
- arange_value_type value2,
- void *data ATTRIBUTE_UNUSED)
-{
- return ((value1 == value2) ? value1 : 0);
-}
-
-/* Create a simple arange set that does not store values. */
-
-static arange_set
-dwarf2_arange_set_new (bfd *abfd)
-{
- return arange_set_new (dwarf2_arange_set_allocate,
- dwarf2_arange_set_deallocate,
- FALSE, NULL, NULL, NULL, NULL, (void *) abfd);
-}
-
-/* Create an arange set that stores pointers to compilation units. */
-
-static arange_set
-dwarf2_arange_set_with_value_new (bfd *abfd)
-{
- return arange_set_new (dwarf2_arange_set_allocate,
- dwarf2_arange_set_deallocate,
- TRUE, NULL, NULL, dwarf2_combine_arange_value,
- NULL, (void *) abfd);
-}
-
-/* Add an arange to a compilation unit. Add the arange to both the
- unit's valueless arange set and the global arange set. */
-
-static void
-dwarf2_comp_unit_arange_add (struct comp_unit *unit,
- bfd_vma low,
- bfd_vma high)
-{
- /* Add arange to unit's local arange set. */
- arange_set_insert (unit->arange_set, low, high - 1, 0);
-
- if (unit->stash->arange_set_status == STASH_ARANGE_SET_ON)
- {
- BFD_ASSERT (unit->stash->comp_unit_arange_set);
- arange_set_insert (unit->stash->comp_unit_arange_set, low, high - 1,
- (arange_value_type) unit);
- }
-}
-
/* Return TRUE if NEW_LINE should sort after LINE. */
static inline bfd_boolean
int end_sequence)
{
bfd_size_type amt = sizeof (struct line_info);
- struct line_info * info = bfd_alloc (table->abfd, amt);
+ struct line_info* info = bfd_alloc (table->abfd, amt);
/* Set member data of 'info'. */
info->address = address;
table->last_line = info;
}
else if (!table->last_line
- || new_line_sorts_after (info, table->last_line))
+ || new_line_sorts_after (info, table->last_line))
{
- /* Normal case: add 'info' to the beginning of the list. */
+ /* Normal case: add 'info' to the beginning of the list */
info->prev_line = table->last_line;
table->last_line = info;
{
/* Abnormal and hard: Neither 'last_line' nor 'lcl_head' are valid
heads for 'info'. Reset 'lcl_head'. */
- struct line_info* li2 = table->last_line; /* Always non-NULL. */
+ struct line_info* li2 = table->last_line; /* always non-NULL */
struct line_info* li1 = li2->prev_line;
while (li1)
&& new_line_sorts_after (info, li1))
break;
- li2 = li1; /* Always non-NULL. */
+ li2 = li1; /* always non-NULL */
li1 = li1->prev_line;
}
table->lcl_head = li2;
}
static void
-arange_add (bfd *abfd, struct arange *first_arange, bfd_vma low_pc,
- bfd_vma high_pc)
+arange_add (bfd *abfd, struct arange *first_arange, bfd_vma low_pc, bfd_vma high_pc)
{
struct arange *arange;
- /* If the first arange is empty, use it. */
+ /* If the first arange is empty, use it. */
if (first_arange->high == 0)
{
first_arange->low = low_pc;
while (arange);
/* Need to allocate a new arange and insert it into the arange list.
- Order isn't significant, so just insert after the first arange. */
+ Order isn't significant, so just insert after the first arange. */
arange = bfd_zalloc (abfd, sizeof (*arange));
arange->low = low_pc;
arange->high = high_pc;
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);
low_pc = address;
if (address > high_pc)
high_pc = address;
- dwarf2_comp_unit_arange_add (unit, low_pc, high_pc);
+ arange_add (unit->abfd, &unit->arange, low_pc, high_pc);
break;
case DW_LNE_set_address:
address = read_address (unit, line_ptr);
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. */
}
static char *
-find_abstract_instance_name (struct comp_unit *unit, bfd_uint64_t die_ref)
+find_abstract_instance_name (struct comp_unit *unit,
+ struct attribute *attr_ptr)
{
bfd *abfd = unit->abfd;
bfd_byte *info_ptr;
unsigned int abbrev_number, bytes_read, i;
struct abbrev_info *abbrev;
+ bfd_uint64_t die_ref = attr_ptr->u.val;
struct attribute attr;
char *name = 0;
- info_ptr = unit->info_ptr_unit + die_ref;
+ /* DW_FORM_ref_addr can reference an entry in a different CU. It
+ is an offset from the .debug_info section, not the current CU. */
+ if (attr_ptr->form == DW_FORM_ref_addr)
+ {
+ /* We only support DW_FORM_ref_addr within the same file, so
+ any relocations should be resolved already. */
+ if (!die_ref)
+ abort ();
+
+ info_ptr = unit->stash->sec_info_ptr + die_ref;
+ }
+ else
+ info_ptr = unit->info_ptr_unit + die_ref;
abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
info_ptr += bytes_read;
name = attr.u.str;
break;
case DW_AT_specification:
- name = find_abstract_instance_name (unit, attr.u.val);
+ name = find_abstract_instance_name (unit, &attr);
break;
case DW_AT_MIPS_linkage_name:
name = attr.u.str;
}
}
}
- return name;
-}
-
-/* Type of callback function used in read_rangelist below. */
-
-typedef void (*read_rangelist_callback_t)(struct comp_unit*, bfd_vma,
- bfd_vma, void*);
-
-/* Call back to add an arange to the old-style arange list. */
-
-static void
-read_rangelist_insert_arange_list (struct comp_unit *unit,
- bfd_vma low,
- bfd_vma high,
- void *data)
-{
- arange_add (unit->abfd, (struct arange*) data, low, high);
+ return (name);
}
-/* Callback to add an arange in the arange set of a compilation unit. */
-
static void
-read_rangelist_comp_unit_arange_add (struct comp_unit *unit,
- bfd_vma low,
- bfd_vma high,
- void *data ATTRIBUTE_UNUSED)
-{
- dwarf2_comp_unit_arange_add (unit, low, high);
-}
-
-/* Read ARANGE list of a compilation unit. For each read arange,
- call the supplied callback function for further processing. */
-
-static void
-read_rangelist (struct comp_unit *unit,
- bfd_uint64_t offset,
- read_rangelist_callback_t callback,
- void *callback_data)
+read_rangelist (struct comp_unit *unit, struct arange *arange, bfd_uint64_t offset)
{
bfd_byte *ranges_ptr;
bfd_vma base_address = unit->base_address;
bfd_vma low_pc;
bfd_vma high_pc;
- if (unit->addr_size == 4)
- {
- low_pc = read_4_bytes (unit->abfd, ranges_ptr);
- ranges_ptr += 4;
- high_pc = read_4_bytes (unit->abfd, ranges_ptr);
- ranges_ptr += 4;
- }
- else
- {
- low_pc = read_8_bytes (unit->abfd, ranges_ptr);
- ranges_ptr += 8;
- high_pc = read_8_bytes (unit->abfd, ranges_ptr);
- ranges_ptr += 8;
- }
+ low_pc = read_address (unit, ranges_ptr);
+ ranges_ptr += unit->addr_size;
+ high_pc = read_address (unit, ranges_ptr);
+ ranges_ptr += unit->addr_size;
+
if (low_pc == 0 && high_pc == 0)
break;
if (low_pc == -1UL && high_pc != -1UL)
base_address = high_pc;
else
- /* Call callback to process new arange. */
- (callback) (unit, base_address + low_pc, base_address + high_pc,
- callback_data);
+ arange_add (unit->abfd, arange, base_address + low_pc, base_address + high_pc);
}
}
break;
case DW_AT_abstract_origin:
- func->name = find_abstract_instance_name (unit, attr.u.val);
+ func->name = find_abstract_instance_name (unit, &attr);
break;
case DW_AT_name:
break;
case DW_AT_ranges:
- read_rangelist (unit, attr.u.val,
- read_rangelist_insert_arange_list,
- & func->arange);
+ read_rangelist (unit, &func->arange, attr.u.val);
break;
case DW_AT_decl_file:
addr_size = read_1_byte (abfd, info_ptr);
info_ptr += 1;
- if (version != 2)
+ if (version != 2 && version != 3)
{
- (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 information."), version);
+ (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 and 3 information."), version);
bfd_set_error (bfd_error_bad_value);
return 0;
}
amt = sizeof (struct comp_unit);
unit = bfd_zalloc (abfd, amt);
unit->abfd = abfd;
+ unit->version = version;
unit->addr_size = addr_size;
unit->offset_size = offset_size;
unit->abbrevs = abbrevs;
unit->end_ptr = end_ptr;
unit->stash = stash;
unit->info_ptr_unit = info_ptr_unit;
- unit->arange_set = dwarf2_arange_set_new (abfd);
for (i = 0; i < abbrev->num_attrs; ++i)
{
break;
case DW_AT_ranges:
- read_rangelist (unit, attr.u.val,
- read_rangelist_comp_unit_arange_add, NULL);
+ read_rangelist (unit, &unit->arange, attr.u.val);
break;
case DW_AT_comp_dir:
{
char *comp_dir = attr.u.str;
-
if (comp_dir)
{
/* Irix 6.2 native cc prepends <machine>.: to the compilation
break;
}
}
-
if (high_pc != 0)
- dwarf2_comp_unit_arange_add (unit, low_pc, high_pc);
+ {
+ arange_add (unit->abfd, &unit->arange, low_pc, high_pc);
+ }
unit->first_child_die_ptr = info_ptr;
return unit;
static bfd_boolean
comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
{
- return arange_set_lookup_address (unit->arange_set, addr, NULL, NULL, NULL);
+ struct arange *arange;
+
+ if (unit->error)
+ return FALSE;
+
+ arange = &unit->arange;
+ do
+ {
+ if (addr >= arange->low && addr < arange->high)
+ return TRUE;
+ arange = arange->next;
+ }
+ while (arange);
+
+ return FALSE;
}
/* If UNIT contains ADDR, set the output parameters to the values for
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;
return NULL;
}
-/* Unset vmas for loadable sections in STASH. */
+/* Unset vmas for adjusted sections in STASH. */
static void
unset_sections (struct dwarf2_debug *stash)
{
unsigned int i;
- struct loadable_section *p;
+ struct adjusted_section *p;
- i = stash->loadable_section_count;
- p = stash->loadable_sections;
+ i = stash->adjusted_section_count;
+ p = stash->adjusted_sections;
for (; i > 0; i--, p++)
p->section->vma = 0;
}
-/* Set unique vmas for loadable sections in ABFD and save vmas in
- STASH for unset_sections. */
+/* Set unique VMAs for loadable and DWARF sections in ABFD and save
+ VMAs in STASH for unset_sections. */
static bfd_boolean
place_sections (bfd *abfd, struct dwarf2_debug *stash)
{
- struct loadable_section *p;
+ struct adjusted_section *p;
unsigned int i;
- if (stash->loadable_section_count != 0)
+ if (stash->adjusted_section_count != 0)
{
- i = stash->loadable_section_count;
- p = stash->loadable_sections;
+ i = stash->adjusted_section_count;
+ p = stash->adjusted_sections;
for (; i > 0; i--, p++)
p->section->vma = p->adj_vma;
}
else
{
asection *sect;
- bfd_vma last_vma = 0;
+ bfd_vma last_vma = 0, last_dwarf = 0;
bfd_size_type amt;
- struct loadable_section *p;
+ struct adjusted_section *p;
i = 0;
for (sect = abfd->sections; sect != NULL; sect = sect->next)
{
bfd_size_type sz;
+ int is_debug_info;
+
+ if (sect->vma != 0)
+ continue;
+
+ /* We need to adjust the VMAs of any .debug_info sections.
+ Skip compressed ones, since no relocations could target
+ them - they should not appear in object files anyway. */
+ if (strcmp (sect->name, DWARF2_DEBUG_INFO) == 0)
+ is_debug_info = 1;
+ else if (CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO))
+ is_debug_info = 1;
+ else
+ is_debug_info = 0;
- if (sect->vma != 0 || (sect->flags & SEC_LOAD) == 0)
+ if (!is_debug_info && (sect->flags & SEC_LOAD) == 0)
continue;
sz = sect->rawsize ? sect->rawsize : sect->size;
i++;
}
- amt = i * sizeof (struct loadable_section);
- p = (struct loadable_section *) bfd_zalloc (abfd, amt);
+ amt = i * sizeof (struct adjusted_section);
+ p = (struct adjusted_section *) bfd_zalloc (abfd, amt);
if (! p)
return FALSE;
- stash->loadable_sections = p;
- stash->loadable_section_count = i;
+ stash->adjusted_sections = p;
+ stash->adjusted_section_count = i;
for (sect = abfd->sections; sect != NULL; sect = sect->next)
{
bfd_size_type sz;
+ int is_debug_info;
- if (sect->vma != 0 || (sect->flags & SEC_LOAD) == 0)
+ if (sect->vma != 0)
+ continue;
+
+ /* We need to adjust the VMAs of any .debug_info sections.
+ Skip compressed ones, since no relocations could target
+ them - they should not appear in object files anyway. */
+ if (strcmp (sect->name, DWARF2_DEBUG_INFO) == 0)
+ is_debug_info = 1;
+ else if (CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO))
+ is_debug_info = 1;
+ else
+ is_debug_info = 0;
+
+ if (!is_debug_info && (sect->flags & SEC_LOAD) == 0)
continue;
sz = sect->rawsize ? sect->rawsize : sect->size;
continue;
p->section = sect;
- if (last_vma != 0)
+ if (is_debug_info)
+ {
+ BFD_ASSERT (sect->alignment_power == 0);
+ sect->vma = last_dwarf;
+ last_dwarf += sz;
+ }
+ else if (last_vma != 0)
{
/* Align the new address to the current section
alignment. */
+ ~((bfd_vma) -1 << sect->alignment_power))
& ((bfd_vma) -1 << sect->alignment_power));
sect->vma = last_vma;
+ last_vma += sect->vma + sz;
}
+ else
+ last_vma += sect->vma + sz;
+
p->adj_vma = sect->vma;
- last_vma += sect->vma + sz;
p++;
}
filename_ptr, linenumber_ptr);
}
-typedef struct
-{
- struct dwarf2_debug * stash;
- arange_set set;
- struct comp_unit * unit;
-} stash_copy_local_aranges_data_t;
-
-static int
-stash_copy_local_aranges (bfd_vma low,
- bfd_vma high,
- arange_value_type data ATTRIBUTE_UNUSED,
- void *info)
-{
- bfd_boolean status;
-
- stash_copy_local_aranges_data_t *copy_data = info;
- status = arange_set_insert (copy_data->set, low, high,
- (arange_value_type) copy_data->unit);
-
- return status ? 0 : 1;
-}
-
-static bfd_boolean
-stash_maybe_enable_arange_set (bfd *abfd, struct dwarf2_debug *stash)
-{
- struct comp_unit *unit;
- stash_copy_local_aranges_data_t copy_data;
-
- if (stash->arange_set_status != STASH_ARANGE_SET_OFF)
- return TRUE;
-
- if (stash->comp_unit_count < STASH_ARANGE_SET_TRIGGER)
- return TRUE;
-
- if (stash->comp_unit_arange_set == NULL)
- {
- stash->comp_unit_arange_set =
- dwarf2_arange_set_with_value_new (abfd);
- if (!stash->comp_unit_arange_set)
- {
- stash->arange_set_status = STASH_ARANGE_SET_DISABLED;
- return FALSE;
- }
- }
-
- copy_data.stash = stash;
- copy_data.set = stash->comp_unit_arange_set;
- for (unit = stash->all_comp_units; unit; unit = unit->next_unit)
- {
- copy_data.unit = unit;
- if (arange_set_foreach (unit->arange_set, stash_copy_local_aranges,
- & copy_data))
- {
- stash->arange_set_status = STASH_ARANGE_SET_DISABLED;
- return FALSE;
- }
- }
- stash->arange_set_status = STASH_ARANGE_SET_ON;
- return TRUE;
-}
-
-/* Find the nearest line to a given address and record filename,
- function name and line number if found. Return TRUE if a line is
- found or FALSE otherwise. */
-
-static bfd_boolean ATTRIBUTE_UNUSED
-stash_find_nearest_line_fast (struct dwarf2_debug *stash,
- bfd_vma addr,
- const char **filename_ptr,
- const char **functionname_ptr,
- unsigned int *linenumber_ptr)
-{
- arange_value_type value;
- struct comp_unit *unit;
-
- /* Try looking up global arange set first. */
- if (stash->arange_set_status == STASH_ARANGE_SET_ON
- && arange_set_lookup_address (stash->comp_unit_arange_set, addr, NULL,
- NULL, &value))
- {
- if ((unit = (struct comp_unit *) value) != NULL)
- /* There is only one compilation unit containing this address. */
- return comp_unit_find_nearest_line (unit, addr, filename_ptr,
- functionname_ptr, linenumber_ptr,
- stash);
- }
-
- /* The arange set is not available or there are multiple compilation
- units containing this address. Search all compilation units. */
- for (unit = stash->all_comp_units; unit; unit = unit->next_unit)
- {
- if (comp_unit_contains_address (unit, addr)
- && comp_unit_find_nearest_line (unit, addr, filename_ptr,
- functionname_ptr,
- linenumber_ptr, stash))
- return TRUE;
- }
-
- return FALSE;
-}
-
/* Find the source code location of SYMBOL. If SYMBOL is NULL
then find the nearest source code location corresponding to
the address SECTION + OFFSET.
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;
+ /* 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;
+ }
+ 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 = bfd_alloc (debug_bfd, total_size);
- if (stash->info_ptr == NULL)
- goto done;
+ total_size = 0;
+ for (msec = find_debug_info (debug_bfd, NULL);
+ msec;
+ msec = find_debug_info (debug_bfd, msec))
+ {
+ bfd_size_type size;
- stash->info_ptr_end = stash->info_ptr;
+ size = msec->size;
+ if (size == 0)
+ continue;
- for (msec = find_debug_info (debug_bfd, NULL);
- msec;
- msec = find_debug_info (debug_bfd, msec))
- {
- bfd_size_type size;
- bfd_size_type start;
+ if (!(bfd_simple_get_relocated_section_contents
+ (debug_bfd, msec, stash->info_ptr_memory + total_size,
+ symbols)))
+ goto done;
- size = msec->size;
- if (size == 0)
- continue;
+ total_size += size;
+ }
+ }
+ else
+ {
+ /* Case 3: multiple sections, some or all compressed. */
+ stash->info_ptr_memory = NULL;
+ total_size = 0;
+ 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;
- start = stash->info_ptr_end - stash->info_ptr;
+ if (size == 0)
+ continue;
- if ((bfd_simple_get_relocated_section_contents
- (debug_bfd, msec, stash->info_ptr + start, symbols)) == NULL)
- continue;
+ buffer = (bfd_simple_get_relocated_section_contents
+ (debug_bfd, msec, NULL, symbols));
+ if (! buffer)
+ goto done;
- stash->info_ptr_end = stash->info_ptr + start + size;
+ if (strcmp (msec->name, DWARF2_COMPRESSED_DEBUG_INFO) == 0)
+ {
+ if (! bfd_uncompress_section_contents (&buffer, &size))
+ {
+ free (buffer);
+ goto done;
+ }
+ }
+ stash->info_ptr_memory = bfd_realloc (stash->info_ptr_memory,
+ total_size + size);
+ memcpy (stash->info_ptr_memory + total_size, buffer, size);
+ free (buffer);
+ total_size += size;
+ }
+ }
}
- BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size);
-
+ stash->info_ptr = stash->info_ptr_memory;
+ stash->info_ptr_end = stash->info_ptr + total_size;
stash->sec = find_debug_info (debug_bfd, NULL);
stash->sec_info_ptr = stash->info_ptr;
stash->syms = symbols;
}
else
{
- if (stash->arange_set_status == STASH_ARANGE_SET_OFF)
- stash_maybe_enable_arange_set (abfd, stash);
-
- found = stash_find_nearest_line_fast (stash, addr, filename_ptr,
- functionname_ptr, linenumber_ptr);
- if (found)
- goto done;
+ for (each = stash->all_comp_units; each; each = each->next_unit)
+ {
+ found = (comp_unit_contains_address (each, addr)
+ && comp_unit_find_nearest_line (each, addr,
+ filename_ptr,
+ functionname_ptr,
+ linenumber_ptr,
+ stash));
+ if (found)
+ goto done;
+ }
}
/* The DWARF2 spec says that the initial length field, and the
else if (addr_size == 8)
{
offset_size = 4;
- stash->info_ptr += 4;
+ stash->info_ptr += 4;
}
else
stash->info_ptr += 4;
{
each = parse_comp_unit (stash, length, info_ptr_unit,
offset_size);
+ if (!each)
+ /* The dwarf information is damaged, don't trust it any
+ more. */
+ break;
stash->info_ptr += length;
+ if (stash->all_comp_units)
+ stash->all_comp_units->prev_unit = each;
+ else
+ stash->last_comp_unit = each;
+
+ each->next_unit = stash->all_comp_units;
+ stash->all_comp_units = each;
+
+ /* DW_AT_low_pc and DW_AT_high_pc are optional for
+ compilation units. If we don't have them (i.e.,
+ unit->high == 0), we need to consult the line info table
+ to see if a compilation unit contains the given
+ address. */
+ if (do_line)
+ found = (((symbol->flags & BSF_FUNCTION) == 0
+ || each->arange.high == 0
+ || comp_unit_contains_address (each, addr))
+ && comp_unit_find_line (each, symbol, addr,
+ filename_ptr,
+ linenumber_ptr,
+ stash));
+ else
+ found = ((each->arange.high == 0
+ || comp_unit_contains_address (each, addr))
+ && comp_unit_find_nearest_line (each, addr,
+ filename_ptr,
+ functionname_ptr,
+ linenumber_ptr,
+ stash));
+
if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
== stash->sec->size)
{
stash->sec_info_ptr = stash->info_ptr;
}
- if (each)
- {
- if (stash->all_comp_units)
- stash->all_comp_units->prev_unit = each;
- else
- stash->last_comp_unit = each;
-
- each->next_unit = stash->all_comp_units;
- stash->all_comp_units = each;
- stash->comp_unit_count++;
-
- /* DW_AT_low_pc and DW_AT_high_pc are optional for
- compilation units. If we don't have them, we need to
- consult the line info table to see if a compilation unit
- contains the given address. */
- if (do_line)
- found = (((symbol->flags & BSF_FUNCTION) == 0
- || arange_set_empty_p (each->arange_set)
- || comp_unit_contains_address (each, addr))
- && comp_unit_find_line (each, symbol, addr,
- filename_ptr,
- linenumber_ptr,
- stash));
- else
- found = ((arange_set_empty_p (each->arange_set)
- || comp_unit_contains_address (each, addr))
- && comp_unit_find_nearest_line (each, addr,
- filename_ptr,
- functionname_ptr,
- linenumber_ptr,
- stash));
- if (found)
- goto done;
- }
+ if (found)
+ goto done;
}
}
for (each = stash->all_comp_units; each; each = each->next_unit)
{
struct abbrev_info **abbrevs = each->abbrevs;
+ struct funcinfo *function_table = each->function_table;
+ struct varinfo *variable_table = each->variable_table;
size_t i;
for (i = 0; i < ABBREV_HASH_SIZE; i++)
free (each->line_table->dirs);
free (each->line_table->files);
}
+
+ while (function_table)
+ {
+ if (function_table->file)
+ {
+ free (function_table->file);
+ function_table->file = NULL;
+ }
+
+ if (function_table->caller_file)
+ {
+ free (function_table->caller_file);
+ function_table->caller_file = NULL;
+ }
+ function_table = function_table->prev_func;
+ }
+
+ while (variable_table)
+ {
+ if (variable_table->file)
+ {
+ free (variable_table->file);
+ variable_table->file = NULL;
+ }
+
+ variable_table = variable_table->prev_var;
+ }
}
- free (stash->dwarf_abbrev_buffer);
- free (stash->dwarf_line_buffer);
- free (stash->dwarf_ranges_buffer);
+ if (stash->dwarf_abbrev_buffer)
+ free (stash->dwarf_abbrev_buffer);
+ if (stash->dwarf_line_buffer)
+ free (stash->dwarf_line_buffer);
+ if (stash->dwarf_str_buffer)
+ free (stash->dwarf_str_buffer);
+ if (stash->dwarf_ranges_buffer)
+ free (stash->dwarf_ranges_buffer);
+ if (stash->info_ptr_memory)
+ free (stash->info_ptr_memory);
}
projects / deliverable / binutils-gdb.git / blobdiff