| Line 1... |
Line 1... |
/* DWARF 2 support.
|
/* DWARF 2 support.
|
Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
|
Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
|
2004, 2005, 2006, 2007, 2008 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
|
Adapted from gdb/dwarf2read.c by Gavin Koch of Cygnus Solutions
|
(gavin@cygnus.com).
|
(gavin@cygnus.com).
|
|
|
From the dwarf2read.c header:
|
From the dwarf2read.c header:
|
| Line 33... |
Line 33... |
#include "sysdep.h"
|
#include "sysdep.h"
|
#include "bfd.h"
|
#include "bfd.h"
|
#include "libiberty.h"
|
#include "libiberty.h"
|
#include "libbfd.h"
|
#include "libbfd.h"
|
#include "elf-bfd.h"
|
#include "elf-bfd.h"
|
#include "elf/dwarf2.h"
|
#include "dwarf2.h"
|
|
|
/* The data in the .debug_line statement prologue looks like this. */
|
/* The data in the .debug_line statement prologue looks like this. */
|
|
|
struct line_head
|
struct line_head
|
{
|
{
|
| Line 73... |
Line 73... |
{
|
{
|
unsigned int size;
|
unsigned int size;
|
bfd_byte *data;
|
bfd_byte *data;
|
};
|
};
|
|
|
struct loadable_section
|
struct adjusted_section
|
{
|
{
|
asection *section;
|
asection *section;
|
bfd_vma adj_vma;
|
bfd_vma adj_vma;
|
};
|
};
|
|
|
| Line 98... |
Line 98... |
bfd_byte *info_ptr_end;
|
bfd_byte *info_ptr_end;
|
|
|
/* Pointer to the bfd, section and address of the beginning of the
|
/* Pointer to the bfd, section and address of the beginning of the
|
section. The bfd might be different than expected because of
|
section. The bfd might be different than expected because of
|
gnu_debuglink sections. */
|
gnu_debuglink sections. */
|
bfd * bfd;
|
bfd *bfd_ptr;
|
asection *sec;
|
asection *sec;
|
bfd_byte *sec_info_ptr;
|
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. */
|
/* Pointer to the symbol table. */
|
asymbol **syms;
|
asymbol **syms;
|
|
|
/* Pointer to the .debug_abbrev section loaded into memory. */
|
/* Pointer to the .debug_abbrev section loaded into memory. */
|
bfd_byte *dwarf_abbrev_buffer;
|
bfd_byte *dwarf_abbrev_buffer;
|
|
|
/* Length of the loaded .debug_abbrev section. */
|
/* Length of the loaded .debug_abbrev section. */
|
unsigned long dwarf_abbrev_size;
|
bfd_size_type dwarf_abbrev_size;
|
|
|
/* Buffer for decode_line_info. */
|
/* Buffer for decode_line_info. */
|
bfd_byte *dwarf_line_buffer;
|
bfd_byte *dwarf_line_buffer;
|
|
|
/* Length of the loaded .debug_line section. */
|
/* 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. */
|
/* Pointer to the .debug_str section loaded into memory. */
|
bfd_byte *dwarf_str_buffer;
|
bfd_byte *dwarf_str_buffer;
|
|
|
/* Length of the loaded .debug_str section. */
|
/* 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. */
|
/* Pointer to the .debug_ranges section loaded into memory. */
|
bfd_byte *dwarf_ranges_buffer;
|
bfd_byte *dwarf_ranges_buffer;
|
|
|
/* Length of the loaded .debug_ranges section. */
|
/* 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
|
/* If the most recent call to bfd_find_nearest_line was given an
|
address in an inlined function, preserve a pointer into the
|
address in an inlined function, preserve a pointer into the
|
calling chain for subsequent calls to bfd_find_inliner_info to
|
calling chain for subsequent calls to bfd_find_inliner_info to
|
use. */
|
use. */
|
struct funcinfo *inliner_chain;
|
struct funcinfo *inliner_chain;
|
|
|
/* Number of loadable sections. */
|
/* Number of sections whose VMA we must adjust. */
|
unsigned int loadable_section_count;
|
unsigned int adjusted_section_count;
|
|
|
/* Array of loadable sections. */
|
/* Array of sections with adjusted VMA. */
|
struct loadable_section *loadable_sections;
|
struct adjusted_section *adjusted_sections;
|
|
|
/* Number of times find_line is called. This is used in
|
/* Number of times find_line is called. This is used in
|
the heuristic for enabling the info hash tables. */
|
the heuristic for enabling the info hash tables. */
|
int info_hash_count;
|
int info_hash_count;
|
|
|
| Line 208... |
Line 214... |
|
|
/* Pointer to the current comp_unit so that we can find a given entry
|
/* Pointer to the current comp_unit so that we can find a given entry
|
by its reference. */
|
by its reference. */
|
bfd_byte *info_ptr_unit;
|
bfd_byte *info_ptr_unit;
|
|
|
|
/* Pointer to the start of the debug section, for DW_FORM_ref_addr. */
|
|
bfd_byte *sec_info_ptr;
|
|
|
/* The offset into .debug_line of the line number table. */
|
/* The offset into .debug_line of the line number table. */
|
unsigned long line_offset;
|
unsigned long line_offset;
|
|
|
/* Pointer to the first child die for the comp unit. */
|
/* Pointer to the first child die for the comp unit. */
|
bfd_byte *first_child_die_ptr;
|
bfd_byte *first_child_die_ptr;
|
| Line 229... |
Line 238... |
struct varinfo *variable_table;
|
struct varinfo *variable_table;
|
|
|
/* Pointer to dwarf2_debug structure. */
|
/* Pointer to dwarf2_debug structure. */
|
struct dwarf2_debug *stash;
|
struct dwarf2_debug *stash;
|
|
|
|
/* DWARF format version for this unit - from unit header. */
|
|
int version;
|
|
|
/* Address size for this unit - from unit header. */
|
/* Address size for this unit - from unit header. */
|
unsigned char addr_size;
|
unsigned char addr_size;
|
|
|
/* Offset size for this unit - from unit header. */
|
/* Offset size for this unit - from unit header. */
|
unsigned char offset_size;
|
unsigned char offset_size;
|
| Line 305... |
Line 317... |
|
|
/* Allocate the structure if it has not already been allocated by a
|
/* Allocate the structure if it has not already been allocated by a
|
derived class. */
|
derived class. */
|
if (ret == NULL)
|
if (ret == NULL)
|
{
|
{
|
ret = bfd_hash_allocate (table, sizeof (* ret));
|
ret = (struct info_hash_entry *) bfd_hash_allocate (table,
|
|
sizeof (* ret));
|
if (ret == NULL)
|
if (ret == NULL)
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Call the allocation method of the base class. */
|
/* Call the allocation method of the base class. */
|
| Line 330... |
Line 343... |
static struct info_hash_table *
|
static struct info_hash_table *
|
create_info_hash_table (bfd *abfd)
|
create_info_hash_table (bfd *abfd)
|
{
|
{
|
struct info_hash_table *hash_table;
|
struct info_hash_table *hash_table;
|
|
|
hash_table = bfd_alloc (abfd, sizeof (struct info_hash_table));
|
hash_table = (struct info_hash_table *)
|
|
bfd_alloc (abfd, sizeof (struct info_hash_table));
|
if (!hash_table)
|
if (!hash_table)
|
return hash_table;
|
return hash_table;
|
|
|
if (!bfd_hash_table_init (&hash_table->base, info_hash_table_newfunc,
|
if (!bfd_hash_table_init (&hash_table->base, info_hash_table_newfunc,
|
sizeof (struct info_hash_entry)))
|
sizeof (struct info_hash_entry)))
|
| Line 363... |
Line 377... |
entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base,
|
entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base,
|
key, TRUE, copy_p);
|
key, TRUE, copy_p);
|
if (!entry)
|
if (!entry)
|
return FALSE;
|
return FALSE;
|
|
|
node = bfd_hash_allocate (&hash_table->base, sizeof (*node));
|
node = (struct info_list_node *) bfd_hash_allocate (&hash_table->base,
|
|
sizeof (*node));
|
if (!node)
|
if (!node)
|
return FALSE;
|
return FALSE;
|
|
|
node->info = info;
|
node->info = info;
|
node->next = entry->head;
|
node->next = entry->head;
|
| Line 387... |
Line 402... |
entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base, key,
|
entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base, key,
|
FALSE, FALSE);
|
FALSE, FALSE);
|
return entry ? entry->head : NULL;
|
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_byte *) 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
|
/* VERBATIM
|
The following function up to the END VERBATIM mark are
|
The following function up to the END VERBATIM mark are
|
copied directly from dwarf2read.c. */
|
copied directly from dwarf2read.c. */
|
|
|
/* Read dwarf information from a buffer. */
|
/* Read dwarf information from a buffer. */
|
| Line 428... |
Line 519... |
static bfd_byte *
|
static bfd_byte *
|
read_n_bytes (bfd *abfd ATTRIBUTE_UNUSED,
|
read_n_bytes (bfd *abfd ATTRIBUTE_UNUSED,
|
bfd_byte *buf,
|
bfd_byte *buf,
|
unsigned int size ATTRIBUTE_UNUSED)
|
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 buf;
|
}
|
}
|
|
|
static char *
|
static char *
|
read_string (bfd *abfd ATTRIBUTE_UNUSED,
|
read_string (bfd *abfd ATTRIBUTE_UNUSED,
|
bfd_byte *buf,
|
bfd_byte *buf,
|
unsigned int *bytes_read_ptr)
|
unsigned int *bytes_read_ptr)
|
{
|
{
|
/* Return a pointer to the embedded string. */
|
/* Return a pointer to the embedded string. */
|
char *str = (char *) buf;
|
char *str = (char *) buf;
|
|
|
if (*str == '\0')
|
if (*str == '\0')
|
{
|
{
|
*bytes_read_ptr = 1;
|
*bytes_read_ptr = 1;
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
*bytes_read_ptr = strlen (str) + 1;
|
*bytes_read_ptr = strlen (str) + 1;
|
return str;
|
return str;
|
}
|
}
|
|
|
|
/* END VERBATIM */
|
|
|
static char *
|
static char *
|
read_indirect_string (struct comp_unit* unit,
|
read_indirect_string (struct comp_unit* unit,
|
bfd_byte *buf,
|
bfd_byte *buf,
|
unsigned int *bytes_read_ptr)
|
unsigned int *bytes_read_ptr)
|
{
|
{
|
| Line 464... |
Line 555... |
|
|
if (unit->offset_size == 4)
|
if (unit->offset_size == 4)
|
offset = read_4_bytes (unit->abfd, buf);
|
offset = read_4_bytes (unit->abfd, buf);
|
else
|
else
|
offset = read_8_bytes (unit->abfd, buf);
|
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,
|
*bytes_read_ptr = unit->offset_size;
|
0, sz))
|
|
return NULL;
|
|
}
|
|
|
|
if (offset >= stash->dwarf_str_size)
|
if (! read_section (unit->abfd, ".debug_str", ".zdebug_str",
|
{
|
stash->syms, offset,
|
(*_bfd_error_handler) (_("Dwarf Error: DW_FORM_strp offset (%lu) greater than or equal to .debug_str size (%lu)."),
|
&stash->dwarf_str_buffer, &stash->dwarf_str_size))
|
(unsigned long) offset, stash->dwarf_str_size);
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return NULL;
|
return NULL;
|
}
|
|
|
|
str = (char *) stash->dwarf_str_buffer + offset;
|
str = (char *) stash->dwarf_str_buffer + offset;
|
if (*str == '\0')
|
if (*str == '\0')
|
return NULL;
|
return NULL;
|
return str;
|
return str;
|
}
|
}
|
|
|
/* END VERBATIM */
|
|
|
|
static bfd_uint64_t
|
static bfd_uint64_t
|
read_address (struct comp_unit *unit, bfd_byte *buf)
|
read_address (struct comp_unit *unit, bfd_byte *buf)
|
{
|
{
|
int signed_vma = get_elf_backend_data (unit->abfd)->sign_extend_vma;
|
int signed_vma = get_elf_backend_data (unit->abfd)->sign_extend_vma;
|
|
|
| Line 580... |
Line 641... |
struct abbrev_info *cur_abbrev;
|
struct abbrev_info *cur_abbrev;
|
unsigned int abbrev_number, bytes_read, abbrev_name;
|
unsigned int abbrev_number, bytes_read, abbrev_name;
|
unsigned int abbrev_form, hash_number;
|
unsigned int abbrev_form, hash_number;
|
bfd_size_type amt;
|
bfd_size_type amt;
|
|
|
if (! stash->dwarf_abbrev_buffer)
|
if (! read_section (abfd, ".debug_abbrev", ".zdebug_abbrev",
|
{
|
stash->syms, offset,
|
asection *msec;
|
&stash->dwarf_abbrev_buffer, &stash->dwarf_abbrev_size))
|
|
|
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;
|
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;
|
|
}
|
|
|
|
amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
|
amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
|
abbrevs = bfd_zalloc (abfd, amt);
|
abbrevs = (struct abbrev_info **) bfd_zalloc (abfd, amt);
|
|
|
abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
|
abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
|
abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
|
abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
|
abbrev_ptr += bytes_read;
|
abbrev_ptr += bytes_read;
|
|
|
/* Loop until we reach an abbrev number of 0. */
|
/* Loop until we reach an abbrev number of 0. */
|
while (abbrev_number)
|
while (abbrev_number)
|
{
|
{
|
amt = sizeof (struct abbrev_info);
|
amt = sizeof (struct abbrev_info);
|
cur_abbrev = bfd_zalloc (abfd, amt);
|
cur_abbrev = (struct abbrev_info *) bfd_zalloc (abfd, amt);
|
|
|
/* Read in abbrev header. */
|
/* Read in abbrev header. */
|
cur_abbrev->number = abbrev_number;
|
cur_abbrev->number = abbrev_number;
|
cur_abbrev->tag = (enum dwarf_tag)
|
cur_abbrev->tag = (enum dwarf_tag)
|
read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
|
read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
|
| Line 643... |
Line 681... |
{
|
{
|
struct attr_abbrev *tmp;
|
struct attr_abbrev *tmp;
|
|
|
amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
|
amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
|
amt *= sizeof (struct attr_abbrev);
|
amt *= sizeof (struct attr_abbrev);
|
tmp = bfd_realloc (cur_abbrev->attrs, amt);
|
tmp = (struct attr_abbrev *) bfd_realloc (cur_abbrev->attrs, amt);
|
if (tmp == NULL)
|
if (tmp == NULL)
|
{
|
{
|
size_t i;
|
size_t i;
|
|
|
for (i = 0; i < ABBREV_HASH_SIZE; i++)
|
for (i = 0; i < ABBREV_HASH_SIZE; i++)
|
| Line 713... |
Line 751... |
|
|
attr->form = (enum dwarf_form) form;
|
attr->form = (enum dwarf_form) form;
|
|
|
switch (form)
|
switch (form)
|
{
|
{
|
case DW_FORM_addr:
|
|
/* FIXME: DWARF3 draft says DW_FORM_ref_addr is offset_size. */
|
|
case DW_FORM_ref_addr:
|
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);
|
attr->u.val = read_address (unit, info_ptr);
|
info_ptr += unit->addr_size;
|
info_ptr += unit->addr_size;
|
break;
|
break;
|
case DW_FORM_block2:
|
case DW_FORM_block2:
|
amt = sizeof (struct dwarf_block);
|
amt = sizeof (struct dwarf_block);
|
blk = bfd_alloc (abfd, amt);
|
blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
|
blk->size = read_2_bytes (abfd, info_ptr);
|
blk->size = read_2_bytes (abfd, info_ptr);
|
info_ptr += 2;
|
info_ptr += 2;
|
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
|
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
|
info_ptr += blk->size;
|
info_ptr += blk->size;
|
attr->u.blk = blk;
|
attr->u.blk = blk;
|
break;
|
break;
|
case DW_FORM_block4:
|
case DW_FORM_block4:
|
amt = sizeof (struct dwarf_block);
|
amt = sizeof (struct dwarf_block);
|
blk = bfd_alloc (abfd, amt);
|
blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
|
blk->size = read_4_bytes (abfd, info_ptr);
|
blk->size = read_4_bytes (abfd, info_ptr);
|
info_ptr += 4;
|
info_ptr += 4;
|
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
|
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
|
info_ptr += blk->size;
|
info_ptr += blk->size;
|
attr->u.blk = blk;
|
attr->u.blk = blk;
|
| Line 759... |
Line 808... |
attr->u.str = read_indirect_string (unit, info_ptr, &bytes_read);
|
attr->u.str = read_indirect_string (unit, info_ptr, &bytes_read);
|
info_ptr += bytes_read;
|
info_ptr += bytes_read;
|
break;
|
break;
|
case DW_FORM_block:
|
case DW_FORM_block:
|
amt = sizeof (struct dwarf_block);
|
amt = sizeof (struct dwarf_block);
|
blk = bfd_alloc (abfd, amt);
|
blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
|
blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
|
blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
|
info_ptr += bytes_read;
|
info_ptr += bytes_read;
|
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
|
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
|
info_ptr += blk->size;
|
info_ptr += blk->size;
|
attr->u.blk = blk;
|
attr->u.blk = blk;
|
break;
|
break;
|
case DW_FORM_block1:
|
case DW_FORM_block1:
|
amt = sizeof (struct dwarf_block);
|
amt = sizeof (struct dwarf_block);
|
blk = bfd_alloc (abfd, amt);
|
blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
|
blk->size = read_1_byte (abfd, info_ptr);
|
blk->size = read_1_byte (abfd, info_ptr);
|
info_ptr += 1;
|
info_ptr += 1;
|
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
|
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
|
info_ptr += blk->size;
|
info_ptr += blk->size;
|
attr->u.blk = blk;
|
attr->u.blk = blk;
|
| Line 933... |
Line 982... |
unsigned int line,
|
unsigned int line,
|
unsigned int column,
|
unsigned int column,
|
int end_sequence)
|
int end_sequence)
|
{
|
{
|
bfd_size_type amt = sizeof (struct line_info);
|
bfd_size_type amt = sizeof (struct line_info);
|
struct line_info* info = bfd_alloc (table->abfd, amt);
|
struct line_info* info = (struct line_info *) bfd_alloc (table->abfd, amt);
|
|
|
/* Set member data of 'info'. */
|
/* Set member data of 'info'. */
|
info->address = address;
|
info->address = address;
|
info->line = line;
|
info->line = line;
|
info->column = column;
|
info->column = column;
|
info->end_sequence = end_sequence;
|
info->end_sequence = end_sequence;
|
|
|
if (filename && filename[0])
|
if (filename && filename[0])
|
{
|
{
|
info->filename = bfd_alloc (table->abfd, strlen (filename) + 1);
|
info->filename = (char *) bfd_alloc (table->abfd, strlen (filename) + 1);
|
if (info->filename)
|
if (info->filename)
|
strcpy (info->filename, filename);
|
strcpy (info->filename, filename);
|
}
|
}
|
else
|
else
|
info->filename = NULL;
|
info->filename = NULL;
|
| Line 1064... |
Line 1113... |
len = strlen (dirname) + strlen (filename) + 2;
|
len = strlen (dirname) + strlen (filename) + 2;
|
|
|
if (subdirname)
|
if (subdirname)
|
{
|
{
|
len += strlen (subdirname) + 1;
|
len += strlen (subdirname) + 1;
|
name = bfd_malloc (len);
|
name = (char *) bfd_malloc (len);
|
if (name)
|
if (name)
|
sprintf (name, "%s/%s/%s", dirname, subdirname, filename);
|
sprintf (name, "%s/%s/%s", dirname, subdirname, filename);
|
}
|
}
|
else
|
else
|
{
|
{
|
name = bfd_malloc (len);
|
name = (char *) bfd_malloc (len);
|
if (name)
|
if (name)
|
sprintf (name, "%s/%s", dirname, filename);
|
sprintf (name, "%s/%s", dirname, filename);
|
}
|
}
|
|
|
return name;
|
return name;
|
| Line 1114... |
Line 1163... |
}
|
}
|
while (arange);
|
while (arange);
|
|
|
/* Need to allocate a new arange and insert it into the arange list.
|
/* 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 = (struct arange *) bfd_zalloc (abfd, sizeof (*arange));
|
arange->low = low_pc;
|
arange->low = low_pc;
|
arange->high = high_pc;
|
arange->high = high_pc;
|
arange->next = first_arange->next;
|
arange->next = first_arange->next;
|
first_arange->next = arange;
|
first_arange->next = arange;
|
}
|
}
|
| Line 1136... |
Line 1185... |
unsigned int i, bytes_read, offset_size;
|
unsigned int i, bytes_read, offset_size;
|
char *cur_file, *cur_dir;
|
char *cur_file, *cur_dir;
|
unsigned char op_code, extended_op, adj_opcode;
|
unsigned char op_code, extended_op, adj_opcode;
|
bfd_size_type amt;
|
bfd_size_type amt;
|
|
|
if (! stash->dwarf_line_buffer)
|
if (! read_section (abfd, ".debug_line", ".zdebug_line",
|
{
|
stash->syms, unit->line_offset,
|
asection *msec;
|
&stash->dwarf_line_buffer, &stash->dwarf_line_size))
|
|
|
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;
|
return 0;
|
}
|
|
|
|
amt = sizeof (struct line_info_table);
|
amt = sizeof (struct line_info_table);
|
table = bfd_alloc (abfd, amt);
|
table = (struct line_info_table *) bfd_alloc (abfd, amt);
|
table->abfd = abfd;
|
table->abfd = abfd;
|
table->comp_dir = unit->comp_dir;
|
table->comp_dir = unit->comp_dir;
|
|
|
table->num_files = 0;
|
table->num_files = 0;
|
table->files = NULL;
|
table->files = NULL;
|
| Line 1219... |
Line 1243... |
lh.line_range = read_1_byte (abfd, line_ptr);
|
lh.line_range = read_1_byte (abfd, line_ptr);
|
line_ptr += 1;
|
line_ptr += 1;
|
lh.opcode_base = read_1_byte (abfd, line_ptr);
|
lh.opcode_base = read_1_byte (abfd, line_ptr);
|
line_ptr += 1;
|
line_ptr += 1;
|
amt = lh.opcode_base * sizeof (unsigned char);
|
amt = lh.opcode_base * sizeof (unsigned char);
|
lh.standard_opcode_lengths = bfd_alloc (abfd, amt);
|
lh.standard_opcode_lengths = (unsigned char *) bfd_alloc (abfd, amt);
|
|
|
lh.standard_opcode_lengths[0] = 1;
|
lh.standard_opcode_lengths[0] = 1;
|
|
|
for (i = 1; i < lh.opcode_base; ++i)
|
for (i = 1; i < lh.opcode_base; ++i)
|
{
|
{
|
| Line 1241... |
Line 1265... |
char **tmp;
|
char **tmp;
|
|
|
amt = table->num_dirs + DIR_ALLOC_CHUNK;
|
amt = table->num_dirs + DIR_ALLOC_CHUNK;
|
amt *= sizeof (char *);
|
amt *= sizeof (char *);
|
|
|
tmp = bfd_realloc (table->dirs, amt);
|
tmp = (char **) bfd_realloc (table->dirs, amt);
|
if (tmp == NULL)
|
if (tmp == NULL)
|
{
|
{
|
free (table->dirs);
|
free (table->dirs);
|
return NULL;
|
return NULL;
|
}
|
}
|
| Line 1267... |
Line 1291... |
struct fileinfo *tmp;
|
struct fileinfo *tmp;
|
|
|
amt = table->num_files + FILE_ALLOC_CHUNK;
|
amt = table->num_files + FILE_ALLOC_CHUNK;
|
amt *= sizeof (struct fileinfo);
|
amt *= sizeof (struct fileinfo);
|
|
|
tmp = bfd_realloc (table->files, amt);
|
tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
|
if (tmp == NULL)
|
if (tmp == NULL)
|
{
|
{
|
free (table->files);
|
free (table->files);
|
free (table->dirs);
|
free (table->dirs);
|
return NULL;
|
return NULL;
|
| Line 1363... |
Line 1387... |
{
|
{
|
struct fileinfo *tmp;
|
struct fileinfo *tmp;
|
|
|
amt = table->num_files + FILE_ALLOC_CHUNK;
|
amt = table->num_files + FILE_ALLOC_CHUNK;
|
amt *= sizeof (struct fileinfo);
|
amt *= sizeof (struct fileinfo);
|
tmp = bfd_realloc (table->files, amt);
|
tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
|
if (tmp == NULL)
|
if (tmp == NULL)
|
{
|
{
|
free (table->files);
|
free (table->files);
|
free (table->dirs);
|
free (table->dirs);
|
free (filename);
|
free (filename);
|
| Line 1385... |
Line 1409... |
table->files[table->num_files].size =
|
table->files[table->num_files].size =
|
read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
|
read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
|
line_ptr += bytes_read;
|
line_ptr += bytes_read;
|
table->num_files++;
|
table->num_files++;
|
break;
|
break;
|
|
case DW_LNE_set_discriminator:
|
|
(void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
|
|
line_ptr += bytes_read;
|
|
break;
|
default:
|
default:
|
(*_bfd_error_handler) (_("Dwarf Error: mangled line number section."));
|
(*_bfd_error_handler) (_("Dwarf Error: mangled line number section."));
|
bfd_set_error (bfd_error_bad_value);
|
bfd_set_error (bfd_error_bad_value);
|
free (filename);
|
free (filename);
|
free (table->files);
|
free (table->files);
|
| Line 1468... |
Line 1496... |
LINENUMBER_PTR, are pointers to the objects to be filled in. */
|
LINENUMBER_PTR, are pointers to the objects to be filled in. */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
lookup_address_in_line_info_table (struct line_info_table *table,
|
lookup_address_in_line_info_table (struct line_info_table *table,
|
bfd_vma addr,
|
bfd_vma addr,
|
struct funcinfo *function,
|
|
const char **filename_ptr,
|
const char **filename_ptr,
|
unsigned int *linenumber_ptr)
|
unsigned int *linenumber_ptr)
|
{
|
{
|
/* Note: table->last_line should be a descendingly sorted list. */
|
/* Note: table->last_line should be a descendingly sorted list. */
|
struct line_info* next_line = table->last_line;
|
struct line_info *each_line;
|
struct line_info* each_line = NULL;
|
|
*filename_ptr = NULL;
|
|
|
|
if (!next_line)
|
|
return FALSE;
|
|
|
|
each_line = next_line->prev_line;
|
|
|
|
/* Check for large addresses */
|
for (each_line = table->last_line;
|
if (addr > next_line->address)
|
each_line;
|
each_line = NULL; /* ensure we skip over the normal case */
|
each_line = each_line->prev_line)
|
|
if (addr >= each_line->address)
|
/* Normal case: search the list; save */
|
break;
|
while (each_line && next_line)
|
|
{
|
|
/* If we have an address match, save this info. This allows us
|
|
to return as good as results as possible for strange debugging
|
|
info. */
|
|
bfd_boolean addr_match = FALSE;
|
|
if (each_line->address <= addr && addr < next_line->address)
|
|
{
|
|
addr_match = TRUE;
|
|
|
|
/* If this line appears to span functions, and addr is in the
|
|
later function, return the first line of that function instead
|
|
of the last line of the earlier one. This check is for GCC
|
|
2.95, which emits the first line number for a function late. */
|
|
|
|
if (function != NULL)
|
|
{
|
|
bfd_vma lowest_pc;
|
|
struct arange *arange;
|
|
|
|
/* Find the lowest address in the function's range list */
|
if (each_line
|
lowest_pc = function->arange.low;
|
&& !(each_line->end_sequence || each_line == table->last_line))
|
for (arange = &function->arange;
|
|
arange;
|
|
arange = arange->next)
|
|
{
|
|
if (function->arange.low < lowest_pc)
|
|
lowest_pc = function->arange.low;
|
|
}
|
|
/* Check for spanning function and set outgoing line info */
|
|
if (addr >= lowest_pc
|
|
&& each_line->address < lowest_pc
|
|
&& next_line->address > lowest_pc)
|
|
{
|
|
*filename_ptr = next_line->filename;
|
|
*linenumber_ptr = next_line->line;
|
|
}
|
|
else
|
|
{
|
{
|
*filename_ptr = each_line->filename;
|
*filename_ptr = each_line->filename;
|
*linenumber_ptr = each_line->line;
|
*linenumber_ptr = each_line->line;
|
}
|
|
}
|
|
else
|
|
{
|
|
*filename_ptr = each_line->filename;
|
|
*linenumber_ptr = each_line->line;
|
|
}
|
|
}
|
|
|
|
if (addr_match && !each_line->end_sequence)
|
|
return TRUE; /* we have definitely found what we want */
|
|
|
|
next_line = each_line;
|
|
each_line = each_line->prev_line;
|
|
}
|
|
|
|
/* At this point each_line is NULL but next_line is not. If we found
|
|
a candidate end-of-sequence point in the loop above, we can return
|
|
that (compatibility with a bug in the Intel compiler); otherwise,
|
|
assuming that we found the containing function for this address in
|
|
this compilation unit, return the first line we have a number for
|
|
(compatibility with GCC 2.95). */
|
|
if (*filename_ptr == NULL && function != NULL)
|
|
{
|
|
*filename_ptr = next_line->filename;
|
|
*linenumber_ptr = next_line->line;
|
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
|
*filename_ptr = NULL;
|
return FALSE;
|
return FALSE;
|
}
|
}
|
|
|
/* Read in the .debug_ranges section for future reference */
|
/* Read in the .debug_ranges section for future reference */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
read_debug_ranges (struct comp_unit *unit)
|
read_debug_ranges (struct comp_unit *unit)
|
{
|
{
|
struct dwarf2_debug *stash = unit->stash;
|
struct dwarf2_debug *stash = unit->stash;
|
if (! stash->dwarf_ranges_buffer)
|
return read_section (unit->abfd, ".debug_ranges", ".zdebug_ranges",
|
{
|
stash->syms, 0,
|
bfd *abfd = unit->abfd;
|
&stash->dwarf_ranges_buffer, &stash->dwarf_ranges_size);
|
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;
|
|
}
|
}
|
|
|
/* Function table functions. */
|
/* Function table functions. */
|
|
|
/* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return TRUE.
|
/* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return TRUE.
|
| Line 1719... |
Line 1661... |
else
|
else
|
return FALSE;
|
return FALSE;
|
}
|
}
|
|
|
static char *
|
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 *abfd = unit->abfd;
|
bfd_byte *info_ptr;
|
bfd_byte *info_ptr;
|
unsigned int abbrev_number, bytes_read, i;
|
unsigned int abbrev_number, bytes_read, i;
|
struct abbrev_info *abbrev;
|
struct abbrev_info *abbrev;
|
|
bfd_uint64_t die_ref = attr_ptr->u.val;
|
struct attribute attr;
|
struct attribute attr;
|
char *name = 0;
|
char *name = 0;
|
|
|
|
/* 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->sec_info_ptr + die_ref;
|
|
}
|
|
else
|
info_ptr = unit->info_ptr_unit + die_ref;
|
info_ptr = unit->info_ptr_unit + die_ref;
|
abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
|
abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
|
info_ptr += bytes_read;
|
info_ptr += bytes_read;
|
|
|
if (abbrev_number)
|
if (abbrev_number)
|
| Line 1754... |
Line 1710... |
/* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
|
/* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
|
if (name == NULL)
|
if (name == NULL)
|
name = attr.u.str;
|
name = attr.u.str;
|
break;
|
break;
|
case DW_AT_specification:
|
case DW_AT_specification:
|
name = find_abstract_instance_name (unit, attr.u.val);
|
name = find_abstract_instance_name (unit, &attr);
|
break;
|
break;
|
case DW_AT_MIPS_linkage_name:
|
case DW_AT_MIPS_linkage_name:
|
name = attr.u.str;
|
name = attr.u.str;
|
break;
|
break;
|
default:
|
default:
|
| Line 1786... |
Line 1742... |
for (;;)
|
for (;;)
|
{
|
{
|
bfd_vma low_pc;
|
bfd_vma low_pc;
|
bfd_vma high_pc;
|
bfd_vma high_pc;
|
|
|
if (unit->addr_size == 4)
|
low_pc = read_address (unit, ranges_ptr);
|
{
|
ranges_ptr += unit->addr_size;
|
low_pc = read_4_bytes (unit->abfd, ranges_ptr);
|
high_pc = read_address (unit, ranges_ptr);
|
ranges_ptr += 4;
|
ranges_ptr += unit->addr_size;
|
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;
|
|
}
|
|
if (low_pc == 0 && high_pc == 0)
|
if (low_pc == 0 && high_pc == 0)
|
break;
|
break;
|
if (low_pc == -1UL && high_pc != -1UL)
|
if (low_pc == -1UL && high_pc != -1UL)
|
base_address = high_pc;
|
base_address = high_pc;
|
else
|
else
|
| Line 1826... |
Line 1773... |
int nested_funcs_size;
|
int nested_funcs_size;
|
|
|
/* Maintain a stack of in-scope functions and inlined functions, which we
|
/* Maintain a stack of in-scope functions and inlined functions, which we
|
can use to set the caller_func field. */
|
can use to set the caller_func field. */
|
nested_funcs_size = 32;
|
nested_funcs_size = 32;
|
nested_funcs = bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *));
|
nested_funcs = (struct funcinfo **)
|
|
bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *));
|
if (nested_funcs == NULL)
|
if (nested_funcs == NULL)
|
return FALSE;
|
return FALSE;
|
nested_funcs[nesting_level] = 0;
|
nested_funcs[nesting_level] = 0;
|
|
|
while (nesting_level)
|
while (nesting_level)
|
| Line 1866... |
Line 1814... |
if (abbrev->tag == DW_TAG_subprogram
|
if (abbrev->tag == DW_TAG_subprogram
|
|| abbrev->tag == DW_TAG_entry_point
|
|| abbrev->tag == DW_TAG_entry_point
|
|| abbrev->tag == DW_TAG_inlined_subroutine)
|
|| abbrev->tag == DW_TAG_inlined_subroutine)
|
{
|
{
|
bfd_size_type amt = sizeof (struct funcinfo);
|
bfd_size_type amt = sizeof (struct funcinfo);
|
func = bfd_zalloc (abfd, amt);
|
func = (struct funcinfo *) bfd_zalloc (abfd, amt);
|
func->tag = abbrev->tag;
|
func->tag = abbrev->tag;
|
func->prev_func = unit->function_table;
|
func->prev_func = unit->function_table;
|
unit->function_table = func;
|
unit->function_table = func;
|
BFD_ASSERT (!unit->cached);
|
BFD_ASSERT (!unit->cached);
|
|
|
| Line 1887... |
Line 1835... |
{
|
{
|
func = NULL;
|
func = NULL;
|
if (abbrev->tag == DW_TAG_variable)
|
if (abbrev->tag == DW_TAG_variable)
|
{
|
{
|
bfd_size_type amt = sizeof (struct varinfo);
|
bfd_size_type amt = sizeof (struct varinfo);
|
var = bfd_zalloc (abfd, amt);
|
var = (struct varinfo *) bfd_zalloc (abfd, amt);
|
var->tag = abbrev->tag;
|
var->tag = abbrev->tag;
|
var->stack = 1;
|
var->stack = 1;
|
var->prev_var = unit->variable_table;
|
var->prev_var = unit->variable_table;
|
unit->variable_table = var;
|
unit->variable_table = var;
|
BFD_ASSERT (!unit->cached);
|
BFD_ASSERT (!unit->cached);
|
| Line 1916... |
Line 1864... |
case DW_AT_call_line:
|
case DW_AT_call_line:
|
func->caller_line = attr.u.val;
|
func->caller_line = attr.u.val;
|
break;
|
break;
|
|
|
case DW_AT_abstract_origin:
|
case DW_AT_abstract_origin:
|
func->name = find_abstract_instance_name (unit, attr.u.val);
|
func->name = find_abstract_instance_name (unit, &attr);
|
break;
|
break;
|
|
|
case DW_AT_name:
|
case DW_AT_name:
|
/* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
|
/* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
|
if (func->name == NULL)
|
if (func->name == NULL)
|
| Line 2025... |
Line 1973... |
if (nesting_level >= nested_funcs_size)
|
if (nesting_level >= nested_funcs_size)
|
{
|
{
|
struct funcinfo **tmp;
|
struct funcinfo **tmp;
|
|
|
nested_funcs_size *= 2;
|
nested_funcs_size *= 2;
|
tmp = bfd_realloc (nested_funcs,
|
tmp = (struct funcinfo **)
|
(nested_funcs_size
|
bfd_realloc (nested_funcs,
|
* sizeof (struct funcinfo *)));
|
(nested_funcs_size * sizeof (struct funcinfo *)));
|
if (tmp == NULL)
|
if (tmp == NULL)
|
{
|
{
|
free (nested_funcs);
|
free (nested_funcs);
|
return FALSE;
|
return FALSE;
|
}
|
}
|
| Line 2071... |
Line 2019... |
bfd_byte *info_ptr = stash->info_ptr;
|
bfd_byte *info_ptr = stash->info_ptr;
|
bfd_byte *end_ptr = info_ptr + unit_length;
|
bfd_byte *end_ptr = info_ptr + unit_length;
|
bfd_size_type amt;
|
bfd_size_type amt;
|
bfd_vma low_pc = 0;
|
bfd_vma low_pc = 0;
|
bfd_vma high_pc = 0;
|
bfd_vma high_pc = 0;
|
bfd *abfd = stash->bfd;
|
bfd *abfd = stash->bfd_ptr;
|
|
|
version = read_2_bytes (abfd, info_ptr);
|
version = read_2_bytes (abfd, info_ptr);
|
info_ptr += 2;
|
info_ptr += 2;
|
BFD_ASSERT (offset_size == 4 || offset_size == 8);
|
BFD_ASSERT (offset_size == 4 || offset_size == 8);
|
if (offset_size == 4)
|
if (offset_size == 4)
|
| Line 2084... |
Line 2032... |
abbrev_offset = read_8_bytes (abfd, info_ptr);
|
abbrev_offset = read_8_bytes (abfd, info_ptr);
|
info_ptr += offset_size;
|
info_ptr += offset_size;
|
addr_size = read_1_byte (abfd, info_ptr);
|
addr_size = read_1_byte (abfd, info_ptr);
|
info_ptr += 1;
|
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);
|
bfd_set_error (bfd_error_bad_value);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
if (addr_size > sizeof (bfd_vma))
|
if (addr_size > sizeof (bfd_vma))
|
| Line 2132... |
Line 2080... |
bfd_set_error (bfd_error_bad_value);
|
bfd_set_error (bfd_error_bad_value);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
amt = sizeof (struct comp_unit);
|
amt = sizeof (struct comp_unit);
|
unit = bfd_zalloc (abfd, amt);
|
unit = (struct comp_unit *) bfd_zalloc (abfd, amt);
|
unit->abfd = abfd;
|
unit->abfd = abfd;
|
|
unit->version = version;
|
unit->addr_size = addr_size;
|
unit->addr_size = addr_size;
|
unit->offset_size = offset_size;
|
unit->offset_size = offset_size;
|
unit->abbrevs = abbrevs;
|
unit->abbrevs = abbrevs;
|
unit->end_ptr = end_ptr;
|
unit->end_ptr = end_ptr;
|
unit->stash = stash;
|
unit->stash = stash;
|
unit->info_ptr_unit = info_ptr_unit;
|
unit->info_ptr_unit = info_ptr_unit;
|
|
unit->sec_info_ptr = stash->sec_info_ptr;
|
|
|
for (i = 0; i < abbrev->num_attrs; ++i)
|
for (i = 0; i < abbrev->num_attrs; ++i)
|
{
|
{
|
info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
|
info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
|
|
|
| Line 2282... |
Line 2232... |
func_p = lookup_address_in_function_table (unit, addr,
|
func_p = lookup_address_in_function_table (unit, addr,
|
&function, functionname_ptr);
|
&function, functionname_ptr);
|
if (func_p && (function->tag == DW_TAG_inlined_subroutine))
|
if (func_p && (function->tag == DW_TAG_inlined_subroutine))
|
stash->inliner_chain = function;
|
stash->inliner_chain = function;
|
line_p = lookup_address_in_line_info_table (unit->line_table, addr,
|
line_p = lookup_address_in_line_info_table (unit->line_table, addr,
|
function, filename_ptr,
|
filename_ptr,
|
linenumber_ptr);
|
linenumber_ptr);
|
return line_p || func_p;
|
return line_p || func_p;
|
}
|
}
|
|
|
/* Check to see if line info is already decoded in a comp_unit.
|
/* Check to see if line info is already decoded in a comp_unit.
|
| Line 2459... |
Line 2409... |
This is a variation on the .debug_info section which has a checksum
|
This is a variation on the .debug_info section which has a checksum
|
describing the contents appended onto the name. This allows the linker to
|
describing the contents appended onto the name. This allows the linker to
|
identify and discard duplicate debugging sections for different
|
identify and discard duplicate debugging sections for different
|
compilation units. */
|
compilation units. */
|
#define DWARF2_DEBUG_INFO ".debug_info"
|
#define DWARF2_DEBUG_INFO ".debug_info"
|
|
#define DWARF2_COMPRESSED_DEBUG_INFO ".zdebug_info"
|
#define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
|
#define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
|
|
|
static asection *
|
static asection *
|
find_debug_info (bfd *abfd, asection *after_sec)
|
find_debug_info (bfd *abfd, asection *after_sec)
|
{
|
{
|
| Line 2473... |
Line 2424... |
while (msec)
|
while (msec)
|
{
|
{
|
if (strcmp (msec->name, DWARF2_DEBUG_INFO) == 0)
|
if (strcmp (msec->name, DWARF2_DEBUG_INFO) == 0)
|
return msec;
|
return msec;
|
|
|
|
if (strcmp (msec->name, DWARF2_COMPRESSED_DEBUG_INFO) == 0)
|
|
return msec;
|
|
|
if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
|
if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
|
return msec;
|
return msec;
|
|
|
msec = msec->next;
|
msec = msec->next;
|
}
|
}
|
|
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Unset vmas for loadable sections in STASH. */
|
/* Unset vmas for adjusted sections in STASH. */
|
|
|
static void
|
static void
|
unset_sections (struct dwarf2_debug *stash)
|
unset_sections (struct dwarf2_debug *stash)
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
struct loadable_section *p;
|
struct adjusted_section *p;
|
|
|
i = stash->loadable_section_count;
|
i = stash->adjusted_section_count;
|
p = stash->loadable_sections;
|
p = stash->adjusted_sections;
|
for (; i > 0; i--, p++)
|
for (; i > 0; i--, p++)
|
p->section->vma = 0;
|
p->section->vma = 0;
|
}
|
}
|
|
|
/* Set unique vmas for loadable sections in ABFD and save vmas in
|
/* Set unique VMAs for loadable and DWARF sections in ABFD and save
|
STASH for unset_sections. */
|
VMAs in STASH for unset_sections. */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
place_sections (bfd *abfd, struct dwarf2_debug *stash)
|
place_sections (bfd *abfd, struct dwarf2_debug *stash)
|
{
|
{
|
struct loadable_section *p;
|
struct adjusted_section *p;
|
unsigned int i;
|
unsigned int i;
|
|
|
if (stash->loadable_section_count != 0)
|
if (stash->adjusted_section_count != 0)
|
{
|
{
|
i = stash->loadable_section_count;
|
i = stash->adjusted_section_count;
|
p = stash->loadable_sections;
|
p = stash->adjusted_sections;
|
for (; i > 0; i--, p++)
|
for (; i > 0; i--, p++)
|
p->section->vma = p->adj_vma;
|
p->section->vma = p->adj_vma;
|
}
|
}
|
else
|
else
|
{
|
{
|
asection *sect;
|
asection *sect;
|
bfd_vma last_vma = 0;
|
bfd_vma last_vma = 0, last_dwarf = 0;
|
bfd_size_type amt;
|
bfd_size_type amt;
|
struct loadable_section *p;
|
struct adjusted_section *p;
|
|
|
i = 0;
|
i = 0;
|
for (sect = abfd->sections; sect != NULL; sect = sect->next)
|
for (sect = abfd->sections; sect != NULL; sect = sect->next)
|
{
|
{
|
bfd_size_type sz;
|
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;
|
continue;
|
|
|
sz = sect->rawsize ? sect->rawsize : sect->size;
|
sz = sect->rawsize ? sect->rawsize : sect->size;
|
if (sz == 0)
|
if (sz == 0)
|
continue;
|
continue;
|
|
|
i++;
|
i++;
|
}
|
}
|
|
|
amt = i * sizeof (struct loadable_section);
|
amt = i * sizeof (struct adjusted_section);
|
p = (struct loadable_section *) bfd_zalloc (abfd, amt);
|
p = (struct adjusted_section *) bfd_zalloc (abfd, amt);
|
if (! p)
|
if (! p)
|
return FALSE;
|
return FALSE;
|
|
|
stash->loadable_sections = p;
|
stash->adjusted_sections = p;
|
stash->loadable_section_count = i;
|
stash->adjusted_section_count = i;
|
|
|
for (sect = abfd->sections; sect != NULL; sect = sect->next)
|
for (sect = abfd->sections; sect != NULL; sect = sect->next)
|
{
|
{
|
bfd_size_type sz;
|
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;
|
continue;
|
|
|
sz = sect->rawsize ? sect->rawsize : sect->size;
|
sz = sect->rawsize ? sect->rawsize : sect->size;
|
if (sz == 0)
|
if (sz == 0)
|
continue;
|
continue;
|
|
|
p->section = sect;
|
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
|
/* Align the new address to the current section
|
alignment. */
|
alignment. */
|
last_vma = ((last_vma
|
last_vma = ((last_vma
|
+ ~((bfd_vma) -1 << sect->alignment_power))
|
+ ~((bfd_vma) -1 << sect->alignment_power))
|
& ((bfd_vma) -1 << sect->alignment_power));
|
& ((bfd_vma) -1 << sect->alignment_power));
|
sect->vma = last_vma;
|
sect->vma = last_vma;
|
|
last_vma += sect->vma + sz;
|
}
|
}
|
p->adj_vma = sect->vma;
|
else
|
last_vma += sect->vma + sz;
|
last_vma += sect->vma + sz;
|
|
|
|
p->adj_vma = sect->vma;
|
|
|
p++;
|
p++;
|
}
|
}
|
}
|
}
|
|
|
return TRUE;
|
return TRUE;
|
| Line 2597... |
Line 2588... |
|
|
for (node = lookup_info_hash_table (hash_table, name);
|
for (node = lookup_info_hash_table (hash_table, name);
|
node;
|
node;
|
node = node->next)
|
node = node->next)
|
{
|
{
|
each_func = node->info;
|
each_func = (struct funcinfo *) node->info;
|
for (arange = &each_func->arange;
|
for (arange = &each_func->arange;
|
arange;
|
arange;
|
arange = arange->next)
|
arange = arange->next)
|
{
|
{
|
if ((!each_func->sec || each_func->sec == sec)
|
if ((!each_func->sec || each_func->sec == sec)
|
| Line 2645... |
Line 2636... |
|
|
for (node = lookup_info_hash_table (hash_table, name);
|
for (node = lookup_info_hash_table (hash_table, name);
|
node;
|
node;
|
node = node->next)
|
node = node->next)
|
{
|
{
|
each = node->info;
|
each = (struct varinfo *) node->info;
|
if (each->addr == addr
|
if (each->addr == addr
|
&& (!each->sec || each->sec == sec))
|
&& (!each->sec || each->sec == sec))
|
{
|
{
|
each->sec = sec;
|
each->sec = sec;
|
*filename_ptr = each->file;
|
*filename_ptr = each->file;
|
| Line 2836... |
Line 2827... |
bfd_vma addr;
|
bfd_vma addr;
|
struct comp_unit* each;
|
struct comp_unit* each;
|
bfd_vma found = FALSE;
|
bfd_vma found = FALSE;
|
bfd_boolean do_line;
|
bfd_boolean do_line;
|
|
|
stash = *pinfo;
|
stash = (struct dwarf2_debug *) *pinfo;
|
|
|
if (! stash)
|
if (! stash)
|
{
|
{
|
bfd_size_type amt = sizeof (struct dwarf2_debug);
|
bfd_size_type amt = sizeof (struct dwarf2_debug);
|
|
|
stash = bfd_zalloc (abfd, amt);
|
stash = (struct dwarf2_debug *) bfd_zalloc (abfd, amt);
|
if (! stash)
|
if (! stash)
|
return FALSE;
|
return FALSE;
|
}
|
}
|
|
|
/* In a relocatable file, 2 functions may have the same address.
|
/* In a relocatable file, 2 functions may have the same address.
|
| Line 2914... |
Line 2905... |
}
|
}
|
}
|
}
|
else
|
else
|
debug_bfd = abfd;
|
debug_bfd = abfd;
|
|
|
/* There can be more than one DWARF2 info section in a BFD these days.
|
/* There can be more than one DWARF2 info section in a BFD these
|
Read them all in and produce one large stash. We do this in two
|
days. First handle the easy case when there's only one. If
|
passes - in the first pass we just accumulate the section sizes.
|
there's more than one, try case two: none of the sections is
|
In the second pass we read in the section's contents. The allows
|
compressed. In that case, read them all in and produce one
|
us to avoid reallocing the data as we add sections to the stash. */
|
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))
|
for (total_size = 0; msec; msec = find_debug_info (debug_bfd, msec))
|
|
{
|
total_size += msec->size;
|
total_size += msec->size;
|
|
if (strcmp (msec->name, DWARF2_COMPRESSED_DEBUG_INFO) == 0)
|
stash->info_ptr = bfd_alloc (debug_bfd, total_size);
|
all_uncompressed = 0;
|
if (stash->info_ptr == NULL)
|
}
|
|
if (all_uncompressed)
|
|
{
|
|
/* Case 2: multiple sections, but none is compressed. */
|
|
stash->info_ptr_memory = (bfd_byte *) bfd_malloc (total_size);
|
|
if (stash->info_ptr_memory == NULL)
|
goto done;
|
goto done;
|
|
|
stash->info_ptr_end = stash->info_ptr;
|
total_size = 0;
|
|
|
for (msec = find_debug_info (debug_bfd, NULL);
|
for (msec = find_debug_info (debug_bfd, NULL);
|
msec;
|
msec;
|
msec = find_debug_info (debug_bfd, msec))
|
msec = find_debug_info (debug_bfd, msec))
|
{
|
{
|
bfd_size_type size;
|
bfd_size_type size;
|
bfd_size_type start;
|
|
|
|
size = msec->size;
|
size = msec->size;
|
if (size == 0)
|
if (size == 0)
|
continue;
|
continue;
|
|
|
start = stash->info_ptr_end - stash->info_ptr;
|
if (!(bfd_simple_get_relocated_section_contents
|
|
(debug_bfd, msec, stash->info_ptr_memory + total_size,
|
|
symbols)))
|
|
goto done;
|
|
|
|
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;
|
|
|
if ((bfd_simple_get_relocated_section_contents
|
if (size == 0)
|
(debug_bfd, msec, stash->info_ptr + start, symbols)) == NULL)
|
|
continue;
|
continue;
|
|
|
stash->info_ptr_end = stash->info_ptr + start + size;
|
buffer = (bfd_simple_get_relocated_section_contents
|
}
|
(debug_bfd, msec, NULL, symbols));
|
|
if (! buffer)
|
|
goto done;
|
|
|
BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_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_byte *)
|
|
bfd_realloc (stash->info_ptr_memory, total_size + size);
|
|
memcpy (stash->info_ptr_memory + total_size, buffer, size);
|
|
free (buffer);
|
|
total_size += 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 = find_debug_info (debug_bfd, NULL);
|
stash->sec_info_ptr = stash->info_ptr;
|
stash->sec_info_ptr = stash->info_ptr;
|
stash->syms = symbols;
|
stash->syms = symbols;
|
stash->bfd = debug_bfd;
|
stash->bfd_ptr = debug_bfd;
|
}
|
}
|
|
|
/* A null info_ptr indicates that there is no dwarf2 info
|
/* A null info_ptr indicates that there is no dwarf2 info
|
(or that an error occured while setting up the stash). */
|
(or that an error occured while setting up the stash). */
|
if (! stash->info_ptr)
|
if (! stash->info_ptr)
|
| Line 3027... |
Line 3076... |
{
|
{
|
bfd_vma length;
|
bfd_vma length;
|
unsigned int offset_size = addr_size;
|
unsigned int offset_size = addr_size;
|
bfd_byte *info_ptr_unit = stash->info_ptr;
|
bfd_byte *info_ptr_unit = stash->info_ptr;
|
|
|
length = read_4_bytes (stash->bfd, stash->info_ptr);
|
length = read_4_bytes (stash->bfd_ptr, stash->info_ptr);
|
/* A 0xffffff length is the DWARF3 way of indicating
|
/* A 0xffffff length is the DWARF3 way of indicating
|
we use 64-bit offsets, instead of 32-bit offsets. */
|
we use 64-bit offsets, instead of 32-bit offsets. */
|
if (length == 0xffffffff)
|
if (length == 0xffffffff)
|
{
|
{
|
offset_size = 8;
|
offset_size = 8;
|
length = read_8_bytes (stash->bfd, stash->info_ptr + 4);
|
length = read_8_bytes (stash->bfd_ptr, stash->info_ptr + 4);
|
stash->info_ptr += 12;
|
stash->info_ptr += 12;
|
}
|
}
|
/* A zero length is the IRIX way of indicating 64-bit offsets,
|
/* A zero length is the IRIX way of indicating 64-bit offsets,
|
mostly because the 64-bit length will generally fit in 32
|
mostly because the 64-bit length will generally fit in 32
|
bits, and the endianness helps. */
|
bits, and the endianness helps. */
|
else if (length == 0)
|
else if (length == 0)
|
{
|
{
|
offset_size = 8;
|
offset_size = 8;
|
length = read_4_bytes (stash->bfd, stash->info_ptr + 4);
|
length = read_4_bytes (stash->bfd_ptr, stash->info_ptr + 4);
|
stash->info_ptr += 8;
|
stash->info_ptr += 8;
|
}
|
}
|
/* In the absence of the hints above, we assume 32-bit DWARF2
|
/* In the absence of the hints above, we assume 32-bit DWARF2
|
offsets even for targets with 64-bit addresses, because:
|
offsets even for targets with 64-bit addresses, because:
|
a) most of the time these targets will not have generated
|
a) most of the time these targets will not have generated
|
| Line 3072... |
Line 3121... |
/* The dwarf information is damaged, don't trust it any
|
/* The dwarf information is damaged, don't trust it any
|
more. */
|
more. */
|
break;
|
break;
|
stash->info_ptr += length;
|
stash->info_ptr += length;
|
|
|
if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
|
|
== stash->sec->size)
|
|
{
|
|
stash->sec = find_debug_info (stash->bfd, stash->sec);
|
|
stash->sec_info_ptr = stash->info_ptr;
|
|
}
|
|
|
|
if (stash->all_comp_units)
|
if (stash->all_comp_units)
|
stash->all_comp_units->prev_unit = each;
|
stash->all_comp_units->prev_unit = each;
|
else
|
else
|
stash->last_comp_unit = each;
|
stash->last_comp_unit = each;
|
|
|
| Line 3108... |
Line 3150... |
&& comp_unit_find_nearest_line (each, addr,
|
&& comp_unit_find_nearest_line (each, addr,
|
filename_ptr,
|
filename_ptr,
|
functionname_ptr,
|
functionname_ptr,
|
linenumber_ptr,
|
linenumber_ptr,
|
stash));
|
stash));
|
|
|
|
if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
|
|
== stash->sec->size)
|
|
{
|
|
stash->sec = find_debug_info (stash->bfd_ptr, stash->sec);
|
|
stash->sec_info_ptr = stash->info_ptr;
|
|
}
|
|
|
if (found)
|
if (found)
|
goto done;
|
goto done;
|
}
|
}
|
}
|
}
|
|
|
| Line 3165... |
Line 3215... |
unsigned int *linenumber_ptr,
|
unsigned int *linenumber_ptr,
|
void **pinfo)
|
void **pinfo)
|
{
|
{
|
struct dwarf2_debug *stash;
|
struct dwarf2_debug *stash;
|
|
|
stash = *pinfo;
|
stash = (struct dwarf2_debug *) *pinfo;
|
if (stash)
|
if (stash)
|
{
|
{
|
struct funcinfo *func = stash->inliner_chain;
|
struct funcinfo *func = stash->inliner_chain;
|
|
|
if (func && func->caller_func)
|
if (func && func->caller_func)
|
| Line 3192... |
Line 3242... |
struct dwarf2_debug *stash;
|
struct dwarf2_debug *stash;
|
|
|
if (abfd == NULL || elf_tdata (abfd) == NULL)
|
if (abfd == NULL || elf_tdata (abfd) == NULL)
|
return;
|
return;
|
|
|
stash = elf_tdata (abfd)->dwarf2_find_line_info;
|
stash = (struct dwarf2_debug *) elf_tdata (abfd)->dwarf2_find_line_info;
|
|
|
if (stash == NULL)
|
if (stash == NULL)
|
return;
|
return;
|
|
|
for (each = stash->all_comp_units; each; each = each->next_unit)
|
for (each = stash->all_comp_units; each; each = each->next_unit)
|
{
|
{
|
struct abbrev_info **abbrevs = each->abbrevs;
|
struct abbrev_info **abbrevs = each->abbrevs;
|
|
struct funcinfo *function_table = each->function_table;
|
|
struct varinfo *variable_table = each->variable_table;
|
size_t i;
|
size_t i;
|
|
|
for (i = 0; i < ABBREV_HASH_SIZE; i++)
|
for (i = 0; i < ABBREV_HASH_SIZE; i++)
|
{
|
{
|
struct abbrev_info *abbrev = abbrevs[i];
|
struct abbrev_info *abbrev = abbrevs[i];
|
| Line 3218... |
Line 3270... |
if (each->line_table)
|
if (each->line_table)
|
{
|
{
|
free (each->line_table->dirs);
|
free (each->line_table->dirs);
|
free (each->line_table->files);
|
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;
|
|
}
|
}
|
}
|
|
|
|
if (stash->dwarf_abbrev_buffer)
|
free (stash->dwarf_abbrev_buffer);
|
free (stash->dwarf_abbrev_buffer);
|
|
if (stash->dwarf_line_buffer)
|
free (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);
|
free (stash->dwarf_ranges_buffer);
|
|
if (stash->info_ptr_memory)
|
|
free (stash->info_ptr_memory);
|
}
|
}
|
|
|
No newline at end of file
|
No newline at end of file
|
