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