2 Copyright (C) 1994-2015 Free Software Foundation, Inc.
4 Adapted from gdb/dwarf2read.c by Gavin Koch of Cygnus Solutions
7 From the dwarf2read.c header:
8 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
9 Inc. with support from Florida State University (under contract
10 with the Ada Joint Program Office), and Silicon Graphics, Inc.
11 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
12 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
13 support in dwarfread.c
15 This file is part of BFD.
17 This program is free software; you can redistribute it and/or modify
18 it under the terms of the GNU General Public License as published by
19 the Free Software Foundation; either version 3 of the License, or (at
20 your option) any later version.
22 This program is distributed in the hope that it will be useful, but
23 WITHOUT ANY WARRANTY; without even the implied warranty of
24 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
25 General Public License for more details.
27 You should have received a copy of the GNU General Public License
28 along with this program; if not, write to the Free Software
29 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
30 MA 02110-1301, USA. */
34 #include "libiberty.h"
39 /* The data in the .debug_line statement prologue looks like this. */
44 unsigned short version;
45 bfd_vma prologue_length;
46 unsigned char minimum_instruction_length;
47 unsigned char maximum_ops_per_insn;
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 /* Names of the debug sections. */
93 const struct dwarf_debug_section *debug_sections;
95 /* The next unread compilation unit within the .debug_info section.
96 Zero indicates that the .debug_info section has not been loaded
100 /* Pointer to the end of the .debug_info section memory buffer. */
101 bfd_byte *info_ptr_end;
103 /* Pointer to the bfd, section and address of the beginning of the
104 section. The bfd might be different than expected because of
105 gnu_debuglink sections. */
108 bfd_byte *sec_info_ptr;
110 /* Support for alternate debug info sections created by the DWZ utility:
111 This includes a pointer to an alternate bfd which contains *extra*,
112 possibly duplicate debug sections, and pointers to the loaded
113 .debug_str and .debug_info sections from this bfd. */
115 bfd_byte * alt_dwarf_str_buffer;
116 bfd_size_type alt_dwarf_str_size;
117 bfd_byte * alt_dwarf_info_buffer;
118 bfd_size_type alt_dwarf_info_size;
120 /* A pointer to the memory block allocated for info_ptr. Neither
121 info_ptr nor sec_info_ptr are guaranteed to stay pointing to the
122 beginning of the malloc block. This is used only to free the
124 bfd_byte *info_ptr_memory;
126 /* Pointer to the symbol table. */
129 /* Pointer to the .debug_abbrev section loaded into memory. */
130 bfd_byte *dwarf_abbrev_buffer;
132 /* Length of the loaded .debug_abbrev section. */
133 bfd_size_type dwarf_abbrev_size;
135 /* Buffer for decode_line_info. */
136 bfd_byte *dwarf_line_buffer;
138 /* Length of the loaded .debug_line section. */
139 bfd_size_type dwarf_line_size;
141 /* Pointer to the .debug_str section loaded into memory. */
142 bfd_byte *dwarf_str_buffer;
144 /* Length of the loaded .debug_str section. */
145 bfd_size_type dwarf_str_size;
147 /* Pointer to the .debug_ranges section loaded into memory. */
148 bfd_byte *dwarf_ranges_buffer;
150 /* Length of the loaded .debug_ranges section. */
151 bfd_size_type dwarf_ranges_size;
153 /* If the most recent call to bfd_find_nearest_line was given an
154 address in an inlined function, preserve a pointer into the
155 calling chain for subsequent calls to bfd_find_inliner_info to
157 struct funcinfo *inliner_chain;
159 /* Section VMAs at the time the stash was built. */
162 /* Number of sections whose VMA we must adjust. */
163 int adjusted_section_count;
165 /* Array of sections with adjusted VMA. */
166 struct adjusted_section *adjusted_sections;
168 /* Number of times find_line is called. This is used in
169 the heuristic for enabling the info hash tables. */
172 #define STASH_INFO_HASH_TRIGGER 100
174 /* Hash table mapping symbol names to function infos. */
175 struct info_hash_table *funcinfo_hash_table;
177 /* Hash table mapping symbol names to variable infos. */
178 struct info_hash_table *varinfo_hash_table;
180 /* Head of comp_unit list in the last hash table update. */
181 struct comp_unit *hash_units_head;
183 /* Status of info hash. */
184 int info_hash_status;
185 #define STASH_INFO_HASH_OFF 0
186 #define STASH_INFO_HASH_ON 1
187 #define STASH_INFO_HASH_DISABLED 2
189 /* True if we opened bfd_ptr. */
190 bfd_boolean close_on_cleanup;
200 /* A minimal decoding of DWARF2 compilation units. We only decode
201 what's needed to get to the line number information. */
205 /* Chain the previously read compilation units. */
206 struct comp_unit *next_unit;
208 /* Likewise, chain the compilation unit read after this one.
209 The comp units are stored in reversed reading order. */
210 struct comp_unit *prev_unit;
212 /* Keep the bfd convenient (for memory allocation). */
215 /* The lowest and highest addresses contained in this compilation
216 unit as specified in the compilation unit header. */
217 struct arange arange;
219 /* The DW_AT_name attribute (for error messages). */
222 /* The abbrev hash table. */
223 struct abbrev_info **abbrevs;
225 /* DW_AT_language. */
228 /* Note that an error was found by comp_unit_find_nearest_line. */
231 /* The DW_AT_comp_dir attribute. */
234 /* TRUE if there is a line number table associated with this comp. unit. */
237 /* Pointer to the current comp_unit so that we can find a given entry
239 bfd_byte *info_ptr_unit;
241 /* Pointer to the start of the debug section, for DW_FORM_ref_addr. */
242 bfd_byte *sec_info_ptr;
244 /* The offset into .debug_line of the line number table. */
245 unsigned long line_offset;
247 /* Pointer to the first child die for the comp unit. */
248 bfd_byte *first_child_die_ptr;
250 /* The end of the comp unit. */
253 /* The decoded line number, NULL if not yet decoded. */
254 struct line_info_table *line_table;
256 /* A list of the functions found in this comp. unit. */
257 struct funcinfo *function_table;
259 /* A list of the variables found in this comp. unit. */
260 struct varinfo *variable_table;
262 /* Pointer to dwarf2_debug structure. */
263 struct dwarf2_debug *stash;
265 /* DWARF format version for this unit - from unit header. */
268 /* Address size for this unit - from unit header. */
269 unsigned char addr_size;
271 /* Offset size for this unit - from unit header. */
272 unsigned char offset_size;
274 /* Base address for this unit - from DW_AT_low_pc attribute of
275 DW_TAG_compile_unit DIE */
276 bfd_vma base_address;
278 /* TRUE if symbols are cached in hash table for faster lookup by name. */
282 /* This data structure holds the information of an abbrev. */
285 unsigned int number; /* Number identifying abbrev. */
286 enum dwarf_tag tag; /* DWARF tag. */
287 int has_children; /* Boolean. */
288 unsigned int num_attrs; /* Number of attributes. */
289 struct attr_abbrev *attrs; /* An array of attribute descriptions. */
290 struct abbrev_info *next; /* Next in chain. */
295 enum dwarf_attribute name;
296 enum dwarf_form form;
299 /* Map of uncompressed DWARF debug section name to compressed one. It
300 is terminated by NULL uncompressed_name. */
302 const struct dwarf_debug_section dwarf_debug_sections[] =
304 { ".debug_abbrev", ".zdebug_abbrev" },
305 { ".debug_aranges", ".zdebug_aranges" },
306 { ".debug_frame", ".zdebug_frame" },
307 { ".debug_info", ".zdebug_info" },
308 { ".debug_info", ".zdebug_info" },
309 { ".debug_line", ".zdebug_line" },
310 { ".debug_loc", ".zdebug_loc" },
311 { ".debug_macinfo", ".zdebug_macinfo" },
312 { ".debug_macro", ".zdebug_macro" },
313 { ".debug_pubnames", ".zdebug_pubnames" },
314 { ".debug_pubtypes", ".zdebug_pubtypes" },
315 { ".debug_ranges", ".zdebug_ranges" },
316 { ".debug_static_func", ".zdebug_static_func" },
317 { ".debug_static_vars", ".zdebug_static_vars" },
318 { ".debug_str", ".zdebug_str", },
319 { ".debug_str", ".zdebug_str", },
320 { ".debug_types", ".zdebug_types" },
321 /* GNU DWARF 1 extensions */
322 { ".debug_sfnames", ".zdebug_sfnames" },
323 { ".debug_srcinfo", ".zebug_srcinfo" },
324 /* SGI/MIPS DWARF 2 extensions */
325 { ".debug_funcnames", ".zdebug_funcnames" },
326 { ".debug_typenames", ".zdebug_typenames" },
327 { ".debug_varnames", ".zdebug_varnames" },
328 { ".debug_weaknames", ".zdebug_weaknames" },
332 /* NB/ Numbers in this enum must match up with indicies
333 into the dwarf_debug_sections[] array above. */
334 enum dwarf_debug_section_enum
361 #ifndef ABBREV_HASH_SIZE
362 #define ABBREV_HASH_SIZE 121
364 #ifndef ATTR_ALLOC_CHUNK
365 #define ATTR_ALLOC_CHUNK 4
368 /* Variable and function hash tables. This is used to speed up look-up
369 in lookup_symbol_in_var_table() and lookup_symbol_in_function_table().
370 In order to share code between variable and function infos, we use
371 a list of untyped pointer for all variable/function info associated with
372 a symbol. We waste a bit of memory for list with one node but that
373 simplifies the code. */
375 struct info_list_node
377 struct info_list_node *next;
381 /* Info hash entry. */
382 struct info_hash_entry
384 struct bfd_hash_entry root;
385 struct info_list_node *head;
388 struct info_hash_table
390 struct bfd_hash_table base;
393 /* Function to create a new entry in info hash table. */
395 static struct bfd_hash_entry *
396 info_hash_table_newfunc (struct bfd_hash_entry *entry,
397 struct bfd_hash_table *table,
400 struct info_hash_entry *ret = (struct info_hash_entry *) entry;
402 /* Allocate the structure if it has not already been allocated by a
406 ret = (struct info_hash_entry *) bfd_hash_allocate (table,
412 /* Call the allocation method of the base class. */
413 ret = ((struct info_hash_entry *)
414 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
416 /* Initialize the local fields here. */
420 return (struct bfd_hash_entry *) ret;
423 /* Function to create a new info hash table. It returns a pointer to the
424 newly created table or NULL if there is any error. We need abfd
425 solely for memory allocation. */
427 static struct info_hash_table *
428 create_info_hash_table (bfd *abfd)
430 struct info_hash_table *hash_table;
432 hash_table = ((struct info_hash_table *)
433 bfd_alloc (abfd, sizeof (struct info_hash_table)));
437 if (!bfd_hash_table_init (&hash_table->base, info_hash_table_newfunc,
438 sizeof (struct info_hash_entry)))
440 bfd_release (abfd, hash_table);
447 /* Insert an info entry into an info hash table. We do not check of
448 duplicate entries. Also, the caller need to guarantee that the
449 right type of info in inserted as info is passed as a void* pointer.
450 This function returns true if there is no error. */
453 insert_info_hash_table (struct info_hash_table *hash_table,
458 struct info_hash_entry *entry;
459 struct info_list_node *node;
461 entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base,
466 node = (struct info_list_node *) bfd_hash_allocate (&hash_table->base,
472 node->next = entry->head;
478 /* Look up an info entry list from an info hash table. Return NULL
481 static struct info_list_node *
482 lookup_info_hash_table (struct info_hash_table *hash_table, const char *key)
484 struct info_hash_entry *entry;
486 entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base, key,
488 return entry ? entry->head : NULL;
491 /* Read a section into its appropriate place in the dwarf2_debug
492 struct (indicated by SECTION_BUFFER and SECTION_SIZE). If SYMS is
493 not NULL, use bfd_simple_get_relocated_section_contents to read the
494 section contents, otherwise use bfd_get_section_contents. Fail if
495 the located section does not contain at least OFFSET bytes. */
498 read_section (bfd * abfd,
499 const struct dwarf_debug_section *sec,
502 bfd_byte ** section_buffer,
503 bfd_size_type * section_size)
506 const char *section_name = sec->uncompressed_name;
508 /* The section may have already been read. */
509 if (*section_buffer == NULL)
511 msec = bfd_get_section_by_name (abfd, section_name);
514 section_name = sec->compressed_name;
515 if (section_name != NULL)
516 msec = bfd_get_section_by_name (abfd, section_name);
520 (*_bfd_error_handler) (_("Dwarf Error: Can't find %s section."),
521 sec->uncompressed_name);
522 bfd_set_error (bfd_error_bad_value);
526 *section_size = msec->rawsize ? msec->rawsize : msec->size;
530 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL, syms);
531 if (! *section_buffer)
536 *section_buffer = (bfd_byte *) bfd_malloc (*section_size);
537 if (! *section_buffer)
539 if (! bfd_get_section_contents (abfd, msec, *section_buffer,
545 /* It is possible to get a bad value for the offset into the section
546 that the client wants. Validate it here to avoid trouble later. */
547 if (offset != 0 && offset >= *section_size)
549 (*_bfd_error_handler) (_("Dwarf Error: Offset (%lu)"
550 " greater than or equal to %s size (%lu)."),
551 (long) offset, section_name, *section_size);
552 bfd_set_error (bfd_error_bad_value);
559 /* Read dwarf information from a buffer. */
562 read_1_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf, bfd_byte *end)
566 return bfd_get_8 (abfd, buf);
570 read_1_signed_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf, bfd_byte *end)
574 return bfd_get_signed_8 (abfd, buf);
578 read_2_bytes (bfd *abfd, bfd_byte *buf, bfd_byte *end)
582 return bfd_get_16 (abfd, buf);
586 read_4_bytes (bfd *abfd, bfd_byte *buf, bfd_byte *end)
590 return bfd_get_32 (abfd, buf);
594 read_8_bytes (bfd *abfd, bfd_byte *buf, bfd_byte *end)
598 return bfd_get_64 (abfd, buf);
602 read_n_bytes (bfd *abfd ATTRIBUTE_UNUSED,
605 unsigned int size ATTRIBUTE_UNUSED)
607 if (buf + size > end)
612 /* Scans a NUL terminated string starting at BUF, returning a pointer to it.
613 Returns the number of characters in the string, *including* the NUL byte,
614 in BYTES_READ_PTR. This value is set even if the function fails. Bytes
615 at or beyond BUF_END will not be read. Returns NULL if there was a
616 problem, or if the string is empty. */
619 read_string (bfd * abfd ATTRIBUTE_UNUSED,
622 unsigned int * bytes_read_ptr)
628 * bytes_read_ptr = 0;
634 * bytes_read_ptr = 1;
638 while (buf < buf_end)
641 * bytes_read_ptr = buf - str;
645 * bytes_read_ptr = buf - str;
649 /* Reads an offset from BUF and then locates the string at this offset
650 inside the debug string section. Returns a pointer to the string.
651 Returns the number of bytes read from BUF, *not* the length of the string,
652 in BYTES_READ_PTR. This value is set even if the function fails. Bytes
653 at or beyond BUF_END will not be read from BUF. Returns NULL if there was
654 a problem, or if the string is empty. Does not check for NUL termination
658 read_indirect_string (struct comp_unit * unit,
661 unsigned int * bytes_read_ptr)
664 struct dwarf2_debug *stash = unit->stash;
667 if (buf + unit->offset_size > buf_end)
669 * bytes_read_ptr = 0;
673 if (unit->offset_size == 4)
674 offset = read_4_bytes (unit->abfd, buf, buf_end);
676 offset = read_8_bytes (unit->abfd, buf, buf_end);
678 *bytes_read_ptr = unit->offset_size;
680 if (! read_section (unit->abfd, &stash->debug_sections[debug_str],
682 &stash->dwarf_str_buffer, &stash->dwarf_str_size))
685 if (offset >= stash->dwarf_str_size)
687 str = (char *) stash->dwarf_str_buffer + offset;
693 /* Like read_indirect_string but uses a .debug_str located in
694 an alternate file pointed to by the .gnu_debugaltlink section.
695 Used to impement DW_FORM_GNU_strp_alt. */
698 read_alt_indirect_string (struct comp_unit * unit,
701 unsigned int * bytes_read_ptr)
704 struct dwarf2_debug *stash = unit->stash;
707 if (buf + unit->offset_size > buf_end)
709 * bytes_read_ptr = 0;
713 if (unit->offset_size == 4)
714 offset = read_4_bytes (unit->abfd, buf, buf_end);
716 offset = read_8_bytes (unit->abfd, buf, buf_end);
718 *bytes_read_ptr = unit->offset_size;
720 if (stash->alt_bfd_ptr == NULL)
723 char * debug_filename = bfd_follow_gnu_debugaltlink (unit->abfd, DEBUGDIR);
725 if (debug_filename == NULL)
728 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
729 || ! bfd_check_format (debug_bfd, bfd_object))
732 bfd_close (debug_bfd);
734 /* FIXME: Should we report our failure to follow the debuglink ? */
735 free (debug_filename);
738 stash->alt_bfd_ptr = debug_bfd;
741 if (! read_section (unit->stash->alt_bfd_ptr,
742 stash->debug_sections + debug_str_alt,
743 NULL, /* FIXME: Do we need to load alternate symbols ? */
745 &stash->alt_dwarf_str_buffer,
746 &stash->alt_dwarf_str_size))
749 if (offset >= stash->alt_dwarf_str_size)
751 str = (char *) stash->alt_dwarf_str_buffer + offset;
758 /* Resolve an alternate reference from UNIT at OFFSET.
759 Returns a pointer into the loaded alternate CU upon success
760 or NULL upon failure. */
763 read_alt_indirect_ref (struct comp_unit * unit,
766 struct dwarf2_debug *stash = unit->stash;
768 if (stash->alt_bfd_ptr == NULL)
771 char * debug_filename = bfd_follow_gnu_debugaltlink (unit->abfd, DEBUGDIR);
773 if (debug_filename == NULL)
776 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
777 || ! bfd_check_format (debug_bfd, bfd_object))
780 bfd_close (debug_bfd);
782 /* FIXME: Should we report our failure to follow the debuglink ? */
783 free (debug_filename);
786 stash->alt_bfd_ptr = debug_bfd;
789 if (! read_section (unit->stash->alt_bfd_ptr,
790 stash->debug_sections + debug_info_alt,
791 NULL, /* FIXME: Do we need to load alternate symbols ? */
793 &stash->alt_dwarf_info_buffer,
794 &stash->alt_dwarf_info_size))
797 if (offset >= stash->alt_dwarf_info_size)
799 return stash->alt_dwarf_info_buffer + offset;
803 read_address (struct comp_unit *unit, bfd_byte *buf, bfd_byte * buf_end)
807 if (bfd_get_flavour (unit->abfd) == bfd_target_elf_flavour)
808 signed_vma = get_elf_backend_data (unit->abfd)->sign_extend_vma;
810 if (buf + unit->addr_size > buf_end)
815 switch (unit->addr_size)
818 return bfd_get_signed_64 (unit->abfd, buf);
820 return bfd_get_signed_32 (unit->abfd, buf);
822 return bfd_get_signed_16 (unit->abfd, buf);
829 switch (unit->addr_size)
832 return bfd_get_64 (unit->abfd, buf);
834 return bfd_get_32 (unit->abfd, buf);
836 return bfd_get_16 (unit->abfd, buf);
843 /* Lookup an abbrev_info structure in the abbrev hash table. */
845 static struct abbrev_info *
846 lookup_abbrev (unsigned int number, struct abbrev_info **abbrevs)
848 unsigned int hash_number;
849 struct abbrev_info *abbrev;
851 hash_number = number % ABBREV_HASH_SIZE;
852 abbrev = abbrevs[hash_number];
856 if (abbrev->number == number)
859 abbrev = abbrev->next;
865 /* In DWARF version 2, the description of the debugging information is
866 stored in a separate .debug_abbrev section. Before we read any
867 dies from a section we read in all abbreviations and install them
870 static struct abbrev_info**
871 read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
873 struct abbrev_info **abbrevs;
874 bfd_byte *abbrev_ptr;
875 bfd_byte *abbrev_end;
876 struct abbrev_info *cur_abbrev;
877 unsigned int abbrev_number, bytes_read, abbrev_name;
878 unsigned int abbrev_form, hash_number;
881 if (! read_section (abfd, &stash->debug_sections[debug_abbrev],
883 &stash->dwarf_abbrev_buffer, &stash->dwarf_abbrev_size))
886 if (offset >= stash->dwarf_abbrev_size)
889 amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
890 abbrevs = (struct abbrev_info **) bfd_zalloc (abfd, amt);
894 abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
895 abbrev_end = stash->dwarf_abbrev_buffer + stash->dwarf_abbrev_size;
896 abbrev_number = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
897 abbrev_ptr += bytes_read;
899 /* Loop until we reach an abbrev number of 0. */
900 while (abbrev_number)
902 amt = sizeof (struct abbrev_info);
903 cur_abbrev = (struct abbrev_info *) bfd_zalloc (abfd, amt);
904 if (cur_abbrev == NULL)
907 /* Read in abbrev header. */
908 cur_abbrev->number = abbrev_number;
909 cur_abbrev->tag = (enum dwarf_tag)
910 safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
911 abbrev_ptr += bytes_read;
912 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr, abbrev_end);
915 /* Now read in declarations. */
916 abbrev_name = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
917 abbrev_ptr += bytes_read;
918 abbrev_form = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
919 abbrev_ptr += bytes_read;
923 if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
925 struct attr_abbrev *tmp;
927 amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
928 amt *= sizeof (struct attr_abbrev);
929 tmp = (struct attr_abbrev *) bfd_realloc (cur_abbrev->attrs, amt);
934 for (i = 0; i < ABBREV_HASH_SIZE; i++)
936 struct abbrev_info *abbrev = abbrevs[i];
940 free (abbrev->attrs);
941 abbrev = abbrev->next;
946 cur_abbrev->attrs = tmp;
949 cur_abbrev->attrs[cur_abbrev->num_attrs].name
950 = (enum dwarf_attribute) abbrev_name;
951 cur_abbrev->attrs[cur_abbrev->num_attrs++].form
952 = (enum dwarf_form) abbrev_form;
953 abbrev_name = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
954 abbrev_ptr += bytes_read;
955 abbrev_form = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
956 abbrev_ptr += bytes_read;
959 hash_number = abbrev_number % ABBREV_HASH_SIZE;
960 cur_abbrev->next = abbrevs[hash_number];
961 abbrevs[hash_number] = cur_abbrev;
963 /* Get next abbreviation.
964 Under Irix6 the abbreviations for a compilation unit are not
965 always properly terminated with an abbrev number of 0.
966 Exit loop if we encounter an abbreviation which we have
967 already read (which means we are about to read the abbreviations
968 for the next compile unit) or if the end of the abbreviation
970 if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
971 >= stash->dwarf_abbrev_size)
973 abbrev_number = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
974 abbrev_ptr += bytes_read;
975 if (lookup_abbrev (abbrev_number, abbrevs) != NULL)
982 /* Returns true if the form is one which has a string value. */
984 static inline bfd_boolean
985 is_str_attr (enum dwarf_form form)
987 return form == DW_FORM_string || form == DW_FORM_strp || form == DW_FORM_GNU_strp_alt;
990 /* Read and fill in the value of attribute ATTR as described by FORM.
991 Read data starting from INFO_PTR, but never at or beyond INFO_PTR_END.
992 Returns an updated INFO_PTR taking into account the amount of data read. */
995 read_attribute_value (struct attribute * attr,
997 struct comp_unit * unit,
999 bfd_byte * info_ptr_end)
1001 bfd *abfd = unit->abfd;
1002 unsigned int bytes_read;
1003 struct dwarf_block *blk;
1006 if (info_ptr >= info_ptr_end)
1008 (*_bfd_error_handler) (_("Dwarf Error: Info pointer extends beyond end of attributes"));
1009 bfd_set_error (bfd_error_bad_value);
1013 attr->form = (enum dwarf_form) form;
1017 case DW_FORM_ref_addr:
1018 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
1020 if (unit->version == 3 || unit->version == 4)
1022 if (unit->offset_size == 4)
1023 attr->u.val = read_4_bytes (unit->abfd, info_ptr, info_ptr_end);
1025 attr->u.val = read_8_bytes (unit->abfd, info_ptr, info_ptr_end);
1026 info_ptr += unit->offset_size;
1031 attr->u.val = read_address (unit, info_ptr, info_ptr_end);
1032 info_ptr += unit->addr_size;
1034 case DW_FORM_GNU_ref_alt:
1035 case DW_FORM_sec_offset:
1036 if (unit->offset_size == 4)
1037 attr->u.val = read_4_bytes (unit->abfd, info_ptr, info_ptr_end);
1039 attr->u.val = read_8_bytes (unit->abfd, info_ptr, info_ptr_end);
1040 info_ptr += unit->offset_size;
1042 case DW_FORM_block2:
1043 amt = sizeof (struct dwarf_block);
1044 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1047 blk->size = read_2_bytes (abfd, info_ptr, info_ptr_end);
1049 blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
1050 info_ptr += blk->size;
1053 case DW_FORM_block4:
1054 amt = sizeof (struct dwarf_block);
1055 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1058 blk->size = read_4_bytes (abfd, info_ptr, info_ptr_end);
1060 blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
1061 info_ptr += blk->size;
1065 attr->u.val = read_2_bytes (abfd, info_ptr, info_ptr_end);
1069 attr->u.val = read_4_bytes (abfd, info_ptr, info_ptr_end);
1073 attr->u.val = read_8_bytes (abfd, info_ptr, info_ptr_end);
1076 case DW_FORM_string:
1077 attr->u.str = read_string (abfd, info_ptr, info_ptr_end, &bytes_read);
1078 info_ptr += bytes_read;
1081 attr->u.str = read_indirect_string (unit, info_ptr, info_ptr_end, &bytes_read);
1082 info_ptr += bytes_read;
1084 case DW_FORM_GNU_strp_alt:
1085 attr->u.str = read_alt_indirect_string (unit, info_ptr, info_ptr_end, &bytes_read);
1086 info_ptr += bytes_read;
1088 case DW_FORM_exprloc:
1090 amt = sizeof (struct dwarf_block);
1091 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1094 blk->size = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
1095 info_ptr += bytes_read;
1096 blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
1097 info_ptr += blk->size;
1100 case DW_FORM_block1:
1101 amt = sizeof (struct dwarf_block);
1102 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1105 blk->size = read_1_byte (abfd, info_ptr, info_ptr_end);
1107 blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
1108 info_ptr += blk->size;
1112 attr->u.val = read_1_byte (abfd, info_ptr, info_ptr_end);
1116 attr->u.val = read_1_byte (abfd, info_ptr, info_ptr_end);
1119 case DW_FORM_flag_present:
1123 attr->u.sval = safe_read_leb128 (abfd, info_ptr, &bytes_read, TRUE, info_ptr_end);
1124 info_ptr += bytes_read;
1127 attr->u.val = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
1128 info_ptr += bytes_read;
1131 attr->u.val = read_1_byte (abfd, info_ptr, info_ptr_end);
1135 attr->u.val = read_2_bytes (abfd, info_ptr, info_ptr_end);
1139 attr->u.val = read_4_bytes (abfd, info_ptr, info_ptr_end);
1143 attr->u.val = read_8_bytes (abfd, info_ptr, info_ptr_end);
1146 case DW_FORM_ref_sig8:
1147 attr->u.val = read_8_bytes (abfd, info_ptr, info_ptr_end);
1150 case DW_FORM_ref_udata:
1151 attr->u.val = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
1152 info_ptr += bytes_read;
1154 case DW_FORM_indirect:
1155 form = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
1156 info_ptr += bytes_read;
1157 info_ptr = read_attribute_value (attr, form, unit, info_ptr, info_ptr_end);
1160 (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %#x."),
1162 bfd_set_error (bfd_error_bad_value);
1168 /* Read an attribute described by an abbreviated attribute. */
1171 read_attribute (struct attribute * attr,
1172 struct attr_abbrev * abbrev,
1173 struct comp_unit * unit,
1174 bfd_byte * info_ptr,
1175 bfd_byte * info_ptr_end)
1177 attr->name = abbrev->name;
1178 info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr, info_ptr_end);
1182 /* Return whether DW_AT_name will return the same as DW_AT_linkage_name
1186 non_mangled (int lang)
1196 case DW_LANG_Cobol74:
1197 case DW_LANG_Cobol85:
1198 case DW_LANG_Fortran77:
1199 case DW_LANG_Pascal83:
1209 /* Source line information table routines. */
1211 #define FILE_ALLOC_CHUNK 5
1212 #define DIR_ALLOC_CHUNK 5
1216 struct line_info* prev_line;
1220 unsigned int column;
1221 unsigned int discriminator;
1222 unsigned char op_index;
1223 unsigned char end_sequence; /* End of (sequential) code sequence. */
1234 struct line_sequence
1237 struct line_sequence* prev_sequence;
1238 struct line_info* last_line; /* Largest VMA. */
1241 struct line_info_table
1244 unsigned int num_files;
1245 unsigned int num_dirs;
1246 unsigned int num_sequences;
1249 struct fileinfo* files;
1250 struct line_sequence* sequences;
1251 struct line_info* lcl_head; /* Local head; used in 'add_line_info'. */
1254 /* Remember some information about each function. If the function is
1255 inlined (DW_TAG_inlined_subroutine) it may have two additional
1256 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
1257 source code location where this function was inlined. */
1261 /* Pointer to previous function in list of all functions. */
1262 struct funcinfo *prev_func;
1263 /* Pointer to function one scope higher. */
1264 struct funcinfo *caller_func;
1265 /* Source location file name where caller_func inlines this func. */
1267 /* Source location file name. */
1269 /* Source location line number where caller_func inlines this func. */
1271 /* Source location line number. */
1274 bfd_boolean is_linkage;
1276 struct arange arange;
1277 /* Where the symbol is defined. */
1283 /* Pointer to previous variable in list of all variables */
1284 struct varinfo *prev_var;
1285 /* Source location file name */
1287 /* Source location line number */
1292 /* Where the symbol is defined */
1294 /* Is this a stack variable? */
1295 unsigned int stack: 1;
1298 /* Return TRUE if NEW_LINE should sort after LINE. */
1300 static inline bfd_boolean
1301 new_line_sorts_after (struct line_info *new_line, struct line_info *line)
1303 return (new_line->address > line->address
1304 || (new_line->address == line->address
1305 && (new_line->op_index > line->op_index
1306 || (new_line->op_index == line->op_index
1307 && new_line->end_sequence < line->end_sequence))));
1311 /* Adds a new entry to the line_info list in the line_info_table, ensuring
1312 that the list is sorted. Note that the line_info list is sorted from
1313 highest to lowest VMA (with possible duplicates); that is,
1314 line_info->prev_line always accesses an equal or smaller VMA. */
1317 add_line_info (struct line_info_table *table,
1319 unsigned char op_index,
1322 unsigned int column,
1323 unsigned int discriminator,
1326 bfd_size_type amt = sizeof (struct line_info);
1327 struct line_sequence* seq = table->sequences;
1328 struct line_info* info = (struct line_info *) bfd_alloc (table->abfd, amt);
1333 /* Set member data of 'info'. */
1334 info->prev_line = NULL;
1335 info->address = address;
1336 info->op_index = op_index;
1338 info->column = column;
1339 info->discriminator = discriminator;
1340 info->end_sequence = end_sequence;
1342 if (filename && filename[0])
1344 info->filename = (char *) bfd_alloc (table->abfd, strlen (filename) + 1);
1345 if (info->filename == NULL)
1347 strcpy (info->filename, filename);
1350 info->filename = NULL;
1352 /* Find the correct location for 'info'. Normally we will receive
1353 new line_info data 1) in order and 2) with increasing VMAs.
1354 However some compilers break the rules (cf. decode_line_info) and
1355 so we include some heuristics for quickly finding the correct
1356 location for 'info'. In particular, these heuristics optimize for
1357 the common case in which the VMA sequence that we receive is a
1358 list of locally sorted VMAs such as
1359 p...z a...j (where a < j < p < z)
1361 Note: table->lcl_head is used to head an *actual* or *possible*
1362 sub-sequence within the list (such as a...j) that is not directly
1363 headed by table->last_line
1365 Note: we may receive duplicate entries from 'decode_line_info'. */
1368 && seq->last_line->address == address
1369 && seq->last_line->op_index == op_index
1370 && seq->last_line->end_sequence == end_sequence)
1372 /* We only keep the last entry with the same address and end
1373 sequence. See PR ld/4986. */
1374 if (table->lcl_head == seq->last_line)
1375 table->lcl_head = info;
1376 info->prev_line = seq->last_line->prev_line;
1377 seq->last_line = info;
1379 else if (!seq || seq->last_line->end_sequence)
1381 /* Start a new line sequence. */
1382 amt = sizeof (struct line_sequence);
1383 seq = (struct line_sequence *) bfd_malloc (amt);
1386 seq->low_pc = address;
1387 seq->prev_sequence = table->sequences;
1388 seq->last_line = info;
1389 table->lcl_head = info;
1390 table->sequences = seq;
1391 table->num_sequences++;
1393 else if (new_line_sorts_after (info, seq->last_line))
1395 /* Normal case: add 'info' to the beginning of the current sequence. */
1396 info->prev_line = seq->last_line;
1397 seq->last_line = info;
1399 /* lcl_head: initialize to head a *possible* sequence at the end. */
1400 if (!table->lcl_head)
1401 table->lcl_head = info;
1403 else if (!new_line_sorts_after (info, table->lcl_head)
1404 && (!table->lcl_head->prev_line
1405 || new_line_sorts_after (info, table->lcl_head->prev_line)))
1407 /* Abnormal but easy: lcl_head is the head of 'info'. */
1408 info->prev_line = table->lcl_head->prev_line;
1409 table->lcl_head->prev_line = info;
1413 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head'
1414 are valid heads for 'info'. Reset 'lcl_head'. */
1415 struct line_info* li2 = seq->last_line; /* Always non-NULL. */
1416 struct line_info* li1 = li2->prev_line;
1420 if (!new_line_sorts_after (info, li2)
1421 && new_line_sorts_after (info, li1))
1424 li2 = li1; /* always non-NULL */
1425 li1 = li1->prev_line;
1427 table->lcl_head = li2;
1428 info->prev_line = table->lcl_head->prev_line;
1429 table->lcl_head->prev_line = info;
1430 if (address < seq->low_pc)
1431 seq->low_pc = address;
1436 /* Extract a fully qualified filename from a line info table.
1437 The returned string has been malloc'ed and it is the caller's
1438 responsibility to free it. */
1441 concat_filename (struct line_info_table *table, unsigned int file)
1445 if (file - 1 >= table->num_files)
1447 /* FILE == 0 means unknown. */
1449 (*_bfd_error_handler)
1450 (_("Dwarf Error: mangled line number section (bad file number)."));
1451 return strdup ("<unknown>");
1454 filename = table->files[file - 1].name;
1456 if (!IS_ABSOLUTE_PATH (filename))
1458 char *dir_name = NULL;
1459 char *subdir_name = NULL;
1463 if (table->files[file - 1].dir
1464 /* PR 17512: file: 0317e960. */
1465 && table->files[file - 1].dir <= table->num_dirs
1466 /* PR 17512: file: 7f3d2e4b. */
1467 && table->dirs != NULL)
1468 subdir_name = table->dirs[table->files[file - 1].dir - 1];
1470 if (!subdir_name || !IS_ABSOLUTE_PATH (subdir_name))
1471 dir_name = table->comp_dir;
1475 dir_name = subdir_name;
1480 return strdup (filename);
1482 len = strlen (dir_name) + strlen (filename) + 2;
1486 len += strlen (subdir_name) + 1;
1487 name = (char *) bfd_malloc (len);
1489 sprintf (name, "%s/%s/%s", dir_name, subdir_name, filename);
1493 name = (char *) bfd_malloc (len);
1495 sprintf (name, "%s/%s", dir_name, filename);
1501 return strdup (filename);
1505 arange_add (const struct comp_unit *unit, struct arange *first_arange,
1506 bfd_vma low_pc, bfd_vma high_pc)
1508 struct arange *arange;
1510 /* Ignore empty ranges. */
1511 if (low_pc == high_pc)
1514 /* If the first arange is empty, use it. */
1515 if (first_arange->high == 0)
1517 first_arange->low = low_pc;
1518 first_arange->high = high_pc;
1522 /* Next see if we can cheaply extend an existing range. */
1523 arange = first_arange;
1526 if (low_pc == arange->high)
1528 arange->high = high_pc;
1531 if (high_pc == arange->low)
1533 arange->low = low_pc;
1536 arange = arange->next;
1540 /* Need to allocate a new arange and insert it into the arange list.
1541 Order isn't significant, so just insert after the first arange. */
1542 arange = (struct arange *) bfd_alloc (unit->abfd, sizeof (*arange));
1545 arange->low = low_pc;
1546 arange->high = high_pc;
1547 arange->next = first_arange->next;
1548 first_arange->next = arange;
1552 /* Compare function for line sequences. */
1555 compare_sequences (const void* a, const void* b)
1557 const struct line_sequence* seq1 = a;
1558 const struct line_sequence* seq2 = b;
1560 /* Sort by low_pc as the primary key. */
1561 if (seq1->low_pc < seq2->low_pc)
1563 if (seq1->low_pc > seq2->low_pc)
1566 /* If low_pc values are equal, sort in reverse order of
1567 high_pc, so that the largest region comes first. */
1568 if (seq1->last_line->address < seq2->last_line->address)
1570 if (seq1->last_line->address > seq2->last_line->address)
1573 if (seq1->last_line->op_index < seq2->last_line->op_index)
1575 if (seq1->last_line->op_index > seq2->last_line->op_index)
1581 /* Sort the line sequences for quick lookup. */
1584 sort_line_sequences (struct line_info_table* table)
1587 struct line_sequence* sequences;
1588 struct line_sequence* seq;
1590 unsigned int num_sequences = table->num_sequences;
1591 bfd_vma last_high_pc;
1593 if (num_sequences == 0)
1596 /* Allocate space for an array of sequences. */
1597 amt = sizeof (struct line_sequence) * num_sequences;
1598 sequences = (struct line_sequence *) bfd_alloc (table->abfd, amt);
1599 if (sequences == NULL)
1602 /* Copy the linked list into the array, freeing the original nodes. */
1603 seq = table->sequences;
1604 for (n = 0; n < num_sequences; n++)
1606 struct line_sequence* last_seq = seq;
1609 sequences[n].low_pc = seq->low_pc;
1610 sequences[n].prev_sequence = NULL;
1611 sequences[n].last_line = seq->last_line;
1612 seq = seq->prev_sequence;
1615 BFD_ASSERT (seq == NULL);
1617 qsort (sequences, n, sizeof (struct line_sequence), compare_sequences);
1619 /* Make the list binary-searchable by trimming overlapping entries
1620 and removing nested entries. */
1622 last_high_pc = sequences[0].last_line->address;
1623 for (n = 1; n < table->num_sequences; n++)
1625 if (sequences[n].low_pc < last_high_pc)
1627 if (sequences[n].last_line->address <= last_high_pc)
1628 /* Skip nested entries. */
1631 /* Trim overlapping entries. */
1632 sequences[n].low_pc = last_high_pc;
1634 last_high_pc = sequences[n].last_line->address;
1635 if (n > num_sequences)
1637 /* Close up the gap. */
1638 sequences[num_sequences].low_pc = sequences[n].low_pc;
1639 sequences[num_sequences].last_line = sequences[n].last_line;
1644 table->sequences = sequences;
1645 table->num_sequences = num_sequences;
1649 /* Decode the line number information for UNIT. */
1651 static struct line_info_table*
1652 decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
1654 bfd *abfd = unit->abfd;
1655 struct line_info_table* table;
1658 struct line_head lh;
1659 unsigned int i, bytes_read, offset_size;
1660 char *cur_file, *cur_dir;
1661 unsigned char op_code, extended_op, adj_opcode;
1662 unsigned int exop_len;
1665 if (! read_section (abfd, &stash->debug_sections[debug_line],
1666 stash->syms, unit->line_offset,
1667 &stash->dwarf_line_buffer, &stash->dwarf_line_size))
1670 amt = sizeof (struct line_info_table);
1671 table = (struct line_info_table *) bfd_alloc (abfd, amt);
1675 table->comp_dir = unit->comp_dir;
1677 table->num_files = 0;
1678 table->files = NULL;
1680 table->num_dirs = 0;
1683 table->num_sequences = 0;
1684 table->sequences = NULL;
1686 table->lcl_head = NULL;
1688 if (stash->dwarf_line_size < 16)
1690 (*_bfd_error_handler)
1691 (_("Dwarf Error: Line info section is too small (%ld)"),
1692 (long) stash->dwarf_line_size);
1693 bfd_set_error (bfd_error_bad_value);
1696 line_ptr = stash->dwarf_line_buffer + unit->line_offset;
1697 line_end = stash->dwarf_line_buffer + stash->dwarf_line_size;
1699 /* Read in the prologue. */
1700 lh.total_length = read_4_bytes (abfd, line_ptr, line_end);
1703 if (lh.total_length == 0xffffffff)
1705 lh.total_length = read_8_bytes (abfd, line_ptr, line_end);
1709 else if (lh.total_length == 0 && unit->addr_size == 8)
1711 /* Handle (non-standard) 64-bit DWARF2 formats. */
1712 lh.total_length = read_4_bytes (abfd, line_ptr, line_end);
1717 if (lh.total_length > stash->dwarf_line_size)
1719 (*_bfd_error_handler)
1720 (_("Dwarf Error: Line info data is bigger (0x%lx) than the section (0x%lx)"),
1721 (long) lh.total_length, (long) stash->dwarf_line_size);
1722 bfd_set_error (bfd_error_bad_value);
1726 line_end = line_ptr + lh.total_length;
1728 lh.version = read_2_bytes (abfd, line_ptr, line_end);
1729 if (lh.version < 2 || lh.version > 4)
1731 (*_bfd_error_handler)
1732 (_("Dwarf Error: Unhandled .debug_line version %d."), lh.version);
1733 bfd_set_error (bfd_error_bad_value);
1738 if (line_ptr + offset_size + (lh.version >=4 ? 6 : 5) >= line_end)
1740 (*_bfd_error_handler)
1741 (_("Dwarf Error: Ran out of room reading prologue"));
1742 bfd_set_error (bfd_error_bad_value);
1746 if (offset_size == 4)
1747 lh.prologue_length = read_4_bytes (abfd, line_ptr, line_end);
1749 lh.prologue_length = read_8_bytes (abfd, line_ptr, line_end);
1750 line_ptr += offset_size;
1752 lh.minimum_instruction_length = read_1_byte (abfd, line_ptr, line_end);
1755 if (lh.version >= 4)
1757 lh.maximum_ops_per_insn = read_1_byte (abfd, line_ptr, line_end);
1761 lh.maximum_ops_per_insn = 1;
1763 if (lh.maximum_ops_per_insn == 0)
1765 (*_bfd_error_handler)
1766 (_("Dwarf Error: Invalid maximum operations per instruction."));
1767 bfd_set_error (bfd_error_bad_value);
1771 lh.default_is_stmt = read_1_byte (abfd, line_ptr, line_end);
1774 lh.line_base = read_1_signed_byte (abfd, line_ptr, line_end);
1777 lh.line_range = read_1_byte (abfd, line_ptr, line_end);
1780 lh.opcode_base = read_1_byte (abfd, line_ptr, line_end);
1783 if (line_ptr + (lh.opcode_base - 1) >= line_end)
1785 (*_bfd_error_handler) (_("Dwarf Error: Ran out of room reading opcodes"));
1786 bfd_set_error (bfd_error_bad_value);
1790 amt = lh.opcode_base * sizeof (unsigned char);
1791 lh.standard_opcode_lengths = (unsigned char *) bfd_alloc (abfd, amt);
1793 lh.standard_opcode_lengths[0] = 1;
1795 for (i = 1; i < lh.opcode_base; ++i)
1797 lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr, line_end);
1801 /* Read directory table. */
1802 while ((cur_dir = read_string (abfd, line_ptr, line_end, &bytes_read)) != NULL)
1804 line_ptr += bytes_read;
1806 if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
1810 amt = table->num_dirs + DIR_ALLOC_CHUNK;
1811 amt *= sizeof (char *);
1813 tmp = (char **) bfd_realloc (table->dirs, amt);
1819 table->dirs[table->num_dirs++] = cur_dir;
1822 line_ptr += bytes_read;
1824 /* Read file name table. */
1825 while ((cur_file = read_string (abfd, line_ptr, line_end, &bytes_read)) != NULL)
1827 line_ptr += bytes_read;
1829 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1831 struct fileinfo *tmp;
1833 amt = table->num_files + FILE_ALLOC_CHUNK;
1834 amt *= sizeof (struct fileinfo);
1836 tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
1842 table->files[table->num_files].name = cur_file;
1843 table->files[table->num_files].dir =
1844 safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1845 line_ptr += bytes_read;
1846 table->files[table->num_files].time = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1847 line_ptr += bytes_read;
1848 table->files[table->num_files].size = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1849 line_ptr += bytes_read;
1853 line_ptr += bytes_read;
1855 /* Read the statement sequences until there's nothing left. */
1856 while (line_ptr < line_end)
1858 /* State machine registers. */
1859 bfd_vma address = 0;
1860 unsigned char op_index = 0;
1861 char * filename = table->num_files ? concat_filename (table, 1) : NULL;
1862 unsigned int line = 1;
1863 unsigned int column = 0;
1864 unsigned int discriminator = 0;
1865 int is_stmt = lh.default_is_stmt;
1866 int end_sequence = 0;
1867 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1868 compilers generate address sequences that are wildly out of
1869 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1870 for ia64-Linux). Thus, to determine the low and high
1871 address, we must compare on every DW_LNS_copy, etc. */
1872 bfd_vma low_pc = (bfd_vma) -1;
1873 bfd_vma high_pc = 0;
1875 /* Decode the table. */
1876 while (! end_sequence)
1878 op_code = read_1_byte (abfd, line_ptr, line_end);
1881 if (op_code >= lh.opcode_base)
1883 /* Special operand. */
1884 adj_opcode = op_code - lh.opcode_base;
1885 if (lh.line_range == 0)
1887 if (lh.maximum_ops_per_insn == 1)
1888 address += (adj_opcode / lh.line_range
1889 * lh.minimum_instruction_length);
1892 address += ((op_index + adj_opcode / lh.line_range)
1893 / lh.maximum_ops_per_insn
1894 * lh.minimum_instruction_length);
1895 op_index = ((op_index + adj_opcode / lh.line_range)
1896 % lh.maximum_ops_per_insn);
1898 line += lh.line_base + (adj_opcode % lh.line_range);
1899 /* Append row to matrix using current values. */
1900 if (!add_line_info (table, address, op_index, filename,
1901 line, column, discriminator, 0))
1904 if (address < low_pc)
1906 if (address > high_pc)
1909 else switch (op_code)
1911 case DW_LNS_extended_op:
1912 exop_len = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1913 line_ptr += bytes_read;
1914 extended_op = read_1_byte (abfd, line_ptr, line_end);
1917 switch (extended_op)
1919 case DW_LNE_end_sequence:
1921 if (!add_line_info (table, address, op_index, filename, line,
1922 column, discriminator, end_sequence))
1925 if (address < low_pc)
1927 if (address > high_pc)
1929 if (!arange_add (unit, &unit->arange, low_pc, high_pc))
1932 case DW_LNE_set_address:
1933 address = read_address (unit, line_ptr, line_end);
1935 line_ptr += unit->addr_size;
1937 case DW_LNE_define_file:
1938 cur_file = read_string (abfd, line_ptr, line_end, &bytes_read);
1939 line_ptr += bytes_read;
1940 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1942 struct fileinfo *tmp;
1944 amt = table->num_files + FILE_ALLOC_CHUNK;
1945 amt *= sizeof (struct fileinfo);
1946 tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
1951 table->files[table->num_files].name = cur_file;
1952 table->files[table->num_files].dir =
1953 safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1954 line_ptr += bytes_read;
1955 table->files[table->num_files].time =
1956 safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1957 line_ptr += bytes_read;
1958 table->files[table->num_files].size =
1959 safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1960 line_ptr += bytes_read;
1963 case DW_LNE_set_discriminator:
1965 safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1966 line_ptr += bytes_read;
1968 case DW_LNE_HP_source_file_correlation:
1969 line_ptr += exop_len - 1;
1972 (*_bfd_error_handler)
1973 (_("Dwarf Error: mangled line number section."));
1974 bfd_set_error (bfd_error_bad_value);
1976 if (filename != NULL)
1982 if (!add_line_info (table, address, op_index,
1983 filename, line, column, discriminator, 0))
1986 if (address < low_pc)
1988 if (address > high_pc)
1991 case DW_LNS_advance_pc:
1992 if (lh.maximum_ops_per_insn == 1)
1993 address += (lh.minimum_instruction_length
1994 * safe_read_leb128 (abfd, line_ptr, &bytes_read,
1998 bfd_vma adjust = safe_read_leb128 (abfd, line_ptr, &bytes_read,
2000 address = ((op_index + adjust) / lh.maximum_ops_per_insn
2001 * lh.minimum_instruction_length);
2002 op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
2004 line_ptr += bytes_read;
2006 case DW_LNS_advance_line:
2007 line += safe_read_leb128 (abfd, line_ptr, &bytes_read, TRUE, line_end);
2008 line_ptr += bytes_read;
2010 case DW_LNS_set_file:
2014 /* The file and directory tables are 0
2015 based, the references are 1 based. */
2016 file = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
2017 line_ptr += bytes_read;
2020 filename = concat_filename (table, file);
2023 case DW_LNS_set_column:
2024 column = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
2025 line_ptr += bytes_read;
2027 case DW_LNS_negate_stmt:
2028 is_stmt = (!is_stmt);
2030 case DW_LNS_set_basic_block:
2032 case DW_LNS_const_add_pc:
2033 if (lh.maximum_ops_per_insn == 1)
2034 address += (lh.minimum_instruction_length
2035 * ((255 - lh.opcode_base) / lh.line_range));
2038 bfd_vma adjust = ((255 - lh.opcode_base) / lh.line_range);
2039 address += (lh.minimum_instruction_length
2040 * ((op_index + adjust)
2041 / lh.maximum_ops_per_insn));
2042 op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
2045 case DW_LNS_fixed_advance_pc:
2046 address += read_2_bytes (abfd, line_ptr, line_end);
2051 /* Unknown standard opcode, ignore it. */
2052 for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
2054 (void) safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
2055 line_ptr += bytes_read;
2065 if (sort_line_sequences (table))
2069 if (table->sequences != NULL)
2070 free (table->sequences);
2071 if (table->files != NULL)
2072 free (table->files);
2073 if (table->dirs != NULL)
2078 /* If ADDR is within TABLE set the output parameters and return the
2079 range of addresses covered by the entry used to fill them out.
2080 Otherwise set * FILENAME_PTR to NULL and return 0.
2081 The parameters FILENAME_PTR, LINENUMBER_PTR and DISCRIMINATOR_PTR
2082 are pointers to the objects to be filled in. */
2085 lookup_address_in_line_info_table (struct line_info_table *table,
2087 const char **filename_ptr,
2088 unsigned int *linenumber_ptr,
2089 unsigned int *discriminator_ptr)
2091 struct line_sequence *seq = NULL;
2092 struct line_info *each_line;
2095 /* Binary search the array of sequences. */
2097 high = table->num_sequences;
2100 mid = (low + high) / 2;
2101 seq = &table->sequences[mid];
2102 if (addr < seq->low_pc)
2104 else if (addr >= seq->last_line->address)
2110 if (seq && addr >= seq->low_pc && addr < seq->last_line->address)
2112 /* Note: seq->last_line should be a descendingly sorted list. */
2113 for (each_line = seq->last_line;
2115 each_line = each_line->prev_line)
2116 if (addr >= each_line->address)
2120 && !(each_line->end_sequence || each_line == seq->last_line))
2122 *filename_ptr = each_line->filename;
2123 *linenumber_ptr = each_line->line;
2124 if (discriminator_ptr)
2125 *discriminator_ptr = each_line->discriminator;
2126 return seq->last_line->address - seq->low_pc;
2130 *filename_ptr = NULL;
2134 /* Read in the .debug_ranges section for future reference. */
2137 read_debug_ranges (struct comp_unit *unit)
2139 struct dwarf2_debug *stash = unit->stash;
2140 return read_section (unit->abfd, &stash->debug_sections[debug_ranges],
2142 &stash->dwarf_ranges_buffer, &stash->dwarf_ranges_size);
2145 /* Function table functions. */
2147 /* If ADDR is within UNIT's function tables, set FUNCTION_PTR, and return
2148 TRUE. Note that we need to find the function that has the smallest range
2149 that contains ADDR, to handle inlined functions without depending upon
2150 them being ordered in TABLE by increasing range. */
2153 lookup_address_in_function_table (struct comp_unit *unit,
2155 struct funcinfo **function_ptr)
2157 struct funcinfo* each_func;
2158 struct funcinfo* best_fit = NULL;
2159 bfd_vma best_fit_len = 0;
2160 struct arange *arange;
2162 for (each_func = unit->function_table;
2164 each_func = each_func->prev_func)
2166 for (arange = &each_func->arange;
2168 arange = arange->next)
2170 if (addr >= arange->low && addr < arange->high)
2173 || arange->high - arange->low < best_fit_len)
2175 best_fit = each_func;
2176 best_fit_len = arange->high - arange->low;
2184 *function_ptr = best_fit;
2190 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
2191 and LINENUMBER_PTR, and return TRUE. */
2194 lookup_symbol_in_function_table (struct comp_unit *unit,
2197 const char **filename_ptr,
2198 unsigned int *linenumber_ptr)
2200 struct funcinfo* each_func;
2201 struct funcinfo* best_fit = NULL;
2202 bfd_vma best_fit_len = 0;
2203 struct arange *arange;
2204 const char *name = bfd_asymbol_name (sym);
2205 asection *sec = bfd_get_section (sym);
2207 for (each_func = unit->function_table;
2209 each_func = each_func->prev_func)
2211 for (arange = &each_func->arange;
2213 arange = arange->next)
2215 if ((!each_func->sec || each_func->sec == sec)
2216 && addr >= arange->low
2217 && addr < arange->high
2219 && strcmp (name, each_func->name) == 0
2221 || arange->high - arange->low < best_fit_len))
2223 best_fit = each_func;
2224 best_fit_len = arange->high - arange->low;
2231 best_fit->sec = sec;
2232 *filename_ptr = best_fit->file;
2233 *linenumber_ptr = best_fit->line;
2240 /* Variable table functions. */
2242 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
2243 LINENUMBER_PTR, and return TRUE. */
2246 lookup_symbol_in_variable_table (struct comp_unit *unit,
2249 const char **filename_ptr,
2250 unsigned int *linenumber_ptr)
2252 const char *name = bfd_asymbol_name (sym);
2253 asection *sec = bfd_get_section (sym);
2254 struct varinfo* each;
2256 for (each = unit->variable_table; each; each = each->prev_var)
2257 if (each->stack == 0
2258 && each->file != NULL
2259 && each->name != NULL
2260 && each->addr == addr
2261 && (!each->sec || each->sec == sec)
2262 && strcmp (name, each->name) == 0)
2268 *filename_ptr = each->file;
2269 *linenumber_ptr = each->line;
2277 find_abstract_instance_name (struct comp_unit *unit,
2278 struct attribute *attr_ptr,
2279 bfd_boolean *is_linkage)
2281 bfd *abfd = unit->abfd;
2283 bfd_byte *info_ptr_end;
2284 unsigned int abbrev_number, bytes_read, i;
2285 struct abbrev_info *abbrev;
2286 bfd_uint64_t die_ref = attr_ptr->u.val;
2287 struct attribute attr;
2290 /* DW_FORM_ref_addr can reference an entry in a different CU. It
2291 is an offset from the .debug_info section, not the current CU. */
2292 if (attr_ptr->form == DW_FORM_ref_addr)
2294 /* We only support DW_FORM_ref_addr within the same file, so
2295 any relocations should be resolved already. */
2299 info_ptr = unit->sec_info_ptr + die_ref;
2300 info_ptr_end = unit->end_ptr;
2302 /* Now find the CU containing this pointer. */
2303 if (info_ptr >= unit->info_ptr_unit && info_ptr < unit->end_ptr)
2307 /* Check other CUs to see if they contain the abbrev. */
2308 struct comp_unit * u;
2310 for (u = unit->prev_unit; u != NULL; u = u->prev_unit)
2311 if (info_ptr >= u->info_ptr_unit && info_ptr < u->end_ptr)
2315 for (u = unit->next_unit; u != NULL; u = u->next_unit)
2316 if (info_ptr >= u->info_ptr_unit && info_ptr < u->end_ptr)
2321 /* else FIXME: What do we do now ? */
2324 else if (attr_ptr->form == DW_FORM_GNU_ref_alt)
2326 info_ptr = read_alt_indirect_ref (unit, die_ref);
2327 if (info_ptr == NULL)
2329 (*_bfd_error_handler)
2330 (_("Dwarf Error: Unable to read alt ref %u."), die_ref);
2331 bfd_set_error (bfd_error_bad_value);
2334 info_ptr_end = unit->stash->alt_dwarf_info_buffer + unit->stash->alt_dwarf_info_size;
2336 /* FIXME: Do we need to locate the correct CU, in a similar
2337 fashion to the code in the DW_FORM_ref_addr case above ? */
2341 info_ptr = unit->info_ptr_unit + die_ref;
2342 info_ptr_end = unit->end_ptr;
2345 abbrev_number = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
2346 info_ptr += bytes_read;
2350 abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
2353 (*_bfd_error_handler)
2354 (_("Dwarf Error: Could not find abbrev number %u."), abbrev_number);
2355 bfd_set_error (bfd_error_bad_value);
2359 for (i = 0; i < abbrev->num_attrs; ++i)
2361 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit,
2362 info_ptr, info_ptr_end);
2363 if (info_ptr == NULL)
2368 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2370 if (name == NULL && is_str_attr (attr.form))
2373 if (non_mangled (unit->lang))
2377 case DW_AT_specification:
2378 name = find_abstract_instance_name (unit, &attr, is_linkage);
2380 case DW_AT_linkage_name:
2381 case DW_AT_MIPS_linkage_name:
2382 /* PR 16949: Corrupt debug info can place
2383 non-string forms into these attributes. */
2384 if (is_str_attr (attr.form))
2400 read_rangelist (struct comp_unit *unit, struct arange *arange,
2401 bfd_uint64_t offset)
2403 bfd_byte *ranges_ptr;
2404 bfd_byte *ranges_end;
2405 bfd_vma base_address = unit->base_address;
2407 if (! unit->stash->dwarf_ranges_buffer)
2409 if (! read_debug_ranges (unit))
2413 ranges_ptr = unit->stash->dwarf_ranges_buffer + offset;
2414 if (ranges_ptr < unit->stash->dwarf_ranges_buffer)
2416 ranges_end = unit->stash->dwarf_ranges_buffer + unit->stash->dwarf_ranges_size;
2423 /* PR 17512: file: 62cada7d. */
2424 if (ranges_ptr + 2 * unit->addr_size >= ranges_end)
2427 low_pc = read_address (unit, ranges_ptr, ranges_end);
2428 ranges_ptr += unit->addr_size;
2429 high_pc = read_address (unit, ranges_ptr, ranges_end);
2430 ranges_ptr += unit->addr_size;
2432 if (low_pc == 0 && high_pc == 0)
2434 if (low_pc == -1UL && high_pc != -1UL)
2435 base_address = high_pc;
2438 if (!arange_add (unit, arange,
2439 base_address + low_pc, base_address + high_pc))
2446 /* DWARF2 Compilation unit functions. */
2448 /* Scan over each die in a comp. unit looking for functions to add
2449 to the function table and variables to the variable table. */
2452 scan_unit_for_symbols (struct comp_unit *unit)
2454 bfd *abfd = unit->abfd;
2455 bfd_byte *info_ptr = unit->first_child_die_ptr;
2456 bfd_byte *info_ptr_end = unit->stash->info_ptr_end;
2457 int nesting_level = 1;
2458 struct funcinfo **nested_funcs;
2459 int nested_funcs_size;
2461 /* Maintain a stack of in-scope functions and inlined functions, which we
2462 can use to set the caller_func field. */
2463 nested_funcs_size = 32;
2464 nested_funcs = (struct funcinfo **)
2465 bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *));
2466 if (nested_funcs == NULL)
2468 nested_funcs[nesting_level] = 0;
2470 while (nesting_level)
2472 unsigned int abbrev_number, bytes_read, i;
2473 struct abbrev_info *abbrev;
2474 struct attribute attr;
2475 struct funcinfo *func;
2476 struct varinfo *var;
2478 bfd_vma high_pc = 0;
2479 bfd_boolean high_pc_relative = FALSE;
2481 /* PR 17512: file: 9f405d9d. */
2482 if (info_ptr >= info_ptr_end)
2485 abbrev_number = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
2486 info_ptr += bytes_read;
2488 if (! abbrev_number)
2494 abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
2497 (*_bfd_error_handler)
2498 (_("Dwarf Error: Could not find abbrev number %u."),
2500 bfd_set_error (bfd_error_bad_value);
2505 if (abbrev->tag == DW_TAG_subprogram
2506 || abbrev->tag == DW_TAG_entry_point
2507 || abbrev->tag == DW_TAG_inlined_subroutine)
2509 bfd_size_type amt = sizeof (struct funcinfo);
2510 func = (struct funcinfo *) bfd_zalloc (abfd, amt);
2513 func->tag = abbrev->tag;
2514 func->prev_func = unit->function_table;
2515 unit->function_table = func;
2516 BFD_ASSERT (!unit->cached);
2518 if (func->tag == DW_TAG_inlined_subroutine)
2519 for (i = nesting_level - 1; i >= 1; i--)
2520 if (nested_funcs[i])
2522 func->caller_func = nested_funcs[i];
2525 nested_funcs[nesting_level] = func;
2530 if (abbrev->tag == DW_TAG_variable)
2532 bfd_size_type amt = sizeof (struct varinfo);
2533 var = (struct varinfo *) bfd_zalloc (abfd, amt);
2536 var->tag = abbrev->tag;
2538 var->prev_var = unit->variable_table;
2539 unit->variable_table = var;
2540 BFD_ASSERT (!unit->cached);
2543 /* No inline function in scope at this nesting level. */
2544 nested_funcs[nesting_level] = 0;
2547 for (i = 0; i < abbrev->num_attrs; ++i)
2549 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr, info_ptr_end);
2550 if (info_ptr == NULL)
2557 case DW_AT_call_file:
2558 func->caller_file = concat_filename (unit->line_table,
2562 case DW_AT_call_line:
2563 func->caller_line = attr.u.val;
2566 case DW_AT_abstract_origin:
2567 case DW_AT_specification:
2568 func->name = find_abstract_instance_name (unit, &attr,
2573 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2575 if (func->name == NULL && is_str_attr (attr.form))
2577 func->name = attr.u.str;
2578 if (non_mangled (unit->lang))
2579 func->is_linkage = TRUE;
2583 case DW_AT_linkage_name:
2584 case DW_AT_MIPS_linkage_name:
2585 /* PR 16949: Corrupt debug info can place
2586 non-string forms into these attributes. */
2587 if (is_str_attr (attr.form))
2589 func->name = attr.u.str;
2590 func->is_linkage = TRUE;
2595 low_pc = attr.u.val;
2599 high_pc = attr.u.val;
2600 high_pc_relative = attr.form != DW_FORM_addr;
2604 if (!read_rangelist (unit, &func->arange, attr.u.val))
2608 case DW_AT_decl_file:
2609 func->file = concat_filename (unit->line_table,
2613 case DW_AT_decl_line:
2614 func->line = attr.u.val;
2626 var->name = attr.u.str;
2629 case DW_AT_decl_file:
2630 var->file = concat_filename (unit->line_table,
2634 case DW_AT_decl_line:
2635 var->line = attr.u.val;
2638 case DW_AT_external:
2639 if (attr.u.val != 0)
2643 case DW_AT_location:
2647 case DW_FORM_block1:
2648 case DW_FORM_block2:
2649 case DW_FORM_block4:
2650 case DW_FORM_exprloc:
2651 if (*attr.u.blk->data == DW_OP_addr)
2655 /* Verify that DW_OP_addr is the only opcode in the
2656 location, in which case the block size will be 1
2657 plus the address size. */
2658 /* ??? For TLS variables, gcc can emit
2659 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
2660 which we don't handle here yet. */
2661 if (attr.u.blk->size == unit->addr_size + 1U)
2662 var->addr = bfd_get (unit->addr_size * 8,
2664 attr.u.blk->data + 1);
2679 if (high_pc_relative)
2682 if (func && high_pc != 0)
2684 if (!arange_add (unit, &func->arange, low_pc, high_pc))
2688 if (abbrev->has_children)
2692 if (nesting_level >= nested_funcs_size)
2694 struct funcinfo **tmp;
2696 nested_funcs_size *= 2;
2697 tmp = (struct funcinfo **)
2698 bfd_realloc (nested_funcs,
2699 nested_funcs_size * sizeof (struct funcinfo *));
2704 nested_funcs[nesting_level] = 0;
2708 free (nested_funcs);
2712 free (nested_funcs);
2716 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
2717 includes the compilation unit header that proceeds the DIE's, but
2718 does not include the length field that precedes each compilation
2719 unit header. END_PTR points one past the end of this comp unit.
2720 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
2722 This routine does not read the whole compilation unit; only enough
2723 to get to the line number information for the compilation unit. */
2725 static struct comp_unit *
2726 parse_comp_unit (struct dwarf2_debug *stash,
2727 bfd_vma unit_length,
2728 bfd_byte *info_ptr_unit,
2729 unsigned int offset_size)
2731 struct comp_unit* unit;
2732 unsigned int version;
2733 bfd_uint64_t abbrev_offset = 0;
2734 unsigned int addr_size;
2735 struct abbrev_info** abbrevs;
2736 unsigned int abbrev_number, bytes_read, i;
2737 struct abbrev_info *abbrev;
2738 struct attribute attr;
2739 bfd_byte *info_ptr = stash->info_ptr;
2740 bfd_byte *end_ptr = info_ptr + unit_length;
2743 bfd_vma high_pc = 0;
2744 bfd *abfd = stash->bfd_ptr;
2745 bfd_boolean high_pc_relative = FALSE;
2747 version = read_2_bytes (abfd, info_ptr, end_ptr);
2749 BFD_ASSERT (offset_size == 4 || offset_size == 8);
2750 if (offset_size == 4)
2751 abbrev_offset = read_4_bytes (abfd, info_ptr, end_ptr);
2753 abbrev_offset = read_8_bytes (abfd, info_ptr, end_ptr);
2754 info_ptr += offset_size;
2755 addr_size = read_1_byte (abfd, info_ptr, end_ptr);
2758 if (version != 2 && version != 3 && version != 4)
2760 (*_bfd_error_handler)
2761 (_("Dwarf Error: found dwarf version '%u', this reader"
2762 " only handles version 2, 3 and 4 information."), version);
2763 bfd_set_error (bfd_error_bad_value);
2767 if (addr_size > sizeof (bfd_vma))
2769 (*_bfd_error_handler)
2770 (_("Dwarf Error: found address size '%u', this reader"
2771 " can not handle sizes greater than '%u'."),
2773 (unsigned int) sizeof (bfd_vma));
2774 bfd_set_error (bfd_error_bad_value);
2778 if (addr_size != 2 && addr_size != 4 && addr_size != 8)
2780 (*_bfd_error_handler)
2781 ("Dwarf Error: found address size '%u', this reader"
2782 " can only handle address sizes '2', '4' and '8'.", addr_size);
2783 bfd_set_error (bfd_error_bad_value);
2787 /* Read the abbrevs for this compilation unit into a table. */
2788 abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
2792 abbrev_number = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, end_ptr);
2793 info_ptr += bytes_read;
2794 if (! abbrev_number)
2796 (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u."),
2798 bfd_set_error (bfd_error_bad_value);
2802 abbrev = lookup_abbrev (abbrev_number, abbrevs);
2805 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
2807 bfd_set_error (bfd_error_bad_value);
2811 amt = sizeof (struct comp_unit);
2812 unit = (struct comp_unit *) bfd_zalloc (abfd, amt);
2816 unit->version = version;
2817 unit->addr_size = addr_size;
2818 unit->offset_size = offset_size;
2819 unit->abbrevs = abbrevs;
2820 unit->end_ptr = end_ptr;
2821 unit->stash = stash;
2822 unit->info_ptr_unit = info_ptr_unit;
2823 unit->sec_info_ptr = stash->sec_info_ptr;
2825 for (i = 0; i < abbrev->num_attrs; ++i)
2827 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr, end_ptr);
2828 if (info_ptr == NULL)
2831 /* Store the data if it is of an attribute we want to keep in a
2832 partial symbol table. */
2835 case DW_AT_stmt_list:
2837 unit->line_offset = attr.u.val;
2841 unit->name = attr.u.str;
2845 low_pc = attr.u.val;
2846 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
2847 this is the base address to use when reading location
2848 lists or range lists. */
2849 if (abbrev->tag == DW_TAG_compile_unit)
2850 unit->base_address = low_pc;
2854 high_pc = attr.u.val;
2855 high_pc_relative = attr.form != DW_FORM_addr;
2859 if (!read_rangelist (unit, &unit->arange, attr.u.val))
2863 case DW_AT_comp_dir:
2865 char *comp_dir = attr.u.str;
2867 /* PR 17512: file: 1fe726be. */
2868 if (! is_str_attr (attr.form))
2870 (*_bfd_error_handler)
2871 (_("Dwarf Error: DW_AT_comp_dir attribute encountered with a non-string form."));
2877 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2878 directory, get rid of it. */
2879 char *cp = strchr (comp_dir, ':');
2881 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
2884 unit->comp_dir = comp_dir;
2888 case DW_AT_language:
2889 unit->lang = attr.u.val;
2896 if (high_pc_relative)
2900 if (!arange_add (unit, &unit->arange, low_pc, high_pc))
2904 unit->first_child_die_ptr = info_ptr;
2908 /* Return TRUE if UNIT may contain the address given by ADDR. When
2909 there are functions written entirely with inline asm statements, the
2910 range info in the compilation unit header may not be correct. We
2911 need to consult the line info table to see if a compilation unit
2912 really contains the given address. */
2915 comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
2917 struct arange *arange;
2922 arange = &unit->arange;
2925 if (addr >= arange->low && addr < arange->high)
2927 arange = arange->next;
2934 /* If UNIT contains ADDR, set the output parameters to the values for
2935 the line containing ADDR. The output parameters, FILENAME_PTR,
2936 FUNCTION_PTR, and LINENUMBER_PTR, are pointers to the objects
2939 Returns the range of addresses covered by the entry that was used
2940 to fill in *LINENUMBER_PTR or 0 if it was not filled in. */
2943 comp_unit_find_nearest_line (struct comp_unit *unit,
2945 const char **filename_ptr,
2946 struct funcinfo **function_ptr,
2947 unsigned int *linenumber_ptr,
2948 unsigned int *discriminator_ptr,
2949 struct dwarf2_debug *stash)
2956 if (! unit->line_table)
2958 if (! unit->stmtlist)
2964 unit->line_table = decode_line_info (unit, stash);
2966 if (! unit->line_table)
2972 if (unit->first_child_die_ptr < unit->end_ptr
2973 && ! scan_unit_for_symbols (unit))
2980 *function_ptr = NULL;
2981 func_p = lookup_address_in_function_table (unit, addr, function_ptr);
2982 if (func_p && (*function_ptr)->tag == DW_TAG_inlined_subroutine)
2983 stash->inliner_chain = *function_ptr;
2985 return lookup_address_in_line_info_table (unit->line_table, addr,
2991 /* Check to see if line info is already decoded in a comp_unit.
2992 If not, decode it. Returns TRUE if no errors were encountered;
2996 comp_unit_maybe_decode_line_info (struct comp_unit *unit,
2997 struct dwarf2_debug *stash)
3002 if (! unit->line_table)
3004 if (! unit->stmtlist)
3010 unit->line_table = decode_line_info (unit, stash);
3012 if (! unit->line_table)
3018 if (unit->first_child_die_ptr < unit->end_ptr
3019 && ! scan_unit_for_symbols (unit))
3029 /* If UNIT contains SYM at ADDR, set the output parameters to the
3030 values for the line containing SYM. The output parameters,
3031 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
3034 Return TRUE if UNIT contains SYM, and no errors were encountered;
3038 comp_unit_find_line (struct comp_unit *unit,
3041 const char **filename_ptr,
3042 unsigned int *linenumber_ptr,
3043 struct dwarf2_debug *stash)
3045 if (!comp_unit_maybe_decode_line_info (unit, stash))
3048 if (sym->flags & BSF_FUNCTION)
3049 return lookup_symbol_in_function_table (unit, sym, addr,
3053 return lookup_symbol_in_variable_table (unit, sym, addr,
3058 static struct funcinfo *
3059 reverse_funcinfo_list (struct funcinfo *head)
3061 struct funcinfo *rhead;
3062 struct funcinfo *temp;
3064 for (rhead = NULL; head; head = temp)
3066 temp = head->prev_func;
3067 head->prev_func = rhead;
3073 static struct varinfo *
3074 reverse_varinfo_list (struct varinfo *head)
3076 struct varinfo *rhead;
3077 struct varinfo *temp;
3079 for (rhead = NULL; head; head = temp)
3081 temp = head->prev_var;
3082 head->prev_var = rhead;
3088 /* Extract all interesting funcinfos and varinfos of a compilation
3089 unit into hash tables for faster lookup. Returns TRUE if no
3090 errors were enountered; FALSE otherwise. */
3093 comp_unit_hash_info (struct dwarf2_debug *stash,
3094 struct comp_unit *unit,
3095 struct info_hash_table *funcinfo_hash_table,
3096 struct info_hash_table *varinfo_hash_table)
3098 struct funcinfo* each_func;
3099 struct varinfo* each_var;
3100 bfd_boolean okay = TRUE;
3102 BFD_ASSERT (stash->info_hash_status != STASH_INFO_HASH_DISABLED);
3104 if (!comp_unit_maybe_decode_line_info (unit, stash))
3107 BFD_ASSERT (!unit->cached);
3109 /* To preserve the original search order, we went to visit the function
3110 infos in the reversed order of the list. However, making the list
3111 bi-directional use quite a bit of extra memory. So we reverse
3112 the list first, traverse the list in the now reversed order and
3113 finally reverse the list again to get back the original order. */
3114 unit->function_table = reverse_funcinfo_list (unit->function_table);
3115 for (each_func = unit->function_table;
3117 each_func = each_func->prev_func)
3119 /* Skip nameless functions. */
3120 if (each_func->name)
3121 /* There is no need to copy name string into hash table as
3122 name string is either in the dwarf string buffer or
3123 info in the stash. */
3124 okay = insert_info_hash_table (funcinfo_hash_table, each_func->name,
3125 (void*) each_func, FALSE);
3127 unit->function_table = reverse_funcinfo_list (unit->function_table);
3131 /* We do the same for variable infos. */
3132 unit->variable_table = reverse_varinfo_list (unit->variable_table);
3133 for (each_var = unit->variable_table;
3135 each_var = each_var->prev_var)
3137 /* Skip stack vars and vars with no files or names. */
3138 if (each_var->stack == 0
3139 && each_var->file != NULL
3140 && each_var->name != NULL)
3141 /* There is no need to copy name string into hash table as
3142 name string is either in the dwarf string buffer or
3143 info in the stash. */
3144 okay = insert_info_hash_table (varinfo_hash_table, each_var->name,
3145 (void*) each_var, FALSE);
3148 unit->variable_table = reverse_varinfo_list (unit->variable_table);
3149 unit->cached = TRUE;
3153 /* Locate a section in a BFD containing debugging info. The search starts
3154 from the section after AFTER_SEC, or from the first section in the BFD if
3155 AFTER_SEC is NULL. The search works by examining the names of the
3156 sections. There are three permissiable names. The first two are given
3157 by DEBUG_SECTIONS[debug_info] (whose standard DWARF2 names are .debug_info
3158 and .zdebug_info). The third is a prefix .gnu.linkonce.wi.
3159 This is a variation on the .debug_info section which has a checksum
3160 describing the contents appended onto the name. This allows the linker to
3161 identify and discard duplicate debugging sections for different
3162 compilation units. */
3163 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
3166 find_debug_info (bfd *abfd, const struct dwarf_debug_section *debug_sections,
3167 asection *after_sec)
3172 if (after_sec == NULL)
3174 look = debug_sections[debug_info].uncompressed_name;
3175 msec = bfd_get_section_by_name (abfd, look);
3179 look = debug_sections[debug_info].compressed_name;
3182 msec = bfd_get_section_by_name (abfd, look);
3187 for (msec = abfd->sections; msec != NULL; msec = msec->next)
3188 if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
3194 for (msec = after_sec->next; msec != NULL; msec = msec->next)
3196 look = debug_sections[debug_info].uncompressed_name;
3197 if (strcmp (msec->name, look) == 0)
3200 look = debug_sections[debug_info].compressed_name;
3201 if (look != NULL && strcmp (msec->name, look) == 0)
3204 if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
3211 /* Transfer VMAs from object file to separate debug file. */
3214 set_debug_vma (bfd *orig_bfd, bfd *debug_bfd)
3218 for (s = orig_bfd->sections, d = debug_bfd->sections;
3219 s != NULL && d != NULL;
3220 s = s->next, d = d->next)
3222 if ((d->flags & SEC_DEBUGGING) != 0)
3224 /* ??? Assumes 1-1 correspondence between sections in the
3226 if (strcmp (s->name, d->name) == 0)
3228 d->output_section = s->output_section;
3229 d->output_offset = s->output_offset;
3235 /* Unset vmas for adjusted sections in STASH. */
3238 unset_sections (struct dwarf2_debug *stash)
3241 struct adjusted_section *p;
3243 i = stash->adjusted_section_count;
3244 p = stash->adjusted_sections;
3245 for (; i > 0; i--, p++)
3246 p->section->vma = 0;
3249 /* Set VMAs for allocated and .debug_info sections in ORIG_BFD, a
3250 relocatable object file. VMAs are normally all zero in relocatable
3251 object files, so if we want to distinguish locations in sections by
3252 address we need to set VMAs so the sections do not overlap. We
3253 also set VMA on .debug_info so that when we have multiple
3254 .debug_info sections (or the linkonce variant) they also do not
3255 overlap. The multiple .debug_info sections make up a single
3256 logical section. ??? We should probably do the same for other
3260 place_sections (bfd *orig_bfd, struct dwarf2_debug *stash)
3263 struct adjusted_section *p;
3265 const char *debug_info_name;
3267 if (stash->adjusted_section_count != 0)
3269 i = stash->adjusted_section_count;
3270 p = stash->adjusted_sections;
3271 for (; i > 0; i--, p++)
3272 p->section->vma = p->adj_vma;
3276 debug_info_name = stash->debug_sections[debug_info].uncompressed_name;
3283 for (sect = abfd->sections; sect != NULL; sect = sect->next)
3287 if ((sect->output_section != NULL
3288 && sect->output_section != sect
3289 && (sect->flags & SEC_DEBUGGING) == 0)
3293 is_debug_info = (strcmp (sect->name, debug_info_name) == 0
3294 || CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO));
3296 if (!((sect->flags & SEC_ALLOC) != 0 && abfd == orig_bfd)
3302 if (abfd == stash->bfd_ptr)
3304 abfd = stash->bfd_ptr;
3308 stash->adjusted_section_count = -1;
3311 bfd_vma last_vma = 0, last_dwarf = 0;
3312 bfd_size_type amt = i * sizeof (struct adjusted_section);
3314 p = (struct adjusted_section *) bfd_malloc (amt);
3318 stash->adjusted_sections = p;
3319 stash->adjusted_section_count = i;
3326 for (sect = abfd->sections; sect != NULL; sect = sect->next)
3331 if ((sect->output_section != NULL
3332 && sect->output_section != sect
3333 && (sect->flags & SEC_DEBUGGING) == 0)
3337 is_debug_info = (strcmp (sect->name, debug_info_name) == 0
3338 || CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO));
3340 if (!((sect->flags & SEC_ALLOC) != 0 && abfd == orig_bfd)
3344 sz = sect->rawsize ? sect->rawsize : sect->size;
3348 BFD_ASSERT (sect->alignment_power == 0);
3349 sect->vma = last_dwarf;
3354 /* Align the new address to the current section
3356 last_vma = ((last_vma
3357 + ~((bfd_vma) -1 << sect->alignment_power))
3358 & ((bfd_vma) -1 << sect->alignment_power));
3359 sect->vma = last_vma;
3364 p->adj_vma = sect->vma;
3367 if (abfd == stash->bfd_ptr)
3369 abfd = stash->bfd_ptr;
3373 if (orig_bfd != stash->bfd_ptr)
3374 set_debug_vma (orig_bfd, stash->bfd_ptr);
3379 /* Look up a funcinfo by name using the given info hash table. If found,
3380 also update the locations pointed to by filename_ptr and linenumber_ptr.
3382 This function returns TRUE if a funcinfo that matches the given symbol
3383 and address is found with any error; otherwise it returns FALSE. */
3386 info_hash_lookup_funcinfo (struct info_hash_table *hash_table,
3389 const char **filename_ptr,
3390 unsigned int *linenumber_ptr)
3392 struct funcinfo* each_func;
3393 struct funcinfo* best_fit = NULL;
3394 bfd_vma best_fit_len = 0;
3395 struct info_list_node *node;
3396 struct arange *arange;
3397 const char *name = bfd_asymbol_name (sym);
3398 asection *sec = bfd_get_section (sym);
3400 for (node = lookup_info_hash_table (hash_table, name);
3404 each_func = (struct funcinfo *) node->info;
3405 for (arange = &each_func->arange;
3407 arange = arange->next)
3409 if ((!each_func->sec || each_func->sec == sec)
3410 && addr >= arange->low
3411 && addr < arange->high
3413 || arange->high - arange->low < best_fit_len))
3415 best_fit = each_func;
3416 best_fit_len = arange->high - arange->low;
3423 best_fit->sec = sec;
3424 *filename_ptr = best_fit->file;
3425 *linenumber_ptr = best_fit->line;
3432 /* Look up a varinfo by name using the given info hash table. If found,
3433 also update the locations pointed to by filename_ptr and linenumber_ptr.
3435 This function returns TRUE if a varinfo that matches the given symbol
3436 and address is found with any error; otherwise it returns FALSE. */
3439 info_hash_lookup_varinfo (struct info_hash_table *hash_table,
3442 const char **filename_ptr,
3443 unsigned int *linenumber_ptr)
3445 const char *name = bfd_asymbol_name (sym);
3446 asection *sec = bfd_get_section (sym);
3447 struct varinfo* each;
3448 struct info_list_node *node;
3450 for (node = lookup_info_hash_table (hash_table, name);
3454 each = (struct varinfo *) node->info;
3455 if (each->addr == addr
3456 && (!each->sec || each->sec == sec))
3459 *filename_ptr = each->file;
3460 *linenumber_ptr = each->line;
3468 /* Update the funcinfo and varinfo info hash tables if they are
3469 not up to date. Returns TRUE if there is no error; otherwise
3470 returns FALSE and disable the info hash tables. */
3473 stash_maybe_update_info_hash_tables (struct dwarf2_debug *stash)
3475 struct comp_unit *each;
3477 /* Exit if hash tables are up-to-date. */
3478 if (stash->all_comp_units == stash->hash_units_head)
3481 if (stash->hash_units_head)
3482 each = stash->hash_units_head->prev_unit;
3484 each = stash->last_comp_unit;
3488 if (!comp_unit_hash_info (stash, each, stash->funcinfo_hash_table,
3489 stash->varinfo_hash_table))
3491 stash->info_hash_status = STASH_INFO_HASH_DISABLED;
3494 each = each->prev_unit;
3497 stash->hash_units_head = stash->all_comp_units;
3501 /* Check consistency of info hash tables. This is for debugging only. */
3503 static void ATTRIBUTE_UNUSED
3504 stash_verify_info_hash_table (struct dwarf2_debug *stash)
3506 struct comp_unit *each_unit;
3507 struct funcinfo *each_func;
3508 struct varinfo *each_var;
3509 struct info_list_node *node;
3512 for (each_unit = stash->all_comp_units;
3514 each_unit = each_unit->next_unit)
3516 for (each_func = each_unit->function_table;
3518 each_func = each_func->prev_func)
3520 if (!each_func->name)
3522 node = lookup_info_hash_table (stash->funcinfo_hash_table,
3526 while (node && !found)
3528 found = node->info == each_func;
3534 for (each_var = each_unit->variable_table;
3536 each_var = each_var->prev_var)
3538 if (!each_var->name || !each_var->file || each_var->stack)
3540 node = lookup_info_hash_table (stash->varinfo_hash_table,
3544 while (node && !found)
3546 found = node->info == each_var;
3554 /* Check to see if we want to enable the info hash tables, which consume
3555 quite a bit of memory. Currently we only check the number times
3556 bfd_dwarf2_find_line is called. In the future, we may also want to
3557 take the number of symbols into account. */
3560 stash_maybe_enable_info_hash_tables (bfd *abfd, struct dwarf2_debug *stash)
3562 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_OFF);
3564 if (stash->info_hash_count++ < STASH_INFO_HASH_TRIGGER)
3567 /* FIXME: Maybe we should check the reduce_memory_overheads
3568 and optimize fields in the bfd_link_info structure ? */
3570 /* Create hash tables. */
3571 stash->funcinfo_hash_table = create_info_hash_table (abfd);
3572 stash->varinfo_hash_table = create_info_hash_table (abfd);
3573 if (!stash->funcinfo_hash_table || !stash->varinfo_hash_table)
3575 /* Turn off info hashes if any allocation above fails. */
3576 stash->info_hash_status = STASH_INFO_HASH_DISABLED;
3579 /* We need a forced update so that the info hash tables will
3580 be created even though there is no compilation unit. That
3581 happens if STASH_INFO_HASH_TRIGGER is 0. */
3582 stash_maybe_update_info_hash_tables (stash);
3583 stash->info_hash_status = STASH_INFO_HASH_ON;
3586 /* Find the file and line associated with a symbol and address using the
3587 info hash tables of a stash. If there is a match, the function returns
3588 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
3589 otherwise it returns FALSE. */
3592 stash_find_line_fast (struct dwarf2_debug *stash,
3595 const char **filename_ptr,
3596 unsigned int *linenumber_ptr)
3598 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_ON);
3600 if (sym->flags & BSF_FUNCTION)
3601 return info_hash_lookup_funcinfo (stash->funcinfo_hash_table, sym, addr,
3602 filename_ptr, linenumber_ptr);
3603 return info_hash_lookup_varinfo (stash->varinfo_hash_table, sym, addr,
3604 filename_ptr, linenumber_ptr);
3607 /* Save current section VMAs. */
3610 save_section_vma (const bfd *abfd, struct dwarf2_debug *stash)
3615 if (abfd->section_count == 0)
3617 stash->sec_vma = bfd_malloc (sizeof (*stash->sec_vma) * abfd->section_count);
3618 if (stash->sec_vma == NULL)
3620 for (i = 0, s = abfd->sections; i < abfd->section_count; i++, s = s->next)
3622 if (s->output_section != NULL)
3623 stash->sec_vma[i] = s->output_section->vma + s->output_offset;
3625 stash->sec_vma[i] = s->vma;
3630 /* Compare current section VMAs against those at the time the stash
3631 was created. If find_nearest_line is used in linker warnings or
3632 errors early in the link process, the debug info stash will be
3633 invalid for later calls. This is because we relocate debug info
3634 sections, so the stashed section contents depend on symbol values,
3635 which in turn depend on section VMAs. */
3638 section_vma_same (const bfd *abfd, const struct dwarf2_debug *stash)
3643 for (i = 0, s = abfd->sections; i < abfd->section_count; i++, s = s->next)
3647 if (s->output_section != NULL)
3648 vma = s->output_section->vma + s->output_offset;
3651 if (vma != stash->sec_vma[i])
3657 /* Read debug information from DEBUG_BFD when DEBUG_BFD is specified.
3658 If DEBUG_BFD is not specified, we read debug information from ABFD
3659 or its gnu_debuglink. The results will be stored in PINFO.
3660 The function returns TRUE iff debug information is ready. */
3663 _bfd_dwarf2_slurp_debug_info (bfd *abfd, bfd *debug_bfd,
3664 const struct dwarf_debug_section *debug_sections,
3667 bfd_boolean do_place)
3669 bfd_size_type amt = sizeof (struct dwarf2_debug);
3670 bfd_size_type total_size;
3672 struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
3676 if (section_vma_same (abfd, stash))
3678 _bfd_dwarf2_cleanup_debug_info (abfd, pinfo);
3679 memset (stash, 0, amt);
3683 stash = (struct dwarf2_debug *) bfd_zalloc (abfd, amt);
3687 stash->debug_sections = debug_sections;
3688 stash->syms = symbols;
3689 if (!save_section_vma (abfd, stash))
3694 if (debug_bfd == NULL)
3697 msec = find_debug_info (debug_bfd, debug_sections, NULL);
3698 if (msec == NULL && abfd == debug_bfd)
3700 char * debug_filename = bfd_follow_gnu_debuglink (abfd, DEBUGDIR);
3702 if (debug_filename == NULL)
3703 /* No dwarf2 info, and no gnu_debuglink to follow.
3704 Note that at this point the stash has been allocated, but
3705 contains zeros. This lets future calls to this function
3706 fail more quickly. */
3709 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
3710 || ! bfd_check_format (debug_bfd, bfd_object)
3711 || (msec = find_debug_info (debug_bfd,
3712 debug_sections, NULL)) == NULL
3713 || !bfd_generic_link_read_symbols (debug_bfd))
3716 bfd_close (debug_bfd);
3717 /* FIXME: Should we report our failure to follow the debuglink ? */
3718 free (debug_filename);
3722 symbols = bfd_get_outsymbols (debug_bfd);
3723 stash->syms = symbols;
3724 stash->close_on_cleanup = TRUE;
3726 stash->bfd_ptr = debug_bfd;
3729 && !place_sections (abfd, stash))
3732 /* There can be more than one DWARF2 info section in a BFD these
3733 days. First handle the easy case when there's only one. If
3734 there's more than one, try case two: none of the sections is
3735 compressed. In that case, read them all in and produce one
3736 large stash. We do this in two passes - in the first pass we
3737 just accumulate the section sizes, and in the second pass we
3738 read in the section's contents. (The allows us to avoid
3739 reallocing the data as we add sections to the stash.) If
3740 some or all sections are compressed, then do things the slow
3741 way, with a bunch of reallocs. */
3743 if (! find_debug_info (debug_bfd, debug_sections, msec))
3745 /* Case 1: only one info section. */
3746 total_size = msec->size;
3747 if (! read_section (debug_bfd, &stash->debug_sections[debug_info],
3749 &stash->info_ptr_memory, &total_size))
3754 /* Case 2: multiple sections. */
3755 for (total_size = 0;
3757 msec = find_debug_info (debug_bfd, debug_sections, msec))
3758 total_size += msec->size;
3760 stash->info_ptr_memory = (bfd_byte *) bfd_malloc (total_size);
3761 if (stash->info_ptr_memory == NULL)
3765 for (msec = find_debug_info (debug_bfd, debug_sections, NULL);
3767 msec = find_debug_info (debug_bfd, debug_sections, msec))
3775 if (!(bfd_simple_get_relocated_section_contents
3776 (debug_bfd, msec, stash->info_ptr_memory + total_size,
3784 stash->info_ptr = stash->info_ptr_memory;
3785 stash->info_ptr_end = stash->info_ptr + total_size;
3786 stash->sec = find_debug_info (debug_bfd, debug_sections, NULL);
3787 stash->sec_info_ptr = stash->info_ptr;
3791 /* Find the source code location of SYMBOL. If SYMBOL is NULL
3792 then find the nearest source code location corresponding to
3793 the address SECTION + OFFSET.
3794 Returns TRUE if the line is found without error and fills in
3795 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
3796 NULL the FUNCTIONNAME_PTR is also filled in.
3797 SYMBOLS contains the symbol table for ABFD.
3798 DEBUG_SECTIONS contains the name of the dwarf debug sections.
3799 ADDR_SIZE is the number of bytes in the initial .debug_info length
3800 field and in the abbreviation offset, or zero to indicate that the
3801 default value should be used. */
3804 _bfd_dwarf2_find_nearest_line (bfd *abfd,
3809 const char **filename_ptr,
3810 const char **functionname_ptr,
3811 unsigned int *linenumber_ptr,
3812 unsigned int *discriminator_ptr,
3813 const struct dwarf_debug_section *debug_sections,
3814 unsigned int addr_size,
3817 /* Read each compilation unit from the section .debug_info, and check
3818 to see if it contains the address we are searching for. If yes,
3819 lookup the address, and return the line number info. If no, go
3820 on to the next compilation unit.
3822 We keep a list of all the previously read compilation units, and
3823 a pointer to the next un-read compilation unit. Check the
3824 previously read units before reading more. */
3825 struct dwarf2_debug *stash;
3826 /* What address are we looking for? */
3828 struct comp_unit* each;
3829 struct funcinfo *function = NULL;
3830 bfd_boolean found = FALSE;
3831 bfd_boolean do_line;
3833 *filename_ptr = NULL;
3834 if (functionname_ptr != NULL)
3835 *functionname_ptr = NULL;
3836 *linenumber_ptr = 0;
3837 if (discriminator_ptr)
3838 *discriminator_ptr = 0;
3840 if (! _bfd_dwarf2_slurp_debug_info (abfd, NULL, debug_sections,
3842 (abfd->flags & (EXEC_P | DYNAMIC)) == 0))
3845 stash = (struct dwarf2_debug *) *pinfo;
3847 do_line = symbol != NULL;
3850 BFD_ASSERT (section == NULL && offset == 0 && functionname_ptr == NULL);
3851 section = bfd_get_section (symbol);
3852 addr = symbol->value;
3856 BFD_ASSERT (section != NULL && functionname_ptr != NULL);
3860 if (section->output_section)
3861 addr += section->output_section->vma + section->output_offset;
3863 addr += section->vma;
3865 /* A null info_ptr indicates that there is no dwarf2 info
3866 (or that an error occured while setting up the stash). */
3867 if (! stash->info_ptr)
3870 stash->inliner_chain = NULL;
3872 /* Check the previously read comp. units first. */
3875 /* The info hash tables use quite a bit of memory. We may not want to
3876 always use them. We use some heuristics to decide if and when to
3878 if (stash->info_hash_status == STASH_INFO_HASH_OFF)
3879 stash_maybe_enable_info_hash_tables (abfd, stash);
3881 /* Keep info hash table up to date if they are available. Note that we
3882 may disable the hash tables if there is any error duing update. */
3883 if (stash->info_hash_status == STASH_INFO_HASH_ON)
3884 stash_maybe_update_info_hash_tables (stash);
3886 if (stash->info_hash_status == STASH_INFO_HASH_ON)
3888 found = stash_find_line_fast (stash, symbol, addr, filename_ptr,
3895 /* Check the previously read comp. units first. */
3896 for (each = stash->all_comp_units; each; each = each->next_unit)
3897 if ((symbol->flags & BSF_FUNCTION) == 0
3898 || each->arange.high == 0
3899 || comp_unit_contains_address (each, addr))
3901 found = comp_unit_find_line (each, symbol, addr, filename_ptr,
3902 linenumber_ptr, stash);
3910 bfd_vma min_range = (bfd_vma) -1;
3911 const char * local_filename = NULL;
3912 struct funcinfo *local_function = NULL;
3913 unsigned int local_linenumber = 0;
3914 unsigned int local_discriminator = 0;
3916 for (each = stash->all_comp_units; each; each = each->next_unit)
3918 bfd_vma range = (bfd_vma) -1;
3920 found = ((each->arange.high == 0
3921 || comp_unit_contains_address (each, addr))
3922 && (range = comp_unit_find_nearest_line (each, addr,
3926 & local_discriminator,
3930 /* PRs 15935 15994: Bogus debug information may have provided us
3931 with an erroneous match. We attempt to counter this by
3932 selecting the match that has the smallest address range
3933 associated with it. (We are assuming that corrupt debug info
3934 will tend to result in extra large address ranges rather than
3935 extra small ranges).
3937 This does mean that we scan through all of the CUs associated
3938 with the bfd each time this function is called. But this does
3939 have the benefit of producing consistent results every time the
3940 function is called. */
3941 if (range <= min_range)
3943 if (filename_ptr && local_filename)
3944 * filename_ptr = local_filename;
3946 function = local_function;
3947 if (discriminator_ptr && local_discriminator)
3948 * discriminator_ptr = local_discriminator;
3949 if (local_linenumber)
3950 * linenumber_ptr = local_linenumber;
3956 if (* linenumber_ptr)
3963 /* The DWARF2 spec says that the initial length field, and the
3964 offset of the abbreviation table, should both be 4-byte values.
3965 However, some compilers do things differently. */
3968 BFD_ASSERT (addr_size == 4 || addr_size == 8);
3970 /* Read each remaining comp. units checking each as they are read. */
3971 while (stash->info_ptr < stash->info_ptr_end)
3974 unsigned int offset_size = addr_size;
3975 bfd_byte *info_ptr_unit = stash->info_ptr;
3977 length = read_4_bytes (stash->bfd_ptr, stash->info_ptr, stash->info_ptr_end);
3978 /* A 0xffffff length is the DWARF3 way of indicating
3979 we use 64-bit offsets, instead of 32-bit offsets. */
3980 if (length == 0xffffffff)
3983 length = read_8_bytes (stash->bfd_ptr, stash->info_ptr + 4, stash->info_ptr_end);
3984 stash->info_ptr += 12;
3986 /* A zero length is the IRIX way of indicating 64-bit offsets,
3987 mostly because the 64-bit length will generally fit in 32
3988 bits, and the endianness helps. */
3989 else if (length == 0)
3992 length = read_4_bytes (stash->bfd_ptr, stash->info_ptr + 4, stash->info_ptr_end);
3993 stash->info_ptr += 8;
3995 /* In the absence of the hints above, we assume 32-bit DWARF2
3996 offsets even for targets with 64-bit addresses, because:
3997 a) most of the time these targets will not have generated
3998 more than 2Gb of debug info and so will not need 64-bit
4001 b) if they do use 64-bit offsets but they are not using
4002 the size hints that are tested for above then they are
4003 not conforming to the DWARF3 standard anyway. */
4004 else if (addr_size == 8)
4007 stash->info_ptr += 4;
4010 stash->info_ptr += 4;
4016 each = parse_comp_unit (stash, length, info_ptr_unit,
4019 /* The dwarf information is damaged, don't trust it any
4023 new_ptr = stash->info_ptr + length;
4024 /* PR 17512: file: 1500698c. */
4025 if (new_ptr < stash->info_ptr)
4027 /* A corrupt length value - do not trust the info any more. */
4032 stash->info_ptr = new_ptr;
4034 if (stash->all_comp_units)
4035 stash->all_comp_units->prev_unit = each;
4037 stash->last_comp_unit = each;
4039 each->next_unit = stash->all_comp_units;
4040 stash->all_comp_units = each;
4042 /* DW_AT_low_pc and DW_AT_high_pc are optional for
4043 compilation units. If we don't have them (i.e.,
4044 unit->high == 0), we need to consult the line info table
4045 to see if a compilation unit contains the given
4048 found = (((symbol->flags & BSF_FUNCTION) == 0
4049 || each->arange.high == 0
4050 || comp_unit_contains_address (each, addr))
4051 && comp_unit_find_line (each, symbol, addr,
4056 found = ((each->arange.high == 0
4057 || comp_unit_contains_address (each, addr))
4058 && comp_unit_find_nearest_line (each, addr,
4065 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
4066 == stash->sec->size)
4068 stash->sec = find_debug_info (stash->bfd_ptr, debug_sections,
4070 stash->sec_info_ptr = stash->info_ptr;
4081 if (!function->is_linkage
4082 && _bfd_elf_find_function (abfd, symbols, section, offset,
4083 *filename_ptr ? NULL : filename_ptr,
4086 function->name = *functionname_ptr;
4087 function->is_linkage = TRUE;
4090 *functionname_ptr = function->name;
4092 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
4093 unset_sections (stash);
4099 _bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED,
4100 const char **filename_ptr,
4101 const char **functionname_ptr,
4102 unsigned int *linenumber_ptr,
4105 struct dwarf2_debug *stash;
4107 stash = (struct dwarf2_debug *) *pinfo;
4110 struct funcinfo *func = stash->inliner_chain;
4112 if (func && func->caller_func)
4114 *filename_ptr = func->caller_file;
4115 *functionname_ptr = func->caller_func->name;
4116 *linenumber_ptr = func->caller_line;
4117 stash->inliner_chain = func->caller_func;
4126 _bfd_dwarf2_cleanup_debug_info (bfd *abfd, void **pinfo)
4128 struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
4129 struct comp_unit *each;
4131 if (abfd == NULL || stash == NULL)
4134 for (each = stash->all_comp_units; each; each = each->next_unit)
4136 struct abbrev_info **abbrevs = each->abbrevs;
4137 struct funcinfo *function_table = each->function_table;
4138 struct varinfo *variable_table = each->variable_table;
4141 for (i = 0; i < ABBREV_HASH_SIZE; i++)
4143 struct abbrev_info *abbrev = abbrevs[i];
4147 free (abbrev->attrs);
4148 abbrev = abbrev->next;
4152 if (each->line_table)
4154 free (each->line_table->dirs);
4155 free (each->line_table->files);
4158 while (function_table)
4160 if (function_table->file)
4162 free (function_table->file);
4163 function_table->file = NULL;
4166 if (function_table->caller_file)
4168 free (function_table->caller_file);
4169 function_table->caller_file = NULL;
4171 function_table = function_table->prev_func;
4174 while (variable_table)
4176 if (variable_table->file)
4178 free (variable_table->file);
4179 variable_table->file = NULL;
4182 variable_table = variable_table->prev_var;
4186 if (stash->dwarf_abbrev_buffer)
4187 free (stash->dwarf_abbrev_buffer);
4188 if (stash->dwarf_line_buffer)
4189 free (stash->dwarf_line_buffer);
4190 if (stash->dwarf_str_buffer)
4191 free (stash->dwarf_str_buffer);
4192 if (stash->dwarf_ranges_buffer)
4193 free (stash->dwarf_ranges_buffer);
4194 if (stash->info_ptr_memory)
4195 free (stash->info_ptr_memory);
4196 if (stash->close_on_cleanup)
4197 bfd_close (stash->bfd_ptr);
4198 if (stash->alt_dwarf_str_buffer)
4199 free (stash->alt_dwarf_str_buffer);
4200 if (stash->alt_dwarf_info_buffer)
4201 free (stash->alt_dwarf_info_buffer);
4203 free (stash->sec_vma);
4204 if (stash->adjusted_sections)
4205 free (stash->adjusted_sections);
4206 if (stash->alt_bfd_ptr)
4207 bfd_close (stash->alt_bfd_ptr);
4210 /* Find the function to a particular section and offset,
4211 for error reporting. */
4214 _bfd_elf_find_function (bfd *abfd,
4218 const char **filename_ptr,
4219 const char **functionname_ptr)
4221 struct elf_find_function_cache
4223 asection *last_section;
4225 const char *filename;
4226 bfd_size_type func_size;
4229 if (symbols == NULL)
4232 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
4235 cache = elf_tdata (abfd)->elf_find_function_cache;
4238 cache = bfd_zalloc (abfd, sizeof (*cache));
4239 elf_tdata (abfd)->elf_find_function_cache = cache;
4243 if (cache->last_section != section
4244 || cache->func == NULL
4245 || offset < cache->func->value
4246 || offset >= cache->func->value + cache->func_size)
4251 /* ??? Given multiple file symbols, it is impossible to reliably
4252 choose the right file name for global symbols. File symbols are
4253 local symbols, and thus all file symbols must sort before any
4254 global symbols. The ELF spec may be interpreted to say that a
4255 file symbol must sort before other local symbols, but currently
4256 ld -r doesn't do this. So, for ld -r output, it is possible to
4257 make a better choice of file name for local symbols by ignoring
4258 file symbols appearing after a given local symbol. */
4259 enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
4260 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4264 state = nothing_seen;
4265 cache->filename = NULL;
4267 cache->func_size = 0;
4268 cache->last_section = section;
4270 for (p = symbols; *p != NULL; p++)
4276 if ((sym->flags & BSF_FILE) != 0)
4279 if (state == symbol_seen)
4280 state = file_after_symbol_seen;
4284 size = bed->maybe_function_sym (sym, section, &code_off);
4286 && code_off <= offset
4287 && (code_off > low_func
4288 || (code_off == low_func
4289 && size > cache->func_size)))
4292 cache->func_size = size;
4293 cache->filename = NULL;
4294 low_func = code_off;
4296 && ((sym->flags & BSF_LOCAL) != 0
4297 || state != file_after_symbol_seen))
4298 cache->filename = bfd_asymbol_name (file);
4300 if (state == nothing_seen)
4301 state = symbol_seen;
4305 if (cache->func == NULL)
4309 *filename_ptr = cache->filename;
4310 if (functionname_ptr)
4311 *functionname_ptr = bfd_asymbol_name (cache->func);