OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [bfd/] [dwarf2.c] - Diff between revs 157 and 225

Go to most recent revision | Show entire file | Details | Blame | View Log

Rev 157 Rev 225
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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.