bfd/dwarf2.c

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