Merge GDB 7.5.1

bfd/dwarf2.c

 /* DWARF 2 support.
    Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
    2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
 
    Adapted from gdb/dwarf2read.c by Gavin Koch of Cygnus Solutions
    (gavin@cygnus.com).
 
    From the dwarf2read.c header:
    Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
    Inc.  with support from Florida State University (under contract
@@ skipping 387 matching lines @@
 
 /* Function to create a new info hash table.  It returns a pointer to the
    newly created table or NULL if there is any error.  We need abfd
    solely for memory allocation.  */
 
 static struct info_hash_table *
 create_info_hash_table (bfd *abfd)
 {
   struct info_hash_table *hash_table;
 
-  hash_table = (struct info_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)
     return hash_table;
 
   if (!bfd_hash_table_init (&hash_table->base, info_hash_table_newfunc,
                             sizeof (struct info_hash_entry)))
     {
       bfd_release (abfd, hash_table);
       return NULL;
     }
 
@@ skipping 76 matching lines @@
           (*_bfd_error_handler) (_("Dwarf Error: Can't find %s section."),
                                  sec->uncompressed_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);
+            = 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;
         }
     }
 
   /* 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)."),
+      (*_bfd_error_handler) (_("Dwarf Error: Offset (%lu)"
+                               " greater than or equal to %s size (%lu)."),
                              (long) offset, section_name, *section_size);
       bfd_set_error (bfd_error_bad_value);
       return FALSE;
     }
 
   return TRUE;
 }
 
 /* VERBATIM
    The following function up to the END VERBATIM mark are
@@ skipping 471 matching lines @@
   char *                comp_dir;
   char **               dirs;
   struct fileinfo*      files;
   struct line_sequence* sequences;
   struct line_info*     lcl_head;   /* Local head; used in 'add_line_info'.  */
 };
 
 /* Remember some information about each function.  If the function is
    inlined (DW_TAG_inlined_subroutine) it may have two additional
    attributes, DW_AT_call_file and DW_AT_call_line, which specify the
-   source code location where this function was inlined. */
+   source code location where this function was inlined.  */
 
 struct funcinfo
 {
-  struct funcinfo *prev_func;           /* Pointer to previous function in list of all functions */
-  struct funcinfo *caller_func;         /* Pointer to function one scope higher */
-  char *caller_file;                    /* Source location file name where caller_func inlines this func */
-  int caller_line;                      /* Source location line number where caller_func inlines this func */
-  char *file;                           /* Source location file name */
-  int line;                             /* Source location line number */
+  /* Pointer to previous function in list of all functions.  */
+  struct funcinfo *prev_func;
+  /* Pointer to function one scope higher.  */
+  struct funcinfo *caller_func;
+  /* Source location file name where caller_func inlines this func.  */
+  char *caller_file;
+  /* Source location line number where caller_func inlines this func.  */
+  int caller_line;
+  /* Source location file name.  */
+  char *file;
+  /* Source location line number.  */
+  int line;
   int tag;
   char *name;
   struct arange arange;
-  asection *sec;                        /* Where the symbol is defined */
+  /* Where the symbol is defined.  */
+  asection *sec;
 };
 
 struct varinfo
 {
   /* Pointer to previous variable in list of all variables */
   struct varinfo *prev_var;
   /* Source location file name */
   char *file;
   /* Source location line number */
   int line;
@@ skipping 200 matching lines @@
             sprintf (name, "%s/%s", dir_name, filename);
         }
 
       return name;
     }
 
   return strdup (filename);
 }
 
 static bfd_boolean
-arange_add (bfd *abfd, struct arange *first_arange,
+arange_add (const struct comp_unit *unit, struct arange *first_arange,
             bfd_vma low_pc, bfd_vma high_pc)
 {
   struct arange *arange;
 
-  /* If the first arange is empty, use it. */
+  /* Ignore empty ranges.  */
+  if (low_pc == high_pc)
+    return TRUE;
+
+  /* If the first arange is empty, use it.  */
   if (first_arange->high == 0)
     {
       first_arange->low = low_pc;
       first_arange->high = high_pc;
       return TRUE;
     }
 
   /* Next see if we can cheaply extend an existing range.  */
   arange = first_arange;
   do
     {
       if (low_pc == arange->high)
         {
           arange->high = high_pc;
           return TRUE;
         }
       if (high_pc == arange->low)
         {
           arange->low = low_pc;
           return TRUE;
         }
       arange = arange->next;
     }
   while (arange);
 
   /* Need to allocate a new arange and insert it into the arange list.
      Order isn't significant, so just insert after the first arange. */
-  arange = (struct arange *) bfd_zalloc (abfd, sizeof (*arange));
+  arange = (struct arange *) bfd_alloc (unit->abfd, sizeof (*arange));
   if (arange == NULL)
     return FALSE;
   arange->low = low_pc;
   arange->high = high_pc;
   arange->next = first_arange->next;
   first_arange->next = arange;
   return TRUE;
 }
 
 /* Compare function for line sequences.  */
@@ skipping 99 matching lines @@
 decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
 {
   bfd *abfd = unit->abfd;
   struct line_info_table* table;
   bfd_byte *line_ptr;
   bfd_byte *line_end;
   struct line_head lh;
   unsigned int i, bytes_read, offset_size;
   char *cur_file, *cur_dir;
   unsigned char op_code, extended_op, adj_opcode;
+  unsigned int exop_len;
   bfd_size_type amt;
 
   if (! read_section (abfd, &stash->debug_sections[debug_line],
                       stash->syms, unit->line_offset,
                       &stash->dwarf_line_buffer, &stash->dwarf_line_size))
     return NULL;
 
   amt = sizeof (struct line_info_table);
   table = (struct line_info_table *) bfd_alloc (abfd, amt);
   if (table == NULL)
@@ skipping 160 matching lines @@
       while (! end_sequence)
         {
           op_code = read_1_byte (abfd, line_ptr);
           line_ptr += 1;
 
           if (op_code >= lh.opcode_base)
             {
               /* Special operand.  */
               adj_opcode = op_code - lh.opcode_base;
               if (lh.maximum_ops_per_insn == 1)
-                address += (adj_opcode / lh.line_range)
-                           * lh.minimum_instruction_length;
+                address += (adj_opcode / lh.line_range
+                            * lh.minimum_instruction_length);
               else
                 {
-                  address += ((op_index + (adj_opcode / lh.line_range))
-                              / lh.maximum_ops_per_insn)
-                             * lh.minimum_instruction_length;
-                  op_index = (op_index + (adj_opcode / lh.line_range))
-                             % lh.maximum_ops_per_insn;
+                  address += ((op_index + adj_opcode / lh.line_range)
+                              / lh.maximum_ops_per_insn
+                              * lh.minimum_instruction_length);
+                  op_index = ((op_index + adj_opcode / lh.line_range)
+                              % lh.maximum_ops_per_insn);
                 }
               line += lh.line_base + (adj_opcode % lh.line_range);
               /* Append row to matrix using current values.  */
               if (!add_line_info (table, address, op_index, filename,
                                   line, column, 0))
                 goto line_fail;
               if (address < low_pc)
                 low_pc = address;
               if (address > high_pc)
                 high_pc = address;
             }
           else switch (op_code)
             {
             case DW_LNS_extended_op:
-              /* Ignore length.  */
-              line_ptr += 1;
+              exop_len = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
+              line_ptr += bytes_read;
               extended_op = read_1_byte (abfd, line_ptr);
               line_ptr += 1;
 
               switch (extended_op)
                 {
                 case DW_LNE_end_sequence:
                   end_sequence = 1;
                   if (!add_line_info (table, address, op_index, filename,
                                       line, column, end_sequence))
                     goto line_fail;
                   if (address < low_pc)
                     low_pc = address;
                   if (address > high_pc)
                     high_pc = address;
-                  if (!arange_add (unit->abfd, &unit->arange, low_pc, high_pc))
+                  if (!arange_add (unit, &unit->arange, low_pc, high_pc))
                     goto line_fail;
                   break;
                 case DW_LNE_set_address:
                   address = read_address (unit, line_ptr);
                   op_index = 0;
                   line_ptr += unit->addr_size;
                   break;
                 case DW_LNE_define_file:
                   cur_file = read_string (abfd, line_ptr, &bytes_read);
                   line_ptr += bytes_read;
@@ skipping 17 matching lines @@
                   line_ptr += bytes_read;
                   table->files[table->num_files].size =
                     read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
                   line_ptr += bytes_read;
                   table->num_files++;
                   break;
                 case DW_LNE_set_discriminator:
                   (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
                   line_ptr += bytes_read;
                   break;
+                case DW_LNE_HP_source_file_correlation:
+                  line_ptr += exop_len - 1;
+                  break;
                 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);
                 line_fail:
                   if (filename != NULL)
                     free (filename);
                   goto fail;
                 }
               break;
             case DW_LNS_copy:
               if (!add_line_info (table, address, op_index,
                                   filename, line, column, 0))
                 goto line_fail;
               if (address < low_pc)
                 low_pc = address;
               if (address > high_pc)
                 high_pc = address;
               break;
             case DW_LNS_advance_pc:
               if (lh.maximum_ops_per_insn == 1)
-                address += lh.minimum_instruction_length
-                           * read_unsigned_leb128 (abfd, line_ptr,
-                                                   &bytes_read);
+                address += (lh.minimum_instruction_length
+                            * read_unsigned_leb128 (abfd, line_ptr,
+                                                    &bytes_read));
               else
                 {
                   bfd_vma adjust = read_unsigned_leb128 (abfd, line_ptr,
                                                          &bytes_read);
-                  address = ((op_index + adjust) / lh.maximum_ops_per_insn)
-                            * lh.minimum_instruction_length;
+                  address = ((op_index + adjust) / lh.maximum_ops_per_insn
+                             * lh.minimum_instruction_length);
                   op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
                 }
               line_ptr += bytes_read;
               break;
             case DW_LNS_advance_line:
               line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
               line_ptr += bytes_read;
               break;
             case DW_LNS_set_file:
               {
@@ skipping 12 matching lines @@
               column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
               line_ptr += bytes_read;
               break;
             case DW_LNS_negate_stmt:
               is_stmt = (!is_stmt);
               break;
             case DW_LNS_set_basic_block:
               break;
             case DW_LNS_const_add_pc:
               if (lh.maximum_ops_per_insn == 1)
-                address += lh.minimum_instruction_length
-                           * ((255 - lh.opcode_base) / lh.line_range);
+                address += (lh.minimum_instruction_length
+                            * ((255 - lh.opcode_base) / lh.line_range));
               else
                 {
                   bfd_vma adjust = ((255 - lh.opcode_base) / lh.line_range);
-                  address += lh.minimum_instruction_length
-                             * ((op_index + adjust) / lh.maximum_ops_per_insn);
+                  address += (lh.minimum_instruction_length
+                              * ((op_index + adjust)
+                                 / lh.maximum_ops_per_insn));
                   op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
                 }
               break;
             case DW_LNS_fixed_advance_pc:
               address += read_2_bytes (abfd, line_ptr);
               op_index = 0;
               line_ptr += 2;
               break;
             default:
               /* Unknown standard opcode, ignore it.  */
@@ skipping 105 matching lines @@
   for (each_func = unit->function_table;
        each_func;
        each_func = each_func->prev_func)
     {
       for (arange = &each_func->arange;
            arange;
            arange = arange->next)
         {
           if (addr >= arange->low && addr < arange->high)
             {
-              if (!best_fit ||
-                  ((arange->high - arange->low) < (best_fit->arange.high - best_fit->arange.low)))
+              if (!best_fit
+                  || (arange->high - arange->low
+                      < best_fit->arange.high - best_fit->arange.low))
                 best_fit = each_func;
             }
         }
     }
 
   if (best_fit)
     {
       *functionname_ptr = best_fit->name;
       *function_ptr = best_fit;
       return TRUE;
@@ skipping 27 matching lines @@
       for (arange = &each_func->arange;
            arange;
            arange = arange->next)
         {
           if ((!each_func->sec || each_func->sec == sec)
               && addr >= arange->low
               && addr < arange->high
               && each_func->name
               && strcmp (name, each_func->name) == 0
               && (!best_fit
-                  || ((arange->high - arange->low)
-                      < (best_fit->arange.high - best_fit->arange.low))))
+                  || (arange->high - arange->low
+                      < best_fit->arange.high - best_fit->arange.low)))
             best_fit = each_func;
         }
     }
 
   if (best_fit)
     {
       best_fit->sec = sec;
       *filename_ptr = best_fit->file;
       *linenumber_ptr = best_fit->line;
       return TRUE;
@@ skipping 64 matching lines @@
   else 
     info_ptr = unit->info_ptr_unit + die_ref;
   abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
   info_ptr += bytes_read;
 
   if (abbrev_number)
     {
       abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
       if (! abbrev)
         {
-          (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
-                                 abbrev_number);
+          (*_bfd_error_handler)
+            (_("Dwarf Error: Could not find abbrev number %u."), abbrev_number);
           bfd_set_error (bfd_error_bad_value);
         }
       else
         {
           for (i = 0; i < abbrev->num_attrs; ++i)
             {
               info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit,
                                          info_ptr);
               if (info_ptr == NULL)
                 break;
@@ skipping 44 matching lines @@
       ranges_ptr += unit->addr_size;
       high_pc = read_address (unit, ranges_ptr);
       ranges_ptr += unit->addr_size;
 
       if (low_pc == 0 && high_pc == 0)
         break;
       if (low_pc == -1UL && high_pc != -1UL)
         base_address = high_pc;
       else
         {
-          if (!arange_add (unit->abfd, arange,
+          if (!arange_add (unit, arange,
                            base_address + low_pc, base_address + high_pc))
             return FALSE;
         }
     }
   return TRUE;
 }
 
 /* DWARF2 Compilation unit functions.  */
 
 /* Scan over each die in a comp. unit looking for functions to add
    to the function table and variables to the variable table.  */
 
 static bfd_boolean
 scan_unit_for_symbols (struct comp_unit *unit)
 {
   bfd *abfd = unit->abfd;
   bfd_byte *info_ptr = unit->first_child_die_ptr;
   int nesting_level = 1;
   struct funcinfo **nested_funcs;
   int nested_funcs_size;
 
   /* Maintain a stack of in-scope functions and inlined functions, which we
      can use to set the caller_func field.  */
   nested_funcs_size = 32;
   nested_funcs = (struct funcinfo **)
-      bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *));
+    bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *));
   if (nested_funcs == NULL)
     return FALSE;
   nested_funcs[nesting_level] = 0;
 
   while (nesting_level)
     {
       unsigned int abbrev_number, bytes_read, i;
       struct abbrev_info *abbrev;
       struct attribute attr;
       struct funcinfo *func;
       struct varinfo *var;
       bfd_vma low_pc = 0;
       bfd_vma high_pc = 0;
+      bfd_boolean high_pc_relative = FALSE;
 
       abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
       info_ptr += bytes_read;
 
       if (! abbrev_number)
         {
           nesting_level--;
           continue;
         }
 
@@ skipping 85 matching lines @@
                 case DW_AT_MIPS_linkage_name:
                   func->name = attr.u.str;
                   break;
 
                 case DW_AT_low_pc:
                   low_pc = attr.u.val;
                   break;
 
                 case DW_AT_high_pc:
                   high_pc = attr.u.val;
+                  high_pc_relative = attr.form != DW_FORM_addr;
                   break;
 
                 case DW_AT_ranges:
                   if (!read_rangelist (unit, &func->arange, attr.u.val))
                     goto fail;
                   break;
 
                 case DW_AT_decl_file:
                   func->file = concat_filename (unit->line_table,
                                                 attr.u.val);
@@ skipping 58 matching lines @@
                       break;
                     }
                   break;
 
                 default:
                   break;
                 }
             }
         }
 
+      if (high_pc_relative)
+        high_pc += low_pc;
+
       if (func && high_pc != 0)
         {
-          if (!arange_add (unit->abfd, &func->arange, low_pc, high_pc))
+          if (!arange_add (unit, &func->arange, low_pc, high_pc))
             goto fail;
         }
 
       if (abbrev->has_children)
         {
           nesting_level++;
 
           if (nesting_level >= nested_funcs_size)
             {
               struct funcinfo **tmp;
 
               nested_funcs_size *= 2;
               tmp = (struct funcinfo **)
-                 bfd_realloc (nested_funcs,
-                              (nested_funcs_size * sizeof (struct funcinfo *)));
+                bfd_realloc (nested_funcs,
+                             nested_funcs_size * sizeof (struct funcinfo *));
               if (tmp == NULL)
                 goto fail;
               nested_funcs = tmp;
             }
           nested_funcs[nesting_level] = 0;
         }
     }
 
   free (nested_funcs);
   return TRUE;
@@ skipping 25 matching lines @@
   struct abbrev_info** abbrevs;
   unsigned int abbrev_number, bytes_read, i;
   struct abbrev_info *abbrev;
   struct attribute attr;
   bfd_byte *info_ptr = stash->info_ptr;
   bfd_byte *end_ptr = info_ptr + unit_length;
   bfd_size_type amt;
   bfd_vma low_pc = 0;
   bfd_vma high_pc = 0;
   bfd *abfd = stash->bfd_ptr;
+  bfd_boolean high_pc_relative = FALSE;
 
   version = read_2_bytes (abfd, info_ptr);
   info_ptr += 2;
   BFD_ASSERT (offset_size == 4 || offset_size == 8);
   if (offset_size == 4)
     abbrev_offset = read_4_bytes (abfd, info_ptr);
   else
     abbrev_offset = read_8_bytes (abfd, info_ptr);
   info_ptr += offset_size;
   addr_size = read_1_byte (abfd, info_ptr);
   info_ptr += 1;
 
   if (version != 2 && version != 3 && version != 4)
     {
-      (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2, 3 and 4 information."), version);
+      (*_bfd_error_handler)
+        (_("Dwarf Error: found dwarf version '%u', this reader"
+           " only handles version 2, 3 and 4 information."), version);
       bfd_set_error (bfd_error_bad_value);
       return 0;
     }
 
   if (addr_size > sizeof (bfd_vma))
     {
-      (*_bfd_error_handler) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
-                         addr_size,
-                         (unsigned int) sizeof (bfd_vma));
+      (*_bfd_error_handler)
+        (_("Dwarf Error: found address size '%u', this reader"
+           " can not handle sizes greater than '%u'."),
+         addr_size,
+         (unsigned int) sizeof (bfd_vma));
       bfd_set_error (bfd_error_bad_value);
       return 0;
     }
 
   if (addr_size != 2 && addr_size != 4 && addr_size != 8)
     {
-      (*_bfd_error_handler) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size);
+      (*_bfd_error_handler)
+        ("Dwarf Error: found address size '%u', this reader"
+         " can only handle address sizes '2', '4' and '8'.", addr_size);
       bfd_set_error (bfd_error_bad_value);
       return 0;
     }
 
   /* Read the abbrevs for this compilation unit into a table.  */
   abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
   if (! abbrevs)
-      return 0;
+    return 0;
 
   abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
   info_ptr += bytes_read;
   if (! abbrev_number)
     {
       (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u."),
-                         abbrev_number);
+                             abbrev_number);
       bfd_set_error (bfd_error_bad_value);
       return 0;
     }
 
   abbrev = lookup_abbrev (abbrev_number, abbrevs);
   if (! abbrev)
     {
       (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
-                         abbrev_number);
+                             abbrev_number);
       bfd_set_error (bfd_error_bad_value);
       return 0;
     }
 
   amt = sizeof (struct comp_unit);
   unit = (struct comp_unit *) bfd_zalloc (abfd, amt);
   if (unit == NULL)
     return NULL;
   unit->abfd = abfd;
   unit->version = version;
@@ skipping 22 matching lines @@
 
         case DW_AT_name:
           unit->name = attr.u.str;
           break;
 
         case DW_AT_low_pc:
           low_pc = attr.u.val;
           /* If the compilation unit DIE has a DW_AT_low_pc attribute,
              this is the base address to use when reading location
              lists or range lists. */
-          unit->base_address = low_pc;
+          if (abbrev->tag == DW_TAG_compile_unit)
+            unit->base_address = low_pc;
           break;
 
         case DW_AT_high_pc:
           high_pc = attr.u.val;
+          high_pc_relative = attr.form != DW_FORM_addr;
           break;
 
         case DW_AT_ranges:
           if (!read_rangelist (unit, &unit->arange, attr.u.val))
             return NULL;
           break;
 
         case DW_AT_comp_dir:
           {
             char *comp_dir = attr.u.str;
             if (comp_dir)
               {
                 /* Irix 6.2 native cc prepends <machine>.: to the compilation
                    directory, get rid of it.  */
                 char *cp = strchr (comp_dir, ':');
 
                 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
                   comp_dir = cp + 1;
               }
             unit->comp_dir = comp_dir;
             break;
           }
 
         default:
           break;
         }
     }
+  if (high_pc_relative)
+    high_pc += low_pc;
   if (high_pc != 0)
     {
-      if (!arange_add (unit->abfd, &unit->arange, low_pc, high_pc))
+      if (!arange_add (unit, &unit->arange, low_pc, high_pc))
         return NULL;
     }
 
   unit->first_child_die_ptr = info_ptr;
   return unit;
 }
 
 /* Return TRUE if UNIT may contain the address given by ADDR.  When
    there are functions written entirely with inline asm statements, the
    range info in the compilation unit header may not be correct.  We
@@ skipping 249 matching lines @@
    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 GNU_LINKONCE_INFO ".gnu.linkonce.wi."
 
 static asection *
 find_debug_info (bfd *abfd, const struct dwarf_debug_section *debug_sections,
                  asection *after_sec)
 {
-  asection * msec;
+  asection *msec;
+  const char *look;
 
-  msec = after_sec != NULL ? after_sec->next : abfd->sections;
-
-  while (msec)
+  if (after_sec == NULL)
     {
-      if (strcmp (msec->name,
-                  debug_sections[debug_info].uncompressed_name) == 0)
+      look = debug_sections[debug_info].uncompressed_name;
+      msec = bfd_get_section_by_name (abfd, look);
+      if (msec != NULL)
         return msec;
 
-      if (debug_sections[debug_info].compressed_name != NULL
-          && strcmp (msec->name,
-                     debug_sections[debug_info].compressed_name) == 0)
+      look = debug_sections[debug_info].compressed_name;
+      if (look != NULL)
+        {
+          msec = bfd_get_section_by_name (abfd, look);
+          if (msec != NULL)
+            return msec;
+        }
+
+      for (msec = abfd->sections; msec != NULL; msec = msec->next)
+        if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
+          return msec;
+
+      return NULL;
+    }
+
+  for (msec = after_sec->next; msec != NULL; msec = msec->next)
+    {
+      look = debug_sections[debug_info].uncompressed_name;
+      if (strcmp (msec->name, look) == 0)
+        return msec;
+
+      look = debug_sections[debug_info].compressed_name;
+      if (look != NULL && strcmp (msec->name, look) == 0)
         return msec;
 
       if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
         return msec;
-
-      msec = msec->next;
     }
 
   return NULL;
 }
 
 /* Unset vmas for adjusted sections in STASH.  */
 
 static void
 unset_sections (struct dwarf2_debug *stash)
 {
@@ skipping 53 matching lines @@
             continue;
 
           sz = sect->rawsize ? sect->rawsize : sect->size;
           if (sz == 0)
             continue;
 
           i++;
         }
 
       amt = i * sizeof (struct adjusted_section);
-      p = (struct adjusted_section *) bfd_zalloc (abfd, amt);
+      p = (struct adjusted_section *) bfd_alloc (abfd, amt);
       if (! p)
         return FALSE;
 
       stash->adjusted_sections = p;
       stash->adjusted_section_count = i;
 
       for (sect = abfd->sections; sect != NULL; sect = sect->next)
         {
           bfd_size_type sz;
           int is_debug_info;
@@ skipping 73 matching lines @@
     {
       each_func = (struct funcinfo *) node->info;
       for (arange = &each_func->arange;
            arange;
            arange = arange->next)
         {
           if ((!each_func->sec || each_func->sec == sec)
               && addr >= arange->low
               && addr < arange->high
               && (!best_fit
-                  || ((arange->high - arange->low)
-                      < (best_fit->arange.high - best_fit->arange.low))))
+                  || (arange->high - arange->low
+                      < best_fit->arange.high - best_fit->arange.low)))
             best_fit = each_func;
         }
     }
 
   if (best_fit)
     {
       best_fit->sec = sec;
       *filename_ptr = best_fit->file;
       *linenumber_ptr = best_fit->line;
       return TRUE;
@@ skipping 170 matching lines @@
 {
   BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_ON);
 
   if (sym->flags & BSF_FUNCTION)
     return info_hash_lookup_funcinfo (stash->funcinfo_hash_table, sym, addr,
                                       filename_ptr, linenumber_ptr);
   return info_hash_lookup_varinfo (stash->varinfo_hash_table, sym, addr,
                                    filename_ptr, linenumber_ptr);
 }
 
+/* Read debug information from DEBUG_BFD when DEBUG_BFD is specified.
+   If DEBUG_BFD is not specified, we read debug information from ABFD
+   or its gnu_debuglink. The results will be stored in PINFO.
+   The function returns TRUE iff debug information is ready.  */
+
+bfd_boolean
+_bfd_dwarf2_slurp_debug_info (bfd *abfd, bfd *debug_bfd,
+                              const struct dwarf_debug_section *debug_sections,
+                              asymbol **symbols,
+                              void **pinfo)
+{
+  bfd_size_type amt = sizeof (struct dwarf2_debug);
+  bfd_size_type total_size;
+  asection *msec;
+  struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
+
+  if (stash != NULL)
+    return TRUE;
+
+  stash = (struct dwarf2_debug *) bfd_zalloc (abfd, amt);
+  if (! stash)
+    return FALSE;
+  stash->debug_sections = debug_sections;
+
+  *pinfo = stash;
+
+  if (debug_bfd == NULL)
+    debug_bfd = abfd;
+
+  msec = find_debug_info (debug_bfd, debug_sections, NULL);
+  if (msec == NULL && abfd == debug_bfd)
+    {
+      char * debug_filename = bfd_follow_gnu_debuglink (abfd, DEBUGDIR);
+
+      if (debug_filename == NULL)
+        /* No dwarf2 info, and no gnu_debuglink to follow.
+           Note that at this point the stash has been allocated, but
+           contains zeros.  This lets future calls to this function
+           fail more quickly.  */
+        return FALSE;
+
+      if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
+          || ! bfd_check_format (debug_bfd, bfd_object)
+          || (msec = find_debug_info (debug_bfd,
+                                      debug_sections, NULL)) == NULL)
+        {
+          if (debug_bfd)
+            bfd_close (debug_bfd);
+          /* FIXME: Should we report our failure to follow the debuglink ?  */
+          free (debug_filename);
+          return FALSE;
+        }
+    }
+
+  /* There can be more than one DWARF2 info section in a BFD these
+     days.  First handle the easy case when there's only one.  If
+     there's more than one, try case two: none of the sections is
+     compressed.  In that case, read them all in and produce one
+     large stash.  We do this in two passes - in the first pass we
+     just accumulate the section sizes, and in the second pass we
+     read in the section's contents.  (The allows us to avoid
+     reallocing the data as we add sections to the stash.)  If
+     some or all sections are compressed, then do things the slow
+     way, with a bunch of reallocs.  */
+
+  if (! find_debug_info (debug_bfd, debug_sections, msec))
+    {
+      /* Case 1: only one info section.  */
+      total_size = msec->size;
+      if (! read_section (debug_bfd, &stash->debug_sections[debug_info],
+                          symbols, 0,
+                          &stash->info_ptr_memory, &total_size))
+        return FALSE;
+    }
+  else
+    {
+      /* Case 2: multiple sections.  */
+      for (total_size = 0;
+           msec;
+           msec = find_debug_info (debug_bfd, debug_sections, msec))
+        total_size += msec->size;
+
+      stash->info_ptr_memory = (bfd_byte *) bfd_malloc (total_size);
+      if (stash->info_ptr_memory == NULL)
+        return FALSE;
+
+      total_size = 0;
+      for (msec = find_debug_info (debug_bfd, debug_sections, NULL);
+           msec;
+           msec = find_debug_info (debug_bfd, debug_sections, msec))
+        {
+          bfd_size_type size;
+
+          size = msec->size;
+          if (size == 0)
+            continue;
+
+          if (!(bfd_simple_get_relocated_section_contents
+                (debug_bfd, msec, stash->info_ptr_memory + total_size,
+                 symbols)))
+            return FALSE;
+
+          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, debug_sections, NULL);
+  stash->sec_info_ptr = stash->info_ptr;
+  stash->syms = symbols;
+  stash->bfd_ptr = debug_bfd;
+
+  return TRUE;
+}
+
 /* Find the source code location of SYMBOL.  If SYMBOL is NULL
    then find the nearest source code location corresponding to
    the address SECTION + OFFSET.
    Returns TRUE if the line is found without error and fills in
    FILENAME_PTR and LINENUMBER_PTR.  In the case where SYMBOL was
    NULL the FUNCTIONNAME_PTR is also filled in.
    SYMBOLS contains the symbol table for ABFD.
    DEBUG_SECTIONS contains the name of the dwarf debug sections.
    ADDR_SIZE is the number of bytes in the initial .debug_info length
    field and in the abbreviation offset, or zero to indicate that the
@@ skipping 20 matching lines @@
      We keep a list of all the previously read compilation units, and
      a pointer to the next un-read compilation unit.  Check the
      previously read units before reading more.  */
   struct dwarf2_debug *stash;
   /* What address are we looking for?  */
   bfd_vma addr;
   struct comp_unit* each;
   bfd_vma found = FALSE;
   bfd_boolean do_line;
 
+  *filename_ptr = NULL;
+  if (functionname_ptr != NULL)
+    *functionname_ptr = NULL;
+  *linenumber_ptr = 0;
+
+  if (! _bfd_dwarf2_slurp_debug_info (abfd, NULL,
+                                      debug_sections, symbols, pinfo))
+    return FALSE;
+
   stash = (struct dwarf2_debug *) *pinfo;
 
-  if (! stash)
-    {
-      bfd_size_type amt = sizeof (struct dwarf2_debug);
-
-      stash = (struct dwarf2_debug *) bfd_zalloc (abfd, amt);
-      if (! stash)
-        return FALSE;
-      stash->debug_sections = debug_sections;
-    }
-
   /* In a relocatable file, 2 functions may have the same address.
      We change the section vma so that they won't overlap.  */
   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
     {
       if (! place_sections (abfd, stash))
         return FALSE;
     }
 
   do_line = (section == NULL
              && offset == 0
              && functionname_ptr == NULL
              && symbol != NULL);
   if (do_line)
     {
       addr = symbol->value;
       section = bfd_get_section (symbol);
     }
   else if (section != NULL
            && functionname_ptr != NULL
            && symbol == NULL)
     addr = offset;
   else
     abort ();
 
   if (section->output_section)
     addr += section->output_section->vma + section->output_offset;
   else
     addr += section->vma;
-  *filename_ptr = NULL;
-  if (! do_line)
-    *functionname_ptr = NULL;
-  *linenumber_ptr = 0;
-
-  if (! *pinfo)
-    {
-      bfd *debug_bfd;
-      bfd_size_type total_size;
-      asection *msec;
-
-      *pinfo = stash;
-
-      msec = find_debug_info (abfd, debug_sections, NULL);
-      if (msec == NULL)
-        {
-          char * debug_filename = bfd_follow_gnu_debuglink (abfd, DEBUGDIR);
-
-          if (debug_filename == NULL)
-            /* No dwarf2 info, and no gnu_debuglink to follow.
-               Note that at this point the stash has been allocated, but
-               contains zeros.  This lets future calls to this function
-               fail more quickly.  */
-            goto done;
-
-          if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
-              || ! bfd_check_format (debug_bfd, bfd_object)
-              || (msec = find_debug_info (debug_bfd,
-                                          debug_sections, NULL)) == NULL)
-            {
-              if (debug_bfd)
-                bfd_close (debug_bfd);
-              /* FIXME: Should we report our failure to follow the debuglink ?  */
-              free (debug_filename);
-              goto done;
-            }
-        }
-      else
-        debug_bfd = abfd;
-
-      /* There can be more than one DWARF2 info section in a BFD these
-         days.  First handle the easy case when there's only one.  If
-         there's more than one, try case two: none of the sections is
-         compressed.  In that case, read them all in and produce one
-         large stash.  We do this in two passes - in the first pass we
-         just accumulate the section sizes, and in the second pass we
-         read in the section's contents.  (The allows us to avoid
-         reallocing the data as we add sections to the stash.)  If
-         some or all sections are compressed, then do things the slow
-         way, with a bunch of reallocs.  */
-
-      if (! find_debug_info (debug_bfd, debug_sections, msec))
-        {
-          /* Case 1: only one info section.  */
-          total_size = msec->size;
-          if (! read_section (debug_bfd, &stash->debug_sections[debug_info],
-                              symbols, 0,
-                              &stash->info_ptr_memory, &total_size))
-            goto done;
-        }
-      else
-        {
-          /* Case 2: multiple sections.  */
-          for (total_size = 0;
-               msec;
-               msec = find_debug_info (debug_bfd, debug_sections, msec))
-            total_size += msec->size;
-
-          stash->info_ptr_memory = (bfd_byte *) bfd_malloc (total_size);
-          if (stash->info_ptr_memory == NULL)
-            goto done;
-
-          total_size = 0;
-          for (msec = find_debug_info (debug_bfd, debug_sections, NULL);
-               msec;
-               msec = find_debug_info (debug_bfd, debug_sections, msec))
-            {
-              bfd_size_type size;
-
-              size = msec->size;
-              if (size == 0)
-                continue;
-
-              if (!(bfd_simple_get_relocated_section_contents
-                    (debug_bfd, msec, stash->info_ptr_memory + total_size,
-                     symbols)))
-                goto done;
-
-              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, debug_sections, NULL);
-      stash->sec_info_ptr = stash->info_ptr;
-      stash->syms = symbols;
-      stash->bfd_ptr = debug_bfd;
-    }
 
   /* A null info_ptr indicates that there is no dwarf2 info
      (or that an error occured while setting up the stash).  */
   if (! stash->info_ptr)
-    goto done;
+    return FALSE;
 
   stash->inliner_chain = NULL;
 
   /* Check the previously read comp. units first.  */
   if (do_line)
     {
       /* The info hash tables use quite a bit of memory.  We may not want to
          always use them.  We use some heuristics to decide if and when to
          turn it on.  */
       if (stash->info_hash_status == STASH_INFO_HASH_OFF)
         stash_maybe_enable_info_hash_tables (abfd, stash);
 
       /* Keep info hash table up to date if they are available.  Note that we
          may disable the hash tables if there is any error duing update. */
       if (stash->info_hash_status == STASH_INFO_HASH_ON)
         stash_maybe_update_info_hash_tables (stash);
 
       if (stash->info_hash_status == STASH_INFO_HASH_ON)
         {
           found = stash_find_line_fast (stash, symbol, addr, filename_ptr,
                                         linenumber_ptr);
           if (found)
             goto done;
         }
       else
         {
           /* Check the previously read comp. units first.  */
           for (each = stash->all_comp_units; each; each = each->next_unit)
             if ((symbol->flags & BSF_FUNCTION) == 0
+                || each->arange.high == 0
                 || comp_unit_contains_address (each, addr))
               {
                 found = comp_unit_find_line (each, symbol, addr, filename_ptr,
                                              linenumber_ptr, stash);
                 if (found)
                   goto done;
               }
         }
     }
   else
     {
       for (each = stash->all_comp_units; each; each = each->next_unit)
         {
-          found = (comp_unit_contains_address (each, addr)
+          found = ((each->arange.high == 0
+                    || comp_unit_contains_address (each, addr))
                    && comp_unit_find_nearest_line (each, addr,
                                                    filename_ptr,
                                                    functionname_ptr,
                                                    linenumber_ptr,
                                                    stash));
           if (found)
             goto done;
         }
     }
 
@@ skipping 92 matching lines @@
               stash->sec = find_debug_info (stash->bfd_ptr, debug_sections,
                                             stash->sec);
               stash->sec_info_ptr = stash->info_ptr;
             }
 
           if (found)
             goto done;
         }
     }
 
-done:
+ done:
   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
     unset_sections (stash);
 
   return found;
 }
 
 /* The DWARF2 version of find_nearest_line.
    Return TRUE if the line is found without error.  */
 
 bfd_boolean
@@ skipping 50 matching lines @@
           *linenumber_ptr = func->caller_line;
           stash->inliner_chain = func->caller_func;
           return TRUE;
         }
     }
 
   return FALSE;
 }
 
 void
-_bfd_dwarf2_cleanup_debug_info (bfd *abfd)
+_bfd_dwarf2_cleanup_debug_info (bfd *abfd, void **pinfo)
 {
+  struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;;
   struct comp_unit *each;
-  struct dwarf2_debug *stash;
 
-  if (abfd == NULL || elf_tdata (abfd) == NULL)
-    return;
-
-  stash = (struct dwarf2_debug *) elf_tdata (abfd)->dwarf2_find_line_info;
-
-  if (stash == NULL)
+  if (abfd == NULL || stash == NULL)
     return;
 
   for (each = stash->all_comp_units; each; each = each->next_unit)
     {
       struct abbrev_info **abbrevs = each->abbrevs;
       struct funcinfo *function_table = each->function_table;
       struct varinfo *variable_table = each->variable_table;
       size_t i;
 
       for (i = 0; i < ABBREV_HASH_SIZE; i++)
@@ skipping 45 matching lines @@
     free (stash->dwarf_abbrev_buffer);
   if (stash->dwarf_line_buffer)
     free (stash->dwarf_line_buffer);
   if (stash->dwarf_str_buffer)
     free (stash->dwarf_str_buffer);
   if (stash->dwarf_ranges_buffer)
     free (stash->dwarf_ranges_buffer);
   if (stash->info_ptr_memory)
     free (stash->info_ptr_memory);
 }