Changeset 609 for branches/GNU/src/binutils/bfd/dwarf2.c

Timestamp:

Aug 16, 2003, 6:59:22 PM (22 years ago)

Author:

bird

Message:

binutils v2.14 - offical sources.

File:

• branches/GNU/src/binutils/bfd/dwarf2.c (modified) (75 diffs, 1 prop)

branches/GNU/src/binutils/bfd/dwarf2.c

@@ -1 +1 @@
 /* DWARF 2 support.
-   Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
+   Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
    Free Software Foundation, Inc.
 
@@ -14 +14 @@
    support in dwarfread.c
 
-This file is part of BFD.
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or (at
-your option) any later version.
-
-This program is distributed in the hope that it will be useful, but
-WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   This file is part of BFD.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or (at
+   your option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #include "bfd.h"
@@ -41 +41 @@
 struct line_head
 {
-  unsigned int total_length;
+  bfd_vma total_length;
   unsigned short version;
-  unsigned int prologue_length;
+  bfd_vma prologue_length;
   unsigned char minimum_instruction_length;
   unsigned char default_is_stmt;
@@ -97 +97 @@
   char* info_ptr_end;
 
+  /* Pointer to the section and address of the beginning of the
+     section.  */
+  asection* sec;
+  char* sec_info_ptr;
+
+  /* Pointer to the symbol table.  */
+  asymbol** syms;
+
   /* Pointer to the .debug_abbrev section loaded into memory.  */
   char* dwarf_abbrev_buffer;
@@ -108 +116 @@
   /* Length of the loaded .debug_line section.  */
   unsigned long dwarf_line_size;
+
+  /* Pointer to the .debug_str section loaded into memory.  */
+  char* dwarf_str_buffer;
+
+  /* Length of the loaded .debug_str section.  */
+  unsigned long dwarf_str_size;
 };
 
@@ -144 +158 @@
   char* comp_dir;
 
-  /* True if there is a line number table associated with this comp. unit.  */
+  /* TRUE if there is a line number table associated with this comp. unit.  */
   int stmtlist;
 
@@ -162 +176 @@
   struct funcinfo* function_table;
 
+  /* Pointer to dwarf2_debug structure.  */
+  struct dwarf2_debug *stash;
+
   /* Address size for this unit - from unit header.  */
   unsigned char addr_size;
+
+  /* Offset size for this unit - from unit header.  */
+  unsigned char offset_size;
 };
+
+/* This data structure holds the information of an abbrev.  */
+struct abbrev_info
+{
+  unsigned int number;          /* Number identifying abbrev.  */
+  enum dwarf_tag tag;           /* DWARF tag.  */
+  int has_children;             /* Boolean.  */
+  unsigned int num_attrs;       /* Number of attributes.  */
+  struct attr_abbrev *attrs;    /* An array of attribute descriptions.  */
+  struct abbrev_info *next;     /* Next in chain.  */
+};
+
+struct attr_abbrev
+{
+  enum dwarf_attribute name;
+  enum dwarf_form form;
+};
+
+#ifndef ABBREV_HASH_SIZE
+#define ABBREV_HASH_SIZE 121
+#endif
+#ifndef ATTR_ALLOC_CHUNK
+#define ATTR_ALLOC_CHUNK 4
+#endif
+
+static unsigned int read_1_byte PARAMS ((bfd *, char *));
+static int read_1_signed_byte PARAMS ((bfd *, char *));
+static unsigned int read_2_bytes PARAMS ((bfd *, char *));
+static unsigned int read_4_bytes PARAMS ((bfd *, char *));
+static bfd_vma read_8_bytes PARAMS ((bfd *, char *));
+static char *read_n_bytes PARAMS ((bfd *, char *, unsigned int));
+static char *read_string PARAMS ((bfd *, char *, unsigned int *));
+static char *read_indirect_string PARAMS ((struct comp_unit *, char *, unsigned int *));
+static unsigned int read_unsigned_leb128
+  PARAMS ((bfd *, char *, unsigned int *));
+static int read_signed_leb128
+  PARAMS ((bfd *, char *, unsigned int *));
+static bfd_vma read_address PARAMS ((struct comp_unit *, char *));
+static struct abbrev_info *lookup_abbrev
+  PARAMS ((unsigned int, struct abbrev_info **));
+static struct abbrev_info **read_abbrevs
+  PARAMS ((bfd *, bfd_vma, struct dwarf2_debug *));
+static char *read_attribute
+  PARAMS ((struct attribute *, struct attr_abbrev *,
+           struct comp_unit *, char *));
+static char *read_attribute_value
+  PARAMS ((struct attribute *, unsigned,
+           struct comp_unit *, char *));
+static void add_line_info
+  PARAMS ((struct line_info_table *, bfd_vma, char *,
+           unsigned int, unsigned int, int));
+static char *concat_filename PARAMS ((struct line_info_table *, unsigned int));
+static void arange_add PARAMS ((struct comp_unit *, bfd_vma, bfd_vma));
+static struct line_info_table *decode_line_info
+  PARAMS ((struct comp_unit *, struct dwarf2_debug *));
+static bfd_boolean lookup_address_in_line_info_table
+  PARAMS ((struct line_info_table *, bfd_vma, struct funcinfo *,
+           const char **, unsigned int *));
+static bfd_boolean lookup_address_in_function_table
+  PARAMS ((struct funcinfo *, bfd_vma, struct funcinfo **, const char **));
+static bfd_boolean scan_unit_for_functions PARAMS ((struct comp_unit *));
+static struct comp_unit *parse_comp_unit
+  PARAMS ((bfd *, struct dwarf2_debug *, bfd_vma, unsigned int));
+static bfd_boolean comp_unit_contains_address
+  PARAMS ((struct comp_unit *, bfd_vma));
+static bfd_boolean comp_unit_find_nearest_line
+  PARAMS ((struct comp_unit *, bfd_vma, const char **, const char **,
+           unsigned int *, struct dwarf2_debug *));
+static asection *find_debug_info PARAMS ((bfd *, asection *));
 
 /* VERBATIM
@@ -228 +317 @@
 #endif
 
-static unsigned int
+static bfd_vma
 read_8_bytes (abfd, buf)
      bfd *abfd;
@@ -254 +343 @@
      unsigned int *bytes_read_ptr;
 {
-  /* If the size of a host char is 8 bits, we can return a pointer
-     to the string, otherwise we have to copy the string to a buffer
-     allocated on the temporary obstack.  */
+  /* Return a pointer to the embedded string.  */
   if (*buf == '\0')
     {
@@ -264 +351 @@
 
   *bytes_read_ptr = strlen (buf) + 1;
+  return buf;
+}
+
+static char *
+read_indirect_string (unit, buf, bytes_read_ptr)
+     struct comp_unit* unit;
+     char *buf;
+     unsigned int *bytes_read_ptr;
+{
+  bfd_vma offset;
+  struct dwarf2_debug *stash = unit->stash;
+
+  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;
+
+      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;
+        }
+
+      stash->dwarf_str_size = msec->_raw_size;
+      stash->dwarf_str_buffer = (char*) bfd_alloc (abfd, msec->_raw_size);
+      if (! stash->dwarf_abbrev_buffer)
+        return NULL;
+
+      if (! bfd_get_section_contents (abfd, msec, stash->dwarf_str_buffer,
+                                      (bfd_vma) 0, msec->_raw_size))
+        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;
+    }
+
+  buf = stash->dwarf_str_buffer + offset;
+  if (*buf == '\0')
+    return NULL;
   return buf;
 }
@@ -350 +490 @@
 }
 
-/* This data structure holds the information of an abbrev.  */
-struct abbrev_info
-{
-  unsigned int number;          /* Number identifying abbrev.  */
-  enum dwarf_tag tag;           /* DWARF tag.  */
-  int has_children;             /* Boolean.  */
-  unsigned int num_attrs;       /* Number of attributes.  */
-  struct attr_abbrev *attrs;    /* An array of attribute descriptions.  */
-  struct abbrev_info *next;     /* Next in chain.  */
-};
-
-struct attr_abbrev
-{
-  enum dwarf_attribute name;
-  enum dwarf_form form;
-};
-
-#ifndef ABBREV_HASH_SIZE
-#define ABBREV_HASH_SIZE 121
-#endif
-#ifndef ATTR_ALLOC_CHUNK
-#define ATTR_ALLOC_CHUNK 4
-#endif
-
 /* Lookup an abbrev_info structure in the abbrev hash table.  */
 
@@ -406 +522 @@
 read_abbrevs (abfd, offset, stash)
      bfd * abfd;
-     unsigned int offset;
+     bfd_vma offset;
      struct dwarf2_debug *stash;
 {
@@ -414 +530 @@
   unsigned int abbrev_number, bytes_read, abbrev_name;
   unsigned int abbrev_form, hash_number;
+  bfd_size_type amt;
 
   if (! stash->dwarf_abbrev_buffer)
@@ -428 +545 @@
 
       stash->dwarf_abbrev_size = msec->_raw_size;
-      stash->dwarf_abbrev_buffer = (char*) bfd_alloc (abfd, stash->dwarf_abbrev_size);
+      stash->dwarf_abbrev_buffer
+        = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
+                                                     stash->syms);
       if (! stash->dwarf_abbrev_buffer)
           return 0;
-
-      if (! bfd_get_section_contents (abfd, msec,
-                                      stash->dwarf_abbrev_buffer, 0,
-                                      stash->dwarf_abbrev_size))
-        return 0;
     }
 
   if (offset >= stash->dwarf_abbrev_size)
     {
-      (*_bfd_error_handler) (_("Dwarf Error: Abbrev offset (%u) greater than or equal to abbrev size (%u)."),
-                             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;
     }
 
-  abbrevs = (struct abbrev_info**) bfd_zalloc (abfd, sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE);
+  amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
+  abbrevs = (struct abbrev_info**) bfd_zalloc (abfd, amt);
 
   abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
@@ -455 +570 @@
   while (abbrev_number)
     {
-      cur_abbrev = (struct abbrev_info*)bfd_zalloc (abfd, sizeof (struct abbrev_info));
+      amt = sizeof (struct abbrev_info);
+      cur_abbrev = (struct abbrev_info *) bfd_zalloc (abfd, amt);
 
       /* Read in abbrev header.  */
       cur_abbrev->number = abbrev_number;
-      cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
+      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);
@@ -474 +591 @@
           if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
             {
-              cur_abbrev->attrs = (struct attr_abbrev *)
-                bfd_realloc (cur_abbrev->attrs,
-                             (cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK)
-                             * sizeof (struct attr_abbrev));
+              amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
+              amt *= sizeof (struct attr_abbrev);
+              cur_abbrev->attrs = ((struct attr_abbrev *)
+                                   bfd_realloc (cur_abbrev->attrs, amt));
               if (! cur_abbrev->attrs)
                 return 0;
             }
 
-          cur_abbrev->attrs[cur_abbrev->num_attrs].name = abbrev_name;
-          cur_abbrev->attrs[cur_abbrev->num_attrs++].form = abbrev_form;
+          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;
@@ -495 +614 @@
 
       /* Get next abbreviation.
-         Under Irix6 the abbreviations for a compilation unit are not
+         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
@@ -513 +632 @@
 }
 
-/* Read an attribute described by an abbreviated attribute.  */
+/* Read an attribute value described by an attribute form.  */
 
 static char *
-read_attribute (attr, abbrev, unit, info_ptr)
+read_attribute_value (attr, form, unit, info_ptr)
      struct attribute   *attr;
-     struct attr_abbrev *abbrev;
+     unsigned form;
      struct comp_unit   *unit;
      char               *info_ptr;
@@ -525 +644 @@
   unsigned int bytes_read;
   struct dwarf_block *blk;
-
-  attr->name = abbrev->name;
-  attr->form = abbrev->form;
-
-  switch (abbrev->form)
+  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:
       DW_ADDR (attr) = read_address (unit, info_ptr);
@@ -537 +657 @@
       break;
     case DW_FORM_block2:
-      blk = (struct dwarf_block *) bfd_alloc (abfd, sizeof (struct dwarf_block));
+      amt = sizeof (struct dwarf_block);
+      blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
       blk->size = read_2_bytes (abfd, info_ptr);
       info_ptr += 2;
@@ -545 +666 @@
       break;
     case DW_FORM_block4:
-      blk = (struct dwarf_block *) bfd_alloc (abfd, sizeof (struct dwarf_block));
+      amt = sizeof (struct dwarf_block);
+      blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
       blk->size = read_4_bytes (abfd, info_ptr);
       info_ptr += 4;
@@ -568 +690 @@
       info_ptr += bytes_read;
       break;
+    case DW_FORM_strp:
+      DW_STRING (attr) = read_indirect_string (unit, info_ptr, &bytes_read);
+      info_ptr += bytes_read;
+      break;
     case DW_FORM_block:
-      blk = (struct dwarf_block *) bfd_alloc (abfd, sizeof (struct dwarf_block));
+      amt = sizeof (struct dwarf_block);
+      blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
       blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
       info_ptr += bytes_read;
@@ -577 +704 @@
       break;
     case DW_FORM_block1:
-      blk = (struct dwarf_block *) bfd_alloc (abfd, sizeof (struct dwarf_block));
+      amt = sizeof (struct dwarf_block);
+      blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
       blk->size = read_1_byte (abfd, info_ptr);
       info_ptr += 1;
@@ -620 +748 @@
       info_ptr += bytes_read;
       break;
-    case DW_FORM_strp:
     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: %d."),
-                             abbrev->form);
+      (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %u."),
+                             form);
       bfd_set_error (bfd_error_bad_value);
     }
+  return info_ptr;
+}
+
+/* Read an attribute described by an abbreviated attribute.  */
+
+static char *
+read_attribute (attr, abbrev, unit, info_ptr)
+     struct attribute   *attr;
+     struct attr_abbrev *abbrev;
+     struct comp_unit   *unit;
+     char               *info_ptr;
+{
+  attr->name = abbrev->name;
+  info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr);
   return info_ptr;
 }
@@ -661 +806 @@
   char** dirs;
   struct fileinfo* files;
-  struct line_info* last_line;
+  struct line_info* last_line;  /* largest VMA */
+  struct line_info* lcl_head;   /* local head; used in 'add_line_info' */
 };
+
+struct funcinfo
+{
+  struct funcinfo *prev_func;
+  char* name;
+  bfd_vma low;
+  bfd_vma high;
+};
+
+/* Adds a new entry to the line_info list in the line_info_table, ensuring
+   that the list is sorted.  Note that the line_info list is sorted from
+   highest to lowest VMA (with possible duplicates); that is,
+   line_info->prev_line always accesses an equal or smaller VMA.  */
 
 static void
@@ -673 +832 @@
      int end_sequence;
 {
-  struct line_info* info = (struct line_info*)
-    bfd_alloc (table->abfd, sizeof (struct line_info));
-
-  info->prev_line = table->last_line;
-  table->last_line = info;
-
+  bfd_size_type amt = sizeof (struct line_info);
+  struct line_info* info = (struct line_info*) bfd_alloc (table->abfd, amt);
+
+  /* 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'.  */
+
+  while (1)
+    if (!table->last_line
+        || address >= table->last_line->address)
+      {
+        /* 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;
+        break;
+      }
+    else if (!table->lcl_head->prev_line
+             && table->lcl_head->address > address)
+      {
+        /* Abnormal but easy: lcl_head is 1) at the *end* of the line
+           list and 2) the head of 'info'.  */
+        info->prev_line = NULL;
+        table->lcl_head->prev_line = info;
+        break;
+      }
+    else if (table->lcl_head->prev_line
+             && table->lcl_head->address > address
+             && address >= table->lcl_head->prev_line->address)
+      {
+        /* Abnormal but easy: lcl_head is 1) in the *middle* of the line
+           list and 2) the head of 'info'.  */
+        info->prev_line = table->lcl_head->prev_line;
+        table->lcl_head->prev_line = info;
+        break;
+      }
+    else
+      {
+        /* Abnormal and hard: Neither 'last_line' nor 'lcl_head' are valid
+           heads for 'info'.  Reset 'lcl_head' and repeat.  */
+        struct line_info* li2 = table->last_line; /* always non-NULL */
+        struct line_info* li1 = li2->prev_line;
+
+        while (li1)
+          {
+            if (li2->address > address && address >= li1->address)
+              break;
+
+            li2 = li1; /* always non-NULL */
+            li1 = li1->prev_line;
+          }
+        table->lcl_head = li2;
+      }
+
+  /* Set member data of 'info'.  */
   info->address = address;
-  info->filename = filename;
   info->line = line;
   info->column = column;
   info->end_sequence = end_sequence;
-}
+
+  amt = strlen (filename);
+  if (amt)
+    {
+      info->filename = bfd_alloc (table->abfd, amt + 1);
+      if (info->filename)
+        strcpy (info->filename, filename);
+    }
+  else
+    info->filename = NULL;
+}
+
+/* Extract a fully qualified filename from a line info table.
+   The returned string has been malloc'ed and it is the caller's
+   responsibility to free it.  */
 
 static char *
@@ -697 +932 @@
       (*_bfd_error_handler)
         (_("Dwarf Error: mangled line number section (bad file number)."));
-      return "<unknown>";
+      return strdup ("<unknown>");
     }
 
   filename = table->files[file - 1].name;
-  if (IS_ABSOLUTE_PATH(filename))
-    return filename;
-
-  else
+
+  if (! IS_ABSOLUTE_PATH (filename))
     {
       char* dirname = (table->files[file - 1].dir
                        ? table->dirs[table->files[file - 1].dir - 1]
                        : table->comp_dir);
-      return (char*) concat (dirname, "/", filename, NULL);
-    }
+
+      /* Not all tools set DW_AT_comp_dir, so dirname may be unknown.
+         The best we can do is return the filename part.  */
+      if (dirname != NULL)
+        {
+          unsigned int len = strlen (dirname) + strlen (filename) + 2;
+          char * name;
+
+          name = bfd_malloc (len);
+          if (name)
+            sprintf (name, "%s/%s", dirname, filename);
+          return name;
+        }
+    }
+
+  return strdup (filename);
 }
 
@@ -750 +997 @@
 
   /* Need to allocate a new arange and insert it into the arange list.  */
-  arange = bfd_zalloc (unit->abfd, sizeof (*arange));
+  arange = (struct arange *)
+    bfd_zalloc (unit->abfd, (bfd_size_type) sizeof (*arange));
   arange->low = low_pc;
   arange->high = high_pc;
@@ -770 +1018 @@
   char *line_end;
   struct line_head lh;
-  unsigned int i, bytes_read;
+  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)
@@ -787 +1036 @@
 
       stash->dwarf_line_size = msec->_raw_size;
-      stash->dwarf_line_buffer = (char *) bfd_alloc (abfd, stash->dwarf_line_size);
+      stash->dwarf_line_buffer
+        = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
+                                                     stash->syms);
       if (! stash->dwarf_line_buffer)
         return 0;
-
-      if (! bfd_get_section_contents (abfd, msec,
-                                      stash->dwarf_line_buffer, 0,
-                                      stash->dwarf_line_size))
-        return 0;
-
-      /* FIXME: We ought to apply the relocs against this section before
-         we process it...  */
-    }
-
-  /* Since we are using un-relocated data, it is possible to get a bad value
-     for the line_offset.  Validate it here so that we won't get a segfault
-     below.  */
+    }
+
+  /* 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 (%u) greater than or equal to line size (%u)."),
+      (*_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);
@@ -811 +1053 @@
     }
 
-  table = (struct line_info_table*) bfd_alloc (abfd,
-                                               sizeof (struct line_info_table));
+  amt = sizeof (struct line_info_table);
+  table = (struct line_info_table*) bfd_alloc (abfd, amt);
   table->abfd = abfd;
   table->comp_dir = unit->comp_dir;
@@ -824 +1066 @@
   table->files = NULL;
   table->last_line = NULL;
+  table->lcl_head = NULL;
 
   line_ptr = stash->dwarf_line_buffer + unit->line_offset;
@@ -830 +1073 @@
   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;
-  lh.prologue_length = read_4_bytes (abfd, line_ptr);
-  line_ptr += 4;
+  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;
@@ -845 +1105 @@
   lh.opcode_base = read_1_byte (abfd, line_ptr);
   line_ptr += 1;
-  lh.standard_opcode_lengths = (unsigned char *)
-    bfd_alloc (abfd, lh.opcode_base * sizeof (unsigned char));
+  amt = lh.opcode_base * sizeof (unsigned char);
+  lh.standard_opcode_lengths = (unsigned char *) bfd_alloc (abfd, amt);
 
   lh.standard_opcode_lengths[0] = 1;
@@ -863 +1123 @@
       if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
         {
-          table->dirs = (char **)
-            bfd_realloc (table->dirs,
-                         (table->num_dirs + DIR_ALLOC_CHUNK) * sizeof (char *));
+          amt = table->num_dirs + DIR_ALLOC_CHUNK;
+          amt *= sizeof (char *);
+          table->dirs = (char **) bfd_realloc (table->dirs, amt);
           if (! table->dirs)
             return 0;
@@ -882 +1142 @@
       if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
         {
-          table->files = (struct fileinfo *)
-            bfd_realloc (table->files,
-                         (table->num_files + FILE_ALLOC_CHUNK)
-                         * sizeof (struct fileinfo));
+          amt = table->num_files + FILE_ALLOC_CHUNK;
+          amt *= sizeof (struct fileinfo);
+          table->files = (struct fileinfo *) bfd_realloc (table->files, amt);
           if (! table->files)
             return 0;
@@ -910 +1169 @@
       /* State machine registers.  */
       bfd_vma address = 0;
-      char* filename = concat_filename (table, 1);
+      char * filename = concat_filename (table, 1);
       unsigned int line = 1;
       unsigned int column = 0;
       int is_stmt = lh.default_is_stmt;
       int basic_block = 0;
-      int end_sequence = 0, need_low_pc = 1;
-      bfd_vma low_pc = 0;
+      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  = 0;
+      bfd_vma high_pc = 0;
 
       /* Decode the table.  */
@@ -924 +1189 @@
           line_ptr += 1;
 
-          switch (op_code)
+          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);
+              basic_block = 1;
+              if (low_pc == 0 || address < low_pc)
+                low_pc = address;
+              if (address > high_pc)
+                high_pc = address;
+            }
+          else switch (op_code)
             {
             case DW_LNS_extended_op:
-              line_ptr += 1;    /* Ignore length.  */
+              /* Ignore length.  */
+              line_ptr += 1;
               extended_op = read_1_byte (abfd, line_ptr);
               line_ptr += 1;
+
               switch (extended_op)
                 {
@@ -936 +1218 @@
                   add_line_info (table, address, filename, line, column,
                                  end_sequence);
-                  if (need_low_pc)
-                    {
-                      need_low_pc = 0;
-                      low_pc = address;
-                    }
-                  arange_add (unit, low_pc, address);
+                  if (low_pc == 0 || address < low_pc)
+                    low_pc = address;
+                  if (address > high_pc)
+                    high_pc = address;
+                  arange_add (unit, low_pc, high_pc);
                   break;
                 case DW_LNE_set_address:
@@ -952 +1233 @@
                   if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
                     {
-                      table->files = (struct fileinfo *)
-                        bfd_realloc (table->files,
-                                     (table->num_files + FILE_ALLOC_CHUNK)
-                                     * sizeof (struct fileinfo));
+                      amt = table->num_files + FILE_ALLOC_CHUNK;
+                      amt *= sizeof (struct fileinfo);
+                      table->files =
+                        (struct fileinfo *) bfd_realloc (table->files, amt);
                       if (! table->files)
                         return 0;
@@ -980 +1261 @@
               add_line_info (table, address, filename, line, column, 0);
               basic_block = 0;
-              if (need_low_pc)
-                {
-                  need_low_pc = 0;
-                  low_pc = address;
-                }
+              if (low_pc == 0 || address < low_pc)
+                low_pc = address;
+              if (address > high_pc)
+                high_pc = address;
               break;
             case DW_LNS_advance_pc:
@@ -999 +1279 @@
                 unsigned int file;
 
-                /* The file and directory tables are 0 based, the references
-                   are 1 based.  */
+                /* 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;
@@ -1024 +1306 @@
               line_ptr += 2;
               break;
-            default:            /* 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);
-              basic_block = 1;
-              if (need_low_pc)
-                {
-                  need_low_pc = 0;
-                  low_pc = address;
-                }
+            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);
     }
 
@@ -1044 +1327 @@
 }
 
-/* If ADDR is within TABLE set the output parameters and return true,
-   otherwise return false.  The output parameters, FILENAME_PTR and
+/* If ADDR is within TABLE set the output parameters and return TRUE,
+   otherwise return FALSE.  The output parameters, FILENAME_PTR and
    LINENUMBER_PTR, are pointers to the objects to be filled in.  */
 
-static boolean
-lookup_address_in_line_info_table (table,
-                                   addr,
-                                   filename_ptr,
+static bfd_boolean
+lookup_address_in_line_info_table (table, addr, function, filename_ptr,
                                    linenumber_ptr)
      struct line_info_table* table;
      bfd_vma addr;
+     struct funcinfo *function;
      const char **filename_ptr;
      unsigned int *linenumber_ptr;
 {
+  /* 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;
+    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 (!each_line->end_sequence
-          && addr >= each_line->address && addr < next_line->address)
-        {
-          *filename_ptr = each_line->filename;
-          *linenumber_ptr = each_line->line;
-          return true;
-        }
+      /* 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
+              && each_line->address < function->low
+              && next_line->address > function->low)
+            {
+              *filename_ptr = next_line->filename;
+              *linenumber_ptr = next_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;
     }
 
-  return false;
+  /* 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;
 }
 
 /* Function table functions.  */
 
-struct funcinfo
-{
-  struct funcinfo *prev_func;
-  char* name;
-  bfd_vma low;
-  bfd_vma high;
-};
-
-/* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return true.  */
-
-static boolean
-lookup_address_in_function_table (table,
-                                  addr,
+/* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return TRUE.  */
+
+static bfd_boolean
+lookup_address_in_function_table (table, addr, function_ptr,
                                   functionname_ptr)
      struct funcinfo* table;
      bfd_vma addr;
+     struct funcinfo** function_ptr;
      const char **functionname_ptr;
 {
@@ -1111 +1427 @@
         {
           *functionname_ptr = each_func->name;
-          return true;
-        }
-    }
-
-  return false;
+          *function_ptr = each_func;
+          return TRUE;
+        }
+    }
+
+  return FALSE;
 }
 
@@ -1123 +1440 @@
    to the function table.  */
 
-static boolean
+static bfd_boolean
 scan_unit_for_functions (unit)
      struct comp_unit *unit;
@@ -1151 +1468 @@
       if (! abbrev)
         {
-          (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %d."),
+          (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
                              abbrev_number);
           bfd_set_error (bfd_error_bad_value);
-          return false;
+          return FALSE;
         }
 
       if (abbrev->tag == DW_TAG_subprogram)
         {
-          func = (struct funcinfo*) bfd_zalloc (abfd, sizeof (struct funcinfo));
+          bfd_size_type amt = sizeof (struct funcinfo);
+          func = (struct funcinfo *) bfd_zalloc (abfd, amt);
           func->prev_func = unit->function_table;
           unit->function_table = func;
@@ -1217 +1535 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -1224 +1542 @@
    does not include the length field that preceeds each compilation
    unit header.  END_PTR points one past the end of this comp unit.
-   If ABBREV_LENGTH is 0, then the length of the abbreviation offset
-   is assumed to be four bytes.  Otherwise, it it is the size given.
+   OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
 
    This routine does not read the whole compilation unit; only enough
@@ -1231 +1548 @@
 
 static struct comp_unit *
-parse_comp_unit (abfd, stash, unit_length, abbrev_length)
+parse_comp_unit (abfd, stash, unit_length, offset_size)
      bfd* abfd;
      struct dwarf2_debug *stash;
      bfd_vma unit_length;
-     unsigned int abbrev_length;
+     unsigned int offset_size;
 {
   struct comp_unit* unit;
-
-  unsigned short version;
-  unsigned int abbrev_offset = 0;
-  unsigned char addr_size;
+  unsigned int version;
+  bfd_vma 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;
-
   char *info_ptr = stash->info_ptr;
   char *end_ptr = info_ptr + unit_length;
+  bfd_size_type amt;
 
   version = read_2_bytes (abfd, info_ptr);
   info_ptr += 2;
-  BFD_ASSERT (abbrev_length == 0
-              || abbrev_length == 4
-              || abbrev_length == 8);
-  if (abbrev_length == 0 || abbrev_length == 4)
+  BFD_ASSERT (offset_size == 4 || offset_size == 8);
+  if (offset_size == 4)
     abbrev_offset = read_4_bytes (abfd, info_ptr);
-  else if (abbrev_length == 8)
+  else
     abbrev_offset = read_8_bytes (abfd, info_ptr);
-  info_ptr += abbrev_length;
+  info_ptr += offset_size;
   addr_size = read_1_byte (abfd, info_ptr);
   info_ptr += 1;
@@ -1266 +1579 @@
   if (version != 2)
     {
-      (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%hu', this reader only handles version 2 information."), version );
+      (*_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;
@@ -1275 +1588 @@
       (*_bfd_error_handler) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
                          addr_size,
-                         sizeof (bfd_vma));
+                         (unsigned int) sizeof (bfd_vma));
       bfd_set_error (bfd_error_bad_value);
       return 0;
@@ -1282 +1595 @@
   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_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;
@@ -1296 +1609 @@
   if (! abbrev_number)
     {
-      (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %d."),
+      (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u."),
                          abbrev_number);
       bfd_set_error (bfd_error_bad_value);
@@ -1305 +1618 @@
   if (! abbrev)
     {
-      (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %d."),
+      (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
                          abbrev_number);
       bfd_set_error (bfd_error_bad_value);
@@ -1311 +1624 @@
     }
 
-  unit = (struct comp_unit*) bfd_zalloc (abfd, sizeof (struct comp_unit));
+  amt = sizeof (struct comp_unit);
+  unit = (struct comp_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;
 
   for (i = 0; i < abbrev->num_attrs; ++i)
@@ -1367 +1683 @@
 }
 
-/* Return true if UNIT contains the address given by ADDR.  */
-
-static boolean
+/* Return TRUE if UNIT contains the address given by ADDR.  */
+
+static bfd_boolean
 comp_unit_contains_address (unit, addr)
      struct comp_unit* unit;
@@ -1377 +1693 @@
 
   if (unit->error)
-    return 0;
+    return FALSE;
 
   arange = &unit->arange;
@@ -1383 +1699 @@
     {
       if (addr >= arange->low && addr < arange->high)
-        return 1;
+        return TRUE;
       arange = arange->next;
     }
   while (arange);
 
-  return 0;
+  return FALSE;
 }
 
@@ -1396 +1712 @@
    to be filled in.
 
-   Return true of UNIT contains ADDR, and no errors were encountered;
-   false otherwise.  */
-
-static boolean
-comp_unit_find_nearest_line (unit, addr,
-                             filename_ptr, functionname_ptr, linenumber_ptr,
-                             stash)
+   Return TRUE if UNIT contains ADDR, and no errors were encountered;
+   FALSE otherwise.  */
+
+static bfd_boolean
+comp_unit_find_nearest_line (unit, addr, filename_ptr, functionname_ptr,
+                             linenumber_ptr, stash)
      struct comp_unit* unit;
      bfd_vma addr;
@@ -1410 +1725 @@
      struct dwarf2_debug *stash;
 {
-  boolean line_p;
-  boolean func_p;
+  bfd_boolean line_p;
+  bfd_boolean func_p;
+  struct funcinfo *function;
 
   if (unit->error)
-    return false;
+    return FALSE;
 
   if (! unit->line_table)
@@ -1421 +1737 @@
         {
           unit->error = 1;
-          return false;
+          return FALSE;
         }
 
@@ -1429 +1745 @@
         {
           unit->error = 1;
-          return false;
-        }
-
-      if (! scan_unit_for_functions (unit))
+          return FALSE;
+        }
+
+      if (unit->first_child_die_ptr < unit->end_ptr
+          && ! scan_unit_for_functions (unit))
         {
           unit->error = 1;
-          return false;
-        }
-    }
-
-  line_p = lookup_address_in_line_info_table (unit->line_table,
-                                              addr,
-                                              filename_ptr,
+          return FALSE;
+        }
+    }
+
+  function = NULL;
+  func_p = lookup_address_in_function_table (unit->function_table, addr,
+                                             &function, functionname_ptr);
+  line_p = lookup_address_in_line_info_table (unit->line_table, addr,
+                                              function, filename_ptr,
                                               linenumber_ptr);
-  func_p = lookup_address_in_function_table (unit->function_table,
-                                             addr,
-                                             functionname_ptr);
   return line_p || func_p;
 }
 
-/* Locate a section in a BFD containing debugging info.  The search starts from the
-   section after AFTER_SEC, or from the first section in the BFD if AFTER_SEC is
-   NULL.  The search works by examining the names of the sections.  There are two
-   permissiable names.  The first is .debug_info.  This is the standard DWARF2 name.
-   The second is a prefix .gnu.linkonce.wi.  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 identify and discard duplicate debugging sections for
-   different compilation units.  */
+/* Locate a section in a BFD containing debugging info.  The search starts
+   from the section after AFTER_SEC, or from the first section in the BFD if
+   AFTER_SEC is NULL.  The search works by examining the names of the
+   sections.  There are two permissiable names.  The first is .debug_info.
+   This is the standard DWARF2 name.  The second is a prefix .gnu.linkonce.wi.
+   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
+   identify and discard duplicate debugging sections for different
+   compilation units.  */
 #define DWARF2_DEBUG_INFO ".debug_info"
 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
@@ -1486 +1803 @@
 }
 
-/* The DWARF2 version of find_nearest line.  Return true if the line
+/* The DWARF2 version of find_nearest line.  Return TRUE if the line
    is found without error.  ADDR_SIZE is the number of bytes in the
    initial .debug_info length field and in the abbreviation offset.
@@ -1492 +1809 @@
    used.  */
 
-boolean
+bfd_boolean
 _bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
                                filename_ptr, functionname_ptr,
-                               linenumber_ptr,
-                               addr_size, pinfo)
+                               linenumber_ptr, addr_size, pinfo)
      bfd *abfd;
      asection *section;
-     asymbol **symbols ATTRIBUTE_UNUSED;
+     asymbol **symbols;
      bfd_vma offset;
      const char **filename_ptr;
@@ -1535 +1851 @@
   if (! stash)
     {
-      unsigned long total_size;
+      bfd_size_type total_size;
       asection *msec;
-
-      stash =
-        (struct dwarf2_debug*) bfd_zalloc (abfd, sizeof (struct dwarf2_debug));
+      bfd_size_type amt = sizeof (struct dwarf2_debug);
+
+      stash = (struct dwarf2_debug*) bfd_zalloc (abfd, amt);
       if (! stash)
-        return false;
+        return FALSE;
 
       *pinfo = (PTR) stash;
@@ -1550 +1866 @@
            has been allocated, but contains zeros, this lets
            future calls to this function fail quicker.  */
-         return false;
+         return FALSE;
 
       /* 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
+         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
@@ -1562 +1878 @@
       stash->info_ptr = (char *) bfd_alloc (abfd, total_size);
       if (stash->info_ptr == NULL)
-        return false;
+        return FALSE;
 
       stash->info_ptr_end = stash->info_ptr;
@@ -1570 +1886 @@
            msec = find_debug_info (abfd, msec))
         {
-          unsigned long size;
-          unsigned long start;
+          bfd_size_type size;
+          bfd_size_type start;
 
           size = msec->_raw_size;
@@ -1579 +1895 @@
           start = stash->info_ptr_end - stash->info_ptr;
 
-          if (! bfd_get_section_contents (abfd, msec, stash->info_ptr + start, 0, size))
+          if ((bfd_simple_get_relocated_section_contents
+               (abfd, msec, stash->info_ptr + start, symbols)) == NULL)
             continue;
 
@@ -1585 +1902 @@
         }
 
-      BFD_ASSERT (stash->info_ptr_end = stash->info_ptr + total_size);
-    }
-
-  /* FIXME: There is a problem with the contents of the
-     .debug_info section.  The 'low' and 'high' addresses of the
-     comp_units are computed by relocs against symbols in the
-     .text segment.  We need these addresses in order to determine
-     the nearest line number, and so we have to resolve the
-     relocs.  There is a similar problem when the .debug_line
-     section is processed as well (e.g., there may be relocs
-     against the operand of the DW_LNE_set_address operator).
-
-     Unfortunately getting hold of the reloc information is hard...
-
-     For now, this means that disassembling object files (as
-     opposed to fully executables) does not always work as well as
-     we would like.  */
+      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)
-    return false;
+    return FALSE;
 
   /* Check the previously read comp. units first.  */
@@ -1618 +1924 @@
   while (stash->info_ptr < stash->info_ptr_end)
     {
-      struct comp_unit* each;
       bfd_vma length;
-      boolean found;
-
-      if (addr_size == 4)
-        length = read_4_bytes (abfd, stash->info_ptr);
+      bfd_boolean found;
+      unsigned int offset_size = addr_size;
+
+      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 addr_size-sized
+         offsets, for backward-compatibility with pre-DWARF3 64-bit
+         platforms.  */
+      else if (addr_size == 8)
+        {
+          length = read_8_bytes (abfd, stash->info_ptr);
+          stash->info_ptr += 8;
+        }
       else
-        length = read_8_bytes (abfd, stash->info_ptr);
-      stash->info_ptr += addr_size;
+        stash->info_ptr += 4;
 
       if (length > 0)
-        {
-          each = parse_comp_unit (abfd, stash, length, addr_size);
+        {
+          each = parse_comp_unit (abfd, stash, length, offset_size);
           stash->info_ptr += length;
+
+          if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
+              == stash->sec->_raw_size)
+            {
+              stash->sec = find_debug_info (abfd, stash->sec);
+              stash->sec_info_ptr = stash->info_ptr;
+            }
 
           if (each)
@@ -1647 +1983 @@
                   if (comp_unit_contains_address (each, addr))
                     return comp_unit_find_nearest_line (each, addr,
-                                                       filename_ptr,
-                                                       functionname_ptr,
-                                                       linenumber_ptr,
-                                                       stash);
+                                                        filename_ptr,
+                                                        functionname_ptr,
+                                                        linenumber_ptr,
+                                                        stash);
                 }
               else
@@ -1660 +1996 @@
                                                        stash);
                   if (found)
-                    return true;
+                    return TRUE;
                 }
             }
@@ -1666 +2002 @@
     }
 
-  return false;
-}
+  return FALSE;
+}