2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008, 2009 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 default_is_stmt;
50 unsigned char line_range;
51 unsigned char opcode_base;
52 unsigned char *standard_opcode_lengths;
55 /* Attributes have a name and a value. */
59 enum dwarf_attribute name;
64 struct dwarf_block *blk;
71 /* Blocks are a bunch of untyped bytes. */
78 struct adjusted_section
86 /* A list of all previously read comp_units. */
87 struct comp_unit *all_comp_units;
89 /* Last comp unit in list above. */
90 struct comp_unit *last_comp_unit;
92 /* The next unread compilation unit within the .debug_info section.
93 Zero indicates that the .debug_info section has not been loaded
97 /* Pointer to the end of the .debug_info section memory buffer. */
98 bfd_byte *info_ptr_end;
100 /* Pointer to the bfd, section and address of the beginning of the
101 section. The bfd might be different than expected because of
102 gnu_debuglink sections. */
105 bfd_byte *sec_info_ptr;
107 /* A pointer to the memory block allocated for info_ptr. Neither
108 info_ptr nor sec_info_ptr are guaranteed to stay pointing to the
109 beginning of the malloc block. This is used only to free the
111 bfd_byte *info_ptr_memory;
113 /* Pointer to the symbol table. */
116 /* Pointer to the .debug_abbrev section loaded into memory. */
117 bfd_byte *dwarf_abbrev_buffer;
119 /* Length of the loaded .debug_abbrev section. */
120 bfd_size_type dwarf_abbrev_size;
122 /* Buffer for decode_line_info. */
123 bfd_byte *dwarf_line_buffer;
125 /* Length of the loaded .debug_line section. */
126 bfd_size_type dwarf_line_size;
128 /* Pointer to the .debug_str section loaded into memory. */
129 bfd_byte *dwarf_str_buffer;
131 /* Length of the loaded .debug_str section. */
132 bfd_size_type dwarf_str_size;
134 /* Pointer to the .debug_ranges section loaded into memory. */
135 bfd_byte *dwarf_ranges_buffer;
137 /* Length of the loaded .debug_ranges section. */
138 bfd_size_type dwarf_ranges_size;
140 /* If the most recent call to bfd_find_nearest_line was given an
141 address in an inlined function, preserve a pointer into the
142 calling chain for subsequent calls to bfd_find_inliner_info to
144 struct funcinfo *inliner_chain;
146 /* Number of sections whose VMA we must adjust. */
147 unsigned int adjusted_section_count;
149 /* Array of sections with adjusted VMA. */
150 struct adjusted_section *adjusted_sections;
152 /* Number of times find_line is called. This is used in
153 the heuristic for enabling the info hash tables. */
156 #define STASH_INFO_HASH_TRIGGER 100
158 /* Hash table mapping symbol names to function infos. */
159 struct info_hash_table *funcinfo_hash_table;
161 /* Hash table mapping symbol names to variable infos. */
162 struct info_hash_table *varinfo_hash_table;
164 /* Head of comp_unit list in the last hash table update. */
165 struct comp_unit *hash_units_head;
167 /* Status of info hash. */
168 int info_hash_status;
169 #define STASH_INFO_HASH_OFF 0
170 #define STASH_INFO_HASH_ON 1
171 #define STASH_INFO_HASH_DISABLED 2
181 /* A minimal decoding of DWARF2 compilation units. We only decode
182 what's needed to get to the line number information. */
186 /* Chain the previously read compilation units. */
187 struct comp_unit *next_unit;
189 /* Likewise, chain the compilation unit read after this one.
190 The comp units are stored in reversed reading order. */
191 struct comp_unit *prev_unit;
193 /* Keep the bfd convenient (for memory allocation). */
196 /* The lowest and highest addresses contained in this compilation
197 unit as specified in the compilation unit header. */
198 struct arange arange;
200 /* The DW_AT_name attribute (for error messages). */
203 /* The abbrev hash table. */
204 struct abbrev_info **abbrevs;
206 /* Note that an error was found by comp_unit_find_nearest_line. */
209 /* The DW_AT_comp_dir attribute. */
212 /* TRUE if there is a line number table associated with this comp. unit. */
215 /* Pointer to the current comp_unit so that we can find a given entry
217 bfd_byte *info_ptr_unit;
219 /* Pointer to the start of the debug section, for DW_FORM_ref_addr. */
220 bfd_byte *sec_info_ptr;
222 /* The offset into .debug_line of the line number table. */
223 unsigned long line_offset;
225 /* Pointer to the first child die for the comp unit. */
226 bfd_byte *first_child_die_ptr;
228 /* The end of the comp unit. */
231 /* The decoded line number, NULL if not yet decoded. */
232 struct line_info_table *line_table;
234 /* A list of the functions found in this comp. unit. */
235 struct funcinfo *function_table;
237 /* A list of the variables found in this comp. unit. */
238 struct varinfo *variable_table;
240 /* Pointer to dwarf2_debug structure. */
241 struct dwarf2_debug *stash;
243 /* DWARF format version for this unit - from unit header. */
246 /* Address size for this unit - from unit header. */
247 unsigned char addr_size;
249 /* Offset size for this unit - from unit header. */
250 unsigned char offset_size;
252 /* Base address for this unit - from DW_AT_low_pc attribute of
253 DW_TAG_compile_unit DIE */
254 bfd_vma base_address;
256 /* TRUE if symbols are cached in hash table for faster lookup by name. */
260 /* This data structure holds the information of an abbrev. */
263 unsigned int number; /* Number identifying abbrev. */
264 enum dwarf_tag tag; /* DWARF tag. */
265 int has_children; /* Boolean. */
266 unsigned int num_attrs; /* Number of attributes. */
267 struct attr_abbrev *attrs; /* An array of attribute descriptions. */
268 struct abbrev_info *next; /* Next in chain. */
273 enum dwarf_attribute name;
274 enum dwarf_form form;
277 #ifndef ABBREV_HASH_SIZE
278 #define ABBREV_HASH_SIZE 121
280 #ifndef ATTR_ALLOC_CHUNK
281 #define ATTR_ALLOC_CHUNK 4
284 /* Variable and function hash tables. This is used to speed up look-up
285 in lookup_symbol_in_var_table() and lookup_symbol_in_function_table().
286 In order to share code between variable and function infos, we use
287 a list of untyped pointer for all variable/function info associated with
288 a symbol. We waste a bit of memory for list with one node but that
289 simplifies the code. */
291 struct info_list_node
293 struct info_list_node *next;
297 /* Info hash entry. */
298 struct info_hash_entry
300 struct bfd_hash_entry root;
301 struct info_list_node *head;
304 struct info_hash_table
306 struct bfd_hash_table base;
309 /* Function to create a new entry in info hash table. */
311 static struct bfd_hash_entry *
312 info_hash_table_newfunc (struct bfd_hash_entry *entry,
313 struct bfd_hash_table *table,
316 struct info_hash_entry *ret = (struct info_hash_entry *) entry;
318 /* Allocate the structure if it has not already been allocated by a
322 ret = (struct info_hash_entry *) bfd_hash_allocate (table,
328 /* Call the allocation method of the base class. */
329 ret = ((struct info_hash_entry *)
330 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
332 /* Initialize the local fields here. */
336 return (struct bfd_hash_entry *) ret;
339 /* Function to create a new info hash table. It returns a pointer to the
340 newly created table or NULL if there is any error. We need abfd
341 solely for memory allocation. */
343 static struct info_hash_table *
344 create_info_hash_table (bfd *abfd)
346 struct info_hash_table *hash_table;
348 hash_table = (struct info_hash_table *)
349 bfd_alloc (abfd, sizeof (struct info_hash_table));
353 if (!bfd_hash_table_init (&hash_table->base, info_hash_table_newfunc,
354 sizeof (struct info_hash_entry)))
356 bfd_release (abfd, hash_table);
363 /* Insert an info entry into an info hash table. We do not check of
364 duplicate entries. Also, the caller need to guarantee that the
365 right type of info in inserted as info is passed as a void* pointer.
366 This function returns true if there is no error. */
369 insert_info_hash_table (struct info_hash_table *hash_table,
374 struct info_hash_entry *entry;
375 struct info_list_node *node;
377 entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base,
382 node = (struct info_list_node *) bfd_hash_allocate (&hash_table->base,
388 node->next = entry->head;
394 /* Look up an info entry list from an info hash table. Return NULL
397 static struct info_list_node *
398 lookup_info_hash_table (struct info_hash_table *hash_table, const char *key)
400 struct info_hash_entry *entry;
402 entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base, key,
404 return entry ? entry->head : NULL;
407 /* Read a section into its appropriate place in the dwarf2_debug
408 struct (indicated by SECTION_BUFFER and SECTION_SIZE). If SYMS is
409 not NULL, use bfd_simple_get_relocated_section_contents to read the
410 section contents, otherwise use bfd_get_section_contents. Fail if
411 the located section does not contain at least OFFSET bytes. */
414 read_section (bfd * abfd,
415 const char * section_name,
416 const char * compressed_section_name,
419 bfd_byte ** section_buffer,
420 bfd_size_type * section_size)
423 bfd_boolean section_is_compressed = FALSE;
425 /* read_section is a noop if the section has already been read. */
426 if (!*section_buffer)
428 msec = bfd_get_section_by_name (abfd, section_name);
429 if (! msec && compressed_section_name)
431 msec = bfd_get_section_by_name (abfd, compressed_section_name);
432 section_is_compressed = TRUE;
436 (*_bfd_error_handler) (_("Dwarf Error: Can't find %s section."), section_name);
437 bfd_set_error (bfd_error_bad_value);
441 *section_size = msec->rawsize ? msec->rawsize : msec->size;
445 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL, syms);
446 if (! *section_buffer)
451 *section_buffer = (bfd_byte *) bfd_malloc (*section_size);
452 if (! *section_buffer)
454 if (! bfd_get_section_contents (abfd, msec, *section_buffer,
459 if (section_is_compressed)
461 if (! bfd_uncompress_section_contents (section_buffer, section_size))
463 (*_bfd_error_handler) (_("Dwarf Error: unable to decompress %s section."), compressed_section_name);
464 bfd_set_error (bfd_error_bad_value);
470 /* It is possible to get a bad value for the offset into the section
471 that the client wants. Validate it here to avoid trouble later. */
472 if (offset != 0 && offset >= *section_size)
474 (*_bfd_error_handler) (_("Dwarf Error: Offset (%lu) greater than or equal to %s size (%lu)."),
475 (long) offset, section_name, *section_size);
476 bfd_set_error (bfd_error_bad_value);
484 The following function up to the END VERBATIM mark are
485 copied directly from dwarf2read.c. */
487 /* Read dwarf information from a buffer. */
490 read_1_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf)
492 return bfd_get_8 (abfd, buf);
496 read_1_signed_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf)
498 return bfd_get_signed_8 (abfd, buf);
502 read_2_bytes (bfd *abfd, bfd_byte *buf)
504 return bfd_get_16 (abfd, buf);
508 read_4_bytes (bfd *abfd, bfd_byte *buf)
510 return bfd_get_32 (abfd, buf);
514 read_8_bytes (bfd *abfd, bfd_byte *buf)
516 return bfd_get_64 (abfd, buf);
520 read_n_bytes (bfd *abfd ATTRIBUTE_UNUSED,
522 unsigned int size ATTRIBUTE_UNUSED)
528 read_string (bfd *abfd ATTRIBUTE_UNUSED,
530 unsigned int *bytes_read_ptr)
532 /* Return a pointer to the embedded string. */
533 char *str = (char *) buf;
541 *bytes_read_ptr = strlen (str) + 1;
548 read_indirect_string (struct comp_unit * unit,
550 unsigned int * bytes_read_ptr)
553 struct dwarf2_debug *stash = unit->stash;
556 if (unit->offset_size == 4)
557 offset = read_4_bytes (unit->abfd, buf);
559 offset = read_8_bytes (unit->abfd, buf);
561 *bytes_read_ptr = unit->offset_size;
563 if (! read_section (unit->abfd, ".debug_str", ".zdebug_str",
565 &stash->dwarf_str_buffer, &stash->dwarf_str_size))
568 str = (char *) stash->dwarf_str_buffer + offset;
575 read_address (struct comp_unit *unit, bfd_byte *buf)
577 int signed_vma = get_elf_backend_data (unit->abfd)->sign_extend_vma;
581 switch (unit->addr_size)
584 return bfd_get_signed_64 (unit->abfd, buf);
586 return bfd_get_signed_32 (unit->abfd, buf);
588 return bfd_get_signed_16 (unit->abfd, buf);
595 switch (unit->addr_size)
598 return bfd_get_64 (unit->abfd, buf);
600 return bfd_get_32 (unit->abfd, buf);
602 return bfd_get_16 (unit->abfd, buf);
609 /* Lookup an abbrev_info structure in the abbrev hash table. */
611 static struct abbrev_info *
612 lookup_abbrev (unsigned int number, struct abbrev_info **abbrevs)
614 unsigned int hash_number;
615 struct abbrev_info *abbrev;
617 hash_number = number % ABBREV_HASH_SIZE;
618 abbrev = abbrevs[hash_number];
622 if (abbrev->number == number)
625 abbrev = abbrev->next;
631 /* In DWARF version 2, the description of the debugging information is
632 stored in a separate .debug_abbrev section. Before we read any
633 dies from a section we read in all abbreviations and install them
636 static struct abbrev_info**
637 read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
639 struct abbrev_info **abbrevs;
640 bfd_byte *abbrev_ptr;
641 struct abbrev_info *cur_abbrev;
642 unsigned int abbrev_number, bytes_read, abbrev_name;
643 unsigned int abbrev_form, hash_number;
646 if (! read_section (abfd, ".debug_abbrev", ".zdebug_abbrev",
648 &stash->dwarf_abbrev_buffer, &stash->dwarf_abbrev_size))
651 amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
652 abbrevs = (struct abbrev_info **) bfd_zalloc (abfd, amt);
654 abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
655 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
656 abbrev_ptr += bytes_read;
658 /* Loop until we reach an abbrev number of 0. */
659 while (abbrev_number)
661 amt = sizeof (struct abbrev_info);
662 cur_abbrev = (struct abbrev_info *) bfd_zalloc (abfd, amt);
664 /* Read in abbrev header. */
665 cur_abbrev->number = abbrev_number;
666 cur_abbrev->tag = (enum dwarf_tag)
667 read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
668 abbrev_ptr += bytes_read;
669 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
672 /* Now read in declarations. */
673 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
674 abbrev_ptr += bytes_read;
675 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
676 abbrev_ptr += bytes_read;
680 if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
682 struct attr_abbrev *tmp;
684 amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
685 amt *= sizeof (struct attr_abbrev);
686 tmp = (struct attr_abbrev *) bfd_realloc (cur_abbrev->attrs, amt);
691 for (i = 0; i < ABBREV_HASH_SIZE; i++)
693 struct abbrev_info *abbrev = abbrevs[i];
697 free (abbrev->attrs);
698 abbrev = abbrev->next;
703 cur_abbrev->attrs = tmp;
706 cur_abbrev->attrs[cur_abbrev->num_attrs].name
707 = (enum dwarf_attribute) abbrev_name;
708 cur_abbrev->attrs[cur_abbrev->num_attrs++].form
709 = (enum dwarf_form) abbrev_form;
710 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
711 abbrev_ptr += bytes_read;
712 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
713 abbrev_ptr += bytes_read;
716 hash_number = abbrev_number % ABBREV_HASH_SIZE;
717 cur_abbrev->next = abbrevs[hash_number];
718 abbrevs[hash_number] = cur_abbrev;
720 /* Get next abbreviation.
721 Under Irix6 the abbreviations for a compilation unit are not
722 always properly terminated with an abbrev number of 0.
723 Exit loop if we encounter an abbreviation which we have
724 already read (which means we are about to read the abbreviations
725 for the next compile unit) or if the end of the abbreviation
727 if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
728 >= stash->dwarf_abbrev_size)
730 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
731 abbrev_ptr += bytes_read;
732 if (lookup_abbrev (abbrev_number,abbrevs) != NULL)
739 /* Read an attribute value described by an attribute form. */
742 read_attribute_value (struct attribute *attr,
744 struct comp_unit *unit,
747 bfd *abfd = unit->abfd;
748 unsigned int bytes_read;
749 struct dwarf_block *blk;
752 attr->form = (enum dwarf_form) form;
756 case DW_FORM_ref_addr:
757 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
759 if (unit->version == 3)
761 if (unit->offset_size == 4)
762 attr->u.val = read_4_bytes (unit->abfd, info_ptr);
764 attr->u.val = read_8_bytes (unit->abfd, info_ptr);
765 info_ptr += unit->offset_size;
770 attr->u.val = read_address (unit, info_ptr);
771 info_ptr += unit->addr_size;
774 amt = sizeof (struct dwarf_block);
775 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
776 blk->size = read_2_bytes (abfd, info_ptr);
778 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
779 info_ptr += blk->size;
783 amt = sizeof (struct dwarf_block);
784 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
785 blk->size = read_4_bytes (abfd, info_ptr);
787 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
788 info_ptr += blk->size;
792 attr->u.val = read_2_bytes (abfd, info_ptr);
796 attr->u.val = read_4_bytes (abfd, info_ptr);
800 attr->u.val = read_8_bytes (abfd, info_ptr);
804 attr->u.str = read_string (abfd, info_ptr, &bytes_read);
805 info_ptr += bytes_read;
808 attr->u.str = read_indirect_string (unit, info_ptr, &bytes_read);
809 info_ptr += bytes_read;
812 amt = sizeof (struct dwarf_block);
813 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
814 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
815 info_ptr += bytes_read;
816 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
817 info_ptr += blk->size;
821 amt = sizeof (struct dwarf_block);
822 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
823 blk->size = read_1_byte (abfd, info_ptr);
825 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
826 info_ptr += blk->size;
830 attr->u.val = read_1_byte (abfd, info_ptr);
834 attr->u.val = read_1_byte (abfd, info_ptr);
838 attr->u.sval = read_signed_leb128 (abfd, info_ptr, &bytes_read);
839 info_ptr += bytes_read;
842 attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
843 info_ptr += bytes_read;
846 attr->u.val = read_1_byte (abfd, info_ptr);
850 attr->u.val = read_2_bytes (abfd, info_ptr);
854 attr->u.val = read_4_bytes (abfd, info_ptr);
858 attr->u.val = read_8_bytes (abfd, info_ptr);
861 case DW_FORM_ref_udata:
862 attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
863 info_ptr += bytes_read;
865 case DW_FORM_indirect:
866 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
867 info_ptr += bytes_read;
868 info_ptr = read_attribute_value (attr, form, unit, info_ptr);
871 (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %u."),
873 bfd_set_error (bfd_error_bad_value);
878 /* Read an attribute described by an abbreviated attribute. */
881 read_attribute (struct attribute *attr,
882 struct attr_abbrev *abbrev,
883 struct comp_unit *unit,
886 attr->name = abbrev->name;
887 info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr);
891 /* Source line information table routines. */
893 #define FILE_ALLOC_CHUNK 5
894 #define DIR_ALLOC_CHUNK 5
898 struct line_info* prev_line;
903 int end_sequence; /* End of (sequential) code sequence. */
914 struct line_info_table
917 unsigned int num_files;
918 unsigned int num_dirs;
921 struct fileinfo* files;
922 struct line_info* last_line; /* largest VMA */
923 struct line_info* lcl_head; /* local head; used in 'add_line_info' */
926 /* Remember some information about each function. If the function is
927 inlined (DW_TAG_inlined_subroutine) it may have two additional
928 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
929 source code location where this function was inlined. */
933 struct funcinfo *prev_func; /* Pointer to previous function in list of all functions */
934 struct funcinfo *caller_func; /* Pointer to function one scope higher */
935 char *caller_file; /* Source location file name where caller_func inlines this func */
936 int caller_line; /* Source location line number where caller_func inlines this func */
937 char *file; /* Source location file name */
938 int line; /* Source location line number */
941 struct arange arange;
942 asection *sec; /* Where the symbol is defined */
947 /* Pointer to previous variable in list of all variables */
948 struct varinfo *prev_var;
949 /* Source location file name */
951 /* Source location line number */
956 /* Where the symbol is defined */
958 /* Is this a stack variable? */
959 unsigned int stack: 1;
962 /* Return TRUE if NEW_LINE should sort after LINE. */
964 static inline bfd_boolean
965 new_line_sorts_after (struct line_info *new_line, struct line_info *line)
967 return (new_line->address > line->address
968 || (new_line->address == line->address
969 && new_line->end_sequence < line->end_sequence));
973 /* Adds a new entry to the line_info list in the line_info_table, ensuring
974 that the list is sorted. Note that the line_info list is sorted from
975 highest to lowest VMA (with possible duplicates); that is,
976 line_info->prev_line always accesses an equal or smaller VMA. */
979 add_line_info (struct line_info_table *table,
986 bfd_size_type amt = sizeof (struct line_info);
987 struct line_info* info = (struct line_info *) bfd_alloc (table->abfd, amt);
989 /* Set member data of 'info'. */
990 info->address = address;
992 info->column = column;
993 info->end_sequence = end_sequence;
995 if (filename && filename[0])
997 info->filename = (char *) bfd_alloc (table->abfd, strlen (filename) + 1);
999 strcpy (info->filename, filename);
1002 info->filename = NULL;
1004 /* Find the correct location for 'info'. Normally we will receive
1005 new line_info data 1) in order and 2) with increasing VMAs.
1006 However some compilers break the rules (cf. decode_line_info) and
1007 so we include some heuristics for quickly finding the correct
1008 location for 'info'. In particular, these heuristics optimize for
1009 the common case in which the VMA sequence that we receive is a
1010 list of locally sorted VMAs such as
1011 p...z a...j (where a < j < p < z)
1013 Note: table->lcl_head is used to head an *actual* or *possible*
1014 sequence within the list (such as a...j) that is not directly
1015 headed by table->last_line
1017 Note: we may receive duplicate entries from 'decode_line_info'. */
1019 if (table->last_line
1020 && table->last_line->address == address
1021 && table->last_line->end_sequence == end_sequence)
1023 /* We only keep the last entry with the same address and end
1024 sequence. See PR ld/4986. */
1025 if (table->lcl_head == table->last_line)
1026 table->lcl_head = info;
1027 info->prev_line = table->last_line->prev_line;
1028 table->last_line = info;
1030 else if (!table->last_line
1031 || new_line_sorts_after (info, table->last_line))
1033 /* Normal case: add 'info' to the beginning of the list */
1034 info->prev_line = table->last_line;
1035 table->last_line = info;
1037 /* lcl_head: initialize to head a *possible* sequence at the end. */
1038 if (!table->lcl_head)
1039 table->lcl_head = info;
1041 else if (!new_line_sorts_after (info, table->lcl_head)
1042 && (!table->lcl_head->prev_line
1043 || new_line_sorts_after (info, table->lcl_head->prev_line)))
1045 /* Abnormal but easy: lcl_head is the head of 'info'. */
1046 info->prev_line = table->lcl_head->prev_line;
1047 table->lcl_head->prev_line = info;
1051 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head' are valid
1052 heads for 'info'. Reset 'lcl_head'. */
1053 struct line_info* li2 = table->last_line; /* always non-NULL */
1054 struct line_info* li1 = li2->prev_line;
1058 if (!new_line_sorts_after (info, li2)
1059 && new_line_sorts_after (info, li1))
1062 li2 = li1; /* always non-NULL */
1063 li1 = li1->prev_line;
1065 table->lcl_head = li2;
1066 info->prev_line = table->lcl_head->prev_line;
1067 table->lcl_head->prev_line = info;
1071 /* Extract a fully qualified filename from a line info table.
1072 The returned string has been malloc'ed and it is the caller's
1073 responsibility to free it. */
1076 concat_filename (struct line_info_table *table, unsigned int file)
1080 if (file - 1 >= table->num_files)
1082 /* FILE == 0 means unknown. */
1084 (*_bfd_error_handler)
1085 (_("Dwarf Error: mangled line number section (bad file number)."));
1086 return strdup ("<unknown>");
1089 filename = table->files[file - 1].name;
1091 if (!IS_ABSOLUTE_PATH (filename))
1093 char *dirname = NULL;
1094 char *subdirname = NULL;
1098 if (table->files[file - 1].dir)
1099 subdirname = table->dirs[table->files[file - 1].dir - 1];
1101 if (!subdirname || !IS_ABSOLUTE_PATH (subdirname))
1102 dirname = table->comp_dir;
1106 dirname = subdirname;
1111 return strdup (filename);
1113 len = strlen (dirname) + strlen (filename) + 2;
1117 len += strlen (subdirname) + 1;
1118 name = (char *) bfd_malloc (len);
1120 sprintf (name, "%s/%s/%s", dirname, subdirname, filename);
1124 name = (char *) bfd_malloc (len);
1126 sprintf (name, "%s/%s", dirname, filename);
1132 return strdup (filename);
1136 arange_add (bfd *abfd, struct arange *first_arange, bfd_vma low_pc, bfd_vma high_pc)
1138 struct arange *arange;
1140 /* If the first arange is empty, use it. */
1141 if (first_arange->high == 0)
1143 first_arange->low = low_pc;
1144 first_arange->high = high_pc;
1148 /* Next see if we can cheaply extend an existing range. */
1149 arange = first_arange;
1152 if (low_pc == arange->high)
1154 arange->high = high_pc;
1157 if (high_pc == arange->low)
1159 arange->low = low_pc;
1162 arange = arange->next;
1166 /* Need to allocate a new arange and insert it into the arange list.
1167 Order isn't significant, so just insert after the first arange. */
1168 arange = (struct arange *) bfd_zalloc (abfd, sizeof (*arange));
1169 arange->low = low_pc;
1170 arange->high = high_pc;
1171 arange->next = first_arange->next;
1172 first_arange->next = arange;
1175 /* Decode the line number information for UNIT. */
1177 static struct line_info_table*
1178 decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
1180 bfd *abfd = unit->abfd;
1181 struct line_info_table* table;
1184 struct line_head lh;
1185 unsigned int i, bytes_read, offset_size;
1186 char *cur_file, *cur_dir;
1187 unsigned char op_code, extended_op, adj_opcode;
1190 if (! read_section (abfd, ".debug_line", ".zdebug_line",
1191 stash->syms, unit->line_offset,
1192 &stash->dwarf_line_buffer, &stash->dwarf_line_size))
1195 amt = sizeof (struct line_info_table);
1196 table = (struct line_info_table *) bfd_alloc (abfd, amt);
1198 table->comp_dir = unit->comp_dir;
1200 table->num_files = 0;
1201 table->files = NULL;
1203 table->num_dirs = 0;
1206 table->files = NULL;
1207 table->last_line = NULL;
1208 table->lcl_head = NULL;
1210 line_ptr = stash->dwarf_line_buffer + unit->line_offset;
1212 /* Read in the prologue. */
1213 lh.total_length = read_4_bytes (abfd, line_ptr);
1216 if (lh.total_length == 0xffffffff)
1218 lh.total_length = read_8_bytes (abfd, line_ptr);
1222 else if (lh.total_length == 0 && unit->addr_size == 8)
1224 /* Handle (non-standard) 64-bit DWARF2 formats. */
1225 lh.total_length = read_4_bytes (abfd, line_ptr);
1229 line_end = line_ptr + lh.total_length;
1230 lh.version = read_2_bytes (abfd, line_ptr);
1232 if (offset_size == 4)
1233 lh.prologue_length = read_4_bytes (abfd, line_ptr);
1235 lh.prologue_length = read_8_bytes (abfd, line_ptr);
1236 line_ptr += offset_size;
1237 lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
1239 lh.default_is_stmt = read_1_byte (abfd, line_ptr);
1241 lh.line_base = read_1_signed_byte (abfd, line_ptr);
1243 lh.line_range = read_1_byte (abfd, line_ptr);
1245 lh.opcode_base = read_1_byte (abfd, line_ptr);
1247 amt = lh.opcode_base * sizeof (unsigned char);
1248 lh.standard_opcode_lengths = (unsigned char *) bfd_alloc (abfd, amt);
1250 lh.standard_opcode_lengths[0] = 1;
1252 for (i = 1; i < lh.opcode_base; ++i)
1254 lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
1258 /* Read directory table. */
1259 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1261 line_ptr += bytes_read;
1263 if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
1267 amt = table->num_dirs + DIR_ALLOC_CHUNK;
1268 amt *= sizeof (char *);
1270 tmp = (char **) bfd_realloc (table->dirs, amt);
1279 table->dirs[table->num_dirs++] = cur_dir;
1282 line_ptr += bytes_read;
1284 /* Read file name table. */
1285 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1287 line_ptr += bytes_read;
1289 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1291 struct fileinfo *tmp;
1293 amt = table->num_files + FILE_ALLOC_CHUNK;
1294 amt *= sizeof (struct fileinfo);
1296 tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
1299 free (table->files);
1306 table->files[table->num_files].name = cur_file;
1307 table->files[table->num_files].dir =
1308 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1309 line_ptr += bytes_read;
1310 table->files[table->num_files].time =
1311 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1312 line_ptr += bytes_read;
1313 table->files[table->num_files].size =
1314 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1315 line_ptr += bytes_read;
1319 line_ptr += bytes_read;
1321 /* Read the statement sequences until there's nothing left. */
1322 while (line_ptr < line_end)
1324 /* State machine registers. */
1325 bfd_vma address = 0;
1326 char * filename = table->num_files ? concat_filename (table, 1) : NULL;
1327 unsigned int line = 1;
1328 unsigned int column = 0;
1329 int is_stmt = lh.default_is_stmt;
1330 int end_sequence = 0;
1331 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1332 compilers generate address sequences that are wildly out of
1333 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1334 for ia64-Linux). Thus, to determine the low and high
1335 address, we must compare on every DW_LNS_copy, etc. */
1336 bfd_vma low_pc = (bfd_vma) -1;
1337 bfd_vma high_pc = 0;
1339 /* Decode the table. */
1340 while (! end_sequence)
1342 op_code = read_1_byte (abfd, line_ptr);
1345 if (op_code >= lh.opcode_base)
1347 /* Special operand. */
1348 adj_opcode = op_code - lh.opcode_base;
1349 address += (adj_opcode / lh.line_range)
1350 * lh.minimum_instruction_length;
1351 line += lh.line_base + (adj_opcode % lh.line_range);
1352 /* Append row to matrix using current values. */
1353 add_line_info (table, address, filename, line, column, 0);
1354 if (address < low_pc)
1356 if (address > high_pc)
1359 else switch (op_code)
1361 case DW_LNS_extended_op:
1362 /* Ignore length. */
1364 extended_op = read_1_byte (abfd, line_ptr);
1367 switch (extended_op)
1369 case DW_LNE_end_sequence:
1371 add_line_info (table, address, filename, line, column,
1373 if (address < low_pc)
1375 if (address > high_pc)
1377 arange_add (unit->abfd, &unit->arange, low_pc, high_pc);
1379 case DW_LNE_set_address:
1380 address = read_address (unit, line_ptr);
1381 line_ptr += unit->addr_size;
1383 case DW_LNE_define_file:
1384 cur_file = read_string (abfd, line_ptr, &bytes_read);
1385 line_ptr += bytes_read;
1386 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1388 struct fileinfo *tmp;
1390 amt = table->num_files + FILE_ALLOC_CHUNK;
1391 amt *= sizeof (struct fileinfo);
1392 tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
1395 free (table->files);
1402 table->files[table->num_files].name = cur_file;
1403 table->files[table->num_files].dir =
1404 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1405 line_ptr += bytes_read;
1406 table->files[table->num_files].time =
1407 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1408 line_ptr += bytes_read;
1409 table->files[table->num_files].size =
1410 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1411 line_ptr += bytes_read;
1414 case DW_LNE_set_discriminator:
1415 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1416 line_ptr += bytes_read;
1419 (*_bfd_error_handler) (_("Dwarf Error: mangled line number section."));
1420 bfd_set_error (bfd_error_bad_value);
1422 free (table->files);
1428 add_line_info (table, address, filename, line, column, 0);
1429 if (address < low_pc)
1431 if (address > high_pc)
1434 case DW_LNS_advance_pc:
1435 address += lh.minimum_instruction_length
1436 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1437 line_ptr += bytes_read;
1439 case DW_LNS_advance_line:
1440 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
1441 line_ptr += bytes_read;
1443 case DW_LNS_set_file:
1447 /* The file and directory tables are 0
1448 based, the references are 1 based. */
1449 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1450 line_ptr += bytes_read;
1453 filename = concat_filename (table, file);
1456 case DW_LNS_set_column:
1457 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1458 line_ptr += bytes_read;
1460 case DW_LNS_negate_stmt:
1461 is_stmt = (!is_stmt);
1463 case DW_LNS_set_basic_block:
1465 case DW_LNS_const_add_pc:
1466 address += lh.minimum_instruction_length
1467 * ((255 - lh.opcode_base) / lh.line_range);
1469 case DW_LNS_fixed_advance_pc:
1470 address += read_2_bytes (abfd, line_ptr);
1477 /* Unknown standard opcode, ignore it. */
1478 for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
1480 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1481 line_ptr += bytes_read;
1494 /* If ADDR is within TABLE set the output parameters and return TRUE,
1495 otherwise return FALSE. The output parameters, FILENAME_PTR and
1496 LINENUMBER_PTR, are pointers to the objects to be filled in. */
1499 lookup_address_in_line_info_table (struct line_info_table *table,
1501 const char **filename_ptr,
1502 unsigned int *linenumber_ptr)
1504 /* Note: table->last_line should be a descendingly sorted list. */
1505 struct line_info *each_line;
1507 for (each_line = table->last_line;
1509 each_line = each_line->prev_line)
1510 if (addr >= each_line->address)
1514 && !(each_line->end_sequence || each_line == table->last_line))
1516 *filename_ptr = each_line->filename;
1517 *linenumber_ptr = each_line->line;
1521 *filename_ptr = NULL;
1525 /* Read in the .debug_ranges section for future reference */
1528 read_debug_ranges (struct comp_unit *unit)
1530 struct dwarf2_debug *stash = unit->stash;
1531 return read_section (unit->abfd, ".debug_ranges", ".zdebug_ranges",
1533 &stash->dwarf_ranges_buffer, &stash->dwarf_ranges_size);
1536 /* Function table functions. */
1538 /* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return TRUE.
1539 Note that we need to find the function that has the smallest
1540 range that contains ADDR, to handle inlined functions without
1541 depending upon them being ordered in TABLE by increasing range. */
1544 lookup_address_in_function_table (struct comp_unit *unit,
1546 struct funcinfo **function_ptr,
1547 const char **functionname_ptr)
1549 struct funcinfo* each_func;
1550 struct funcinfo* best_fit = NULL;
1551 struct arange *arange;
1553 for (each_func = unit->function_table;
1555 each_func = each_func->prev_func)
1557 for (arange = &each_func->arange;
1559 arange = arange->next)
1561 if (addr >= arange->low && addr < arange->high)
1564 ((arange->high - arange->low) < (best_fit->arange.high - best_fit->arange.low)))
1565 best_fit = each_func;
1572 *functionname_ptr = best_fit->name;
1573 *function_ptr = best_fit;
1582 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
1583 and LINENUMBER_PTR, and return TRUE. */
1586 lookup_symbol_in_function_table (struct comp_unit *unit,
1589 const char **filename_ptr,
1590 unsigned int *linenumber_ptr)
1592 struct funcinfo* each_func;
1593 struct funcinfo* best_fit = NULL;
1594 struct arange *arange;
1595 const char *name = bfd_asymbol_name (sym);
1596 asection *sec = bfd_get_section (sym);
1598 for (each_func = unit->function_table;
1600 each_func = each_func->prev_func)
1602 for (arange = &each_func->arange;
1604 arange = arange->next)
1606 if ((!each_func->sec || each_func->sec == sec)
1607 && addr >= arange->low
1608 && addr < arange->high
1610 && strcmp (name, each_func->name) == 0
1612 || ((arange->high - arange->low)
1613 < (best_fit->arange.high - best_fit->arange.low))))
1614 best_fit = each_func;
1620 best_fit->sec = sec;
1621 *filename_ptr = best_fit->file;
1622 *linenumber_ptr = best_fit->line;
1629 /* Variable table functions. */
1631 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
1632 LINENUMBER_PTR, and return TRUE. */
1635 lookup_symbol_in_variable_table (struct comp_unit *unit,
1638 const char **filename_ptr,
1639 unsigned int *linenumber_ptr)
1641 const char *name = bfd_asymbol_name (sym);
1642 asection *sec = bfd_get_section (sym);
1643 struct varinfo* each;
1645 for (each = unit->variable_table; each; each = each->prev_var)
1646 if (each->stack == 0
1647 && each->file != NULL
1648 && each->name != NULL
1649 && each->addr == addr
1650 && (!each->sec || each->sec == sec)
1651 && strcmp (name, each->name) == 0)
1657 *filename_ptr = each->file;
1658 *linenumber_ptr = each->line;
1666 find_abstract_instance_name (struct comp_unit *unit,
1667 struct attribute *attr_ptr)
1669 bfd *abfd = unit->abfd;
1671 unsigned int abbrev_number, bytes_read, i;
1672 struct abbrev_info *abbrev;
1673 bfd_uint64_t die_ref = attr_ptr->u.val;
1674 struct attribute attr;
1677 /* DW_FORM_ref_addr can reference an entry in a different CU. It
1678 is an offset from the .debug_info section, not the current CU. */
1679 if (attr_ptr->form == DW_FORM_ref_addr)
1681 /* We only support DW_FORM_ref_addr within the same file, so
1682 any relocations should be resolved already. */
1686 info_ptr = unit->sec_info_ptr + die_ref;
1689 info_ptr = unit->info_ptr_unit + die_ref;
1690 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1691 info_ptr += bytes_read;
1695 abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
1698 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1700 bfd_set_error (bfd_error_bad_value);
1704 for (i = 0; i < abbrev->num_attrs; ++i)
1706 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1710 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
1714 case DW_AT_specification:
1715 name = find_abstract_instance_name (unit, &attr);
1717 case DW_AT_MIPS_linkage_name:
1730 read_rangelist (struct comp_unit *unit, struct arange *arange, bfd_uint64_t offset)
1732 bfd_byte *ranges_ptr;
1733 bfd_vma base_address = unit->base_address;
1735 if (! unit->stash->dwarf_ranges_buffer)
1737 if (! read_debug_ranges (unit))
1740 ranges_ptr = unit->stash->dwarf_ranges_buffer + offset;
1747 low_pc = read_address (unit, ranges_ptr);
1748 ranges_ptr += unit->addr_size;
1749 high_pc = read_address (unit, ranges_ptr);
1750 ranges_ptr += unit->addr_size;
1752 if (low_pc == 0 && high_pc == 0)
1754 if (low_pc == -1UL && high_pc != -1UL)
1755 base_address = high_pc;
1757 arange_add (unit->abfd, arange, base_address + low_pc, base_address + high_pc);
1761 /* DWARF2 Compilation unit functions. */
1763 /* Scan over each die in a comp. unit looking for functions to add
1764 to the function table and variables to the variable table. */
1767 scan_unit_for_symbols (struct comp_unit *unit)
1769 bfd *abfd = unit->abfd;
1770 bfd_byte *info_ptr = unit->first_child_die_ptr;
1771 int nesting_level = 1;
1772 struct funcinfo **nested_funcs;
1773 int nested_funcs_size;
1775 /* Maintain a stack of in-scope functions and inlined functions, which we
1776 can use to set the caller_func field. */
1777 nested_funcs_size = 32;
1778 nested_funcs = (struct funcinfo **)
1779 bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *));
1780 if (nested_funcs == NULL)
1782 nested_funcs[nesting_level] = 0;
1784 while (nesting_level)
1786 unsigned int abbrev_number, bytes_read, i;
1787 struct abbrev_info *abbrev;
1788 struct attribute attr;
1789 struct funcinfo *func;
1790 struct varinfo *var;
1792 bfd_vma high_pc = 0;
1794 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1795 info_ptr += bytes_read;
1797 if (! abbrev_number)
1803 abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
1806 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1808 bfd_set_error (bfd_error_bad_value);
1809 free (nested_funcs);
1814 if (abbrev->tag == DW_TAG_subprogram
1815 || abbrev->tag == DW_TAG_entry_point
1816 || abbrev->tag == DW_TAG_inlined_subroutine)
1818 bfd_size_type amt = sizeof (struct funcinfo);
1819 func = (struct funcinfo *) bfd_zalloc (abfd, amt);
1820 func->tag = abbrev->tag;
1821 func->prev_func = unit->function_table;
1822 unit->function_table = func;
1823 BFD_ASSERT (!unit->cached);
1825 if (func->tag == DW_TAG_inlined_subroutine)
1826 for (i = nesting_level - 1; i >= 1; i--)
1827 if (nested_funcs[i])
1829 func->caller_func = nested_funcs[i];
1832 nested_funcs[nesting_level] = func;
1837 if (abbrev->tag == DW_TAG_variable)
1839 bfd_size_type amt = sizeof (struct varinfo);
1840 var = (struct varinfo *) bfd_zalloc (abfd, amt);
1841 var->tag = abbrev->tag;
1843 var->prev_var = unit->variable_table;
1844 unit->variable_table = var;
1845 BFD_ASSERT (!unit->cached);
1848 /* No inline function in scope at this nesting level. */
1849 nested_funcs[nesting_level] = 0;
1852 for (i = 0; i < abbrev->num_attrs; ++i)
1854 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1860 case DW_AT_call_file:
1861 func->caller_file = concat_filename (unit->line_table, attr.u.val);
1864 case DW_AT_call_line:
1865 func->caller_line = attr.u.val;
1868 case DW_AT_abstract_origin:
1869 func->name = find_abstract_instance_name (unit, &attr);
1873 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
1874 if (func->name == NULL)
1875 func->name = attr.u.str;
1878 case DW_AT_MIPS_linkage_name:
1879 func->name = attr.u.str;
1883 low_pc = attr.u.val;
1887 high_pc = attr.u.val;
1891 read_rangelist (unit, &func->arange, attr.u.val);
1894 case DW_AT_decl_file:
1895 func->file = concat_filename (unit->line_table,
1899 case DW_AT_decl_line:
1900 func->line = attr.u.val;
1912 var->name = attr.u.str;
1915 case DW_AT_decl_file:
1916 var->file = concat_filename (unit->line_table,
1920 case DW_AT_decl_line:
1921 var->line = attr.u.val;
1924 case DW_AT_external:
1925 if (attr.u.val != 0)
1929 case DW_AT_location:
1933 case DW_FORM_block1:
1934 case DW_FORM_block2:
1935 case DW_FORM_block4:
1936 if (*attr.u.blk->data == DW_OP_addr)
1940 /* Verify that DW_OP_addr is the only opcode in the
1941 location, in which case the block size will be 1
1942 plus the address size. */
1943 /* ??? For TLS variables, gcc can emit
1944 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
1945 which we don't handle here yet. */
1946 if (attr.u.blk->size == unit->addr_size + 1U)
1947 var->addr = bfd_get (unit->addr_size * 8,
1949 attr.u.blk->data + 1);
1964 if (func && high_pc != 0)
1966 arange_add (unit->abfd, &func->arange, low_pc, high_pc);
1969 if (abbrev->has_children)
1973 if (nesting_level >= nested_funcs_size)
1975 struct funcinfo **tmp;
1977 nested_funcs_size *= 2;
1978 tmp = (struct funcinfo **)
1979 bfd_realloc (nested_funcs,
1980 (nested_funcs_size * sizeof (struct funcinfo *)));
1983 free (nested_funcs);
1988 nested_funcs[nesting_level] = 0;
1992 free (nested_funcs);
1996 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
1997 includes the compilation unit header that proceeds the DIE's, but
1998 does not include the length field that precedes each compilation
1999 unit header. END_PTR points one past the end of this comp unit.
2000 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
2002 This routine does not read the whole compilation unit; only enough
2003 to get to the line number information for the compilation unit. */
2005 static struct comp_unit *
2006 parse_comp_unit (struct dwarf2_debug *stash,
2007 bfd_vma unit_length,
2008 bfd_byte *info_ptr_unit,
2009 unsigned int offset_size)
2011 struct comp_unit* unit;
2012 unsigned int version;
2013 bfd_uint64_t abbrev_offset = 0;
2014 unsigned int addr_size;
2015 struct abbrev_info** abbrevs;
2016 unsigned int abbrev_number, bytes_read, i;
2017 struct abbrev_info *abbrev;
2018 struct attribute attr;
2019 bfd_byte *info_ptr = stash->info_ptr;
2020 bfd_byte *end_ptr = info_ptr + unit_length;
2023 bfd_vma high_pc = 0;
2024 bfd *abfd = stash->bfd_ptr;
2026 version = read_2_bytes (abfd, info_ptr);
2028 BFD_ASSERT (offset_size == 4 || offset_size == 8);
2029 if (offset_size == 4)
2030 abbrev_offset = read_4_bytes (abfd, info_ptr);
2032 abbrev_offset = read_8_bytes (abfd, info_ptr);
2033 info_ptr += offset_size;
2034 addr_size = read_1_byte (abfd, info_ptr);
2037 if (version != 2 && version != 3)
2039 (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 and 3 information."), version);
2040 bfd_set_error (bfd_error_bad_value);
2044 if (addr_size > sizeof (bfd_vma))
2046 (*_bfd_error_handler) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
2048 (unsigned int) sizeof (bfd_vma));
2049 bfd_set_error (bfd_error_bad_value);
2053 if (addr_size != 2 && addr_size != 4 && addr_size != 8)
2055 (*_bfd_error_handler) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size);
2056 bfd_set_error (bfd_error_bad_value);
2060 /* Read the abbrevs for this compilation unit into a table. */
2061 abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
2065 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2066 info_ptr += bytes_read;
2067 if (! abbrev_number)
2069 (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u."),
2071 bfd_set_error (bfd_error_bad_value);
2075 abbrev = lookup_abbrev (abbrev_number, abbrevs);
2078 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
2080 bfd_set_error (bfd_error_bad_value);
2084 amt = sizeof (struct comp_unit);
2085 unit = (struct comp_unit *) bfd_zalloc (abfd, amt);
2087 unit->version = version;
2088 unit->addr_size = addr_size;
2089 unit->offset_size = offset_size;
2090 unit->abbrevs = abbrevs;
2091 unit->end_ptr = end_ptr;
2092 unit->stash = stash;
2093 unit->info_ptr_unit = info_ptr_unit;
2094 unit->sec_info_ptr = stash->sec_info_ptr;
2096 for (i = 0; i < abbrev->num_attrs; ++i)
2098 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
2100 /* Store the data if it is of an attribute we want to keep in a
2101 partial symbol table. */
2104 case DW_AT_stmt_list:
2106 unit->line_offset = attr.u.val;
2110 unit->name = attr.u.str;
2114 low_pc = attr.u.val;
2115 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
2116 this is the base address to use when reading location
2117 lists or range lists. */
2118 unit->base_address = low_pc;
2122 high_pc = attr.u.val;
2126 read_rangelist (unit, &unit->arange, attr.u.val);
2129 case DW_AT_comp_dir:
2131 char *comp_dir = attr.u.str;
2134 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2135 directory, get rid of it. */
2136 char *cp = strchr (comp_dir, ':');
2138 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
2141 unit->comp_dir = comp_dir;
2151 arange_add (unit->abfd, &unit->arange, low_pc, high_pc);
2154 unit->first_child_die_ptr = info_ptr;
2158 /* Return TRUE if UNIT may contain the address given by ADDR. When
2159 there are functions written entirely with inline asm statements, the
2160 range info in the compilation unit header may not be correct. We
2161 need to consult the line info table to see if a compilation unit
2162 really contains the given address. */
2165 comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
2167 struct arange *arange;
2172 arange = &unit->arange;
2175 if (addr >= arange->low && addr < arange->high)
2177 arange = arange->next;
2184 /* If UNIT contains ADDR, set the output parameters to the values for
2185 the line containing ADDR. The output parameters, FILENAME_PTR,
2186 FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
2189 Return TRUE if UNIT contains ADDR, and no errors were encountered;
2193 comp_unit_find_nearest_line (struct comp_unit *unit,
2195 const char **filename_ptr,
2196 const char **functionname_ptr,
2197 unsigned int *linenumber_ptr,
2198 struct dwarf2_debug *stash)
2202 struct funcinfo *function;
2207 if (! unit->line_table)
2209 if (! unit->stmtlist)
2215 unit->line_table = decode_line_info (unit, stash);
2217 if (! unit->line_table)
2223 if (unit->first_child_die_ptr < unit->end_ptr
2224 && ! scan_unit_for_symbols (unit))
2232 func_p = lookup_address_in_function_table (unit, addr,
2233 &function, functionname_ptr);
2234 if (func_p && (function->tag == DW_TAG_inlined_subroutine))
2235 stash->inliner_chain = function;
2236 line_p = lookup_address_in_line_info_table (unit->line_table, addr,
2239 return line_p || func_p;
2242 /* Check to see if line info is already decoded in a comp_unit.
2243 If not, decode it. Returns TRUE if no errors were encountered;
2247 comp_unit_maybe_decode_line_info (struct comp_unit *unit,
2248 struct dwarf2_debug *stash)
2253 if (! unit->line_table)
2255 if (! unit->stmtlist)
2261 unit->line_table = decode_line_info (unit, stash);
2263 if (! unit->line_table)
2269 if (unit->first_child_die_ptr < unit->end_ptr
2270 && ! scan_unit_for_symbols (unit))
2280 /* If UNIT contains SYM at ADDR, set the output parameters to the
2281 values for the line containing SYM. The output parameters,
2282 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
2285 Return TRUE if UNIT contains SYM, and no errors were encountered;
2289 comp_unit_find_line (struct comp_unit *unit,
2292 const char **filename_ptr,
2293 unsigned int *linenumber_ptr,
2294 struct dwarf2_debug *stash)
2296 if (!comp_unit_maybe_decode_line_info (unit, stash))
2299 if (sym->flags & BSF_FUNCTION)
2300 return lookup_symbol_in_function_table (unit, sym, addr,
2304 return lookup_symbol_in_variable_table (unit, sym, addr,
2309 static struct funcinfo *
2310 reverse_funcinfo_list (struct funcinfo *head)
2312 struct funcinfo *rhead;
2313 struct funcinfo *temp;
2315 for (rhead = NULL; head; head = temp)
2317 temp = head->prev_func;
2318 head->prev_func = rhead;
2324 static struct varinfo *
2325 reverse_varinfo_list (struct varinfo *head)
2327 struct varinfo *rhead;
2328 struct varinfo *temp;
2330 for (rhead = NULL; head; head = temp)
2332 temp = head->prev_var;
2333 head->prev_var = rhead;
2339 /* Extract all interesting funcinfos and varinfos of a compilation
2340 unit into hash tables for faster lookup. Returns TRUE if no
2341 errors were enountered; FALSE otherwise. */
2344 comp_unit_hash_info (struct dwarf2_debug *stash,
2345 struct comp_unit *unit,
2346 struct info_hash_table *funcinfo_hash_table,
2347 struct info_hash_table *varinfo_hash_table)
2349 struct funcinfo* each_func;
2350 struct varinfo* each_var;
2351 bfd_boolean okay = TRUE;
2353 BFD_ASSERT (stash->info_hash_status != STASH_INFO_HASH_DISABLED);
2355 if (!comp_unit_maybe_decode_line_info (unit, stash))
2358 BFD_ASSERT (!unit->cached);
2360 /* To preserve the original search order, we went to visit the function
2361 infos in the reversed order of the list. However, making the list
2362 bi-directional use quite a bit of extra memory. So we reverse
2363 the list first, traverse the list in the now reversed order and
2364 finally reverse the list again to get back the original order. */
2365 unit->function_table = reverse_funcinfo_list (unit->function_table);
2366 for (each_func = unit->function_table;
2368 each_func = each_func->prev_func)
2370 /* Skip nameless functions. */
2371 if (each_func->name)
2372 /* There is no need to copy name string into hash table as
2373 name string is either in the dwarf string buffer or
2374 info in the stash. */
2375 okay = insert_info_hash_table (funcinfo_hash_table, each_func->name,
2376 (void*) each_func, FALSE);
2378 unit->function_table = reverse_funcinfo_list (unit->function_table);
2382 /* We do the same for variable infos. */
2383 unit->variable_table = reverse_varinfo_list (unit->variable_table);
2384 for (each_var = unit->variable_table;
2386 each_var = each_var->prev_var)
2388 /* Skip stack vars and vars with no files or names. */
2389 if (each_var->stack == 0
2390 && each_var->file != NULL
2391 && each_var->name != NULL)
2392 /* There is no need to copy name string into hash table as
2393 name string is either in the dwarf string buffer or
2394 info in the stash. */
2395 okay = insert_info_hash_table (varinfo_hash_table, each_var->name,
2396 (void*) each_var, FALSE);
2399 unit->variable_table = reverse_varinfo_list (unit->variable_table);
2400 unit->cached = TRUE;
2404 /* Locate a section in a BFD containing debugging info. The search starts
2405 from the section after AFTER_SEC, or from the first section in the BFD if
2406 AFTER_SEC is NULL. The search works by examining the names of the
2407 sections. There are two permissiable names. The first is .debug_info.
2408 This is the standard DWARF2 name. The second is a prefix .gnu.linkonce.wi.
2409 This is a variation on the .debug_info section which has a checksum
2410 describing the contents appended onto the name. This allows the linker to
2411 identify and discard duplicate debugging sections for different
2412 compilation units. */
2413 #define DWARF2_DEBUG_INFO ".debug_info"
2414 #define DWARF2_COMPRESSED_DEBUG_INFO ".zdebug_info"
2415 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
2418 find_debug_info (bfd *abfd, asection *after_sec)
2422 msec = after_sec != NULL ? after_sec->next : abfd->sections;
2426 if (strcmp (msec->name, DWARF2_DEBUG_INFO) == 0)
2429 if (strcmp (msec->name, DWARF2_COMPRESSED_DEBUG_INFO) == 0)
2432 if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
2441 /* Unset vmas for adjusted sections in STASH. */
2444 unset_sections (struct dwarf2_debug *stash)
2447 struct adjusted_section *p;
2449 i = stash->adjusted_section_count;
2450 p = stash->adjusted_sections;
2451 for (; i > 0; i--, p++)
2452 p->section->vma = 0;
2455 /* Set unique VMAs for loadable and DWARF sections in ABFD and save
2456 VMAs in STASH for unset_sections. */
2459 place_sections (bfd *abfd, struct dwarf2_debug *stash)
2461 struct adjusted_section *p;
2464 if (stash->adjusted_section_count != 0)
2466 i = stash->adjusted_section_count;
2467 p = stash->adjusted_sections;
2468 for (; i > 0; i--, p++)
2469 p->section->vma = p->adj_vma;
2474 bfd_vma last_vma = 0, last_dwarf = 0;
2476 struct adjusted_section *p;
2479 for (sect = abfd->sections; sect != NULL; sect = sect->next)
2487 /* We need to adjust the VMAs of any .debug_info sections.
2488 Skip compressed ones, since no relocations could target
2489 them - they should not appear in object files anyway. */
2490 if (strcmp (sect->name, DWARF2_DEBUG_INFO) == 0)
2492 else if (CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO))
2497 if (!is_debug_info && (sect->flags & SEC_LOAD) == 0)
2500 sz = sect->rawsize ? sect->rawsize : sect->size;
2507 amt = i * sizeof (struct adjusted_section);
2508 p = (struct adjusted_section *) bfd_zalloc (abfd, amt);
2512 stash->adjusted_sections = p;
2513 stash->adjusted_section_count = i;
2515 for (sect = abfd->sections; sect != NULL; sect = sect->next)
2523 /* We need to adjust the VMAs of any .debug_info sections.
2524 Skip compressed ones, since no relocations could target
2525 them - they should not appear in object files anyway. */
2526 if (strcmp (sect->name, DWARF2_DEBUG_INFO) == 0)
2528 else if (CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO))
2533 if (!is_debug_info && (sect->flags & SEC_LOAD) == 0)
2536 sz = sect->rawsize ? sect->rawsize : sect->size;
2543 BFD_ASSERT (sect->alignment_power == 0);
2544 sect->vma = last_dwarf;
2547 else if (last_vma != 0)
2549 /* Align the new address to the current section
2551 last_vma = ((last_vma
2552 + ~((bfd_vma) -1 << sect->alignment_power))
2553 & ((bfd_vma) -1 << sect->alignment_power));
2554 sect->vma = last_vma;
2555 last_vma += sect->vma + sz;
2558 last_vma += sect->vma + sz;
2560 p->adj_vma = sect->vma;
2569 /* Look up a funcinfo by name using the given info hash table. If found,
2570 also update the locations pointed to by filename_ptr and linenumber_ptr.
2572 This function returns TRUE if a funcinfo that matches the given symbol
2573 and address is found with any error; otherwise it returns FALSE. */
2576 info_hash_lookup_funcinfo (struct info_hash_table *hash_table,
2579 const char **filename_ptr,
2580 unsigned int *linenumber_ptr)
2582 struct funcinfo* each_func;
2583 struct funcinfo* best_fit = NULL;
2584 struct info_list_node *node;
2585 struct arange *arange;
2586 const char *name = bfd_asymbol_name (sym);
2587 asection *sec = bfd_get_section (sym);
2589 for (node = lookup_info_hash_table (hash_table, name);
2593 each_func = (struct funcinfo *) node->info;
2594 for (arange = &each_func->arange;
2596 arange = arange->next)
2598 if ((!each_func->sec || each_func->sec == sec)
2599 && addr >= arange->low
2600 && addr < arange->high
2602 || ((arange->high - arange->low)
2603 < (best_fit->arange.high - best_fit->arange.low))))
2604 best_fit = each_func;
2610 best_fit->sec = sec;
2611 *filename_ptr = best_fit->file;
2612 *linenumber_ptr = best_fit->line;
2619 /* Look up a varinfo by name using the given info hash table. If found,
2620 also update the locations pointed to by filename_ptr and linenumber_ptr.
2622 This function returns TRUE if a varinfo that matches the given symbol
2623 and address is found with any error; otherwise it returns FALSE. */
2626 info_hash_lookup_varinfo (struct info_hash_table *hash_table,
2629 const char **filename_ptr,
2630 unsigned int *linenumber_ptr)
2632 const char *name = bfd_asymbol_name (sym);
2633 asection *sec = bfd_get_section (sym);
2634 struct varinfo* each;
2635 struct info_list_node *node;
2637 for (node = lookup_info_hash_table (hash_table, name);
2641 each = (struct varinfo *) node->info;
2642 if (each->addr == addr
2643 && (!each->sec || each->sec == sec))
2646 *filename_ptr = each->file;
2647 *linenumber_ptr = each->line;
2655 /* Update the funcinfo and varinfo info hash tables if they are
2656 not up to date. Returns TRUE if there is no error; otherwise
2657 returns FALSE and disable the info hash tables. */
2660 stash_maybe_update_info_hash_tables (struct dwarf2_debug *stash)
2662 struct comp_unit *each;
2664 /* Exit if hash tables are up-to-date. */
2665 if (stash->all_comp_units == stash->hash_units_head)
2668 if (stash->hash_units_head)
2669 each = stash->hash_units_head->prev_unit;
2671 each = stash->last_comp_unit;
2675 if (!comp_unit_hash_info (stash, each, stash->funcinfo_hash_table,
2676 stash->varinfo_hash_table))
2678 stash->info_hash_status = STASH_INFO_HASH_DISABLED;
2681 each = each->prev_unit;
2684 stash->hash_units_head = stash->all_comp_units;
2688 /* Check consistency of info hash tables. This is for debugging only. */
2690 static void ATTRIBUTE_UNUSED
2691 stash_verify_info_hash_table (struct dwarf2_debug *stash)
2693 struct comp_unit *each_unit;
2694 struct funcinfo *each_func;
2695 struct varinfo *each_var;
2696 struct info_list_node *node;
2699 for (each_unit = stash->all_comp_units;
2701 each_unit = each_unit->next_unit)
2703 for (each_func = each_unit->function_table;
2705 each_func = each_func->prev_func)
2707 if (!each_func->name)
2709 node = lookup_info_hash_table (stash->funcinfo_hash_table,
2713 while (node && !found)
2715 found = node->info == each_func;
2721 for (each_var = each_unit->variable_table;
2723 each_var = each_var->prev_var)
2725 if (!each_var->name || !each_var->file || each_var->stack)
2727 node = lookup_info_hash_table (stash->varinfo_hash_table,
2731 while (node && !found)
2733 found = node->info == each_var;
2741 /* Check to see if we want to enable the info hash tables, which consume
2742 quite a bit of memory. Currently we only check the number times
2743 bfd_dwarf2_find_line is called. In the future, we may also want to
2744 take the number of symbols into account. */
2747 stash_maybe_enable_info_hash_tables (bfd *abfd, struct dwarf2_debug *stash)
2749 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_OFF);
2751 if (stash->info_hash_count++ < STASH_INFO_HASH_TRIGGER)
2754 /* FIXME: Maybe we should check the reduce_memory_overheads
2755 and optimize fields in the bfd_link_info structure ? */
2757 /* Create hash tables. */
2758 stash->funcinfo_hash_table = create_info_hash_table (abfd);
2759 stash->varinfo_hash_table = create_info_hash_table (abfd);
2760 if (!stash->funcinfo_hash_table || !stash->varinfo_hash_table)
2762 /* Turn off info hashes if any allocation above fails. */
2763 stash->info_hash_status = STASH_INFO_HASH_DISABLED;
2766 /* We need a forced update so that the info hash tables will
2767 be created even though there is no compilation unit. That
2768 happens if STASH_INFO_HASH_TRIGGER is 0. */
2769 stash_maybe_update_info_hash_tables (stash);
2770 stash->info_hash_status = STASH_INFO_HASH_ON;
2773 /* Find the file and line associated with a symbol and address using the
2774 info hash tables of a stash. If there is a match, the function returns
2775 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
2776 otherwise it returns FALSE. */
2779 stash_find_line_fast (struct dwarf2_debug *stash,
2782 const char **filename_ptr,
2783 unsigned int *linenumber_ptr)
2785 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_ON);
2787 if (sym->flags & BSF_FUNCTION)
2788 return info_hash_lookup_funcinfo (stash->funcinfo_hash_table, sym, addr,
2789 filename_ptr, linenumber_ptr);
2790 return info_hash_lookup_varinfo (stash->varinfo_hash_table, sym, addr,
2791 filename_ptr, linenumber_ptr);
2794 /* Find the source code location of SYMBOL. If SYMBOL is NULL
2795 then find the nearest source code location corresponding to
2796 the address SECTION + OFFSET.
2797 Returns TRUE if the line is found without error and fills in
2798 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
2799 NULL the FUNCTIONNAME_PTR is also filled in.
2800 SYMBOLS contains the symbol table for ABFD.
2801 ADDR_SIZE is the number of bytes in the initial .debug_info length
2802 field and in the abbreviation offset, or zero to indicate that the
2803 default value should be used. */
2806 find_line (bfd *abfd,
2811 const char **filename_ptr,
2812 const char **functionname_ptr,
2813 unsigned int *linenumber_ptr,
2814 unsigned int addr_size,
2817 /* Read each compilation unit from the section .debug_info, and check
2818 to see if it contains the address we are searching for. If yes,
2819 lookup the address, and return the line number info. If no, go
2820 on to the next compilation unit.
2822 We keep a list of all the previously read compilation units, and
2823 a pointer to the next un-read compilation unit. Check the
2824 previously read units before reading more. */
2825 struct dwarf2_debug *stash;
2826 /* What address are we looking for? */
2828 struct comp_unit* each;
2829 bfd_vma found = FALSE;
2830 bfd_boolean do_line;
2832 stash = (struct dwarf2_debug *) *pinfo;
2836 bfd_size_type amt = sizeof (struct dwarf2_debug);
2838 stash = (struct dwarf2_debug *) bfd_zalloc (abfd, amt);
2843 /* In a relocatable file, 2 functions may have the same address.
2844 We change the section vma so that they won't overlap. */
2845 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
2847 if (! place_sections (abfd, stash))
2851 do_line = (section == NULL
2853 && functionname_ptr == NULL
2857 addr = symbol->value;
2858 section = bfd_get_section (symbol);
2860 else if (section != NULL
2861 && functionname_ptr != NULL
2867 if (section->output_section)
2868 addr += section->output_section->vma + section->output_offset;
2870 addr += section->vma;
2871 *filename_ptr = NULL;
2873 *functionname_ptr = NULL;
2874 *linenumber_ptr = 0;
2879 bfd_size_type total_size;
2884 msec = find_debug_info (abfd, NULL);
2887 char * debug_filename = bfd_follow_gnu_debuglink (abfd, DEBUGDIR);
2889 if (debug_filename == NULL)
2890 /* No dwarf2 info, and no gnu_debuglink to follow.
2891 Note that at this point the stash has been allocated, but
2892 contains zeros. This lets future calls to this function
2893 fail more quickly. */
2896 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
2897 || ! bfd_check_format (debug_bfd, bfd_object)
2898 || (msec = find_debug_info (debug_bfd, NULL)) == NULL)
2901 bfd_close (debug_bfd);
2902 /* FIXME: Should we report our failure to follow the debuglink ? */
2903 free (debug_filename);
2910 /* There can be more than one DWARF2 info section in a BFD these
2911 days. First handle the easy case when there's only one. If
2912 there's more than one, try case two: none of the sections is
2913 compressed. In that case, read them all in and produce one
2914 large stash. We do this in two passes - in the first pass we
2915 just accumulate the section sizes, and in the second pass we
2916 read in the section's contents. (The allows us to avoid
2917 reallocing the data as we add sections to the stash.) If
2918 some or all sections are compressed, then do things the slow
2919 way, with a bunch of reallocs. */
2921 if (! find_debug_info (debug_bfd, msec))
2923 /* Case 1: only one info section. */
2924 total_size = msec->size;
2925 if (! read_section (debug_bfd, ".debug_info", ".zdebug_info",
2927 &stash->info_ptr_memory, &total_size))
2932 int all_uncompressed = 1;
2933 for (total_size = 0; msec; msec = find_debug_info (debug_bfd, msec))
2935 total_size += msec->size;
2936 if (strcmp (msec->name, DWARF2_COMPRESSED_DEBUG_INFO) == 0)
2937 all_uncompressed = 0;
2939 if (all_uncompressed)
2941 /* Case 2: multiple sections, but none is compressed. */
2942 stash->info_ptr_memory = (bfd_byte *) bfd_malloc (total_size);
2943 if (stash->info_ptr_memory == NULL)
2947 for (msec = find_debug_info (debug_bfd, NULL);
2949 msec = find_debug_info (debug_bfd, msec))
2957 if (!(bfd_simple_get_relocated_section_contents
2958 (debug_bfd, msec, stash->info_ptr_memory + total_size,
2967 /* Case 3: multiple sections, some or all compressed. */
2968 stash->info_ptr_memory = NULL;
2970 for (msec = find_debug_info (debug_bfd, NULL);
2972 msec = find_debug_info (debug_bfd, msec))
2974 bfd_size_type size = msec->size;
2980 buffer = (bfd_simple_get_relocated_section_contents
2981 (debug_bfd, msec, NULL, symbols));
2985 if (strcmp (msec->name, DWARF2_COMPRESSED_DEBUG_INFO) == 0)
2987 if (! bfd_uncompress_section_contents (&buffer, &size))
2993 stash->info_ptr_memory = (bfd_byte *)
2994 bfd_realloc (stash->info_ptr_memory, total_size + size);
2995 memcpy (stash->info_ptr_memory + total_size, buffer, size);
3002 stash->info_ptr = stash->info_ptr_memory;
3003 stash->info_ptr_end = stash->info_ptr + total_size;
3004 stash->sec = find_debug_info (debug_bfd, NULL);
3005 stash->sec_info_ptr = stash->info_ptr;
3006 stash->syms = symbols;
3007 stash->bfd_ptr = debug_bfd;
3010 /* A null info_ptr indicates that there is no dwarf2 info
3011 (or that an error occured while setting up the stash). */
3012 if (! stash->info_ptr)
3015 stash->inliner_chain = NULL;
3017 /* Check the previously read comp. units first. */
3020 /* The info hash tables use quite a bit of memory. We may not want to
3021 always use them. We use some heuristics to decide if and when to
3023 if (stash->info_hash_status == STASH_INFO_HASH_OFF)
3024 stash_maybe_enable_info_hash_tables (abfd, stash);
3026 /* Keep info hash table up to date if they are available. Note that we
3027 may disable the hash tables if there is any error duing update. */
3028 if (stash->info_hash_status == STASH_INFO_HASH_ON)
3029 stash_maybe_update_info_hash_tables (stash);
3031 if (stash->info_hash_status == STASH_INFO_HASH_ON)
3033 found = stash_find_line_fast (stash, symbol, addr, filename_ptr,
3040 /* Check the previously read comp. units first. */
3041 for (each = stash->all_comp_units; each; each = each->next_unit)
3042 if ((symbol->flags & BSF_FUNCTION) == 0
3043 || comp_unit_contains_address (each, addr))
3045 found = comp_unit_find_line (each, symbol, addr, filename_ptr,
3046 linenumber_ptr, stash);
3054 for (each = stash->all_comp_units; each; each = each->next_unit)
3056 found = (comp_unit_contains_address (each, addr)
3057 && comp_unit_find_nearest_line (each, addr,
3067 /* The DWARF2 spec says that the initial length field, and the
3068 offset of the abbreviation table, should both be 4-byte values.
3069 However, some compilers do things differently. */
3072 BFD_ASSERT (addr_size == 4 || addr_size == 8);
3074 /* Read each remaining comp. units checking each as they are read. */
3075 while (stash->info_ptr < stash->info_ptr_end)
3078 unsigned int offset_size = addr_size;
3079 bfd_byte *info_ptr_unit = stash->info_ptr;
3081 length = read_4_bytes (stash->bfd_ptr, stash->info_ptr);
3082 /* A 0xffffff length is the DWARF3 way of indicating
3083 we use 64-bit offsets, instead of 32-bit offsets. */
3084 if (length == 0xffffffff)
3087 length = read_8_bytes (stash->bfd_ptr, stash->info_ptr + 4);
3088 stash->info_ptr += 12;
3090 /* A zero length is the IRIX way of indicating 64-bit offsets,
3091 mostly because the 64-bit length will generally fit in 32
3092 bits, and the endianness helps. */
3093 else if (length == 0)
3096 length = read_4_bytes (stash->bfd_ptr, stash->info_ptr + 4);
3097 stash->info_ptr += 8;
3099 /* In the absence of the hints above, we assume 32-bit DWARF2
3100 offsets even for targets with 64-bit addresses, because:
3101 a) most of the time these targets will not have generated
3102 more than 2Gb of debug info and so will not need 64-bit
3105 b) if they do use 64-bit offsets but they are not using
3106 the size hints that are tested for above then they are
3107 not conforming to the DWARF3 standard anyway. */
3108 else if (addr_size == 8)
3111 stash->info_ptr += 4;
3114 stash->info_ptr += 4;
3118 each = parse_comp_unit (stash, length, info_ptr_unit,
3121 /* The dwarf information is damaged, don't trust it any
3124 stash->info_ptr += length;
3126 if (stash->all_comp_units)
3127 stash->all_comp_units->prev_unit = each;
3129 stash->last_comp_unit = each;
3131 each->next_unit = stash->all_comp_units;
3132 stash->all_comp_units = each;
3134 /* DW_AT_low_pc and DW_AT_high_pc are optional for
3135 compilation units. If we don't have them (i.e.,
3136 unit->high == 0), we need to consult the line info table
3137 to see if a compilation unit contains the given
3140 found = (((symbol->flags & BSF_FUNCTION) == 0
3141 || each->arange.high == 0
3142 || comp_unit_contains_address (each, addr))
3143 && comp_unit_find_line (each, symbol, addr,
3148 found = ((each->arange.high == 0
3149 || comp_unit_contains_address (each, addr))
3150 && comp_unit_find_nearest_line (each, addr,
3156 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
3157 == stash->sec->size)
3159 stash->sec = find_debug_info (stash->bfd_ptr, stash->sec);
3160 stash->sec_info_ptr = stash->info_ptr;
3169 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
3170 unset_sections (stash);
3175 /* The DWARF2 version of find_nearest_line.
3176 Return TRUE if the line is found without error. */
3179 _bfd_dwarf2_find_nearest_line (bfd *abfd,
3183 const char **filename_ptr,
3184 const char **functionname_ptr,
3185 unsigned int *linenumber_ptr,
3186 unsigned int addr_size,
3189 return find_line (abfd, section, offset, NULL, symbols, filename_ptr,
3190 functionname_ptr, linenumber_ptr, addr_size,
3194 /* The DWARF2 version of find_line.
3195 Return TRUE if the line is found without error. */
3198 _bfd_dwarf2_find_line (bfd *abfd,
3201 const char **filename_ptr,
3202 unsigned int *linenumber_ptr,
3203 unsigned int addr_size,
3206 return find_line (abfd, NULL, 0, symbol, symbols, filename_ptr,
3207 NULL, linenumber_ptr, addr_size,
3212 _bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED,
3213 const char **filename_ptr,
3214 const char **functionname_ptr,
3215 unsigned int *linenumber_ptr,
3218 struct dwarf2_debug *stash;
3220 stash = (struct dwarf2_debug *) *pinfo;
3223 struct funcinfo *func = stash->inliner_chain;
3225 if (func && func->caller_func)
3227 *filename_ptr = func->caller_file;
3228 *functionname_ptr = func->caller_func->name;
3229 *linenumber_ptr = func->caller_line;
3230 stash->inliner_chain = func->caller_func;
3239 _bfd_dwarf2_cleanup_debug_info (bfd *abfd)
3241 struct comp_unit *each;
3242 struct dwarf2_debug *stash;
3244 if (abfd == NULL || elf_tdata (abfd) == NULL)
3247 stash = (struct dwarf2_debug *) elf_tdata (abfd)->dwarf2_find_line_info;
3252 for (each = stash->all_comp_units; each; each = each->next_unit)
3254 struct abbrev_info **abbrevs = each->abbrevs;
3255 struct funcinfo *function_table = each->function_table;
3256 struct varinfo *variable_table = each->variable_table;
3259 for (i = 0; i < ABBREV_HASH_SIZE; i++)
3261 struct abbrev_info *abbrev = abbrevs[i];
3265 free (abbrev->attrs);
3266 abbrev = abbrev->next;
3270 if (each->line_table)
3272 free (each->line_table->dirs);
3273 free (each->line_table->files);
3276 while (function_table)
3278 if (function_table->file)
3280 free (function_table->file);
3281 function_table->file = NULL;
3284 if (function_table->caller_file)
3286 free (function_table->caller_file);
3287 function_table->caller_file = NULL;
3289 function_table = function_table->prev_func;
3292 while (variable_table)
3294 if (variable_table->file)
3296 free (variable_table->file);
3297 variable_table->file = NULL;
3300 variable_table = variable_table->prev_var;
3304 if (stash->dwarf_abbrev_buffer)
3305 free (stash->dwarf_abbrev_buffer);
3306 if (stash->dwarf_line_buffer)
3307 free (stash->dwarf_line_buffer);
3308 if (stash->dwarf_str_buffer)
3309 free (stash->dwarf_str_buffer);
3310 if (stash->dwarf_ranges_buffer)
3311 free (stash->dwarf_ranges_buffer);
3312 if (stash->info_ptr_memory)
3313 free (stash->info_ptr_memory);