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