2 Copyright (C) 1994-2016 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 /* xgettext: c-format */
550 _bfd_error_handler (_("Dwarf Error: Offset (%lu)"
551 " greater than or equal to %s size (%lu)."),
552 (long) offset, section_name, *section_size);
553 bfd_set_error (bfd_error_bad_value);
560 /* Read dwarf information from a buffer. */
563 read_1_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf, bfd_byte *end)
567 return bfd_get_8 (abfd, buf);
571 read_1_signed_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf, bfd_byte *end)
575 return bfd_get_signed_8 (abfd, buf);
579 read_2_bytes (bfd *abfd, bfd_byte *buf, bfd_byte *end)
583 return bfd_get_16 (abfd, buf);
587 read_4_bytes (bfd *abfd, bfd_byte *buf, bfd_byte *end)
591 return bfd_get_32 (abfd, buf);
595 read_8_bytes (bfd *abfd, bfd_byte *buf, bfd_byte *end)
599 return bfd_get_64 (abfd, buf);
603 read_n_bytes (bfd *abfd ATTRIBUTE_UNUSED,
606 unsigned int size ATTRIBUTE_UNUSED)
608 if (buf + size > end)
613 /* Scans a NUL terminated string starting at BUF, returning a pointer to it.
614 Returns the number of characters in the string, *including* the NUL byte,
615 in BYTES_READ_PTR. This value is set even if the function fails. Bytes
616 at or beyond BUF_END will not be read. Returns NULL if there was a
617 problem, or if the string is empty. */
620 read_string (bfd * abfd ATTRIBUTE_UNUSED,
623 unsigned int * bytes_read_ptr)
629 * bytes_read_ptr = 0;
635 * bytes_read_ptr = 1;
639 while (buf < buf_end)
642 * bytes_read_ptr = buf - str;
646 * bytes_read_ptr = buf - str;
650 /* Reads an offset from BUF and then locates the string at this offset
651 inside the debug string section. Returns a pointer to the string.
652 Returns the number of bytes read from BUF, *not* the length of the string,
653 in BYTES_READ_PTR. This value is set even if the function fails. Bytes
654 at or beyond BUF_END will not be read from BUF. Returns NULL if there was
655 a problem, or if the string is empty. Does not check for NUL termination
659 read_indirect_string (struct comp_unit * unit,
662 unsigned int * bytes_read_ptr)
665 struct dwarf2_debug *stash = unit->stash;
668 if (buf + unit->offset_size > buf_end)
670 * bytes_read_ptr = 0;
674 if (unit->offset_size == 4)
675 offset = read_4_bytes (unit->abfd, buf, buf_end);
677 offset = read_8_bytes (unit->abfd, buf, buf_end);
679 *bytes_read_ptr = unit->offset_size;
681 if (! read_section (unit->abfd, &stash->debug_sections[debug_str],
683 &stash->dwarf_str_buffer, &stash->dwarf_str_size))
686 if (offset >= stash->dwarf_str_size)
688 str = (char *) stash->dwarf_str_buffer + offset;
694 /* Like read_indirect_string but uses a .debug_str located in
695 an alternate file pointed to by the .gnu_debugaltlink section.
696 Used to impement DW_FORM_GNU_strp_alt. */
699 read_alt_indirect_string (struct comp_unit * unit,
702 unsigned int * bytes_read_ptr)
705 struct dwarf2_debug *stash = unit->stash;
708 if (buf + unit->offset_size > buf_end)
710 * bytes_read_ptr = 0;
714 if (unit->offset_size == 4)
715 offset = read_4_bytes (unit->abfd, buf, buf_end);
717 offset = read_8_bytes (unit->abfd, buf, buf_end);
719 *bytes_read_ptr = unit->offset_size;
721 if (stash->alt_bfd_ptr == NULL)
724 char * debug_filename = bfd_follow_gnu_debugaltlink (unit->abfd, DEBUGDIR);
726 if (debug_filename == NULL)
729 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
730 || ! bfd_check_format (debug_bfd, bfd_object))
733 bfd_close (debug_bfd);
735 /* FIXME: Should we report our failure to follow the debuglink ? */
736 free (debug_filename);
739 stash->alt_bfd_ptr = debug_bfd;
742 if (! read_section (unit->stash->alt_bfd_ptr,
743 stash->debug_sections + debug_str_alt,
744 NULL, /* FIXME: Do we need to load alternate symbols ? */
746 &stash->alt_dwarf_str_buffer,
747 &stash->alt_dwarf_str_size))
750 if (offset >= stash->alt_dwarf_str_size)
752 str = (char *) stash->alt_dwarf_str_buffer + offset;
759 /* Resolve an alternate reference from UNIT at OFFSET.
760 Returns a pointer into the loaded alternate CU upon success
761 or NULL upon failure. */
764 read_alt_indirect_ref (struct comp_unit * unit,
767 struct dwarf2_debug *stash = unit->stash;
769 if (stash->alt_bfd_ptr == NULL)
772 char * debug_filename = bfd_follow_gnu_debugaltlink (unit->abfd, DEBUGDIR);
774 if (debug_filename == NULL)
777 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
778 || ! bfd_check_format (debug_bfd, bfd_object))
781 bfd_close (debug_bfd);
783 /* FIXME: Should we report our failure to follow the debuglink ? */
784 free (debug_filename);
787 stash->alt_bfd_ptr = debug_bfd;
790 if (! read_section (unit->stash->alt_bfd_ptr,
791 stash->debug_sections + debug_info_alt,
792 NULL, /* FIXME: Do we need to load alternate symbols ? */
794 &stash->alt_dwarf_info_buffer,
795 &stash->alt_dwarf_info_size))
798 if (offset >= stash->alt_dwarf_info_size)
800 return stash->alt_dwarf_info_buffer + offset;
804 read_address (struct comp_unit *unit, bfd_byte *buf, bfd_byte * buf_end)
808 if (bfd_get_flavour (unit->abfd) == bfd_target_elf_flavour)
809 signed_vma = get_elf_backend_data (unit->abfd)->sign_extend_vma;
811 if (buf + unit->addr_size > buf_end)
816 switch (unit->addr_size)
819 return bfd_get_signed_64 (unit->abfd, buf);
821 return bfd_get_signed_32 (unit->abfd, buf);
823 return bfd_get_signed_16 (unit->abfd, buf);
830 switch (unit->addr_size)
833 return bfd_get_64 (unit->abfd, buf);
835 return bfd_get_32 (unit->abfd, buf);
837 return bfd_get_16 (unit->abfd, buf);
844 /* Lookup an abbrev_info structure in the abbrev hash table. */
846 static struct abbrev_info *
847 lookup_abbrev (unsigned int number, struct abbrev_info **abbrevs)
849 unsigned int hash_number;
850 struct abbrev_info *abbrev;
852 hash_number = number % ABBREV_HASH_SIZE;
853 abbrev = abbrevs[hash_number];
857 if (abbrev->number == number)
860 abbrev = abbrev->next;
866 /* In DWARF version 2, the description of the debugging information is
867 stored in a separate .debug_abbrev section. Before we read any
868 dies from a section we read in all abbreviations and install them
871 static struct abbrev_info**
872 read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
874 struct abbrev_info **abbrevs;
875 bfd_byte *abbrev_ptr;
876 bfd_byte *abbrev_end;
877 struct abbrev_info *cur_abbrev;
878 unsigned int abbrev_number, bytes_read, abbrev_name;
879 unsigned int abbrev_form, hash_number;
882 if (! read_section (abfd, &stash->debug_sections[debug_abbrev],
884 &stash->dwarf_abbrev_buffer, &stash->dwarf_abbrev_size))
887 if (offset >= stash->dwarf_abbrev_size)
890 amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
891 abbrevs = (struct abbrev_info **) bfd_zalloc (abfd, amt);
895 abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
896 abbrev_end = stash->dwarf_abbrev_buffer + stash->dwarf_abbrev_size;
897 abbrev_number = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
898 abbrev_ptr += bytes_read;
900 /* Loop until we reach an abbrev number of 0. */
901 while (abbrev_number)
903 amt = sizeof (struct abbrev_info);
904 cur_abbrev = (struct abbrev_info *) bfd_zalloc (abfd, amt);
905 if (cur_abbrev == NULL)
908 /* Read in abbrev header. */
909 cur_abbrev->number = abbrev_number;
910 cur_abbrev->tag = (enum dwarf_tag)
911 safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
912 abbrev_ptr += bytes_read;
913 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr, abbrev_end);
916 /* Now read in declarations. */
917 abbrev_name = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
918 abbrev_ptr += bytes_read;
919 abbrev_form = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
920 abbrev_ptr += bytes_read;
924 if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
926 struct attr_abbrev *tmp;
928 amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
929 amt *= sizeof (struct attr_abbrev);
930 tmp = (struct attr_abbrev *) bfd_realloc (cur_abbrev->attrs, amt);
935 for (i = 0; i < ABBREV_HASH_SIZE; i++)
937 struct abbrev_info *abbrev = abbrevs[i];
941 free (abbrev->attrs);
942 abbrev = abbrev->next;
947 cur_abbrev->attrs = tmp;
950 cur_abbrev->attrs[cur_abbrev->num_attrs].name
951 = (enum dwarf_attribute) abbrev_name;
952 cur_abbrev->attrs[cur_abbrev->num_attrs++].form
953 = (enum dwarf_form) abbrev_form;
954 abbrev_name = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
955 abbrev_ptr += bytes_read;
956 abbrev_form = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
957 abbrev_ptr += bytes_read;
960 hash_number = abbrev_number % ABBREV_HASH_SIZE;
961 cur_abbrev->next = abbrevs[hash_number];
962 abbrevs[hash_number] = cur_abbrev;
964 /* Get next abbreviation.
965 Under Irix6 the abbreviations for a compilation unit are not
966 always properly terminated with an abbrev number of 0.
967 Exit loop if we encounter an abbreviation which we have
968 already read (which means we are about to read the abbreviations
969 for the next compile unit) or if the end of the abbreviation
971 if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
972 >= stash->dwarf_abbrev_size)
974 abbrev_number = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
975 abbrev_ptr += bytes_read;
976 if (lookup_abbrev (abbrev_number, abbrevs) != NULL)
983 /* Returns true if the form is one which has a string value. */
985 static inline bfd_boolean
986 is_str_attr (enum dwarf_form form)
988 return form == DW_FORM_string || form == DW_FORM_strp || form == DW_FORM_GNU_strp_alt;
991 /* Read and fill in the value of attribute ATTR as described by FORM.
992 Read data starting from INFO_PTR, but never at or beyond INFO_PTR_END.
993 Returns an updated INFO_PTR taking into account the amount of data read. */
996 read_attribute_value (struct attribute * attr,
998 struct comp_unit * unit,
1000 bfd_byte * info_ptr_end)
1002 bfd *abfd = unit->abfd;
1003 unsigned int bytes_read;
1004 struct dwarf_block *blk;
1007 if (info_ptr >= info_ptr_end && form != DW_FORM_flag_present)
1009 _bfd_error_handler (_("Dwarf Error: Info pointer extends beyond end of attributes"));
1010 bfd_set_error (bfd_error_bad_value);
1014 attr->form = (enum dwarf_form) form;
1018 case DW_FORM_ref_addr:
1019 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
1021 if (unit->version == 3 || unit->version == 4)
1023 if (unit->offset_size == 4)
1024 attr->u.val = read_4_bytes (unit->abfd, info_ptr, info_ptr_end);
1026 attr->u.val = read_8_bytes (unit->abfd, info_ptr, info_ptr_end);
1027 info_ptr += unit->offset_size;
1032 attr->u.val = read_address (unit, info_ptr, info_ptr_end);
1033 info_ptr += unit->addr_size;
1035 case DW_FORM_GNU_ref_alt:
1036 case DW_FORM_sec_offset:
1037 if (unit->offset_size == 4)
1038 attr->u.val = read_4_bytes (unit->abfd, info_ptr, info_ptr_end);
1040 attr->u.val = read_8_bytes (unit->abfd, info_ptr, info_ptr_end);
1041 info_ptr += unit->offset_size;
1043 case DW_FORM_block2:
1044 amt = sizeof (struct dwarf_block);
1045 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1048 blk->size = read_2_bytes (abfd, info_ptr, info_ptr_end);
1050 blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
1051 info_ptr += blk->size;
1054 case DW_FORM_block4:
1055 amt = sizeof (struct dwarf_block);
1056 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1059 blk->size = read_4_bytes (abfd, info_ptr, info_ptr_end);
1061 blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
1062 info_ptr += blk->size;
1066 attr->u.val = read_2_bytes (abfd, info_ptr, info_ptr_end);
1070 attr->u.val = read_4_bytes (abfd, info_ptr, info_ptr_end);
1074 attr->u.val = read_8_bytes (abfd, info_ptr, info_ptr_end);
1077 case DW_FORM_string:
1078 attr->u.str = read_string (abfd, info_ptr, info_ptr_end, &bytes_read);
1079 info_ptr += bytes_read;
1082 attr->u.str = read_indirect_string (unit, info_ptr, info_ptr_end, &bytes_read);
1083 info_ptr += bytes_read;
1085 case DW_FORM_GNU_strp_alt:
1086 attr->u.str = read_alt_indirect_string (unit, info_ptr, info_ptr_end, &bytes_read);
1087 info_ptr += bytes_read;
1089 case DW_FORM_exprloc:
1091 amt = sizeof (struct dwarf_block);
1092 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1095 blk->size = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
1096 info_ptr += bytes_read;
1097 blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
1098 info_ptr += blk->size;
1101 case DW_FORM_block1:
1102 amt = sizeof (struct dwarf_block);
1103 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1106 blk->size = read_1_byte (abfd, info_ptr, info_ptr_end);
1108 blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
1109 info_ptr += blk->size;
1113 attr->u.val = read_1_byte (abfd, info_ptr, info_ptr_end);
1117 attr->u.val = read_1_byte (abfd, info_ptr, info_ptr_end);
1120 case DW_FORM_flag_present:
1124 attr->u.sval = safe_read_leb128 (abfd, info_ptr, &bytes_read, TRUE, info_ptr_end);
1125 info_ptr += bytes_read;
1128 attr->u.val = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
1129 info_ptr += bytes_read;
1132 attr->u.val = read_1_byte (abfd, info_ptr, info_ptr_end);
1136 attr->u.val = read_2_bytes (abfd, info_ptr, info_ptr_end);
1140 attr->u.val = read_4_bytes (abfd, info_ptr, info_ptr_end);
1144 attr->u.val = read_8_bytes (abfd, info_ptr, info_ptr_end);
1147 case DW_FORM_ref_sig8:
1148 attr->u.val = read_8_bytes (abfd, info_ptr, info_ptr_end);
1151 case DW_FORM_ref_udata:
1152 attr->u.val = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
1153 info_ptr += bytes_read;
1155 case DW_FORM_indirect:
1156 form = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
1157 info_ptr += bytes_read;
1158 info_ptr = read_attribute_value (attr, form, unit, info_ptr, info_ptr_end);
1161 _bfd_error_handler (_("Dwarf Error: Invalid or unhandled FORM value: %#x."),
1163 bfd_set_error (bfd_error_bad_value);
1169 /* Read an attribute described by an abbreviated attribute. */
1172 read_attribute (struct attribute * attr,
1173 struct attr_abbrev * abbrev,
1174 struct comp_unit * unit,
1175 bfd_byte * info_ptr,
1176 bfd_byte * info_ptr_end)
1178 attr->name = abbrev->name;
1179 info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr, info_ptr_end);
1183 /* Return whether DW_AT_name will return the same as DW_AT_linkage_name
1187 non_mangled (int lang)
1197 case DW_LANG_Cobol74:
1198 case DW_LANG_Cobol85:
1199 case DW_LANG_Fortran77:
1200 case DW_LANG_Pascal83:
1210 /* Source line information table routines. */
1212 #define FILE_ALLOC_CHUNK 5
1213 #define DIR_ALLOC_CHUNK 5
1217 struct line_info* prev_line;
1221 unsigned int column;
1222 unsigned int discriminator;
1223 unsigned char op_index;
1224 unsigned char end_sequence; /* End of (sequential) code sequence. */
1235 struct line_sequence
1238 struct line_sequence* prev_sequence;
1239 struct line_info* last_line; /* Largest VMA. */
1242 struct line_info_table
1245 unsigned int num_files;
1246 unsigned int num_dirs;
1247 unsigned int num_sequences;
1250 struct fileinfo* files;
1251 struct line_sequence* sequences;
1252 struct line_info* lcl_head; /* Local head; used in 'add_line_info'. */
1255 /* Remember some information about each function. If the function is
1256 inlined (DW_TAG_inlined_subroutine) it may have two additional
1257 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
1258 source code location where this function was inlined. */
1262 /* Pointer to previous function in list of all functions. */
1263 struct funcinfo *prev_func;
1264 /* Pointer to function one scope higher. */
1265 struct funcinfo *caller_func;
1266 /* Source location file name where caller_func inlines this func. */
1268 /* Source location file name. */
1270 /* Source location line number where caller_func inlines this func. */
1272 /* Source location line number. */
1275 bfd_boolean is_linkage;
1277 struct arange arange;
1278 /* Where the symbol is defined. */
1284 /* Pointer to previous variable in list of all variables */
1285 struct varinfo *prev_var;
1286 /* Source location file name */
1288 /* Source location line number */
1293 /* Where the symbol is defined */
1295 /* Is this a stack variable? */
1296 unsigned int stack: 1;
1299 /* Return TRUE if NEW_LINE should sort after LINE. */
1301 static inline bfd_boolean
1302 new_line_sorts_after (struct line_info *new_line, struct line_info *line)
1304 return (new_line->address > line->address
1305 || (new_line->address == line->address
1306 && (new_line->op_index > line->op_index
1307 || (new_line->op_index == line->op_index
1308 && new_line->end_sequence < line->end_sequence))));
1312 /* Adds a new entry to the line_info list in the line_info_table, ensuring
1313 that the list is sorted. Note that the line_info list is sorted from
1314 highest to lowest VMA (with possible duplicates); that is,
1315 line_info->prev_line always accesses an equal or smaller VMA. */
1318 add_line_info (struct line_info_table *table,
1320 unsigned char op_index,
1323 unsigned int column,
1324 unsigned int discriminator,
1327 bfd_size_type amt = sizeof (struct line_info);
1328 struct line_sequence* seq = table->sequences;
1329 struct line_info* info = (struct line_info *) bfd_alloc (table->abfd, amt);
1334 /* Set member data of 'info'. */
1335 info->prev_line = NULL;
1336 info->address = address;
1337 info->op_index = op_index;
1339 info->column = column;
1340 info->discriminator = discriminator;
1341 info->end_sequence = end_sequence;
1343 if (filename && filename[0])
1345 info->filename = (char *) bfd_alloc (table->abfd, strlen (filename) + 1);
1346 if (info->filename == NULL)
1348 strcpy (info->filename, filename);
1351 info->filename = NULL;
1353 /* Find the correct location for 'info'. Normally we will receive
1354 new line_info data 1) in order and 2) with increasing VMAs.
1355 However some compilers break the rules (cf. decode_line_info) and
1356 so we include some heuristics for quickly finding the correct
1357 location for 'info'. In particular, these heuristics optimize for
1358 the common case in which the VMA sequence that we receive is a
1359 list of locally sorted VMAs such as
1360 p...z a...j (where a < j < p < z)
1362 Note: table->lcl_head is used to head an *actual* or *possible*
1363 sub-sequence within the list (such as a...j) that is not directly
1364 headed by table->last_line
1366 Note: we may receive duplicate entries from 'decode_line_info'. */
1369 && seq->last_line->address == address
1370 && seq->last_line->op_index == op_index
1371 && seq->last_line->end_sequence == end_sequence)
1373 /* We only keep the last entry with the same address and end
1374 sequence. See PR ld/4986. */
1375 if (table->lcl_head == seq->last_line)
1376 table->lcl_head = info;
1377 info->prev_line = seq->last_line->prev_line;
1378 seq->last_line = info;
1380 else if (!seq || seq->last_line->end_sequence)
1382 /* Start a new line sequence. */
1383 amt = sizeof (struct line_sequence);
1384 seq = (struct line_sequence *) bfd_malloc (amt);
1387 seq->low_pc = address;
1388 seq->prev_sequence = table->sequences;
1389 seq->last_line = info;
1390 table->lcl_head = info;
1391 table->sequences = seq;
1392 table->num_sequences++;
1394 else if (new_line_sorts_after (info, seq->last_line))
1396 /* Normal case: add 'info' to the beginning of the current sequence. */
1397 info->prev_line = seq->last_line;
1398 seq->last_line = info;
1400 /* lcl_head: initialize to head a *possible* sequence at the end. */
1401 if (!table->lcl_head)
1402 table->lcl_head = info;
1404 else if (!new_line_sorts_after (info, table->lcl_head)
1405 && (!table->lcl_head->prev_line
1406 || new_line_sorts_after (info, table->lcl_head->prev_line)))
1408 /* Abnormal but easy: lcl_head is the head of 'info'. */
1409 info->prev_line = table->lcl_head->prev_line;
1410 table->lcl_head->prev_line = info;
1414 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head'
1415 are valid heads for 'info'. Reset 'lcl_head'. */
1416 struct line_info* li2 = seq->last_line; /* Always non-NULL. */
1417 struct line_info* li1 = li2->prev_line;
1421 if (!new_line_sorts_after (info, li2)
1422 && new_line_sorts_after (info, li1))
1425 li2 = li1; /* always non-NULL */
1426 li1 = li1->prev_line;
1428 table->lcl_head = li2;
1429 info->prev_line = table->lcl_head->prev_line;
1430 table->lcl_head->prev_line = info;
1431 if (address < seq->low_pc)
1432 seq->low_pc = address;
1437 /* Extract a fully qualified filename from a line info table.
1438 The returned string has been malloc'ed and it is the caller's
1439 responsibility to free it. */
1442 concat_filename (struct line_info_table *table, unsigned int file)
1446 if (file - 1 >= table->num_files)
1448 /* FILE == 0 means unknown. */
1451 (_("Dwarf Error: mangled line number section (bad file number)."));
1452 return strdup ("<unknown>");
1455 filename = table->files[file - 1].name;
1457 if (!IS_ABSOLUTE_PATH (filename))
1459 char *dir_name = NULL;
1460 char *subdir_name = NULL;
1464 if (table->files[file - 1].dir
1465 /* PR 17512: file: 0317e960. */
1466 && table->files[file - 1].dir <= table->num_dirs
1467 /* PR 17512: file: 7f3d2e4b. */
1468 && table->dirs != NULL)
1469 subdir_name = table->dirs[table->files[file - 1].dir - 1];
1471 if (!subdir_name || !IS_ABSOLUTE_PATH (subdir_name))
1472 dir_name = table->comp_dir;
1476 dir_name = subdir_name;
1481 return strdup (filename);
1483 len = strlen (dir_name) + strlen (filename) + 2;
1487 len += strlen (subdir_name) + 1;
1488 name = (char *) bfd_malloc (len);
1490 sprintf (name, "%s/%s/%s", dir_name, subdir_name, filename);
1494 name = (char *) bfd_malloc (len);
1496 sprintf (name, "%s/%s", dir_name, filename);
1502 return strdup (filename);
1506 arange_add (const struct comp_unit *unit, struct arange *first_arange,
1507 bfd_vma low_pc, bfd_vma high_pc)
1509 struct arange *arange;
1511 /* Ignore empty ranges. */
1512 if (low_pc == high_pc)
1515 /* If the first arange is empty, use it. */
1516 if (first_arange->high == 0)
1518 first_arange->low = low_pc;
1519 first_arange->high = high_pc;
1523 /* Next see if we can cheaply extend an existing range. */
1524 arange = first_arange;
1527 if (low_pc == arange->high)
1529 arange->high = high_pc;
1532 if (high_pc == arange->low)
1534 arange->low = low_pc;
1537 arange = arange->next;
1541 /* Need to allocate a new arange and insert it into the arange list.
1542 Order isn't significant, so just insert after the first arange. */
1543 arange = (struct arange *) bfd_alloc (unit->abfd, sizeof (*arange));
1546 arange->low = low_pc;
1547 arange->high = high_pc;
1548 arange->next = first_arange->next;
1549 first_arange->next = arange;
1553 /* Compare function for line sequences. */
1556 compare_sequences (const void* a, const void* b)
1558 const struct line_sequence* seq1 = a;
1559 const struct line_sequence* seq2 = b;
1561 /* Sort by low_pc as the primary key. */
1562 if (seq1->low_pc < seq2->low_pc)
1564 if (seq1->low_pc > seq2->low_pc)
1567 /* If low_pc values are equal, sort in reverse order of
1568 high_pc, so that the largest region comes first. */
1569 if (seq1->last_line->address < seq2->last_line->address)
1571 if (seq1->last_line->address > seq2->last_line->address)
1574 if (seq1->last_line->op_index < seq2->last_line->op_index)
1576 if (seq1->last_line->op_index > seq2->last_line->op_index)
1582 /* Sort the line sequences for quick lookup. */
1585 sort_line_sequences (struct line_info_table* table)
1588 struct line_sequence* sequences;
1589 struct line_sequence* seq;
1591 unsigned int num_sequences = table->num_sequences;
1592 bfd_vma last_high_pc;
1594 if (num_sequences == 0)
1597 /* Allocate space for an array of sequences. */
1598 amt = sizeof (struct line_sequence) * num_sequences;
1599 sequences = (struct line_sequence *) bfd_alloc (table->abfd, amt);
1600 if (sequences == NULL)
1603 /* Copy the linked list into the array, freeing the original nodes. */
1604 seq = table->sequences;
1605 for (n = 0; n < num_sequences; n++)
1607 struct line_sequence* last_seq = seq;
1610 sequences[n].low_pc = seq->low_pc;
1611 sequences[n].prev_sequence = NULL;
1612 sequences[n].last_line = seq->last_line;
1613 seq = seq->prev_sequence;
1616 BFD_ASSERT (seq == NULL);
1618 qsort (sequences, n, sizeof (struct line_sequence), compare_sequences);
1620 /* Make the list binary-searchable by trimming overlapping entries
1621 and removing nested entries. */
1623 last_high_pc = sequences[0].last_line->address;
1624 for (n = 1; n < table->num_sequences; n++)
1626 if (sequences[n].low_pc < last_high_pc)
1628 if (sequences[n].last_line->address <= last_high_pc)
1629 /* Skip nested entries. */
1632 /* Trim overlapping entries. */
1633 sequences[n].low_pc = last_high_pc;
1635 last_high_pc = sequences[n].last_line->address;
1636 if (n > num_sequences)
1638 /* Close up the gap. */
1639 sequences[num_sequences].low_pc = sequences[n].low_pc;
1640 sequences[num_sequences].last_line = sequences[n].last_line;
1645 table->sequences = sequences;
1646 table->num_sequences = num_sequences;
1650 /* Decode the line number information for UNIT. */
1652 static struct line_info_table*
1653 decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
1655 bfd *abfd = unit->abfd;
1656 struct line_info_table* table;
1659 struct line_head lh;
1660 unsigned int i, bytes_read, offset_size;
1661 char *cur_file, *cur_dir;
1662 unsigned char op_code, extended_op, adj_opcode;
1663 unsigned int exop_len;
1666 if (! read_section (abfd, &stash->debug_sections[debug_line],
1667 stash->syms, unit->line_offset,
1668 &stash->dwarf_line_buffer, &stash->dwarf_line_size))
1671 amt = sizeof (struct line_info_table);
1672 table = (struct line_info_table *) bfd_alloc (abfd, amt);
1676 table->comp_dir = unit->comp_dir;
1678 table->num_files = 0;
1679 table->files = NULL;
1681 table->num_dirs = 0;
1684 table->num_sequences = 0;
1685 table->sequences = NULL;
1687 table->lcl_head = NULL;
1689 if (stash->dwarf_line_size < 16)
1692 (_("Dwarf Error: Line info section is too small (%ld)"),
1693 (long) stash->dwarf_line_size);
1694 bfd_set_error (bfd_error_bad_value);
1697 line_ptr = stash->dwarf_line_buffer + unit->line_offset;
1698 line_end = stash->dwarf_line_buffer + stash->dwarf_line_size;
1700 /* Read in the prologue. */
1701 lh.total_length = read_4_bytes (abfd, line_ptr, line_end);
1704 if (lh.total_length == 0xffffffff)
1706 lh.total_length = read_8_bytes (abfd, line_ptr, line_end);
1710 else if (lh.total_length == 0 && unit->addr_size == 8)
1712 /* Handle (non-standard) 64-bit DWARF2 formats. */
1713 lh.total_length = read_4_bytes (abfd, line_ptr, line_end);
1718 if (lh.total_length > stash->dwarf_line_size)
1721 /* xgettext: c-format */
1722 (_("Dwarf Error: Line info data is bigger (0x%lx) than the section (0x%lx)"),
1723 (long) lh.total_length, (long) stash->dwarf_line_size);
1724 bfd_set_error (bfd_error_bad_value);
1728 line_end = line_ptr + lh.total_length;
1730 lh.version = read_2_bytes (abfd, line_ptr, line_end);
1731 if (lh.version < 2 || lh.version > 4)
1734 (_("Dwarf Error: Unhandled .debug_line version %d."), lh.version);
1735 bfd_set_error (bfd_error_bad_value);
1740 if (line_ptr + offset_size + (lh.version >=4 ? 6 : 5) >= line_end)
1743 (_("Dwarf Error: Ran out of room reading prologue"));
1744 bfd_set_error (bfd_error_bad_value);
1748 if (offset_size == 4)
1749 lh.prologue_length = read_4_bytes (abfd, line_ptr, line_end);
1751 lh.prologue_length = read_8_bytes (abfd, line_ptr, line_end);
1752 line_ptr += offset_size;
1754 lh.minimum_instruction_length = read_1_byte (abfd, line_ptr, line_end);
1757 if (lh.version >= 4)
1759 lh.maximum_ops_per_insn = read_1_byte (abfd, line_ptr, line_end);
1763 lh.maximum_ops_per_insn = 1;
1765 if (lh.maximum_ops_per_insn == 0)
1768 (_("Dwarf Error: Invalid maximum operations per instruction."));
1769 bfd_set_error (bfd_error_bad_value);
1773 lh.default_is_stmt = read_1_byte (abfd, line_ptr, line_end);
1776 lh.line_base = read_1_signed_byte (abfd, line_ptr, line_end);
1779 lh.line_range = read_1_byte (abfd, line_ptr, line_end);
1782 lh.opcode_base = read_1_byte (abfd, line_ptr, line_end);
1785 if (line_ptr + (lh.opcode_base - 1) >= line_end)
1787 _bfd_error_handler (_("Dwarf Error: Ran out of room reading opcodes"));
1788 bfd_set_error (bfd_error_bad_value);
1792 amt = lh.opcode_base * sizeof (unsigned char);
1793 lh.standard_opcode_lengths = (unsigned char *) bfd_alloc (abfd, amt);
1795 lh.standard_opcode_lengths[0] = 1;
1797 for (i = 1; i < lh.opcode_base; ++i)
1799 lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr, line_end);
1803 /* Read directory table. */
1804 while ((cur_dir = read_string (abfd, line_ptr, line_end, &bytes_read)) != NULL)
1806 line_ptr += bytes_read;
1808 if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
1812 amt = table->num_dirs + DIR_ALLOC_CHUNK;
1813 amt *= sizeof (char *);
1815 tmp = (char **) bfd_realloc (table->dirs, amt);
1821 table->dirs[table->num_dirs++] = cur_dir;
1824 line_ptr += bytes_read;
1826 /* Read file name table. */
1827 while ((cur_file = read_string (abfd, line_ptr, line_end, &bytes_read)) != NULL)
1829 line_ptr += bytes_read;
1831 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1833 struct fileinfo *tmp;
1835 amt = table->num_files + FILE_ALLOC_CHUNK;
1836 amt *= sizeof (struct fileinfo);
1838 tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
1844 table->files[table->num_files].name = cur_file;
1845 table->files[table->num_files].dir =
1846 safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1847 line_ptr += bytes_read;
1848 table->files[table->num_files].time = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1849 line_ptr += bytes_read;
1850 table->files[table->num_files].size = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1851 line_ptr += bytes_read;
1855 line_ptr += bytes_read;
1857 /* Read the statement sequences until there's nothing left. */
1858 while (line_ptr < line_end)
1860 /* State machine registers. */
1861 bfd_vma address = 0;
1862 unsigned char op_index = 0;
1863 char * filename = table->num_files ? concat_filename (table, 1) : NULL;
1864 unsigned int line = 1;
1865 unsigned int column = 0;
1866 unsigned int discriminator = 0;
1867 int is_stmt = lh.default_is_stmt;
1868 int end_sequence = 0;
1869 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1870 compilers generate address sequences that are wildly out of
1871 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1872 for ia64-Linux). Thus, to determine the low and high
1873 address, we must compare on every DW_LNS_copy, etc. */
1874 bfd_vma low_pc = (bfd_vma) -1;
1875 bfd_vma high_pc = 0;
1877 /* Decode the table. */
1878 while (! end_sequence)
1880 op_code = read_1_byte (abfd, line_ptr, line_end);
1883 if (op_code >= lh.opcode_base)
1885 /* Special operand. */
1886 adj_opcode = op_code - lh.opcode_base;
1887 if (lh.line_range == 0)
1889 if (lh.maximum_ops_per_insn == 1)
1890 address += (adj_opcode / lh.line_range
1891 * lh.minimum_instruction_length);
1894 address += ((op_index + adj_opcode / lh.line_range)
1895 / lh.maximum_ops_per_insn
1896 * lh.minimum_instruction_length);
1897 op_index = ((op_index + adj_opcode / lh.line_range)
1898 % lh.maximum_ops_per_insn);
1900 line += lh.line_base + (adj_opcode % lh.line_range);
1901 /* Append row to matrix using current values. */
1902 if (!add_line_info (table, address, op_index, filename,
1903 line, column, discriminator, 0))
1906 if (address < low_pc)
1908 if (address > high_pc)
1911 else switch (op_code)
1913 case DW_LNS_extended_op:
1914 exop_len = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1915 line_ptr += bytes_read;
1916 extended_op = read_1_byte (abfd, line_ptr, line_end);
1919 switch (extended_op)
1921 case DW_LNE_end_sequence:
1923 if (!add_line_info (table, address, op_index, filename, line,
1924 column, discriminator, end_sequence))
1927 if (address < low_pc)
1929 if (address > high_pc)
1931 if (!arange_add (unit, &unit->arange, low_pc, high_pc))
1934 case DW_LNE_set_address:
1935 address = read_address (unit, line_ptr, line_end);
1937 line_ptr += unit->addr_size;
1939 case DW_LNE_define_file:
1940 cur_file = read_string (abfd, line_ptr, line_end, &bytes_read);
1941 line_ptr += bytes_read;
1942 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1944 struct fileinfo *tmp;
1946 amt = table->num_files + FILE_ALLOC_CHUNK;
1947 amt *= sizeof (struct fileinfo);
1948 tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
1953 table->files[table->num_files].name = cur_file;
1954 table->files[table->num_files].dir =
1955 safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1956 line_ptr += bytes_read;
1957 table->files[table->num_files].time =
1958 safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1959 line_ptr += bytes_read;
1960 table->files[table->num_files].size =
1961 safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1962 line_ptr += bytes_read;
1965 case DW_LNE_set_discriminator:
1967 safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1968 line_ptr += bytes_read;
1970 case DW_LNE_HP_source_file_correlation:
1971 line_ptr += exop_len - 1;
1975 (_("Dwarf Error: mangled line number section."));
1976 bfd_set_error (bfd_error_bad_value);
1978 if (filename != NULL)
1984 if (!add_line_info (table, address, op_index,
1985 filename, line, column, discriminator, 0))
1988 if (address < low_pc)
1990 if (address > high_pc)
1993 case DW_LNS_advance_pc:
1994 if (lh.maximum_ops_per_insn == 1)
1995 address += (lh.minimum_instruction_length
1996 * safe_read_leb128 (abfd, line_ptr, &bytes_read,
2000 bfd_vma adjust = safe_read_leb128 (abfd, line_ptr, &bytes_read,
2002 address = ((op_index + adjust) / lh.maximum_ops_per_insn
2003 * lh.minimum_instruction_length);
2004 op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
2006 line_ptr += bytes_read;
2008 case DW_LNS_advance_line:
2009 line += safe_read_leb128 (abfd, line_ptr, &bytes_read, TRUE, line_end);
2010 line_ptr += bytes_read;
2012 case DW_LNS_set_file:
2016 /* The file and directory tables are 0
2017 based, the references are 1 based. */
2018 file = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
2019 line_ptr += bytes_read;
2022 filename = concat_filename (table, file);
2025 case DW_LNS_set_column:
2026 column = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
2027 line_ptr += bytes_read;
2029 case DW_LNS_negate_stmt:
2030 is_stmt = (!is_stmt);
2032 case DW_LNS_set_basic_block:
2034 case DW_LNS_const_add_pc:
2035 if (lh.maximum_ops_per_insn == 1)
2036 address += (lh.minimum_instruction_length
2037 * ((255 - lh.opcode_base) / lh.line_range));
2040 bfd_vma adjust = ((255 - lh.opcode_base) / lh.line_range);
2041 address += (lh.minimum_instruction_length
2042 * ((op_index + adjust)
2043 / lh.maximum_ops_per_insn));
2044 op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
2047 case DW_LNS_fixed_advance_pc:
2048 address += read_2_bytes (abfd, line_ptr, line_end);
2053 /* Unknown standard opcode, ignore it. */
2054 for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
2056 (void) safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
2057 line_ptr += bytes_read;
2067 if (sort_line_sequences (table))
2071 if (table->sequences != NULL)
2072 free (table->sequences);
2073 if (table->files != NULL)
2074 free (table->files);
2075 if (table->dirs != NULL)
2080 /* If ADDR is within TABLE set the output parameters and return the
2081 range of addresses covered by the entry used to fill them out.
2082 Otherwise set * FILENAME_PTR to NULL and return 0.
2083 The parameters FILENAME_PTR, LINENUMBER_PTR and DISCRIMINATOR_PTR
2084 are pointers to the objects to be filled in. */
2087 lookup_address_in_line_info_table (struct line_info_table *table,
2089 const char **filename_ptr,
2090 unsigned int *linenumber_ptr,
2091 unsigned int *discriminator_ptr)
2093 struct line_sequence *seq = NULL;
2094 struct line_info *each_line;
2097 /* Binary search the array of sequences. */
2099 high = table->num_sequences;
2102 mid = (low + high) / 2;
2103 seq = &table->sequences[mid];
2104 if (addr < seq->low_pc)
2106 else if (addr >= seq->last_line->address)
2112 if (seq && addr >= seq->low_pc && addr < seq->last_line->address)
2114 /* Note: seq->last_line should be a descendingly sorted list. */
2115 for (each_line = seq->last_line;
2117 each_line = each_line->prev_line)
2118 if (addr >= each_line->address)
2122 && !(each_line->end_sequence || each_line == seq->last_line))
2124 *filename_ptr = each_line->filename;
2125 *linenumber_ptr = each_line->line;
2126 if (discriminator_ptr)
2127 *discriminator_ptr = each_line->discriminator;
2128 return seq->last_line->address - seq->low_pc;
2132 *filename_ptr = NULL;
2136 /* Read in the .debug_ranges section for future reference. */
2139 read_debug_ranges (struct comp_unit *unit)
2141 struct dwarf2_debug *stash = unit->stash;
2142 return read_section (unit->abfd, &stash->debug_sections[debug_ranges],
2144 &stash->dwarf_ranges_buffer, &stash->dwarf_ranges_size);
2147 /* Function table functions. */
2149 /* If ADDR is within UNIT's function tables, set FUNCTION_PTR, and return
2150 TRUE. Note that we need to find the function that has the smallest range
2151 that contains ADDR, to handle inlined functions without depending upon
2152 them being ordered in TABLE by increasing range. */
2155 lookup_address_in_function_table (struct comp_unit *unit,
2157 struct funcinfo **function_ptr)
2159 struct funcinfo* each_func;
2160 struct funcinfo* best_fit = NULL;
2161 bfd_vma best_fit_len = 0;
2162 struct arange *arange;
2164 for (each_func = unit->function_table;
2166 each_func = each_func->prev_func)
2168 for (arange = &each_func->arange;
2170 arange = arange->next)
2172 if (addr >= arange->low && addr < arange->high)
2175 || arange->high - arange->low < best_fit_len)
2177 best_fit = each_func;
2178 best_fit_len = arange->high - arange->low;
2186 *function_ptr = best_fit;
2192 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
2193 and LINENUMBER_PTR, and return TRUE. */
2196 lookup_symbol_in_function_table (struct comp_unit *unit,
2199 const char **filename_ptr,
2200 unsigned int *linenumber_ptr)
2202 struct funcinfo* each_func;
2203 struct funcinfo* best_fit = NULL;
2204 bfd_vma best_fit_len = 0;
2205 struct arange *arange;
2206 const char *name = bfd_asymbol_name (sym);
2207 asection *sec = bfd_get_section (sym);
2209 for (each_func = unit->function_table;
2211 each_func = each_func->prev_func)
2213 for (arange = &each_func->arange;
2215 arange = arange->next)
2217 if ((!each_func->sec || each_func->sec == sec)
2218 && addr >= arange->low
2219 && addr < arange->high
2221 && strcmp (name, each_func->name) == 0
2223 || arange->high - arange->low < best_fit_len))
2225 best_fit = each_func;
2226 best_fit_len = arange->high - arange->low;
2233 best_fit->sec = sec;
2234 *filename_ptr = best_fit->file;
2235 *linenumber_ptr = best_fit->line;
2242 /* Variable table functions. */
2244 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
2245 LINENUMBER_PTR, and return TRUE. */
2248 lookup_symbol_in_variable_table (struct comp_unit *unit,
2251 const char **filename_ptr,
2252 unsigned int *linenumber_ptr)
2254 const char *name = bfd_asymbol_name (sym);
2255 asection *sec = bfd_get_section (sym);
2256 struct varinfo* each;
2258 for (each = unit->variable_table; each; each = each->prev_var)
2259 if (each->stack == 0
2260 && each->file != NULL
2261 && each->name != NULL
2262 && each->addr == addr
2263 && (!each->sec || each->sec == sec)
2264 && strcmp (name, each->name) == 0)
2270 *filename_ptr = each->file;
2271 *linenumber_ptr = each->line;
2279 find_abstract_instance_name (struct comp_unit *unit,
2280 struct attribute *attr_ptr,
2281 bfd_boolean *is_linkage)
2283 bfd *abfd = unit->abfd;
2285 bfd_byte *info_ptr_end;
2286 unsigned int abbrev_number, bytes_read, i;
2287 struct abbrev_info *abbrev;
2288 bfd_uint64_t die_ref = attr_ptr->u.val;
2289 struct attribute attr;
2292 /* DW_FORM_ref_addr can reference an entry in a different CU. It
2293 is an offset from the .debug_info section, not the current CU. */
2294 if (attr_ptr->form == DW_FORM_ref_addr)
2296 /* We only support DW_FORM_ref_addr within the same file, so
2297 any relocations should be resolved already. */
2301 info_ptr = unit->sec_info_ptr + die_ref;
2302 info_ptr_end = unit->end_ptr;
2304 /* Now find the CU containing this pointer. */
2305 if (info_ptr >= unit->info_ptr_unit && info_ptr < unit->end_ptr)
2309 /* Check other CUs to see if they contain the abbrev. */
2310 struct comp_unit * u;
2312 for (u = unit->prev_unit; u != NULL; u = u->prev_unit)
2313 if (info_ptr >= u->info_ptr_unit && info_ptr < u->end_ptr)
2317 for (u = unit->next_unit; u != NULL; u = u->next_unit)
2318 if (info_ptr >= u->info_ptr_unit && info_ptr < u->end_ptr)
2323 /* else FIXME: What do we do now ? */
2326 else if (attr_ptr->form == DW_FORM_GNU_ref_alt)
2328 info_ptr = read_alt_indirect_ref (unit, die_ref);
2329 if (info_ptr == NULL)
2332 (_("Dwarf Error: Unable to read alt ref %u."), die_ref);
2333 bfd_set_error (bfd_error_bad_value);
2336 info_ptr_end = unit->stash->alt_dwarf_info_buffer + unit->stash->alt_dwarf_info_size;
2338 /* FIXME: Do we need to locate the correct CU, in a similar
2339 fashion to the code in the DW_FORM_ref_addr case above ? */
2343 info_ptr = unit->info_ptr_unit + die_ref;
2344 info_ptr_end = unit->end_ptr;
2347 abbrev_number = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
2348 info_ptr += bytes_read;
2352 abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
2356 (_("Dwarf Error: Could not find abbrev number %u."), abbrev_number);
2357 bfd_set_error (bfd_error_bad_value);
2361 for (i = 0; i < abbrev->num_attrs; ++i)
2363 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit,
2364 info_ptr, info_ptr_end);
2365 if (info_ptr == NULL)
2370 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2372 if (name == NULL && is_str_attr (attr.form))
2375 if (non_mangled (unit->lang))
2379 case DW_AT_specification:
2380 name = find_abstract_instance_name (unit, &attr, is_linkage);
2382 case DW_AT_linkage_name:
2383 case DW_AT_MIPS_linkage_name:
2384 /* PR 16949: Corrupt debug info can place
2385 non-string forms into these attributes. */
2386 if (is_str_attr (attr.form))
2402 read_rangelist (struct comp_unit *unit, struct arange *arange,
2403 bfd_uint64_t offset)
2405 bfd_byte *ranges_ptr;
2406 bfd_byte *ranges_end;
2407 bfd_vma base_address = unit->base_address;
2409 if (! unit->stash->dwarf_ranges_buffer)
2411 if (! read_debug_ranges (unit))
2415 ranges_ptr = unit->stash->dwarf_ranges_buffer + offset;
2416 if (ranges_ptr < unit->stash->dwarf_ranges_buffer)
2418 ranges_end = unit->stash->dwarf_ranges_buffer + unit->stash->dwarf_ranges_size;
2425 /* PR 17512: file: 62cada7d. */
2426 if (ranges_ptr + 2 * unit->addr_size > ranges_end)
2429 low_pc = read_address (unit, ranges_ptr, ranges_end);
2430 ranges_ptr += unit->addr_size;
2431 high_pc = read_address (unit, ranges_ptr, ranges_end);
2432 ranges_ptr += unit->addr_size;
2434 if (low_pc == 0 && high_pc == 0)
2436 if (low_pc == -1UL && high_pc != -1UL)
2437 base_address = high_pc;
2440 if (!arange_add (unit, arange,
2441 base_address + low_pc, base_address + high_pc))
2448 /* DWARF2 Compilation unit functions. */
2450 /* Scan over each die in a comp. unit looking for functions to add
2451 to the function table and variables to the variable table. */
2454 scan_unit_for_symbols (struct comp_unit *unit)
2456 bfd *abfd = unit->abfd;
2457 bfd_byte *info_ptr = unit->first_child_die_ptr;
2458 bfd_byte *info_ptr_end = unit->stash->info_ptr_end;
2459 int nesting_level = 1;
2460 struct funcinfo **nested_funcs;
2461 int nested_funcs_size;
2463 /* Maintain a stack of in-scope functions and inlined functions, which we
2464 can use to set the caller_func field. */
2465 nested_funcs_size = 32;
2466 nested_funcs = (struct funcinfo **)
2467 bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *));
2468 if (nested_funcs == NULL)
2470 nested_funcs[nesting_level] = 0;
2472 while (nesting_level)
2474 unsigned int abbrev_number, bytes_read, i;
2475 struct abbrev_info *abbrev;
2476 struct attribute attr;
2477 struct funcinfo *func;
2478 struct varinfo *var;
2480 bfd_vma high_pc = 0;
2481 bfd_boolean high_pc_relative = FALSE;
2483 /* PR 17512: file: 9f405d9d. */
2484 if (info_ptr >= info_ptr_end)
2487 abbrev_number = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
2488 info_ptr += bytes_read;
2490 if (! abbrev_number)
2496 abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
2500 (_("Dwarf Error: Could not find abbrev number %u."),
2502 bfd_set_error (bfd_error_bad_value);
2507 if (abbrev->tag == DW_TAG_subprogram
2508 || abbrev->tag == DW_TAG_entry_point
2509 || abbrev->tag == DW_TAG_inlined_subroutine)
2511 bfd_size_type amt = sizeof (struct funcinfo);
2512 func = (struct funcinfo *) bfd_zalloc (abfd, amt);
2515 func->tag = abbrev->tag;
2516 func->prev_func = unit->function_table;
2517 unit->function_table = func;
2518 BFD_ASSERT (!unit->cached);
2520 if (func->tag == DW_TAG_inlined_subroutine)
2521 for (i = nesting_level - 1; i >= 1; i--)
2522 if (nested_funcs[i])
2524 func->caller_func = nested_funcs[i];
2527 nested_funcs[nesting_level] = func;
2532 if (abbrev->tag == DW_TAG_variable)
2534 bfd_size_type amt = sizeof (struct varinfo);
2535 var = (struct varinfo *) bfd_zalloc (abfd, amt);
2538 var->tag = abbrev->tag;
2540 var->prev_var = unit->variable_table;
2541 unit->variable_table = var;
2542 BFD_ASSERT (!unit->cached);
2545 /* No inline function in scope at this nesting level. */
2546 nested_funcs[nesting_level] = 0;
2549 for (i = 0; i < abbrev->num_attrs; ++i)
2551 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr, info_ptr_end);
2552 if (info_ptr == NULL)
2559 case DW_AT_call_file:
2560 func->caller_file = concat_filename (unit->line_table,
2564 case DW_AT_call_line:
2565 func->caller_line = attr.u.val;
2568 case DW_AT_abstract_origin:
2569 case DW_AT_specification:
2570 func->name = find_abstract_instance_name (unit, &attr,
2575 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2577 if (func->name == NULL && is_str_attr (attr.form))
2579 func->name = attr.u.str;
2580 if (non_mangled (unit->lang))
2581 func->is_linkage = TRUE;
2585 case DW_AT_linkage_name:
2586 case DW_AT_MIPS_linkage_name:
2587 /* PR 16949: Corrupt debug info can place
2588 non-string forms into these attributes. */
2589 if (is_str_attr (attr.form))
2591 func->name = attr.u.str;
2592 func->is_linkage = TRUE;
2597 low_pc = attr.u.val;
2601 high_pc = attr.u.val;
2602 high_pc_relative = attr.form != DW_FORM_addr;
2606 if (!read_rangelist (unit, &func->arange, attr.u.val))
2610 case DW_AT_decl_file:
2611 func->file = concat_filename (unit->line_table,
2615 case DW_AT_decl_line:
2616 func->line = attr.u.val;
2628 var->name = attr.u.str;
2631 case DW_AT_decl_file:
2632 var->file = concat_filename (unit->line_table,
2636 case DW_AT_decl_line:
2637 var->line = attr.u.val;
2640 case DW_AT_external:
2641 if (attr.u.val != 0)
2645 case DW_AT_location:
2649 case DW_FORM_block1:
2650 case DW_FORM_block2:
2651 case DW_FORM_block4:
2652 case DW_FORM_exprloc:
2653 if (*attr.u.blk->data == DW_OP_addr)
2657 /* Verify that DW_OP_addr is the only opcode in the
2658 location, in which case the block size will be 1
2659 plus the address size. */
2660 /* ??? For TLS variables, gcc can emit
2661 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
2662 which we don't handle here yet. */
2663 if (attr.u.blk->size == unit->addr_size + 1U)
2664 var->addr = bfd_get (unit->addr_size * 8,
2666 attr.u.blk->data + 1);
2681 if (high_pc_relative)
2684 if (func && high_pc != 0)
2686 if (!arange_add (unit, &func->arange, low_pc, high_pc))
2690 if (abbrev->has_children)
2694 if (nesting_level >= nested_funcs_size)
2696 struct funcinfo **tmp;
2698 nested_funcs_size *= 2;
2699 tmp = (struct funcinfo **)
2700 bfd_realloc (nested_funcs,
2701 nested_funcs_size * sizeof (struct funcinfo *));
2706 nested_funcs[nesting_level] = 0;
2710 free (nested_funcs);
2714 free (nested_funcs);
2718 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
2719 includes the compilation unit header that proceeds the DIE's, but
2720 does not include the length field that precedes each compilation
2721 unit header. END_PTR points one past the end of this comp unit.
2722 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
2724 This routine does not read the whole compilation unit; only enough
2725 to get to the line number information for the compilation unit. */
2727 static struct comp_unit *
2728 parse_comp_unit (struct dwarf2_debug *stash,
2729 bfd_vma unit_length,
2730 bfd_byte *info_ptr_unit,
2731 unsigned int offset_size)
2733 struct comp_unit* unit;
2734 unsigned int version;
2735 bfd_uint64_t abbrev_offset = 0;
2736 unsigned int addr_size;
2737 struct abbrev_info** abbrevs;
2738 unsigned int abbrev_number, bytes_read, i;
2739 struct abbrev_info *abbrev;
2740 struct attribute attr;
2741 bfd_byte *info_ptr = stash->info_ptr;
2742 bfd_byte *end_ptr = info_ptr + unit_length;
2745 bfd_vma high_pc = 0;
2746 bfd *abfd = stash->bfd_ptr;
2747 bfd_boolean high_pc_relative = FALSE;
2749 version = read_2_bytes (abfd, info_ptr, end_ptr);
2751 BFD_ASSERT (offset_size == 4 || offset_size == 8);
2752 if (offset_size == 4)
2753 abbrev_offset = read_4_bytes (abfd, info_ptr, end_ptr);
2755 abbrev_offset = read_8_bytes (abfd, info_ptr, end_ptr);
2756 info_ptr += offset_size;
2757 addr_size = read_1_byte (abfd, info_ptr, end_ptr);
2760 if (version != 2 && version != 3 && version != 4)
2762 /* PR 19872: A version number of 0 probably means that there is padding
2763 at the end of the .debug_info section. Gold puts it there when
2764 performing an incremental link, for example. So do not generate
2765 an error, just return a NULL. */
2769 (_("Dwarf Error: found dwarf version '%u', this reader"
2770 " only handles version 2, 3 and 4 information."), version);
2771 bfd_set_error (bfd_error_bad_value);
2776 if (addr_size > sizeof (bfd_vma))
2779 /* xgettext: c-format */
2780 (_("Dwarf Error: found address size '%u', this reader"
2781 " can not handle sizes greater than '%u'."),
2783 (unsigned int) sizeof (bfd_vma));
2784 bfd_set_error (bfd_error_bad_value);
2788 if (addr_size != 2 && addr_size != 4 && addr_size != 8)
2791 ("Dwarf Error: found address size '%u', this reader"
2792 " can only handle address sizes '2', '4' and '8'.", addr_size);
2793 bfd_set_error (bfd_error_bad_value);
2797 /* Read the abbrevs for this compilation unit into a table. */
2798 abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
2802 abbrev_number = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, end_ptr);
2803 info_ptr += bytes_read;
2804 if (! abbrev_number)
2806 /* PR 19872: An abbrev number of 0 probably means that there is padding
2807 at the end of the .debug_abbrev section. Gold puts it there when
2808 performing an incremental link, for example. So do not generate
2809 an error, just return a NULL. */
2813 abbrev = lookup_abbrev (abbrev_number, abbrevs);
2816 _bfd_error_handler (_("Dwarf Error: Could not find abbrev number %u."),
2818 bfd_set_error (bfd_error_bad_value);
2822 amt = sizeof (struct comp_unit);
2823 unit = (struct comp_unit *) bfd_zalloc (abfd, amt);
2827 unit->version = version;
2828 unit->addr_size = addr_size;
2829 unit->offset_size = offset_size;
2830 unit->abbrevs = abbrevs;
2831 unit->end_ptr = end_ptr;
2832 unit->stash = stash;
2833 unit->info_ptr_unit = info_ptr_unit;
2834 unit->sec_info_ptr = stash->sec_info_ptr;
2836 for (i = 0; i < abbrev->num_attrs; ++i)
2838 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr, end_ptr);
2839 if (info_ptr == NULL)
2842 /* Store the data if it is of an attribute we want to keep in a
2843 partial symbol table. */
2846 case DW_AT_stmt_list:
2848 unit->line_offset = attr.u.val;
2852 unit->name = attr.u.str;
2856 low_pc = attr.u.val;
2857 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
2858 this is the base address to use when reading location
2859 lists or range lists. */
2860 if (abbrev->tag == DW_TAG_compile_unit)
2861 unit->base_address = low_pc;
2865 high_pc = attr.u.val;
2866 high_pc_relative = attr.form != DW_FORM_addr;
2870 if (!read_rangelist (unit, &unit->arange, attr.u.val))
2874 case DW_AT_comp_dir:
2876 char *comp_dir = attr.u.str;
2878 /* PR 17512: file: 1fe726be. */
2879 if (! is_str_attr (attr.form))
2882 (_("Dwarf Error: DW_AT_comp_dir attribute encountered with a non-string form."));
2888 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2889 directory, get rid of it. */
2890 char *cp = strchr (comp_dir, ':');
2892 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
2895 unit->comp_dir = comp_dir;
2899 case DW_AT_language:
2900 unit->lang = attr.u.val;
2907 if (high_pc_relative)
2911 if (!arange_add (unit, &unit->arange, low_pc, high_pc))
2915 unit->first_child_die_ptr = info_ptr;
2919 /* Return TRUE if UNIT may contain the address given by ADDR. When
2920 there are functions written entirely with inline asm statements, the
2921 range info in the compilation unit header may not be correct. We
2922 need to consult the line info table to see if a compilation unit
2923 really contains the given address. */
2926 comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
2928 struct arange *arange;
2933 arange = &unit->arange;
2936 if (addr >= arange->low && addr < arange->high)
2938 arange = arange->next;
2945 /* If UNIT contains ADDR, set the output parameters to the values for
2946 the line containing ADDR. The output parameters, FILENAME_PTR,
2947 FUNCTION_PTR, and LINENUMBER_PTR, are pointers to the objects
2950 Returns the range of addresses covered by the entry that was used
2951 to fill in *LINENUMBER_PTR or 0 if it was not filled in. */
2954 comp_unit_find_nearest_line (struct comp_unit *unit,
2956 const char **filename_ptr,
2957 struct funcinfo **function_ptr,
2958 unsigned int *linenumber_ptr,
2959 unsigned int *discriminator_ptr,
2960 struct dwarf2_debug *stash)
2967 if (! unit->line_table)
2969 if (! unit->stmtlist)
2975 unit->line_table = decode_line_info (unit, stash);
2977 if (! unit->line_table)
2983 if (unit->first_child_die_ptr < unit->end_ptr
2984 && ! scan_unit_for_symbols (unit))
2991 *function_ptr = NULL;
2992 func_p = lookup_address_in_function_table (unit, addr, function_ptr);
2993 if (func_p && (*function_ptr)->tag == DW_TAG_inlined_subroutine)
2994 stash->inliner_chain = *function_ptr;
2996 return lookup_address_in_line_info_table (unit->line_table, addr,
3002 /* Check to see if line info is already decoded in a comp_unit.
3003 If not, decode it. Returns TRUE if no errors were encountered;
3007 comp_unit_maybe_decode_line_info (struct comp_unit *unit,
3008 struct dwarf2_debug *stash)
3013 if (! unit->line_table)
3015 if (! unit->stmtlist)
3021 unit->line_table = decode_line_info (unit, stash);
3023 if (! unit->line_table)
3029 if (unit->first_child_die_ptr < unit->end_ptr
3030 && ! scan_unit_for_symbols (unit))
3040 /* If UNIT contains SYM at ADDR, set the output parameters to the
3041 values for the line containing SYM. The output parameters,
3042 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
3045 Return TRUE if UNIT contains SYM, and no errors were encountered;
3049 comp_unit_find_line (struct comp_unit *unit,
3052 const char **filename_ptr,
3053 unsigned int *linenumber_ptr,
3054 struct dwarf2_debug *stash)
3056 if (!comp_unit_maybe_decode_line_info (unit, stash))
3059 if (sym->flags & BSF_FUNCTION)
3060 return lookup_symbol_in_function_table (unit, sym, addr,
3064 return lookup_symbol_in_variable_table (unit, sym, addr,
3069 static struct funcinfo *
3070 reverse_funcinfo_list (struct funcinfo *head)
3072 struct funcinfo *rhead;
3073 struct funcinfo *temp;
3075 for (rhead = NULL; head; head = temp)
3077 temp = head->prev_func;
3078 head->prev_func = rhead;
3084 static struct varinfo *
3085 reverse_varinfo_list (struct varinfo *head)
3087 struct varinfo *rhead;
3088 struct varinfo *temp;
3090 for (rhead = NULL; head; head = temp)
3092 temp = head->prev_var;
3093 head->prev_var = rhead;
3099 /* Extract all interesting funcinfos and varinfos of a compilation
3100 unit into hash tables for faster lookup. Returns TRUE if no
3101 errors were enountered; FALSE otherwise. */
3104 comp_unit_hash_info (struct dwarf2_debug *stash,
3105 struct comp_unit *unit,
3106 struct info_hash_table *funcinfo_hash_table,
3107 struct info_hash_table *varinfo_hash_table)
3109 struct funcinfo* each_func;
3110 struct varinfo* each_var;
3111 bfd_boolean okay = TRUE;
3113 BFD_ASSERT (stash->info_hash_status != STASH_INFO_HASH_DISABLED);
3115 if (!comp_unit_maybe_decode_line_info (unit, stash))
3118 BFD_ASSERT (!unit->cached);
3120 /* To preserve the original search order, we went to visit the function
3121 infos in the reversed order of the list. However, making the list
3122 bi-directional use quite a bit of extra memory. So we reverse
3123 the list first, traverse the list in the now reversed order and
3124 finally reverse the list again to get back the original order. */
3125 unit->function_table = reverse_funcinfo_list (unit->function_table);
3126 for (each_func = unit->function_table;
3128 each_func = each_func->prev_func)
3130 /* Skip nameless functions. */
3131 if (each_func->name)
3132 /* There is no need to copy name string into hash table as
3133 name string is either in the dwarf string buffer or
3134 info in the stash. */
3135 okay = insert_info_hash_table (funcinfo_hash_table, each_func->name,
3136 (void*) each_func, FALSE);
3138 unit->function_table = reverse_funcinfo_list (unit->function_table);
3142 /* We do the same for variable infos. */
3143 unit->variable_table = reverse_varinfo_list (unit->variable_table);
3144 for (each_var = unit->variable_table;
3146 each_var = each_var->prev_var)
3148 /* Skip stack vars and vars with no files or names. */
3149 if (each_var->stack == 0
3150 && each_var->file != NULL
3151 && each_var->name != NULL)
3152 /* There is no need to copy name string into hash table as
3153 name string is either in the dwarf string buffer or
3154 info in the stash. */
3155 okay = insert_info_hash_table (varinfo_hash_table, each_var->name,
3156 (void*) each_var, FALSE);
3159 unit->variable_table = reverse_varinfo_list (unit->variable_table);
3160 unit->cached = TRUE;
3164 /* Locate a section in a BFD containing debugging info. The search starts
3165 from the section after AFTER_SEC, or from the first section in the BFD if
3166 AFTER_SEC is NULL. The search works by examining the names of the
3167 sections. There are three permissiable names. The first two are given
3168 by DEBUG_SECTIONS[debug_info] (whose standard DWARF2 names are .debug_info
3169 and .zdebug_info). The third is a prefix .gnu.linkonce.wi.
3170 This is a variation on the .debug_info section which has a checksum
3171 describing the contents appended onto the name. This allows the linker to
3172 identify and discard duplicate debugging sections for different
3173 compilation units. */
3174 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
3177 find_debug_info (bfd *abfd, const struct dwarf_debug_section *debug_sections,
3178 asection *after_sec)
3183 if (after_sec == NULL)
3185 look = debug_sections[debug_info].uncompressed_name;
3186 msec = bfd_get_section_by_name (abfd, look);
3190 look = debug_sections[debug_info].compressed_name;
3193 msec = bfd_get_section_by_name (abfd, look);
3198 for (msec = abfd->sections; msec != NULL; msec = msec->next)
3199 if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
3205 for (msec = after_sec->next; msec != NULL; msec = msec->next)
3207 look = debug_sections[debug_info].uncompressed_name;
3208 if (strcmp (msec->name, look) == 0)
3211 look = debug_sections[debug_info].compressed_name;
3212 if (look != NULL && strcmp (msec->name, look) == 0)
3215 if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
3222 /* Transfer VMAs from object file to separate debug file. */
3225 set_debug_vma (bfd *orig_bfd, bfd *debug_bfd)
3229 for (s = orig_bfd->sections, d = debug_bfd->sections;
3230 s != NULL && d != NULL;
3231 s = s->next, d = d->next)
3233 if ((d->flags & SEC_DEBUGGING) != 0)
3235 /* ??? Assumes 1-1 correspondence between sections in the
3237 if (strcmp (s->name, d->name) == 0)
3239 d->output_section = s->output_section;
3240 d->output_offset = s->output_offset;
3246 /* Unset vmas for adjusted sections in STASH. */
3249 unset_sections (struct dwarf2_debug *stash)
3252 struct adjusted_section *p;
3254 i = stash->adjusted_section_count;
3255 p = stash->adjusted_sections;
3256 for (; i > 0; i--, p++)
3257 p->section->vma = 0;
3260 /* Set VMAs for allocated and .debug_info sections in ORIG_BFD, a
3261 relocatable object file. VMAs are normally all zero in relocatable
3262 object files, so if we want to distinguish locations in sections by
3263 address we need to set VMAs so the sections do not overlap. We
3264 also set VMA on .debug_info so that when we have multiple
3265 .debug_info sections (or the linkonce variant) they also do not
3266 overlap. The multiple .debug_info sections make up a single
3267 logical section. ??? We should probably do the same for other
3271 place_sections (bfd *orig_bfd, struct dwarf2_debug *stash)
3274 struct adjusted_section *p;
3276 const char *debug_info_name;
3278 if (stash->adjusted_section_count != 0)
3280 i = stash->adjusted_section_count;
3281 p = stash->adjusted_sections;
3282 for (; i > 0; i--, p++)
3283 p->section->vma = p->adj_vma;
3287 debug_info_name = stash->debug_sections[debug_info].uncompressed_name;
3294 for (sect = abfd->sections; sect != NULL; sect = sect->next)
3298 if ((sect->output_section != NULL
3299 && sect->output_section != sect
3300 && (sect->flags & SEC_DEBUGGING) == 0)
3304 is_debug_info = (strcmp (sect->name, debug_info_name) == 0
3305 || CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO));
3307 if (!((sect->flags & SEC_ALLOC) != 0 && abfd == orig_bfd)
3313 if (abfd == stash->bfd_ptr)
3315 abfd = stash->bfd_ptr;
3319 stash->adjusted_section_count = -1;
3322 bfd_vma last_vma = 0, last_dwarf = 0;
3323 bfd_size_type amt = i * sizeof (struct adjusted_section);
3325 p = (struct adjusted_section *) bfd_malloc (amt);
3329 stash->adjusted_sections = p;
3330 stash->adjusted_section_count = i;
3337 for (sect = abfd->sections; sect != NULL; sect = sect->next)
3342 if ((sect->output_section != NULL
3343 && sect->output_section != sect
3344 && (sect->flags & SEC_DEBUGGING) == 0)
3348 is_debug_info = (strcmp (sect->name, debug_info_name) == 0
3349 || CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO));
3351 if (!((sect->flags & SEC_ALLOC) != 0 && abfd == orig_bfd)
3355 sz = sect->rawsize ? sect->rawsize : sect->size;
3359 BFD_ASSERT (sect->alignment_power == 0);
3360 sect->vma = last_dwarf;
3365 /* Align the new address to the current section
3367 last_vma = ((last_vma
3368 + ~(-((bfd_vma) 1 << sect->alignment_power)))
3369 & (-((bfd_vma) 1 << sect->alignment_power)));
3370 sect->vma = last_vma;
3375 p->adj_vma = sect->vma;
3378 if (abfd == stash->bfd_ptr)
3380 abfd = stash->bfd_ptr;
3384 if (orig_bfd != stash->bfd_ptr)
3385 set_debug_vma (orig_bfd, stash->bfd_ptr);
3390 /* Look up a funcinfo by name using the given info hash table. If found,
3391 also update the locations pointed to by filename_ptr and linenumber_ptr.
3393 This function returns TRUE if a funcinfo that matches the given symbol
3394 and address is found with any error; otherwise it returns FALSE. */
3397 info_hash_lookup_funcinfo (struct info_hash_table *hash_table,
3400 const char **filename_ptr,
3401 unsigned int *linenumber_ptr)
3403 struct funcinfo* each_func;
3404 struct funcinfo* best_fit = NULL;
3405 bfd_vma best_fit_len = 0;
3406 struct info_list_node *node;
3407 struct arange *arange;
3408 const char *name = bfd_asymbol_name (sym);
3409 asection *sec = bfd_get_section (sym);
3411 for (node = lookup_info_hash_table (hash_table, name);
3415 each_func = (struct funcinfo *) node->info;
3416 for (arange = &each_func->arange;
3418 arange = arange->next)
3420 if ((!each_func->sec || each_func->sec == sec)
3421 && addr >= arange->low
3422 && addr < arange->high
3424 || arange->high - arange->low < best_fit_len))
3426 best_fit = each_func;
3427 best_fit_len = arange->high - arange->low;
3434 best_fit->sec = sec;
3435 *filename_ptr = best_fit->file;
3436 *linenumber_ptr = best_fit->line;
3443 /* Look up a varinfo by name using the given info hash table. If found,
3444 also update the locations pointed to by filename_ptr and linenumber_ptr.
3446 This function returns TRUE if a varinfo that matches the given symbol
3447 and address is found with any error; otherwise it returns FALSE. */
3450 info_hash_lookup_varinfo (struct info_hash_table *hash_table,
3453 const char **filename_ptr,
3454 unsigned int *linenumber_ptr)
3456 const char *name = bfd_asymbol_name (sym);
3457 asection *sec = bfd_get_section (sym);
3458 struct varinfo* each;
3459 struct info_list_node *node;
3461 for (node = lookup_info_hash_table (hash_table, name);
3465 each = (struct varinfo *) node->info;
3466 if (each->addr == addr
3467 && (!each->sec || each->sec == sec))
3470 *filename_ptr = each->file;
3471 *linenumber_ptr = each->line;
3479 /* Update the funcinfo and varinfo info hash tables if they are
3480 not up to date. Returns TRUE if there is no error; otherwise
3481 returns FALSE and disable the info hash tables. */
3484 stash_maybe_update_info_hash_tables (struct dwarf2_debug *stash)
3486 struct comp_unit *each;
3488 /* Exit if hash tables are up-to-date. */
3489 if (stash->all_comp_units == stash->hash_units_head)
3492 if (stash->hash_units_head)
3493 each = stash->hash_units_head->prev_unit;
3495 each = stash->last_comp_unit;
3499 if (!comp_unit_hash_info (stash, each, stash->funcinfo_hash_table,
3500 stash->varinfo_hash_table))
3502 stash->info_hash_status = STASH_INFO_HASH_DISABLED;
3505 each = each->prev_unit;
3508 stash->hash_units_head = stash->all_comp_units;
3512 /* Check consistency of info hash tables. This is for debugging only. */
3514 static void ATTRIBUTE_UNUSED
3515 stash_verify_info_hash_table (struct dwarf2_debug *stash)
3517 struct comp_unit *each_unit;
3518 struct funcinfo *each_func;
3519 struct varinfo *each_var;
3520 struct info_list_node *node;
3523 for (each_unit = stash->all_comp_units;
3525 each_unit = each_unit->next_unit)
3527 for (each_func = each_unit->function_table;
3529 each_func = each_func->prev_func)
3531 if (!each_func->name)
3533 node = lookup_info_hash_table (stash->funcinfo_hash_table,
3537 while (node && !found)
3539 found = node->info == each_func;
3545 for (each_var = each_unit->variable_table;
3547 each_var = each_var->prev_var)
3549 if (!each_var->name || !each_var->file || each_var->stack)
3551 node = lookup_info_hash_table (stash->varinfo_hash_table,
3555 while (node && !found)
3557 found = node->info == each_var;
3565 /* Check to see if we want to enable the info hash tables, which consume
3566 quite a bit of memory. Currently we only check the number times
3567 bfd_dwarf2_find_line is called. In the future, we may also want to
3568 take the number of symbols into account. */
3571 stash_maybe_enable_info_hash_tables (bfd *abfd, struct dwarf2_debug *stash)
3573 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_OFF);
3575 if (stash->info_hash_count++ < STASH_INFO_HASH_TRIGGER)
3578 /* FIXME: Maybe we should check the reduce_memory_overheads
3579 and optimize fields in the bfd_link_info structure ? */
3581 /* Create hash tables. */
3582 stash->funcinfo_hash_table = create_info_hash_table (abfd);
3583 stash->varinfo_hash_table = create_info_hash_table (abfd);
3584 if (!stash->funcinfo_hash_table || !stash->varinfo_hash_table)
3586 /* Turn off info hashes if any allocation above fails. */
3587 stash->info_hash_status = STASH_INFO_HASH_DISABLED;
3590 /* We need a forced update so that the info hash tables will
3591 be created even though there is no compilation unit. That
3592 happens if STASH_INFO_HASH_TRIGGER is 0. */
3593 stash_maybe_update_info_hash_tables (stash);
3594 stash->info_hash_status = STASH_INFO_HASH_ON;
3597 /* Find the file and line associated with a symbol and address using the
3598 info hash tables of a stash. If there is a match, the function returns
3599 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
3600 otherwise it returns FALSE. */
3603 stash_find_line_fast (struct dwarf2_debug *stash,
3606 const char **filename_ptr,
3607 unsigned int *linenumber_ptr)
3609 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_ON);
3611 if (sym->flags & BSF_FUNCTION)
3612 return info_hash_lookup_funcinfo (stash->funcinfo_hash_table, sym, addr,
3613 filename_ptr, linenumber_ptr);
3614 return info_hash_lookup_varinfo (stash->varinfo_hash_table, sym, addr,
3615 filename_ptr, linenumber_ptr);
3618 /* Save current section VMAs. */
3621 save_section_vma (const bfd *abfd, struct dwarf2_debug *stash)
3626 if (abfd->section_count == 0)
3628 stash->sec_vma = bfd_malloc (sizeof (*stash->sec_vma) * abfd->section_count);
3629 if (stash->sec_vma == NULL)
3631 for (i = 0, s = abfd->sections; i < abfd->section_count; i++, s = s->next)
3633 if (s->output_section != NULL)
3634 stash->sec_vma[i] = s->output_section->vma + s->output_offset;
3636 stash->sec_vma[i] = s->vma;
3641 /* Compare current section VMAs against those at the time the stash
3642 was created. If find_nearest_line is used in linker warnings or
3643 errors early in the link process, the debug info stash will be
3644 invalid for later calls. This is because we relocate debug info
3645 sections, so the stashed section contents depend on symbol values,
3646 which in turn depend on section VMAs. */
3649 section_vma_same (const bfd *abfd, const struct dwarf2_debug *stash)
3654 for (i = 0, s = abfd->sections; i < abfd->section_count; i++, s = s->next)
3658 if (s->output_section != NULL)
3659 vma = s->output_section->vma + s->output_offset;
3662 if (vma != stash->sec_vma[i])
3668 /* Read debug information from DEBUG_BFD when DEBUG_BFD is specified.
3669 If DEBUG_BFD is not specified, we read debug information from ABFD
3670 or its gnu_debuglink. The results will be stored in PINFO.
3671 The function returns TRUE iff debug information is ready. */
3674 _bfd_dwarf2_slurp_debug_info (bfd *abfd, bfd *debug_bfd,
3675 const struct dwarf_debug_section *debug_sections,
3678 bfd_boolean do_place)
3680 bfd_size_type amt = sizeof (struct dwarf2_debug);
3681 bfd_size_type total_size;
3683 struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
3687 if (section_vma_same (abfd, stash))
3689 _bfd_dwarf2_cleanup_debug_info (abfd, pinfo);
3690 memset (stash, 0, amt);
3694 stash = (struct dwarf2_debug *) bfd_zalloc (abfd, amt);
3698 stash->debug_sections = debug_sections;
3699 stash->syms = symbols;
3700 if (!save_section_vma (abfd, stash))
3705 if (debug_bfd == NULL)
3708 msec = find_debug_info (debug_bfd, debug_sections, NULL);
3709 if (msec == NULL && abfd == debug_bfd)
3711 char * debug_filename = bfd_follow_gnu_debuglink (abfd, DEBUGDIR);
3713 if (debug_filename == NULL)
3714 /* No dwarf2 info, and no gnu_debuglink to follow.
3715 Note that at this point the stash has been allocated, but
3716 contains zeros. This lets future calls to this function
3717 fail more quickly. */
3720 /* Set BFD_DECOMPRESS to decompress debug sections. */
3721 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
3722 || !(debug_bfd->flags |= BFD_DECOMPRESS,
3723 bfd_check_format (debug_bfd, bfd_object))
3724 || (msec = find_debug_info (debug_bfd,
3725 debug_sections, NULL)) == NULL
3726 || !bfd_generic_link_read_symbols (debug_bfd))
3729 bfd_close (debug_bfd);
3730 /* FIXME: Should we report our failure to follow the debuglink ? */
3731 free (debug_filename);
3735 symbols = bfd_get_outsymbols (debug_bfd);
3736 stash->syms = symbols;
3737 stash->close_on_cleanup = TRUE;
3739 stash->bfd_ptr = debug_bfd;
3742 && !place_sections (abfd, stash))
3745 /* There can be more than one DWARF2 info section in a BFD these
3746 days. First handle the easy case when there's only one. If
3747 there's more than one, try case two: none of the sections is
3748 compressed. In that case, read them all in and produce one
3749 large stash. We do this in two passes - in the first pass we
3750 just accumulate the section sizes, and in the second pass we
3751 read in the section's contents. (The allows us to avoid
3752 reallocing the data as we add sections to the stash.) If
3753 some or all sections are compressed, then do things the slow
3754 way, with a bunch of reallocs. */
3756 if (! find_debug_info (debug_bfd, debug_sections, msec))
3758 /* Case 1: only one info section. */
3759 total_size = msec->size;
3760 if (! read_section (debug_bfd, &stash->debug_sections[debug_info],
3762 &stash->info_ptr_memory, &total_size))
3767 /* Case 2: multiple sections. */
3768 for (total_size = 0;
3770 msec = find_debug_info (debug_bfd, debug_sections, msec))
3771 total_size += msec->size;
3773 stash->info_ptr_memory = (bfd_byte *) bfd_malloc (total_size);
3774 if (stash->info_ptr_memory == NULL)
3778 for (msec = find_debug_info (debug_bfd, debug_sections, NULL);
3780 msec = find_debug_info (debug_bfd, debug_sections, msec))
3788 if (!(bfd_simple_get_relocated_section_contents
3789 (debug_bfd, msec, stash->info_ptr_memory + total_size,
3797 stash->info_ptr = stash->info_ptr_memory;
3798 stash->info_ptr_end = stash->info_ptr + total_size;
3799 stash->sec = find_debug_info (debug_bfd, debug_sections, NULL);
3800 stash->sec_info_ptr = stash->info_ptr;
3804 /* Scan the debug information in PINFO looking for a DW_TAG_subprogram
3805 abbrev with a DW_AT_low_pc attached to it. Then lookup that same
3806 symbol in SYMBOLS and return the difference between the low_pc and
3807 the symbol's address. Returns 0 if no suitable symbol could be found. */
3810 _bfd_dwarf2_find_symbol_bias (asymbol ** symbols, void ** pinfo)
3812 struct dwarf2_debug *stash;
3813 struct comp_unit * unit;
3815 stash = (struct dwarf2_debug *) *pinfo;
3820 for (unit = stash->all_comp_units; unit; unit = unit->next_unit)
3822 struct funcinfo * func;
3824 if (unit->function_table == NULL)
3826 if (unit->line_table == NULL)
3827 unit->line_table = decode_line_info (unit, stash);
3828 if (unit->line_table != NULL)
3829 scan_unit_for_symbols (unit);
3832 for (func = unit->function_table; func != NULL; func = func->prev_func)
3833 if (func->name && func->arange.low)
3837 /* FIXME: Do we need to scan the aranges looking for the lowest pc value ? */
3839 for (psym = symbols; * psym != NULL; psym++)
3841 asymbol * sym = * psym;
3843 if (sym->flags & BSF_FUNCTION
3844 && sym->section != NULL
3845 && strcmp (sym->name, func->name) == 0)
3846 return ((bfd_signed_vma) func->arange.low) -
3847 ((bfd_signed_vma) (sym->value + sym->section->vma));
3855 /* Find the source code location of SYMBOL. If SYMBOL is NULL
3856 then find the nearest source code location corresponding to
3857 the address SECTION + OFFSET.
3858 Returns TRUE if the line is found without error and fills in
3859 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
3860 NULL the FUNCTIONNAME_PTR is also filled in.
3861 SYMBOLS contains the symbol table for ABFD.
3862 DEBUG_SECTIONS contains the name of the dwarf debug sections.
3863 ADDR_SIZE is the number of bytes in the initial .debug_info length
3864 field and in the abbreviation offset, or zero to indicate that the
3865 default value should be used. */
3868 _bfd_dwarf2_find_nearest_line (bfd *abfd,
3873 const char **filename_ptr,
3874 const char **functionname_ptr,
3875 unsigned int *linenumber_ptr,
3876 unsigned int *discriminator_ptr,
3877 const struct dwarf_debug_section *debug_sections,
3878 unsigned int addr_size,
3881 /* Read each compilation unit from the section .debug_info, and check
3882 to see if it contains the address we are searching for. If yes,
3883 lookup the address, and return the line number info. If no, go
3884 on to the next compilation unit.
3886 We keep a list of all the previously read compilation units, and
3887 a pointer to the next un-read compilation unit. Check the
3888 previously read units before reading more. */
3889 struct dwarf2_debug *stash;
3890 /* What address are we looking for? */
3892 struct comp_unit* each;
3893 struct funcinfo *function = NULL;
3894 bfd_boolean found = FALSE;
3895 bfd_boolean do_line;
3897 *filename_ptr = NULL;
3898 if (functionname_ptr != NULL)
3899 *functionname_ptr = NULL;
3900 *linenumber_ptr = 0;
3901 if (discriminator_ptr)
3902 *discriminator_ptr = 0;
3904 if (! _bfd_dwarf2_slurp_debug_info (abfd, NULL, debug_sections,
3906 (abfd->flags & (EXEC_P | DYNAMIC)) == 0))
3909 stash = (struct dwarf2_debug *) *pinfo;
3911 do_line = symbol != NULL;
3914 BFD_ASSERT (section == NULL && offset == 0 && functionname_ptr == NULL);
3915 section = bfd_get_section (symbol);
3916 addr = symbol->value;
3920 BFD_ASSERT (section != NULL && functionname_ptr != NULL);
3924 if (section->output_section)
3925 addr += section->output_section->vma + section->output_offset;
3927 addr += section->vma;
3929 /* A null info_ptr indicates that there is no dwarf2 info
3930 (or that an error occured while setting up the stash). */
3931 if (! stash->info_ptr)
3934 stash->inliner_chain = NULL;
3936 /* Check the previously read comp. units first. */
3939 /* The info hash tables use quite a bit of memory. We may not want to
3940 always use them. We use some heuristics to decide if and when to
3942 if (stash->info_hash_status == STASH_INFO_HASH_OFF)
3943 stash_maybe_enable_info_hash_tables (abfd, stash);
3945 /* Keep info hash table up to date if they are available. Note that we
3946 may disable the hash tables if there is any error duing update. */
3947 if (stash->info_hash_status == STASH_INFO_HASH_ON)
3948 stash_maybe_update_info_hash_tables (stash);
3950 if (stash->info_hash_status == STASH_INFO_HASH_ON)
3952 found = stash_find_line_fast (stash, symbol, addr, filename_ptr,
3959 /* Check the previously read comp. units first. */
3960 for (each = stash->all_comp_units; each; each = each->next_unit)
3961 if ((symbol->flags & BSF_FUNCTION) == 0
3962 || each->arange.high == 0
3963 || comp_unit_contains_address (each, addr))
3965 found = comp_unit_find_line (each, symbol, addr, filename_ptr,
3966 linenumber_ptr, stash);
3974 bfd_vma min_range = (bfd_vma) -1;
3975 const char * local_filename = NULL;
3976 struct funcinfo *local_function = NULL;
3977 unsigned int local_linenumber = 0;
3978 unsigned int local_discriminator = 0;
3980 for (each = stash->all_comp_units; each; each = each->next_unit)
3982 bfd_vma range = (bfd_vma) -1;
3984 found = ((each->arange.high == 0
3985 || comp_unit_contains_address (each, addr))
3986 && (range = comp_unit_find_nearest_line (each, addr,
3990 & local_discriminator,
3994 /* PRs 15935 15994: Bogus debug information may have provided us
3995 with an erroneous match. We attempt to counter this by
3996 selecting the match that has the smallest address range
3997 associated with it. (We are assuming that corrupt debug info
3998 will tend to result in extra large address ranges rather than
3999 extra small ranges).
4001 This does mean that we scan through all of the CUs associated
4002 with the bfd each time this function is called. But this does
4003 have the benefit of producing consistent results every time the
4004 function is called. */
4005 if (range <= min_range)
4007 if (filename_ptr && local_filename)
4008 * filename_ptr = local_filename;
4010 function = local_function;
4011 if (discriminator_ptr && local_discriminator)
4012 * discriminator_ptr = local_discriminator;
4013 if (local_linenumber)
4014 * linenumber_ptr = local_linenumber;
4020 if (* linenumber_ptr)
4027 /* The DWARF2 spec says that the initial length field, and the
4028 offset of the abbreviation table, should both be 4-byte values.
4029 However, some compilers do things differently. */
4032 BFD_ASSERT (addr_size == 4 || addr_size == 8);
4034 /* Read each remaining comp. units checking each as they are read. */
4035 while (stash->info_ptr < stash->info_ptr_end)
4038 unsigned int offset_size = addr_size;
4039 bfd_byte *info_ptr_unit = stash->info_ptr;
4041 length = read_4_bytes (stash->bfd_ptr, stash->info_ptr, stash->info_ptr_end);
4042 /* A 0xffffff length is the DWARF3 way of indicating
4043 we use 64-bit offsets, instead of 32-bit offsets. */
4044 if (length == 0xffffffff)
4047 length = read_8_bytes (stash->bfd_ptr, stash->info_ptr + 4, stash->info_ptr_end);
4048 stash->info_ptr += 12;
4050 /* A zero length is the IRIX way of indicating 64-bit offsets,
4051 mostly because the 64-bit length will generally fit in 32
4052 bits, and the endianness helps. */
4053 else if (length == 0)
4056 length = read_4_bytes (stash->bfd_ptr, stash->info_ptr + 4, stash->info_ptr_end);
4057 stash->info_ptr += 8;
4059 /* In the absence of the hints above, we assume 32-bit DWARF2
4060 offsets even for targets with 64-bit addresses, because:
4061 a) most of the time these targets will not have generated
4062 more than 2Gb of debug info and so will not need 64-bit
4065 b) if they do use 64-bit offsets but they are not using
4066 the size hints that are tested for above then they are
4067 not conforming to the DWARF3 standard anyway. */
4068 else if (addr_size == 8)
4071 stash->info_ptr += 4;
4074 stash->info_ptr += 4;
4080 each = parse_comp_unit (stash, length, info_ptr_unit,
4083 /* The dwarf information is damaged, don't trust it any
4087 new_ptr = stash->info_ptr + length;
4088 /* PR 17512: file: 1500698c. */
4089 if (new_ptr < stash->info_ptr)
4091 /* A corrupt length value - do not trust the info any more. */
4096 stash->info_ptr = new_ptr;
4098 if (stash->all_comp_units)
4099 stash->all_comp_units->prev_unit = each;
4101 stash->last_comp_unit = each;
4103 each->next_unit = stash->all_comp_units;
4104 stash->all_comp_units = each;
4106 /* DW_AT_low_pc and DW_AT_high_pc are optional for
4107 compilation units. If we don't have them (i.e.,
4108 unit->high == 0), we need to consult the line info table
4109 to see if a compilation unit contains the given
4112 found = (((symbol->flags & BSF_FUNCTION) == 0
4113 || each->arange.high == 0
4114 || comp_unit_contains_address (each, addr))
4115 && comp_unit_find_line (each, symbol, addr,
4120 found = ((each->arange.high == 0
4121 || comp_unit_contains_address (each, addr))
4122 && comp_unit_find_nearest_line (each, addr,
4129 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
4130 == stash->sec->size)
4132 stash->sec = find_debug_info (stash->bfd_ptr, debug_sections,
4134 stash->sec_info_ptr = stash->info_ptr;
4145 if (!function->is_linkage)
4150 fun = _bfd_elf_find_function (abfd, symbols, section, offset,
4151 *filename_ptr ? NULL : filename_ptr,
4153 sec_vma = section->vma;
4154 if (section->output_section != NULL)
4155 sec_vma = section->output_section->vma + section->output_offset;
4157 && fun->value + sec_vma == function->arange.low)
4158 function->name = *functionname_ptr;
4159 /* Even if we didn't find a linkage name, say that we have
4160 to stop a repeated search of symbols. */
4161 function->is_linkage = TRUE;
4163 *functionname_ptr = function->name;
4165 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
4166 unset_sections (stash);
4172 _bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED,
4173 const char **filename_ptr,
4174 const char **functionname_ptr,
4175 unsigned int *linenumber_ptr,
4178 struct dwarf2_debug *stash;
4180 stash = (struct dwarf2_debug *) *pinfo;
4183 struct funcinfo *func = stash->inliner_chain;
4185 if (func && func->caller_func)
4187 *filename_ptr = func->caller_file;
4188 *functionname_ptr = func->caller_func->name;
4189 *linenumber_ptr = func->caller_line;
4190 stash->inliner_chain = func->caller_func;
4199 _bfd_dwarf2_cleanup_debug_info (bfd *abfd, void **pinfo)
4201 struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
4202 struct comp_unit *each;
4204 if (abfd == NULL || stash == NULL)
4207 for (each = stash->all_comp_units; each; each = each->next_unit)
4209 struct abbrev_info **abbrevs = each->abbrevs;
4210 struct funcinfo *function_table = each->function_table;
4211 struct varinfo *variable_table = each->variable_table;
4214 for (i = 0; i < ABBREV_HASH_SIZE; i++)
4216 struct abbrev_info *abbrev = abbrevs[i];
4220 free (abbrev->attrs);
4221 abbrev = abbrev->next;
4225 if (each->line_table)
4227 free (each->line_table->dirs);
4228 free (each->line_table->files);
4231 while (function_table)
4233 if (function_table->file)
4235 free (function_table->file);
4236 function_table->file = NULL;
4239 if (function_table->caller_file)
4241 free (function_table->caller_file);
4242 function_table->caller_file = NULL;
4244 function_table = function_table->prev_func;
4247 while (variable_table)
4249 if (variable_table->file)
4251 free (variable_table->file);
4252 variable_table->file = NULL;
4255 variable_table = variable_table->prev_var;
4259 if (stash->dwarf_abbrev_buffer)
4260 free (stash->dwarf_abbrev_buffer);
4261 if (stash->dwarf_line_buffer)
4262 free (stash->dwarf_line_buffer);
4263 if (stash->dwarf_str_buffer)
4264 free (stash->dwarf_str_buffer);
4265 if (stash->dwarf_ranges_buffer)
4266 free (stash->dwarf_ranges_buffer);
4267 if (stash->info_ptr_memory)
4268 free (stash->info_ptr_memory);
4269 if (stash->close_on_cleanup)
4270 bfd_close (stash->bfd_ptr);
4271 if (stash->alt_dwarf_str_buffer)
4272 free (stash->alt_dwarf_str_buffer);
4273 if (stash->alt_dwarf_info_buffer)
4274 free (stash->alt_dwarf_info_buffer);
4276 free (stash->sec_vma);
4277 if (stash->adjusted_sections)
4278 free (stash->adjusted_sections);
4279 if (stash->alt_bfd_ptr)
4280 bfd_close (stash->alt_bfd_ptr);
4283 /* Find the function to a particular section and offset,
4284 for error reporting. */
4287 _bfd_elf_find_function (bfd *abfd,
4291 const char **filename_ptr,
4292 const char **functionname_ptr)
4294 struct elf_find_function_cache
4296 asection *last_section;
4298 const char *filename;
4299 bfd_size_type func_size;
4302 if (symbols == NULL)
4305 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
4308 cache = elf_tdata (abfd)->elf_find_function_cache;
4311 cache = bfd_zalloc (abfd, sizeof (*cache));
4312 elf_tdata (abfd)->elf_find_function_cache = cache;
4316 if (cache->last_section != section
4317 || cache->func == NULL
4318 || offset < cache->func->value
4319 || offset >= cache->func->value + cache->func_size)
4324 /* ??? Given multiple file symbols, it is impossible to reliably
4325 choose the right file name for global symbols. File symbols are
4326 local symbols, and thus all file symbols must sort before any
4327 global symbols. The ELF spec may be interpreted to say that a
4328 file symbol must sort before other local symbols, but currently
4329 ld -r doesn't do this. So, for ld -r output, it is possible to
4330 make a better choice of file name for local symbols by ignoring
4331 file symbols appearing after a given local symbol. */
4332 enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
4333 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4337 state = nothing_seen;
4338 cache->filename = NULL;
4340 cache->func_size = 0;
4341 cache->last_section = section;
4343 for (p = symbols; *p != NULL; p++)
4349 if ((sym->flags & BSF_FILE) != 0)
4352 if (state == symbol_seen)
4353 state = file_after_symbol_seen;
4357 size = bed->maybe_function_sym (sym, section, &code_off);
4359 && code_off <= offset
4360 && (code_off > low_func
4361 || (code_off == low_func
4362 && size > cache->func_size)))
4365 cache->func_size = size;
4366 cache->filename = NULL;
4367 low_func = code_off;
4369 && ((sym->flags & BSF_LOCAL) != 0
4370 || state != file_after_symbol_seen))
4371 cache->filename = bfd_asymbol_name (file);
4373 if (state == nothing_seen)
4374 state = symbol_seen;
4378 if (cache->func == NULL)
4382 *filename_ptr = cache->filename;
4383 if (functionname_ptr)
4384 *functionname_ptr = bfd_asymbol_name (cache->func);