2006-01-17 H.J. Lu <hongjiu.lu@intel.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 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 2 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, MA 02110-1301, USA.  */
31
32 #include "bfd.h"
33 #include "sysdep.h"
34 #include "libiberty.h"
35 #include "libbfd.h"
36 #include "elf-bfd.h"
37 #include "elf/dwarf2.h"
38
39 /* The data in the .debug_line statement prologue looks like this.  */
40
41 struct line_head
42 {
43   bfd_vma total_length;
44   unsigned short version;
45   bfd_vma prologue_length;
46   unsigned char minimum_instruction_length;
47   unsigned char default_is_stmt;
48   int line_base;
49   unsigned char line_range;
50   unsigned char opcode_base;
51   unsigned char *standard_opcode_lengths;
52 };
53
54 /* Attributes have a name and a value.  */
55
56 struct attribute
57 {
58   enum dwarf_attribute name;
59   enum dwarf_form form;
60   union
61   {
62     char *str;
63     struct dwarf_block *blk;
64     bfd_uint64_t val;
65     bfd_int64_t sval;
66   }
67   u;
68 };
69
70 /* Blocks are a bunch of untyped bytes.  */
71 struct dwarf_block
72 {
73   unsigned int size;
74   bfd_byte *data;
75 };
76
77 struct dwarf2_debug
78 {
79   /* A list of all previously read comp_units.  */
80   struct comp_unit *all_comp_units;
81
82   /* The next unread compilation unit within the .debug_info section.
83      Zero indicates that the .debug_info section has not been loaded
84      into a buffer yet.  */
85   bfd_byte *info_ptr;
86
87   /* Pointer to the end of the .debug_info section memory buffer.  */
88   bfd_byte *info_ptr_end;
89
90   /* Pointer to the section and address of the beginning of the
91      section.  */
92   asection *sec;
93   bfd_byte *sec_info_ptr;
94
95   /* Pointer to the symbol table.  */
96   asymbol **syms;
97
98   /* Pointer to the .debug_abbrev section loaded into memory.  */
99   bfd_byte *dwarf_abbrev_buffer;
100
101   /* Length of the loaded .debug_abbrev section.  */
102   unsigned long dwarf_abbrev_size;
103
104   /* Buffer for decode_line_info.  */
105   bfd_byte *dwarf_line_buffer;
106
107   /* Length of the loaded .debug_line section.  */
108   unsigned long dwarf_line_size;
109
110   /* Pointer to the .debug_str section loaded into memory.  */
111   bfd_byte *dwarf_str_buffer;
112
113   /* Length of the loaded .debug_str section.  */
114   unsigned long dwarf_str_size;
115
116   /* Pointer to the .debug_ranges section loaded into memory. */
117   bfd_byte *dwarf_ranges_buffer;
118
119   /* Length of the loaded .debug_ranges section. */
120   unsigned long dwarf_ranges_size;
121
122   /* If the most recent call to bfd_find_nearest_line was given an
123      address in an inlined function, preserve a pointer into the
124      calling chain for subsequent calls to bfd_find_inliner_info to
125      use. */
126   struct funcinfo *inliner_chain;
127 };
128
129 struct arange
130 {
131   struct arange *next;
132   bfd_vma low;
133   bfd_vma high;
134 };
135
136 /* A minimal decoding of DWARF2 compilation units.  We only decode
137    what's needed to get to the line number information.  */
138
139 struct comp_unit
140 {
141   /* Chain the previously read compilation units.  */
142   struct comp_unit *next_unit;
143
144   /* Keep the bfd convenient (for memory allocation).  */
145   bfd *abfd;
146
147   /* The lowest and highest addresses contained in this compilation
148      unit as specified in the compilation unit header.  */
149   struct arange arange;
150
151   /* The DW_AT_name attribute (for error messages).  */
152   char *name;
153
154   /* The abbrev hash table.  */
155   struct abbrev_info **abbrevs;
156
157   /* Note that an error was found by comp_unit_find_nearest_line.  */
158   int error;
159
160   /* The DW_AT_comp_dir attribute.  */
161   char *comp_dir;
162
163   /* TRUE if there is a line number table associated with this comp. unit.  */
164   int stmtlist;
165
166   /* Pointer to the current comp_unit so that we can find a given entry
167      by its reference.  */
168   bfd_byte *info_ptr_unit;
169
170   /* The offset into .debug_line of the line number table.  */
171   unsigned long line_offset;
172
173   /* Pointer to the first child die for the comp unit.  */
174   bfd_byte *first_child_die_ptr;
175
176   /* The end of the comp unit.  */
177   bfd_byte *end_ptr;
178
179   /* The decoded line number, NULL if not yet decoded.  */
180   struct line_info_table *line_table;
181
182   /* A list of the functions found in this comp. unit.  */
183   struct funcinfo *function_table;
184
185   /* A list of the variables found in this comp. unit.  */
186   struct varinfo *variable_table;
187
188   /* Pointer to dwarf2_debug structure.  */
189   struct dwarf2_debug *stash;
190
191   /* Address size for this unit - from unit header.  */
192   unsigned char addr_size;
193
194   /* Offset size for this unit - from unit header.  */
195   unsigned char offset_size;
196
197   /* Base address for this unit - from DW_AT_low_pc attribute of
198      DW_TAG_compile_unit DIE */
199   bfd_vma base_address;
200 };
201
202 /* This data structure holds the information of an abbrev.  */
203 struct abbrev_info
204 {
205   unsigned int number;          /* Number identifying abbrev.  */
206   enum dwarf_tag tag;           /* DWARF tag.  */
207   int has_children;             /* Boolean.  */
208   unsigned int num_attrs;       /* Number of attributes.  */
209   struct attr_abbrev *attrs;    /* An array of attribute descriptions.  */
210   struct abbrev_info *next;     /* Next in chain.  */
211 };
212
213 struct attr_abbrev
214 {
215   enum dwarf_attribute name;
216   enum dwarf_form form;
217 };
218
219 #ifndef ABBREV_HASH_SIZE
220 #define ABBREV_HASH_SIZE 121
221 #endif
222 #ifndef ATTR_ALLOC_CHUNK
223 #define ATTR_ALLOC_CHUNK 4
224 #endif
225
226 /* VERBATIM
227    The following function up to the END VERBATIM mark are
228    copied directly from dwarf2read.c.  */
229
230 /* Read dwarf information from a buffer.  */
231
232 static unsigned int
233 read_1_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf)
234 {
235   return bfd_get_8 (abfd, buf);
236 }
237
238 static int
239 read_1_signed_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf)
240 {
241   return bfd_get_signed_8 (abfd, buf);
242 }
243
244 static unsigned int
245 read_2_bytes (bfd *abfd, bfd_byte *buf)
246 {
247   return bfd_get_16 (abfd, buf);
248 }
249
250 static unsigned int
251 read_4_bytes (bfd *abfd, bfd_byte *buf)
252 {
253   return bfd_get_32 (abfd, buf);
254 }
255
256 static bfd_uint64_t
257 read_8_bytes (bfd *abfd, bfd_byte *buf)
258 {
259   return bfd_get_64 (abfd, buf);
260 }
261
262 static bfd_byte *
263 read_n_bytes (bfd *abfd ATTRIBUTE_UNUSED,
264               bfd_byte *buf,
265               unsigned int size ATTRIBUTE_UNUSED)
266 {
267   /* If the size of a host char is 8 bits, we can return a pointer
268      to the buffer, otherwise we have to copy the data to a buffer
269      allocated on the temporary obstack.  */
270   return buf;
271 }
272
273 static char *
274 read_string (bfd *abfd ATTRIBUTE_UNUSED,
275              bfd_byte *buf,
276              unsigned int *bytes_read_ptr)
277 {
278   /* Return a pointer to the embedded string.  */
279   char *str = (char *) buf;
280   if (*str == '\0')
281     {
282       *bytes_read_ptr = 1;
283       return NULL;
284     }
285
286   *bytes_read_ptr = strlen (str) + 1;
287   return str;
288 }
289
290 static char *
291 read_indirect_string (struct comp_unit* unit,
292                       bfd_byte *buf,
293                       unsigned int *bytes_read_ptr)
294 {
295   bfd_uint64_t offset;
296   struct dwarf2_debug *stash = unit->stash;
297   char *str;
298
299   if (unit->offset_size == 4)
300     offset = read_4_bytes (unit->abfd, buf);
301   else
302     offset = read_8_bytes (unit->abfd, buf);
303   *bytes_read_ptr = unit->offset_size;
304
305   if (! stash->dwarf_str_buffer)
306     {
307       asection *msec;
308       bfd *abfd = unit->abfd;
309       bfd_size_type sz;
310
311       msec = bfd_get_section_by_name (abfd, ".debug_str");
312       if (! msec)
313         {
314           (*_bfd_error_handler)
315             (_("Dwarf Error: Can't find .debug_str section."));
316           bfd_set_error (bfd_error_bad_value);
317           return NULL;
318         }
319
320       sz = msec->rawsize ? msec->rawsize : msec->size;
321       stash->dwarf_str_size = sz;
322       stash->dwarf_str_buffer = bfd_alloc (abfd, sz);
323       if (! stash->dwarf_str_buffer)
324         return NULL;
325
326       if (! bfd_get_section_contents (abfd, msec, stash->dwarf_str_buffer,
327                                       0, sz))
328         return NULL;
329     }
330
331   if (offset >= stash->dwarf_str_size)
332     {
333       (*_bfd_error_handler) (_("Dwarf Error: DW_FORM_strp offset (%lu) greater than or equal to .debug_str size (%lu)."),
334                              (unsigned long) offset, stash->dwarf_str_size);
335       bfd_set_error (bfd_error_bad_value);
336       return NULL;
337     }
338
339   str = (char *) stash->dwarf_str_buffer + offset;
340   if (*str == '\0')
341     return NULL;
342   return str;
343 }
344
345 /* END VERBATIM */
346
347 static bfd_uint64_t
348 read_address (struct comp_unit *unit, bfd_byte *buf)
349 {
350   int signed_vma = get_elf_backend_data (unit->abfd)->sign_extend_vma;
351
352   if (signed_vma)
353     {
354       switch (unit->addr_size)
355         {
356         case 8:
357           return bfd_get_signed_64 (unit->abfd, buf);
358         case 4:
359           return bfd_get_signed_32 (unit->abfd, buf);
360         case 2:
361           return bfd_get_signed_16 (unit->abfd, buf);
362         default:
363           abort ();
364         }
365     }
366   else
367     {
368       switch (unit->addr_size)
369         {
370         case 8:
371           return bfd_get_64 (unit->abfd, buf);
372         case 4:
373           return bfd_get_32 (unit->abfd, buf);
374         case 2:
375           return bfd_get_16 (unit->abfd, buf);
376         default:
377           abort ();
378         }
379     }
380 }
381
382 /* Lookup an abbrev_info structure in the abbrev hash table.  */
383
384 static struct abbrev_info *
385 lookup_abbrev (unsigned int number, struct abbrev_info **abbrevs)
386 {
387   unsigned int hash_number;
388   struct abbrev_info *abbrev;
389
390   hash_number = number % ABBREV_HASH_SIZE;
391   abbrev = abbrevs[hash_number];
392
393   while (abbrev)
394     {
395       if (abbrev->number == number)
396         return abbrev;
397       else
398         abbrev = abbrev->next;
399     }
400
401   return NULL;
402 }
403
404 /* In DWARF version 2, the description of the debugging information is
405    stored in a separate .debug_abbrev section.  Before we read any
406    dies from a section we read in all abbreviations and install them
407    in a hash table.  */
408
409 static struct abbrev_info**
410 read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
411 {
412   struct abbrev_info **abbrevs;
413   bfd_byte *abbrev_ptr;
414   struct abbrev_info *cur_abbrev;
415   unsigned int abbrev_number, bytes_read, abbrev_name;
416   unsigned int abbrev_form, hash_number;
417   bfd_size_type amt;
418
419   if (! stash->dwarf_abbrev_buffer)
420     {
421       asection *msec;
422
423       msec = bfd_get_section_by_name (abfd, ".debug_abbrev");
424       if (! msec)
425         {
426           (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_abbrev section."));
427           bfd_set_error (bfd_error_bad_value);
428           return 0;
429         }
430
431       stash->dwarf_abbrev_size = msec->size;
432       stash->dwarf_abbrev_buffer
433         = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
434                                                      stash->syms);
435       if (! stash->dwarf_abbrev_buffer)
436           return 0;
437     }
438
439   if (offset >= stash->dwarf_abbrev_size)
440     {
441       (*_bfd_error_handler) (_("Dwarf Error: Abbrev offset (%lu) greater than or equal to .debug_abbrev size (%lu)."),
442                              (unsigned long) offset, stash->dwarf_abbrev_size);
443       bfd_set_error (bfd_error_bad_value);
444       return 0;
445     }
446
447   amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
448   abbrevs = bfd_zalloc (abfd, amt);
449
450   abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
451   abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
452   abbrev_ptr += bytes_read;
453
454   /* Loop until we reach an abbrev number of 0.  */
455   while (abbrev_number)
456     {
457       amt = sizeof (struct abbrev_info);
458       cur_abbrev = bfd_zalloc (abfd, amt);
459
460       /* Read in abbrev header.  */
461       cur_abbrev->number = abbrev_number;
462       cur_abbrev->tag = (enum dwarf_tag)
463         read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
464       abbrev_ptr += bytes_read;
465       cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
466       abbrev_ptr += 1;
467
468       /* Now read in declarations.  */
469       abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
470       abbrev_ptr += bytes_read;
471       abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
472       abbrev_ptr += bytes_read;
473
474       while (abbrev_name)
475         {
476           if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
477             {
478               struct attr_abbrev *tmp;
479
480               amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
481               amt *= sizeof (struct attr_abbrev);
482               tmp = bfd_realloc (cur_abbrev->attrs, amt);
483               if (tmp == NULL)
484                 {
485                   size_t i;
486
487                   for (i = 0; i < ABBREV_HASH_SIZE; i++)
488                     {
489                     struct abbrev_info *abbrev = abbrevs[i];
490
491                     while (abbrev)
492                       {
493                         free (abbrev->attrs);
494                         abbrev = abbrev->next;
495                       }
496                     }
497                   return NULL;
498                 }
499               cur_abbrev->attrs = tmp;
500             }
501
502           cur_abbrev->attrs[cur_abbrev->num_attrs].name
503             = (enum dwarf_attribute) abbrev_name;
504           cur_abbrev->attrs[cur_abbrev->num_attrs++].form
505             = (enum dwarf_form) abbrev_form;
506           abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
507           abbrev_ptr += bytes_read;
508           abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
509           abbrev_ptr += bytes_read;
510         }
511
512       hash_number = abbrev_number % ABBREV_HASH_SIZE;
513       cur_abbrev->next = abbrevs[hash_number];
514       abbrevs[hash_number] = cur_abbrev;
515
516       /* Get next abbreviation.
517          Under Irix6 the abbreviations for a compilation unit are not
518          always properly terminated with an abbrev number of 0.
519          Exit loop if we encounter an abbreviation which we have
520          already read (which means we are about to read the abbreviations
521          for the next compile unit) or if the end of the abbreviation
522          table is reached.  */
523       if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
524             >= stash->dwarf_abbrev_size)
525         break;
526       abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
527       abbrev_ptr += bytes_read;
528       if (lookup_abbrev (abbrev_number,abbrevs) != NULL)
529         break;
530     }
531
532   return abbrevs;
533 }
534
535 /* Read an attribute value described by an attribute form.  */
536
537 static bfd_byte *
538 read_attribute_value (struct attribute *attr,
539                       unsigned form,
540                       struct comp_unit *unit,
541                       bfd_byte *info_ptr)
542 {
543   bfd *abfd = unit->abfd;
544   unsigned int bytes_read;
545   struct dwarf_block *blk;
546   bfd_size_type amt;
547
548   attr->form = (enum dwarf_form) form;
549
550   switch (form)
551     {
552     case DW_FORM_addr:
553       /* FIXME: DWARF3 draft says DW_FORM_ref_addr is offset_size.  */
554     case DW_FORM_ref_addr:
555       attr->u.val = read_address (unit, info_ptr);
556       info_ptr += unit->addr_size;
557       break;
558     case DW_FORM_block2:
559       amt = sizeof (struct dwarf_block);
560       blk = bfd_alloc (abfd, amt);
561       blk->size = read_2_bytes (abfd, info_ptr);
562       info_ptr += 2;
563       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
564       info_ptr += blk->size;
565       attr->u.blk = blk;
566       break;
567     case DW_FORM_block4:
568       amt = sizeof (struct dwarf_block);
569       blk = bfd_alloc (abfd, amt);
570       blk->size = read_4_bytes (abfd, info_ptr);
571       info_ptr += 4;
572       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
573       info_ptr += blk->size;
574       attr->u.blk = blk;
575       break;
576     case DW_FORM_data2:
577       attr->u.val = read_2_bytes (abfd, info_ptr);
578       info_ptr += 2;
579       break;
580     case DW_FORM_data4:
581       attr->u.val = read_4_bytes (abfd, info_ptr);
582       info_ptr += 4;
583       break;
584     case DW_FORM_data8:
585       attr->u.val = read_8_bytes (abfd, info_ptr);
586       info_ptr += 8;
587       break;
588     case DW_FORM_string:
589       attr->u.str = read_string (abfd, info_ptr, &bytes_read);
590       info_ptr += bytes_read;
591       break;
592     case DW_FORM_strp:
593       attr->u.str = read_indirect_string (unit, info_ptr, &bytes_read);
594       info_ptr += bytes_read;
595       break;
596     case DW_FORM_block:
597       amt = sizeof (struct dwarf_block);
598       blk = bfd_alloc (abfd, amt);
599       blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
600       info_ptr += bytes_read;
601       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
602       info_ptr += blk->size;
603       attr->u.blk = blk;
604       break;
605     case DW_FORM_block1:
606       amt = sizeof (struct dwarf_block);
607       blk = bfd_alloc (abfd, amt);
608       blk->size = read_1_byte (abfd, info_ptr);
609       info_ptr += 1;
610       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
611       info_ptr += blk->size;
612       attr->u.blk = blk;
613       break;
614     case DW_FORM_data1:
615       attr->u.val = read_1_byte (abfd, info_ptr);
616       info_ptr += 1;
617       break;
618     case DW_FORM_flag:
619       attr->u.val = read_1_byte (abfd, info_ptr);
620       info_ptr += 1;
621       break;
622     case DW_FORM_sdata:
623       attr->u.sval = read_signed_leb128 (abfd, info_ptr, &bytes_read);
624       info_ptr += bytes_read;
625       break;
626     case DW_FORM_udata:
627       attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
628       info_ptr += bytes_read;
629       break;
630     case DW_FORM_ref1:
631       attr->u.val = read_1_byte (abfd, info_ptr);
632       info_ptr += 1;
633       break;
634     case DW_FORM_ref2:
635       attr->u.val = read_2_bytes (abfd, info_ptr);
636       info_ptr += 2;
637       break;
638     case DW_FORM_ref4:
639       attr->u.val = read_4_bytes (abfd, info_ptr);
640       info_ptr += 4;
641       break;
642     case DW_FORM_ref8:
643       attr->u.val = read_8_bytes (abfd, info_ptr);
644       info_ptr += 8;
645       break;
646     case DW_FORM_ref_udata:
647       attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
648       info_ptr += bytes_read;
649       break;
650     case DW_FORM_indirect:
651       form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
652       info_ptr += bytes_read;
653       info_ptr = read_attribute_value (attr, form, unit, info_ptr);
654       break;
655     default:
656       (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %u."),
657                              form);
658       bfd_set_error (bfd_error_bad_value);
659     }
660   return info_ptr;
661 }
662
663 /* Read an attribute described by an abbreviated attribute.  */
664
665 static bfd_byte *
666 read_attribute (struct attribute *attr,
667                 struct attr_abbrev *abbrev,
668                 struct comp_unit *unit,
669                 bfd_byte *info_ptr)
670 {
671   attr->name = abbrev->name;
672   info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr);
673   return info_ptr;
674 }
675
676 /* Source line information table routines.  */
677
678 #define FILE_ALLOC_CHUNK 5
679 #define DIR_ALLOC_CHUNK 5
680
681 struct line_info
682 {
683   struct line_info* prev_line;
684   bfd_vma address;
685   char *filename;
686   unsigned int line;
687   unsigned int column;
688   int end_sequence;             /* End of (sequential) code sequence.  */
689 };
690
691 struct fileinfo
692 {
693   char *name;
694   unsigned int dir;
695   unsigned int time;
696   unsigned int size;
697 };
698
699 struct line_info_table
700 {
701   bfd* abfd;
702   unsigned int num_files;
703   unsigned int num_dirs;
704   char *comp_dir;
705   char **dirs;
706   struct fileinfo* files;
707   struct line_info* last_line;  /* largest VMA */
708   struct line_info* lcl_head;   /* local head; used in 'add_line_info' */
709 };
710
711 /* Remember some information about each function.  If the function is
712    inlined (DW_TAG_inlined_subroutine) it may have two additional
713    attributes, DW_AT_call_file and DW_AT_call_line, which specify the
714    source code location where this function was inlined. */
715
716 struct funcinfo
717 {
718   struct funcinfo *prev_func;           /* Pointer to previous function in list of all functions */
719   struct funcinfo *caller_func;         /* Pointer to function one scope higher */
720   char *caller_file;                    /* Source location file name where caller_func inlines this func */
721   int caller_line;                      /* Source location line number where caller_func inlines this func */
722   char *file;                           /* Source location file name */
723   int line;                             /* Source location line number */
724   int tag;
725   char *name;
726   struct arange arange;
727   asection *sec;                        /* Where the symbol is defined */
728 };
729
730 struct varinfo
731 {
732   /* Pointer to previous variable in list of all variables */
733   struct varinfo *prev_var;
734   /* Source location file name */
735   char *file;
736   /* Source location line number */
737   int line;
738   int tag;
739   char *name;
740   bfd_vma addr;
741   /* Where the symbol is defined */
742   asection *sec;
743   /* Is this a stack variable? */
744   unsigned int stack: 1;
745 };
746
747 /* Adds a new entry to the line_info list in the line_info_table, ensuring
748    that the list is sorted.  Note that the line_info list is sorted from
749    highest to lowest VMA (with possible duplicates); that is,
750    line_info->prev_line always accesses an equal or smaller VMA.  */
751
752 static void
753 add_line_info (struct line_info_table *table,
754                bfd_vma address,
755                char *filename,
756                unsigned int line,
757                unsigned int column,
758                int end_sequence)
759 {
760   bfd_size_type amt = sizeof (struct line_info);
761   struct line_info* info = bfd_alloc (table->abfd, amt);
762
763   /* Find the correct location for 'info'.  Normally we will receive
764      new line_info data 1) in order and 2) with increasing VMAs.
765      However some compilers break the rules (cf. decode_line_info) and
766      so we include some heuristics for quickly finding the correct
767      location for 'info'. In particular, these heuristics optimize for
768      the common case in which the VMA sequence that we receive is a
769      list of locally sorted VMAs such as
770        p...z a...j  (where a < j < p < z)
771
772      Note: table->lcl_head is used to head an *actual* or *possible*
773      sequence within the list (such as a...j) that is not directly
774      headed by table->last_line
775
776      Note: we may receive duplicate entries from 'decode_line_info'.  */
777
778   while (1)
779     if (!table->last_line
780         || address >= table->last_line->address)
781       {
782         /* Normal case: add 'info' to the beginning of the list */
783         info->prev_line = table->last_line;
784         table->last_line = info;
785
786         /* lcl_head: initialize to head a *possible* sequence at the end.  */
787         if (!table->lcl_head)
788           table->lcl_head = info;
789         break;
790       }
791     else if (!table->lcl_head->prev_line
792              && table->lcl_head->address > address)
793       {
794         /* Abnormal but easy: lcl_head is 1) at the *end* of the line
795            list and 2) the head of 'info'.  */
796         info->prev_line = NULL;
797         table->lcl_head->prev_line = info;
798         break;
799       }
800     else if (table->lcl_head->prev_line
801              && table->lcl_head->address > address
802              && address >= table->lcl_head->prev_line->address)
803       {
804         /* Abnormal but easy: lcl_head is 1) in the *middle* of the line
805            list and 2) the head of 'info'.  */
806         info->prev_line = table->lcl_head->prev_line;
807         table->lcl_head->prev_line = info;
808         break;
809       }
810     else
811       {
812         /* Abnormal and hard: Neither 'last_line' nor 'lcl_head' are valid
813            heads for 'info'.  Reset 'lcl_head' and repeat.  */
814         struct line_info* li2 = table->last_line; /* always non-NULL */
815         struct line_info* li1 = li2->prev_line;
816
817         while (li1)
818           {
819             if (li2->address > address && address >= li1->address)
820               break;
821
822             li2 = li1; /* always non-NULL */
823             li1 = li1->prev_line;
824           }
825         table->lcl_head = li2;
826       }
827
828   /* Set member data of 'info'.  */
829   info->address = address;
830   info->line = line;
831   info->column = column;
832   info->end_sequence = end_sequence;
833
834   if (filename && filename[0])
835     {
836       info->filename = bfd_alloc (table->abfd, strlen (filename) + 1);
837       if (info->filename)
838         strcpy (info->filename, filename);
839     }
840   else
841     info->filename = NULL;
842 }
843
844 /* Extract a fully qualified filename from a line info table.
845    The returned string has been malloc'ed and it is the caller's
846    responsibility to free it.  */
847
848 static char *
849 concat_filename (struct line_info_table *table, unsigned int file)
850 {
851   char *filename;
852
853   if (file - 1 >= table->num_files)
854     {
855       (*_bfd_error_handler)
856         (_("Dwarf Error: mangled line number section (bad file number)."));
857       return strdup ("<unknown>");
858     }
859
860   filename = table->files[file - 1].name;
861
862   if (! IS_ABSOLUTE_PATH (filename))
863     {
864       char *dirname = (table->files[file - 1].dir
865                        ? table->dirs[table->files[file - 1].dir - 1]
866                        : table->comp_dir);
867
868       /* Not all tools set DW_AT_comp_dir, so dirname may be unknown.
869          The best we can do is return the filename part.  */
870       if (dirname != NULL)
871         {
872           unsigned int len = strlen (dirname) + strlen (filename) + 2;
873           char * name;
874
875           name = bfd_malloc (len);
876           if (name)
877             sprintf (name, "%s/%s", dirname, filename);
878           return name;
879         }
880     }
881
882   return strdup (filename);
883 }
884
885 static void
886 arange_add (bfd *abfd, struct arange *first_arange, bfd_vma low_pc, bfd_vma high_pc)
887 {
888   struct arange *arange;
889
890   /* If the first arange is empty, use it. */
891   if (first_arange->high == 0)
892     {
893       first_arange->low = low_pc;
894       first_arange->high = high_pc;
895       return;
896     }
897
898   /* Next see if we can cheaply extend an existing range.  */
899   arange = first_arange;
900   do
901     {
902       if (low_pc == arange->high)
903         {
904           arange->high = high_pc;
905           return;
906         }
907       if (high_pc == arange->low)
908         {
909           arange->low = low_pc;
910           return;
911         }
912       arange = arange->next;
913     }
914   while (arange);
915
916   /* Need to allocate a new arange and insert it into the arange list.
917      Order isn't significant, so just insert after the first arange. */
918   arange = bfd_zalloc (abfd, sizeof (*arange));
919   arange->low = low_pc;
920   arange->high = high_pc;
921   arange->next = first_arange->next;
922   first_arange->next = arange;
923 }
924
925 /* Decode the line number information for UNIT.  */
926
927 static struct line_info_table*
928 decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
929 {
930   bfd *abfd = unit->abfd;
931   struct line_info_table* table;
932   bfd_byte *line_ptr;
933   bfd_byte *line_end;
934   struct line_head lh;
935   unsigned int i, bytes_read, offset_size;
936   char *cur_file, *cur_dir;
937   unsigned char op_code, extended_op, adj_opcode;
938   bfd_size_type amt;
939
940   if (! stash->dwarf_line_buffer)
941     {
942       asection *msec;
943
944       msec = bfd_get_section_by_name (abfd, ".debug_line");
945       if (! msec)
946         {
947           (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_line section."));
948           bfd_set_error (bfd_error_bad_value);
949           return 0;
950         }
951
952       stash->dwarf_line_size = msec->size;
953       stash->dwarf_line_buffer
954         = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
955                                                      stash->syms);
956       if (! stash->dwarf_line_buffer)
957         return 0;
958     }
959
960   /* It is possible to get a bad value for the line_offset.  Validate
961      it here so that we won't get a segfault below.  */
962   if (unit->line_offset >= stash->dwarf_line_size)
963     {
964       (*_bfd_error_handler) (_("Dwarf Error: Line offset (%lu) greater than or equal to .debug_line size (%lu)."),
965                              unit->line_offset, stash->dwarf_line_size);
966       bfd_set_error (bfd_error_bad_value);
967       return 0;
968     }
969
970   amt = sizeof (struct line_info_table);
971   table = bfd_alloc (abfd, amt);
972   table->abfd = abfd;
973   table->comp_dir = unit->comp_dir;
974
975   table->num_files = 0;
976   table->files = NULL;
977
978   table->num_dirs = 0;
979   table->dirs = NULL;
980
981   table->files = NULL;
982   table->last_line = NULL;
983   table->lcl_head = NULL;
984
985   line_ptr = stash->dwarf_line_buffer + unit->line_offset;
986
987   /* Read in the prologue.  */
988   lh.total_length = read_4_bytes (abfd, line_ptr);
989   line_ptr += 4;
990   offset_size = 4;
991   if (lh.total_length == 0xffffffff)
992     {
993       lh.total_length = read_8_bytes (abfd, line_ptr);
994       line_ptr += 8;
995       offset_size = 8;
996     }
997   else if (lh.total_length == 0 && unit->addr_size == 8)
998     {
999       /* Handle (non-standard) 64-bit DWARF2 formats.  */
1000       lh.total_length = read_4_bytes (abfd, line_ptr);
1001       line_ptr += 4;
1002       offset_size = 8;
1003     }
1004   line_end = line_ptr + lh.total_length;
1005   lh.version = read_2_bytes (abfd, line_ptr);
1006   line_ptr += 2;
1007   if (offset_size == 4)
1008     lh.prologue_length = read_4_bytes (abfd, line_ptr);
1009   else
1010     lh.prologue_length = read_8_bytes (abfd, line_ptr);
1011   line_ptr += offset_size;
1012   lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
1013   line_ptr += 1;
1014   lh.default_is_stmt = read_1_byte (abfd, line_ptr);
1015   line_ptr += 1;
1016   lh.line_base = read_1_signed_byte (abfd, line_ptr);
1017   line_ptr += 1;
1018   lh.line_range = read_1_byte (abfd, line_ptr);
1019   line_ptr += 1;
1020   lh.opcode_base = read_1_byte (abfd, line_ptr);
1021   line_ptr += 1;
1022   amt = lh.opcode_base * sizeof (unsigned char);
1023   lh.standard_opcode_lengths = bfd_alloc (abfd, amt);
1024
1025   lh.standard_opcode_lengths[0] = 1;
1026
1027   for (i = 1; i < lh.opcode_base; ++i)
1028     {
1029       lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
1030       line_ptr += 1;
1031     }
1032
1033   /* Read directory table.  */
1034   while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1035     {
1036       line_ptr += bytes_read;
1037
1038       if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
1039         {
1040           char **tmp;
1041
1042           amt = table->num_dirs + DIR_ALLOC_CHUNK;
1043           amt *= sizeof (char *);
1044
1045           tmp = bfd_realloc (table->dirs, amt);
1046           if (tmp == NULL)
1047             {
1048               free (table->dirs);
1049               return NULL;
1050             }
1051           table->dirs = tmp;
1052         }
1053
1054       table->dirs[table->num_dirs++] = cur_dir;
1055     }
1056
1057   line_ptr += bytes_read;
1058
1059   /* Read file name table.  */
1060   while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1061     {
1062       line_ptr += bytes_read;
1063
1064       if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1065         {
1066           struct fileinfo *tmp;
1067
1068           amt = table->num_files + FILE_ALLOC_CHUNK;
1069           amt *= sizeof (struct fileinfo);
1070
1071           tmp = bfd_realloc (table->files, amt);
1072           if (tmp == NULL)
1073             {
1074               free (table->files);
1075               free (table->dirs);
1076               return NULL;
1077             }
1078           table->files = tmp;
1079         }
1080
1081       table->files[table->num_files].name = cur_file;
1082       table->files[table->num_files].dir =
1083         read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1084       line_ptr += bytes_read;
1085       table->files[table->num_files].time =
1086         read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1087       line_ptr += bytes_read;
1088       table->files[table->num_files].size =
1089         read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1090       line_ptr += bytes_read;
1091       table->num_files++;
1092     }
1093
1094   line_ptr += bytes_read;
1095
1096   /* Read the statement sequences until there's nothing left.  */
1097   while (line_ptr < line_end)
1098     {
1099       /* State machine registers.  */
1100       bfd_vma address = 0;
1101       char * filename = table->num_files ? concat_filename (table, 1) : NULL;
1102       unsigned int line = 1;
1103       unsigned int column = 0;
1104       int is_stmt = lh.default_is_stmt;
1105       int basic_block = 0;
1106       int end_sequence = 0;
1107       /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1108          compilers generate address sequences that are wildly out of
1109          order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1110          for ia64-Linux).  Thus, to determine the low and high
1111          address, we must compare on every DW_LNS_copy, etc.  */
1112       bfd_vma low_pc  = (bfd_vma) -1;
1113       bfd_vma high_pc = 0;
1114
1115       /* Decode the table.  */
1116       while (! end_sequence)
1117         {
1118           op_code = read_1_byte (abfd, line_ptr);
1119           line_ptr += 1;
1120
1121           if (op_code >= lh.opcode_base)
1122             {
1123               /* Special operand.  */
1124               adj_opcode = op_code - lh.opcode_base;
1125               address += (adj_opcode / lh.line_range)
1126                 * lh.minimum_instruction_length;
1127               line += lh.line_base + (adj_opcode % lh.line_range);
1128               /* Append row to matrix using current values.  */
1129               add_line_info (table, address, filename, line, column, 0);
1130               basic_block = 1;
1131               if (address < low_pc)
1132                 low_pc = address;
1133               if (address > high_pc)
1134                 high_pc = address;
1135             }
1136           else switch (op_code)
1137             {
1138             case DW_LNS_extended_op:
1139               /* Ignore length.  */
1140               line_ptr += 1;
1141               extended_op = read_1_byte (abfd, line_ptr);
1142               line_ptr += 1;
1143
1144               switch (extended_op)
1145                 {
1146                 case DW_LNE_end_sequence:
1147                   end_sequence = 1;
1148                   add_line_info (table, address, filename, line, column,
1149                                  end_sequence);
1150                   if (address < low_pc)
1151                     low_pc = address;
1152                   if (address > high_pc)
1153                     high_pc = address;
1154                   arange_add (unit->abfd, &unit->arange, low_pc, high_pc);
1155                   break;
1156                 case DW_LNE_set_address:
1157                   address = read_address (unit, line_ptr);
1158                   line_ptr += unit->addr_size;
1159                   break;
1160                 case DW_LNE_define_file:
1161                   cur_file = read_string (abfd, line_ptr, &bytes_read);
1162                   line_ptr += bytes_read;
1163                   if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1164                     {
1165                       struct fileinfo *tmp;
1166
1167                       amt = table->num_files + FILE_ALLOC_CHUNK;
1168                       amt *= sizeof (struct fileinfo);
1169                       tmp = bfd_realloc (table->files, amt);
1170                       if (tmp == NULL)
1171                         {
1172                           free (table->files);
1173                           free (table->dirs);
1174                           free (filename);
1175                           return NULL;
1176                         }
1177                       table->files = tmp;
1178                     }
1179                   table->files[table->num_files].name = cur_file;
1180                   table->files[table->num_files].dir =
1181                     read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1182                   line_ptr += bytes_read;
1183                   table->files[table->num_files].time =
1184                     read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1185                   line_ptr += bytes_read;
1186                   table->files[table->num_files].size =
1187                     read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1188                   line_ptr += bytes_read;
1189                   table->num_files++;
1190                   break;
1191                 default:
1192                   (*_bfd_error_handler) (_("Dwarf Error: mangled line number section."));
1193                   bfd_set_error (bfd_error_bad_value);
1194                   free (filename);
1195                   free (table->files);
1196                   free (table->dirs);
1197                   return NULL;
1198                 }
1199               break;
1200             case DW_LNS_copy:
1201               add_line_info (table, address, filename, line, column, 0);
1202               basic_block = 0;
1203               if (address < low_pc)
1204                 low_pc = address;
1205               if (address > high_pc)
1206                 high_pc = address;
1207               break;
1208             case DW_LNS_advance_pc:
1209               address += lh.minimum_instruction_length
1210                 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1211               line_ptr += bytes_read;
1212               break;
1213             case DW_LNS_advance_line:
1214               line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
1215               line_ptr += bytes_read;
1216               break;
1217             case DW_LNS_set_file:
1218               {
1219                 unsigned int file;
1220
1221                 /* The file and directory tables are 0
1222                    based, the references are 1 based.  */
1223                 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1224                 line_ptr += bytes_read;
1225                 if (filename)
1226                   free (filename);
1227                 filename = concat_filename (table, file);
1228                 break;
1229               }
1230             case DW_LNS_set_column:
1231               column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1232               line_ptr += bytes_read;
1233               break;
1234             case DW_LNS_negate_stmt:
1235               is_stmt = (!is_stmt);
1236               break;
1237             case DW_LNS_set_basic_block:
1238               basic_block = 1;
1239               break;
1240             case DW_LNS_const_add_pc:
1241               address += lh.minimum_instruction_length
1242                       * ((255 - lh.opcode_base) / lh.line_range);
1243               break;
1244             case DW_LNS_fixed_advance_pc:
1245               address += read_2_bytes (abfd, line_ptr);
1246               line_ptr += 2;
1247               break;
1248             default:
1249               {
1250                 int i;
1251
1252                 /* Unknown standard opcode, ignore it.  */
1253                 for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
1254                   {
1255                     (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1256                     line_ptr += bytes_read;
1257                   }
1258               }
1259             }
1260         }
1261
1262       if (filename)
1263         free (filename);
1264     }
1265
1266   return table;
1267 }
1268
1269 /* If ADDR is within TABLE set the output parameters and return TRUE,
1270    otherwise return FALSE.  The output parameters, FILENAME_PTR and
1271    LINENUMBER_PTR, are pointers to the objects to be filled in.  */
1272
1273 static bfd_boolean
1274 lookup_address_in_line_info_table (struct line_info_table *table,
1275                                    bfd_vma addr,
1276                                    struct funcinfo *function,
1277                                    const char **filename_ptr,
1278                                    unsigned int *linenumber_ptr)
1279 {
1280   /* Note: table->last_line should be a descendingly sorted list. */
1281   struct line_info* next_line = table->last_line;
1282   struct line_info* each_line = NULL;
1283   *filename_ptr = NULL;
1284
1285   if (!next_line)
1286     return FALSE;
1287
1288   each_line = next_line->prev_line;
1289
1290   /* Check for large addresses */
1291   if (addr > next_line->address)
1292     each_line = NULL; /* ensure we skip over the normal case */
1293
1294   /* Normal case: search the list; save  */
1295   while (each_line && next_line)
1296     {
1297       /* If we have an address match, save this info.  This allows us
1298          to return as good as results as possible for strange debugging
1299          info.  */
1300       bfd_boolean addr_match = FALSE;
1301       if (each_line->address <= addr && addr < next_line->address)
1302         {
1303           addr_match = TRUE;
1304
1305           /* If this line appears to span functions, and addr is in the
1306              later function, return the first line of that function instead
1307              of the last line of the earlier one.  This check is for GCC
1308              2.95, which emits the first line number for a function late.  */
1309
1310           if (function != NULL)
1311             {
1312               bfd_vma lowest_pc;
1313               struct arange *arange;
1314
1315               /* Find the lowest address in the function's range list */
1316               lowest_pc = function->arange.low;
1317               for (arange = &function->arange;
1318                    arange;
1319                    arange = arange->next)
1320                 {
1321                   if (function->arange.low < lowest_pc)
1322                     lowest_pc = function->arange.low;
1323                 }
1324               /* Check for spanning function and set outgoing line info */
1325               if (addr >= lowest_pc
1326                   && each_line->address < lowest_pc
1327                   && next_line->address > lowest_pc)
1328                 {
1329                   *filename_ptr = next_line->filename;
1330                   *linenumber_ptr = next_line->line;
1331                 }
1332               else
1333                 {
1334                   *filename_ptr = each_line->filename;
1335                   *linenumber_ptr = each_line->line;
1336                 }
1337             }
1338           else
1339             {
1340               *filename_ptr = each_line->filename;
1341               *linenumber_ptr = each_line->line;
1342             }
1343         }
1344
1345       if (addr_match && !each_line->end_sequence)
1346         return TRUE; /* we have definitely found what we want */
1347
1348       next_line = each_line;
1349       each_line = each_line->prev_line;
1350     }
1351
1352   /* At this point each_line is NULL but next_line is not.  If we found
1353      a candidate end-of-sequence point in the loop above, we can return
1354      that (compatibility with a bug in the Intel compiler); otherwise,
1355      assuming that we found the containing function for this address in
1356      this compilation unit, return the first line we have a number for
1357      (compatibility with GCC 2.95).  */
1358   if (*filename_ptr == NULL && function != NULL)
1359     {
1360       *filename_ptr = next_line->filename;
1361       *linenumber_ptr = next_line->line;
1362       return TRUE;
1363     }
1364
1365   return FALSE;
1366 }
1367
1368 /* Read in the .debug_ranges section for future reference */
1369
1370 static bfd_boolean
1371 read_debug_ranges (struct comp_unit *unit)
1372 {
1373   struct dwarf2_debug *stash = unit->stash;
1374   if (! stash->dwarf_ranges_buffer)
1375     {
1376       bfd *abfd = unit->abfd;
1377       asection *msec;
1378
1379       msec = bfd_get_section_by_name (abfd, ".debug_ranges");
1380       if (! msec)
1381         {
1382           (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_ranges section."));
1383           bfd_set_error (bfd_error_bad_value);
1384           return FALSE;
1385         }
1386
1387       stash->dwarf_ranges_size = msec->size;
1388       stash->dwarf_ranges_buffer
1389         = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
1390                                                      stash->syms);
1391       if (! stash->dwarf_ranges_buffer)
1392         return FALSE;
1393     }
1394   return TRUE;
1395 }
1396
1397 /* Function table functions.  */
1398
1399 /* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return TRUE.
1400    Note that we need to find the function that has the smallest
1401    range that contains ADDR, to handle inlined functions without
1402    depending upon them being ordered in TABLE by increasing range. */
1403
1404 static bfd_boolean
1405 lookup_address_in_function_table (struct comp_unit *unit,
1406                                   bfd_vma addr,
1407                                   struct funcinfo **function_ptr,
1408                                   const char **functionname_ptr)
1409 {
1410   struct funcinfo* each_func;
1411   struct funcinfo* best_fit = NULL;
1412   struct arange *arange;
1413
1414   for (each_func = unit->function_table;
1415        each_func;
1416        each_func = each_func->prev_func)
1417     {
1418       for (arange = &each_func->arange;
1419            arange;
1420            arange = arange->next)
1421         {
1422           if (addr >= arange->low && addr < arange->high)
1423             {
1424               if (!best_fit ||
1425                   ((arange->high - arange->low) < (best_fit->arange.high - best_fit->arange.low)))
1426                 best_fit = each_func;
1427             }
1428         }
1429     }
1430
1431   if (best_fit)
1432     {
1433       *functionname_ptr = best_fit->name;
1434       *function_ptr = best_fit;
1435       return TRUE;
1436     }
1437   else
1438     {
1439       return FALSE;
1440     }
1441 }
1442
1443 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
1444    and LINENUMBER_PTR, and return TRUE.  */
1445
1446 static bfd_boolean
1447 lookup_symbol_in_function_table (struct comp_unit *unit,
1448                                  asymbol *sym,
1449                                  bfd_vma addr,
1450                                  const char **filename_ptr,
1451                                  unsigned int *linenumber_ptr)
1452 {
1453   struct funcinfo* each_func;
1454   struct funcinfo* best_fit = NULL;
1455   struct arange *arange;
1456   const char *name = bfd_asymbol_name (sym);
1457   asection *sec = bfd_get_section (sym);
1458
1459   for (each_func = unit->function_table;
1460        each_func;
1461        each_func = each_func->prev_func)
1462     {
1463       for (arange = &each_func->arange;
1464            arange;
1465            arange = arange->next)
1466         {
1467           if ((!each_func->sec || each_func->sec == sec)
1468               && addr >= arange->low
1469               && addr < arange->high
1470               && each_func->name
1471               && strcmp (name, each_func->name) == 0
1472               && (!best_fit
1473                   || ((arange->high - arange->low)
1474                       < (best_fit->arange.high - best_fit->arange.low))))
1475             best_fit = each_func;
1476         }
1477     }
1478
1479   if (best_fit)
1480     {
1481       best_fit->sec = sec;
1482       *filename_ptr = best_fit->file;
1483       *linenumber_ptr = best_fit->line;
1484       return TRUE;
1485     }
1486   else
1487     return FALSE;
1488 }
1489
1490 /* Variable table functions.  */
1491
1492 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
1493    LINENUMBER_PTR, and return TRUE.  */
1494
1495 static bfd_boolean
1496 lookup_symbol_in_variable_table (struct comp_unit *unit,
1497                                  asymbol *sym,
1498                                  bfd_vma addr,
1499                                  const char **filename_ptr,
1500                                  unsigned int *linenumber_ptr)
1501 {
1502   const char *name = bfd_asymbol_name (sym);
1503   asection *sec = bfd_get_section (sym);
1504   struct varinfo* each;
1505
1506   for (each = unit->variable_table; each; each = each->prev_var)
1507     if (each->stack == 0
1508         && each->file != NULL
1509         && each->name != NULL
1510         && each->addr == addr
1511         && (!each->sec || each->sec == sec)
1512         && strcmp (name, each->name) == 0)
1513       break;
1514
1515   if (each)
1516     {
1517       each->sec = sec;
1518       *filename_ptr = each->file;
1519       *linenumber_ptr = each->line;
1520       return TRUE;
1521     }
1522   else
1523     return FALSE;
1524 }
1525
1526 static char *
1527 find_abstract_instance_name (struct comp_unit *unit, bfd_uint64_t die_ref)
1528 {
1529   bfd *abfd = unit->abfd;
1530   bfd_byte *info_ptr;
1531   unsigned int abbrev_number, bytes_read, i;
1532   struct abbrev_info *abbrev;
1533   struct attribute attr;
1534   char *name = 0;
1535
1536   info_ptr = unit->info_ptr_unit + die_ref;
1537   abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1538   info_ptr += bytes_read;
1539
1540   if (abbrev_number)
1541     {
1542       abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
1543       if (! abbrev)
1544         {
1545           (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1546                                  abbrev_number);
1547           bfd_set_error (bfd_error_bad_value);
1548         }
1549       else
1550         {
1551           for (i = 0; i < abbrev->num_attrs; ++i)
1552             {
1553               info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1554               switch (attr.name)
1555                 {
1556                 case DW_AT_name:
1557                   /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name.  */
1558                   if (name == NULL)
1559                     name = attr.u.str;
1560                   break;
1561                 case DW_AT_specification:
1562                   name = find_abstract_instance_name (unit, attr.u.val);
1563                   break;
1564                 case DW_AT_MIPS_linkage_name:
1565                   name = attr.u.str;
1566                   break;
1567                 default:
1568                   break;
1569                 }
1570             }
1571         }
1572     }
1573   return (name);
1574 }
1575
1576 static void
1577 read_rangelist (struct comp_unit *unit, struct arange *arange, bfd_uint64_t offset)
1578 {
1579   bfd_byte *ranges_ptr;
1580   bfd_vma base_address = unit->base_address;
1581
1582   if (! unit->stash->dwarf_ranges_buffer)
1583     {
1584       if (! read_debug_ranges (unit))
1585         return;
1586     }
1587   ranges_ptr = unit->stash->dwarf_ranges_buffer + offset;
1588     
1589   for (;;)
1590     {
1591       bfd_vma low_pc;
1592       bfd_vma high_pc;
1593
1594       if (unit->addr_size == 4)
1595         {
1596           low_pc = read_4_bytes (unit->abfd, ranges_ptr);
1597           ranges_ptr += 4;
1598           high_pc = read_4_bytes (unit->abfd, ranges_ptr);
1599           ranges_ptr += 4;
1600         }
1601       else
1602         {
1603           low_pc = read_8_bytes (unit->abfd, ranges_ptr);
1604           ranges_ptr += 8;
1605           high_pc = read_8_bytes (unit->abfd, ranges_ptr);
1606           ranges_ptr += 8;
1607         }
1608       if (low_pc == 0 && high_pc == 0)
1609         break;
1610       if (low_pc == -1UL && high_pc != -1UL)
1611         base_address = high_pc;
1612       else
1613           arange_add (unit->abfd, arange, base_address + low_pc, base_address + high_pc);
1614     }
1615 }
1616
1617 /* DWARF2 Compilation unit functions.  */
1618
1619 /* Scan over each die in a comp. unit looking for functions to add
1620    to the function table and variables to the variable table.  */
1621
1622 static bfd_boolean
1623 scan_unit_for_symbols (struct comp_unit *unit)
1624 {
1625   bfd *abfd = unit->abfd;
1626   bfd_byte *info_ptr = unit->first_child_die_ptr;
1627   int nesting_level = 1;
1628   struct funcinfo **nested_funcs;
1629   int nested_funcs_size;
1630
1631   /* Maintain a stack of in-scope functions and inlined functions, which we
1632      can use to set the caller_func field.  */
1633   nested_funcs_size = 32;
1634   nested_funcs = bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *));
1635   if (nested_funcs == NULL)
1636     return FALSE;
1637   nested_funcs[nesting_level] = 0;
1638
1639   while (nesting_level)
1640     {
1641       unsigned int abbrev_number, bytes_read, i;
1642       struct abbrev_info *abbrev;
1643       struct attribute attr;
1644       struct funcinfo *func;
1645       struct varinfo *var;
1646       bfd_vma low_pc = 0;
1647       bfd_vma high_pc = 0;
1648
1649       abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1650       info_ptr += bytes_read;
1651
1652       if (! abbrev_number)
1653         {
1654           nesting_level--;
1655           continue;
1656         }
1657
1658       abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
1659       if (! abbrev)
1660         {
1661           (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1662                              abbrev_number);
1663           bfd_set_error (bfd_error_bad_value);
1664           free (nested_funcs);
1665           return FALSE;
1666         }
1667
1668       var = NULL;
1669       if (abbrev->tag == DW_TAG_subprogram
1670           || abbrev->tag == DW_TAG_entry_point
1671           || abbrev->tag == DW_TAG_inlined_subroutine)
1672         {
1673           bfd_size_type amt = sizeof (struct funcinfo);
1674           func = bfd_zalloc (abfd, amt);
1675           func->tag = abbrev->tag;
1676           func->prev_func = unit->function_table;
1677           unit->function_table = func;
1678
1679           if (func->tag == DW_TAG_inlined_subroutine)
1680             for (i = nesting_level - 1; i >= 1; i--)
1681               if (nested_funcs[i])
1682                 {
1683                   func->caller_func = nested_funcs[i];
1684                   break;
1685                 }
1686           nested_funcs[nesting_level] = func;
1687         }
1688       else
1689         {
1690           func = NULL;
1691           if (abbrev->tag == DW_TAG_variable)
1692             {
1693               bfd_size_type amt = sizeof (struct varinfo);
1694               var = bfd_zalloc (abfd, amt);
1695               var->tag = abbrev->tag;
1696               var->stack = 1;
1697               var->prev_var = unit->variable_table;
1698               unit->variable_table = var;
1699             }
1700
1701           /* No inline function in scope at this nesting level.  */
1702           nested_funcs[nesting_level] = 0;
1703         }
1704
1705       for (i = 0; i < abbrev->num_attrs; ++i)
1706         {
1707           info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1708
1709           if (func)
1710             {
1711               switch (attr.name)
1712                 {
1713                 case DW_AT_call_file:
1714                   func->caller_file = concat_filename (unit->line_table, attr.u.val);
1715                   break;
1716
1717                 case DW_AT_call_line:
1718                   func->caller_line = attr.u.val;
1719                   break;
1720
1721                 case DW_AT_abstract_origin:
1722                   func->name = find_abstract_instance_name (unit, attr.u.val);
1723                   break;
1724
1725                 case DW_AT_name:
1726                   /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name.  */
1727                   if (func->name == NULL)
1728                     func->name = attr.u.str;
1729                   break;
1730
1731                 case DW_AT_MIPS_linkage_name:
1732                   func->name = attr.u.str;
1733                   break;
1734
1735                 case DW_AT_low_pc:
1736                   low_pc = attr.u.val;
1737                   break;
1738
1739                 case DW_AT_high_pc:
1740                   high_pc = attr.u.val;
1741                   break;
1742
1743                 case DW_AT_ranges:
1744                   read_rangelist (unit, &func->arange, attr.u.val);
1745                   break;
1746
1747                 case DW_AT_decl_file:
1748                   func->file = concat_filename (unit->line_table,
1749                                                 attr.u.val);
1750                   break;
1751
1752                 case DW_AT_decl_line:
1753                   func->line = attr.u.val;
1754                   break;
1755
1756                 default:
1757                   break;
1758                 }
1759             }
1760           else if (var)
1761             {
1762               switch (attr.name)
1763                 {
1764                 case DW_AT_name:
1765                   var->name = attr.u.str;
1766                   break;
1767
1768                 case DW_AT_decl_file:
1769                   var->file = concat_filename (unit->line_table,
1770                                                attr.u.val);
1771                   break;
1772
1773                 case DW_AT_decl_line:
1774                   var->line = attr.u.val;
1775                   break;
1776
1777                 case DW_AT_external:
1778                   if (attr.u.val != 0)
1779                     var->stack = 0;
1780                   break;
1781
1782                 case DW_AT_location:
1783                   switch (attr.form)
1784                     {
1785                     case DW_FORM_block:
1786                     case DW_FORM_block1:
1787                     case DW_FORM_block2:
1788                     case DW_FORM_block4:
1789                       if (*attr.u.blk->data == DW_OP_addr)
1790                         {
1791                           var->stack = 0;
1792
1793                           /* Verify that DW_OP_addr is the only opcode in the
1794                              location, in which case the block size will be 1
1795                              plus the address size.  */
1796                           /* ??? For TLS variables, gcc can emit
1797                              DW_OP_addr <addr> DW_OP_GNU_push_tls_address
1798                              which we don't handle here yet.  */
1799                           if (attr.u.blk->size == unit->addr_size + 1U)
1800                             var->addr = bfd_get (unit->addr_size * 8,
1801                                                  unit->abfd,
1802                                                  attr.u.blk->data + 1);
1803                         }
1804                       break;
1805                     
1806                     default:
1807                       break;
1808                     }
1809                   break;
1810
1811                 default:
1812                   break;
1813                 }
1814             }
1815         }
1816
1817       if (func && high_pc != 0)
1818         {
1819           arange_add (unit->abfd, &func->arange, low_pc, high_pc);
1820         }
1821
1822       if (abbrev->has_children)
1823         {
1824           nesting_level++;
1825
1826           if (nesting_level >= nested_funcs_size)
1827             {
1828               struct funcinfo **tmp;
1829
1830               nested_funcs_size *= 2;
1831               tmp = bfd_realloc (nested_funcs,
1832                                  (nested_funcs_size
1833                                   * sizeof (struct funcinfo *)));
1834               if (tmp == NULL)
1835                 {
1836                   free (nested_funcs);
1837                   return FALSE;
1838                 }
1839               nested_funcs = tmp;
1840             }
1841           nested_funcs[nesting_level] = 0;
1842         }
1843     }
1844
1845   free (nested_funcs);
1846   return TRUE;
1847 }
1848
1849 /* Parse a DWARF2 compilation unit starting at INFO_PTR.  This
1850    includes the compilation unit header that proceeds the DIE's, but
1851    does not include the length field that precedes each compilation
1852    unit header.  END_PTR points one past the end of this comp unit.
1853    OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
1854
1855    This routine does not read the whole compilation unit; only enough
1856    to get to the line number information for the compilation unit.  */
1857
1858 static struct comp_unit *
1859 parse_comp_unit (bfd *abfd,
1860                  struct dwarf2_debug *stash,
1861                  bfd_vma unit_length,
1862                  bfd_byte *info_ptr_unit,
1863                  unsigned int offset_size)
1864 {
1865   struct comp_unit* unit;
1866   unsigned int version;
1867   bfd_uint64_t abbrev_offset = 0;
1868   unsigned int addr_size;
1869   struct abbrev_info** abbrevs;
1870   unsigned int abbrev_number, bytes_read, i;
1871   struct abbrev_info *abbrev;
1872   struct attribute attr;
1873   bfd_byte *info_ptr = stash->info_ptr;
1874   bfd_byte *end_ptr = info_ptr + unit_length;
1875   bfd_size_type amt;
1876   bfd_vma low_pc = 0;
1877   bfd_vma high_pc = 0;
1878
1879   version = read_2_bytes (abfd, info_ptr);
1880   info_ptr += 2;
1881   BFD_ASSERT (offset_size == 4 || offset_size == 8);
1882   if (offset_size == 4)
1883     abbrev_offset = read_4_bytes (abfd, info_ptr);
1884   else
1885     abbrev_offset = read_8_bytes (abfd, info_ptr);
1886   info_ptr += offset_size;
1887   addr_size = read_1_byte (abfd, info_ptr);
1888   info_ptr += 1;
1889
1890   if (version != 2)
1891     {
1892       (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 information."), version);
1893       bfd_set_error (bfd_error_bad_value);
1894       return 0;
1895     }
1896
1897   if (addr_size > sizeof (bfd_vma))
1898     {
1899       (*_bfd_error_handler) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
1900                          addr_size,
1901                          (unsigned int) sizeof (bfd_vma));
1902       bfd_set_error (bfd_error_bad_value);
1903       return 0;
1904     }
1905
1906   if (addr_size != 2 && addr_size != 4 && addr_size != 8)
1907     {
1908       (*_bfd_error_handler) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size);
1909       bfd_set_error (bfd_error_bad_value);
1910       return 0;
1911     }
1912
1913   /* Read the abbrevs for this compilation unit into a table.  */
1914   abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
1915   if (! abbrevs)
1916       return 0;
1917
1918   abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1919   info_ptr += bytes_read;
1920   if (! abbrev_number)
1921     {
1922       (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u."),
1923                          abbrev_number);
1924       bfd_set_error (bfd_error_bad_value);
1925       return 0;
1926     }
1927
1928   abbrev = lookup_abbrev (abbrev_number, abbrevs);
1929   if (! abbrev)
1930     {
1931       (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1932                          abbrev_number);
1933       bfd_set_error (bfd_error_bad_value);
1934       return 0;
1935     }
1936
1937   amt = sizeof (struct comp_unit);
1938   unit = bfd_zalloc (abfd, amt);
1939   unit->abfd = abfd;
1940   unit->addr_size = addr_size;
1941   unit->offset_size = offset_size;
1942   unit->abbrevs = abbrevs;
1943   unit->end_ptr = end_ptr;
1944   unit->stash = stash;
1945   unit->info_ptr_unit = info_ptr_unit;
1946
1947   for (i = 0; i < abbrev->num_attrs; ++i)
1948     {
1949       info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1950
1951       /* Store the data if it is of an attribute we want to keep in a
1952          partial symbol table.  */
1953       switch (attr.name)
1954         {
1955         case DW_AT_stmt_list:
1956           unit->stmtlist = 1;
1957           unit->line_offset = attr.u.val;
1958           break;
1959
1960         case DW_AT_name:
1961           unit->name = attr.u.str;
1962           break;
1963
1964         case DW_AT_low_pc:
1965           low_pc = attr.u.val;
1966           /* If the compilation unit DIE has a DW_AT_low_pc attribute,
1967              this is the base address to use when reading location
1968              lists or range lists. */
1969           unit->base_address = low_pc;
1970           break;
1971
1972         case DW_AT_high_pc:
1973           high_pc = attr.u.val;
1974           break;
1975
1976         case DW_AT_ranges:
1977           read_rangelist (unit, &unit->arange, attr.u.val);
1978           break;
1979
1980         case DW_AT_comp_dir:
1981           {
1982             char *comp_dir = attr.u.str;
1983             if (comp_dir)
1984               {
1985                 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1986                    directory, get rid of it.  */
1987                 char *cp = strchr (comp_dir, ':');
1988
1989                 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
1990                   comp_dir = cp + 1;
1991               }
1992             unit->comp_dir = comp_dir;
1993             break;
1994           }
1995
1996         default:
1997           break;
1998         }
1999     }
2000   if (high_pc != 0)
2001     {
2002       arange_add (unit->abfd, &unit->arange, low_pc, high_pc);
2003     }
2004
2005   unit->first_child_die_ptr = info_ptr;
2006   return unit;
2007 }
2008
2009 /* Return TRUE if UNIT may contain the address given by ADDR.  When
2010    there are functions written entirely with inline asm statements, the
2011    range info in the compilation unit header may not be correct.  We
2012    need to consult the line info table to see if a compilation unit
2013    really contains the given address.  */
2014
2015 static bfd_boolean
2016 comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
2017 {
2018   struct arange *arange;
2019
2020   if (unit->error)
2021     return FALSE;
2022
2023   arange = &unit->arange;
2024   do
2025     {
2026       if (addr >= arange->low && addr < arange->high)
2027         return TRUE;
2028       arange = arange->next;
2029     }
2030   while (arange);
2031
2032   return FALSE;
2033 }
2034
2035 /* If UNIT contains ADDR, set the output parameters to the values for
2036    the line containing ADDR.  The output parameters, FILENAME_PTR,
2037    FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
2038    to be filled in.
2039
2040    Return TRUE if UNIT contains ADDR, and no errors were encountered;
2041    FALSE otherwise.  */
2042
2043 static bfd_boolean
2044 comp_unit_find_nearest_line (struct comp_unit *unit,
2045                              bfd_vma addr,
2046                              const char **filename_ptr,
2047                              const char **functionname_ptr,
2048                              unsigned int *linenumber_ptr,
2049                              struct dwarf2_debug *stash)
2050 {
2051   bfd_boolean line_p;
2052   bfd_boolean func_p;
2053   struct funcinfo *function;
2054
2055   if (unit->error)
2056     return FALSE;
2057
2058   if (! unit->line_table)
2059     {
2060       if (! unit->stmtlist)
2061         {
2062           unit->error = 1;
2063           return FALSE;
2064         }
2065
2066       unit->line_table = decode_line_info (unit, stash);
2067
2068       if (! unit->line_table)
2069         {
2070           unit->error = 1;
2071           return FALSE;
2072         }
2073
2074       if (unit->first_child_die_ptr < unit->end_ptr
2075           && ! scan_unit_for_symbols (unit))
2076         {
2077           unit->error = 1;
2078           return FALSE;
2079         }
2080     }
2081
2082   function = NULL;
2083   func_p = lookup_address_in_function_table (unit, addr,
2084                                              &function, functionname_ptr);
2085   if (func_p && (function->tag == DW_TAG_inlined_subroutine))
2086     stash->inliner_chain = function;
2087   line_p = lookup_address_in_line_info_table (unit->line_table, addr,
2088                                               function, filename_ptr,
2089                                               linenumber_ptr);
2090   return line_p || func_p;
2091 }
2092
2093 /* If UNIT contains SYM at ADDR, set the output parameters to the
2094    values for the line containing SYM.  The output parameters,
2095    FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
2096    filled in.
2097
2098    Return TRUE if UNIT contains SYM, and no errors were encountered;
2099    FALSE otherwise.  */
2100
2101 static bfd_boolean
2102 comp_unit_find_line (struct comp_unit *unit,
2103                      asymbol *sym,
2104                      bfd_vma addr,
2105                      const char **filename_ptr,
2106                      unsigned int *linenumber_ptr,
2107                      struct dwarf2_debug *stash)
2108 {
2109   if (unit->error)
2110     return FALSE;
2111
2112   if (! unit->line_table)
2113     {
2114       if (! unit->stmtlist)
2115         {
2116           unit->error = 1;
2117           return FALSE;
2118         }
2119
2120       unit->line_table = decode_line_info (unit, stash);
2121
2122       if (! unit->line_table)
2123         {
2124           unit->error = 1;
2125           return FALSE;
2126         }
2127
2128       if (unit->first_child_die_ptr < unit->end_ptr
2129           && ! scan_unit_for_symbols (unit))
2130         {
2131           unit->error = 1;
2132           return FALSE;
2133         }
2134     }
2135
2136   if (sym->flags & BSF_FUNCTION)
2137     return lookup_symbol_in_function_table (unit, sym, addr,
2138                                             filename_ptr,
2139                                             linenumber_ptr);
2140   else
2141     return lookup_symbol_in_variable_table (unit, sym, addr,
2142                                             filename_ptr,
2143                                             linenumber_ptr);
2144 }
2145
2146 /* Locate a section in a BFD containing debugging info.  The search starts
2147    from the section after AFTER_SEC, or from the first section in the BFD if
2148    AFTER_SEC is NULL.  The search works by examining the names of the
2149    sections.  There are two permissiable names.  The first is .debug_info.
2150    This is the standard DWARF2 name.  The second is a prefix .gnu.linkonce.wi.
2151    This is a variation on the .debug_info section which has a checksum
2152    describing the contents appended onto the name.  This allows the linker to
2153    identify and discard duplicate debugging sections for different
2154    compilation units.  */
2155 #define DWARF2_DEBUG_INFO ".debug_info"
2156 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
2157
2158 static asection *
2159 find_debug_info (bfd *abfd, asection *after_sec)
2160 {
2161   asection * msec;
2162
2163   if (after_sec)
2164     msec = after_sec->next;
2165   else
2166     msec = abfd->sections;
2167
2168   while (msec)
2169     {
2170       if (strcmp (msec->name, DWARF2_DEBUG_INFO) == 0)
2171         return msec;
2172
2173       if (strncmp (msec->name, GNU_LINKONCE_INFO, strlen (GNU_LINKONCE_INFO)) == 0)
2174         return msec;
2175
2176       msec = msec->next;
2177     }
2178
2179   return NULL;
2180 }
2181
2182 /* The DWARF2 version of find_nearest_line.  Return TRUE if the line
2183    is found without error.  ADDR_SIZE is the number of bytes in the
2184    initial .debug_info length field and in the abbreviation offset.
2185    You may use zero to indicate that the default value should be
2186    used.  */
2187
2188 bfd_boolean
2189 _bfd_dwarf2_find_nearest_line (bfd *abfd,
2190                                asection *section,
2191                                asymbol **symbols,
2192                                bfd_vma offset,
2193                                const char **filename_ptr,
2194                                const char **functionname_ptr,
2195                                unsigned int *linenumber_ptr,
2196                                unsigned int addr_size,
2197                                void **pinfo)
2198 {
2199   /* Read each compilation unit from the section .debug_info, and check
2200      to see if it contains the address we are searching for.  If yes,
2201      lookup the address, and return the line number info.  If no, go
2202      on to the next compilation unit.
2203
2204      We keep a list of all the previously read compilation units, and
2205      a pointer to the next un-read compilation unit.  Check the
2206      previously read units before reading more.  */
2207   struct dwarf2_debug *stash;
2208
2209   /* What address are we looking for?  */
2210   bfd_vma addr;
2211
2212   struct comp_unit* each;
2213
2214   stash = *pinfo;
2215   addr = offset;
2216   if (section->output_section)
2217     addr += section->output_section->vma + section->output_offset;
2218   else
2219     addr += section->vma;
2220   *filename_ptr = NULL;
2221   *functionname_ptr = NULL;
2222   *linenumber_ptr = 0;
2223
2224   /* The DWARF2 spec says that the initial length field, and the
2225      offset of the abbreviation table, should both be 4-byte values.
2226      However, some compilers do things differently.  */
2227   if (addr_size == 0)
2228     addr_size = 4;
2229   BFD_ASSERT (addr_size == 4 || addr_size == 8);
2230
2231   if (! stash)
2232     {
2233       bfd_size_type total_size;
2234       asection *msec;
2235       bfd_size_type amt = sizeof (struct dwarf2_debug);
2236
2237       stash = bfd_zalloc (abfd, amt);
2238       if (! stash)
2239         return FALSE;
2240
2241       *pinfo = stash;
2242
2243       msec = find_debug_info (abfd, NULL);
2244       if (! msec)
2245         /* No dwarf2 info.  Note that at this point the stash
2246            has been allocated, but contains zeros, this lets
2247            future calls to this function fail quicker.  */
2248          return FALSE;
2249
2250       /* There can be more than one DWARF2 info section in a BFD these days.
2251          Read them all in and produce one large stash.  We do this in two
2252          passes - in the first pass we just accumulate the section sizes.
2253          In the second pass we read in the section's contents.  The allows
2254          us to avoid reallocing the data as we add sections to the stash.  */
2255       for (total_size = 0; msec; msec = find_debug_info (abfd, msec))
2256         total_size += msec->size;
2257
2258       stash->info_ptr = bfd_alloc (abfd, total_size);
2259       if (stash->info_ptr == NULL)
2260         return FALSE;
2261
2262       stash->info_ptr_end = stash->info_ptr;
2263
2264       for (msec = find_debug_info (abfd, NULL);
2265            msec;
2266            msec = find_debug_info (abfd, msec))
2267         {
2268           bfd_size_type size;
2269           bfd_size_type start;
2270
2271           size = msec->size;
2272           if (size == 0)
2273             continue;
2274
2275           start = stash->info_ptr_end - stash->info_ptr;
2276
2277           if ((bfd_simple_get_relocated_section_contents
2278                (abfd, msec, stash->info_ptr + start, symbols)) == NULL)
2279             continue;
2280
2281           stash->info_ptr_end = stash->info_ptr + start + size;
2282         }
2283
2284       BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size);
2285
2286       stash->sec = find_debug_info (abfd, NULL);
2287       stash->sec_info_ptr = stash->info_ptr;
2288       stash->syms = symbols;
2289     }
2290
2291   /* A null info_ptr indicates that there is no dwarf2 info
2292      (or that an error occured while setting up the stash).  */
2293   if (! stash->info_ptr)
2294     return FALSE;
2295
2296   stash->inliner_chain = NULL;
2297
2298   /* Check the previously read comp. units first.  */
2299   for (each = stash->all_comp_units; each; each = each->next_unit)
2300     if (comp_unit_contains_address (each, addr)
2301         && comp_unit_find_nearest_line (each, addr, filename_ptr,
2302                                         functionname_ptr,
2303                                         linenumber_ptr, stash))
2304       return TRUE;
2305
2306   /* Read each remaining comp. units checking each as they are read.  */
2307   while (stash->info_ptr < stash->info_ptr_end)
2308     {
2309       bfd_vma length;
2310       unsigned int offset_size = addr_size;
2311       bfd_byte *info_ptr_unit = stash->info_ptr;
2312
2313       length = read_4_bytes (abfd, stash->info_ptr);
2314       /* A 0xffffff length is the DWARF3 way of indicating we use
2315          64-bit offsets, instead of 32-bit offsets.  */
2316       if (length == 0xffffffff)
2317         {
2318           offset_size = 8;
2319           length = read_8_bytes (abfd, stash->info_ptr + 4);
2320           stash->info_ptr += 12;
2321         }
2322       /* A zero length is the IRIX way of indicating 64-bit offsets,
2323          mostly because the 64-bit length will generally fit in 32
2324          bits, and the endianness helps.  */
2325       else if (length == 0)
2326         {
2327           offset_size = 8;
2328           length = read_4_bytes (abfd, stash->info_ptr + 4);
2329           stash->info_ptr += 8;
2330         }
2331       /* In the absence of the hints above, we assume addr_size-sized
2332          offsets, for backward-compatibility with pre-DWARF3 64-bit
2333          platforms.  */
2334       else if (addr_size == 8)
2335         {
2336           length = read_8_bytes (abfd, stash->info_ptr);
2337           stash->info_ptr += 8;
2338         }
2339       else
2340         stash->info_ptr += 4;
2341
2342       if (length > 0)
2343         {
2344           each = parse_comp_unit (abfd, stash, length, info_ptr_unit,
2345                                   offset_size);
2346           stash->info_ptr += length;
2347
2348           if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
2349               == stash->sec->size)
2350             {
2351               stash->sec = find_debug_info (abfd, stash->sec);
2352               stash->sec_info_ptr = stash->info_ptr;
2353             }
2354
2355           if (each)
2356             {
2357               each->next_unit = stash->all_comp_units;
2358               stash->all_comp_units = each;
2359
2360               /* DW_AT_low_pc and DW_AT_high_pc are optional for
2361                  compilation units.  If we don't have them (i.e.,
2362                  unit->high == 0), we need to consult the line info
2363                  table to see if a compilation unit contains the given
2364                  address.  */
2365               if ((each->arange.high == 0
2366                    || comp_unit_contains_address (each, addr))
2367                   && comp_unit_find_nearest_line (each, addr,
2368                                                   filename_ptr,
2369                                                   functionname_ptr,
2370                                                   linenumber_ptr,
2371                                                   stash))
2372                 return TRUE;
2373             }
2374         }
2375     }
2376
2377   return FALSE;
2378 }
2379
2380 /* The DWARF2 version of find_line.  Return TRUE if the line is found
2381    without error.  */
2382
2383 bfd_boolean
2384 _bfd_dwarf2_find_line (bfd *abfd,
2385                        asymbol **symbols,
2386                        asymbol *symbol,
2387                        const char **filename_ptr,
2388                        unsigned int *linenumber_ptr,
2389                        unsigned int addr_size,
2390                        void **pinfo)
2391 {
2392   /* Read each compilation unit from the section .debug_info, and check
2393      to see if it contains the address we are searching for.  If yes,
2394      lookup the address, and return the line number info.  If no, go
2395      on to the next compilation unit.
2396
2397      We keep a list of all the previously read compilation units, and
2398      a pointer to the next un-read compilation unit.  Check the
2399      previously read units before reading more.  */
2400   struct dwarf2_debug *stash;
2401
2402   /* What address are we looking for?  */
2403   bfd_vma addr;
2404
2405   struct comp_unit* each;
2406
2407   asection *section;
2408
2409   bfd_boolean found;
2410
2411   section = bfd_get_section (symbol);
2412
2413   addr = symbol->value;
2414   if (section->output_section)
2415     addr += section->output_section->vma + section->output_offset;
2416   else
2417     addr += section->vma;
2418
2419   *filename_ptr = NULL;
2420   stash = *pinfo;
2421   *filename_ptr = NULL;
2422   *linenumber_ptr = 0;
2423
2424   if (! stash)
2425     {
2426       bfd_size_type total_size;
2427       asection *msec;
2428       bfd_size_type amt = sizeof (struct dwarf2_debug);
2429
2430       stash = bfd_zalloc (abfd, amt);
2431       if (! stash)
2432         return FALSE;
2433
2434       *pinfo = stash;
2435
2436       msec = find_debug_info (abfd, NULL);
2437       if (! msec)
2438         /* No dwarf2 info.  Note that at this point the stash
2439            has been allocated, but contains zeros, this lets
2440            future calls to this function fail quicker.  */
2441          return FALSE;
2442
2443       /* There can be more than one DWARF2 info section in a BFD these days.
2444          Read them all in and produce one large stash.  We do this in two
2445          passes - in the first pass we just accumulate the section sizes.
2446          In the second pass we read in the section's contents.  The allows
2447          us to avoid reallocing the data as we add sections to the stash.  */
2448       for (total_size = 0; msec; msec = find_debug_info (abfd, msec))
2449         total_size += msec->size;
2450
2451       stash->info_ptr = bfd_alloc (abfd, total_size);
2452       if (stash->info_ptr == NULL)
2453         return FALSE;
2454
2455       stash->info_ptr_end = stash->info_ptr;
2456
2457       for (msec = find_debug_info (abfd, NULL);
2458            msec;
2459            msec = find_debug_info (abfd, msec))
2460         {
2461           bfd_size_type size;
2462           bfd_size_type start;
2463
2464           size = msec->size;
2465           if (size == 0)
2466             continue;
2467
2468           start = stash->info_ptr_end - stash->info_ptr;
2469
2470           if ((bfd_simple_get_relocated_section_contents
2471                (abfd, msec, stash->info_ptr + start, symbols)) == NULL)
2472             continue;
2473
2474           stash->info_ptr_end = stash->info_ptr + start + size;
2475         }
2476
2477       BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size);
2478
2479       stash->sec = find_debug_info (abfd, NULL);
2480       stash->sec_info_ptr = stash->info_ptr;
2481       stash->syms = symbols;
2482     }
2483
2484   /* A null info_ptr indicates that there is no dwarf2 info
2485      (or that an error occured while setting up the stash).  */
2486   if (! stash->info_ptr)
2487     return FALSE;
2488
2489   stash->inliner_chain = NULL;
2490
2491   /* Check the previously read comp. units first.  */
2492   for (each = stash->all_comp_units; each; each = each->next_unit)
2493     if ((symbol->flags & BSF_FUNCTION) == 0
2494         || comp_unit_contains_address (each, addr))
2495       {
2496         found = comp_unit_find_line (each, symbol, addr, filename_ptr,
2497                                      linenumber_ptr, stash);
2498         if (found)
2499           return found;
2500       }
2501
2502   /* The DWARF2 spec says that the initial length field, and the
2503      offset of the abbreviation table, should both be 4-byte values.
2504      However, some compilers do things differently.  */
2505   if (addr_size == 0)
2506     addr_size = 4;
2507   BFD_ASSERT (addr_size == 4 || addr_size == 8);
2508
2509   /* Read each remaining comp. units checking each as they are read.  */
2510   while (stash->info_ptr < stash->info_ptr_end)
2511     {
2512       bfd_vma length;
2513       unsigned int offset_size = addr_size;
2514       bfd_byte *info_ptr_unit = stash->info_ptr;
2515
2516       length = read_4_bytes (abfd, stash->info_ptr);
2517       /* A 0xffffff length is the DWARF3 way of indicating we use
2518          64-bit offsets, instead of 32-bit offsets.  */
2519       if (length == 0xffffffff)
2520         {
2521           offset_size = 8;
2522           length = read_8_bytes (abfd, stash->info_ptr + 4);
2523           stash->info_ptr += 12;
2524         }
2525       /* A zero length is the IRIX way of indicating 64-bit offsets,
2526          mostly because the 64-bit length will generally fit in 32
2527          bits, and the endianness helps.  */
2528       else if (length == 0)
2529         {
2530           offset_size = 8;
2531           length = read_4_bytes (abfd, stash->info_ptr + 4);
2532           stash->info_ptr += 8;
2533         }
2534       /* In the absence of the hints above, we assume addr_size-sized
2535          offsets, for backward-compatibility with pre-DWARF3 64-bit
2536          platforms.  */
2537       else if (addr_size == 8)
2538         {
2539           length = read_8_bytes (abfd, stash->info_ptr);
2540           stash->info_ptr += 8;
2541         }
2542       else
2543         stash->info_ptr += 4;
2544
2545       if (length > 0)
2546         {
2547           each = parse_comp_unit (abfd, stash, length, info_ptr_unit,
2548                                   offset_size);
2549           stash->info_ptr += length;
2550
2551           if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
2552               == stash->sec->size)
2553             {
2554               stash->sec = find_debug_info (abfd, stash->sec);
2555               stash->sec_info_ptr = stash->info_ptr;
2556             }
2557
2558           if (each)
2559             {
2560               each->next_unit = stash->all_comp_units;
2561               stash->all_comp_units = each;
2562
2563               /* DW_AT_low_pc and DW_AT_high_pc are optional for
2564                  compilation units.  If we don't have them (i.e.,
2565                  unit->high == 0), we need to consult the line info
2566                  table to see if a compilation unit contains the given
2567                  address.  */
2568               found = (((symbol->flags & BSF_FUNCTION) == 0
2569                         || each->arange.high <= 0
2570                         || comp_unit_contains_address (each, addr))
2571                        && comp_unit_find_line (each, symbol, addr,
2572                                                filename_ptr,
2573                                                linenumber_ptr,
2574                                                stash));
2575               if (found)
2576                 return TRUE;
2577             }
2578         }
2579     }
2580
2581   return FALSE;
2582 }
2583
2584 bfd_boolean
2585 _bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED,
2586                                const char **filename_ptr,
2587                                const char **functionname_ptr,
2588                                unsigned int *linenumber_ptr,
2589                                void **pinfo)
2590 {
2591   struct dwarf2_debug *stash;
2592
2593   stash = *pinfo;
2594   if (stash)
2595     {
2596       struct funcinfo *func = stash->inliner_chain;
2597       if (func && func->caller_func)
2598         {
2599           *filename_ptr = func->caller_file;
2600           *functionname_ptr = func->caller_func->name;
2601           *linenumber_ptr = func->caller_line;
2602           stash->inliner_chain = func->caller_func;
2603           return (TRUE);
2604         }
2605     }
2606
2607   return (FALSE);
2608 }
2609
2610 void
2611 _bfd_dwarf2_cleanup_debug_info (bfd *abfd)
2612 {
2613   struct comp_unit *each;
2614   struct dwarf2_debug *stash;
2615
2616   if (abfd == NULL || elf_tdata (abfd) == NULL)
2617     return;
2618
2619   stash = elf_tdata (abfd)->dwarf2_find_line_info;
2620
2621   if (stash == NULL)
2622     return;
2623
2624   for (each = stash->all_comp_units; each; each = each->next_unit)
2625     {
2626       struct abbrev_info **abbrevs = each->abbrevs;
2627       size_t i;
2628
2629       for (i = 0; i < ABBREV_HASH_SIZE; i++)
2630         {
2631           struct abbrev_info *abbrev = abbrevs[i];
2632
2633           while (abbrev)
2634             {
2635               free (abbrev->attrs);
2636               abbrev = abbrev->next;
2637             }
2638         }
2639
2640       if (each->line_table)
2641         {
2642           free (each->line_table->dirs);
2643           free (each->line_table->files);
2644         }
2645     }
2646
2647   free (stash->dwarf_abbrev_buffer);
2648   free (stash->dwarf_line_buffer);
2649   free (stash->dwarf_ranges_buffer);
2650 }