Back to index

cell-binutils  2.17cvs20070401
Classes | Defines | Functions
dwarf2.c File Reference
#include "bfd.h"
#include "sysdep.h"
#include "libiberty.h"
#include "libbfd.h"
#include "elf-bfd.h"
#include "elf/dwarf2.h"

Go to the source code of this file.

Classes

struct  line_head
struct  attribute
struct  dwarf_block
struct  loadable_section
struct  dwarf2_debug
struct  arange
struct  comp_unit
struct  abbrev_info
struct  attr_abbrev
struct  line_info
struct  fileinfo
struct  line_info_table
struct  funcinfo
struct  varinfo

Defines

#define ABBREV_HASH_SIZE   121
#define ATTR_ALLOC_CHUNK   4
#define FILE_ALLOC_CHUNK   5
#define DIR_ALLOC_CHUNK   5
#define DWARF2_DEBUG_INFO   ".debug_info"
#define GNU_LINKONCE_INFO   ".gnu.linkonce.wi."

Functions

static unsigned int read_1_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf)
static int read_1_signed_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf)
static unsigned int read_2_bytes (bfd *abfd, bfd_byte *buf)
static unsigned int read_4_bytes (bfd *abfd, bfd_byte *buf)
static bfd_uint64_t read_8_bytes (bfd *abfd, bfd_byte *buf)
static bfd_byteread_n_bytes (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf, unsigned int size ATTRIBUTE_UNUSED)
static char * read_string (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf, unsigned int *bytes_read_ptr)
static char * read_indirect_string (struct comp_unit *unit, bfd_byte *buf, unsigned int *bytes_read_ptr)
static bfd_uint64_t read_address (struct comp_unit *unit, bfd_byte *buf)
static struct abbrev_infolookup_abbrev (unsigned int number, struct abbrev_info **abbrevs)
static struct abbrev_info ** read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
static bfd_byteread_attribute_value (struct attribute *attr, unsigned form, struct comp_unit *unit, bfd_byte *info_ptr)
static bfd_byteread_attribute (struct attribute *attr, struct attr_abbrev *abbrev, struct comp_unit *unit, bfd_byte *info_ptr)
static bfd_boolean new_line_sorts_after (struct line_info *new_line, struct line_info *line)
static void add_line_info (struct line_info_table *table, bfd_vma address, char *filename, unsigned int line, unsigned int column, int end_sequence)
static char * concat_filename (struct line_info_table *table, unsigned int file)
static void arange_add (bfd *abfd, struct arange *first_arange, bfd_vma low_pc, bfd_vma high_pc)
static struct line_info_tabledecode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
static bfd_boolean lookup_address_in_line_info_table (struct line_info_table *table, bfd_vma addr, struct funcinfo *function, const char **filename_ptr, unsigned int *linenumber_ptr)
static bfd_boolean read_debug_ranges (struct comp_unit *unit)
static bfd_boolean lookup_address_in_function_table (struct comp_unit *unit, bfd_vma addr, struct funcinfo **function_ptr, const char **functionname_ptr)
static bfd_boolean lookup_symbol_in_function_table (struct comp_unit *unit, asymbol *sym, bfd_vma addr, const char **filename_ptr, unsigned int *linenumber_ptr)
static bfd_boolean lookup_symbol_in_variable_table (struct comp_unit *unit, asymbol *sym, bfd_vma addr, const char **filename_ptr, unsigned int *linenumber_ptr)
static char * find_abstract_instance_name (struct comp_unit *unit, bfd_uint64_t die_ref)
static void read_rangelist (struct comp_unit *unit, struct arange *arange, bfd_uint64_t offset)
static bfd_boolean scan_unit_for_symbols (struct comp_unit *unit)
static struct comp_unitparse_comp_unit (bfd *abfd, struct dwarf2_debug *stash, bfd_vma unit_length, bfd_byte *info_ptr_unit, unsigned int offset_size)
static bfd_boolean comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
static bfd_boolean comp_unit_find_nearest_line (struct comp_unit *unit, bfd_vma addr, const char **filename_ptr, const char **functionname_ptr, unsigned int *linenumber_ptr, struct dwarf2_debug *stash)
static bfd_boolean comp_unit_find_line (struct comp_unit *unit, asymbol *sym, bfd_vma addr, const char **filename_ptr, unsigned int *linenumber_ptr, struct dwarf2_debug *stash)
static asectionfind_debug_info (bfd *abfd, asection *after_sec)
static void unset_sections (struct dwarf2_debug *stash)
static bfd_boolean place_sections (bfd *abfd, struct dwarf2_debug *stash)
bfd_boolean _bfd_dwarf2_find_nearest_line (bfd *abfd, asection *section, asymbol **symbols, bfd_vma offset, const char **filename_ptr, const char **functionname_ptr, unsigned int *linenumber_ptr, unsigned int addr_size, void **pinfo)
bfd_boolean _bfd_dwarf2_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol, const char **filename_ptr, unsigned int *linenumber_ptr, unsigned int addr_size, void **pinfo)
bfd_boolean _bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED, const char **filename_ptr, const char **functionname_ptr, unsigned int *linenumber_ptr, void **pinfo)
void _bfd_dwarf2_cleanup_debug_info (bfd *abfd)

Class Documentation

struct line_head

Definition at line 41 of file dwarf2.c.

Class Members
unsigned char default_is_stmt
int line_base
unsigned char line_range
unsigned char minimum_instruction_length
unsigned char opcode_base
bfd_vma prologue_length
unsigned char * standard_opcode_lengths
bfd_vma total_length
unsigned short version
struct attribute

Definition at line 56 of file dwarf2.c.

struct dwarf_block

Definition at line 71 of file dwarf2.c.

Class Members
bfd_byte * data
unsigned int size
struct loadable_section

Definition at line 77 of file dwarf2.c.

Collaboration diagram for loadable_section:
Class Members
bfd_vma adj_vma
asection * section
struct dwarf2_debug

Definition at line 83 of file dwarf2.c.

Collaboration diagram for dwarf2_debug:
Class Members
struct comp_unit * all_comp_units
bfd_byte * dwarf_abbrev_buffer
unsigned long dwarf_abbrev_size
bfd_byte * dwarf_line_buffer
unsigned long dwarf_line_size
bfd_byte * dwarf_ranges_buffer
unsigned long dwarf_ranges_size
bfd_byte * dwarf_str_buffer
unsigned long dwarf_str_size
bfd_byte * info_ptr
bfd_byte * info_ptr_end
struct funcinfo * inliner_chain
unsigned int loadable_section_count
struct loadable_section * loadable_sections
asection * sec
bfd_byte * sec_info_ptr
asymbol ** syms
struct arange

Definition at line 141 of file dwarf2.c.

Collaboration diagram for arange:
Class Members
bfd_vma high
bfd_vma low
struct arange * next
struct comp_unit

Definition at line 151 of file dwarf2.c.

Collaboration diagram for comp_unit:
Class Members
struct abbrev_info ** abbrevs
bfd * abfd
unsigned char addr_size
bfd_vma base_address
char * comp_dir
bfd_byte * end_ptr
int error
bfd_byte * first_child_die_ptr
struct funcinfo * function_table
bfd_byte * info_ptr_unit
unsigned long line_offset
struct line_info_table * line_table
char * name
struct comp_unit * next_unit
unsigned char offset_size
struct dwarf2_debug * stash
int stmtlist
struct varinfo * variable_table
struct abbrev_info

Definition at line 215 of file dwarf2.c.

Collaboration diagram for abbrev_info:
Class Members
enum dwarf_tag int
has_children unsigned int
num_attrs struct attr_abbrev *
attrs
struct abbrev_info * next
unsigned int number
struct attr_abbrev

Definition at line 225 of file dwarf2.c.

struct line_info

Definition at line 693 of file dwarf2.c.

Collaboration diagram for line_info:
Class Members
bfd_vma address
unsigned int column
int end_sequence
char * filename
unsigned int line
struct line_info * prev_line
struct fileinfo

Definition at line 703 of file dwarf2.c.

Class Members
unsigned int dir
char * name
unsigned int size
unsigned int time
struct line_info_table

Definition at line 711 of file dwarf2.c.

Collaboration diagram for line_info_table:
Class Members
bfd * abfd
char * comp_dir
char ** dirs
struct fileinfo * files
struct line_info * last_line
struct line_info * lcl_head
unsigned int num_dirs
unsigned int num_files
struct funcinfo

Definition at line 728 of file dwarf2.c.

Collaboration diagram for funcinfo:
Class Members
char * caller_file
struct funcinfo * caller_func
int caller_line
char * file
int line
char * name
struct funcinfo * prev_func
asection * sec
int tag
struct varinfo

Definition at line 742 of file dwarf2.c.

Collaboration diagram for varinfo:
Class Members
bfd_vma addr
char * file
int line
char * name
struct varinfo * prev_var
asection * sec
unsigned int stack: 1
int tag

Define Documentation

#define ABBREV_HASH_SIZE   121

Definition at line 232 of file dwarf2.c.

#define ATTR_ALLOC_CHUNK   4

Definition at line 235 of file dwarf2.c.

#define DIR_ALLOC_CHUNK   5

Definition at line 691 of file dwarf2.c.

#define DWARF2_DEBUG_INFO   ".debug_info"

Definition at line 2187 of file dwarf2.c.

#define FILE_ALLOC_CHUNK   5

Definition at line 690 of file dwarf2.c.

#define GNU_LINKONCE_INFO   ".gnu.linkonce.wi."

Definition at line 2188 of file dwarf2.c.


Function Documentation

Definition at line 2788 of file dwarf2.c.

{
  struct comp_unit *each;
  struct dwarf2_debug *stash;

  if (abfd == NULL || elf_tdata (abfd) == NULL)
    return;

  stash = elf_tdata (abfd)->dwarf2_find_line_info;

  if (stash == NULL)
    return;

  for (each = stash->all_comp_units; each; each = each->next_unit)
    {
      struct abbrev_info **abbrevs = each->abbrevs;
      size_t i;

      for (i = 0; i < ABBREV_HASH_SIZE; i++)
       {
         struct abbrev_info *abbrev = abbrevs[i];

         while (abbrev)
           {
             free (abbrev->attrs);
             abbrev = abbrev->next;
           }
       }

      if (each->line_table)
       {
         free (each->line_table->dirs);
         free (each->line_table->files);
       }
    }

  free (stash->dwarf_abbrev_buffer);
  free (stash->dwarf_line_buffer);
  free (stash->dwarf_ranges_buffer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bfd_boolean _bfd_dwarf2_find_inliner_info ( bfd *abfd  ATTRIBUTE_UNUSED,
const char **  filename_ptr,
const char **  functionname_ptr,
unsigned int linenumber_ptr,
void **  pinfo 
)

Definition at line 2762 of file dwarf2.c.

{
  struct dwarf2_debug *stash;

  stash = *pinfo;
  if (stash)
    {
      struct funcinfo *func = stash->inliner_chain;
      if (func && func->caller_func)
       {
         *filename_ptr = func->caller_file;
         *functionname_ptr = func->caller_func->name;
         *linenumber_ptr = func->caller_line;
         stash->inliner_chain = func->caller_func;
         return (TRUE);
       }
    }

  return (FALSE);
}

Here is the caller graph for this function:

bfd_boolean _bfd_dwarf2_find_line ( bfd abfd,
asymbol **  symbols,
asymbol symbol,
const char **  filename_ptr,
unsigned int linenumber_ptr,
unsigned int  addr_size,
void **  pinfo 
)

Definition at line 2538 of file dwarf2.c.

{
  /* Read each compilation unit from the section .debug_info, and check
     to see if it contains the address we are searching for.  If yes,
     lookup the address, and return the line number info.  If no, go
     on to the next compilation unit.

     We keep a list of all the previously read compilation units, and
     a pointer to the next un-read compilation unit.  Check the
     previously read units before reading more.  */
  struct dwarf2_debug *stash;

  /* What address are we looking for?  */
  bfd_vma addr;

  struct comp_unit* each;

  asection *section;

  bfd_boolean found = FALSE;

  section = bfd_get_section (symbol);

  stash = *pinfo;

  if (! stash)
    {
      bfd_size_type amt = sizeof (struct dwarf2_debug);

      stash = bfd_zalloc (abfd, amt);
      if (! stash)
       return FALSE;
    }

  /* In a relocatable file, 2 functions may have the same address.
     We change the section vma so that they won't overlap.  */
  if (!stash && (abfd->flags & (EXEC_P | DYNAMIC)) == 0)
    {
      if (! place_sections (abfd, stash))
       return FALSE;
    }

  addr = symbol->value;
  if (section->output_section)
    addr += section->output_section->vma + section->output_offset;
  else
    addr += section->vma;

  *filename_ptr = NULL;
  *filename_ptr = NULL;
  *linenumber_ptr = 0;

  if (! *pinfo)
    {
      bfd_size_type total_size;
      asection *msec;

      *pinfo = stash;

      msec = find_debug_info (abfd, NULL);
      if (! msec)
       /* No dwarf2 info.  Note that at this point the stash
          has been allocated, but contains zeros, this lets
          future calls to this function fail quicker.  */
       goto done;

      /* 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 (abfd, msec))
       total_size += msec->size;

      stash->info_ptr = bfd_alloc (abfd, total_size);
      if (stash->info_ptr == NULL)
       goto done;

      stash->info_ptr_end = stash->info_ptr;

      for (msec = find_debug_info (abfd, NULL);
          msec;
          msec = find_debug_info (abfd, msec))
       {
         bfd_size_type size;
         bfd_size_type start;

         size = msec->size;
         if (size == 0)
           continue;

         start = stash->info_ptr_end - stash->info_ptr;

         if ((bfd_simple_get_relocated_section_contents
              (abfd, msec, stash->info_ptr + start, symbols)) == NULL)
           continue;

         stash->info_ptr_end = stash->info_ptr + start + size;
       }

      BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size);

      stash->sec = find_debug_info (abfd, NULL);
      stash->sec_info_ptr = stash->info_ptr;
      stash->syms = symbols;
    }

  /* A null info_ptr indicates that there is no dwarf2 info
     (or that an error occured while setting up the stash).  */
  if (! stash->info_ptr)
    goto done;

  stash->inliner_chain = NULL;

  /* Check the previously read comp. units first.  */
  for (each = stash->all_comp_units; each; each = each->next_unit)
    if ((symbol->flags & BSF_FUNCTION) == 0
       || comp_unit_contains_address (each, addr))
      {
       found = comp_unit_find_line (each, symbol, addr, filename_ptr,
                                 linenumber_ptr, stash);
       if (found)
         goto done;
      }

  /* The DWARF2 spec says that the initial length field, and the
     offset of the abbreviation table, should both be 4-byte values.
     However, some compilers do things differently.  */
  if (addr_size == 0)
    addr_size = 4;
  BFD_ASSERT (addr_size == 4 || addr_size == 8);

  /* Read each remaining comp. units checking each as they are read.  */
  while (stash->info_ptr < stash->info_ptr_end)
    {
      bfd_vma length;
      unsigned int offset_size = addr_size;
      bfd_byte *info_ptr_unit = stash->info_ptr;

      length = read_4_bytes (abfd, stash->info_ptr);
      /* A 0xffffff length is the DWARF3 way of indicating we use
        64-bit offsets, instead of 32-bit offsets.  */
      if (length == 0xffffffff)
       {
         offset_size = 8;
         length = read_8_bytes (abfd, stash->info_ptr + 4);
         stash->info_ptr += 12;
       }
      /* A zero length is the IRIX way of indicating 64-bit offsets,
        mostly because the 64-bit length will generally fit in 32
        bits, and the endianness helps.  */
      else if (length == 0)
       {
         offset_size = 8;
         length = read_4_bytes (abfd, stash->info_ptr + 4);
         stash->info_ptr += 8;
       }
      /* In the absence of the hints above, we assume 32-bit DWARF2
        offsets even for targets with 64-bit addresses, because:
          a) most of the time these targets will not have generated
             more than 2Gb of debug info and so will not need 64-bit
             offsets,
        and
          b) if they do use 64-bit offsets but they are not using
             the size hints that are tested for above then they are
             not conforming to the DWARF3 standard anyway.  */
      else if (addr_size == 8)
       {
         offset_size = 4;
          stash->info_ptr += 4;
       }
      else
       stash->info_ptr += 4;

      if (length > 0)
       {
         each = parse_comp_unit (abfd, stash, length, info_ptr_unit,
                              offset_size);
         stash->info_ptr += length;

         if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
             == stash->sec->size)
           {
             stash->sec = find_debug_info (abfd, stash->sec);
             stash->sec_info_ptr = stash->info_ptr;
           }

         if (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.  */
             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));
             if (found)
              goto done;
           }
       }
    }

done:
  if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
    unset_sections (stash);

  return found;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bfd_boolean _bfd_dwarf2_find_nearest_line ( bfd abfd,
asection section,
asymbol **  symbols,
bfd_vma  offset,
const char **  filename_ptr,
const char **  functionname_ptr,
unsigned int linenumber_ptr,
unsigned int  addr_size,
void **  pinfo 
)

Definition at line 2312 of file dwarf2.c.

{
  /* Read each compilation unit from the section .debug_info, and check
     to see if it contains the address we are searching for.  If yes,
     lookup the address, and return the line number info.  If no, go
     on to the next compilation unit.

     We keep a list of all the previously read compilation units, and
     a pointer to the next un-read compilation unit.  Check the
     previously read units before reading more.  */
  struct dwarf2_debug *stash;

  /* What address are we looking for?  */
  bfd_vma addr;

  struct comp_unit* each;

  bfd_vma found = FALSE;

  stash = *pinfo;

  if (! stash)
    {
      bfd_size_type amt = sizeof (struct dwarf2_debug);

      stash = bfd_zalloc (abfd, amt);
      if (! stash)
       return FALSE;
    }

  /* In a relocatable file, 2 functions may have the same address.
     We change the section vma so that they won't overlap.  */
  if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
    {
      if (! place_sections (abfd, stash))
       return FALSE;
    }

  addr = offset;
  if (section->output_section)
    addr += section->output_section->vma + section->output_offset;
  else
    addr += section->vma;
  *filename_ptr = NULL;
  *functionname_ptr = NULL;
  *linenumber_ptr = 0;

  /* The DWARF2 spec says that the initial length field, and the
     offset of the abbreviation table, should both be 4-byte values.
     However, some compilers do things differently.  */
  if (addr_size == 0)
    addr_size = 4;
  BFD_ASSERT (addr_size == 4 || addr_size == 8);

  if (! *pinfo)
    {
      bfd_size_type total_size;
      asection *msec;

      *pinfo = stash;

      msec = find_debug_info (abfd, NULL);
      if (! msec)
       /* No dwarf2 info.  Note that at this point the stash
          has been allocated, but contains zeros, this lets
          future calls to this function fail quicker.  */
       goto done;

      /* 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 (abfd, msec))
       total_size += msec->size;

      stash->info_ptr = bfd_alloc (abfd, total_size);
      if (stash->info_ptr == NULL)
       goto done;

      stash->info_ptr_end = stash->info_ptr;

      for (msec = find_debug_info (abfd, NULL);
          msec;
          msec = find_debug_info (abfd, msec))
       {
         bfd_size_type size;
         bfd_size_type start;

         size = msec->size;
         if (size == 0)
           continue;

         start = stash->info_ptr_end - stash->info_ptr;

         if ((bfd_simple_get_relocated_section_contents
              (abfd, msec, stash->info_ptr + start, symbols)) == NULL)
           continue;

         stash->info_ptr_end = stash->info_ptr + start + size;
       }

      BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size);

      stash->sec = find_debug_info (abfd, NULL);
      stash->sec_info_ptr = stash->info_ptr;
      stash->syms = symbols;
    }

  /* A null info_ptr indicates that there is no dwarf2 info
     (or that an error occured while setting up the stash).  */
  if (! stash->info_ptr)
    goto done;

  stash->inliner_chain = NULL;

  /* Check the previously read comp. units first.  */
  for (each = stash->all_comp_units; each; each = each->next_unit)
    if (comp_unit_contains_address (each, addr)
       && comp_unit_find_nearest_line (each, addr, filename_ptr,
                                   functionname_ptr,
                                   linenumber_ptr, stash))
      {
       found = TRUE;
       goto done;
      }

  /* Read each remaining comp. units checking each as they are read.  */
  while (stash->info_ptr < stash->info_ptr_end)
    {
      bfd_vma length;
      unsigned int offset_size = addr_size;
      bfd_byte *info_ptr_unit = stash->info_ptr;

      length = read_4_bytes (abfd, stash->info_ptr);
      /* A 0xffffff length is the DWARF3 way of indicating we use
        64-bit offsets, instead of 32-bit offsets.  */
      if (length == 0xffffffff)
       {
         offset_size = 8;
         length = read_8_bytes (abfd, stash->info_ptr + 4);
         stash->info_ptr += 12;
       }
      /* A zero length is the IRIX way of indicating 64-bit offsets,
        mostly because the 64-bit length will generally fit in 32
        bits, and the endianness helps.  */
      else if (length == 0)
       {
         offset_size = 8;
         length = read_4_bytes (abfd, stash->info_ptr + 4);
         stash->info_ptr += 8;
       }
      /* In the absence of the hints above, we assume 32-bit DWARF2
        offsets even for targets with 64-bit addresses, because:
          a) most of the time these targets will not have generated
             more than 2Gb of debug info and so will not need 64-bit
             offsets,
        and
          b) if they do use 64-bit offsets but they are not using
             the size hints that are tested for above then they are
             not conforming to the DWARF3 standard anyway.  */
      else if (addr_size == 8)
       {
         offset_size = 4;
          stash->info_ptr += 4;
       }
      else
       stash->info_ptr += 4;

      if (length > 0)
       {
         each = parse_comp_unit (abfd, stash, length, info_ptr_unit,
                              offset_size);
         stash->info_ptr += length;

         if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
             == stash->sec->size)
           {
             stash->sec = find_debug_info (abfd, stash->sec);
             stash->sec_info_ptr = stash->info_ptr;
           }

         if (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 ((each->arange.high == 0
                 || comp_unit_contains_address (each, addr))
                && comp_unit_find_nearest_line (each, addr,
                                            filename_ptr,
                                            functionname_ptr,
                                            linenumber_ptr,
                                            stash))
              {
                found = TRUE;
                goto done;
              }
           }
       }
    }

done:
  if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
    unset_sections (stash);

  return found;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void add_line_info ( struct line_info_table table,
bfd_vma  address,
char *  filename,
unsigned int  line,
unsigned int  column,
int  end_sequence 
) [static]

Definition at line 776 of file dwarf2.c.

{
  bfd_size_type amt = sizeof (struct line_info);
  struct line_info* info = bfd_alloc (table->abfd, amt);

  /* Set member data of 'info'.  */
  info->address = address;
  info->line = line;
  info->column = column;
  info->end_sequence = end_sequence;

  if (filename && filename[0])
    {
      info->filename = bfd_alloc (table->abfd, strlen (filename) + 1);
      if (info->filename)
       strcpy (info->filename, filename);
    }
  else
    info->filename = NULL;

  /* Find the correct location for 'info'.  Normally we will receive
     new line_info data 1) in order and 2) with increasing VMAs.
     However some compilers break the rules (cf. decode_line_info) and
     so we include some heuristics for quickly finding the correct
     location for 'info'. In particular, these heuristics optimize for
     the common case in which the VMA sequence that we receive is a
     list of locally sorted VMAs such as
       p...z a...j  (where a < j < p < z)

     Note: table->lcl_head is used to head an *actual* or *possible*
     sequence within the list (such as a...j) that is not directly
     headed by table->last_line

     Note: we may receive duplicate entries from 'decode_line_info'.  */

  if (!table->last_line
      || new_line_sorts_after (info, table->last_line))
    {
      /* Normal case: add 'info' to the beginning of the list */
      info->prev_line = table->last_line;
      table->last_line = info;

      /* lcl_head: initialize to head a *possible* sequence at the end.  */
      if (!table->lcl_head)
       table->lcl_head = info;
    }
  else if (!new_line_sorts_after (info, table->lcl_head)
          && (!table->lcl_head->prev_line
              || new_line_sorts_after (info, table->lcl_head->prev_line)))
    {
      /* Abnormal but easy: lcl_head is the head of 'info'.  */
      info->prev_line = table->lcl_head->prev_line;
      table->lcl_head->prev_line = info;
    }
  else
    {
      /* 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* li1 = li2->prev_line;

      while (li1)
       {
         if (!new_line_sorts_after (info, li2)
             && new_line_sorts_after (info, li1))
           break;

         li2 = li1; /* always non-NULL */
         li1 = li1->prev_line;
       }
      table->lcl_head = li2;
      info->prev_line = table->lcl_head->prev_line;
      table->lcl_head->prev_line = info;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void arange_add ( bfd abfd,
struct arange first_arange,
bfd_vma  low_pc,
bfd_vma  high_pc 
) [static]

Definition at line 922 of file dwarf2.c.

{
  struct arange *arange;

  /* If the first arange is empty, use it. */
  if (first_arange->high == 0)
    {
      first_arange->low = low_pc;
      first_arange->high = high_pc;
      return;
    }

  /* Next see if we can cheaply extend an existing range.  */
  arange = first_arange;
  do
    {
      if (low_pc == arange->high)
       {
         arange->high = high_pc;
         return;
       }
      if (high_pc == arange->low)
       {
         arange->low = low_pc;
         return;
       }
      arange = arange->next;
    }
  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. */
  arange = bfd_zalloc (abfd, sizeof (*arange));
  arange->low = low_pc;
  arange->high = high_pc;
  arange->next = first_arange->next;
  first_arange->next = arange;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean comp_unit_contains_address ( struct comp_unit unit,
bfd_vma  addr 
) [static]

Definition at line 2048 of file dwarf2.c.

{
  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;
}

Here is the caller graph for this function:

static bfd_boolean comp_unit_find_line ( struct comp_unit unit,
asymbol sym,
bfd_vma  addr,
const char **  filename_ptr,
unsigned int linenumber_ptr,
struct dwarf2_debug stash 
) [static]

Definition at line 2134 of file dwarf2.c.

{
  if (unit->error)
    return FALSE;

  if (! unit->line_table)
    {
      if (! unit->stmtlist)
       {
         unit->error = 1;
         return FALSE;
       }

      unit->line_table = decode_line_info (unit, stash);

      if (! unit->line_table)
       {
         unit->error = 1;
         return FALSE;
       }

      if (unit->first_child_die_ptr < unit->end_ptr
         && ! scan_unit_for_symbols (unit))
       {
         unit->error = 1;
         return FALSE;
       }
    }

  if (sym->flags & BSF_FUNCTION)
    return lookup_symbol_in_function_table (unit, sym, addr,
                                       filename_ptr,
                                       linenumber_ptr);
  else
    return lookup_symbol_in_variable_table (unit, sym, addr,
                                       filename_ptr,
                                       linenumber_ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean comp_unit_find_nearest_line ( struct comp_unit unit,
bfd_vma  addr,
const char **  filename_ptr,
const char **  functionname_ptr,
unsigned int linenumber_ptr,
struct dwarf2_debug stash 
) [static]

Definition at line 2076 of file dwarf2.c.

{
  bfd_boolean line_p;
  bfd_boolean func_p;
  struct funcinfo *function;

  if (unit->error)
    return FALSE;

  if (! unit->line_table)
    {
      if (! unit->stmtlist)
       {
         unit->error = 1;
         return FALSE;
       }

      unit->line_table = decode_line_info (unit, stash);

      if (! unit->line_table)
       {
         unit->error = 1;
         return FALSE;
       }

      if (unit->first_child_die_ptr < unit->end_ptr
         && ! scan_unit_for_symbols (unit))
       {
         unit->error = 1;
         return FALSE;
       }
    }

  function = NULL;
  func_p = lookup_address_in_function_table (unit, addr,
                                        &function, functionname_ptr);
  if (func_p && (function->tag == DW_TAG_inlined_subroutine))
    stash->inliner_chain = function;
  line_p = lookup_address_in_line_info_table (unit->line_table, addr,
                                         function, filename_ptr,
                                         linenumber_ptr);
  return line_p || func_p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* concat_filename ( struct line_info_table table,
unsigned int  file 
) [static]

Definition at line 862 of file dwarf2.c.

{
  char *filename;

  if (file - 1 >= table->num_files)
    {
      /* FILE == 0 means unknown.  */
      if (file)
       (*_bfd_error_handler)
         (_("Dwarf Error: mangled line number section (bad file number)."));
      return strdup ("<unknown>");
    }

  filename = table->files[file - 1].name;

  if (!IS_ABSOLUTE_PATH (filename))
    {
      char *dirname = NULL;
      char *subdirname = NULL;
      char *name;
      size_t len;

      if (table->files[file - 1].dir)
       subdirname = table->dirs[table->files[file - 1].dir - 1];

      if (!subdirname || !IS_ABSOLUTE_PATH (subdirname))
       dirname = table->comp_dir;

      if (!dirname)
       {
         dirname = subdirname;
         subdirname = NULL;
       }

      if (!dirname)
       return strdup (filename);

      len = strlen (dirname) + strlen (filename) + 2;

      if (subdirname)
       {
         len += strlen (subdirname) + 1;
         name = bfd_malloc (len);
         if (name)
           sprintf (name, "%s/%s/%s", dirname, subdirname, filename);
       }
      else
       {
         name = bfd_malloc (len);
         if (name)
           sprintf (name, "%s/%s", dirname, filename);
       }

      return name;
    }

  return strdup (filename);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct line_info_table* decode_line_info ( struct comp_unit unit,
struct dwarf2_debug stash 
) [static, read]

Definition at line 964 of file dwarf2.c.

{
  bfd *abfd = unit->abfd;
  struct line_info_table* table;
  bfd_byte *line_ptr;
  bfd_byte *line_end;
  struct line_head lh;
  unsigned int i, bytes_read, offset_size;
  char *cur_file, *cur_dir;
  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;
    }

  amt = sizeof (struct line_info_table);
  table = bfd_alloc (abfd, amt);
  table->abfd = abfd;
  table->comp_dir = unit->comp_dir;

  table->num_files = 0;
  table->files = NULL;

  table->num_dirs = 0;
  table->dirs = NULL;

  table->files = NULL;
  table->last_line = NULL;
  table->lcl_head = NULL;

  line_ptr = stash->dwarf_line_buffer + unit->line_offset;

  /* Read in the prologue.  */
  lh.total_length = read_4_bytes (abfd, line_ptr);
  line_ptr += 4;
  offset_size = 4;
  if (lh.total_length == 0xffffffff)
    {
      lh.total_length = read_8_bytes (abfd, line_ptr);
      line_ptr += 8;
      offset_size = 8;
    }
  else if (lh.total_length == 0 && unit->addr_size == 8)
    {
      /* Handle (non-standard) 64-bit DWARF2 formats.  */
      lh.total_length = read_4_bytes (abfd, line_ptr);
      line_ptr += 4;
      offset_size = 8;
    }
  line_end = line_ptr + lh.total_length;
  lh.version = read_2_bytes (abfd, line_ptr);
  line_ptr += 2;
  if (offset_size == 4)
    lh.prologue_length = read_4_bytes (abfd, line_ptr);
  else
    lh.prologue_length = read_8_bytes (abfd, line_ptr);
  line_ptr += offset_size;
  lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
  line_ptr += 1;
  lh.default_is_stmt = read_1_byte (abfd, line_ptr);
  line_ptr += 1;
  lh.line_base = read_1_signed_byte (abfd, line_ptr);
  line_ptr += 1;
  lh.line_range = read_1_byte (abfd, line_ptr);
  line_ptr += 1;
  lh.opcode_base = read_1_byte (abfd, line_ptr);
  line_ptr += 1;
  amt = lh.opcode_base * sizeof (unsigned char);
  lh.standard_opcode_lengths = bfd_alloc (abfd, amt);

  lh.standard_opcode_lengths[0] = 1;

  for (i = 1; i < lh.opcode_base; ++i)
    {
      lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
      line_ptr += 1;
    }

  /* Read directory table.  */
  while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
    {
      line_ptr += bytes_read;

      if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
       {
         char **tmp;

         amt = table->num_dirs + DIR_ALLOC_CHUNK;
         amt *= sizeof (char *);

         tmp = bfd_realloc (table->dirs, amt);
         if (tmp == NULL)
           {
             free (table->dirs);
             return NULL;
           }
         table->dirs = tmp;
       }

      table->dirs[table->num_dirs++] = cur_dir;
    }

  line_ptr += bytes_read;

  /* Read file name table.  */
  while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
    {
      line_ptr += bytes_read;

      if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
       {
         struct fileinfo *tmp;

         amt = table->num_files + FILE_ALLOC_CHUNK;
         amt *= sizeof (struct fileinfo);

         tmp = bfd_realloc (table->files, amt);
         if (tmp == NULL)
           {
             free (table->files);
             free (table->dirs);
             return NULL;
           }
         table->files = tmp;
       }

      table->files[table->num_files].name = cur_file;
      table->files[table->num_files].dir =
       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
      line_ptr += bytes_read;
      table->files[table->num_files].time =
       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
      line_ptr += bytes_read;
      table->files[table->num_files].size =
       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
      line_ptr += bytes_read;
      table->num_files++;
    }

  line_ptr += bytes_read;

  /* Read the statement sequences until there's nothing left.  */
  while (line_ptr < line_end)
    {
      /* State machine registers.  */
      bfd_vma address = 0;
      char * filename = table->num_files ? concat_filename (table, 1) : NULL;
      unsigned int line = 1;
      unsigned int column = 0;
      int is_stmt = lh.default_is_stmt;
      int end_sequence = 0;
      /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
        compilers generate address sequences that are wildly out of
        order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
        for ia64-Linux).  Thus, to determine the low and high
        address, we must compare on every DW_LNS_copy, etc.  */
      bfd_vma low_pc  = (bfd_vma) -1;
      bfd_vma high_pc = 0;

      /* Decode the table.  */
      while (! end_sequence)
       {
         op_code = read_1_byte (abfd, line_ptr);
         line_ptr += 1;

         if (op_code >= lh.opcode_base)
           {
             /* Special operand.  */
             adj_opcode = op_code - lh.opcode_base;
             address += (adj_opcode / lh.line_range)
              * lh.minimum_instruction_length;
             line += lh.line_base + (adj_opcode % lh.line_range);
             /* Append row to matrix using current values.  */
             add_line_info (table, address, filename, line, column, 0);
             if (address < low_pc)
              low_pc = address;
             if (address > high_pc)
              high_pc = address;
           }
         else switch (op_code)
           {
           case DW_LNS_extended_op:
             /* Ignore length.  */
             line_ptr += 1;
             extended_op = read_1_byte (abfd, line_ptr);
             line_ptr += 1;

             switch (extended_op)
              {
              case DW_LNE_end_sequence:
                end_sequence = 1;
                add_line_info (table, address, filename, line, column,
                             end_sequence);
                if (address < low_pc)
                  low_pc = address;
                if (address > high_pc)
                  high_pc = address;
                arange_add (unit->abfd, &unit->arange, low_pc, high_pc);
                break;
              case DW_LNE_set_address:
                address = read_address (unit, line_ptr);
                line_ptr += unit->addr_size;
                break;
              case DW_LNE_define_file:
                cur_file = read_string (abfd, line_ptr, &bytes_read);
                line_ptr += bytes_read;
                if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
                  {
                    struct fileinfo *tmp;

                    amt = table->num_files + FILE_ALLOC_CHUNK;
                    amt *= sizeof (struct fileinfo);
                    tmp = bfd_realloc (table->files, amt);
                    if (tmp == NULL)
                     {
                       free (table->files);
                       free (table->dirs);
                       free (filename);
                       return NULL;
                     }
                    table->files = tmp;
                  }
                table->files[table->num_files].name = cur_file;
                table->files[table->num_files].dir =
                  read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
                line_ptr += bytes_read;
                table->files[table->num_files].time =
                  read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
                line_ptr += bytes_read;
                table->files[table->num_files].size =
                  read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
                line_ptr += bytes_read;
                table->num_files++;
                break;
              default:
                (*_bfd_error_handler) (_("Dwarf Error: mangled line number section."));
                bfd_set_error (bfd_error_bad_value);
                free (filename);
                free (table->files);
                free (table->dirs);
                return NULL;
              }
             break;
           case DW_LNS_copy:
             add_line_info (table, address, filename, line, column, 0);
             if (address < low_pc)
              low_pc = address;
             if (address > high_pc)
              high_pc = address;
             break;
           case DW_LNS_advance_pc:
             address += lh.minimum_instruction_length
              * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
             line_ptr += bytes_read;
             break;
           case DW_LNS_advance_line:
             line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
             line_ptr += bytes_read;
             break;
           case DW_LNS_set_file:
             {
              unsigned int file;

              /* The file and directory tables are 0
                 based, the references are 1 based.  */
              file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
              line_ptr += bytes_read;
              if (filename)
                free (filename);
              filename = concat_filename (table, file);
              break;
             }
           case DW_LNS_set_column:
             column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
             line_ptr += bytes_read;
             break;
           case DW_LNS_negate_stmt:
             is_stmt = (!is_stmt);
             break;
           case DW_LNS_set_basic_block:
             break;
           case DW_LNS_const_add_pc:
             address += lh.minimum_instruction_length
                    * ((255 - lh.opcode_base) / lh.line_range);
             break;
           case DW_LNS_fixed_advance_pc:
             address += read_2_bytes (abfd, line_ptr);
             line_ptr += 2;
             break;
           default:
             {
              int i;

              /* Unknown standard opcode, ignore it.  */
              for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
                {
                  (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
                  line_ptr += bytes_read;
                }
             }
           }
       }

      if (filename)
       free (filename);
    }

  return table;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* find_abstract_instance_name ( struct comp_unit unit,
bfd_uint64_t  die_ref 
) [static]

Definition at line 1559 of file dwarf2.c.

{
  bfd *abfd = unit->abfd;
  bfd_byte *info_ptr;
  unsigned int abbrev_number, bytes_read, i;
  struct abbrev_info *abbrev;
  struct attribute attr;
  char *name = 0;

  info_ptr = unit->info_ptr_unit + die_ref;
  abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
  info_ptr += bytes_read;

  if (abbrev_number)
    {
      abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
      if (! abbrev)
       {
         (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
                             abbrev_number);
         bfd_set_error (bfd_error_bad_value);
       }
      else
       {
         for (i = 0; i < abbrev->num_attrs; ++i)
           {
             info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
             switch (attr.name)
              {
              case DW_AT_name:
                /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name.  */
                if (name == NULL)
                  name = attr.u.str;
                break;
              case DW_AT_specification:
                name = find_abstract_instance_name (unit, attr.u.val);
                break;
              case DW_AT_MIPS_linkage_name:
                name = attr.u.str;
                break;
              default:
                break;
              }
           }
       }
    }
  return (name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static asection* find_debug_info ( bfd abfd,
asection after_sec 
) [static]

Definition at line 2191 of file dwarf2.c.

{
  asection * msec;

  if (after_sec)
    msec = after_sec->next;
  else
    msec = abfd->sections;

  while (msec)
    {
      if (strcmp (msec->name, DWARF2_DEBUG_INFO) == 0)
       return msec;

      if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
       return msec;

      msec = msec->next;
    }

  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct abbrev_info* lookup_abbrev ( unsigned int  number,
struct abbrev_info **  abbrevs 
) [static, read]

Definition at line 397 of file dwarf2.c.

{
  unsigned int hash_number;
  struct abbrev_info *abbrev;

  hash_number = number % ABBREV_HASH_SIZE;
  abbrev = abbrevs[hash_number];

  while (abbrev)
    {
      if (abbrev->number == number)
       return abbrev;
      else
       abbrev = abbrev->next;
    }

  return NULL;
}

Here is the caller graph for this function:

static bfd_boolean lookup_address_in_function_table ( struct comp_unit unit,
bfd_vma  addr,
struct funcinfo **  function_ptr,
const char **  functionname_ptr 
) [static]

Definition at line 1437 of file dwarf2.c.

{
  struct funcinfo* each_func;
  struct funcinfo* best_fit = NULL;
  struct arange *arange;

  for (each_func = unit->function_table;
       each_func;
       each_func = each_func->prev_func)
    {
      for (arange = &each_func->arange;
          arange;
          arange = arange->next)
       {
         if (addr >= arange->low && addr < arange->high)
           {
             if (!best_fit ||
                ((arange->high - arange->low) < (best_fit->arange.high - best_fit->arange.low)))
              best_fit = each_func;
           }
       }
    }

  if (best_fit)
    {
      *functionname_ptr = best_fit->name;
      *function_ptr = best_fit;
      return TRUE;
    }
  else
    {
      return FALSE;
    }
}

Here is the caller graph for this function:

static bfd_boolean lookup_address_in_line_info_table ( struct line_info_table table,
bfd_vma  addr,
struct funcinfo function,
const char **  filename_ptr,
unsigned int linenumber_ptr 
) [static]

Definition at line 1306 of file dwarf2.c.

{
  /* Note: table->last_line should be a descendingly sorted list. */
  struct line_info* next_line = table->last_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 */
  if (addr > next_line->address)
    each_line = NULL; /* ensure we skip over the normal case */

  /* Normal case: search the list; save  */
  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 */
             lowest_pc = function->arange.low;
             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;
                *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 FALSE;
}

Here is the caller graph for this function:

static bfd_boolean lookup_symbol_in_function_table ( struct comp_unit unit,
asymbol sym,
bfd_vma  addr,
const char **  filename_ptr,
unsigned int linenumber_ptr 
) [static]

Definition at line 1479 of file dwarf2.c.

{
  struct funcinfo* each_func;
  struct funcinfo* best_fit = NULL;
  struct arange *arange;
  const char *name = bfd_asymbol_name (sym);
  asection *sec = bfd_get_section (sym);

  for (each_func = unit->function_table;
       each_func;
       each_func = each_func->prev_func)
    {
      for (arange = &each_func->arange;
          arange;
          arange = arange->next)
       {
         if ((!each_func->sec || each_func->sec == sec)
             && addr >= arange->low
             && addr < arange->high
             && each_func->name
             && strcmp (name, each_func->name) == 0
             && (!best_fit
                || ((arange->high - arange->low)
                    < (best_fit->arange.high - best_fit->arange.low))))
           best_fit = each_func;
       }
    }

  if (best_fit)
    {
      best_fit->sec = sec;
      *filename_ptr = best_fit->file;
      *linenumber_ptr = best_fit->line;
      return TRUE;
    }
  else
    return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean lookup_symbol_in_variable_table ( struct comp_unit unit,
asymbol sym,
bfd_vma  addr,
const char **  filename_ptr,
unsigned int linenumber_ptr 
) [static]

Definition at line 1528 of file dwarf2.c.

{
  const char *name = bfd_asymbol_name (sym);
  asection *sec = bfd_get_section (sym);
  struct varinfo* each;

  for (each = unit->variable_table; each; each = each->prev_var)
    if (each->stack == 0
       && each->file != NULL
       && each->name != NULL
       && each->addr == addr
       && (!each->sec || each->sec == sec)
       && strcmp (name, each->name) == 0)
      break;

  if (each)
    {
      each->sec = sec;
      *filename_ptr = each->file;
      *linenumber_ptr = each->line;
      return TRUE;
    }
  else
    return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean new_line_sorts_after ( struct line_info new_line,
struct line_info line 
) [inline, static]

Definition at line 762 of file dwarf2.c.

{
  return (new_line->address > line->address
         || (new_line->address == line->address
             && new_line->end_sequence < line->end_sequence));
}

Here is the caller graph for this function:

static struct comp_unit* parse_comp_unit ( bfd abfd,
struct dwarf2_debug stash,
bfd_vma  unit_length,
bfd_byte info_ptr_unit,
unsigned int  offset_size 
) [static, read]

Definition at line 1891 of file dwarf2.c.

{
  struct comp_unit* unit;
  unsigned int version;
  bfd_uint64_t abbrev_offset = 0;
  unsigned int addr_size;
  struct abbrev_info** abbrevs;
  unsigned int abbrev_number, bytes_read, i;
  struct abbrev_info *abbrev;
  struct attribute attr;
  bfd_byte *info_ptr = stash->info_ptr;
  bfd_byte *end_ptr = info_ptr + unit_length;
  bfd_size_type amt;
  bfd_vma low_pc = 0;
  bfd_vma high_pc = 0;

  version = read_2_bytes (abfd, info_ptr);
  info_ptr += 2;
  BFD_ASSERT (offset_size == 4 || offset_size == 8);
  if (offset_size == 4)
    abbrev_offset = read_4_bytes (abfd, info_ptr);
  else
    abbrev_offset = read_8_bytes (abfd, info_ptr);
  info_ptr += offset_size;
  addr_size = read_1_byte (abfd, info_ptr);
  info_ptr += 1;

  if (version != 2)
    {
      (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 information."), version);
      bfd_set_error (bfd_error_bad_value);
      return 0;
    }

  if (addr_size > sizeof (bfd_vma))
    {
      (*_bfd_error_handler) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
                      addr_size,
                      (unsigned int) sizeof (bfd_vma));
      bfd_set_error (bfd_error_bad_value);
      return 0;
    }

  if (addr_size != 2 && addr_size != 4 && addr_size != 8)
    {
      (*_bfd_error_handler) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size);
      bfd_set_error (bfd_error_bad_value);
      return 0;
    }

  /* Read the abbrevs for this compilation unit into a table.  */
  abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
  if (! abbrevs)
      return 0;

  abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
  info_ptr += bytes_read;
  if (! abbrev_number)
    {
      (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u."),
                      abbrev_number);
      bfd_set_error (bfd_error_bad_value);
      return 0;
    }

  abbrev = lookup_abbrev (abbrev_number, abbrevs);
  if (! abbrev)
    {
      (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
                      abbrev_number);
      bfd_set_error (bfd_error_bad_value);
      return 0;
    }

  amt = sizeof (struct comp_unit);
  unit = bfd_zalloc (abfd, amt);
  unit->abfd = abfd;
  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;

  for (i = 0; i < abbrev->num_attrs; ++i)
    {
      info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);

      /* Store the data if it is of an attribute we want to keep in a
        partial symbol table.  */
      switch (attr.name)
       {
       case DW_AT_stmt_list:
         unit->stmtlist = 1;
         unit->line_offset = attr.u.val;
         break;

       case DW_AT_name:
         unit->name = attr.u.str;
         break;

       case DW_AT_low_pc:
         low_pc = attr.u.val;
         /* If the compilation unit DIE has a DW_AT_low_pc attribute,
            this is the base address to use when reading location
            lists or range lists. */
         unit->base_address = low_pc;
         break;

       case DW_AT_high_pc:
         high_pc = attr.u.val;
         break;

       case DW_AT_ranges:
         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
                 directory, get rid of it.  */
              char *cp = strchr (comp_dir, ':');

              if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
                comp_dir = cp + 1;
             }
           unit->comp_dir = comp_dir;
           break;
         }

       default:
         break;
       }
    }
  if (high_pc != 0)
    {
      arange_add (unit->abfd, &unit->arange, low_pc, high_pc);
    }

  unit->first_child_die_ptr = info_ptr;
  return unit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean place_sections ( bfd abfd,
struct dwarf2_debug stash 
) [static]

Definition at line 2232 of file dwarf2.c.

{
  struct loadable_section *p;
  unsigned int i;

  if (stash->loadable_section_count != 0)
    {
      i = stash->loadable_section_count;
      p = stash->loadable_sections;
      for (; i > 0; i--, p++)
       p->section->vma = p->adj_vma;
    }
  else
    {
      asection *sect;
      bfd_vma last_vma = 0;
      bfd_size_type amt;
      struct loadable_section *p;

      i = 0;
      for (sect = abfd->sections; sect != NULL; sect = sect->next)
       {
         bfd_size_type sz;

         if (sect->vma != 0 || (sect->flags & SEC_LOAD) == 0)
           continue;

         sz = sect->rawsize ? sect->rawsize : sect->size;
         if (sz == 0)
           continue;

         i++;
       }

      amt = i * sizeof (struct loadable_section);
      p = (struct loadable_section *) bfd_zalloc (abfd, amt);
      if (! p)
       return FALSE;

      stash->loadable_sections = p;
      stash->loadable_section_count = i;

      for (sect = abfd->sections; sect != NULL; sect = sect->next)
       {
         bfd_size_type sz;

         if (sect->vma != 0 || (sect->flags & SEC_LOAD) == 0)
           continue;

         sz = sect->rawsize ? sect->rawsize : sect->size;
         if (sz == 0)
           continue;

         p->section = sect;
         if (last_vma != 0)
           {
             /* Align the new address to the current section
               alignment.  */
             last_vma = ((last_vma
                        + ~((bfd_vma) -1 << sect->alignment_power))
                       & ((bfd_vma) -1 << sect->alignment_power));
             sect->vma = last_vma;
           }
         p->adj_vma = sect->vma;
         last_vma += sect->vma + sz;

         p++;
       }
    }

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static unsigned int read_1_byte ( bfd *abfd  ATTRIBUTE_UNUSED,
bfd_byte buf 
) [static]

Definition at line 245 of file dwarf2.c.

{
  return bfd_get_8 (abfd, buf);
}

Here is the caller graph for this function:

static int read_1_signed_byte ( bfd *abfd  ATTRIBUTE_UNUSED,
bfd_byte buf 
) [static]

Definition at line 251 of file dwarf2.c.

{
  return bfd_get_signed_8 (abfd, buf);
}

Here is the caller graph for this function:

static unsigned int read_2_bytes ( bfd abfd,
bfd_byte buf 
) [static]

Definition at line 257 of file dwarf2.c.

{
  return bfd_get_16 (abfd, buf);
}

Here is the caller graph for this function:

static unsigned int read_4_bytes ( bfd abfd,
bfd_byte buf 
) [static]

Definition at line 263 of file dwarf2.c.

{
  return bfd_get_32 (abfd, buf);
}

Here is the caller graph for this function:

static bfd_uint64_t read_8_bytes ( bfd abfd,
bfd_byte buf 
) [static]

Definition at line 269 of file dwarf2.c.

{
  return bfd_get_64 (abfd, buf);
}

Here is the caller graph for this function:

static struct abbrev_info** read_abbrevs ( bfd abfd,
bfd_uint64_t  offset,
struct dwarf2_debug stash 
) [static, read]

Definition at line 422 of file dwarf2.c.

{
  struct abbrev_info **abbrevs;
  bfd_byte *abbrev_ptr;
  struct abbrev_info *cur_abbrev;
  unsigned int abbrev_number, bytes_read, abbrev_name;
  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;
    }

  amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
  abbrevs = bfd_zalloc (abfd, amt);

  abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
  abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
  abbrev_ptr += bytes_read;

  /* Loop until we reach an abbrev number of 0.  */
  while (abbrev_number)
    {
      amt = sizeof (struct abbrev_info);
      cur_abbrev = bfd_zalloc (abfd, amt);

      /* Read in abbrev header.  */
      cur_abbrev->number = abbrev_number;
      cur_abbrev->tag = (enum dwarf_tag)
       read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
      abbrev_ptr += bytes_read;
      cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
      abbrev_ptr += 1;

      /* Now read in declarations.  */
      abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
      abbrev_ptr += bytes_read;
      abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
      abbrev_ptr += bytes_read;

      while (abbrev_name)
       {
         if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
           {
             struct attr_abbrev *tmp;

             amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
             amt *= sizeof (struct attr_abbrev);
             tmp = bfd_realloc (cur_abbrev->attrs, amt);
             if (tmp == NULL)
              {
                size_t i;

                for (i = 0; i < ABBREV_HASH_SIZE; i++)
                  {
                    struct abbrev_info *abbrev = abbrevs[i];

                    while (abbrev)
                     {
                       free (abbrev->attrs);
                       abbrev = abbrev->next;
                     }
                  }
                return NULL;
              }
             cur_abbrev->attrs = tmp;
           }

         cur_abbrev->attrs[cur_abbrev->num_attrs].name
           = (enum dwarf_attribute) abbrev_name;
         cur_abbrev->attrs[cur_abbrev->num_attrs++].form
           = (enum dwarf_form) abbrev_form;
         abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
         abbrev_ptr += bytes_read;
         abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
         abbrev_ptr += bytes_read;
       }

      hash_number = abbrev_number % ABBREV_HASH_SIZE;
      cur_abbrev->next = abbrevs[hash_number];
      abbrevs[hash_number] = cur_abbrev;

      /* Get next abbreviation.
        Under Irix6 the abbreviations for a compilation unit are not
        always properly terminated with an abbrev number of 0.
        Exit loop if we encounter an abbreviation which we have
        already read (which means we are about to read the abbreviations
        for the next compile unit) or if the end of the abbreviation
        table is reached.  */
      if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
         >= stash->dwarf_abbrev_size)
       break;
      abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
      abbrev_ptr += bytes_read;
      if (lookup_abbrev (abbrev_number,abbrevs) != NULL)
       break;
    }

  return abbrevs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_uint64_t read_address ( struct comp_unit unit,
bfd_byte buf 
) [static]

Definition at line 360 of file dwarf2.c.

{
  int signed_vma = get_elf_backend_data (unit->abfd)->sign_extend_vma;

  if (signed_vma)
    {
      switch (unit->addr_size)
       {
       case 8:
         return bfd_get_signed_64 (unit->abfd, buf);
       case 4:
         return bfd_get_signed_32 (unit->abfd, buf);
       case 2:
         return bfd_get_signed_16 (unit->abfd, buf);
       default:
         abort ();
       }
    }
  else
    {
      switch (unit->addr_size)
       {
       case 8:
         return bfd_get_64 (unit->abfd, buf);
       case 4:
         return bfd_get_32 (unit->abfd, buf);
       case 2:
         return bfd_get_16 (unit->abfd, buf);
       default:
         abort ();
       }
    }
}

Here is the caller graph for this function:

static bfd_byte* read_attribute ( struct attribute attr,
struct attr_abbrev abbrev,
struct comp_unit unit,
bfd_byte info_ptr 
) [static]

Definition at line 678 of file dwarf2.c.

{
  attr->name = abbrev->name;
  info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr);
  return info_ptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_byte* read_attribute_value ( struct attribute attr,
unsigned  form,
struct comp_unit unit,
bfd_byte info_ptr 
) [static]

Definition at line 550 of file dwarf2.c.

{
  bfd *abfd = unit->abfd;
  unsigned int bytes_read;
  struct dwarf_block *blk;
  bfd_size_type amt;

  attr->form = (enum dwarf_form) form;

  switch (form)
    {
    case DW_FORM_addr:
      /* FIXME: DWARF3 draft says DW_FORM_ref_addr is offset_size.  */
    case DW_FORM_ref_addr:
      attr->u.val = read_address (unit, info_ptr);
      info_ptr += unit->addr_size;
      break;
    case DW_FORM_block2:
      amt = sizeof (struct dwarf_block);
      blk = bfd_alloc (abfd, amt);
      blk->size = read_2_bytes (abfd, info_ptr);
      info_ptr += 2;
      blk->data = read_n_bytes (abfd, info_ptr, blk->size);
      info_ptr += blk->size;
      attr->u.blk = blk;
      break;
    case DW_FORM_block4:
      amt = sizeof (struct dwarf_block);
      blk = bfd_alloc (abfd, amt);
      blk->size = read_4_bytes (abfd, info_ptr);
      info_ptr += 4;
      blk->data = read_n_bytes (abfd, info_ptr, blk->size);
      info_ptr += blk->size;
      attr->u.blk = blk;
      break;
    case DW_FORM_data2:
      attr->u.val = read_2_bytes (abfd, info_ptr);
      info_ptr += 2;
      break;
    case DW_FORM_data4:
      attr->u.val = read_4_bytes (abfd, info_ptr);
      info_ptr += 4;
      break;
    case DW_FORM_data8:
      attr->u.val = read_8_bytes (abfd, info_ptr);
      info_ptr += 8;
      break;
    case DW_FORM_string:
      attr->u.str = read_string (abfd, info_ptr, &bytes_read);
      info_ptr += bytes_read;
      break;
    case DW_FORM_strp:
      attr->u.str = read_indirect_string (unit, info_ptr, &bytes_read);
      info_ptr += bytes_read;
      break;
    case DW_FORM_block:
      amt = sizeof (struct dwarf_block);
      blk = bfd_alloc (abfd, amt);
      blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
      info_ptr += bytes_read;
      blk->data = read_n_bytes (abfd, info_ptr, blk->size);
      info_ptr += blk->size;
      attr->u.blk = blk;
      break;
    case DW_FORM_block1:
      amt = sizeof (struct dwarf_block);
      blk = bfd_alloc (abfd, amt);
      blk->size = read_1_byte (abfd, info_ptr);
      info_ptr += 1;
      blk->data = read_n_bytes (abfd, info_ptr, blk->size);
      info_ptr += blk->size;
      attr->u.blk = blk;
      break;
    case DW_FORM_data1:
      attr->u.val = read_1_byte (abfd, info_ptr);
      info_ptr += 1;
      break;
    case DW_FORM_flag:
      attr->u.val = read_1_byte (abfd, info_ptr);
      info_ptr += 1;
      break;
    case DW_FORM_sdata:
      attr->u.sval = read_signed_leb128 (abfd, info_ptr, &bytes_read);
      info_ptr += bytes_read;
      break;
    case DW_FORM_udata:
      attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
      info_ptr += bytes_read;
      break;
    case DW_FORM_ref1:
      attr->u.val = read_1_byte (abfd, info_ptr);
      info_ptr += 1;
      break;
    case DW_FORM_ref2:
      attr->u.val = read_2_bytes (abfd, info_ptr);
      info_ptr += 2;
      break;
    case DW_FORM_ref4:
      attr->u.val = read_4_bytes (abfd, info_ptr);
      info_ptr += 4;
      break;
    case DW_FORM_ref8:
      attr->u.val = read_8_bytes (abfd, info_ptr);
      info_ptr += 8;
      break;
    case DW_FORM_ref_udata:
      attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
      info_ptr += bytes_read;
      break;
    case DW_FORM_indirect:
      form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
      info_ptr += bytes_read;
      info_ptr = read_attribute_value (attr, form, unit, info_ptr);
      break;
    default:
      (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %u."),
                          form);
      bfd_set_error (bfd_error_bad_value);
    }
  return info_ptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean read_debug_ranges ( struct comp_unit unit) [static]

Definition at line 1403 of file dwarf2.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* read_indirect_string ( struct comp_unit unit,
bfd_byte buf,
unsigned int bytes_read_ptr 
) [static]

Definition at line 303 of file dwarf2.c.

{
  bfd_uint64_t offset;
  struct dwarf2_debug *stash = unit->stash;
  char *str;

  if (unit->offset_size == 4)
    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;
    }

  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;
    }

  str = (char *) stash->dwarf_str_buffer + offset;
  if (*str == '\0')
    return NULL;
  return str;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_byte* read_n_bytes ( bfd *abfd  ATTRIBUTE_UNUSED,
bfd_byte buf,
unsigned int size  ATTRIBUTE_UNUSED 
) [static]

Definition at line 275 of file dwarf2.c.

{
  /* 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;
}

Here is the caller graph for this function:

static void read_rangelist ( struct comp_unit unit,
struct arange arange,
bfd_uint64_t  offset 
) [static]

Definition at line 1609 of file dwarf2.c.

{
  bfd_byte *ranges_ptr;
  bfd_vma base_address = unit->base_address;

  if (! unit->stash->dwarf_ranges_buffer)
    {
      if (! read_debug_ranges (unit))
       return;
    }
  ranges_ptr = unit->stash->dwarf_ranges_buffer + offset;

  for (;;)
    {
      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;
       }
      if (low_pc == 0 && high_pc == 0)
       break;
      if (low_pc == -1UL && high_pc != -1UL)
       base_address = high_pc;
      else
       arange_add (unit->abfd, arange, base_address + low_pc, base_address + high_pc);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* read_string ( bfd *abfd  ATTRIBUTE_UNUSED,
bfd_byte buf,
unsigned int bytes_read_ptr 
) [static]

Definition at line 286 of file dwarf2.c.

{
  /* Return a pointer to the embedded string.  */
  char *str = (char *) buf;
  if (*str == '\0')
    {
      *bytes_read_ptr = 1;
      return NULL;
    }

  *bytes_read_ptr = strlen (str) + 1;
  return str;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean scan_unit_for_symbols ( struct comp_unit unit) [static]

Definition at line 1655 of file dwarf2.c.

{
  bfd *abfd = unit->abfd;
  bfd_byte *info_ptr = unit->first_child_die_ptr;
  int nesting_level = 1;
  struct funcinfo **nested_funcs;
  int nested_funcs_size;

  /* Maintain a stack of in-scope functions and inlined functions, which we
     can use to set the caller_func field.  */
  nested_funcs_size = 32;
  nested_funcs = bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *));
  if (nested_funcs == NULL)
    return FALSE;
  nested_funcs[nesting_level] = 0;

  while (nesting_level)
    {
      unsigned int abbrev_number, bytes_read, i;
      struct abbrev_info *abbrev;
      struct attribute attr;
      struct funcinfo *func;
      struct varinfo *var;
      bfd_vma low_pc = 0;
      bfd_vma high_pc = 0;

      abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
      info_ptr += bytes_read;

      if (! abbrev_number)
       {
         nesting_level--;
         continue;
       }

      abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
      if (! abbrev)
       {
         (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
                          abbrev_number);
         bfd_set_error (bfd_error_bad_value);
         free (nested_funcs);
         return FALSE;
       }

      var = NULL;
      if (abbrev->tag == DW_TAG_subprogram
         || abbrev->tag == DW_TAG_entry_point
         || abbrev->tag == DW_TAG_inlined_subroutine)
       {
         bfd_size_type amt = sizeof (struct funcinfo);
         func = bfd_zalloc (abfd, amt);
         func->tag = abbrev->tag;
         func->prev_func = unit->function_table;
         unit->function_table = func;

         if (func->tag == DW_TAG_inlined_subroutine)
           for (i = nesting_level - 1; i >= 1; i--)
             if (nested_funcs[i])
              {
                func->caller_func = nested_funcs[i];
                break;
              }
         nested_funcs[nesting_level] = func;
       }
      else
       {
         func = NULL;
         if (abbrev->tag == DW_TAG_variable)
           {
             bfd_size_type amt = sizeof (struct varinfo);
             var = bfd_zalloc (abfd, amt);
             var->tag = abbrev->tag;
             var->stack = 1;
             var->prev_var = unit->variable_table;
             unit->variable_table = var;
           }

         /* No inline function in scope at this nesting level.  */
         nested_funcs[nesting_level] = 0;
       }

      for (i = 0; i < abbrev->num_attrs; ++i)
       {
         info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);

         if (func)
           {
             switch (attr.name)
              {
              case DW_AT_call_file:
                func->caller_file = concat_filename (unit->line_table, attr.u.val);
                break;

              case DW_AT_call_line:
                func->caller_line = attr.u.val;
                break;

              case DW_AT_abstract_origin:
                func->name = find_abstract_instance_name (unit, attr.u.val);
                break;

              case DW_AT_name:
                /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name.  */
                if (func->name == NULL)
                  func->name = attr.u.str;
                break;

              case DW_AT_MIPS_linkage_name:
                func->name = attr.u.str;
                break;

              case DW_AT_low_pc:
                low_pc = attr.u.val;
                break;

              case DW_AT_high_pc:
                high_pc = attr.u.val;
                break;

              case DW_AT_ranges:
                read_rangelist (unit, &func->arange, attr.u.val);
                break;

              case DW_AT_decl_file:
                func->file = concat_filename (unit->line_table,
                                          attr.u.val);
                break;

              case DW_AT_decl_line:
                func->line = attr.u.val;
                break;

              default:
                break;
              }
           }
         else if (var)
           {
             switch (attr.name)
              {
              case DW_AT_name:
                var->name = attr.u.str;
                break;

              case DW_AT_decl_file:
                var->file = concat_filename (unit->line_table,
                                          attr.u.val);
                break;

              case DW_AT_decl_line:
                var->line = attr.u.val;
                break;

              case DW_AT_external:
                if (attr.u.val != 0)
                  var->stack = 0;
                break;

              case DW_AT_location:
                switch (attr.form)
                  {
                  case DW_FORM_block:
                  case DW_FORM_block1:
                  case DW_FORM_block2:
                  case DW_FORM_block4:
                    if (*attr.u.blk->data == DW_OP_addr)
                     {
                       var->stack = 0;

                       /* Verify that DW_OP_addr is the only opcode in the
                          location, in which case the block size will be 1
                          plus the address size.  */
                       /* ??? For TLS variables, gcc can emit
                          DW_OP_addr <addr> DW_OP_GNU_push_tls_address
                          which we don't handle here yet.  */
                       if (attr.u.blk->size == unit->addr_size + 1U)
                         var->addr = bfd_get (unit->addr_size * 8,
                                           unit->abfd,
                                           attr.u.blk->data + 1);
                     }
                    break;

                  default:
                    break;
                  }
                break;

              default:
                break;
              }
           }
       }

      if (func && high_pc != 0)
       {
         arange_add (unit->abfd, &func->arange, low_pc, high_pc);
       }

      if (abbrev->has_children)
       {
         nesting_level++;

         if (nesting_level >= nested_funcs_size)
           {
             struct funcinfo **tmp;

             nested_funcs_size *= 2;
             tmp = bfd_realloc (nested_funcs,
                             (nested_funcs_size
                              * sizeof (struct funcinfo *)));
             if (tmp == NULL)
              {
                free (nested_funcs);
                return FALSE;
              }
             nested_funcs = tmp;
           }
         nested_funcs[nesting_level] = 0;
       }
    }

  free (nested_funcs);
  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void unset_sections ( struct dwarf2_debug stash) [static]

Definition at line 2217 of file dwarf2.c.

{
  unsigned int i;
  struct loadable_section *p;

  i = stash->loadable_section_count;
  p = stash->loadable_sections;
  for (; i > 0; i--, p++)
    p->section->vma = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function: