Home | History | Annotate | Download | only in bfd
      1 /* DWARF 2 support.
      2    Copyright (C) 1994-2016 Free Software Foundation, Inc.
      3 
      4    Adapted from gdb/dwarf2read.c by Gavin Koch of Cygnus Solutions
      5    (gavin (at) cygnus.com).
      6 
      7    From the dwarf2read.c header:
      8    Adapted by Gary Funck (gary (at) intrepid.com), Intrepid Technology,
      9    Inc.  with support from Florida State University (under contract
     10    with the Ada Joint Program Office), and Silicon Graphics, Inc.
     11    Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
     12    based on Fred Fish's (Cygnus Support) implementation of DWARF 1
     13    support in dwarfread.c
     14 
     15    This file is part of BFD.
     16 
     17    This program is free software; you can redistribute it and/or modify
     18    it under the terms of the GNU General Public License as published by
     19    the Free Software Foundation; either version 3 of the License, or (at
     20    your option) any later version.
     21 
     22    This program is distributed in the hope that it will be useful, but
     23    WITHOUT ANY WARRANTY; without even the implied warranty of
     24    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     25    General Public License for more details.
     26 
     27    You should have received a copy of the GNU General Public License
     28    along with this program; if not, write to the Free Software
     29    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
     30    MA 02110-1301, USA.  */
     31 
     32 #include "sysdep.h"
     33 #include "bfd.h"
     34 #include "libiberty.h"
     35 #include "libbfd.h"
     36 #include "elf-bfd.h"
     37 #include "dwarf2.h"
     38 
     39 /* The data in the .debug_line statement prologue looks like this.  */
     40 
     41 struct line_head
     42 {
     43   bfd_vma total_length;
     44   unsigned short version;
     45   bfd_vma prologue_length;
     46   unsigned char minimum_instruction_length;
     47   unsigned char maximum_ops_per_insn;
     48   unsigned char default_is_stmt;
     49   int line_base;
     50   unsigned char line_range;
     51   unsigned char opcode_base;
     52   unsigned char *standard_opcode_lengths;
     53 };
     54 
     55 /* Attributes have a name and a value.  */
     56 
     57 struct attribute
     58 {
     59   enum dwarf_attribute name;
     60   enum dwarf_form form;
     61   union
     62   {
     63     char *str;
     64     struct dwarf_block *blk;
     65     bfd_uint64_t val;
     66     bfd_int64_t sval;
     67   }
     68   u;
     69 };
     70 
     71 /* Blocks are a bunch of untyped bytes.  */
     72 struct dwarf_block
     73 {
     74   unsigned int size;
     75   bfd_byte *data;
     76 };
     77 
     78 struct adjusted_section
     79 {
     80   asection *section;
     81   bfd_vma adj_vma;
     82 };
     83 
     84 struct dwarf2_debug
     85 {
     86   /* A list of all previously read comp_units.  */
     87   struct comp_unit *all_comp_units;
     88 
     89   /* Last comp unit in list above.  */
     90   struct comp_unit *last_comp_unit;
     91 
     92   /* Names of the debug sections.  */
     93   const struct dwarf_debug_section *debug_sections;
     94 
     95   /* The next unread compilation unit within the .debug_info section.
     96      Zero indicates that the .debug_info section has not been loaded
     97      into a buffer yet.  */
     98   bfd_byte *info_ptr;
     99 
    100   /* Pointer to the end of the .debug_info section memory buffer.  */
    101   bfd_byte *info_ptr_end;
    102 
    103   /* Pointer to the bfd, section and address of the beginning of the
    104      section.  The bfd might be different than expected because of
    105      gnu_debuglink sections.  */
    106   bfd *bfd_ptr;
    107   asection *sec;
    108   bfd_byte *sec_info_ptr;
    109 
    110   /* Support for alternate debug info sections created by the DWZ utility:
    111      This includes a pointer to an alternate bfd which contains *extra*,
    112      possibly duplicate debug sections, and pointers to the loaded
    113      .debug_str and .debug_info sections from this bfd.  */
    114   bfd *          alt_bfd_ptr;
    115   bfd_byte *     alt_dwarf_str_buffer;
    116   bfd_size_type  alt_dwarf_str_size;
    117   bfd_byte *     alt_dwarf_info_buffer;
    118   bfd_size_type  alt_dwarf_info_size;
    119 
    120   /* A pointer to the memory block allocated for info_ptr.  Neither
    121      info_ptr nor sec_info_ptr are guaranteed to stay pointing to the
    122      beginning of the malloc block.  This is used only to free the
    123      memory later.  */
    124   bfd_byte *info_ptr_memory;
    125 
    126   /* Pointer to the symbol table.  */
    127   asymbol **syms;
    128 
    129   /* Pointer to the .debug_abbrev section loaded into memory.  */
    130   bfd_byte *dwarf_abbrev_buffer;
    131 
    132   /* Length of the loaded .debug_abbrev section.  */
    133   bfd_size_type dwarf_abbrev_size;
    134 
    135   /* Buffer for decode_line_info.  */
    136   bfd_byte *dwarf_line_buffer;
    137 
    138   /* Length of the loaded .debug_line section.  */
    139   bfd_size_type dwarf_line_size;
    140 
    141   /* Pointer to the .debug_str section loaded into memory.  */
    142   bfd_byte *dwarf_str_buffer;
    143 
    144   /* Length of the loaded .debug_str section.  */
    145   bfd_size_type dwarf_str_size;
    146 
    147   /* Pointer to the .debug_ranges section loaded into memory. */
    148   bfd_byte *dwarf_ranges_buffer;
    149 
    150   /* Length of the loaded .debug_ranges section. */
    151   bfd_size_type dwarf_ranges_size;
    152 
    153   /* If the most recent call to bfd_find_nearest_line was given an
    154      address in an inlined function, preserve a pointer into the
    155      calling chain for subsequent calls to bfd_find_inliner_info to
    156      use. */
    157   struct funcinfo *inliner_chain;
    158 
    159   /* Section VMAs at the time the stash was built.  */
    160   bfd_vma *sec_vma;
    161 
    162   /* Number of sections whose VMA we must adjust.  */
    163   int adjusted_section_count;
    164 
    165   /* Array of sections with adjusted VMA.  */
    166   struct adjusted_section *adjusted_sections;
    167 
    168   /* Number of times find_line is called.  This is used in
    169      the heuristic for enabling the info hash tables.  */
    170   int info_hash_count;
    171 
    172 #define STASH_INFO_HASH_TRIGGER    100
    173 
    174   /* Hash table mapping symbol names to function infos.  */
    175   struct info_hash_table *funcinfo_hash_table;
    176 
    177   /* Hash table mapping symbol names to variable infos.  */
    178   struct info_hash_table *varinfo_hash_table;
    179 
    180   /* Head of comp_unit list in the last hash table update.  */
    181   struct comp_unit *hash_units_head;
    182 
    183   /* Status of info hash.  */
    184   int info_hash_status;
    185 #define STASH_INFO_HASH_OFF        0
    186 #define STASH_INFO_HASH_ON         1
    187 #define STASH_INFO_HASH_DISABLED   2
    188 
    189   /* True if we opened bfd_ptr.  */
    190   bfd_boolean close_on_cleanup;
    191 };
    192 
    193 struct arange
    194 {
    195   struct arange *next;
    196   bfd_vma low;
    197   bfd_vma high;
    198 };
    199 
    200 /* A minimal decoding of DWARF2 compilation units.  We only decode
    201    what's needed to get to the line number information.  */
    202 
    203 struct comp_unit
    204 {
    205   /* Chain the previously read compilation units.  */
    206   struct comp_unit *next_unit;
    207 
    208   /* Likewise, chain the compilation unit read after this one.
    209      The comp units are stored in reversed reading order.  */
    210   struct comp_unit *prev_unit;
    211 
    212   /* Keep the bfd convenient (for memory allocation).  */
    213   bfd *abfd;
    214 
    215   /* The lowest and highest addresses contained in this compilation
    216      unit as specified in the compilation unit header.  */
    217   struct arange arange;
    218 
    219   /* The DW_AT_name attribute (for error messages).  */
    220   char *name;
    221 
    222   /* The abbrev hash table.  */
    223   struct abbrev_info **abbrevs;
    224 
    225   /* DW_AT_language.  */
    226   int lang;
    227 
    228   /* Note that an error was found by comp_unit_find_nearest_line.  */
    229   int error;
    230 
    231   /* The DW_AT_comp_dir attribute.  */
    232   char *comp_dir;
    233 
    234   /* TRUE if there is a line number table associated with this comp. unit.  */
    235   int stmtlist;
    236 
    237   /* Pointer to the current comp_unit so that we can find a given entry
    238      by its reference.  */
    239   bfd_byte *info_ptr_unit;
    240 
    241   /* Pointer to the start of the debug section, for DW_FORM_ref_addr.  */
    242   bfd_byte *sec_info_ptr;
    243 
    244   /* The offset into .debug_line of the line number table.  */
    245   unsigned long line_offset;
    246 
    247   /* Pointer to the first child die for the comp unit.  */
    248   bfd_byte *first_child_die_ptr;
    249 
    250   /* The end of the comp unit.  */
    251   bfd_byte *end_ptr;
    252 
    253   /* The decoded line number, NULL if not yet decoded.  */
    254   struct line_info_table *line_table;
    255 
    256   /* A list of the functions found in this comp. unit.  */
    257   struct funcinfo *function_table;
    258 
    259   /* A list of the variables found in this comp. unit.  */
    260   struct varinfo *variable_table;
    261 
    262   /* Pointer to dwarf2_debug structure.  */
    263   struct dwarf2_debug *stash;
    264 
    265   /* DWARF format version for this unit - from unit header.  */
    266   int version;
    267 
    268   /* Address size for this unit - from unit header.  */
    269   unsigned char addr_size;
    270 
    271   /* Offset size for this unit - from unit header.  */
    272   unsigned char offset_size;
    273 
    274   /* Base address for this unit - from DW_AT_low_pc attribute of
    275      DW_TAG_compile_unit DIE */
    276   bfd_vma base_address;
    277 
    278   /* TRUE if symbols are cached in hash table for faster lookup by name.  */
    279   bfd_boolean cached;
    280 };
    281 
    282 /* This data structure holds the information of an abbrev.  */
    283 struct abbrev_info
    284 {
    285   unsigned int number;		/* Number identifying abbrev.  */
    286   enum dwarf_tag tag;		/* DWARF tag.  */
    287   int has_children;		/* Boolean.  */
    288   unsigned int num_attrs;	/* Number of attributes.  */
    289   struct attr_abbrev *attrs;	/* An array of attribute descriptions.  */
    290   struct abbrev_info *next;	/* Next in chain.  */
    291 };
    292 
    293 struct attr_abbrev
    294 {
    295   enum dwarf_attribute name;
    296   enum dwarf_form form;
    297 };
    298 
    299 /* Map of uncompressed DWARF debug section name to compressed one.  It
    300    is terminated by NULL uncompressed_name.  */
    301 
    302 const struct dwarf_debug_section dwarf_debug_sections[] =
    303 {
    304   { ".debug_abbrev",		".zdebug_abbrev" },
    305   { ".debug_aranges",		".zdebug_aranges" },
    306   { ".debug_frame",		".zdebug_frame" },
    307   { ".debug_info",		".zdebug_info" },
    308   { ".debug_info",		".zdebug_info" },
    309   { ".debug_line",		".zdebug_line" },
    310   { ".debug_loc",		".zdebug_loc" },
    311   { ".debug_macinfo",		".zdebug_macinfo" },
    312   { ".debug_macro",		".zdebug_macro" },
    313   { ".debug_pubnames",		".zdebug_pubnames" },
    314   { ".debug_pubtypes",		".zdebug_pubtypes" },
    315   { ".debug_ranges",		".zdebug_ranges" },
    316   { ".debug_static_func",	".zdebug_static_func" },
    317   { ".debug_static_vars",	".zdebug_static_vars" },
    318   { ".debug_str",		".zdebug_str", },
    319   { ".debug_str",		".zdebug_str", },
    320   { ".debug_types",		".zdebug_types" },
    321   /* GNU DWARF 1 extensions */
    322   { ".debug_sfnames",		".zdebug_sfnames" },
    323   { ".debug_srcinfo",		".zebug_srcinfo" },
    324   /* SGI/MIPS DWARF 2 extensions */
    325   { ".debug_funcnames",		".zdebug_funcnames" },
    326   { ".debug_typenames",		".zdebug_typenames" },
    327   { ".debug_varnames",		".zdebug_varnames" },
    328   { ".debug_weaknames",		".zdebug_weaknames" },
    329   { NULL,			NULL },
    330 };
    331 
    332 /* NB/ Numbers in this enum must match up with indicies
    333    into the dwarf_debug_sections[] array above.  */
    334 enum dwarf_debug_section_enum
    335 {
    336   debug_abbrev = 0,
    337   debug_aranges,
    338   debug_frame,
    339   debug_info,
    340   debug_info_alt,
    341   debug_line,
    342   debug_loc,
    343   debug_macinfo,
    344   debug_macro,
    345   debug_pubnames,
    346   debug_pubtypes,
    347   debug_ranges,
    348   debug_static_func,
    349   debug_static_vars,
    350   debug_str,
    351   debug_str_alt,
    352   debug_types,
    353   debug_sfnames,
    354   debug_srcinfo,
    355   debug_funcnames,
    356   debug_typenames,
    357   debug_varnames,
    358   debug_weaknames
    359 };
    360 
    361 #ifndef ABBREV_HASH_SIZE
    362 #define ABBREV_HASH_SIZE 121
    363 #endif
    364 #ifndef ATTR_ALLOC_CHUNK
    365 #define ATTR_ALLOC_CHUNK 4
    366 #endif
    367 
    368 /* Variable and function hash tables.  This is used to speed up look-up
    369    in lookup_symbol_in_var_table() and lookup_symbol_in_function_table().
    370    In order to share code between variable and function infos, we use
    371    a list of untyped pointer for all variable/function info associated with
    372    a symbol.  We waste a bit of memory for list with one node but that
    373    simplifies the code.  */
    374 
    375 struct info_list_node
    376 {
    377   struct info_list_node *next;
    378   void *info;
    379 };
    380 
    381 /* Info hash entry.  */
    382 struct info_hash_entry
    383 {
    384   struct bfd_hash_entry root;
    385   struct info_list_node *head;
    386 };
    387 
    388 struct info_hash_table
    389 {
    390   struct bfd_hash_table base;
    391 };
    392 
    393 /* Function to create a new entry in info hash table. */
    394 
    395 static struct bfd_hash_entry *
    396 info_hash_table_newfunc (struct bfd_hash_entry *entry,
    397 			 struct bfd_hash_table *table,
    398 			 const char *string)
    399 {
    400   struct info_hash_entry *ret = (struct info_hash_entry *) entry;
    401 
    402   /* Allocate the structure if it has not already been allocated by a
    403      derived class.  */
    404   if (ret == NULL)
    405     {
    406       ret = (struct info_hash_entry *) bfd_hash_allocate (table,
    407 							  sizeof (* ret));
    408       if (ret == NULL)
    409 	return NULL;
    410     }
    411 
    412   /* Call the allocation method of the base class.  */
    413   ret = ((struct info_hash_entry *)
    414 	 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
    415 
    416   /* Initialize the local fields here.  */
    417   if (ret)
    418     ret->head = NULL;
    419 
    420   return (struct bfd_hash_entry *) ret;
    421 }
    422 
    423 /* Function to create a new info hash table.  It returns a pointer to the
    424    newly created table or NULL if there is any error.  We need abfd
    425    solely for memory allocation.  */
    426 
    427 static struct info_hash_table *
    428 create_info_hash_table (bfd *abfd)
    429 {
    430   struct info_hash_table *hash_table;
    431 
    432   hash_table = ((struct info_hash_table *)
    433 		bfd_alloc (abfd, sizeof (struct info_hash_table)));
    434   if (!hash_table)
    435     return hash_table;
    436 
    437   if (!bfd_hash_table_init (&hash_table->base, info_hash_table_newfunc,
    438 			    sizeof (struct info_hash_entry)))
    439     {
    440       bfd_release (abfd, hash_table);
    441       return NULL;
    442     }
    443 
    444   return hash_table;
    445 }
    446 
    447 /* Insert an info entry into an info hash table.  We do not check of
    448    duplicate entries.  Also, the caller need to guarantee that the
    449    right type of info in inserted as info is passed as a void* pointer.
    450    This function returns true if there is no error.  */
    451 
    452 static bfd_boolean
    453 insert_info_hash_table (struct info_hash_table *hash_table,
    454 			const char *key,
    455 			void *info,
    456 			bfd_boolean copy_p)
    457 {
    458   struct info_hash_entry *entry;
    459   struct info_list_node *node;
    460 
    461   entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base,
    462 						     key, TRUE, copy_p);
    463   if (!entry)
    464     return FALSE;
    465 
    466   node = (struct info_list_node *) bfd_hash_allocate (&hash_table->base,
    467 						      sizeof (*node));
    468   if (!node)
    469     return FALSE;
    470 
    471   node->info = info;
    472   node->next = entry->head;
    473   entry->head = node;
    474 
    475   return TRUE;
    476 }
    477 
    478 /* Look up an info entry list from an info hash table.  Return NULL
    479    if there is none. */
    480 
    481 static struct info_list_node *
    482 lookup_info_hash_table (struct info_hash_table *hash_table, const char *key)
    483 {
    484   struct info_hash_entry *entry;
    485 
    486   entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base, key,
    487 						     FALSE, FALSE);
    488   return entry ? entry->head : NULL;
    489 }
    490 
    491 /* Read a section into its appropriate place in the dwarf2_debug
    492    struct (indicated by SECTION_BUFFER and SECTION_SIZE).  If SYMS is
    493    not NULL, use bfd_simple_get_relocated_section_contents to read the
    494    section contents, otherwise use bfd_get_section_contents.  Fail if
    495    the located section does not contain at least OFFSET bytes.  */
    496 
    497 static bfd_boolean
    498 read_section (bfd *           abfd,
    499 	      const struct dwarf_debug_section *sec,
    500 	      asymbol **      syms,
    501 	      bfd_uint64_t    offset,
    502 	      bfd_byte **     section_buffer,
    503 	      bfd_size_type * section_size)
    504 {
    505   asection *msec;
    506   const char *section_name = sec->uncompressed_name;
    507 
    508   /* The section may have already been read.  */
    509   if (*section_buffer == NULL)
    510     {
    511       msec = bfd_get_section_by_name (abfd, section_name);
    512       if (! msec)
    513 	{
    514 	  section_name = sec->compressed_name;
    515 	  if (section_name != NULL)
    516 	    msec = bfd_get_section_by_name (abfd, section_name);
    517 	}
    518       if (! msec)
    519 	{
    520 	  (*_bfd_error_handler) (_("Dwarf Error: Can't find %s section."),
    521 				 sec->uncompressed_name);
    522 	  bfd_set_error (bfd_error_bad_value);
    523 	  return FALSE;
    524 	}
    525 
    526       *section_size = msec->rawsize ? msec->rawsize : msec->size;
    527       if (syms)
    528 	{
    529 	  *section_buffer
    530 	    = bfd_simple_get_relocated_section_contents (abfd, msec, NULL, syms);
    531 	  if (! *section_buffer)
    532 	    return FALSE;
    533 	}
    534       else
    535 	{
    536 	  *section_buffer = (bfd_byte *) bfd_malloc (*section_size);
    537 	  if (! *section_buffer)
    538 	    return FALSE;
    539 	  if (! bfd_get_section_contents (abfd, msec, *section_buffer,
    540 					  0, *section_size))
    541 	    return FALSE;
    542 	}
    543     }
    544 
    545   /* It is possible to get a bad value for the offset into the section
    546      that the client wants.  Validate it here to avoid trouble later.  */
    547   if (offset != 0 && offset >= *section_size)
    548     {
    549       (*_bfd_error_handler) (_("Dwarf Error: Offset (%lu)"
    550 			       " greater than or equal to %s size (%lu)."),
    551 			     (long) offset, section_name, *section_size);
    552       bfd_set_error (bfd_error_bad_value);
    553       return FALSE;
    554     }
    555 
    556   return TRUE;
    557 }
    558 
    559 /* Read dwarf information from a buffer.  */
    560 
    561 static unsigned int
    562 read_1_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf, bfd_byte *end)
    563 {
    564   if (buf + 1 > end)
    565     return 0;
    566   return bfd_get_8 (abfd, buf);
    567 }
    568 
    569 static int
    570 read_1_signed_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf, bfd_byte *end)
    571 {
    572   if (buf + 1 > end)
    573     return 0;
    574   return bfd_get_signed_8 (abfd, buf);
    575 }
    576 
    577 static unsigned int
    578 read_2_bytes (bfd *abfd, bfd_byte *buf, bfd_byte *end)
    579 {
    580   if (buf + 2 > end)
    581     return 0;
    582   return bfd_get_16 (abfd, buf);
    583 }
    584 
    585 static unsigned int
    586 read_4_bytes (bfd *abfd, bfd_byte *buf, bfd_byte *end)
    587 {
    588   if (buf + 4 > end)
    589     return 0;
    590   return bfd_get_32 (abfd, buf);
    591 }
    592 
    593 static bfd_uint64_t
    594 read_8_bytes (bfd *abfd, bfd_byte *buf, bfd_byte *end)
    595 {
    596   if (buf + 8 > end)
    597     return 0;
    598   return bfd_get_64 (abfd, buf);
    599 }
    600 
    601 static bfd_byte *
    602 read_n_bytes (bfd *abfd ATTRIBUTE_UNUSED,
    603 	      bfd_byte *buf,
    604 	      bfd_byte *end,
    605 	      unsigned int size ATTRIBUTE_UNUSED)
    606 {
    607   if (buf + size > end)
    608     return NULL;
    609   return buf;
    610 }
    611 
    612 /* Scans a NUL terminated string starting at BUF, returning a pointer to it.
    613    Returns the number of characters in the string, *including* the NUL byte,
    614    in BYTES_READ_PTR.  This value is set even if the function fails.  Bytes
    615    at or beyond BUF_END will not be read.  Returns NULL if there was a
    616    problem, or if the string is empty.  */
    617 
    618 static char *
    619 read_string (bfd *          abfd ATTRIBUTE_UNUSED,
    620 	     bfd_byte *     buf,
    621 	     bfd_byte *     buf_end,
    622 	     unsigned int * bytes_read_ptr)
    623 {
    624   bfd_byte *str = buf;
    625 
    626   if (buf >= buf_end)
    627     {
    628       * bytes_read_ptr = 0;
    629       return NULL;
    630     }
    631 
    632   if (*str == '\0')
    633     {
    634       * bytes_read_ptr = 1;
    635       return NULL;
    636     }
    637 
    638   while (buf < buf_end)
    639     if (* buf ++ == 0)
    640       {
    641 	* bytes_read_ptr = buf - str;
    642 	return (char *) str;
    643       }
    644 
    645   * bytes_read_ptr = buf - str;
    646   return NULL;
    647 }
    648 
    649 /* Reads an offset from BUF and then locates the string at this offset
    650    inside the debug string section.  Returns a pointer to the string.
    651    Returns the number of bytes read from BUF, *not* the length of the string,
    652    in BYTES_READ_PTR.  This value is set even if the function fails.  Bytes
    653    at or beyond BUF_END will not be read from BUF.  Returns NULL if there was
    654    a problem, or if the string is empty.  Does not check for NUL termination
    655    of the string.  */
    656 
    657 static char *
    658 read_indirect_string (struct comp_unit * unit,
    659 		      bfd_byte *         buf,
    660 		      bfd_byte *         buf_end,
    661 		      unsigned int *     bytes_read_ptr)
    662 {
    663   bfd_uint64_t offset;
    664   struct dwarf2_debug *stash = unit->stash;
    665   char *str;
    666 
    667   if (buf + unit->offset_size > buf_end)
    668     {
    669       * bytes_read_ptr = 0;
    670       return NULL;
    671     }
    672 
    673   if (unit->offset_size == 4)
    674     offset = read_4_bytes (unit->abfd, buf, buf_end);
    675   else
    676     offset = read_8_bytes (unit->abfd, buf, buf_end);
    677 
    678   *bytes_read_ptr = unit->offset_size;
    679 
    680   if (! read_section (unit->abfd, &stash->debug_sections[debug_str],
    681 		      stash->syms, offset,
    682 		      &stash->dwarf_str_buffer, &stash->dwarf_str_size))
    683     return NULL;
    684 
    685   if (offset >= stash->dwarf_str_size)
    686     return NULL;
    687   str = (char *) stash->dwarf_str_buffer + offset;
    688   if (*str == '\0')
    689     return NULL;
    690   return str;
    691 }
    692 
    693 /* Like read_indirect_string but uses a .debug_str located in
    694    an alternate file pointed to by the .gnu_debugaltlink section.
    695    Used to impement DW_FORM_GNU_strp_alt.  */
    696 
    697 static char *
    698 read_alt_indirect_string (struct comp_unit * unit,
    699 			  bfd_byte *         buf,
    700 			  bfd_byte *         buf_end,
    701 			  unsigned int *     bytes_read_ptr)
    702 {
    703   bfd_uint64_t offset;
    704   struct dwarf2_debug *stash = unit->stash;
    705   char *str;
    706 
    707   if (buf + unit->offset_size > buf_end)
    708     {
    709       * bytes_read_ptr = 0;
    710       return NULL;
    711     }
    712 
    713   if (unit->offset_size == 4)
    714     offset = read_4_bytes (unit->abfd, buf, buf_end);
    715   else
    716     offset = read_8_bytes (unit->abfd, buf, buf_end);
    717 
    718   *bytes_read_ptr = unit->offset_size;
    719 
    720   if (stash->alt_bfd_ptr == NULL)
    721     {
    722       bfd *  debug_bfd;
    723       char * debug_filename = bfd_follow_gnu_debugaltlink (unit->abfd, DEBUGDIR);
    724 
    725       if (debug_filename == NULL)
    726 	return NULL;
    727 
    728       if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
    729 	  || ! bfd_check_format (debug_bfd, bfd_object))
    730 	{
    731 	  if (debug_bfd)
    732 	    bfd_close (debug_bfd);
    733 
    734 	  /* FIXME: Should we report our failure to follow the debuglink ?  */
    735 	  free (debug_filename);
    736 	  return NULL;
    737 	}
    738       stash->alt_bfd_ptr = debug_bfd;
    739     }
    740 
    741   if (! read_section (unit->stash->alt_bfd_ptr,
    742 		      stash->debug_sections + debug_str_alt,
    743 		      NULL, /* FIXME: Do we need to load alternate symbols ?  */
    744 		      offset,
    745 		      &stash->alt_dwarf_str_buffer,
    746 		      &stash->alt_dwarf_str_size))
    747     return NULL;
    748 
    749   if (offset >= stash->alt_dwarf_str_size)
    750     return NULL;
    751   str = (char *) stash->alt_dwarf_str_buffer + offset;
    752   if (*str == '\0')
    753     return NULL;
    754 
    755   return str;
    756 }
    757 
    758 /* Resolve an alternate reference from UNIT at OFFSET.
    759    Returns a pointer into the loaded alternate CU upon success
    760    or NULL upon failure.  */
    761 
    762 static bfd_byte *
    763 read_alt_indirect_ref (struct comp_unit * unit,
    764 		       bfd_uint64_t       offset)
    765 {
    766   struct dwarf2_debug *stash = unit->stash;
    767 
    768   if (stash->alt_bfd_ptr == NULL)
    769     {
    770       bfd *  debug_bfd;
    771       char * debug_filename = bfd_follow_gnu_debugaltlink (unit->abfd, DEBUGDIR);
    772 
    773       if (debug_filename == NULL)
    774 	return FALSE;
    775 
    776       if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
    777 	  || ! bfd_check_format (debug_bfd, bfd_object))
    778 	{
    779 	  if (debug_bfd)
    780 	    bfd_close (debug_bfd);
    781 
    782 	  /* FIXME: Should we report our failure to follow the debuglink ?  */
    783 	  free (debug_filename);
    784 	  return NULL;
    785 	}
    786       stash->alt_bfd_ptr = debug_bfd;
    787     }
    788 
    789   if (! read_section (unit->stash->alt_bfd_ptr,
    790 		      stash->debug_sections + debug_info_alt,
    791 		      NULL, /* FIXME: Do we need to load alternate symbols ?  */
    792 		      offset,
    793 		      &stash->alt_dwarf_info_buffer,
    794 		      &stash->alt_dwarf_info_size))
    795     return NULL;
    796 
    797   if (offset >= stash->alt_dwarf_info_size)
    798     return NULL;
    799   return stash->alt_dwarf_info_buffer + offset;
    800 }
    801 
    802 static bfd_uint64_t
    803 read_address (struct comp_unit *unit, bfd_byte *buf, bfd_byte * buf_end)
    804 {
    805   int signed_vma = 0;
    806 
    807   if (bfd_get_flavour (unit->abfd) == bfd_target_elf_flavour)
    808     signed_vma = get_elf_backend_data (unit->abfd)->sign_extend_vma;
    809 
    810   if (buf + unit->addr_size > buf_end)
    811     return 0;
    812 
    813   if (signed_vma)
    814     {
    815       switch (unit->addr_size)
    816 	{
    817 	case 8:
    818 	  return bfd_get_signed_64 (unit->abfd, buf);
    819 	case 4:
    820 	  return bfd_get_signed_32 (unit->abfd, buf);
    821 	case 2:
    822 	  return bfd_get_signed_16 (unit->abfd, buf);
    823 	default:
    824 	  abort ();
    825 	}
    826     }
    827   else
    828     {
    829       switch (unit->addr_size)
    830 	{
    831 	case 8:
    832 	  return bfd_get_64 (unit->abfd, buf);
    833 	case 4:
    834 	  return bfd_get_32 (unit->abfd, buf);
    835 	case 2:
    836 	  return bfd_get_16 (unit->abfd, buf);
    837 	default:
    838 	  abort ();
    839 	}
    840     }
    841 }
    842 
    843 /* Lookup an abbrev_info structure in the abbrev hash table.  */
    844 
    845 static struct abbrev_info *
    846 lookup_abbrev (unsigned int number, struct abbrev_info **abbrevs)
    847 {
    848   unsigned int hash_number;
    849   struct abbrev_info *abbrev;
    850 
    851   hash_number = number % ABBREV_HASH_SIZE;
    852   abbrev = abbrevs[hash_number];
    853 
    854   while (abbrev)
    855     {
    856       if (abbrev->number == number)
    857 	return abbrev;
    858       else
    859 	abbrev = abbrev->next;
    860     }
    861 
    862   return NULL;
    863 }
    864 
    865 /* In DWARF version 2, the description of the debugging information is
    866    stored in a separate .debug_abbrev section.  Before we read any
    867    dies from a section we read in all abbreviations and install them
    868    in a hash table.  */
    869 
    870 static struct abbrev_info**
    871 read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
    872 {
    873   struct abbrev_info **abbrevs;
    874   bfd_byte *abbrev_ptr;
    875   bfd_byte *abbrev_end;
    876   struct abbrev_info *cur_abbrev;
    877   unsigned int abbrev_number, bytes_read, abbrev_name;
    878   unsigned int abbrev_form, hash_number;
    879   bfd_size_type amt;
    880 
    881   if (! read_section (abfd, &stash->debug_sections[debug_abbrev],
    882 		      stash->syms, offset,
    883 		      &stash->dwarf_abbrev_buffer, &stash->dwarf_abbrev_size))
    884     return NULL;
    885 
    886   if (offset >= stash->dwarf_abbrev_size)
    887     return NULL;
    888 
    889   amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
    890   abbrevs = (struct abbrev_info **) bfd_zalloc (abfd, amt);
    891   if (abbrevs == NULL)
    892     return NULL;
    893 
    894   abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
    895   abbrev_end = stash->dwarf_abbrev_buffer + stash->dwarf_abbrev_size;
    896   abbrev_number = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
    897   abbrev_ptr += bytes_read;
    898 
    899   /* Loop until we reach an abbrev number of 0.  */
    900   while (abbrev_number)
    901     {
    902       amt = sizeof (struct abbrev_info);
    903       cur_abbrev = (struct abbrev_info *) bfd_zalloc (abfd, amt);
    904       if (cur_abbrev == NULL)
    905 	return NULL;
    906 
    907       /* Read in abbrev header.  */
    908       cur_abbrev->number = abbrev_number;
    909       cur_abbrev->tag = (enum dwarf_tag)
    910 	safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
    911       abbrev_ptr += bytes_read;
    912       cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr, abbrev_end);
    913       abbrev_ptr += 1;
    914 
    915       /* Now read in declarations.  */
    916       abbrev_name = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
    917       abbrev_ptr += bytes_read;
    918       abbrev_form = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
    919       abbrev_ptr += bytes_read;
    920 
    921       while (abbrev_name)
    922 	{
    923 	  if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
    924 	    {
    925 	      struct attr_abbrev *tmp;
    926 
    927 	      amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
    928 	      amt *= sizeof (struct attr_abbrev);
    929 	      tmp = (struct attr_abbrev *) bfd_realloc (cur_abbrev->attrs, amt);
    930 	      if (tmp == NULL)
    931 		{
    932 		  size_t i;
    933 
    934 		  for (i = 0; i < ABBREV_HASH_SIZE; i++)
    935 		    {
    936 		      struct abbrev_info *abbrev = abbrevs[i];
    937 
    938 		      while (abbrev)
    939 			{
    940 			  free (abbrev->attrs);
    941 			  abbrev = abbrev->next;
    942 			}
    943 		    }
    944 		  return NULL;
    945 		}
    946 	      cur_abbrev->attrs = tmp;
    947 	    }
    948 
    949 	  cur_abbrev->attrs[cur_abbrev->num_attrs].name
    950 	    = (enum dwarf_attribute) abbrev_name;
    951 	  cur_abbrev->attrs[cur_abbrev->num_attrs++].form
    952 	    = (enum dwarf_form) abbrev_form;
    953 	  abbrev_name = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
    954 	  abbrev_ptr += bytes_read;
    955 	  abbrev_form = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
    956 	  abbrev_ptr += bytes_read;
    957 	}
    958 
    959       hash_number = abbrev_number % ABBREV_HASH_SIZE;
    960       cur_abbrev->next = abbrevs[hash_number];
    961       abbrevs[hash_number] = cur_abbrev;
    962 
    963       /* Get next abbreviation.
    964 	 Under Irix6 the abbreviations for a compilation unit are not
    965 	 always properly terminated with an abbrev number of 0.
    966 	 Exit loop if we encounter an abbreviation which we have
    967 	 already read (which means we are about to read the abbreviations
    968 	 for the next compile unit) or if the end of the abbreviation
    969 	 table is reached.  */
    970       if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
    971 	  >= stash->dwarf_abbrev_size)
    972 	break;
    973       abbrev_number = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
    974       abbrev_ptr += bytes_read;
    975       if (lookup_abbrev (abbrev_number, abbrevs) != NULL)
    976 	break;
    977     }
    978 
    979   return abbrevs;
    980 }
    981 
    982 /* Returns true if the form is one which has a string value.  */
    983 
    984 static inline bfd_boolean
    985 is_str_attr (enum dwarf_form form)
    986 {
    987   return form == DW_FORM_string || form == DW_FORM_strp || form == DW_FORM_GNU_strp_alt;
    988 }
    989 
    990 /* Read and fill in the value of attribute ATTR as described by FORM.
    991    Read data starting from INFO_PTR, but never at or beyond INFO_PTR_END.
    992    Returns an updated INFO_PTR taking into account the amount of data read.  */
    993 
    994 static bfd_byte *
    995 read_attribute_value (struct attribute *  attr,
    996 		      unsigned            form,
    997 		      struct comp_unit *  unit,
    998 		      bfd_byte *          info_ptr,
    999 		      bfd_byte *          info_ptr_end)
   1000 {
   1001   bfd *abfd = unit->abfd;
   1002   unsigned int bytes_read;
   1003   struct dwarf_block *blk;
   1004   bfd_size_type amt;
   1005 
   1006   if (info_ptr >= info_ptr_end && form != DW_FORM_flag_present)
   1007     {
   1008       (*_bfd_error_handler) (_("Dwarf Error: Info pointer extends beyond end of attributes"));
   1009       bfd_set_error (bfd_error_bad_value);
   1010       return info_ptr;
   1011     }
   1012 
   1013   attr->form = (enum dwarf_form) form;
   1014 
   1015   switch (form)
   1016     {
   1017     case DW_FORM_ref_addr:
   1018       /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
   1019 	 DWARF3.  */
   1020       if (unit->version == 3 || unit->version == 4)
   1021 	{
   1022 	  if (unit->offset_size == 4)
   1023 	    attr->u.val = read_4_bytes (unit->abfd, info_ptr, info_ptr_end);
   1024 	  else
   1025 	    attr->u.val = read_8_bytes (unit->abfd, info_ptr, info_ptr_end);
   1026 	  info_ptr += unit->offset_size;
   1027 	  break;
   1028 	}
   1029       /* FALLTHROUGH */
   1030     case DW_FORM_addr:
   1031       attr->u.val = read_address (unit, info_ptr, info_ptr_end);
   1032       info_ptr += unit->addr_size;
   1033       break;
   1034     case DW_FORM_GNU_ref_alt:
   1035     case DW_FORM_sec_offset:
   1036       if (unit->offset_size == 4)
   1037 	attr->u.val = read_4_bytes (unit->abfd, info_ptr, info_ptr_end);
   1038       else
   1039 	attr->u.val = read_8_bytes (unit->abfd, info_ptr, info_ptr_end);
   1040       info_ptr += unit->offset_size;
   1041       break;
   1042     case DW_FORM_block2:
   1043       amt = sizeof (struct dwarf_block);
   1044       blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
   1045       if (blk == NULL)
   1046 	return NULL;
   1047       blk->size = read_2_bytes (abfd, info_ptr, info_ptr_end);
   1048       info_ptr += 2;
   1049       blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
   1050       info_ptr += blk->size;
   1051       attr->u.blk = blk;
   1052       break;
   1053     case DW_FORM_block4:
   1054       amt = sizeof (struct dwarf_block);
   1055       blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
   1056       if (blk == NULL)
   1057 	return NULL;
   1058       blk->size = read_4_bytes (abfd, info_ptr, info_ptr_end);
   1059       info_ptr += 4;
   1060       blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
   1061       info_ptr += blk->size;
   1062       attr->u.blk = blk;
   1063       break;
   1064     case DW_FORM_data2:
   1065       attr->u.val = read_2_bytes (abfd, info_ptr, info_ptr_end);
   1066       info_ptr += 2;
   1067       break;
   1068     case DW_FORM_data4:
   1069       attr->u.val = read_4_bytes (abfd, info_ptr, info_ptr_end);
   1070       info_ptr += 4;
   1071       break;
   1072     case DW_FORM_data8:
   1073       attr->u.val = read_8_bytes (abfd, info_ptr, info_ptr_end);
   1074       info_ptr += 8;
   1075       break;
   1076     case DW_FORM_string:
   1077       attr->u.str = read_string (abfd, info_ptr, info_ptr_end, &bytes_read);
   1078       info_ptr += bytes_read;
   1079       break;
   1080     case DW_FORM_strp:
   1081       attr->u.str = read_indirect_string (unit, info_ptr, info_ptr_end, &bytes_read);
   1082       info_ptr += bytes_read;
   1083       break;
   1084     case DW_FORM_GNU_strp_alt:
   1085       attr->u.str = read_alt_indirect_string (unit, info_ptr, info_ptr_end, &bytes_read);
   1086       info_ptr += bytes_read;
   1087       break;
   1088     case DW_FORM_exprloc:
   1089     case DW_FORM_block:
   1090       amt = sizeof (struct dwarf_block);
   1091       blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
   1092       if (blk == NULL)
   1093 	return NULL;
   1094       blk->size = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
   1095       info_ptr += bytes_read;
   1096       blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
   1097       info_ptr += blk->size;
   1098       attr->u.blk = blk;
   1099       break;
   1100     case DW_FORM_block1:
   1101       amt = sizeof (struct dwarf_block);
   1102       blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
   1103       if (blk == NULL)
   1104 	return NULL;
   1105       blk->size = read_1_byte (abfd, info_ptr, info_ptr_end);
   1106       info_ptr += 1;
   1107       blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
   1108       info_ptr += blk->size;
   1109       attr->u.blk = blk;
   1110       break;
   1111     case DW_FORM_data1:
   1112       attr->u.val = read_1_byte (abfd, info_ptr, info_ptr_end);
   1113       info_ptr += 1;
   1114       break;
   1115     case DW_FORM_flag:
   1116       attr->u.val = read_1_byte (abfd, info_ptr, info_ptr_end);
   1117       info_ptr += 1;
   1118       break;
   1119     case DW_FORM_flag_present:
   1120       attr->u.val = 1;
   1121       break;
   1122     case DW_FORM_sdata:
   1123       attr->u.sval = safe_read_leb128 (abfd, info_ptr, &bytes_read, TRUE, info_ptr_end);
   1124       info_ptr += bytes_read;
   1125       break;
   1126     case DW_FORM_udata:
   1127       attr->u.val = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
   1128       info_ptr += bytes_read;
   1129       break;
   1130     case DW_FORM_ref1:
   1131       attr->u.val = read_1_byte (abfd, info_ptr, info_ptr_end);
   1132       info_ptr += 1;
   1133       break;
   1134     case DW_FORM_ref2:
   1135       attr->u.val = read_2_bytes (abfd, info_ptr, info_ptr_end);
   1136       info_ptr += 2;
   1137       break;
   1138     case DW_FORM_ref4:
   1139       attr->u.val = read_4_bytes (abfd, info_ptr, info_ptr_end);
   1140       info_ptr += 4;
   1141       break;
   1142     case DW_FORM_ref8:
   1143       attr->u.val = read_8_bytes (abfd, info_ptr, info_ptr_end);
   1144       info_ptr += 8;
   1145       break;
   1146     case DW_FORM_ref_sig8:
   1147       attr->u.val = read_8_bytes (abfd, info_ptr, info_ptr_end);
   1148       info_ptr += 8;
   1149       break;
   1150     case DW_FORM_ref_udata:
   1151       attr->u.val = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
   1152       info_ptr += bytes_read;
   1153       break;
   1154     case DW_FORM_indirect:
   1155       form = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
   1156       info_ptr += bytes_read;
   1157       info_ptr = read_attribute_value (attr, form, unit, info_ptr, info_ptr_end);
   1158       break;
   1159     default:
   1160       (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %#x."),
   1161 			     form);
   1162       bfd_set_error (bfd_error_bad_value);
   1163       return NULL;
   1164     }
   1165   return info_ptr;
   1166 }
   1167 
   1168 /* Read an attribute described by an abbreviated attribute.  */
   1169 
   1170 static bfd_byte *
   1171 read_attribute (struct attribute *    attr,
   1172 		struct attr_abbrev *  abbrev,
   1173 		struct comp_unit *    unit,
   1174 		bfd_byte *            info_ptr,
   1175 		bfd_byte *            info_ptr_end)
   1176 {
   1177   attr->name = abbrev->name;
   1178   info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr, info_ptr_end);
   1179   return info_ptr;
   1180 }
   1181 
   1182 /* Return whether DW_AT_name will return the same as DW_AT_linkage_name
   1183    for a function.  */
   1184 
   1185 static bfd_boolean
   1186 non_mangled (int lang)
   1187 {
   1188   switch (lang)
   1189     {
   1190     default:
   1191       return FALSE;
   1192 
   1193     case DW_LANG_C89:
   1194     case DW_LANG_C:
   1195     case DW_LANG_Ada83:
   1196     case DW_LANG_Cobol74:
   1197     case DW_LANG_Cobol85:
   1198     case DW_LANG_Fortran77:
   1199     case DW_LANG_Pascal83:
   1200     case DW_LANG_C99:
   1201     case DW_LANG_Ada95:
   1202     case DW_LANG_PLI:
   1203     case DW_LANG_UPC:
   1204     case DW_LANG_C11:
   1205       return TRUE;
   1206     }
   1207 }
   1208 
   1209 /* Source line information table routines.  */
   1210 
   1211 #define FILE_ALLOC_CHUNK 5
   1212 #define DIR_ALLOC_CHUNK 5
   1213 
   1214 struct line_info
   1215 {
   1216   struct line_info* prev_line;
   1217   bfd_vma address;
   1218   char *filename;
   1219   unsigned int line;
   1220   unsigned int column;
   1221   unsigned int discriminator;
   1222   unsigned char op_index;
   1223   unsigned char end_sequence;		/* End of (sequential) code sequence.  */
   1224 };
   1225 
   1226 struct fileinfo
   1227 {
   1228   char *name;
   1229   unsigned int dir;
   1230   unsigned int time;
   1231   unsigned int size;
   1232 };
   1233 
   1234 struct line_sequence
   1235 {
   1236   bfd_vma               low_pc;
   1237   struct line_sequence* prev_sequence;
   1238   struct line_info*     last_line;  /* Largest VMA.  */
   1239 };
   1240 
   1241 struct line_info_table
   1242 {
   1243   bfd*                  abfd;
   1244   unsigned int          num_files;
   1245   unsigned int          num_dirs;
   1246   unsigned int          num_sequences;
   1247   char *                comp_dir;
   1248   char **               dirs;
   1249   struct fileinfo*      files;
   1250   struct line_sequence* sequences;
   1251   struct line_info*     lcl_head;   /* Local head; used in 'add_line_info'.  */
   1252 };
   1253 
   1254 /* Remember some information about each function.  If the function is
   1255    inlined (DW_TAG_inlined_subroutine) it may have two additional
   1256    attributes, DW_AT_call_file and DW_AT_call_line, which specify the
   1257    source code location where this function was inlined.  */
   1258 
   1259 struct funcinfo
   1260 {
   1261   /* Pointer to previous function in list of all functions.  */
   1262   struct funcinfo *prev_func;
   1263   /* Pointer to function one scope higher.  */
   1264   struct funcinfo *caller_func;
   1265   /* Source location file name where caller_func inlines this func.  */
   1266   char *caller_file;
   1267   /* Source location file name.  */
   1268   char *file;
   1269   /* Source location line number where caller_func inlines this func.  */
   1270   int caller_line;
   1271   /* Source location line number.  */
   1272   int line;
   1273   int tag;
   1274   bfd_boolean is_linkage;
   1275   const char *name;
   1276   struct arange arange;
   1277   /* Where the symbol is defined.  */
   1278   asection *sec;
   1279 };
   1280 
   1281 struct varinfo
   1282 {
   1283   /* Pointer to previous variable in list of all variables */
   1284   struct varinfo *prev_var;
   1285   /* Source location file name */
   1286   char *file;
   1287   /* Source location line number */
   1288   int line;
   1289   int tag;
   1290   char *name;
   1291   bfd_vma addr;
   1292   /* Where the symbol is defined */
   1293   asection *sec;
   1294   /* Is this a stack variable? */
   1295   unsigned int stack: 1;
   1296 };
   1297 
   1298 /* Return TRUE if NEW_LINE should sort after LINE.  */
   1299 
   1300 static inline bfd_boolean
   1301 new_line_sorts_after (struct line_info *new_line, struct line_info *line)
   1302 {
   1303   return (new_line->address > line->address
   1304 	  || (new_line->address == line->address
   1305 	      && (new_line->op_index > line->op_index
   1306 		  || (new_line->op_index == line->op_index
   1307 		      && new_line->end_sequence < line->end_sequence))));
   1308 }
   1309 
   1310 
   1311 /* Adds a new entry to the line_info list in the line_info_table, ensuring
   1312    that the list is sorted.  Note that the line_info list is sorted from
   1313    highest to lowest VMA (with possible duplicates); that is,
   1314    line_info->prev_line always accesses an equal or smaller VMA.  */
   1315 
   1316 static bfd_boolean
   1317 add_line_info (struct line_info_table *table,
   1318 	       bfd_vma address,
   1319 	       unsigned char op_index,
   1320 	       char *filename,
   1321 	       unsigned int line,
   1322 	       unsigned int column,
   1323 	       unsigned int discriminator,
   1324 	       int end_sequence)
   1325 {
   1326   bfd_size_type amt = sizeof (struct line_info);
   1327   struct line_sequence* seq = table->sequences;
   1328   struct line_info* info = (struct line_info *) bfd_alloc (table->abfd, amt);
   1329 
   1330   if (info == NULL)
   1331     return FALSE;
   1332 
   1333   /* Set member data of 'info'.  */
   1334   info->prev_line = NULL;
   1335   info->address = address;
   1336   info->op_index = op_index;
   1337   info->line = line;
   1338   info->column = column;
   1339   info->discriminator = discriminator;
   1340   info->end_sequence = end_sequence;
   1341 
   1342   if (filename && filename[0])
   1343     {
   1344       info->filename = (char *) bfd_alloc (table->abfd, strlen (filename) + 1);
   1345       if (info->filename == NULL)
   1346 	return FALSE;
   1347       strcpy (info->filename, filename);
   1348     }
   1349   else
   1350     info->filename = NULL;
   1351 
   1352   /* Find the correct location for 'info'.  Normally we will receive
   1353      new line_info data 1) in order and 2) with increasing VMAs.
   1354      However some compilers break the rules (cf. decode_line_info) and
   1355      so we include some heuristics for quickly finding the correct
   1356      location for 'info'. In particular, these heuristics optimize for
   1357      the common case in which the VMA sequence that we receive is a
   1358      list of locally sorted VMAs such as
   1359        p...z a...j  (where a < j < p < z)
   1360 
   1361      Note: table->lcl_head is used to head an *actual* or *possible*
   1362      sub-sequence within the list (such as a...j) that is not directly
   1363      headed by table->last_line
   1364 
   1365      Note: we may receive duplicate entries from 'decode_line_info'.  */
   1366 
   1367   if (seq
   1368       && seq->last_line->address == address
   1369       && seq->last_line->op_index == op_index
   1370       && seq->last_line->end_sequence == end_sequence)
   1371     {
   1372       /* We only keep the last entry with the same address and end
   1373 	 sequence.  See PR ld/4986.  */
   1374       if (table->lcl_head == seq->last_line)
   1375 	table->lcl_head = info;
   1376       info->prev_line = seq->last_line->prev_line;
   1377       seq->last_line = info;
   1378     }
   1379   else if (!seq || seq->last_line->end_sequence)
   1380     {
   1381       /* Start a new line sequence.  */
   1382       amt = sizeof (struct line_sequence);
   1383       seq = (struct line_sequence *) bfd_malloc (amt);
   1384       if (seq == NULL)
   1385 	return FALSE;
   1386       seq->low_pc = address;
   1387       seq->prev_sequence = table->sequences;
   1388       seq->last_line = info;
   1389       table->lcl_head = info;
   1390       table->sequences = seq;
   1391       table->num_sequences++;
   1392     }
   1393   else if (new_line_sorts_after (info, seq->last_line))
   1394     {
   1395       /* Normal case: add 'info' to the beginning of the current sequence.  */
   1396       info->prev_line = seq->last_line;
   1397       seq->last_line = info;
   1398 
   1399       /* lcl_head: initialize to head a *possible* sequence at the end.  */
   1400       if (!table->lcl_head)
   1401 	table->lcl_head = info;
   1402     }
   1403   else if (!new_line_sorts_after (info, table->lcl_head)
   1404 	   && (!table->lcl_head->prev_line
   1405 	       || new_line_sorts_after (info, table->lcl_head->prev_line)))
   1406     {
   1407       /* Abnormal but easy: lcl_head is the head of 'info'.  */
   1408       info->prev_line = table->lcl_head->prev_line;
   1409       table->lcl_head->prev_line = info;
   1410     }
   1411   else
   1412     {
   1413       /* Abnormal and hard: Neither 'last_line' nor 'lcl_head'
   1414 	 are valid heads for 'info'.  Reset 'lcl_head'.  */
   1415       struct line_info* li2 = seq->last_line; /* Always non-NULL.  */
   1416       struct line_info* li1 = li2->prev_line;
   1417 
   1418       while (li1)
   1419 	{
   1420 	  if (!new_line_sorts_after (info, li2)
   1421 	      && new_line_sorts_after (info, li1))
   1422 	    break;
   1423 
   1424 	  li2 = li1; /* always non-NULL */
   1425 	  li1 = li1->prev_line;
   1426 	}
   1427       table->lcl_head = li2;
   1428       info->prev_line = table->lcl_head->prev_line;
   1429       table->lcl_head->prev_line = info;
   1430       if (address < seq->low_pc)
   1431 	seq->low_pc = address;
   1432     }
   1433   return TRUE;
   1434 }
   1435 
   1436 /* Extract a fully qualified filename from a line info table.
   1437    The returned string has been malloc'ed and it is the caller's
   1438    responsibility to free it.  */
   1439 
   1440 static char *
   1441 concat_filename (struct line_info_table *table, unsigned int file)
   1442 {
   1443   char *filename;
   1444 
   1445   if (file - 1 >= table->num_files)
   1446     {
   1447       /* FILE == 0 means unknown.  */
   1448       if (file)
   1449 	(*_bfd_error_handler)
   1450 	  (_("Dwarf Error: mangled line number section (bad file number)."));
   1451       return strdup ("<unknown>");
   1452     }
   1453 
   1454   filename = table->files[file - 1].name;
   1455 
   1456   if (!IS_ABSOLUTE_PATH (filename))
   1457     {
   1458       char *dir_name = NULL;
   1459       char *subdir_name = NULL;
   1460       char *name;
   1461       size_t len;
   1462 
   1463       if (table->files[file - 1].dir
   1464 	  /* PR 17512: file: 0317e960.  */
   1465 	  && table->files[file - 1].dir <= table->num_dirs
   1466 	  /* PR 17512: file: 7f3d2e4b.  */
   1467 	  && table->dirs != NULL)
   1468 	subdir_name = table->dirs[table->files[file - 1].dir - 1];
   1469 
   1470       if (!subdir_name || !IS_ABSOLUTE_PATH (subdir_name))
   1471 	dir_name = table->comp_dir;
   1472 
   1473       if (!dir_name)
   1474 	{
   1475 	  dir_name = subdir_name;
   1476 	  subdir_name = NULL;
   1477 	}
   1478 
   1479       if (!dir_name)
   1480 	return strdup (filename);
   1481 
   1482       len = strlen (dir_name) + strlen (filename) + 2;
   1483 
   1484       if (subdir_name)
   1485 	{
   1486 	  len += strlen (subdir_name) + 1;
   1487 	  name = (char *) bfd_malloc (len);
   1488 	  if (name)
   1489 	    sprintf (name, "%s/%s/%s", dir_name, subdir_name, filename);
   1490 	}
   1491       else
   1492 	{
   1493 	  name = (char *) bfd_malloc (len);
   1494 	  if (name)
   1495 	    sprintf (name, "%s/%s", dir_name, filename);
   1496 	}
   1497 
   1498       return name;
   1499     }
   1500 
   1501   return strdup (filename);
   1502 }
   1503 
   1504 static bfd_boolean
   1505 arange_add (const struct comp_unit *unit, struct arange *first_arange,
   1506 	    bfd_vma low_pc, bfd_vma high_pc)
   1507 {
   1508   struct arange *arange;
   1509 
   1510   /* Ignore empty ranges.  */
   1511   if (low_pc == high_pc)
   1512     return TRUE;
   1513 
   1514   /* If the first arange is empty, use it.  */
   1515   if (first_arange->high == 0)
   1516     {
   1517       first_arange->low = low_pc;
   1518       first_arange->high = high_pc;
   1519       return TRUE;
   1520     }
   1521 
   1522   /* Next see if we can cheaply extend an existing range.  */
   1523   arange = first_arange;
   1524   do
   1525     {
   1526       if (low_pc == arange->high)
   1527 	{
   1528 	  arange->high = high_pc;
   1529 	  return TRUE;
   1530 	}
   1531       if (high_pc == arange->low)
   1532 	{
   1533 	  arange->low = low_pc;
   1534 	  return TRUE;
   1535 	}
   1536       arange = arange->next;
   1537     }
   1538   while (arange);
   1539 
   1540   /* Need to allocate a new arange and insert it into the arange list.
   1541      Order isn't significant, so just insert after the first arange. */
   1542   arange = (struct arange *) bfd_alloc (unit->abfd, sizeof (*arange));
   1543   if (arange == NULL)
   1544     return FALSE;
   1545   arange->low = low_pc;
   1546   arange->high = high_pc;
   1547   arange->next = first_arange->next;
   1548   first_arange->next = arange;
   1549   return TRUE;
   1550 }
   1551 
   1552 /* Compare function for line sequences.  */
   1553 
   1554 static int
   1555 compare_sequences (const void* a, const void* b)
   1556 {
   1557   const struct line_sequence* seq1 = a;
   1558   const struct line_sequence* seq2 = b;
   1559 
   1560   /* Sort by low_pc as the primary key.  */
   1561   if (seq1->low_pc < seq2->low_pc)
   1562     return -1;
   1563   if (seq1->low_pc > seq2->low_pc)
   1564     return 1;
   1565 
   1566   /* If low_pc values are equal, sort in reverse order of
   1567      high_pc, so that the largest region comes first.  */
   1568   if (seq1->last_line->address < seq2->last_line->address)
   1569     return 1;
   1570   if (seq1->last_line->address > seq2->last_line->address)
   1571     return -1;
   1572 
   1573   if (seq1->last_line->op_index < seq2->last_line->op_index)
   1574     return 1;
   1575   if (seq1->last_line->op_index > seq2->last_line->op_index)
   1576     return -1;
   1577 
   1578   return 0;
   1579 }
   1580 
   1581 /* Sort the line sequences for quick lookup.  */
   1582 
   1583 static bfd_boolean
   1584 sort_line_sequences (struct line_info_table* table)
   1585 {
   1586   bfd_size_type amt;
   1587   struct line_sequence* sequences;
   1588   struct line_sequence* seq;
   1589   unsigned int n = 0;
   1590   unsigned int num_sequences = table->num_sequences;
   1591   bfd_vma last_high_pc;
   1592 
   1593   if (num_sequences == 0)
   1594     return TRUE;
   1595 
   1596   /* Allocate space for an array of sequences.  */
   1597   amt = sizeof (struct line_sequence) * num_sequences;
   1598   sequences = (struct line_sequence *) bfd_alloc (table->abfd, amt);
   1599   if (sequences == NULL)
   1600     return FALSE;
   1601 
   1602   /* Copy the linked list into the array, freeing the original nodes.  */
   1603   seq = table->sequences;
   1604   for (n = 0; n < num_sequences; n++)
   1605     {
   1606       struct line_sequence* last_seq = seq;
   1607 
   1608       BFD_ASSERT (seq);
   1609       sequences[n].low_pc = seq->low_pc;
   1610       sequences[n].prev_sequence = NULL;
   1611       sequences[n].last_line = seq->last_line;
   1612       seq = seq->prev_sequence;
   1613       free (last_seq);
   1614     }
   1615   BFD_ASSERT (seq == NULL);
   1616 
   1617   qsort (sequences, n, sizeof (struct line_sequence), compare_sequences);
   1618 
   1619   /* Make the list binary-searchable by trimming overlapping entries
   1620      and removing nested entries.  */
   1621   num_sequences = 1;
   1622   last_high_pc = sequences[0].last_line->address;
   1623   for (n = 1; n < table->num_sequences; n++)
   1624     {
   1625       if (sequences[n].low_pc < last_high_pc)
   1626 	{
   1627 	  if (sequences[n].last_line->address <= last_high_pc)
   1628 	    /* Skip nested entries.  */
   1629 	    continue;
   1630 
   1631 	  /* Trim overlapping entries.  */
   1632 	  sequences[n].low_pc = last_high_pc;
   1633 	}
   1634       last_high_pc = sequences[n].last_line->address;
   1635       if (n > num_sequences)
   1636 	{
   1637 	  /* Close up the gap.  */
   1638 	  sequences[num_sequences].low_pc = sequences[n].low_pc;
   1639 	  sequences[num_sequences].last_line = sequences[n].last_line;
   1640 	}
   1641       num_sequences++;
   1642     }
   1643 
   1644   table->sequences = sequences;
   1645   table->num_sequences = num_sequences;
   1646   return TRUE;
   1647 }
   1648 
   1649 /* Decode the line number information for UNIT.  */
   1650 
   1651 static struct line_info_table*
   1652 decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
   1653 {
   1654   bfd *abfd = unit->abfd;
   1655   struct line_info_table* table;
   1656   bfd_byte *line_ptr;
   1657   bfd_byte *line_end;
   1658   struct line_head lh;
   1659   unsigned int i, bytes_read, offset_size;
   1660   char *cur_file, *cur_dir;
   1661   unsigned char op_code, extended_op, adj_opcode;
   1662   unsigned int exop_len;
   1663   bfd_size_type amt;
   1664 
   1665   if (! read_section (abfd, &stash->debug_sections[debug_line],
   1666 		      stash->syms, unit->line_offset,
   1667 		      &stash->dwarf_line_buffer, &stash->dwarf_line_size))
   1668     return NULL;
   1669 
   1670   amt = sizeof (struct line_info_table);
   1671   table = (struct line_info_table *) bfd_alloc (abfd, amt);
   1672   if (table == NULL)
   1673     return NULL;
   1674   table->abfd = abfd;
   1675   table->comp_dir = unit->comp_dir;
   1676 
   1677   table->num_files = 0;
   1678   table->files = NULL;
   1679 
   1680   table->num_dirs = 0;
   1681   table->dirs = NULL;
   1682 
   1683   table->num_sequences = 0;
   1684   table->sequences = NULL;
   1685 
   1686   table->lcl_head = NULL;
   1687 
   1688   if (stash->dwarf_line_size < 16)
   1689     {
   1690       (*_bfd_error_handler)
   1691 	(_("Dwarf Error: Line info section is too small (%ld)"),
   1692 	 (long) stash->dwarf_line_size);
   1693       bfd_set_error (bfd_error_bad_value);
   1694       return NULL;
   1695     }
   1696   line_ptr = stash->dwarf_line_buffer + unit->line_offset;
   1697   line_end = stash->dwarf_line_buffer + stash->dwarf_line_size;
   1698 
   1699   /* Read in the prologue.  */
   1700   lh.total_length = read_4_bytes (abfd, line_ptr, line_end);
   1701   line_ptr += 4;
   1702   offset_size = 4;
   1703   if (lh.total_length == 0xffffffff)
   1704     {
   1705       lh.total_length = read_8_bytes (abfd, line_ptr, line_end);
   1706       line_ptr += 8;
   1707       offset_size = 8;
   1708     }
   1709   else if (lh.total_length == 0 && unit->addr_size == 8)
   1710     {
   1711       /* Handle (non-standard) 64-bit DWARF2 formats.  */
   1712       lh.total_length = read_4_bytes (abfd, line_ptr, line_end);
   1713       line_ptr += 4;
   1714       offset_size = 8;
   1715     }
   1716 
   1717   if (lh.total_length > stash->dwarf_line_size)
   1718     {
   1719       (*_bfd_error_handler)
   1720 	(_("Dwarf Error: Line info data is bigger (0x%lx) than the section (0x%lx)"),
   1721 	 (long) lh.total_length, (long) stash->dwarf_line_size);
   1722       bfd_set_error (bfd_error_bad_value);
   1723       return NULL;
   1724     }
   1725 
   1726   line_end = line_ptr + lh.total_length;
   1727 
   1728   lh.version = read_2_bytes (abfd, line_ptr, line_end);
   1729   if (lh.version < 2 || lh.version > 4)
   1730     {
   1731       (*_bfd_error_handler)
   1732 	(_("Dwarf Error: Unhandled .debug_line version %d."), lh.version);
   1733       bfd_set_error (bfd_error_bad_value);
   1734       return NULL;
   1735     }
   1736   line_ptr += 2;
   1737 
   1738   if (line_ptr + offset_size + (lh.version >=4 ? 6 : 5) >= line_end)
   1739     {
   1740       (*_bfd_error_handler)
   1741 	(_("Dwarf Error: Ran out of room reading prologue"));
   1742       bfd_set_error (bfd_error_bad_value);
   1743       return NULL;
   1744     }
   1745 
   1746   if (offset_size == 4)
   1747     lh.prologue_length = read_4_bytes (abfd, line_ptr, line_end);
   1748   else
   1749     lh.prologue_length = read_8_bytes (abfd, line_ptr, line_end);
   1750   line_ptr += offset_size;
   1751 
   1752   lh.minimum_instruction_length = read_1_byte (abfd, line_ptr, line_end);
   1753   line_ptr += 1;
   1754 
   1755   if (lh.version >= 4)
   1756     {
   1757       lh.maximum_ops_per_insn = read_1_byte (abfd, line_ptr, line_end);
   1758       line_ptr += 1;
   1759     }
   1760   else
   1761     lh.maximum_ops_per_insn = 1;
   1762 
   1763   if (lh.maximum_ops_per_insn == 0)
   1764     {
   1765       (*_bfd_error_handler)
   1766 	(_("Dwarf Error: Invalid maximum operations per instruction."));
   1767       bfd_set_error (bfd_error_bad_value);
   1768       return NULL;
   1769     }
   1770 
   1771   lh.default_is_stmt = read_1_byte (abfd, line_ptr, line_end);
   1772   line_ptr += 1;
   1773 
   1774   lh.line_base = read_1_signed_byte (abfd, line_ptr, line_end);
   1775   line_ptr += 1;
   1776 
   1777   lh.line_range = read_1_byte (abfd, line_ptr, line_end);
   1778   line_ptr += 1;
   1779 
   1780   lh.opcode_base = read_1_byte (abfd, line_ptr, line_end);
   1781   line_ptr += 1;
   1782 
   1783   if (line_ptr + (lh.opcode_base - 1) >= line_end)
   1784     {
   1785       (*_bfd_error_handler) (_("Dwarf Error: Ran out of room reading opcodes"));
   1786       bfd_set_error (bfd_error_bad_value);
   1787       return NULL;
   1788     }
   1789 
   1790   amt = lh.opcode_base * sizeof (unsigned char);
   1791   lh.standard_opcode_lengths = (unsigned char *) bfd_alloc (abfd, amt);
   1792 
   1793   lh.standard_opcode_lengths[0] = 1;
   1794 
   1795   for (i = 1; i < lh.opcode_base; ++i)
   1796     {
   1797       lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr, line_end);
   1798       line_ptr += 1;
   1799     }
   1800 
   1801   /* Read directory table.  */
   1802   while ((cur_dir = read_string (abfd, line_ptr, line_end, &bytes_read)) != NULL)
   1803     {
   1804       line_ptr += bytes_read;
   1805 
   1806       if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
   1807 	{
   1808 	  char **tmp;
   1809 
   1810 	  amt = table->num_dirs + DIR_ALLOC_CHUNK;
   1811 	  amt *= sizeof (char *);
   1812 
   1813 	  tmp = (char **) bfd_realloc (table->dirs, amt);
   1814 	  if (tmp == NULL)
   1815 	    goto fail;
   1816 	  table->dirs = tmp;
   1817 	}
   1818 
   1819       table->dirs[table->num_dirs++] = cur_dir;
   1820     }
   1821 
   1822   line_ptr += bytes_read;
   1823 
   1824   /* Read file name table.  */
   1825   while ((cur_file = read_string (abfd, line_ptr, line_end, &bytes_read)) != NULL)
   1826     {
   1827       line_ptr += bytes_read;
   1828 
   1829       if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
   1830 	{
   1831 	  struct fileinfo *tmp;
   1832 
   1833 	  amt = table->num_files + FILE_ALLOC_CHUNK;
   1834 	  amt *= sizeof (struct fileinfo);
   1835 
   1836 	  tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
   1837 	  if (tmp == NULL)
   1838 	    goto fail;
   1839 	  table->files = tmp;
   1840 	}
   1841 
   1842       table->files[table->num_files].name = cur_file;
   1843       table->files[table->num_files].dir =
   1844 	safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
   1845       line_ptr += bytes_read;
   1846       table->files[table->num_files].time = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
   1847       line_ptr += bytes_read;
   1848       table->files[table->num_files].size = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
   1849       line_ptr += bytes_read;
   1850       table->num_files++;
   1851     }
   1852 
   1853   line_ptr += bytes_read;
   1854 
   1855   /* Read the statement sequences until there's nothing left.  */
   1856   while (line_ptr < line_end)
   1857     {
   1858       /* State machine registers.  */
   1859       bfd_vma address = 0;
   1860       unsigned char op_index = 0;
   1861       char * filename = table->num_files ? concat_filename (table, 1) : NULL;
   1862       unsigned int line = 1;
   1863       unsigned int column = 0;
   1864       unsigned int discriminator = 0;
   1865       int is_stmt = lh.default_is_stmt;
   1866       int end_sequence = 0;
   1867       /* eraxxon (at) alumni.rice.edu: Against the DWARF2 specs, some
   1868 	 compilers generate address sequences that are wildly out of
   1869 	 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
   1870 	 for ia64-Linux).  Thus, to determine the low and high
   1871 	 address, we must compare on every DW_LNS_copy, etc.  */
   1872       bfd_vma low_pc  = (bfd_vma) -1;
   1873       bfd_vma high_pc = 0;
   1874 
   1875       /* Decode the table.  */
   1876       while (! end_sequence)
   1877 	{
   1878 	  op_code = read_1_byte (abfd, line_ptr, line_end);
   1879 	  line_ptr += 1;
   1880 
   1881 	  if (op_code >= lh.opcode_base)
   1882 	    {
   1883 	      /* Special operand.  */
   1884 	      adj_opcode = op_code - lh.opcode_base;
   1885 	      if (lh.line_range == 0)
   1886 		goto line_fail;
   1887 	      if (lh.maximum_ops_per_insn == 1)
   1888 		address += (adj_opcode / lh.line_range
   1889 			    * lh.minimum_instruction_length);
   1890 	      else
   1891 		{
   1892 		  address += ((op_index + adj_opcode / lh.line_range)
   1893 			      / lh.maximum_ops_per_insn
   1894 			      * lh.minimum_instruction_length);
   1895 		  op_index = ((op_index + adj_opcode / lh.line_range)
   1896 			      % lh.maximum_ops_per_insn);
   1897 		}
   1898 	      line += lh.line_base + (adj_opcode % lh.line_range);
   1899 	      /* Append row to matrix using current values.  */
   1900 	      if (!add_line_info (table, address, op_index, filename,
   1901 				  line, column, discriminator, 0))
   1902 		goto line_fail;
   1903 	      discriminator = 0;
   1904 	      if (address < low_pc)
   1905 		low_pc = address;
   1906 	      if (address > high_pc)
   1907 		high_pc = address;
   1908 	    }
   1909 	  else switch (op_code)
   1910 	    {
   1911 	    case DW_LNS_extended_op:
   1912 	      exop_len = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
   1913 	      line_ptr += bytes_read;
   1914 	      extended_op = read_1_byte (abfd, line_ptr, line_end);
   1915 	      line_ptr += 1;
   1916 
   1917 	      switch (extended_op)
   1918 		{
   1919 		case DW_LNE_end_sequence:
   1920 		  end_sequence = 1;
   1921 		  if (!add_line_info (table, address, op_index, filename, line,
   1922 				      column, discriminator, end_sequence))
   1923 		    goto line_fail;
   1924 		  discriminator = 0;
   1925 		  if (address < low_pc)
   1926 		    low_pc = address;
   1927 		  if (address > high_pc)
   1928 		    high_pc = address;
   1929 		  if (!arange_add (unit, &unit->arange, low_pc, high_pc))
   1930 		    goto line_fail;
   1931 		  break;
   1932 		case DW_LNE_set_address:
   1933 		  address = read_address (unit, line_ptr, line_end);
   1934 		  op_index = 0;
   1935 		  line_ptr += unit->addr_size;
   1936 		  break;
   1937 		case DW_LNE_define_file:
   1938 		  cur_file = read_string (abfd, line_ptr, line_end, &bytes_read);
   1939 		  line_ptr += bytes_read;
   1940 		  if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
   1941 		    {
   1942 		      struct fileinfo *tmp;
   1943 
   1944 		      amt = table->num_files + FILE_ALLOC_CHUNK;
   1945 		      amt *= sizeof (struct fileinfo);
   1946 		      tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
   1947 		      if (tmp == NULL)
   1948 			goto line_fail;
   1949 		      table->files = tmp;
   1950 		    }
   1951 		  table->files[table->num_files].name = cur_file;
   1952 		  table->files[table->num_files].dir =
   1953 		    safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
   1954 		  line_ptr += bytes_read;
   1955 		  table->files[table->num_files].time =
   1956 		    safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
   1957 		  line_ptr += bytes_read;
   1958 		  table->files[table->num_files].size =
   1959 		    safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
   1960 		  line_ptr += bytes_read;
   1961 		  table->num_files++;
   1962 		  break;
   1963 		case DW_LNE_set_discriminator:
   1964 		  discriminator =
   1965 		    safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
   1966 		  line_ptr += bytes_read;
   1967 		  break;
   1968 		case DW_LNE_HP_source_file_correlation:
   1969 		  line_ptr += exop_len - 1;
   1970 		  break;
   1971 		default:
   1972 		  (*_bfd_error_handler)
   1973 		    (_("Dwarf Error: mangled line number section."));
   1974 		  bfd_set_error (bfd_error_bad_value);
   1975 		line_fail:
   1976 		  if (filename != NULL)
   1977 		    free (filename);
   1978 		  goto fail;
   1979 		}
   1980 	      break;
   1981 	    case DW_LNS_copy:
   1982 	      if (!add_line_info (table, address, op_index,
   1983 				  filename, line, column, discriminator, 0))
   1984 		goto line_fail;
   1985 	      discriminator = 0;
   1986 	      if (address < low_pc)
   1987 		low_pc = address;
   1988 	      if (address > high_pc)
   1989 		high_pc = address;
   1990 	      break;
   1991 	    case DW_LNS_advance_pc:
   1992 	      if (lh.maximum_ops_per_insn == 1)
   1993 		address += (lh.minimum_instruction_length
   1994 			    * safe_read_leb128 (abfd, line_ptr, &bytes_read,
   1995 						FALSE, line_end));
   1996 	      else
   1997 		{
   1998 		  bfd_vma adjust = safe_read_leb128 (abfd, line_ptr, &bytes_read,
   1999 						     FALSE, line_end);
   2000 		  address = ((op_index + adjust) / lh.maximum_ops_per_insn
   2001 			     * lh.minimum_instruction_length);
   2002 		  op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
   2003 		}
   2004 	      line_ptr += bytes_read;
   2005 	      break;
   2006 	    case DW_LNS_advance_line:
   2007 	      line += safe_read_leb128 (abfd, line_ptr, &bytes_read, TRUE, line_end);
   2008 	      line_ptr += bytes_read;
   2009 	      break;
   2010 	    case DW_LNS_set_file:
   2011 	      {
   2012 		unsigned int file;
   2013 
   2014 		/* The file and directory tables are 0
   2015 		   based, the references are 1 based.  */
   2016 		file = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
   2017 		line_ptr += bytes_read;
   2018 		if (filename)
   2019 		  free (filename);
   2020 		filename = concat_filename (table, file);
   2021 		break;
   2022 	      }
   2023 	    case DW_LNS_set_column:
   2024 	      column = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
   2025 	      line_ptr += bytes_read;
   2026 	      break;
   2027 	    case DW_LNS_negate_stmt:
   2028 	      is_stmt = (!is_stmt);
   2029 	      break;
   2030 	    case DW_LNS_set_basic_block:
   2031 	      break;
   2032 	    case DW_LNS_const_add_pc:
   2033 	      if (lh.maximum_ops_per_insn == 1)
   2034 		address += (lh.minimum_instruction_length
   2035 			    * ((255 - lh.opcode_base) / lh.line_range));
   2036 	      else
   2037 		{
   2038 		  bfd_vma adjust = ((255 - lh.opcode_base) / lh.line_range);
   2039 		  address += (lh.minimum_instruction_length
   2040 			      * ((op_index + adjust)
   2041 				 / lh.maximum_ops_per_insn));
   2042 		  op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
   2043 		}
   2044 	      break;
   2045 	    case DW_LNS_fixed_advance_pc:
   2046 	      address += read_2_bytes (abfd, line_ptr, line_end);
   2047 	      op_index = 0;
   2048 	      line_ptr += 2;
   2049 	      break;
   2050 	    default:
   2051 	      /* Unknown standard opcode, ignore it.  */
   2052 	      for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
   2053 		{
   2054 		  (void) safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
   2055 		  line_ptr += bytes_read;
   2056 		}
   2057 	      break;
   2058 	    }
   2059 	}
   2060 
   2061       if (filename)
   2062 	free (filename);
   2063     }
   2064 
   2065   if (sort_line_sequences (table))
   2066     return table;
   2067 
   2068  fail:
   2069   if (table->sequences != NULL)
   2070     free (table->sequences);
   2071   if (table->files != NULL)
   2072     free (table->files);
   2073   if (table->dirs != NULL)
   2074     free (table->dirs);
   2075   return NULL;
   2076 }
   2077 
   2078 /* If ADDR is within TABLE set the output parameters and return the
   2079    range of addresses covered by the entry used to fill them out.
   2080    Otherwise set * FILENAME_PTR to NULL and return 0.
   2081    The parameters FILENAME_PTR, LINENUMBER_PTR and DISCRIMINATOR_PTR
   2082    are pointers to the objects to be filled in.  */
   2083 
   2084 static bfd_vma
   2085 lookup_address_in_line_info_table (struct line_info_table *table,
   2086 				   bfd_vma addr,
   2087 				   const char **filename_ptr,
   2088 				   unsigned int *linenumber_ptr,
   2089 				   unsigned int *discriminator_ptr)
   2090 {
   2091   struct line_sequence *seq = NULL;
   2092   struct line_info *each_line;
   2093   int low, high, mid;
   2094 
   2095   /* Binary search the array of sequences.  */
   2096   low = 0;
   2097   high = table->num_sequences;
   2098   while (low < high)
   2099     {
   2100       mid = (low + high) / 2;
   2101       seq = &table->sequences[mid];
   2102       if (addr < seq->low_pc)
   2103 	high = mid;
   2104       else if (addr >= seq->last_line->address)
   2105 	low = mid + 1;
   2106       else
   2107 	break;
   2108     }
   2109 
   2110   if (seq && addr >= seq->low_pc && addr < seq->last_line->address)
   2111     {
   2112       /* Note: seq->last_line should be a descendingly sorted list.  */
   2113       for (each_line = seq->last_line;
   2114 	   each_line;
   2115 	   each_line = each_line->prev_line)
   2116 	if (addr >= each_line->address)
   2117 	  break;
   2118 
   2119       if (each_line
   2120 	  && !(each_line->end_sequence || each_line == seq->last_line))
   2121 	{
   2122 	  *filename_ptr = each_line->filename;
   2123 	  *linenumber_ptr = each_line->line;
   2124 	  if (discriminator_ptr)
   2125 	    *discriminator_ptr = each_line->discriminator;
   2126 	  return seq->last_line->address - seq->low_pc;
   2127 	}
   2128     }
   2129 
   2130   *filename_ptr = NULL;
   2131   return 0;
   2132 }
   2133 
   2134 /* Read in the .debug_ranges section for future reference.  */
   2135 
   2136 static bfd_boolean
   2137 read_debug_ranges (struct comp_unit *unit)
   2138 {
   2139   struct dwarf2_debug *stash = unit->stash;
   2140   return read_section (unit->abfd, &stash->debug_sections[debug_ranges],
   2141 		       stash->syms, 0,
   2142 		       &stash->dwarf_ranges_buffer, &stash->dwarf_ranges_size);
   2143 }
   2144 
   2145 /* Function table functions.  */
   2146 
   2147 /* If ADDR is within UNIT's function tables, set FUNCTION_PTR, and return
   2148    TRUE.  Note that we need to find the function that has the smallest range
   2149    that contains ADDR, to handle inlined functions without depending upon
   2150    them being ordered in TABLE by increasing range.  */
   2151 
   2152 static bfd_boolean
   2153 lookup_address_in_function_table (struct comp_unit *unit,
   2154 				  bfd_vma addr,
   2155 				  struct funcinfo **function_ptr)
   2156 {
   2157   struct funcinfo* each_func;
   2158   struct funcinfo* best_fit = NULL;
   2159   bfd_vma best_fit_len = 0;
   2160   struct arange *arange;
   2161 
   2162   for (each_func = unit->function_table;
   2163        each_func;
   2164        each_func = each_func->prev_func)
   2165     {
   2166       for (arange = &each_func->arange;
   2167 	   arange;
   2168 	   arange = arange->next)
   2169 	{
   2170 	  if (addr >= arange->low && addr < arange->high)
   2171 	    {
   2172 	      if (!best_fit
   2173 		  || arange->high - arange->low < best_fit_len)
   2174 		{
   2175 		  best_fit = each_func;
   2176 		  best_fit_len = arange->high - arange->low;
   2177 		}
   2178 	    }
   2179 	}
   2180     }
   2181 
   2182   if (best_fit)
   2183     {
   2184       *function_ptr = best_fit;
   2185       return TRUE;
   2186     }
   2187   return FALSE;
   2188 }
   2189 
   2190 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
   2191    and LINENUMBER_PTR, and return TRUE.  */
   2192 
   2193 static bfd_boolean
   2194 lookup_symbol_in_function_table (struct comp_unit *unit,
   2195 				 asymbol *sym,
   2196 				 bfd_vma addr,
   2197 				 const char **filename_ptr,
   2198 				 unsigned int *linenumber_ptr)
   2199 {
   2200   struct funcinfo* each_func;
   2201   struct funcinfo* best_fit = NULL;
   2202   bfd_vma best_fit_len = 0;
   2203   struct arange *arange;
   2204   const char *name = bfd_asymbol_name (sym);
   2205   asection *sec = bfd_get_section (sym);
   2206 
   2207   for (each_func = unit->function_table;
   2208        each_func;
   2209        each_func = each_func->prev_func)
   2210     {
   2211       for (arange = &each_func->arange;
   2212 	   arange;
   2213 	   arange = arange->next)
   2214 	{
   2215 	  if ((!each_func->sec || each_func->sec == sec)
   2216 	      && addr >= arange->low
   2217 	      && addr < arange->high
   2218 	      && each_func->name
   2219 	      && strcmp (name, each_func->name) == 0
   2220 	      && (!best_fit
   2221 		  || arange->high - arange->low < best_fit_len))
   2222 	    {
   2223 	      best_fit = each_func;
   2224 	      best_fit_len = arange->high - arange->low;
   2225 	    }
   2226 	}
   2227     }
   2228 
   2229   if (best_fit)
   2230     {
   2231       best_fit->sec = sec;
   2232       *filename_ptr = best_fit->file;
   2233       *linenumber_ptr = best_fit->line;
   2234       return TRUE;
   2235     }
   2236   else
   2237     return FALSE;
   2238 }
   2239 
   2240 /* Variable table functions.  */
   2241 
   2242 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
   2243    LINENUMBER_PTR, and return TRUE.  */
   2244 
   2245 static bfd_boolean
   2246 lookup_symbol_in_variable_table (struct comp_unit *unit,
   2247 				 asymbol *sym,
   2248 				 bfd_vma addr,
   2249 				 const char **filename_ptr,
   2250 				 unsigned int *linenumber_ptr)
   2251 {
   2252   const char *name = bfd_asymbol_name (sym);
   2253   asection *sec = bfd_get_section (sym);
   2254   struct varinfo* each;
   2255 
   2256   for (each = unit->variable_table; each; each = each->prev_var)
   2257     if (each->stack == 0
   2258 	&& each->file != NULL
   2259 	&& each->name != NULL
   2260 	&& each->addr == addr
   2261 	&& (!each->sec || each->sec == sec)
   2262 	&& strcmp (name, each->name) == 0)
   2263       break;
   2264 
   2265   if (each)
   2266     {
   2267       each->sec = sec;
   2268       *filename_ptr = each->file;
   2269       *linenumber_ptr = each->line;
   2270       return TRUE;
   2271     }
   2272   else
   2273     return FALSE;
   2274 }
   2275 
   2276 static char *
   2277 find_abstract_instance_name (struct comp_unit *unit,
   2278 			     struct attribute *attr_ptr,
   2279 			     bfd_boolean *is_linkage)
   2280 {
   2281   bfd *abfd = unit->abfd;
   2282   bfd_byte *info_ptr;
   2283   bfd_byte *info_ptr_end;
   2284   unsigned int abbrev_number, bytes_read, i;
   2285   struct abbrev_info *abbrev;
   2286   bfd_uint64_t die_ref = attr_ptr->u.val;
   2287   struct attribute attr;
   2288   char *name = NULL;
   2289 
   2290   /* DW_FORM_ref_addr can reference an entry in a different CU. It
   2291      is an offset from the .debug_info section, not the current CU.  */
   2292   if (attr_ptr->form == DW_FORM_ref_addr)
   2293     {
   2294       /* We only support DW_FORM_ref_addr within the same file, so
   2295 	 any relocations should be resolved already.  */
   2296       if (!die_ref)
   2297 	abort ();
   2298 
   2299       info_ptr = unit->sec_info_ptr + die_ref;
   2300       info_ptr_end = unit->end_ptr;
   2301 
   2302       /* Now find the CU containing this pointer.  */
   2303       if (info_ptr >= unit->info_ptr_unit && info_ptr < unit->end_ptr)
   2304 	;
   2305       else
   2306 	{
   2307 	  /* Check other CUs to see if they contain the abbrev.  */
   2308 	  struct comp_unit * u;
   2309 
   2310 	  for (u = unit->prev_unit; u != NULL; u = u->prev_unit)
   2311 	    if (info_ptr >= u->info_ptr_unit && info_ptr < u->end_ptr)
   2312 	      break;
   2313 
   2314 	  if (u == NULL)
   2315 	    for (u = unit->next_unit; u != NULL; u = u->next_unit)
   2316 	      if (info_ptr >= u->info_ptr_unit && info_ptr < u->end_ptr)
   2317 		break;
   2318 
   2319 	  if (u)
   2320 	    unit = u;
   2321 	  /* else FIXME: What do we do now ?  */
   2322 	}
   2323     }
   2324   else if (attr_ptr->form == DW_FORM_GNU_ref_alt)
   2325     {
   2326       info_ptr = read_alt_indirect_ref (unit, die_ref);
   2327       if (info_ptr == NULL)
   2328 	{
   2329 	  (*_bfd_error_handler)
   2330 	    (_("Dwarf Error: Unable to read alt ref %u."), die_ref);
   2331 	  bfd_set_error (bfd_error_bad_value);
   2332 	  return NULL;
   2333 	}
   2334       info_ptr_end = unit->stash->alt_dwarf_info_buffer + unit->stash->alt_dwarf_info_size;
   2335 
   2336       /* FIXME: Do we need to locate the correct CU, in a similar
   2337 	 fashion to the code in the DW_FORM_ref_addr case above ?  */
   2338     }
   2339   else
   2340     {
   2341       info_ptr = unit->info_ptr_unit + die_ref;
   2342       info_ptr_end = unit->end_ptr;
   2343     }
   2344 
   2345   abbrev_number = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
   2346   info_ptr += bytes_read;
   2347 
   2348   if (abbrev_number)
   2349     {
   2350       abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
   2351       if (! abbrev)
   2352 	{
   2353 	  (*_bfd_error_handler)
   2354 	    (_("Dwarf Error: Could not find abbrev number %u."), abbrev_number);
   2355 	  bfd_set_error (bfd_error_bad_value);
   2356 	}
   2357       else
   2358 	{
   2359 	  for (i = 0; i < abbrev->num_attrs; ++i)
   2360 	    {
   2361 	      info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit,
   2362 					 info_ptr, info_ptr_end);
   2363 	      if (info_ptr == NULL)
   2364 		break;
   2365 	      switch (attr.name)
   2366 		{
   2367 		case DW_AT_name:
   2368 		  /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
   2369 		     over DW_AT_name.  */
   2370 		  if (name == NULL && is_str_attr (attr.form))
   2371 		    {
   2372 		      name = attr.u.str;
   2373 		      if (non_mangled (unit->lang))
   2374 			*is_linkage = TRUE;
   2375 		    }
   2376 		  break;
   2377 		case DW_AT_specification:
   2378 		  name = find_abstract_instance_name (unit, &attr, is_linkage);
   2379 		  break;
   2380 		case DW_AT_linkage_name:
   2381 		case DW_AT_MIPS_linkage_name:
   2382 		  /* PR 16949:  Corrupt debug info can place
   2383 		     non-string forms into these attributes.  */
   2384 		  if (is_str_attr (attr.form))
   2385 		    {
   2386 		      name = attr.u.str;
   2387 		      *is_linkage = TRUE;
   2388 		    }
   2389 		  break;
   2390 		default:
   2391 		  break;
   2392 		}
   2393 	    }
   2394 	}
   2395     }
   2396   return name;
   2397 }
   2398 
   2399 static bfd_boolean
   2400 read_rangelist (struct comp_unit *unit, struct arange *arange,
   2401 		bfd_uint64_t offset)
   2402 {
   2403   bfd_byte *ranges_ptr;
   2404   bfd_byte *ranges_end;
   2405   bfd_vma base_address = unit->base_address;
   2406 
   2407   if (! unit->stash->dwarf_ranges_buffer)
   2408     {
   2409       if (! read_debug_ranges (unit))
   2410 	return FALSE;
   2411     }
   2412 
   2413   ranges_ptr = unit->stash->dwarf_ranges_buffer + offset;
   2414   if (ranges_ptr < unit->stash->dwarf_ranges_buffer)
   2415     return FALSE;
   2416   ranges_end = unit->stash->dwarf_ranges_buffer + unit->stash->dwarf_ranges_size;
   2417 
   2418   for (;;)
   2419     {
   2420       bfd_vma low_pc;
   2421       bfd_vma high_pc;
   2422 
   2423       /* PR 17512: file: 62cada7d.  */
   2424       if (ranges_ptr + 2 * unit->addr_size > ranges_end)
   2425 	return FALSE;
   2426 
   2427       low_pc = read_address (unit, ranges_ptr, ranges_end);
   2428       ranges_ptr += unit->addr_size;
   2429       high_pc = read_address (unit, ranges_ptr, ranges_end);
   2430       ranges_ptr += unit->addr_size;
   2431 
   2432       if (low_pc == 0 && high_pc == 0)
   2433 	break;
   2434       if (low_pc == -1UL && high_pc != -1UL)
   2435 	base_address = high_pc;
   2436       else
   2437 	{
   2438 	  if (!arange_add (unit, arange,
   2439 			   base_address + low_pc, base_address + high_pc))
   2440 	    return FALSE;
   2441 	}
   2442     }
   2443   return TRUE;
   2444 }
   2445 
   2446 /* DWARF2 Compilation unit functions.  */
   2447 
   2448 /* Scan over each die in a comp. unit looking for functions to add
   2449    to the function table and variables to the variable table.  */
   2450 
   2451 static bfd_boolean
   2452 scan_unit_for_symbols (struct comp_unit *unit)
   2453 {
   2454   bfd *abfd = unit->abfd;
   2455   bfd_byte *info_ptr = unit->first_child_die_ptr;
   2456   bfd_byte *info_ptr_end = unit->stash->info_ptr_end;
   2457   int nesting_level = 1;
   2458   struct funcinfo **nested_funcs;
   2459   int nested_funcs_size;
   2460 
   2461   /* Maintain a stack of in-scope functions and inlined functions, which we
   2462      can use to set the caller_func field.  */
   2463   nested_funcs_size = 32;
   2464   nested_funcs = (struct funcinfo **)
   2465     bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *));
   2466   if (nested_funcs == NULL)
   2467     return FALSE;
   2468   nested_funcs[nesting_level] = 0;
   2469 
   2470   while (nesting_level)
   2471     {
   2472       unsigned int abbrev_number, bytes_read, i;
   2473       struct abbrev_info *abbrev;
   2474       struct attribute attr;
   2475       struct funcinfo *func;
   2476       struct varinfo *var;
   2477       bfd_vma low_pc = 0;
   2478       bfd_vma high_pc = 0;
   2479       bfd_boolean high_pc_relative = FALSE;
   2480 
   2481       /* PR 17512: file: 9f405d9d.  */
   2482       if (info_ptr >= info_ptr_end)
   2483 	goto fail;
   2484 
   2485       abbrev_number = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
   2486       info_ptr += bytes_read;
   2487 
   2488       if (! abbrev_number)
   2489 	{
   2490 	  nesting_level--;
   2491 	  continue;
   2492 	}
   2493 
   2494       abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
   2495       if (! abbrev)
   2496 	{
   2497 	  (*_bfd_error_handler)
   2498 	    (_("Dwarf Error: Could not find abbrev number %u."),
   2499 	     abbrev_number);
   2500 	  bfd_set_error (bfd_error_bad_value);
   2501 	  goto fail;
   2502 	}
   2503 
   2504       var = NULL;
   2505       if (abbrev->tag == DW_TAG_subprogram
   2506 	  || abbrev->tag == DW_TAG_entry_point
   2507 	  || abbrev->tag == DW_TAG_inlined_subroutine)
   2508 	{
   2509 	  bfd_size_type amt = sizeof (struct funcinfo);
   2510 	  func = (struct funcinfo *) bfd_zalloc (abfd, amt);
   2511 	  if (func == NULL)
   2512 	    goto fail;
   2513 	  func->tag = abbrev->tag;
   2514 	  func->prev_func = unit->function_table;
   2515 	  unit->function_table = func;
   2516 	  BFD_ASSERT (!unit->cached);
   2517 
   2518 	  if (func->tag == DW_TAG_inlined_subroutine)
   2519 	    for (i = nesting_level - 1; i >= 1; i--)
   2520 	      if (nested_funcs[i])
   2521 		{
   2522 		  func->caller_func = nested_funcs[i];
   2523 		  break;
   2524 		}
   2525 	  nested_funcs[nesting_level] = func;
   2526 	}
   2527       else
   2528 	{
   2529 	  func = NULL;
   2530 	  if (abbrev->tag == DW_TAG_variable)
   2531 	    {
   2532 	      bfd_size_type amt = sizeof (struct varinfo);
   2533 	      var = (struct varinfo *) bfd_zalloc (abfd, amt);
   2534 	      if (var == NULL)
   2535 		goto fail;
   2536 	      var->tag = abbrev->tag;
   2537 	      var->stack = 1;
   2538 	      var->prev_var = unit->variable_table;
   2539 	      unit->variable_table = var;
   2540 	      BFD_ASSERT (!unit->cached);
   2541 	    }
   2542 
   2543 	  /* No inline function in scope at this nesting level.  */
   2544 	  nested_funcs[nesting_level] = 0;
   2545 	}
   2546 
   2547       for (i = 0; i < abbrev->num_attrs; ++i)
   2548 	{
   2549 	  info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr, info_ptr_end);
   2550 	  if (info_ptr == NULL)
   2551 	    goto fail;
   2552 
   2553 	  if (func)
   2554 	    {
   2555 	      switch (attr.name)
   2556 		{
   2557 		case DW_AT_call_file:
   2558 		  func->caller_file = concat_filename (unit->line_table,
   2559 						       attr.u.val);
   2560 		  break;
   2561 
   2562 		case DW_AT_call_line:
   2563 		  func->caller_line = attr.u.val;
   2564 		  break;
   2565 
   2566 		case DW_AT_abstract_origin:
   2567 		case DW_AT_specification:
   2568 		  func->name = find_abstract_instance_name (unit, &attr,
   2569 							    &func->is_linkage);
   2570 		  break;
   2571 
   2572 		case DW_AT_name:
   2573 		  /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
   2574 		     over DW_AT_name.  */
   2575 		  if (func->name == NULL && is_str_attr (attr.form))
   2576 		    {
   2577 		      func->name = attr.u.str;
   2578 		      if (non_mangled (unit->lang))
   2579 			func->is_linkage = TRUE;
   2580 		    }
   2581 		  break;
   2582 
   2583 		case DW_AT_linkage_name:
   2584 		case DW_AT_MIPS_linkage_name:
   2585 		  /* PR 16949:  Corrupt debug info can place
   2586 		     non-string forms into these attributes.  */
   2587 		  if (is_str_attr (attr.form))
   2588 		    {
   2589 		      func->name = attr.u.str;
   2590 		      func->is_linkage = TRUE;
   2591 		    }
   2592 		  break;
   2593 
   2594 		case DW_AT_low_pc:
   2595 		  low_pc = attr.u.val;
   2596 		  break;
   2597 
   2598 		case DW_AT_high_pc:
   2599 		  high_pc = attr.u.val;
   2600 		  high_pc_relative = attr.form != DW_FORM_addr;
   2601 		  break;
   2602 
   2603 		case DW_AT_ranges:
   2604 		  if (!read_rangelist (unit, &func->arange, attr.u.val))
   2605 		    goto fail;
   2606 		  break;
   2607 
   2608 		case DW_AT_decl_file:
   2609 		  func->file = concat_filename (unit->line_table,
   2610 						attr.u.val);
   2611 		  break;
   2612 
   2613 		case DW_AT_decl_line:
   2614 		  func->line = attr.u.val;
   2615 		  break;
   2616 
   2617 		default:
   2618 		  break;
   2619 		}
   2620 	    }
   2621 	  else if (var)
   2622 	    {
   2623 	      switch (attr.name)
   2624 		{
   2625 		case DW_AT_name:
   2626 		  var->name = attr.u.str;
   2627 		  break;
   2628 
   2629 		case DW_AT_decl_file:
   2630 		  var->file = concat_filename (unit->line_table,
   2631 					       attr.u.val);
   2632 		  break;
   2633 
   2634 		case DW_AT_decl_line:
   2635 		  var->line = attr.u.val;
   2636 		  break;
   2637 
   2638 		case DW_AT_external:
   2639 		  if (attr.u.val != 0)
   2640 		    var->stack = 0;
   2641 		  break;
   2642 
   2643 		case DW_AT_location:
   2644 		  switch (attr.form)
   2645 		    {
   2646 		    case DW_FORM_block:
   2647 		    case DW_FORM_block1:
   2648 		    case DW_FORM_block2:
   2649 		    case DW_FORM_block4:
   2650 		    case DW_FORM_exprloc:
   2651 		      if (*attr.u.blk->data == DW_OP_addr)
   2652 			{
   2653 			  var->stack = 0;
   2654 
   2655 			  /* Verify that DW_OP_addr is the only opcode in the
   2656 			     location, in which case the block size will be 1
   2657 			     plus the address size.  */
   2658 			  /* ??? For TLS variables, gcc can emit
   2659 			     DW_OP_addr <addr> DW_OP_GNU_push_tls_address
   2660 			     which we don't handle here yet.  */
   2661 			  if (attr.u.blk->size == unit->addr_size + 1U)
   2662 			    var->addr = bfd_get (unit->addr_size * 8,
   2663 						 unit->abfd,
   2664 						 attr.u.blk->data + 1);
   2665 			}
   2666 		      break;
   2667 
   2668 		    default:
   2669 		      break;
   2670 		    }
   2671 		  break;
   2672 
   2673 		default:
   2674 		  break;
   2675 		}
   2676 	    }
   2677 	}
   2678 
   2679       if (high_pc_relative)
   2680 	high_pc += low_pc;
   2681 
   2682       if (func && high_pc != 0)
   2683 	{
   2684 	  if (!arange_add (unit, &func->arange, low_pc, high_pc))
   2685 	    goto fail;
   2686 	}
   2687 
   2688       if (abbrev->has_children)
   2689 	{
   2690 	  nesting_level++;
   2691 
   2692 	  if (nesting_level >= nested_funcs_size)
   2693 	    {
   2694 	      struct funcinfo **tmp;
   2695 
   2696 	      nested_funcs_size *= 2;
   2697 	      tmp = (struct funcinfo **)
   2698 		bfd_realloc (nested_funcs,
   2699 			     nested_funcs_size * sizeof (struct funcinfo *));
   2700 	      if (tmp == NULL)
   2701 		goto fail;
   2702 	      nested_funcs = tmp;
   2703 	    }
   2704 	  nested_funcs[nesting_level] = 0;
   2705 	}
   2706     }
   2707 
   2708   free (nested_funcs);
   2709   return TRUE;
   2710 
   2711  fail:
   2712   free (nested_funcs);
   2713   return FALSE;
   2714 }
   2715 
   2716 /* Parse a DWARF2 compilation unit starting at INFO_PTR.  This
   2717    includes the compilation unit header that proceeds the DIE's, but
   2718    does not include the length field that precedes each compilation
   2719    unit header.  END_PTR points one past the end of this comp unit.
   2720    OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
   2721 
   2722    This routine does not read the whole compilation unit; only enough
   2723    to get to the line number information for the compilation unit.  */
   2724 
   2725 static struct comp_unit *
   2726 parse_comp_unit (struct dwarf2_debug *stash,
   2727 		 bfd_vma unit_length,
   2728 		 bfd_byte *info_ptr_unit,
   2729 		 unsigned int offset_size)
   2730 {
   2731   struct comp_unit* unit;
   2732   unsigned int version;
   2733   bfd_uint64_t abbrev_offset = 0;
   2734   unsigned int addr_size;
   2735   struct abbrev_info** abbrevs;
   2736   unsigned int abbrev_number, bytes_read, i;
   2737   struct abbrev_info *abbrev;
   2738   struct attribute attr;
   2739   bfd_byte *info_ptr = stash->info_ptr;
   2740   bfd_byte *end_ptr = info_ptr + unit_length;
   2741   bfd_size_type amt;
   2742   bfd_vma low_pc = 0;
   2743   bfd_vma high_pc = 0;
   2744   bfd *abfd = stash->bfd_ptr;
   2745   bfd_boolean high_pc_relative = FALSE;
   2746 
   2747   version = read_2_bytes (abfd, info_ptr, end_ptr);
   2748   info_ptr += 2;
   2749   BFD_ASSERT (offset_size == 4 || offset_size == 8);
   2750   if (offset_size == 4)
   2751     abbrev_offset = read_4_bytes (abfd, info_ptr, end_ptr);
   2752   else
   2753     abbrev_offset = read_8_bytes (abfd, info_ptr, end_ptr);
   2754   info_ptr += offset_size;
   2755   addr_size = read_1_byte (abfd, info_ptr, end_ptr);
   2756   info_ptr += 1;
   2757 
   2758   if (version != 2 && version != 3 && version != 4)
   2759     {
   2760       /* PR 19872: A version number of 0 probably means that there is padding
   2761 	 at the end of the .debug_info section.  Gold puts it there when
   2762 	 performing an incremental link, for example.  So do not generate
   2763 	 an error, just return a NULL.  */
   2764       if (version)
   2765 	{
   2766 	  (*_bfd_error_handler)
   2767 	    (_("Dwarf Error: found dwarf version '%u', this reader"
   2768 	       " only handles version 2, 3 and 4 information."), version);
   2769 	  bfd_set_error (bfd_error_bad_value);
   2770 	}
   2771       return NULL;
   2772     }
   2773 
   2774   if (addr_size > sizeof (bfd_vma))
   2775     {
   2776       (*_bfd_error_handler)
   2777 	(_("Dwarf Error: found address size '%u', this reader"
   2778 	   " can not handle sizes greater than '%u'."),
   2779 	 addr_size,
   2780 	 (unsigned int) sizeof (bfd_vma));
   2781       bfd_set_error (bfd_error_bad_value);
   2782       return NULL;
   2783     }
   2784 
   2785   if (addr_size != 2 && addr_size != 4 && addr_size != 8)
   2786     {
   2787       (*_bfd_error_handler)
   2788 	("Dwarf Error: found address size '%u', this reader"
   2789 	 " can only handle address sizes '2', '4' and '8'.", addr_size);
   2790       bfd_set_error (bfd_error_bad_value);
   2791       return NULL;
   2792     }
   2793 
   2794   /* Read the abbrevs for this compilation unit into a table.  */
   2795   abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
   2796   if (! abbrevs)
   2797     return NULL;
   2798 
   2799   abbrev_number = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, end_ptr);
   2800   info_ptr += bytes_read;
   2801   if (! abbrev_number)
   2802     {
   2803       /* PR 19872: An abbrev number of 0 probably means that there is padding
   2804 	 at the end of the .debug_abbrev section.  Gold puts it there when
   2805 	 performing an incremental link, for example.  So do not generate
   2806 	 an error, just return a NULL.  */
   2807       return NULL;
   2808     }
   2809 
   2810   abbrev = lookup_abbrev (abbrev_number, abbrevs);
   2811   if (! abbrev)
   2812     {
   2813       (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
   2814 			     abbrev_number);
   2815       bfd_set_error (bfd_error_bad_value);
   2816       return NULL;
   2817     }
   2818 
   2819   amt = sizeof (struct comp_unit);
   2820   unit = (struct comp_unit *) bfd_zalloc (abfd, amt);
   2821   if (unit == NULL)
   2822     return NULL;
   2823   unit->abfd = abfd;
   2824   unit->version = version;
   2825   unit->addr_size = addr_size;
   2826   unit->offset_size = offset_size;
   2827   unit->abbrevs = abbrevs;
   2828   unit->end_ptr = end_ptr;
   2829   unit->stash = stash;
   2830   unit->info_ptr_unit = info_ptr_unit;
   2831   unit->sec_info_ptr = stash->sec_info_ptr;
   2832 
   2833   for (i = 0; i < abbrev->num_attrs; ++i)
   2834     {
   2835       info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr, end_ptr);
   2836       if (info_ptr == NULL)
   2837 	return NULL;
   2838 
   2839       /* Store the data if it is of an attribute we want to keep in a
   2840 	 partial symbol table.  */
   2841       switch (attr.name)
   2842 	{
   2843 	case DW_AT_stmt_list:
   2844 	  unit->stmtlist = 1;
   2845 	  unit->line_offset = attr.u.val;
   2846 	  break;
   2847 
   2848 	case DW_AT_name:
   2849 	  unit->name = attr.u.str;
   2850 	  break;
   2851 
   2852 	case DW_AT_low_pc:
   2853 	  low_pc = attr.u.val;
   2854 	  /* If the compilation unit DIE has a DW_AT_low_pc attribute,
   2855 	     this is the base address to use when reading location
   2856 	     lists or range lists. */
   2857 	  if (abbrev->tag == DW_TAG_compile_unit)
   2858 	    unit->base_address = low_pc;
   2859 	  break;
   2860 
   2861 	case DW_AT_high_pc:
   2862 	  high_pc = attr.u.val;
   2863 	  high_pc_relative = attr.form != DW_FORM_addr;
   2864 	  break;
   2865 
   2866 	case DW_AT_ranges:
   2867 	  if (!read_rangelist (unit, &unit->arange, attr.u.val))
   2868 	    return NULL;
   2869 	  break;
   2870 
   2871 	case DW_AT_comp_dir:
   2872 	  {
   2873 	    char *comp_dir = attr.u.str;
   2874 
   2875 	    /* PR 17512: file: 1fe726be.  */
   2876 	    if (! is_str_attr (attr.form))
   2877 	      {
   2878 		(*_bfd_error_handler)
   2879 		  (_("Dwarf Error: DW_AT_comp_dir attribute encountered with a non-string form."));
   2880 		comp_dir = NULL;
   2881 	      }
   2882 
   2883 	    if (comp_dir)
   2884 	      {
   2885 		/* Irix 6.2 native cc prepends <machine>.: to the compilation
   2886 		   directory, get rid of it.  */
   2887 		char *cp = strchr (comp_dir, ':');
   2888 
   2889 		if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
   2890 		  comp_dir = cp + 1;
   2891 	      }
   2892 	    unit->comp_dir = comp_dir;
   2893 	    break;
   2894 	  }
   2895 
   2896 	case DW_AT_language:
   2897 	  unit->lang = attr.u.val;
   2898 	  break;
   2899 
   2900 	default:
   2901 	  break;
   2902 	}
   2903     }
   2904   if (high_pc_relative)
   2905     high_pc += low_pc;
   2906   if (high_pc != 0)
   2907     {
   2908       if (!arange_add (unit, &unit->arange, low_pc, high_pc))
   2909 	return NULL;
   2910     }
   2911 
   2912   unit->first_child_die_ptr = info_ptr;
   2913   return unit;
   2914 }
   2915 
   2916 /* Return TRUE if UNIT may contain the address given by ADDR.  When
   2917    there are functions written entirely with inline asm statements, the
   2918    range info in the compilation unit header may not be correct.  We
   2919    need to consult the line info table to see if a compilation unit
   2920    really contains the given address.  */
   2921 
   2922 static bfd_boolean
   2923 comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
   2924 {
   2925   struct arange *arange;
   2926 
   2927   if (unit->error)
   2928     return FALSE;
   2929 
   2930   arange = &unit->arange;
   2931   do
   2932     {
   2933       if (addr >= arange->low && addr < arange->high)
   2934 	return TRUE;
   2935       arange = arange->next;
   2936     }
   2937   while (arange);
   2938 
   2939   return FALSE;
   2940 }
   2941 
   2942 /* If UNIT contains ADDR, set the output parameters to the values for
   2943    the line containing ADDR.  The output parameters, FILENAME_PTR,
   2944    FUNCTION_PTR, and LINENUMBER_PTR, are pointers to the objects
   2945    to be filled in.
   2946 
   2947    Returns the range of addresses covered by the entry that was used
   2948    to fill in *LINENUMBER_PTR or 0 if it was not filled in.  */
   2949 
   2950 static bfd_vma
   2951 comp_unit_find_nearest_line (struct comp_unit *unit,
   2952 			     bfd_vma addr,
   2953 			     const char **filename_ptr,
   2954 			     struct funcinfo **function_ptr,
   2955 			     unsigned int *linenumber_ptr,
   2956 			     unsigned int *discriminator_ptr,
   2957 			     struct dwarf2_debug *stash)
   2958 {
   2959   bfd_boolean func_p;
   2960 
   2961   if (unit->error)
   2962     return FALSE;
   2963 
   2964   if (! unit->line_table)
   2965     {
   2966       if (! unit->stmtlist)
   2967 	{
   2968 	  unit->error = 1;
   2969 	  return FALSE;
   2970 	}
   2971 
   2972       unit->line_table = decode_line_info (unit, stash);
   2973 
   2974       if (! unit->line_table)
   2975 	{
   2976 	  unit->error = 1;
   2977 	  return FALSE;
   2978 	}
   2979 
   2980       if (unit->first_child_die_ptr < unit->end_ptr
   2981 	  && ! scan_unit_for_symbols (unit))
   2982 	{
   2983 	  unit->error = 1;
   2984 	  return FALSE;
   2985 	}
   2986     }
   2987 
   2988   *function_ptr = NULL;
   2989   func_p = lookup_address_in_function_table (unit, addr, function_ptr);
   2990   if (func_p && (*function_ptr)->tag == DW_TAG_inlined_subroutine)
   2991     stash->inliner_chain = *function_ptr;
   2992 
   2993   return lookup_address_in_line_info_table (unit->line_table, addr,
   2994 					    filename_ptr,
   2995 					    linenumber_ptr,
   2996 					    discriminator_ptr);
   2997 }
   2998 
   2999 /* Check to see if line info is already decoded in a comp_unit.
   3000    If not, decode it.  Returns TRUE if no errors were encountered;
   3001    FALSE otherwise.  */
   3002 
   3003 static bfd_boolean
   3004 comp_unit_maybe_decode_line_info (struct comp_unit *unit,
   3005 				  struct dwarf2_debug *stash)
   3006 {
   3007   if (unit->error)
   3008     return FALSE;
   3009 
   3010   if (! unit->line_table)
   3011     {
   3012       if (! unit->stmtlist)
   3013 	{
   3014 	  unit->error = 1;
   3015 	  return FALSE;
   3016 	}
   3017 
   3018       unit->line_table = decode_line_info (unit, stash);
   3019 
   3020       if (! unit->line_table)
   3021 	{
   3022 	  unit->error = 1;
   3023 	  return FALSE;
   3024 	}
   3025 
   3026       if (unit->first_child_die_ptr < unit->end_ptr
   3027 	  && ! scan_unit_for_symbols (unit))
   3028 	{
   3029 	  unit->error = 1;
   3030 	  return FALSE;
   3031 	}
   3032     }
   3033 
   3034   return TRUE;
   3035 }
   3036 
   3037 /* If UNIT contains SYM at ADDR, set the output parameters to the
   3038    values for the line containing SYM.  The output parameters,
   3039    FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
   3040    filled in.
   3041 
   3042    Return TRUE if UNIT contains SYM, and no errors were encountered;
   3043    FALSE otherwise.  */
   3044 
   3045 static bfd_boolean
   3046 comp_unit_find_line (struct comp_unit *unit,
   3047 		     asymbol *sym,
   3048 		     bfd_vma addr,
   3049 		     const char **filename_ptr,
   3050 		     unsigned int *linenumber_ptr,
   3051 		     struct dwarf2_debug *stash)
   3052 {
   3053   if (!comp_unit_maybe_decode_line_info (unit, stash))
   3054     return FALSE;
   3055 
   3056   if (sym->flags & BSF_FUNCTION)
   3057     return lookup_symbol_in_function_table (unit, sym, addr,
   3058 					    filename_ptr,
   3059 					    linenumber_ptr);
   3060 
   3061   return lookup_symbol_in_variable_table (unit, sym, addr,
   3062 					  filename_ptr,
   3063 					  linenumber_ptr);
   3064 }
   3065 
   3066 static struct funcinfo *
   3067 reverse_funcinfo_list (struct funcinfo *head)
   3068 {
   3069   struct funcinfo *rhead;
   3070   struct funcinfo *temp;
   3071 
   3072   for (rhead = NULL; head; head = temp)
   3073     {
   3074       temp = head->prev_func;
   3075       head->prev_func = rhead;
   3076       rhead = head;
   3077     }
   3078   return rhead;
   3079 }
   3080 
   3081 static struct varinfo *
   3082 reverse_varinfo_list (struct varinfo *head)
   3083 {
   3084   struct varinfo *rhead;
   3085   struct varinfo *temp;
   3086 
   3087   for (rhead = NULL; head; head = temp)
   3088     {
   3089       temp = head->prev_var;
   3090       head->prev_var = rhead;
   3091       rhead = head;
   3092     }
   3093   return rhead;
   3094 }
   3095 
   3096 /* Extract all interesting funcinfos and varinfos of a compilation
   3097    unit into hash tables for faster lookup.  Returns TRUE if no
   3098    errors were enountered; FALSE otherwise.  */
   3099 
   3100 static bfd_boolean
   3101 comp_unit_hash_info (struct dwarf2_debug *stash,
   3102 		     struct comp_unit *unit,
   3103 		     struct info_hash_table *funcinfo_hash_table,
   3104 		     struct info_hash_table *varinfo_hash_table)
   3105 {
   3106   struct funcinfo* each_func;
   3107   struct varinfo* each_var;
   3108   bfd_boolean okay = TRUE;
   3109 
   3110   BFD_ASSERT (stash->info_hash_status != STASH_INFO_HASH_DISABLED);
   3111 
   3112   if (!comp_unit_maybe_decode_line_info (unit, stash))
   3113     return FALSE;
   3114 
   3115   BFD_ASSERT (!unit->cached);
   3116 
   3117   /* To preserve the original search order, we went to visit the function
   3118      infos in the reversed order of the list.  However, making the list
   3119      bi-directional use quite a bit of extra memory.  So we reverse
   3120      the list first, traverse the list in the now reversed order and
   3121      finally reverse the list again to get back the original order.  */
   3122   unit->function_table = reverse_funcinfo_list (unit->function_table);
   3123   for (each_func = unit->function_table;
   3124        each_func && okay;
   3125        each_func = each_func->prev_func)
   3126     {
   3127       /* Skip nameless functions. */
   3128       if (each_func->name)
   3129 	/* There is no need to copy name string into hash table as
   3130 	   name string is either in the dwarf string buffer or
   3131 	   info in the stash.  */
   3132 	okay = insert_info_hash_table (funcinfo_hash_table, each_func->name,
   3133 				       (void*) each_func, FALSE);
   3134     }
   3135   unit->function_table = reverse_funcinfo_list (unit->function_table);
   3136   if (!okay)
   3137     return FALSE;
   3138 
   3139   /* We do the same for variable infos.  */
   3140   unit->variable_table = reverse_varinfo_list (unit->variable_table);
   3141   for (each_var = unit->variable_table;
   3142        each_var && okay;
   3143        each_var = each_var->prev_var)
   3144     {
   3145       /* Skip stack vars and vars with no files or names.  */
   3146       if (each_var->stack == 0
   3147 	  && each_var->file != NULL
   3148 	  && each_var->name != NULL)
   3149 	/* There is no need to copy name string into hash table as
   3150 	   name string is either in the dwarf string buffer or
   3151 	   info in the stash.  */
   3152 	okay = insert_info_hash_table (varinfo_hash_table, each_var->name,
   3153 				       (void*) each_var, FALSE);
   3154     }
   3155 
   3156   unit->variable_table = reverse_varinfo_list (unit->variable_table);
   3157   unit->cached = TRUE;
   3158   return okay;
   3159 }
   3160 
   3161 /* Locate a section in a BFD containing debugging info.  The search starts
   3162    from the section after AFTER_SEC, or from the first section in the BFD if
   3163    AFTER_SEC is NULL.  The search works by examining the names of the
   3164    sections.  There are three permissiable names.  The first two are given
   3165    by DEBUG_SECTIONS[debug_info] (whose standard DWARF2 names are .debug_info
   3166    and .zdebug_info).  The third is a prefix .gnu.linkonce.wi.
   3167    This is a variation on the .debug_info section which has a checksum
   3168    describing the contents appended onto the name.  This allows the linker to
   3169    identify and discard duplicate debugging sections for different
   3170    compilation units.  */
   3171 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
   3172 
   3173 static asection *
   3174 find_debug_info (bfd *abfd, const struct dwarf_debug_section *debug_sections,
   3175 		 asection *after_sec)
   3176 {
   3177   asection *msec;
   3178   const char *look;
   3179 
   3180   if (after_sec == NULL)
   3181     {
   3182       look = debug_sections[debug_info].uncompressed_name;
   3183       msec = bfd_get_section_by_name (abfd, look);
   3184       if (msec != NULL)
   3185 	return msec;
   3186 
   3187       look = debug_sections[debug_info].compressed_name;
   3188       if (look != NULL)
   3189 	{
   3190 	  msec = bfd_get_section_by_name (abfd, look);
   3191 	  if (msec != NULL)
   3192 	    return msec;
   3193 	}
   3194 
   3195       for (msec = abfd->sections; msec != NULL; msec = msec->next)
   3196 	if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
   3197 	  return msec;
   3198 
   3199       return NULL;
   3200     }
   3201 
   3202   for (msec = after_sec->next; msec != NULL; msec = msec->next)
   3203     {
   3204       look = debug_sections[debug_info].uncompressed_name;
   3205       if (strcmp (msec->name, look) == 0)
   3206 	return msec;
   3207 
   3208       look = debug_sections[debug_info].compressed_name;
   3209       if (look != NULL && strcmp (msec->name, look) == 0)
   3210 	return msec;
   3211 
   3212       if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
   3213 	return msec;
   3214     }
   3215 
   3216   return NULL;
   3217 }
   3218 
   3219 /* Transfer VMAs from object file to separate debug file.  */
   3220 
   3221 static void
   3222 set_debug_vma (bfd *orig_bfd, bfd *debug_bfd)
   3223 {
   3224   asection *s, *d;
   3225 
   3226   for (s = orig_bfd->sections, d = debug_bfd->sections;
   3227        s != NULL && d != NULL;
   3228        s = s->next, d = d->next)
   3229     {
   3230       if ((d->flags & SEC_DEBUGGING) != 0)
   3231 	break;
   3232       /* ??? Assumes 1-1 correspondence between sections in the
   3233 	 two files.  */
   3234       if (strcmp (s->name, d->name) == 0)
   3235 	{
   3236 	  d->output_section = s->output_section;
   3237 	  d->output_offset = s->output_offset;
   3238 	  d->vma = s->vma;
   3239 	}
   3240     }
   3241 }
   3242 
   3243 /* Unset vmas for adjusted sections in STASH.  */
   3244 
   3245 static void
   3246 unset_sections (struct dwarf2_debug *stash)
   3247 {
   3248   int i;
   3249   struct adjusted_section *p;
   3250 
   3251   i = stash->adjusted_section_count;
   3252   p = stash->adjusted_sections;
   3253   for (; i > 0; i--, p++)
   3254     p->section->vma = 0;
   3255 }
   3256 
   3257 /* Set VMAs for allocated and .debug_info sections in ORIG_BFD, a
   3258    relocatable object file.  VMAs are normally all zero in relocatable
   3259    object files, so if we want to distinguish locations in sections by
   3260    address we need to set VMAs so the sections do not overlap.  We
   3261    also set VMA on .debug_info so that when we have multiple
   3262    .debug_info sections (or the linkonce variant) they also do not
   3263    overlap.  The multiple .debug_info sections make up a single
   3264    logical section.  ??? We should probably do the same for other
   3265    debug sections.  */
   3266 
   3267 static bfd_boolean
   3268 place_sections (bfd *orig_bfd, struct dwarf2_debug *stash)
   3269 {
   3270   bfd *abfd;
   3271   struct adjusted_section *p;
   3272   int i;
   3273   const char *debug_info_name;
   3274 
   3275   if (stash->adjusted_section_count != 0)
   3276     {
   3277       i = stash->adjusted_section_count;
   3278       p = stash->adjusted_sections;
   3279       for (; i > 0; i--, p++)
   3280 	p->section->vma = p->adj_vma;
   3281       return TRUE;
   3282     }
   3283 
   3284   debug_info_name = stash->debug_sections[debug_info].uncompressed_name;
   3285   i = 0;
   3286   abfd = orig_bfd;
   3287   while (1)
   3288     {
   3289       asection *sect;
   3290 
   3291       for (sect = abfd->sections; sect != NULL; sect = sect->next)
   3292 	{
   3293 	  int is_debug_info;
   3294 
   3295 	  if ((sect->output_section != NULL
   3296 	       && sect->output_section != sect
   3297 	       && (sect->flags & SEC_DEBUGGING) == 0)
   3298 	      || sect->vma != 0)
   3299 	    continue;
   3300 
   3301 	  is_debug_info = (strcmp (sect->name, debug_info_name) == 0
   3302 			   || CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO));
   3303 
   3304 	  if (!((sect->flags & SEC_ALLOC) != 0 && abfd == orig_bfd)
   3305 	      && !is_debug_info)
   3306 	    continue;
   3307 
   3308 	  i++;
   3309 	}
   3310       if (abfd == stash->bfd_ptr)
   3311 	break;
   3312       abfd = stash->bfd_ptr;
   3313     }
   3314 
   3315   if (i <= 1)
   3316     stash->adjusted_section_count = -1;
   3317   else
   3318     {
   3319       bfd_vma last_vma = 0, last_dwarf = 0;
   3320       bfd_size_type amt = i * sizeof (struct adjusted_section);
   3321 
   3322       p = (struct adjusted_section *) bfd_malloc (amt);
   3323       if (p == NULL)
   3324 	return FALSE;
   3325 
   3326       stash->adjusted_sections = p;
   3327       stash->adjusted_section_count = i;
   3328 
   3329       abfd = orig_bfd;
   3330       while (1)
   3331 	{
   3332 	  asection *sect;
   3333 
   3334 	  for (sect = abfd->sections; sect != NULL; sect = sect->next)
   3335 	    {
   3336 	      bfd_size_type sz;
   3337 	      int is_debug_info;
   3338 
   3339 	      if ((sect->output_section != NULL
   3340 		   && sect->output_section != sect
   3341 		   && (sect->flags & SEC_DEBUGGING) == 0)
   3342 		  || sect->vma != 0)
   3343 		continue;
   3344 
   3345 	      is_debug_info = (strcmp (sect->name, debug_info_name) == 0
   3346 			       || CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO));
   3347 
   3348 	      if (!((sect->flags & SEC_ALLOC) != 0 && abfd == orig_bfd)
   3349 		  && !is_debug_info)
   3350 		continue;
   3351 
   3352 	      sz = sect->rawsize ? sect->rawsize : sect->size;
   3353 
   3354 	      if (is_debug_info)
   3355 		{
   3356 		  BFD_ASSERT (sect->alignment_power == 0);
   3357 		  sect->vma = last_dwarf;
   3358 		  last_dwarf += sz;
   3359 		}
   3360 	      else
   3361 		{
   3362 		  /* Align the new address to the current section
   3363 		     alignment.  */
   3364 		  last_vma = ((last_vma
   3365 			       + ~(-((bfd_vma) 1 << sect->alignment_power)))
   3366 			      & (-((bfd_vma) 1 << sect->alignment_power)));
   3367 		  sect->vma = last_vma;
   3368 		  last_vma += sz;
   3369 		}
   3370 
   3371 	      p->section = sect;
   3372 	      p->adj_vma = sect->vma;
   3373 	      p++;
   3374 	    }
   3375 	  if (abfd == stash->bfd_ptr)
   3376 	    break;
   3377 	  abfd = stash->bfd_ptr;
   3378 	}
   3379     }
   3380 
   3381   if (orig_bfd != stash->bfd_ptr)
   3382     set_debug_vma (orig_bfd, stash->bfd_ptr);
   3383 
   3384   return TRUE;
   3385 }
   3386 
   3387 /* Look up a funcinfo by name using the given info hash table.  If found,
   3388    also update the locations pointed to by filename_ptr and linenumber_ptr.
   3389 
   3390    This function returns TRUE if a funcinfo that matches the given symbol
   3391    and address is found with any error; otherwise it returns FALSE.  */
   3392 
   3393 static bfd_boolean
   3394 info_hash_lookup_funcinfo (struct info_hash_table *hash_table,
   3395 			   asymbol *sym,
   3396 			   bfd_vma addr,
   3397 			   const char **filename_ptr,
   3398 			   unsigned int *linenumber_ptr)
   3399 {
   3400   struct funcinfo* each_func;
   3401   struct funcinfo* best_fit = NULL;
   3402   bfd_vma best_fit_len = 0;
   3403   struct info_list_node *node;
   3404   struct arange *arange;
   3405   const char *name = bfd_asymbol_name (sym);
   3406   asection *sec = bfd_get_section (sym);
   3407 
   3408   for (node = lookup_info_hash_table (hash_table, name);
   3409        node;
   3410        node = node->next)
   3411     {
   3412       each_func = (struct funcinfo *) node->info;
   3413       for (arange = &each_func->arange;
   3414 	   arange;
   3415 	   arange = arange->next)
   3416 	{
   3417 	  if ((!each_func->sec || each_func->sec == sec)
   3418 	      && addr >= arange->low
   3419 	      && addr < arange->high
   3420 	      && (!best_fit
   3421 		  || arange->high - arange->low < best_fit_len))
   3422 	    {
   3423 	      best_fit = each_func;
   3424 	      best_fit_len = arange->high - arange->low;
   3425 	    }
   3426 	}
   3427     }
   3428 
   3429   if (best_fit)
   3430     {
   3431       best_fit->sec = sec;
   3432       *filename_ptr = best_fit->file;
   3433       *linenumber_ptr = best_fit->line;
   3434       return TRUE;
   3435     }
   3436 
   3437   return FALSE;
   3438 }
   3439 
   3440 /* Look up a varinfo by name using the given info hash table.  If found,
   3441    also update the locations pointed to by filename_ptr and linenumber_ptr.
   3442 
   3443    This function returns TRUE if a varinfo that matches the given symbol
   3444    and address is found with any error; otherwise it returns FALSE.  */
   3445 
   3446 static bfd_boolean
   3447 info_hash_lookup_varinfo (struct info_hash_table *hash_table,
   3448 			  asymbol *sym,
   3449 			  bfd_vma addr,
   3450 			  const char **filename_ptr,
   3451 			  unsigned int *linenumber_ptr)
   3452 {
   3453   const char *name = bfd_asymbol_name (sym);
   3454   asection *sec = bfd_get_section (sym);
   3455   struct varinfo* each;
   3456   struct info_list_node *node;
   3457 
   3458   for (node = lookup_info_hash_table (hash_table, name);
   3459        node;
   3460        node = node->next)
   3461     {
   3462       each = (struct varinfo *) node->info;
   3463       if (each->addr == addr
   3464 	  && (!each->sec || each->sec == sec))
   3465 	{
   3466 	  each->sec = sec;
   3467 	  *filename_ptr = each->file;
   3468 	  *linenumber_ptr = each->line;
   3469 	  return TRUE;
   3470 	}
   3471     }
   3472 
   3473   return FALSE;
   3474 }
   3475 
   3476 /* Update the funcinfo and varinfo info hash tables if they are
   3477    not up to date.  Returns TRUE if there is no error; otherwise
   3478    returns FALSE and disable the info hash tables.  */
   3479 
   3480 static bfd_boolean
   3481 stash_maybe_update_info_hash_tables (struct dwarf2_debug *stash)
   3482 {
   3483   struct comp_unit *each;
   3484 
   3485   /* Exit if hash tables are up-to-date.  */
   3486   if (stash->all_comp_units == stash->hash_units_head)
   3487     return TRUE;
   3488 
   3489   if (stash->hash_units_head)
   3490     each = stash->hash_units_head->prev_unit;
   3491   else
   3492     each = stash->last_comp_unit;
   3493 
   3494   while (each)
   3495     {
   3496       if (!comp_unit_hash_info (stash, each, stash->funcinfo_hash_table,
   3497 				stash->varinfo_hash_table))
   3498 	{
   3499 	  stash->info_hash_status = STASH_INFO_HASH_DISABLED;
   3500 	  return FALSE;
   3501 	}
   3502       each = each->prev_unit;
   3503     }
   3504 
   3505   stash->hash_units_head = stash->all_comp_units;
   3506   return TRUE;
   3507 }
   3508 
   3509 /* Check consistency of info hash tables.  This is for debugging only. */
   3510 
   3511 static void ATTRIBUTE_UNUSED
   3512 stash_verify_info_hash_table (struct dwarf2_debug *stash)
   3513 {
   3514   struct comp_unit *each_unit;
   3515   struct funcinfo *each_func;
   3516   struct varinfo *each_var;
   3517   struct info_list_node *node;
   3518   bfd_boolean found;
   3519 
   3520   for (each_unit = stash->all_comp_units;
   3521        each_unit;
   3522        each_unit = each_unit->next_unit)
   3523     {
   3524       for (each_func = each_unit->function_table;
   3525 	   each_func;
   3526 	   each_func = each_func->prev_func)
   3527 	{
   3528 	  if (!each_func->name)
   3529 	    continue;
   3530 	  node = lookup_info_hash_table (stash->funcinfo_hash_table,
   3531 					 each_func->name);
   3532 	  BFD_ASSERT (node);
   3533 	  found = FALSE;
   3534 	  while (node && !found)
   3535 	    {
   3536 	      found = node->info == each_func;
   3537 	      node = node->next;
   3538 	    }
   3539 	  BFD_ASSERT (found);
   3540 	}
   3541 
   3542       for (each_var = each_unit->variable_table;
   3543 	   each_var;
   3544 	   each_var = each_var->prev_var)
   3545 	{
   3546 	  if (!each_var->name || !each_var->file || each_var->stack)
   3547 	    continue;
   3548 	  node = lookup_info_hash_table (stash->varinfo_hash_table,
   3549 					 each_var->name);
   3550 	  BFD_ASSERT (node);
   3551 	  found = FALSE;
   3552 	  while (node && !found)
   3553 	    {
   3554 	      found = node->info == each_var;
   3555 	      node = node->next;
   3556 	    }
   3557 	  BFD_ASSERT (found);
   3558 	}
   3559     }
   3560 }
   3561 
   3562 /* Check to see if we want to enable the info hash tables, which consume
   3563    quite a bit of memory.  Currently we only check the number times
   3564    bfd_dwarf2_find_line is called.  In the future, we may also want to
   3565    take the number of symbols into account.  */
   3566 
   3567 static void
   3568 stash_maybe_enable_info_hash_tables (bfd *abfd, struct dwarf2_debug *stash)
   3569 {
   3570   BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_OFF);
   3571 
   3572   if (stash->info_hash_count++ < STASH_INFO_HASH_TRIGGER)
   3573     return;
   3574 
   3575   /* FIXME: Maybe we should check the reduce_memory_overheads
   3576      and optimize fields in the bfd_link_info structure ?  */
   3577 
   3578   /* Create hash tables.  */
   3579   stash->funcinfo_hash_table = create_info_hash_table (abfd);
   3580   stash->varinfo_hash_table = create_info_hash_table (abfd);
   3581   if (!stash->funcinfo_hash_table || !stash->varinfo_hash_table)
   3582     {
   3583       /* Turn off info hashes if any allocation above fails.  */
   3584       stash->info_hash_status = STASH_INFO_HASH_DISABLED;
   3585       return;
   3586     }
   3587   /* We need a forced update so that the info hash tables will
   3588      be created even though there is no compilation unit.  That
   3589      happens if STASH_INFO_HASH_TRIGGER is 0.  */
   3590   stash_maybe_update_info_hash_tables (stash);
   3591   stash->info_hash_status = STASH_INFO_HASH_ON;
   3592 }
   3593 
   3594 /* Find the file and line associated with a symbol and address using the
   3595    info hash tables of a stash. If there is a match, the function returns
   3596    TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
   3597    otherwise it returns FALSE.  */
   3598 
   3599 static bfd_boolean
   3600 stash_find_line_fast (struct dwarf2_debug *stash,
   3601 		      asymbol *sym,
   3602 		      bfd_vma addr,
   3603 		      const char **filename_ptr,
   3604 		      unsigned int *linenumber_ptr)
   3605 {
   3606   BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_ON);
   3607 
   3608   if (sym->flags & BSF_FUNCTION)
   3609     return info_hash_lookup_funcinfo (stash->funcinfo_hash_table, sym, addr,
   3610 				      filename_ptr, linenumber_ptr);
   3611   return info_hash_lookup_varinfo (stash->varinfo_hash_table, sym, addr,
   3612 				   filename_ptr, linenumber_ptr);
   3613 }
   3614 
   3615 /* Save current section VMAs.  */
   3616 
   3617 static bfd_boolean
   3618 save_section_vma (const bfd *abfd, struct dwarf2_debug *stash)
   3619 {
   3620   asection *s;
   3621   unsigned int i;
   3622 
   3623   if (abfd->section_count == 0)
   3624     return TRUE;
   3625   stash->sec_vma = bfd_malloc (sizeof (*stash->sec_vma) * abfd->section_count);
   3626   if (stash->sec_vma == NULL)
   3627     return FALSE;
   3628   for (i = 0, s = abfd->sections; i < abfd->section_count; i++, s = s->next)
   3629     {
   3630       if (s->output_section != NULL)
   3631 	stash->sec_vma[i] = s->output_section->vma + s->output_offset;
   3632       else
   3633 	stash->sec_vma[i] = s->vma;
   3634     }
   3635   return TRUE;
   3636 }
   3637 
   3638 /* Compare current section VMAs against those at the time the stash
   3639    was created.  If find_nearest_line is used in linker warnings or
   3640    errors early in the link process, the debug info stash will be
   3641    invalid for later calls.  This is because we relocate debug info
   3642    sections, so the stashed section contents depend on symbol values,
   3643    which in turn depend on section VMAs.  */
   3644 
   3645 static bfd_boolean
   3646 section_vma_same (const bfd *abfd, const struct dwarf2_debug *stash)
   3647 {
   3648   asection *s;
   3649   unsigned int i;
   3650 
   3651   for (i = 0, s = abfd->sections; i < abfd->section_count; i++, s = s->next)
   3652     {
   3653       bfd_vma vma;
   3654 
   3655       if (s->output_section != NULL)
   3656 	vma = s->output_section->vma + s->output_offset;
   3657       else
   3658 	vma = s->vma;
   3659       if (vma != stash->sec_vma[i])
   3660 	return FALSE;
   3661     }
   3662   return TRUE;
   3663 }
   3664 
   3665 /* Read debug information from DEBUG_BFD when DEBUG_BFD is specified.
   3666    If DEBUG_BFD is not specified, we read debug information from ABFD
   3667    or its gnu_debuglink. The results will be stored in PINFO.
   3668    The function returns TRUE iff debug information is ready.  */
   3669 
   3670 bfd_boolean
   3671 _bfd_dwarf2_slurp_debug_info (bfd *abfd, bfd *debug_bfd,
   3672 			      const struct dwarf_debug_section *debug_sections,
   3673 			      asymbol **symbols,
   3674 			      void **pinfo,
   3675 			      bfd_boolean do_place)
   3676 {
   3677   bfd_size_type amt = sizeof (struct dwarf2_debug);
   3678   bfd_size_type total_size;
   3679   asection *msec;
   3680   struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
   3681 
   3682   if (stash != NULL)
   3683     {
   3684       if (section_vma_same (abfd, stash))
   3685 	return TRUE;
   3686       _bfd_dwarf2_cleanup_debug_info (abfd, pinfo);
   3687       memset (stash, 0, amt);
   3688     }
   3689   else
   3690     {
   3691       stash = (struct dwarf2_debug *) bfd_zalloc (abfd, amt);
   3692       if (! stash)
   3693 	return FALSE;
   3694     }
   3695   stash->debug_sections = debug_sections;
   3696   stash->syms = symbols;
   3697   if (!save_section_vma (abfd, stash))
   3698     return FALSE;
   3699 
   3700   *pinfo = stash;
   3701 
   3702   if (debug_bfd == NULL)
   3703     debug_bfd = abfd;
   3704 
   3705   msec = find_debug_info (debug_bfd, debug_sections, NULL);
   3706   if (msec == NULL && abfd == debug_bfd)
   3707     {
   3708       char * debug_filename = bfd_follow_gnu_debuglink (abfd, DEBUGDIR);
   3709 
   3710       if (debug_filename == NULL)
   3711 	/* No dwarf2 info, and no gnu_debuglink to follow.
   3712 	   Note that at this point the stash has been allocated, but
   3713 	   contains zeros.  This lets future calls to this function
   3714 	   fail more quickly.  */
   3715 	return FALSE;
   3716 
   3717       /* Set BFD_DECOMPRESS to decompress debug sections.  */
   3718       if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
   3719 	  || !(debug_bfd->flags |= BFD_DECOMPRESS,
   3720 	       bfd_check_format (debug_bfd, bfd_object))
   3721 	  || (msec = find_debug_info (debug_bfd,
   3722 				      debug_sections, NULL)) == NULL
   3723 	  || !bfd_generic_link_read_symbols (debug_bfd))
   3724 	{
   3725 	  if (debug_bfd)
   3726 	    bfd_close (debug_bfd);
   3727 	  /* FIXME: Should we report our failure to follow the debuglink ?  */
   3728 	  free (debug_filename);
   3729 	  return FALSE;
   3730 	}
   3731 
   3732       symbols = bfd_get_outsymbols (debug_bfd);
   3733       stash->syms = symbols;
   3734       stash->close_on_cleanup = TRUE;
   3735     }
   3736   stash->bfd_ptr = debug_bfd;
   3737 
   3738   if (do_place
   3739       && !place_sections (abfd, stash))
   3740     return FALSE;
   3741 
   3742   /* There can be more than one DWARF2 info section in a BFD these
   3743      days.  First handle the easy case when there's only one.  If
   3744      there's more than one, try case two: none of the sections is
   3745      compressed.  In that case, read them all in and produce one
   3746      large stash.  We do this in two passes - in the first pass we
   3747      just accumulate the section sizes, and in the second pass we
   3748      read in the section's contents.  (The allows us to avoid
   3749      reallocing the data as we add sections to the stash.)  If
   3750      some or all sections are compressed, then do things the slow
   3751      way, with a bunch of reallocs.  */
   3752 
   3753   if (! find_debug_info (debug_bfd, debug_sections, msec))
   3754     {
   3755       /* Case 1: only one info section.  */
   3756       total_size = msec->size;
   3757       if (! read_section (debug_bfd, &stash->debug_sections[debug_info],
   3758 			  symbols, 0,
   3759 			  &stash->info_ptr_memory, &total_size))
   3760 	return FALSE;
   3761     }
   3762   else
   3763     {
   3764       /* Case 2: multiple sections.  */
   3765       for (total_size = 0;
   3766 	   msec;
   3767 	   msec = find_debug_info (debug_bfd, debug_sections, msec))
   3768 	total_size += msec->size;
   3769 
   3770       stash->info_ptr_memory = (bfd_byte *) bfd_malloc (total_size);
   3771       if (stash->info_ptr_memory == NULL)
   3772 	return FALSE;
   3773 
   3774       total_size = 0;
   3775       for (msec = find_debug_info (debug_bfd, debug_sections, NULL);
   3776 	   msec;
   3777 	   msec = find_debug_info (debug_bfd, debug_sections, msec))
   3778 	{
   3779 	  bfd_size_type size;
   3780 
   3781 	  size = msec->size;
   3782 	  if (size == 0)
   3783 	    continue;
   3784 
   3785 	  if (!(bfd_simple_get_relocated_section_contents
   3786 		(debug_bfd, msec, stash->info_ptr_memory + total_size,
   3787 		 symbols)))
   3788 	    return FALSE;
   3789 
   3790 	  total_size += size;
   3791 	}
   3792     }
   3793 
   3794   stash->info_ptr = stash->info_ptr_memory;
   3795   stash->info_ptr_end = stash->info_ptr + total_size;
   3796   stash->sec = find_debug_info (debug_bfd, debug_sections, NULL);
   3797   stash->sec_info_ptr = stash->info_ptr;
   3798   return TRUE;
   3799 }
   3800 
   3801 /* Scan the debug information in PINFO looking for a DW_TAG_subprogram
   3802    abbrev with a DW_AT_low_pc attached to it.  Then lookup that same
   3803    symbol in SYMBOLS and return the difference between the low_pc and
   3804    the symbol's address.  Returns 0 if no suitable symbol could be found.  */
   3805 
   3806 bfd_signed_vma
   3807 _bfd_dwarf2_find_symbol_bias (asymbol ** symbols, void ** pinfo)
   3808 {
   3809   struct dwarf2_debug *stash;
   3810   struct comp_unit * unit;
   3811 
   3812   stash = (struct dwarf2_debug *) *pinfo;
   3813 
   3814   if (stash == NULL)
   3815     return 0;
   3816 
   3817   for (unit = stash->all_comp_units; unit; unit = unit->next_unit)
   3818     {
   3819       struct funcinfo * func;
   3820 
   3821       if (unit->function_table == NULL)
   3822 	{
   3823 	  if (unit->line_table == NULL)
   3824 	    unit->line_table = decode_line_info (unit, stash);
   3825 	  if (unit->line_table != NULL)
   3826 	    scan_unit_for_symbols (unit);
   3827 	}
   3828 
   3829       for (func = unit->function_table; func != NULL; func = func->prev_func)
   3830 	if (func->name && func->arange.low)
   3831 	  {
   3832 	    asymbol ** psym;
   3833 
   3834 	    /* FIXME: Do we need to scan the aranges looking for the lowest pc value ?  */
   3835 
   3836 	    for (psym = symbols; * psym != NULL; psym++)
   3837 	      {
   3838 		asymbol * sym = * psym;
   3839 
   3840 		if (sym->flags & BSF_FUNCTION
   3841 		    && sym->section != NULL
   3842 		    && strcmp (sym->name, func->name) == 0)
   3843 		  return ((bfd_signed_vma) func->arange.low) -
   3844 		    ((bfd_signed_vma) (sym->value + sym->section->vma));
   3845 	      }
   3846 	  }
   3847     }
   3848 
   3849   return 0;
   3850 }
   3851 
   3852 /* Find the source code location of SYMBOL.  If SYMBOL is NULL
   3853    then find the nearest source code location corresponding to
   3854    the address SECTION + OFFSET.
   3855    Returns TRUE if the line is found without error and fills in
   3856    FILENAME_PTR and LINENUMBER_PTR.  In the case where SYMBOL was
   3857    NULL the FUNCTIONNAME_PTR is also filled in.
   3858    SYMBOLS contains the symbol table for ABFD.
   3859    DEBUG_SECTIONS contains the name of the dwarf debug sections.
   3860    ADDR_SIZE is the number of bytes in the initial .debug_info length
   3861    field and in the abbreviation offset, or zero to indicate that the
   3862    default value should be used.  */
   3863 
   3864 bfd_boolean
   3865 _bfd_dwarf2_find_nearest_line (bfd *abfd,
   3866 			       asymbol **symbols,
   3867 			       asymbol *symbol,
   3868 			       asection *section,
   3869 			       bfd_vma offset,
   3870 			       const char **filename_ptr,
   3871 			       const char **functionname_ptr,
   3872 			       unsigned int *linenumber_ptr,
   3873 			       unsigned int *discriminator_ptr,
   3874 			       const struct dwarf_debug_section *debug_sections,
   3875 			       unsigned int addr_size,
   3876 			       void **pinfo)
   3877 {
   3878   /* Read each compilation unit from the section .debug_info, and check
   3879      to see if it contains the address we are searching for.  If yes,
   3880      lookup the address, and return the line number info.  If no, go
   3881      on to the next compilation unit.
   3882 
   3883      We keep a list of all the previously read compilation units, and
   3884      a pointer to the next un-read compilation unit.  Check the
   3885      previously read units before reading more.  */
   3886   struct dwarf2_debug *stash;
   3887   /* What address are we looking for?  */
   3888   bfd_vma addr;
   3889   struct comp_unit* each;
   3890   struct funcinfo *function = NULL;
   3891   bfd_boolean found = FALSE;
   3892   bfd_boolean do_line;
   3893 
   3894   *filename_ptr = NULL;
   3895   if (functionname_ptr != NULL)
   3896     *functionname_ptr = NULL;
   3897   *linenumber_ptr = 0;
   3898   if (discriminator_ptr)
   3899     *discriminator_ptr = 0;
   3900 
   3901   if (! _bfd_dwarf2_slurp_debug_info (abfd, NULL, debug_sections,
   3902 				      symbols, pinfo,
   3903 				      (abfd->flags & (EXEC_P | DYNAMIC)) == 0))
   3904     return FALSE;
   3905 
   3906   stash = (struct dwarf2_debug *) *pinfo;
   3907 
   3908   do_line = symbol != NULL;
   3909   if (do_line)
   3910     {
   3911       BFD_ASSERT (section == NULL && offset == 0 && functionname_ptr == NULL);
   3912       section = bfd_get_section (symbol);
   3913       addr = symbol->value;
   3914     }
   3915   else
   3916     {
   3917       BFD_ASSERT (section != NULL && functionname_ptr != NULL);
   3918       addr = offset;
   3919     }
   3920 
   3921   if (section->output_section)
   3922     addr += section->output_section->vma + section->output_offset;
   3923   else
   3924     addr += section->vma;
   3925 
   3926   /* A null info_ptr indicates that there is no dwarf2 info
   3927      (or that an error occured while setting up the stash).  */
   3928   if (! stash->info_ptr)
   3929     return FALSE;
   3930 
   3931   stash->inliner_chain = NULL;
   3932 
   3933   /* Check the previously read comp. units first.  */
   3934   if (do_line)
   3935     {
   3936       /* The info hash tables use quite a bit of memory.  We may not want to
   3937 	 always use them.  We use some heuristics to decide if and when to
   3938 	 turn it on.  */
   3939       if (stash->info_hash_status == STASH_INFO_HASH_OFF)
   3940 	stash_maybe_enable_info_hash_tables (abfd, stash);
   3941 
   3942       /* Keep info hash table up to date if they are available.  Note that we
   3943 	 may disable the hash tables if there is any error duing update. */
   3944       if (stash->info_hash_status == STASH_INFO_HASH_ON)
   3945 	stash_maybe_update_info_hash_tables (stash);
   3946 
   3947       if (stash->info_hash_status == STASH_INFO_HASH_ON)
   3948 	{
   3949 	  found = stash_find_line_fast (stash, symbol, addr, filename_ptr,
   3950 					linenumber_ptr);
   3951 	  if (found)
   3952 	    goto done;
   3953 	}
   3954       else
   3955 	{
   3956 	  /* Check the previously read comp. units first.  */
   3957 	  for (each = stash->all_comp_units; each; each = each->next_unit)
   3958 	    if ((symbol->flags & BSF_FUNCTION) == 0
   3959 		|| each->arange.high == 0
   3960 		|| comp_unit_contains_address (each, addr))
   3961 	      {
   3962 		found = comp_unit_find_line (each, symbol, addr, filename_ptr,
   3963 					     linenumber_ptr, stash);
   3964 		if (found)
   3965 		  goto done;
   3966 	      }
   3967 	}
   3968     }
   3969   else
   3970     {
   3971       bfd_vma min_range = (bfd_vma) -1;
   3972       const char * local_filename = NULL;
   3973       struct funcinfo *local_function = NULL;
   3974       unsigned int local_linenumber = 0;
   3975       unsigned int local_discriminator = 0;
   3976 
   3977       for (each = stash->all_comp_units; each; each = each->next_unit)
   3978 	{
   3979 	  bfd_vma range = (bfd_vma) -1;
   3980 
   3981 	  found = ((each->arange.high == 0
   3982 		    || comp_unit_contains_address (each, addr))
   3983 		   && (range = comp_unit_find_nearest_line (each, addr,
   3984 							    & local_filename,
   3985 							    & local_function,
   3986 							    & local_linenumber,
   3987 							    & local_discriminator,
   3988 							    stash)) != 0);
   3989 	  if (found)
   3990 	    {
   3991 	      /* PRs 15935 15994: Bogus debug information may have provided us
   3992 		 with an erroneous match.  We attempt to counter this by
   3993 		 selecting the match that has the smallest address range
   3994 		 associated with it.  (We are assuming that corrupt debug info
   3995 		 will tend to result in extra large address ranges rather than
   3996 		 extra small ranges).
   3997 
   3998 		 This does mean that we scan through all of the CUs associated
   3999 		 with the bfd each time this function is called.  But this does
   4000 		 have the benefit of producing consistent results every time the
   4001 		 function is called.  */
   4002 	      if (range <= min_range)
   4003 		{
   4004 		  if (filename_ptr && local_filename)
   4005 		    * filename_ptr = local_filename;
   4006 		  if (local_function)
   4007 		    function = local_function;
   4008 		  if (discriminator_ptr && local_discriminator)
   4009 		    * discriminator_ptr = local_discriminator;
   4010 		  if (local_linenumber)
   4011 		    * linenumber_ptr = local_linenumber;
   4012 		  min_range = range;
   4013 		}
   4014 	    }
   4015 	}
   4016 
   4017       if (* linenumber_ptr)
   4018 	{
   4019 	  found = TRUE;
   4020 	  goto done;
   4021 	}
   4022     }
   4023 
   4024   /* The DWARF2 spec says that the initial length field, and the
   4025      offset of the abbreviation table, should both be 4-byte values.
   4026      However, some compilers do things differently.  */
   4027   if (addr_size == 0)
   4028     addr_size = 4;
   4029   BFD_ASSERT (addr_size == 4 || addr_size == 8);
   4030 
   4031   /* Read each remaining comp. units checking each as they are read.  */
   4032   while (stash->info_ptr < stash->info_ptr_end)
   4033     {
   4034       bfd_vma length;
   4035       unsigned int offset_size = addr_size;
   4036       bfd_byte *info_ptr_unit = stash->info_ptr;
   4037 
   4038       length = read_4_bytes (stash->bfd_ptr, stash->info_ptr, stash->info_ptr_end);
   4039       /* A 0xffffff length is the DWARF3 way of indicating
   4040 	 we use 64-bit offsets, instead of 32-bit offsets.  */
   4041       if (length == 0xffffffff)
   4042 	{
   4043 	  offset_size = 8;
   4044 	  length = read_8_bytes (stash->bfd_ptr, stash->info_ptr + 4, stash->info_ptr_end);
   4045 	  stash->info_ptr += 12;
   4046 	}
   4047       /* A zero length is the IRIX way of indicating 64-bit offsets,
   4048 	 mostly because the 64-bit length will generally fit in 32
   4049 	 bits, and the endianness helps.  */
   4050       else if (length == 0)
   4051 	{
   4052 	  offset_size = 8;
   4053 	  length = read_4_bytes (stash->bfd_ptr, stash->info_ptr + 4, stash->info_ptr_end);
   4054 	  stash->info_ptr += 8;
   4055 	}
   4056       /* In the absence of the hints above, we assume 32-bit DWARF2
   4057 	 offsets even for targets with 64-bit addresses, because:
   4058 	   a) most of the time these targets will not have generated
   4059 	      more than 2Gb of debug info and so will not need 64-bit
   4060 	      offsets,
   4061 	 and
   4062 	   b) if they do use 64-bit offsets but they are not using
   4063 	      the size hints that are tested for above then they are
   4064 	      not conforming to the DWARF3 standard anyway.  */
   4065       else if (addr_size == 8)
   4066 	{
   4067 	  offset_size = 4;
   4068 	  stash->info_ptr += 4;
   4069 	}
   4070       else
   4071 	stash->info_ptr += 4;
   4072 
   4073       if (length > 0)
   4074 	{
   4075 	  bfd_byte * new_ptr;
   4076 
   4077 	  each = parse_comp_unit (stash, length, info_ptr_unit,
   4078 				  offset_size);
   4079 	  if (!each)
   4080 	    /* The dwarf information is damaged, don't trust it any
   4081 	       more.  */
   4082 	    break;
   4083 
   4084 	  new_ptr = stash->info_ptr + length;
   4085 	  /* PR 17512: file: 1500698c.  */
   4086 	  if (new_ptr < stash->info_ptr)
   4087 	    {
   4088 	      /* A corrupt length value - do not trust the info any more.  */
   4089 	      found = FALSE;
   4090 	      break;
   4091 	    }
   4092 	  else
   4093 	    stash->info_ptr = new_ptr;
   4094 
   4095 	  if (stash->all_comp_units)
   4096 	    stash->all_comp_units->prev_unit = each;
   4097 	  else
   4098 	    stash->last_comp_unit = each;
   4099 
   4100 	  each->next_unit = stash->all_comp_units;
   4101 	  stash->all_comp_units = each;
   4102 
   4103 	  /* DW_AT_low_pc and DW_AT_high_pc are optional for
   4104 	     compilation units.  If we don't have them (i.e.,
   4105 	     unit->high == 0), we need to consult the line info table
   4106 	     to see if a compilation unit contains the given
   4107 	     address.  */
   4108 	  if (do_line)
   4109 	    found = (((symbol->flags & BSF_FUNCTION) == 0
   4110 		      || each->arange.high == 0
   4111 		      || comp_unit_contains_address (each, addr))
   4112 		     && comp_unit_find_line (each, symbol, addr,
   4113 					     filename_ptr,
   4114 					     linenumber_ptr,
   4115 					     stash));
   4116 	  else
   4117 	    found = ((each->arange.high == 0
   4118 		      || comp_unit_contains_address (each, addr))
   4119 		     && comp_unit_find_nearest_line (each, addr,
   4120 						     filename_ptr,
   4121 						     &function,
   4122 						     linenumber_ptr,
   4123 						     discriminator_ptr,
   4124 						     stash) != 0);
   4125 
   4126 	  if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
   4127 	      == stash->sec->size)
   4128 	    {
   4129 	      stash->sec = find_debug_info (stash->bfd_ptr, debug_sections,
   4130 					    stash->sec);
   4131 	      stash->sec_info_ptr = stash->info_ptr;
   4132 	    }
   4133 
   4134 	  if (found)
   4135 	    goto done;
   4136 	}
   4137     }
   4138 
   4139  done:
   4140   if (function)
   4141     {
   4142       if (!function->is_linkage)
   4143 	{
   4144 	  asymbol *fun;
   4145 	  bfd_vma sec_vma;
   4146 
   4147 	  fun = _bfd_elf_find_function (abfd, symbols, section, offset,
   4148 					*filename_ptr ? NULL : filename_ptr,
   4149 					functionname_ptr);
   4150 	  sec_vma = section->vma;
   4151 	  if (section->output_section != NULL)
   4152 	    sec_vma = section->output_section->vma + section->output_offset;
   4153 	  if (fun != NULL
   4154 	      && fun->value + sec_vma == function->arange.low)
   4155 	    function->name = *functionname_ptr;
   4156 	  /* Even if we didn't find a linkage name, say that we have
   4157 	     to stop a repeated search of symbols.  */
   4158 	  function->is_linkage = TRUE;
   4159 	}
   4160       *functionname_ptr = function->name;
   4161     }
   4162   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
   4163     unset_sections (stash);
   4164 
   4165   return found;
   4166 }
   4167 
   4168 bfd_boolean
   4169 _bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED,
   4170 			       const char **filename_ptr,
   4171 			       const char **functionname_ptr,
   4172 			       unsigned int *linenumber_ptr,
   4173 			       void **pinfo)
   4174 {
   4175   struct dwarf2_debug *stash;
   4176 
   4177   stash = (struct dwarf2_debug *) *pinfo;
   4178   if (stash)
   4179     {
   4180       struct funcinfo *func = stash->inliner_chain;
   4181 
   4182       if (func && func->caller_func)
   4183 	{
   4184 	  *filename_ptr = func->caller_file;
   4185 	  *functionname_ptr = func->caller_func->name;
   4186 	  *linenumber_ptr = func->caller_line;
   4187 	  stash->inliner_chain = func->caller_func;
   4188 	  return TRUE;
   4189 	}
   4190     }
   4191 
   4192   return FALSE;
   4193 }
   4194 
   4195 void
   4196 _bfd_dwarf2_cleanup_debug_info (bfd *abfd, void **pinfo)
   4197 {
   4198   struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
   4199   struct comp_unit *each;
   4200 
   4201   if (abfd == NULL || stash == NULL)
   4202     return;
   4203 
   4204   for (each = stash->all_comp_units; each; each = each->next_unit)
   4205     {
   4206       struct abbrev_info **abbrevs = each->abbrevs;
   4207       struct funcinfo *function_table = each->function_table;
   4208       struct varinfo *variable_table = each->variable_table;
   4209       size_t i;
   4210 
   4211       for (i = 0; i < ABBREV_HASH_SIZE; i++)
   4212 	{
   4213 	  struct abbrev_info *abbrev = abbrevs[i];
   4214 
   4215 	  while (abbrev)
   4216 	    {
   4217 	      free (abbrev->attrs);
   4218 	      abbrev = abbrev->next;
   4219 	    }
   4220 	}
   4221 
   4222       if (each->line_table)
   4223 	{
   4224 	  free (each->line_table->dirs);
   4225 	  free (each->line_table->files);
   4226 	}
   4227 
   4228       while (function_table)
   4229 	{
   4230 	  if (function_table->file)
   4231 	    {
   4232 	      free (function_table->file);
   4233 	      function_table->file = NULL;
   4234 	    }
   4235 
   4236 	  if (function_table->caller_file)
   4237 	    {
   4238 	      free (function_table->caller_file);
   4239 	      function_table->caller_file = NULL;
   4240 	    }
   4241 	  function_table = function_table->prev_func;
   4242 	}
   4243 
   4244       while (variable_table)
   4245 	{
   4246 	  if (variable_table->file)
   4247 	    {
   4248 	      free (variable_table->file);
   4249 	      variable_table->file = NULL;
   4250 	    }
   4251 
   4252 	  variable_table = variable_table->prev_var;
   4253 	}
   4254     }
   4255 
   4256   if (stash->dwarf_abbrev_buffer)
   4257     free (stash->dwarf_abbrev_buffer);
   4258   if (stash->dwarf_line_buffer)
   4259     free (stash->dwarf_line_buffer);
   4260   if (stash->dwarf_str_buffer)
   4261     free (stash->dwarf_str_buffer);
   4262   if (stash->dwarf_ranges_buffer)
   4263     free (stash->dwarf_ranges_buffer);
   4264   if (stash->info_ptr_memory)
   4265     free (stash->info_ptr_memory);
   4266   if (stash->close_on_cleanup)
   4267     bfd_close (stash->bfd_ptr);
   4268   if (stash->alt_dwarf_str_buffer)
   4269     free (stash->alt_dwarf_str_buffer);
   4270   if (stash->alt_dwarf_info_buffer)
   4271     free (stash->alt_dwarf_info_buffer);
   4272   if (stash->sec_vma)
   4273     free (stash->sec_vma);
   4274   if (stash->adjusted_sections)
   4275     free (stash->adjusted_sections);
   4276   if (stash->alt_bfd_ptr)
   4277     bfd_close (stash->alt_bfd_ptr);
   4278 }
   4279 
   4280 /* Find the function to a particular section and offset,
   4281    for error reporting.  */
   4282 
   4283 asymbol *
   4284 _bfd_elf_find_function (bfd *abfd,
   4285 			asymbol **symbols,
   4286 			asection *section,
   4287 			bfd_vma offset,
   4288 			const char **filename_ptr,
   4289 			const char **functionname_ptr)
   4290 {
   4291   struct elf_find_function_cache
   4292   {
   4293     asection *last_section;
   4294     asymbol *func;
   4295     const char *filename;
   4296     bfd_size_type func_size;
   4297   } *cache;
   4298 
   4299   if (symbols == NULL)
   4300     return NULL;
   4301 
   4302   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
   4303     return NULL;
   4304 
   4305   cache = elf_tdata (abfd)->elf_find_function_cache;
   4306   if (cache == NULL)
   4307     {
   4308       cache = bfd_zalloc (abfd, sizeof (*cache));
   4309       elf_tdata (abfd)->elf_find_function_cache = cache;
   4310       if (cache == NULL)
   4311 	return NULL;
   4312     }
   4313   if (cache->last_section != section
   4314       || cache->func == NULL
   4315       || offset < cache->func->value
   4316       || offset >= cache->func->value + cache->func_size)
   4317     {
   4318       asymbol *file;
   4319       bfd_vma low_func;
   4320       asymbol **p;
   4321       /* ??? Given multiple file symbols, it is impossible to reliably
   4322 	 choose the right file name for global symbols.  File symbols are
   4323 	 local symbols, and thus all file symbols must sort before any
   4324 	 global symbols.  The ELF spec may be interpreted to say that a
   4325 	 file symbol must sort before other local symbols, but currently
   4326 	 ld -r doesn't do this.  So, for ld -r output, it is possible to
   4327 	 make a better choice of file name for local symbols by ignoring
   4328 	 file symbols appearing after a given local symbol.  */
   4329       enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
   4330       const struct elf_backend_data *bed = get_elf_backend_data (abfd);
   4331 
   4332       file = NULL;
   4333       low_func = 0;
   4334       state = nothing_seen;
   4335       cache->filename = NULL;
   4336       cache->func = NULL;
   4337       cache->func_size = 0;
   4338       cache->last_section = section;
   4339 
   4340       for (p = symbols; *p != NULL; p++)
   4341 	{
   4342 	  asymbol *sym = *p;
   4343 	  bfd_vma code_off;
   4344 	  bfd_size_type size;
   4345 
   4346 	  if ((sym->flags & BSF_FILE) != 0)
   4347 	    {
   4348 	      file = sym;
   4349 	      if (state == symbol_seen)
   4350 		state = file_after_symbol_seen;
   4351 	      continue;
   4352 	    }
   4353 
   4354 	  size = bed->maybe_function_sym (sym, section, &code_off);
   4355 	  if (size != 0
   4356 	      && code_off <= offset
   4357 	      && (code_off > low_func
   4358 		  || (code_off == low_func
   4359 		      && size > cache->func_size)))
   4360 	    {
   4361 	      cache->func = sym;
   4362 	      cache->func_size = size;
   4363 	      cache->filename = NULL;
   4364 	      low_func = code_off;
   4365 	      if (file != NULL
   4366 		  && ((sym->flags & BSF_LOCAL) != 0
   4367 		      || state != file_after_symbol_seen))
   4368 		cache->filename = bfd_asymbol_name (file);
   4369 	    }
   4370 	  if (state == nothing_seen)
   4371 	    state = symbol_seen;
   4372 	}
   4373     }
   4374 
   4375   if (cache->func == NULL)
   4376     return NULL;
   4377 
   4378   if (filename_ptr)
   4379     *filename_ptr = cache->filename;
   4380   if (functionname_ptr)
   4381     *functionname_ptr = bfd_asymbol_name (cache->func);
   4382 
   4383   return cache->func;
   4384 }
   4385