2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
5 Adapted from gdb/dwarf2read.c by Gavin Koch of Cygnus Solutions
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
16 This file is part of BFD.
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.
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.
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. */
35 #include "libiberty.h"
40 /* The data in the .debug_line statement prologue looks like this. */
45 unsigned short version;
46 bfd_vma prologue_length;
47 unsigned char minimum_instruction_length;
48 unsigned char maximum_ops_per_insn;
49 unsigned char default_is_stmt;
51 unsigned char line_range;
52 unsigned char opcode_base;
53 unsigned char *standard_opcode_lengths;
56 /* Attributes have a name and a value. */
60 enum dwarf_attribute name;
65 struct dwarf_block *blk;
72 /* Blocks are a bunch of untyped bytes. */
79 struct adjusted_section
87 /* A list of all previously read comp_units. */
88 struct comp_unit *all_comp_units;
90 /* Last comp unit in list above. */
91 struct comp_unit *last_comp_unit;
93 /* The next unread compilation unit within the .debug_info section.
94 Zero indicates that the .debug_info section has not been loaded
98 /* Pointer to the end of the .debug_info section memory buffer. */
99 bfd_byte *info_ptr_end;
101 /* Pointer to the bfd, section and address of the beginning of the
102 section. The bfd might be different than expected because of
103 gnu_debuglink sections. */
106 bfd_byte *sec_info_ptr;
108 /* A pointer to the memory block allocated for info_ptr. Neither
109 info_ptr nor sec_info_ptr are guaranteed to stay pointing to the
110 beginning of the malloc block. This is used only to free the
112 bfd_byte *info_ptr_memory;
114 /* Pointer to the symbol table. */
117 /* Pointer to the .debug_abbrev section loaded into memory. */
118 bfd_byte *dwarf_abbrev_buffer;
120 /* Length of the loaded .debug_abbrev section. */
121 bfd_size_type dwarf_abbrev_size;
123 /* Buffer for decode_line_info. */
124 bfd_byte *dwarf_line_buffer;
126 /* Length of the loaded .debug_line section. */
127 bfd_size_type dwarf_line_size;
129 /* Pointer to the .debug_str section loaded into memory. */
130 bfd_byte *dwarf_str_buffer;
132 /* Length of the loaded .debug_str section. */
133 bfd_size_type dwarf_str_size;
135 /* Pointer to the .debug_ranges section loaded into memory. */
136 bfd_byte *dwarf_ranges_buffer;
138 /* Length of the loaded .debug_ranges section. */
139 bfd_size_type dwarf_ranges_size;
141 /* If the most recent call to bfd_find_nearest_line was given an
142 address in an inlined function, preserve a pointer into the
143 calling chain for subsequent calls to bfd_find_inliner_info to
145 struct funcinfo *inliner_chain;
147 /* Number of sections whose VMA we must adjust. */
148 unsigned int adjusted_section_count;
150 /* Array of sections with adjusted VMA. */
151 struct adjusted_section *adjusted_sections;
153 /* Number of times find_line is called. This is used in
154 the heuristic for enabling the info hash tables. */
157 #define STASH_INFO_HASH_TRIGGER 100
159 /* Hash table mapping symbol names to function infos. */
160 struct info_hash_table *funcinfo_hash_table;
162 /* Hash table mapping symbol names to variable infos. */
163 struct info_hash_table *varinfo_hash_table;
165 /* Head of comp_unit list in the last hash table update. */
166 struct comp_unit *hash_units_head;
168 /* Status of info hash. */
169 int info_hash_status;
170 #define STASH_INFO_HASH_OFF 0
171 #define STASH_INFO_HASH_ON 1
172 #define STASH_INFO_HASH_DISABLED 2
182 /* A minimal decoding of DWARF2 compilation units. We only decode
183 what's needed to get to the line number information. */
187 /* Chain the previously read compilation units. */
188 struct comp_unit *next_unit;
190 /* Likewise, chain the compilation unit read after this one.
191 The comp units are stored in reversed reading order. */
192 struct comp_unit *prev_unit;
194 /* Keep the bfd convenient (for memory allocation). */
197 /* The lowest and highest addresses contained in this compilation
198 unit as specified in the compilation unit header. */
199 struct arange arange;
201 /* The DW_AT_name attribute (for error messages). */
204 /* The abbrev hash table. */
205 struct abbrev_info **abbrevs;
207 /* Note that an error was found by comp_unit_find_nearest_line. */
210 /* The DW_AT_comp_dir attribute. */
213 /* TRUE if there is a line number table associated with this comp. unit. */
216 /* Pointer to the current comp_unit so that we can find a given entry
218 bfd_byte *info_ptr_unit;
220 /* Pointer to the start of the debug section, for DW_FORM_ref_addr. */
221 bfd_byte *sec_info_ptr;
223 /* The offset into .debug_line of the line number table. */
224 unsigned long line_offset;
226 /* Pointer to the first child die for the comp unit. */
227 bfd_byte *first_child_die_ptr;
229 /* The end of the comp unit. */
232 /* The decoded line number, NULL if not yet decoded. */
233 struct line_info_table *line_table;
235 /* A list of the functions found in this comp. unit. */
236 struct funcinfo *function_table;
238 /* A list of the variables found in this comp. unit. */
239 struct varinfo *variable_table;
241 /* Pointer to dwarf2_debug structure. */
242 struct dwarf2_debug *stash;
244 /* DWARF format version for this unit - from unit header. */
247 /* Address size for this unit - from unit header. */
248 unsigned char addr_size;
250 /* Offset size for this unit - from unit header. */
251 unsigned char offset_size;
253 /* Base address for this unit - from DW_AT_low_pc attribute of
254 DW_TAG_compile_unit DIE */
255 bfd_vma base_address;
257 /* TRUE if symbols are cached in hash table for faster lookup by name. */
261 /* This data structure holds the information of an abbrev. */
264 unsigned int number; /* Number identifying abbrev. */
265 enum dwarf_tag tag; /* DWARF tag. */
266 int has_children; /* Boolean. */
267 unsigned int num_attrs; /* Number of attributes. */
268 struct attr_abbrev *attrs; /* An array of attribute descriptions. */
269 struct abbrev_info *next; /* Next in chain. */
274 enum dwarf_attribute name;
275 enum dwarf_form form;
278 #ifndef ABBREV_HASH_SIZE
279 #define ABBREV_HASH_SIZE 121
281 #ifndef ATTR_ALLOC_CHUNK
282 #define ATTR_ALLOC_CHUNK 4
285 /* Variable and function hash tables. This is used to speed up look-up
286 in lookup_symbol_in_var_table() and lookup_symbol_in_function_table().
287 In order to share code between variable and function infos, we use
288 a list of untyped pointer for all variable/function info associated with
289 a symbol. We waste a bit of memory for list with one node but that
290 simplifies the code. */
292 struct info_list_node
294 struct info_list_node *next;
298 /* Info hash entry. */
299 struct info_hash_entry
301 struct bfd_hash_entry root;
302 struct info_list_node *head;
305 struct info_hash_table
307 struct bfd_hash_table base;
310 /* Function to create a new entry in info hash table. */
312 static struct bfd_hash_entry *
313 info_hash_table_newfunc (struct bfd_hash_entry *entry,
314 struct bfd_hash_table *table,
317 struct info_hash_entry *ret = (struct info_hash_entry *) entry;
319 /* Allocate the structure if it has not already been allocated by a
323 ret = (struct info_hash_entry *) bfd_hash_allocate (table,
329 /* Call the allocation method of the base class. */
330 ret = ((struct info_hash_entry *)
331 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
333 /* Initialize the local fields here. */
337 return (struct bfd_hash_entry *) ret;
340 /* Function to create a new info hash table. It returns a pointer to the
341 newly created table or NULL if there is any error. We need abfd
342 solely for memory allocation. */
344 static struct info_hash_table *
345 create_info_hash_table (bfd *abfd)
347 struct info_hash_table *hash_table;
349 hash_table = (struct info_hash_table *)
350 bfd_alloc (abfd, sizeof (struct info_hash_table));
354 if (!bfd_hash_table_init (&hash_table->base, info_hash_table_newfunc,
355 sizeof (struct info_hash_entry)))
357 bfd_release (abfd, hash_table);
364 /* Insert an info entry into an info hash table. We do not check of
365 duplicate entries. Also, the caller need to guarantee that the
366 right type of info in inserted as info is passed as a void* pointer.
367 This function returns true if there is no error. */
370 insert_info_hash_table (struct info_hash_table *hash_table,
375 struct info_hash_entry *entry;
376 struct info_list_node *node;
378 entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base,
383 node = (struct info_list_node *) bfd_hash_allocate (&hash_table->base,
389 node->next = entry->head;
395 /* Look up an info entry list from an info hash table. Return NULL
398 static struct info_list_node *
399 lookup_info_hash_table (struct info_hash_table *hash_table, const char *key)
401 struct info_hash_entry *entry;
403 entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base, key,
405 return entry ? entry->head : NULL;
408 /* Read a section, uncompress it if necessary, and relocate it. */
411 read_and_uncompress_section (bfd * abfd,
413 bfd_boolean section_is_compressed,
415 bfd_byte ** section_buffer,
416 bfd_size_type * section_size)
418 /* Get the unrelocated contents of the section. */
419 *section_buffer = (bfd_byte *) bfd_malloc (*section_size);
420 if (! *section_buffer)
422 if (! bfd_get_section_contents (abfd, msec, *section_buffer,
426 if (section_is_compressed)
428 if (! bfd_uncompress_section_contents (section_buffer, section_size))
430 (*_bfd_error_handler) (_("Dwarf Error: unable to decompress %s section."),
431 bfd_get_section_name (abfd, msec));
432 bfd_set_error (bfd_error_bad_value);
439 /* We want to relocate the data we've already read (and
440 decompressed), so we store a pointer to the data in
441 the bfd_section, and tell it that the contents are
442 already in memory. */
443 BFD_ASSERT (msec->contents == NULL && (msec->flags & SEC_IN_MEMORY) == 0);
444 msec->contents = *section_buffer;
445 msec->flags |= SEC_IN_MEMORY;
446 msec->size = *section_size;
448 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL, syms);
449 if (! *section_buffer)
456 /* Read a section into its appropriate place in the dwarf2_debug
457 struct (indicated by SECTION_BUFFER and SECTION_SIZE). If SYMS is
458 not NULL, use bfd_simple_get_relocated_section_contents to read the
459 section contents, otherwise use bfd_get_section_contents. Fail if
460 the located section does not contain at least OFFSET bytes. */
463 read_section (bfd * abfd,
464 const char * section_name,
465 const char * compressed_section_name,
468 bfd_byte ** section_buffer,
469 bfd_size_type * section_size)
472 bfd_boolean section_is_compressed = FALSE;
474 /* read_section is a noop if the section has already been read. */
475 if (!*section_buffer)
477 msec = bfd_get_section_by_name (abfd, section_name);
478 if (! msec && compressed_section_name)
480 msec = bfd_get_section_by_name (abfd, compressed_section_name);
481 section_is_compressed = TRUE;
485 (*_bfd_error_handler) (_("Dwarf Error: Can't find %s section."), section_name);
486 bfd_set_error (bfd_error_bad_value);
490 *section_size = msec->rawsize ? msec->rawsize : msec->size;
492 if (! read_and_uncompress_section (abfd, msec, section_is_compressed,
493 syms, section_buffer, section_size))
497 /* It is possible to get a bad value for the offset into the section
498 that the client wants. Validate it here to avoid trouble later. */
499 if (offset != 0 && offset >= *section_size)
501 (*_bfd_error_handler) (_("Dwarf Error: Offset (%lu) greater than or equal to %s size (%lu)."),
502 (long) offset, section_name, *section_size);
503 bfd_set_error (bfd_error_bad_value);
511 The following function up to the END VERBATIM mark are
512 copied directly from dwarf2read.c. */
514 /* Read dwarf information from a buffer. */
517 read_1_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf)
519 return bfd_get_8 (abfd, buf);
523 read_1_signed_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf)
525 return bfd_get_signed_8 (abfd, buf);
529 read_2_bytes (bfd *abfd, bfd_byte *buf)
531 return bfd_get_16 (abfd, buf);
535 read_4_bytes (bfd *abfd, bfd_byte *buf)
537 return bfd_get_32 (abfd, buf);
541 read_8_bytes (bfd *abfd, bfd_byte *buf)
543 return bfd_get_64 (abfd, buf);
547 read_n_bytes (bfd *abfd ATTRIBUTE_UNUSED,
549 unsigned int size ATTRIBUTE_UNUSED)
555 read_string (bfd *abfd ATTRIBUTE_UNUSED,
557 unsigned int *bytes_read_ptr)
559 /* Return a pointer to the embedded string. */
560 char *str = (char *) buf;
568 *bytes_read_ptr = strlen (str) + 1;
575 read_indirect_string (struct comp_unit * unit,
577 unsigned int * bytes_read_ptr)
580 struct dwarf2_debug *stash = unit->stash;
583 if (unit->offset_size == 4)
584 offset = read_4_bytes (unit->abfd, buf);
586 offset = read_8_bytes (unit->abfd, buf);
588 *bytes_read_ptr = unit->offset_size;
590 if (! read_section (unit->abfd, ".debug_str", ".zdebug_str",
592 &stash->dwarf_str_buffer, &stash->dwarf_str_size))
595 str = (char *) stash->dwarf_str_buffer + offset;
602 read_address (struct comp_unit *unit, bfd_byte *buf)
604 int signed_vma = get_elf_backend_data (unit->abfd)->sign_extend_vma;
608 switch (unit->addr_size)
611 return bfd_get_signed_64 (unit->abfd, buf);
613 return bfd_get_signed_32 (unit->abfd, buf);
615 return bfd_get_signed_16 (unit->abfd, buf);
622 switch (unit->addr_size)
625 return bfd_get_64 (unit->abfd, buf);
627 return bfd_get_32 (unit->abfd, buf);
629 return bfd_get_16 (unit->abfd, buf);
636 /* Lookup an abbrev_info structure in the abbrev hash table. */
638 static struct abbrev_info *
639 lookup_abbrev (unsigned int number, struct abbrev_info **abbrevs)
641 unsigned int hash_number;
642 struct abbrev_info *abbrev;
644 hash_number = number % ABBREV_HASH_SIZE;
645 abbrev = abbrevs[hash_number];
649 if (abbrev->number == number)
652 abbrev = abbrev->next;
658 /* In DWARF version 2, the description of the debugging information is
659 stored in a separate .debug_abbrev section. Before we read any
660 dies from a section we read in all abbreviations and install them
663 static struct abbrev_info**
664 read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
666 struct abbrev_info **abbrevs;
667 bfd_byte *abbrev_ptr;
668 struct abbrev_info *cur_abbrev;
669 unsigned int abbrev_number, bytes_read, abbrev_name;
670 unsigned int abbrev_form, hash_number;
673 if (! read_section (abfd, ".debug_abbrev", ".zdebug_abbrev",
675 &stash->dwarf_abbrev_buffer, &stash->dwarf_abbrev_size))
678 amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
679 abbrevs = (struct abbrev_info **) bfd_zalloc (abfd, amt);
683 abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
684 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
685 abbrev_ptr += bytes_read;
687 /* Loop until we reach an abbrev number of 0. */
688 while (abbrev_number)
690 amt = sizeof (struct abbrev_info);
691 cur_abbrev = (struct abbrev_info *) bfd_zalloc (abfd, amt);
692 if (cur_abbrev == NULL)
695 /* Read in abbrev header. */
696 cur_abbrev->number = abbrev_number;
697 cur_abbrev->tag = (enum dwarf_tag)
698 read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
699 abbrev_ptr += bytes_read;
700 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
703 /* Now read in declarations. */
704 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
705 abbrev_ptr += bytes_read;
706 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
707 abbrev_ptr += bytes_read;
711 if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
713 struct attr_abbrev *tmp;
715 amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
716 amt *= sizeof (struct attr_abbrev);
717 tmp = (struct attr_abbrev *) bfd_realloc (cur_abbrev->attrs, amt);
722 for (i = 0; i < ABBREV_HASH_SIZE; i++)
724 struct abbrev_info *abbrev = abbrevs[i];
728 free (abbrev->attrs);
729 abbrev = abbrev->next;
734 cur_abbrev->attrs = tmp;
737 cur_abbrev->attrs[cur_abbrev->num_attrs].name
738 = (enum dwarf_attribute) abbrev_name;
739 cur_abbrev->attrs[cur_abbrev->num_attrs++].form
740 = (enum dwarf_form) abbrev_form;
741 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
742 abbrev_ptr += bytes_read;
743 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
744 abbrev_ptr += bytes_read;
747 hash_number = abbrev_number % ABBREV_HASH_SIZE;
748 cur_abbrev->next = abbrevs[hash_number];
749 abbrevs[hash_number] = cur_abbrev;
751 /* Get next abbreviation.
752 Under Irix6 the abbreviations for a compilation unit are not
753 always properly terminated with an abbrev number of 0.
754 Exit loop if we encounter an abbreviation which we have
755 already read (which means we are about to read the abbreviations
756 for the next compile unit) or if the end of the abbreviation
758 if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
759 >= stash->dwarf_abbrev_size)
761 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
762 abbrev_ptr += bytes_read;
763 if (lookup_abbrev (abbrev_number,abbrevs) != NULL)
770 /* Read an attribute value described by an attribute form. */
773 read_attribute_value (struct attribute *attr,
775 struct comp_unit *unit,
778 bfd *abfd = unit->abfd;
779 unsigned int bytes_read;
780 struct dwarf_block *blk;
783 attr->form = (enum dwarf_form) form;
787 case DW_FORM_ref_addr:
788 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
790 if (unit->version == 3 || unit->version == 4)
792 if (unit->offset_size == 4)
793 attr->u.val = read_4_bytes (unit->abfd, info_ptr);
795 attr->u.val = read_8_bytes (unit->abfd, info_ptr);
796 info_ptr += unit->offset_size;
801 attr->u.val = read_address (unit, info_ptr);
802 info_ptr += unit->addr_size;
804 case DW_FORM_sec_offset:
805 if (unit->offset_size == 4)
806 attr->u.val = read_4_bytes (unit->abfd, info_ptr);
808 attr->u.val = read_8_bytes (unit->abfd, info_ptr);
809 info_ptr += unit->offset_size;
812 amt = sizeof (struct dwarf_block);
813 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
816 blk->size = read_2_bytes (abfd, info_ptr);
818 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
819 info_ptr += blk->size;
823 amt = sizeof (struct dwarf_block);
824 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
827 blk->size = read_4_bytes (abfd, info_ptr);
829 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
830 info_ptr += blk->size;
834 attr->u.val = read_2_bytes (abfd, info_ptr);
838 attr->u.val = read_4_bytes (abfd, info_ptr);
842 attr->u.val = read_8_bytes (abfd, info_ptr);
846 attr->u.str = read_string (abfd, info_ptr, &bytes_read);
847 info_ptr += bytes_read;
850 attr->u.str = read_indirect_string (unit, info_ptr, &bytes_read);
851 info_ptr += bytes_read;
853 case DW_FORM_exprloc:
855 amt = sizeof (struct dwarf_block);
856 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
859 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
860 info_ptr += bytes_read;
861 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
862 info_ptr += blk->size;
866 amt = sizeof (struct dwarf_block);
867 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
870 blk->size = read_1_byte (abfd, info_ptr);
872 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
873 info_ptr += blk->size;
877 attr->u.val = read_1_byte (abfd, info_ptr);
881 attr->u.val = read_1_byte (abfd, info_ptr);
884 case DW_FORM_flag_present:
888 attr->u.sval = read_signed_leb128 (abfd, info_ptr, &bytes_read);
889 info_ptr += bytes_read;
892 attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
893 info_ptr += bytes_read;
896 attr->u.val = read_1_byte (abfd, info_ptr);
900 attr->u.val = read_2_bytes (abfd, info_ptr);
904 attr->u.val = read_4_bytes (abfd, info_ptr);
908 attr->u.val = read_8_bytes (abfd, info_ptr);
911 case DW_FORM_ref_sig8:
912 attr->u.val = read_8_bytes (abfd, info_ptr);
915 case DW_FORM_ref_udata:
916 attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
917 info_ptr += bytes_read;
919 case DW_FORM_indirect:
920 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
921 info_ptr += bytes_read;
922 info_ptr = read_attribute_value (attr, form, unit, info_ptr);
925 (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %u."),
927 bfd_set_error (bfd_error_bad_value);
933 /* Read an attribute described by an abbreviated attribute. */
936 read_attribute (struct attribute *attr,
937 struct attr_abbrev *abbrev,
938 struct comp_unit *unit,
941 attr->name = abbrev->name;
942 info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr);
946 /* Source line information table routines. */
948 #define FILE_ALLOC_CHUNK 5
949 #define DIR_ALLOC_CHUNK 5
953 struct line_info* prev_line;
958 unsigned char op_index;
959 unsigned char end_sequence; /* End of (sequential) code sequence. */
973 struct line_sequence* prev_sequence;
974 struct line_info* last_line; /* Largest VMA. */
977 struct line_info_table
980 unsigned int num_files;
981 unsigned int num_dirs;
982 unsigned int num_sequences;
985 struct fileinfo* files;
986 struct line_sequence* sequences;
987 struct line_info* lcl_head; /* Local head; used in 'add_line_info'. */
990 /* Remember some information about each function. If the function is
991 inlined (DW_TAG_inlined_subroutine) it may have two additional
992 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
993 source code location where this function was inlined. */
997 struct funcinfo *prev_func; /* Pointer to previous function in list of all functions */
998 struct funcinfo *caller_func; /* Pointer to function one scope higher */
999 char *caller_file; /* Source location file name where caller_func inlines this func */
1000 int caller_line; /* Source location line number where caller_func inlines this func */
1001 char *file; /* Source location file name */
1002 int line; /* Source location line number */
1005 struct arange arange;
1006 asection *sec; /* Where the symbol is defined */
1011 /* Pointer to previous variable in list of all variables */
1012 struct varinfo *prev_var;
1013 /* Source location file name */
1015 /* Source location line number */
1020 /* Where the symbol is defined */
1022 /* Is this a stack variable? */
1023 unsigned int stack: 1;
1026 /* Return TRUE if NEW_LINE should sort after LINE. */
1028 static inline bfd_boolean
1029 new_line_sorts_after (struct line_info *new_line, struct line_info *line)
1031 return (new_line->address > line->address
1032 || (new_line->address == line->address
1033 && (new_line->op_index > line->op_index
1034 || (new_line->op_index == line->op_index
1035 && new_line->end_sequence < line->end_sequence))));
1039 /* Adds a new entry to the line_info list in the line_info_table, ensuring
1040 that the list is sorted. Note that the line_info list is sorted from
1041 highest to lowest VMA (with possible duplicates); that is,
1042 line_info->prev_line always accesses an equal or smaller VMA. */
1045 add_line_info (struct line_info_table *table,
1047 unsigned char op_index,
1050 unsigned int column,
1053 bfd_size_type amt = sizeof (struct line_info);
1054 struct line_sequence* seq = table->sequences;
1055 struct line_info* info = (struct line_info *) bfd_alloc (table->abfd, amt);
1060 /* Set member data of 'info'. */
1061 info->prev_line = NULL;
1062 info->address = address;
1063 info->op_index = op_index;
1065 info->column = column;
1066 info->end_sequence = end_sequence;
1068 if (filename && filename[0])
1070 info->filename = (char *) bfd_alloc (table->abfd, strlen (filename) + 1);
1071 if (info->filename == NULL)
1073 strcpy (info->filename, filename);
1076 info->filename = NULL;
1078 /* Find the correct location for 'info'. Normally we will receive
1079 new line_info data 1) in order and 2) with increasing VMAs.
1080 However some compilers break the rules (cf. decode_line_info) and
1081 so we include some heuristics for quickly finding the correct
1082 location for 'info'. In particular, these heuristics optimize for
1083 the common case in which the VMA sequence that we receive is a
1084 list of locally sorted VMAs such as
1085 p...z a...j (where a < j < p < z)
1087 Note: table->lcl_head is used to head an *actual* or *possible*
1088 sub-sequence within the list (such as a...j) that is not directly
1089 headed by table->last_line
1091 Note: we may receive duplicate entries from 'decode_line_info'. */
1094 && seq->last_line->address == address
1095 && seq->last_line->op_index == op_index
1096 && seq->last_line->end_sequence == end_sequence)
1098 /* We only keep the last entry with the same address and end
1099 sequence. See PR ld/4986. */
1100 if (table->lcl_head == seq->last_line)
1101 table->lcl_head = info;
1102 info->prev_line = seq->last_line->prev_line;
1103 seq->last_line = info;
1105 else if (!seq || seq->last_line->end_sequence)
1107 /* Start a new line sequence. */
1108 amt = sizeof (struct line_sequence);
1109 seq = (struct line_sequence *) bfd_malloc (amt);
1112 seq->low_pc = address;
1113 seq->prev_sequence = table->sequences;
1114 seq->last_line = info;
1115 table->lcl_head = info;
1116 table->sequences = seq;
1117 table->num_sequences++;
1119 else if (new_line_sorts_after (info, seq->last_line))
1121 /* Normal case: add 'info' to the beginning of the current sequence. */
1122 info->prev_line = seq->last_line;
1123 seq->last_line = info;
1125 /* lcl_head: initialize to head a *possible* sequence at the end. */
1126 if (!table->lcl_head)
1127 table->lcl_head = info;
1129 else if (!new_line_sorts_after (info, table->lcl_head)
1130 && (!table->lcl_head->prev_line
1131 || new_line_sorts_after (info, table->lcl_head->prev_line)))
1133 /* Abnormal but easy: lcl_head is the head of 'info'. */
1134 info->prev_line = table->lcl_head->prev_line;
1135 table->lcl_head->prev_line = info;
1139 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head'
1140 are valid heads for 'info'. Reset 'lcl_head'. */
1141 struct line_info* li2 = seq->last_line; /* Always non-NULL. */
1142 struct line_info* li1 = li2->prev_line;
1146 if (!new_line_sorts_after (info, li2)
1147 && new_line_sorts_after (info, li1))
1150 li2 = li1; /* always non-NULL */
1151 li1 = li1->prev_line;
1153 table->lcl_head = li2;
1154 info->prev_line = table->lcl_head->prev_line;
1155 table->lcl_head->prev_line = info;
1156 if (address < seq->low_pc)
1157 seq->low_pc = address;
1162 /* Extract a fully qualified filename from a line info table.
1163 The returned string has been malloc'ed and it is the caller's
1164 responsibility to free it. */
1167 concat_filename (struct line_info_table *table, unsigned int file)
1171 if (file - 1 >= table->num_files)
1173 /* FILE == 0 means unknown. */
1175 (*_bfd_error_handler)
1176 (_("Dwarf Error: mangled line number section (bad file number)."));
1177 return strdup ("<unknown>");
1180 filename = table->files[file - 1].name;
1182 if (!IS_ABSOLUTE_PATH (filename))
1184 char *dir_name = NULL;
1185 char *subdir_name = NULL;
1189 if (table->files[file - 1].dir)
1190 subdir_name = table->dirs[table->files[file - 1].dir - 1];
1192 if (!subdir_name || !IS_ABSOLUTE_PATH (subdir_name))
1193 dir_name = table->comp_dir;
1197 dir_name = subdir_name;
1202 return strdup (filename);
1204 len = strlen (dir_name) + strlen (filename) + 2;
1208 len += strlen (subdir_name) + 1;
1209 name = (char *) bfd_malloc (len);
1211 sprintf (name, "%s/%s/%s", dir_name, subdir_name, filename);
1215 name = (char *) bfd_malloc (len);
1217 sprintf (name, "%s/%s", dir_name, filename);
1223 return strdup (filename);
1227 arange_add (bfd *abfd, struct arange *first_arange,
1228 bfd_vma low_pc, bfd_vma high_pc)
1230 struct arange *arange;
1232 /* If the first arange is empty, use it. */
1233 if (first_arange->high == 0)
1235 first_arange->low = low_pc;
1236 first_arange->high = high_pc;
1240 /* Next see if we can cheaply extend an existing range. */
1241 arange = first_arange;
1244 if (low_pc == arange->high)
1246 arange->high = high_pc;
1249 if (high_pc == arange->low)
1251 arange->low = low_pc;
1254 arange = arange->next;
1258 /* Need to allocate a new arange and insert it into the arange list.
1259 Order isn't significant, so just insert after the first arange. */
1260 arange = (struct arange *) bfd_zalloc (abfd, sizeof (*arange));
1263 arange->low = low_pc;
1264 arange->high = high_pc;
1265 arange->next = first_arange->next;
1266 first_arange->next = arange;
1270 /* Compare function for line sequences. */
1273 compare_sequences (const void* a, const void* b)
1275 const struct line_sequence* seq1 = a;
1276 const struct line_sequence* seq2 = b;
1278 /* Sort by low_pc as the primary key. */
1279 if (seq1->low_pc < seq2->low_pc)
1281 if (seq1->low_pc > seq2->low_pc)
1284 /* If low_pc values are equal, sort in reverse order of
1285 high_pc, so that the largest region comes first. */
1286 if (seq1->last_line->address < seq2->last_line->address)
1288 if (seq1->last_line->address > seq2->last_line->address)
1291 if (seq1->last_line->op_index < seq2->last_line->op_index)
1293 if (seq1->last_line->op_index > seq2->last_line->op_index)
1299 /* Sort the line sequences for quick lookup. */
1302 sort_line_sequences (struct line_info_table* table)
1305 struct line_sequence* sequences;
1306 struct line_sequence* seq;
1308 unsigned int num_sequences = table->num_sequences;
1309 bfd_vma last_high_pc;
1311 if (num_sequences == 0)
1314 /* Allocate space for an array of sequences. */
1315 amt = sizeof (struct line_sequence) * num_sequences;
1316 sequences = (struct line_sequence *) bfd_alloc (table->abfd, amt);
1317 if (sequences == NULL)
1320 /* Copy the linked list into the array, freeing the original nodes. */
1321 seq = table->sequences;
1322 for (n = 0; n < num_sequences; n++)
1324 struct line_sequence* last_seq = seq;
1327 sequences[n].low_pc = seq->low_pc;
1328 sequences[n].prev_sequence = NULL;
1329 sequences[n].last_line = seq->last_line;
1330 seq = seq->prev_sequence;
1333 BFD_ASSERT (seq == NULL);
1335 qsort (sequences, n, sizeof (struct line_sequence), compare_sequences);
1337 /* Make the list binary-searchable by trimming overlapping entries
1338 and removing nested entries. */
1340 last_high_pc = sequences[0].last_line->address;
1341 for (n = 1; n < table->num_sequences; n++)
1343 if (sequences[n].low_pc < last_high_pc)
1345 if (sequences[n].last_line->address <= last_high_pc)
1346 /* Skip nested entries. */
1349 /* Trim overlapping entries. */
1350 sequences[n].low_pc = last_high_pc;
1352 last_high_pc = sequences[n].last_line->address;
1353 if (n > num_sequences)
1355 /* Close up the gap. */
1356 sequences[num_sequences].low_pc = sequences[n].low_pc;
1357 sequences[num_sequences].last_line = sequences[n].last_line;
1362 table->sequences = sequences;
1363 table->num_sequences = num_sequences;
1367 /* Decode the line number information for UNIT. */
1369 static struct line_info_table*
1370 decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
1372 bfd *abfd = unit->abfd;
1373 struct line_info_table* table;
1376 struct line_head lh;
1377 unsigned int i, bytes_read, offset_size;
1378 char *cur_file, *cur_dir;
1379 unsigned char op_code, extended_op, adj_opcode;
1382 if (! read_section (abfd, ".debug_line", ".zdebug_line",
1383 stash->syms, unit->line_offset,
1384 &stash->dwarf_line_buffer, &stash->dwarf_line_size))
1387 amt = sizeof (struct line_info_table);
1388 table = (struct line_info_table *) bfd_alloc (abfd, amt);
1392 table->comp_dir = unit->comp_dir;
1394 table->num_files = 0;
1395 table->files = NULL;
1397 table->num_dirs = 0;
1400 table->num_sequences = 0;
1401 table->sequences = NULL;
1403 table->lcl_head = NULL;
1405 line_ptr = stash->dwarf_line_buffer + unit->line_offset;
1407 /* Read in the prologue. */
1408 lh.total_length = read_4_bytes (abfd, line_ptr);
1411 if (lh.total_length == 0xffffffff)
1413 lh.total_length = read_8_bytes (abfd, line_ptr);
1417 else if (lh.total_length == 0 && unit->addr_size == 8)
1419 /* Handle (non-standard) 64-bit DWARF2 formats. */
1420 lh.total_length = read_4_bytes (abfd, line_ptr);
1424 line_end = line_ptr + lh.total_length;
1425 lh.version = read_2_bytes (abfd, line_ptr);
1426 if (lh.version < 2 || lh.version > 4)
1428 (*_bfd_error_handler)
1429 (_("Dwarf Error: Unhandled .debug_line version %d."), lh.version);
1430 bfd_set_error (bfd_error_bad_value);
1434 if (offset_size == 4)
1435 lh.prologue_length = read_4_bytes (abfd, line_ptr);
1437 lh.prologue_length = read_8_bytes (abfd, line_ptr);
1438 line_ptr += offset_size;
1439 lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
1441 if (lh.version >= 4)
1443 lh.maximum_ops_per_insn = read_1_byte (abfd, line_ptr);
1447 lh.maximum_ops_per_insn = 1;
1448 if (lh.maximum_ops_per_insn == 0)
1450 (*_bfd_error_handler)
1451 (_("Dwarf Error: Invalid maximum operations per instruction."));
1452 bfd_set_error (bfd_error_bad_value);
1455 lh.default_is_stmt = read_1_byte (abfd, line_ptr);
1457 lh.line_base = read_1_signed_byte (abfd, line_ptr);
1459 lh.line_range = read_1_byte (abfd, line_ptr);
1461 lh.opcode_base = read_1_byte (abfd, line_ptr);
1463 amt = lh.opcode_base * sizeof (unsigned char);
1464 lh.standard_opcode_lengths = (unsigned char *) bfd_alloc (abfd, amt);
1466 lh.standard_opcode_lengths[0] = 1;
1468 for (i = 1; i < lh.opcode_base; ++i)
1470 lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
1474 /* Read directory table. */
1475 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1477 line_ptr += bytes_read;
1479 if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
1483 amt = table->num_dirs + DIR_ALLOC_CHUNK;
1484 amt *= sizeof (char *);
1486 tmp = (char **) bfd_realloc (table->dirs, amt);
1492 table->dirs[table->num_dirs++] = cur_dir;
1495 line_ptr += bytes_read;
1497 /* Read file name table. */
1498 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1500 line_ptr += bytes_read;
1502 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1504 struct fileinfo *tmp;
1506 amt = table->num_files + FILE_ALLOC_CHUNK;
1507 amt *= sizeof (struct fileinfo);
1509 tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
1515 table->files[table->num_files].name = cur_file;
1516 table->files[table->num_files].dir =
1517 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1518 line_ptr += bytes_read;
1519 table->files[table->num_files].time =
1520 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1521 line_ptr += bytes_read;
1522 table->files[table->num_files].size =
1523 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1524 line_ptr += bytes_read;
1528 line_ptr += bytes_read;
1530 /* Read the statement sequences until there's nothing left. */
1531 while (line_ptr < line_end)
1533 /* State machine registers. */
1534 bfd_vma address = 0;
1535 unsigned char op_index = 0;
1536 char * filename = table->num_files ? concat_filename (table, 1) : NULL;
1537 unsigned int line = 1;
1538 unsigned int column = 0;
1539 int is_stmt = lh.default_is_stmt;
1540 int end_sequence = 0;
1541 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1542 compilers generate address sequences that are wildly out of
1543 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1544 for ia64-Linux). Thus, to determine the low and high
1545 address, we must compare on every DW_LNS_copy, etc. */
1546 bfd_vma low_pc = (bfd_vma) -1;
1547 bfd_vma high_pc = 0;
1549 /* Decode the table. */
1550 while (! end_sequence)
1552 op_code = read_1_byte (abfd, line_ptr);
1555 if (op_code >= lh.opcode_base)
1557 /* Special operand. */
1558 adj_opcode = op_code - lh.opcode_base;
1559 if (lh.maximum_ops_per_insn == 1)
1560 address += (adj_opcode / lh.line_range)
1561 * lh.minimum_instruction_length;
1564 address += ((op_index + (adj_opcode / lh.line_range))
1565 / lh.maximum_ops_per_insn)
1566 * lh.minimum_instruction_length;
1567 op_index = (op_index + (adj_opcode / lh.line_range))
1568 % lh.maximum_ops_per_insn;
1570 line += lh.line_base + (adj_opcode % lh.line_range);
1571 /* Append row to matrix using current values. */
1572 if (!add_line_info (table, address, op_index, filename,
1575 if (address < low_pc)
1577 if (address > high_pc)
1580 else switch (op_code)
1582 case DW_LNS_extended_op:
1583 /* Ignore length. */
1585 extended_op = read_1_byte (abfd, line_ptr);
1588 switch (extended_op)
1590 case DW_LNE_end_sequence:
1592 if (!add_line_info (table, address, op_index, filename,
1593 line, column, end_sequence))
1595 if (address < low_pc)
1597 if (address > high_pc)
1599 if (!arange_add (unit->abfd, &unit->arange, low_pc, high_pc))
1602 case DW_LNE_set_address:
1603 address = read_address (unit, line_ptr);
1605 line_ptr += unit->addr_size;
1607 case DW_LNE_define_file:
1608 cur_file = read_string (abfd, line_ptr, &bytes_read);
1609 line_ptr += bytes_read;
1610 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1612 struct fileinfo *tmp;
1614 amt = table->num_files + FILE_ALLOC_CHUNK;
1615 amt *= sizeof (struct fileinfo);
1616 tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
1621 table->files[table->num_files].name = cur_file;
1622 table->files[table->num_files].dir =
1623 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1624 line_ptr += bytes_read;
1625 table->files[table->num_files].time =
1626 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1627 line_ptr += bytes_read;
1628 table->files[table->num_files].size =
1629 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1630 line_ptr += bytes_read;
1633 case DW_LNE_set_discriminator:
1634 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1635 line_ptr += bytes_read;
1638 (*_bfd_error_handler) (_("Dwarf Error: mangled line number section."));
1639 bfd_set_error (bfd_error_bad_value);
1641 if (filename != NULL)
1647 if (!add_line_info (table, address, op_index,
1648 filename, line, column, 0))
1650 if (address < low_pc)
1652 if (address > high_pc)
1655 case DW_LNS_advance_pc:
1656 if (lh.maximum_ops_per_insn == 1)
1657 address += lh.minimum_instruction_length
1658 * read_unsigned_leb128 (abfd, line_ptr,
1662 bfd_vma adjust = read_unsigned_leb128 (abfd, line_ptr,
1664 address = ((op_index + adjust) / lh.maximum_ops_per_insn)
1665 * lh.minimum_instruction_length;
1666 op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
1668 line_ptr += bytes_read;
1670 case DW_LNS_advance_line:
1671 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
1672 line_ptr += bytes_read;
1674 case DW_LNS_set_file:
1678 /* The file and directory tables are 0
1679 based, the references are 1 based. */
1680 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1681 line_ptr += bytes_read;
1684 filename = concat_filename (table, file);
1687 case DW_LNS_set_column:
1688 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1689 line_ptr += bytes_read;
1691 case DW_LNS_negate_stmt:
1692 is_stmt = (!is_stmt);
1694 case DW_LNS_set_basic_block:
1696 case DW_LNS_const_add_pc:
1697 if (lh.maximum_ops_per_insn == 1)
1698 address += lh.minimum_instruction_length
1699 * ((255 - lh.opcode_base) / lh.line_range);
1702 bfd_vma adjust = ((255 - lh.opcode_base) / lh.line_range);
1703 address += lh.minimum_instruction_length
1704 * ((op_index + adjust) / lh.maximum_ops_per_insn);
1705 op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
1708 case DW_LNS_fixed_advance_pc:
1709 address += read_2_bytes (abfd, line_ptr);
1714 /* Unknown standard opcode, ignore it. */
1715 for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
1717 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1718 line_ptr += bytes_read;
1728 if (sort_line_sequences (table))
1732 if (table->sequences != NULL)
1733 free (table->sequences);
1734 if (table->files != NULL)
1735 free (table->files);
1736 if (table->dirs != NULL)
1741 /* If ADDR is within TABLE set the output parameters and return TRUE,
1742 otherwise return FALSE. The output parameters, FILENAME_PTR and
1743 LINENUMBER_PTR, are pointers to the objects to be filled in. */
1746 lookup_address_in_line_info_table (struct line_info_table *table,
1748 const char **filename_ptr,
1749 unsigned int *linenumber_ptr)
1751 struct line_sequence *seq = NULL;
1752 struct line_info *each_line;
1755 /* Binary search the array of sequences. */
1757 high = table->num_sequences;
1760 mid = (low + high) / 2;
1761 seq = &table->sequences[mid];
1762 if (addr < seq->low_pc)
1764 else if (addr >= seq->last_line->address)
1770 if (seq && addr >= seq->low_pc && addr < seq->last_line->address)
1772 /* Note: seq->last_line should be a descendingly sorted list. */
1773 for (each_line = seq->last_line;
1775 each_line = each_line->prev_line)
1776 if (addr >= each_line->address)
1780 && !(each_line->end_sequence || each_line == seq->last_line))
1782 *filename_ptr = each_line->filename;
1783 *linenumber_ptr = each_line->line;
1788 *filename_ptr = NULL;
1792 /* Read in the .debug_ranges section for future reference. */
1795 read_debug_ranges (struct comp_unit *unit)
1797 struct dwarf2_debug *stash = unit->stash;
1798 return read_section (unit->abfd, ".debug_ranges", ".zdebug_ranges",
1800 &stash->dwarf_ranges_buffer, &stash->dwarf_ranges_size);
1803 /* Function table functions. */
1805 /* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return TRUE.
1806 Note that we need to find the function that has the smallest
1807 range that contains ADDR, to handle inlined functions without
1808 depending upon them being ordered in TABLE by increasing range. */
1811 lookup_address_in_function_table (struct comp_unit *unit,
1813 struct funcinfo **function_ptr,
1814 const char **functionname_ptr)
1816 struct funcinfo* each_func;
1817 struct funcinfo* best_fit = NULL;
1818 struct arange *arange;
1820 for (each_func = unit->function_table;
1822 each_func = each_func->prev_func)
1824 for (arange = &each_func->arange;
1826 arange = arange->next)
1828 if (addr >= arange->low && addr < arange->high)
1831 ((arange->high - arange->low) < (best_fit->arange.high - best_fit->arange.low)))
1832 best_fit = each_func;
1839 *functionname_ptr = best_fit->name;
1840 *function_ptr = best_fit;
1849 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
1850 and LINENUMBER_PTR, and return TRUE. */
1853 lookup_symbol_in_function_table (struct comp_unit *unit,
1856 const char **filename_ptr,
1857 unsigned int *linenumber_ptr)
1859 struct funcinfo* each_func;
1860 struct funcinfo* best_fit = NULL;
1861 struct arange *arange;
1862 const char *name = bfd_asymbol_name (sym);
1863 asection *sec = bfd_get_section (sym);
1865 for (each_func = unit->function_table;
1867 each_func = each_func->prev_func)
1869 for (arange = &each_func->arange;
1871 arange = arange->next)
1873 if ((!each_func->sec || each_func->sec == sec)
1874 && addr >= arange->low
1875 && addr < arange->high
1877 && strcmp (name, each_func->name) == 0
1879 || ((arange->high - arange->low)
1880 < (best_fit->arange.high - best_fit->arange.low))))
1881 best_fit = each_func;
1887 best_fit->sec = sec;
1888 *filename_ptr = best_fit->file;
1889 *linenumber_ptr = best_fit->line;
1896 /* Variable table functions. */
1898 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
1899 LINENUMBER_PTR, and return TRUE. */
1902 lookup_symbol_in_variable_table (struct comp_unit *unit,
1905 const char **filename_ptr,
1906 unsigned int *linenumber_ptr)
1908 const char *name = bfd_asymbol_name (sym);
1909 asection *sec = bfd_get_section (sym);
1910 struct varinfo* each;
1912 for (each = unit->variable_table; each; each = each->prev_var)
1913 if (each->stack == 0
1914 && each->file != NULL
1915 && each->name != NULL
1916 && each->addr == addr
1917 && (!each->sec || each->sec == sec)
1918 && strcmp (name, each->name) == 0)
1924 *filename_ptr = each->file;
1925 *linenumber_ptr = each->line;
1933 find_abstract_instance_name (struct comp_unit *unit,
1934 struct attribute *attr_ptr)
1936 bfd *abfd = unit->abfd;
1938 unsigned int abbrev_number, bytes_read, i;
1939 struct abbrev_info *abbrev;
1940 bfd_uint64_t die_ref = attr_ptr->u.val;
1941 struct attribute attr;
1944 /* DW_FORM_ref_addr can reference an entry in a different CU. It
1945 is an offset from the .debug_info section, not the current CU. */
1946 if (attr_ptr->form == DW_FORM_ref_addr)
1948 /* We only support DW_FORM_ref_addr within the same file, so
1949 any relocations should be resolved already. */
1953 info_ptr = unit->sec_info_ptr + die_ref;
1956 info_ptr = unit->info_ptr_unit + die_ref;
1957 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1958 info_ptr += bytes_read;
1962 abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
1965 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1967 bfd_set_error (bfd_error_bad_value);
1971 for (i = 0; i < abbrev->num_attrs; ++i)
1973 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit,
1975 if (info_ptr == NULL)
1980 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
1985 case DW_AT_specification:
1986 name = find_abstract_instance_name (unit, &attr);
1988 case DW_AT_linkage_name:
1989 case DW_AT_MIPS_linkage_name:
2002 read_rangelist (struct comp_unit *unit, struct arange *arange,
2003 bfd_uint64_t offset)
2005 bfd_byte *ranges_ptr;
2006 bfd_vma base_address = unit->base_address;
2008 if (! unit->stash->dwarf_ranges_buffer)
2010 if (! read_debug_ranges (unit))
2013 ranges_ptr = unit->stash->dwarf_ranges_buffer + offset;
2020 low_pc = read_address (unit, ranges_ptr);
2021 ranges_ptr += unit->addr_size;
2022 high_pc = read_address (unit, ranges_ptr);
2023 ranges_ptr += unit->addr_size;
2025 if (low_pc == 0 && high_pc == 0)
2027 if (low_pc == -1UL && high_pc != -1UL)
2028 base_address = high_pc;
2031 if (!arange_add (unit->abfd, arange,
2032 base_address + low_pc, base_address + high_pc))
2039 /* DWARF2 Compilation unit functions. */
2041 /* Scan over each die in a comp. unit looking for functions to add
2042 to the function table and variables to the variable table. */
2045 scan_unit_for_symbols (struct comp_unit *unit)
2047 bfd *abfd = unit->abfd;
2048 bfd_byte *info_ptr = unit->first_child_die_ptr;
2049 int nesting_level = 1;
2050 struct funcinfo **nested_funcs;
2051 int nested_funcs_size;
2053 /* Maintain a stack of in-scope functions and inlined functions, which we
2054 can use to set the caller_func field. */
2055 nested_funcs_size = 32;
2056 nested_funcs = (struct funcinfo **)
2057 bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *));
2058 if (nested_funcs == NULL)
2060 nested_funcs[nesting_level] = 0;
2062 while (nesting_level)
2064 unsigned int abbrev_number, bytes_read, i;
2065 struct abbrev_info *abbrev;
2066 struct attribute attr;
2067 struct funcinfo *func;
2068 struct varinfo *var;
2070 bfd_vma high_pc = 0;
2072 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2073 info_ptr += bytes_read;
2075 if (! abbrev_number)
2081 abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
2084 (*_bfd_error_handler)
2085 (_("Dwarf Error: Could not find abbrev number %u."),
2087 bfd_set_error (bfd_error_bad_value);
2092 if (abbrev->tag == DW_TAG_subprogram
2093 || abbrev->tag == DW_TAG_entry_point
2094 || abbrev->tag == DW_TAG_inlined_subroutine)
2096 bfd_size_type amt = sizeof (struct funcinfo);
2097 func = (struct funcinfo *) bfd_zalloc (abfd, amt);
2100 func->tag = abbrev->tag;
2101 func->prev_func = unit->function_table;
2102 unit->function_table = func;
2103 BFD_ASSERT (!unit->cached);
2105 if (func->tag == DW_TAG_inlined_subroutine)
2106 for (i = nesting_level - 1; i >= 1; i--)
2107 if (nested_funcs[i])
2109 func->caller_func = nested_funcs[i];
2112 nested_funcs[nesting_level] = func;
2117 if (abbrev->tag == DW_TAG_variable)
2119 bfd_size_type amt = sizeof (struct varinfo);
2120 var = (struct varinfo *) bfd_zalloc (abfd, amt);
2123 var->tag = abbrev->tag;
2125 var->prev_var = unit->variable_table;
2126 unit->variable_table = var;
2127 BFD_ASSERT (!unit->cached);
2130 /* No inline function in scope at this nesting level. */
2131 nested_funcs[nesting_level] = 0;
2134 for (i = 0; i < abbrev->num_attrs; ++i)
2136 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
2137 if (info_ptr == NULL)
2144 case DW_AT_call_file:
2145 func->caller_file = concat_filename (unit->line_table,
2149 case DW_AT_call_line:
2150 func->caller_line = attr.u.val;
2153 case DW_AT_abstract_origin:
2154 func->name = find_abstract_instance_name (unit, &attr);
2158 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2160 if (func->name == NULL)
2161 func->name = attr.u.str;
2164 case DW_AT_linkage_name:
2165 case DW_AT_MIPS_linkage_name:
2166 func->name = attr.u.str;
2170 low_pc = attr.u.val;
2174 high_pc = attr.u.val;
2178 if (!read_rangelist (unit, &func->arange, attr.u.val))
2182 case DW_AT_decl_file:
2183 func->file = concat_filename (unit->line_table,
2187 case DW_AT_decl_line:
2188 func->line = attr.u.val;
2200 var->name = attr.u.str;
2203 case DW_AT_decl_file:
2204 var->file = concat_filename (unit->line_table,
2208 case DW_AT_decl_line:
2209 var->line = attr.u.val;
2212 case DW_AT_external:
2213 if (attr.u.val != 0)
2217 case DW_AT_location:
2221 case DW_FORM_block1:
2222 case DW_FORM_block2:
2223 case DW_FORM_block4:
2224 case DW_FORM_exprloc:
2225 if (*attr.u.blk->data == DW_OP_addr)
2229 /* Verify that DW_OP_addr is the only opcode in the
2230 location, in which case the block size will be 1
2231 plus the address size. */
2232 /* ??? For TLS variables, gcc can emit
2233 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
2234 which we don't handle here yet. */
2235 if (attr.u.blk->size == unit->addr_size + 1U)
2236 var->addr = bfd_get (unit->addr_size * 8,
2238 attr.u.blk->data + 1);
2253 if (func && high_pc != 0)
2255 if (!arange_add (unit->abfd, &func->arange, low_pc, high_pc))
2259 if (abbrev->has_children)
2263 if (nesting_level >= nested_funcs_size)
2265 struct funcinfo **tmp;
2267 nested_funcs_size *= 2;
2268 tmp = (struct funcinfo **)
2269 bfd_realloc (nested_funcs,
2270 (nested_funcs_size * sizeof (struct funcinfo *)));
2275 nested_funcs[nesting_level] = 0;
2279 free (nested_funcs);
2283 free (nested_funcs);
2287 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
2288 includes the compilation unit header that proceeds the DIE's, but
2289 does not include the length field that precedes each compilation
2290 unit header. END_PTR points one past the end of this comp unit.
2291 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
2293 This routine does not read the whole compilation unit; only enough
2294 to get to the line number information for the compilation unit. */
2296 static struct comp_unit *
2297 parse_comp_unit (struct dwarf2_debug *stash,
2298 bfd_vma unit_length,
2299 bfd_byte *info_ptr_unit,
2300 unsigned int offset_size)
2302 struct comp_unit* unit;
2303 unsigned int version;
2304 bfd_uint64_t abbrev_offset = 0;
2305 unsigned int addr_size;
2306 struct abbrev_info** abbrevs;
2307 unsigned int abbrev_number, bytes_read, i;
2308 struct abbrev_info *abbrev;
2309 struct attribute attr;
2310 bfd_byte *info_ptr = stash->info_ptr;
2311 bfd_byte *end_ptr = info_ptr + unit_length;
2314 bfd_vma high_pc = 0;
2315 bfd *abfd = stash->bfd_ptr;
2317 version = read_2_bytes (abfd, info_ptr);
2319 BFD_ASSERT (offset_size == 4 || offset_size == 8);
2320 if (offset_size == 4)
2321 abbrev_offset = read_4_bytes (abfd, info_ptr);
2323 abbrev_offset = read_8_bytes (abfd, info_ptr);
2324 info_ptr += offset_size;
2325 addr_size = read_1_byte (abfd, info_ptr);
2328 if (version != 2 && version != 3 && version != 4)
2330 (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2, 3 and 4 information."), version);
2331 bfd_set_error (bfd_error_bad_value);
2335 if (addr_size > sizeof (bfd_vma))
2337 (*_bfd_error_handler) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
2339 (unsigned int) sizeof (bfd_vma));
2340 bfd_set_error (bfd_error_bad_value);
2344 if (addr_size != 2 && addr_size != 4 && addr_size != 8)
2346 (*_bfd_error_handler) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size);
2347 bfd_set_error (bfd_error_bad_value);
2351 /* Read the abbrevs for this compilation unit into a table. */
2352 abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
2356 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2357 info_ptr += bytes_read;
2358 if (! abbrev_number)
2360 (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u."),
2362 bfd_set_error (bfd_error_bad_value);
2366 abbrev = lookup_abbrev (abbrev_number, abbrevs);
2369 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
2371 bfd_set_error (bfd_error_bad_value);
2375 amt = sizeof (struct comp_unit);
2376 unit = (struct comp_unit *) bfd_zalloc (abfd, amt);
2380 unit->version = version;
2381 unit->addr_size = addr_size;
2382 unit->offset_size = offset_size;
2383 unit->abbrevs = abbrevs;
2384 unit->end_ptr = end_ptr;
2385 unit->stash = stash;
2386 unit->info_ptr_unit = info_ptr_unit;
2387 unit->sec_info_ptr = stash->sec_info_ptr;
2389 for (i = 0; i < abbrev->num_attrs; ++i)
2391 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
2392 if (info_ptr == NULL)
2395 /* Store the data if it is of an attribute we want to keep in a
2396 partial symbol table. */
2399 case DW_AT_stmt_list:
2401 unit->line_offset = attr.u.val;
2405 unit->name = attr.u.str;
2409 low_pc = attr.u.val;
2410 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
2411 this is the base address to use when reading location
2412 lists or range lists. */
2413 unit->base_address = low_pc;
2417 high_pc = attr.u.val;
2421 if (!read_rangelist (unit, &unit->arange, attr.u.val))
2425 case DW_AT_comp_dir:
2427 char *comp_dir = attr.u.str;
2430 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2431 directory, get rid of it. */
2432 char *cp = strchr (comp_dir, ':');
2434 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
2437 unit->comp_dir = comp_dir;
2447 if (!arange_add (unit->abfd, &unit->arange, low_pc, high_pc))
2451 unit->first_child_die_ptr = info_ptr;
2455 /* Return TRUE if UNIT may contain the address given by ADDR. When
2456 there are functions written entirely with inline asm statements, the
2457 range info in the compilation unit header may not be correct. We
2458 need to consult the line info table to see if a compilation unit
2459 really contains the given address. */
2462 comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
2464 struct arange *arange;
2469 arange = &unit->arange;
2472 if (addr >= arange->low && addr < arange->high)
2474 arange = arange->next;
2481 /* If UNIT contains ADDR, set the output parameters to the values for
2482 the line containing ADDR. The output parameters, FILENAME_PTR,
2483 FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
2486 Return TRUE if UNIT contains ADDR, and no errors were encountered;
2490 comp_unit_find_nearest_line (struct comp_unit *unit,
2492 const char **filename_ptr,
2493 const char **functionname_ptr,
2494 unsigned int *linenumber_ptr,
2495 struct dwarf2_debug *stash)
2499 struct funcinfo *function;
2504 if (! unit->line_table)
2506 if (! unit->stmtlist)
2512 unit->line_table = decode_line_info (unit, stash);
2514 if (! unit->line_table)
2520 if (unit->first_child_die_ptr < unit->end_ptr
2521 && ! scan_unit_for_symbols (unit))
2529 func_p = lookup_address_in_function_table (unit, addr,
2530 &function, functionname_ptr);
2531 if (func_p && (function->tag == DW_TAG_inlined_subroutine))
2532 stash->inliner_chain = function;
2533 line_p = lookup_address_in_line_info_table (unit->line_table, addr,
2536 return line_p || func_p;
2539 /* Check to see if line info is already decoded in a comp_unit.
2540 If not, decode it. Returns TRUE if no errors were encountered;
2544 comp_unit_maybe_decode_line_info (struct comp_unit *unit,
2545 struct dwarf2_debug *stash)
2550 if (! unit->line_table)
2552 if (! unit->stmtlist)
2558 unit->line_table = decode_line_info (unit, stash);
2560 if (! unit->line_table)
2566 if (unit->first_child_die_ptr < unit->end_ptr
2567 && ! scan_unit_for_symbols (unit))
2577 /* If UNIT contains SYM at ADDR, set the output parameters to the
2578 values for the line containing SYM. The output parameters,
2579 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
2582 Return TRUE if UNIT contains SYM, and no errors were encountered;
2586 comp_unit_find_line (struct comp_unit *unit,
2589 const char **filename_ptr,
2590 unsigned int *linenumber_ptr,
2591 struct dwarf2_debug *stash)
2593 if (!comp_unit_maybe_decode_line_info (unit, stash))
2596 if (sym->flags & BSF_FUNCTION)
2597 return lookup_symbol_in_function_table (unit, sym, addr,
2601 return lookup_symbol_in_variable_table (unit, sym, addr,
2606 static struct funcinfo *
2607 reverse_funcinfo_list (struct funcinfo *head)
2609 struct funcinfo *rhead;
2610 struct funcinfo *temp;
2612 for (rhead = NULL; head; head = temp)
2614 temp = head->prev_func;
2615 head->prev_func = rhead;
2621 static struct varinfo *
2622 reverse_varinfo_list (struct varinfo *head)
2624 struct varinfo *rhead;
2625 struct varinfo *temp;
2627 for (rhead = NULL; head; head = temp)
2629 temp = head->prev_var;
2630 head->prev_var = rhead;
2636 /* Extract all interesting funcinfos and varinfos of a compilation
2637 unit into hash tables for faster lookup. Returns TRUE if no
2638 errors were enountered; FALSE otherwise. */
2641 comp_unit_hash_info (struct dwarf2_debug *stash,
2642 struct comp_unit *unit,
2643 struct info_hash_table *funcinfo_hash_table,
2644 struct info_hash_table *varinfo_hash_table)
2646 struct funcinfo* each_func;
2647 struct varinfo* each_var;
2648 bfd_boolean okay = TRUE;
2650 BFD_ASSERT (stash->info_hash_status != STASH_INFO_HASH_DISABLED);
2652 if (!comp_unit_maybe_decode_line_info (unit, stash))
2655 BFD_ASSERT (!unit->cached);
2657 /* To preserve the original search order, we went to visit the function
2658 infos in the reversed order of the list. However, making the list
2659 bi-directional use quite a bit of extra memory. So we reverse
2660 the list first, traverse the list in the now reversed order and
2661 finally reverse the list again to get back the original order. */
2662 unit->function_table = reverse_funcinfo_list (unit->function_table);
2663 for (each_func = unit->function_table;
2665 each_func = each_func->prev_func)
2667 /* Skip nameless functions. */
2668 if (each_func->name)
2669 /* There is no need to copy name string into hash table as
2670 name string is either in the dwarf string buffer or
2671 info in the stash. */
2672 okay = insert_info_hash_table (funcinfo_hash_table, each_func->name,
2673 (void*) each_func, FALSE);
2675 unit->function_table = reverse_funcinfo_list (unit->function_table);
2679 /* We do the same for variable infos. */
2680 unit->variable_table = reverse_varinfo_list (unit->variable_table);
2681 for (each_var = unit->variable_table;
2683 each_var = each_var->prev_var)
2685 /* Skip stack vars and vars with no files or names. */
2686 if (each_var->stack == 0
2687 && each_var->file != NULL
2688 && each_var->name != NULL)
2689 /* There is no need to copy name string into hash table as
2690 name string is either in the dwarf string buffer or
2691 info in the stash. */
2692 okay = insert_info_hash_table (varinfo_hash_table, each_var->name,
2693 (void*) each_var, FALSE);
2696 unit->variable_table = reverse_varinfo_list (unit->variable_table);
2697 unit->cached = TRUE;
2701 /* Locate a section in a BFD containing debugging info. The search starts
2702 from the section after AFTER_SEC, or from the first section in the BFD if
2703 AFTER_SEC is NULL. The search works by examining the names of the
2704 sections. There are two permissiable names. The first is .debug_info.
2705 This is the standard DWARF2 name. The second is a prefix .gnu.linkonce.wi.
2706 This is a variation on the .debug_info section which has a checksum
2707 describing the contents appended onto the name. This allows the linker to
2708 identify and discard duplicate debugging sections for different
2709 compilation units. */
2710 #define DWARF2_DEBUG_INFO ".debug_info"
2711 #define DWARF2_COMPRESSED_DEBUG_INFO ".zdebug_info"
2712 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
2715 find_debug_info (bfd *abfd, asection *after_sec)
2719 msec = after_sec != NULL ? after_sec->next : abfd->sections;
2723 if (strcmp (msec->name, DWARF2_DEBUG_INFO) == 0)
2726 if (strcmp (msec->name, DWARF2_COMPRESSED_DEBUG_INFO) == 0)
2729 if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
2738 /* Unset vmas for adjusted sections in STASH. */
2741 unset_sections (struct dwarf2_debug *stash)
2744 struct adjusted_section *p;
2746 i = stash->adjusted_section_count;
2747 p = stash->adjusted_sections;
2748 for (; i > 0; i--, p++)
2749 p->section->vma = 0;
2752 /* Set unique VMAs for loadable and DWARF sections in ABFD and save
2753 VMAs in STASH for unset_sections. */
2756 place_sections (bfd *abfd, struct dwarf2_debug *stash)
2758 struct adjusted_section *p;
2761 if (stash->adjusted_section_count != 0)
2763 i = stash->adjusted_section_count;
2764 p = stash->adjusted_sections;
2765 for (; i > 0; i--, p++)
2766 p->section->vma = p->adj_vma;
2771 bfd_vma last_vma = 0, last_dwarf = 0;
2775 for (sect = abfd->sections; sect != NULL; sect = sect->next)
2783 /* We need to adjust the VMAs of any .debug_info sections.
2784 Skip compressed ones, since no relocations could target
2785 them - they should not appear in object files anyway. */
2786 if (strcmp (sect->name, DWARF2_DEBUG_INFO) == 0)
2788 else if (CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO))
2793 if (!is_debug_info && (sect->flags & SEC_LOAD) == 0)
2796 sz = sect->rawsize ? sect->rawsize : sect->size;
2803 amt = i * sizeof (struct adjusted_section);
2804 p = (struct adjusted_section *) bfd_zalloc (abfd, amt);
2808 stash->adjusted_sections = p;
2809 stash->adjusted_section_count = i;
2811 for (sect = abfd->sections; sect != NULL; sect = sect->next)
2819 /* We need to adjust the VMAs of any .debug_info sections.
2820 Skip compressed ones, since no relocations could target
2821 them - they should not appear in object files anyway. */
2822 if (strcmp (sect->name, DWARF2_DEBUG_INFO) == 0)
2824 else if (CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO))
2829 if (!is_debug_info && (sect->flags & SEC_LOAD) == 0)
2832 sz = sect->rawsize ? sect->rawsize : sect->size;
2839 BFD_ASSERT (sect->alignment_power == 0);
2840 sect->vma = last_dwarf;
2843 else if (last_vma != 0)
2845 /* Align the new address to the current section
2847 last_vma = ((last_vma
2848 + ~((bfd_vma) -1 << sect->alignment_power))
2849 & ((bfd_vma) -1 << sect->alignment_power));
2850 sect->vma = last_vma;
2851 last_vma += sect->vma + sz;
2854 last_vma += sect->vma + sz;
2856 p->adj_vma = sect->vma;
2865 /* Look up a funcinfo by name using the given info hash table. If found,
2866 also update the locations pointed to by filename_ptr and linenumber_ptr.
2868 This function returns TRUE if a funcinfo that matches the given symbol
2869 and address is found with any error; otherwise it returns FALSE. */
2872 info_hash_lookup_funcinfo (struct info_hash_table *hash_table,
2875 const char **filename_ptr,
2876 unsigned int *linenumber_ptr)
2878 struct funcinfo* each_func;
2879 struct funcinfo* best_fit = NULL;
2880 struct info_list_node *node;
2881 struct arange *arange;
2882 const char *name = bfd_asymbol_name (sym);
2883 asection *sec = bfd_get_section (sym);
2885 for (node = lookup_info_hash_table (hash_table, name);
2889 each_func = (struct funcinfo *) node->info;
2890 for (arange = &each_func->arange;
2892 arange = arange->next)
2894 if ((!each_func->sec || each_func->sec == sec)
2895 && addr >= arange->low
2896 && addr < arange->high
2898 || ((arange->high - arange->low)
2899 < (best_fit->arange.high - best_fit->arange.low))))
2900 best_fit = each_func;
2906 best_fit->sec = sec;
2907 *filename_ptr = best_fit->file;
2908 *linenumber_ptr = best_fit->line;
2915 /* Look up a varinfo by name using the given info hash table. If found,
2916 also update the locations pointed to by filename_ptr and linenumber_ptr.
2918 This function returns TRUE if a varinfo that matches the given symbol
2919 and address is found with any error; otherwise it returns FALSE. */
2922 info_hash_lookup_varinfo (struct info_hash_table *hash_table,
2925 const char **filename_ptr,
2926 unsigned int *linenumber_ptr)
2928 const char *name = bfd_asymbol_name (sym);
2929 asection *sec = bfd_get_section (sym);
2930 struct varinfo* each;
2931 struct info_list_node *node;
2933 for (node = lookup_info_hash_table (hash_table, name);
2937 each = (struct varinfo *) node->info;
2938 if (each->addr == addr
2939 && (!each->sec || each->sec == sec))
2942 *filename_ptr = each->file;
2943 *linenumber_ptr = each->line;
2951 /* Update the funcinfo and varinfo info hash tables if they are
2952 not up to date. Returns TRUE if there is no error; otherwise
2953 returns FALSE and disable the info hash tables. */
2956 stash_maybe_update_info_hash_tables (struct dwarf2_debug *stash)
2958 struct comp_unit *each;
2960 /* Exit if hash tables are up-to-date. */
2961 if (stash->all_comp_units == stash->hash_units_head)
2964 if (stash->hash_units_head)
2965 each = stash->hash_units_head->prev_unit;
2967 each = stash->last_comp_unit;
2971 if (!comp_unit_hash_info (stash, each, stash->funcinfo_hash_table,
2972 stash->varinfo_hash_table))
2974 stash->info_hash_status = STASH_INFO_HASH_DISABLED;
2977 each = each->prev_unit;
2980 stash->hash_units_head = stash->all_comp_units;
2984 /* Check consistency of info hash tables. This is for debugging only. */
2986 static void ATTRIBUTE_UNUSED
2987 stash_verify_info_hash_table (struct dwarf2_debug *stash)
2989 struct comp_unit *each_unit;
2990 struct funcinfo *each_func;
2991 struct varinfo *each_var;
2992 struct info_list_node *node;
2995 for (each_unit = stash->all_comp_units;
2997 each_unit = each_unit->next_unit)
2999 for (each_func = each_unit->function_table;
3001 each_func = each_func->prev_func)
3003 if (!each_func->name)
3005 node = lookup_info_hash_table (stash->funcinfo_hash_table,
3009 while (node && !found)
3011 found = node->info == each_func;
3017 for (each_var = each_unit->variable_table;
3019 each_var = each_var->prev_var)
3021 if (!each_var->name || !each_var->file || each_var->stack)
3023 node = lookup_info_hash_table (stash->varinfo_hash_table,
3027 while (node && !found)
3029 found = node->info == each_var;
3037 /* Check to see if we want to enable the info hash tables, which consume
3038 quite a bit of memory. Currently we only check the number times
3039 bfd_dwarf2_find_line is called. In the future, we may also want to
3040 take the number of symbols into account. */
3043 stash_maybe_enable_info_hash_tables (bfd *abfd, struct dwarf2_debug *stash)
3045 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_OFF);
3047 if (stash->info_hash_count++ < STASH_INFO_HASH_TRIGGER)
3050 /* FIXME: Maybe we should check the reduce_memory_overheads
3051 and optimize fields in the bfd_link_info structure ? */
3053 /* Create hash tables. */
3054 stash->funcinfo_hash_table = create_info_hash_table (abfd);
3055 stash->varinfo_hash_table = create_info_hash_table (abfd);
3056 if (!stash->funcinfo_hash_table || !stash->varinfo_hash_table)
3058 /* Turn off info hashes if any allocation above fails. */
3059 stash->info_hash_status = STASH_INFO_HASH_DISABLED;
3062 /* We need a forced update so that the info hash tables will
3063 be created even though there is no compilation unit. That
3064 happens if STASH_INFO_HASH_TRIGGER is 0. */
3065 stash_maybe_update_info_hash_tables (stash);
3066 stash->info_hash_status = STASH_INFO_HASH_ON;
3069 /* Find the file and line associated with a symbol and address using the
3070 info hash tables of a stash. If there is a match, the function returns
3071 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
3072 otherwise it returns FALSE. */
3075 stash_find_line_fast (struct dwarf2_debug *stash,
3078 const char **filename_ptr,
3079 unsigned int *linenumber_ptr)
3081 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_ON);
3083 if (sym->flags & BSF_FUNCTION)
3084 return info_hash_lookup_funcinfo (stash->funcinfo_hash_table, sym, addr,
3085 filename_ptr, linenumber_ptr);
3086 return info_hash_lookup_varinfo (stash->varinfo_hash_table, sym, addr,
3087 filename_ptr, linenumber_ptr);
3090 /* Find the source code location of SYMBOL. If SYMBOL is NULL
3091 then find the nearest source code location corresponding to
3092 the address SECTION + OFFSET.
3093 Returns TRUE if the line is found without error and fills in
3094 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
3095 NULL the FUNCTIONNAME_PTR is also filled in.
3096 SYMBOLS contains the symbol table for ABFD.
3097 ADDR_SIZE is the number of bytes in the initial .debug_info length
3098 field and in the abbreviation offset, or zero to indicate that the
3099 default value should be used. */
3102 find_line (bfd *abfd,
3107 const char **filename_ptr,
3108 const char **functionname_ptr,
3109 unsigned int *linenumber_ptr,
3110 unsigned int addr_size,
3113 /* Read each compilation unit from the section .debug_info, and check
3114 to see if it contains the address we are searching for. If yes,
3115 lookup the address, and return the line number info. If no, go
3116 on to the next compilation unit.
3118 We keep a list of all the previously read compilation units, and
3119 a pointer to the next un-read compilation unit. Check the
3120 previously read units before reading more. */
3121 struct dwarf2_debug *stash;
3122 /* What address are we looking for? */
3124 struct comp_unit* each;
3125 bfd_vma found = FALSE;
3126 bfd_boolean do_line;
3128 stash = (struct dwarf2_debug *) *pinfo;
3132 bfd_size_type amt = sizeof (struct dwarf2_debug);
3134 stash = (struct dwarf2_debug *) bfd_zalloc (abfd, amt);
3139 /* In a relocatable file, 2 functions may have the same address.
3140 We change the section vma so that they won't overlap. */
3141 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
3143 if (! place_sections (abfd, stash))
3147 do_line = (section == NULL
3149 && functionname_ptr == NULL
3153 addr = symbol->value;
3154 section = bfd_get_section (symbol);
3156 else if (section != NULL
3157 && functionname_ptr != NULL
3163 if (section->output_section)
3164 addr += section->output_section->vma + section->output_offset;
3166 addr += section->vma;
3167 *filename_ptr = NULL;
3169 *functionname_ptr = NULL;
3170 *linenumber_ptr = 0;
3175 bfd_size_type total_size;
3180 msec = find_debug_info (abfd, NULL);
3183 char * debug_filename = bfd_follow_gnu_debuglink (abfd, DEBUGDIR);
3185 if (debug_filename == NULL)
3186 /* No dwarf2 info, and no gnu_debuglink to follow.
3187 Note that at this point the stash has been allocated, but
3188 contains zeros. This lets future calls to this function
3189 fail more quickly. */
3192 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
3193 || ! bfd_check_format (debug_bfd, bfd_object)
3194 || (msec = find_debug_info (debug_bfd, NULL)) == NULL)
3197 bfd_close (debug_bfd);
3198 /* FIXME: Should we report our failure to follow the debuglink ? */
3199 free (debug_filename);
3206 /* There can be more than one DWARF2 info section in a BFD these
3207 days. First handle the easy case when there's only one. If
3208 there's more than one, try case two: none of the sections is
3209 compressed. In that case, read them all in and produce one
3210 large stash. We do this in two passes - in the first pass we
3211 just accumulate the section sizes, and in the second pass we
3212 read in the section's contents. (The allows us to avoid
3213 reallocing the data as we add sections to the stash.) If
3214 some or all sections are compressed, then do things the slow
3215 way, with a bunch of reallocs. */
3217 if (! find_debug_info (debug_bfd, msec))
3219 /* Case 1: only one info section. */
3220 total_size = msec->size;
3221 if (! read_section (debug_bfd, ".debug_info", ".zdebug_info",
3223 &stash->info_ptr_memory, &total_size))
3228 int all_uncompressed = 1;
3229 for (total_size = 0; msec; msec = find_debug_info (debug_bfd, msec))
3231 total_size += msec->size;
3232 if (strcmp (msec->name, DWARF2_COMPRESSED_DEBUG_INFO) == 0)
3233 all_uncompressed = 0;
3235 if (all_uncompressed)
3237 /* Case 2: multiple sections, but none is compressed. */
3238 stash->info_ptr_memory = (bfd_byte *) bfd_malloc (total_size);
3239 if (stash->info_ptr_memory == NULL)
3243 for (msec = find_debug_info (debug_bfd, NULL);
3245 msec = find_debug_info (debug_bfd, msec))
3253 if (!(bfd_simple_get_relocated_section_contents
3254 (debug_bfd, msec, stash->info_ptr_memory + total_size,
3263 /* Case 3: multiple sections, some or all compressed. */
3264 stash->info_ptr_memory = NULL;
3266 for (msec = find_debug_info (debug_bfd, NULL);
3268 msec = find_debug_info (debug_bfd, msec))
3270 bfd_size_type size = msec->size;
3271 bfd_byte *buffer, *tmp;
3272 bfd_boolean is_compressed =
3273 strcmp (msec->name, DWARF2_COMPRESSED_DEBUG_INFO) == 0;
3278 if (! read_and_uncompress_section (debug_bfd, msec,
3279 is_compressed, symbols,
3283 tmp = (bfd_byte *) bfd_realloc (stash->info_ptr_memory,
3290 stash->info_ptr_memory = tmp;
3291 memcpy (stash->info_ptr_memory + total_size, buffer, size);
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, NULL);
3301 stash->sec_info_ptr = stash->info_ptr;
3302 stash->syms = symbols;
3303 stash->bfd_ptr = debug_bfd;
3306 /* A null info_ptr indicates that there is no dwarf2 info
3307 (or that an error occured while setting up the stash). */
3308 if (! stash->info_ptr)
3311 stash->inliner_chain = NULL;
3313 /* Check the previously read comp. units first. */
3316 /* The info hash tables use quite a bit of memory. We may not want to
3317 always use them. We use some heuristics to decide if and when to
3319 if (stash->info_hash_status == STASH_INFO_HASH_OFF)
3320 stash_maybe_enable_info_hash_tables (abfd, stash);
3322 /* Keep info hash table up to date if they are available. Note that we
3323 may disable the hash tables if there is any error duing update. */
3324 if (stash->info_hash_status == STASH_INFO_HASH_ON)
3325 stash_maybe_update_info_hash_tables (stash);
3327 if (stash->info_hash_status == STASH_INFO_HASH_ON)
3329 found = stash_find_line_fast (stash, symbol, addr, filename_ptr,
3336 /* Check the previously read comp. units first. */
3337 for (each = stash->all_comp_units; each; each = each->next_unit)
3338 if ((symbol->flags & BSF_FUNCTION) == 0
3339 || comp_unit_contains_address (each, addr))
3341 found = comp_unit_find_line (each, symbol, addr, filename_ptr,
3342 linenumber_ptr, stash);
3350 for (each = stash->all_comp_units; each; each = each->next_unit)
3352 found = (comp_unit_contains_address (each, addr)
3353 && comp_unit_find_nearest_line (each, addr,
3363 /* The DWARF2 spec says that the initial length field, and the
3364 offset of the abbreviation table, should both be 4-byte values.
3365 However, some compilers do things differently. */
3368 BFD_ASSERT (addr_size == 4 || addr_size == 8);
3370 /* Read each remaining comp. units checking each as they are read. */
3371 while (stash->info_ptr < stash->info_ptr_end)
3374 unsigned int offset_size = addr_size;
3375 bfd_byte *info_ptr_unit = stash->info_ptr;
3377 length = read_4_bytes (stash->bfd_ptr, stash->info_ptr);
3378 /* A 0xffffff length is the DWARF3 way of indicating
3379 we use 64-bit offsets, instead of 32-bit offsets. */
3380 if (length == 0xffffffff)
3383 length = read_8_bytes (stash->bfd_ptr, stash->info_ptr + 4);
3384 stash->info_ptr += 12;
3386 /* A zero length is the IRIX way of indicating 64-bit offsets,
3387 mostly because the 64-bit length will generally fit in 32
3388 bits, and the endianness helps. */
3389 else if (length == 0)
3392 length = read_4_bytes (stash->bfd_ptr, stash->info_ptr + 4);
3393 stash->info_ptr += 8;
3395 /* In the absence of the hints above, we assume 32-bit DWARF2
3396 offsets even for targets with 64-bit addresses, because:
3397 a) most of the time these targets will not have generated
3398 more than 2Gb of debug info and so will not need 64-bit
3401 b) if they do use 64-bit offsets but they are not using
3402 the size hints that are tested for above then they are
3403 not conforming to the DWARF3 standard anyway. */
3404 else if (addr_size == 8)
3407 stash->info_ptr += 4;
3410 stash->info_ptr += 4;
3414 each = parse_comp_unit (stash, length, info_ptr_unit,
3417 /* The dwarf information is damaged, don't trust it any
3420 stash->info_ptr += length;
3422 if (stash->all_comp_units)
3423 stash->all_comp_units->prev_unit = each;
3425 stash->last_comp_unit = each;
3427 each->next_unit = stash->all_comp_units;
3428 stash->all_comp_units = each;
3430 /* DW_AT_low_pc and DW_AT_high_pc are optional for
3431 compilation units. If we don't have them (i.e.,
3432 unit->high == 0), we need to consult the line info table
3433 to see if a compilation unit contains the given
3436 found = (((symbol->flags & BSF_FUNCTION) == 0
3437 || each->arange.high == 0
3438 || comp_unit_contains_address (each, addr))
3439 && comp_unit_find_line (each, symbol, addr,
3444 found = ((each->arange.high == 0
3445 || comp_unit_contains_address (each, addr))
3446 && comp_unit_find_nearest_line (each, addr,
3452 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
3453 == stash->sec->size)
3455 stash->sec = find_debug_info (stash->bfd_ptr, stash->sec);
3456 stash->sec_info_ptr = stash->info_ptr;
3465 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
3466 unset_sections (stash);
3471 /* The DWARF2 version of find_nearest_line.
3472 Return TRUE if the line is found without error. */
3475 _bfd_dwarf2_find_nearest_line (bfd *abfd,
3479 const char **filename_ptr,
3480 const char **functionname_ptr,
3481 unsigned int *linenumber_ptr,
3482 unsigned int addr_size,
3485 return find_line (abfd, section, offset, NULL, symbols, filename_ptr,
3486 functionname_ptr, linenumber_ptr, addr_size,
3490 /* The DWARF2 version of find_line.
3491 Return TRUE if the line is found without error. */
3494 _bfd_dwarf2_find_line (bfd *abfd,
3497 const char **filename_ptr,
3498 unsigned int *linenumber_ptr,
3499 unsigned int addr_size,
3502 return find_line (abfd, NULL, 0, symbol, symbols, filename_ptr,
3503 NULL, linenumber_ptr, addr_size,
3508 _bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED,
3509 const char **filename_ptr,
3510 const char **functionname_ptr,
3511 unsigned int *linenumber_ptr,
3514 struct dwarf2_debug *stash;
3516 stash = (struct dwarf2_debug *) *pinfo;
3519 struct funcinfo *func = stash->inliner_chain;
3521 if (func && func->caller_func)
3523 *filename_ptr = func->caller_file;
3524 *functionname_ptr = func->caller_func->name;
3525 *linenumber_ptr = func->caller_line;
3526 stash->inliner_chain = func->caller_func;
3535 _bfd_dwarf2_cleanup_debug_info (bfd *abfd)
3537 struct comp_unit *each;
3538 struct dwarf2_debug *stash;
3540 if (abfd == NULL || elf_tdata (abfd) == NULL)
3543 stash = (struct dwarf2_debug *) elf_tdata (abfd)->dwarf2_find_line_info;
3548 for (each = stash->all_comp_units; each; each = each->next_unit)
3550 struct abbrev_info **abbrevs = each->abbrevs;
3551 struct funcinfo *function_table = each->function_table;
3552 struct varinfo *variable_table = each->variable_table;
3555 for (i = 0; i < ABBREV_HASH_SIZE; i++)
3557 struct abbrev_info *abbrev = abbrevs[i];
3561 free (abbrev->attrs);
3562 abbrev = abbrev->next;
3566 if (each->line_table)
3568 free (each->line_table->dirs);
3569 free (each->line_table->files);
3572 while (function_table)
3574 if (function_table->file)
3576 free (function_table->file);
3577 function_table->file = NULL;
3580 if (function_table->caller_file)
3582 free (function_table->caller_file);
3583 function_table->caller_file = NULL;
3585 function_table = function_table->prev_func;
3588 while (variable_table)
3590 if (variable_table->file)
3592 free (variable_table->file);
3593 variable_table->file = NULL;
3596 variable_table = variable_table->prev_var;
3600 if (stash->dwarf_abbrev_buffer)
3601 free (stash->dwarf_abbrev_buffer);
3602 if (stash->dwarf_line_buffer)
3603 free (stash->dwarf_line_buffer);
3604 if (stash->dwarf_str_buffer)
3605 free (stash->dwarf_str_buffer);
3606 if (stash->dwarf_ranges_buffer)
3607 free (stash->dwarf_ranges_buffer);
3608 if (stash->info_ptr_memory)
3609 free (stash->info_ptr_memory);