2 Copyright (C) 1994-2017 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 table of function information references searchable by address. */
260 struct lookup_funcinfo *lookup_funcinfo_table;
262 /* Number of functions in the function_table and sorted_function_table. */
263 bfd_size_type number_of_functions;
265 /* A list of the variables found in this comp. unit. */
266 struct varinfo *variable_table;
268 /* Pointer to dwarf2_debug structure. */
269 struct dwarf2_debug *stash;
271 /* DWARF format version for this unit - from unit header. */
274 /* Address size for this unit - from unit header. */
275 unsigned char addr_size;
277 /* Offset size for this unit - from unit header. */
278 unsigned char offset_size;
280 /* Base address for this unit - from DW_AT_low_pc attribute of
281 DW_TAG_compile_unit DIE */
282 bfd_vma base_address;
284 /* TRUE if symbols are cached in hash table for faster lookup by name. */
288 /* This data structure holds the information of an abbrev. */
291 unsigned int number; /* Number identifying abbrev. */
292 enum dwarf_tag tag; /* DWARF tag. */
293 int has_children; /* Boolean. */
294 unsigned int num_attrs; /* Number of attributes. */
295 struct attr_abbrev *attrs; /* An array of attribute descriptions. */
296 struct abbrev_info *next; /* Next in chain. */
301 enum dwarf_attribute name;
302 enum dwarf_form form;
305 /* Map of uncompressed DWARF debug section name to compressed one. It
306 is terminated by NULL uncompressed_name. */
308 const struct dwarf_debug_section dwarf_debug_sections[] =
310 { ".debug_abbrev", ".zdebug_abbrev" },
311 { ".debug_aranges", ".zdebug_aranges" },
312 { ".debug_frame", ".zdebug_frame" },
313 { ".debug_info", ".zdebug_info" },
314 { ".debug_info", ".zdebug_info" },
315 { ".debug_line", ".zdebug_line" },
316 { ".debug_loc", ".zdebug_loc" },
317 { ".debug_macinfo", ".zdebug_macinfo" },
318 { ".debug_macro", ".zdebug_macro" },
319 { ".debug_pubnames", ".zdebug_pubnames" },
320 { ".debug_pubtypes", ".zdebug_pubtypes" },
321 { ".debug_ranges", ".zdebug_ranges" },
322 { ".debug_static_func", ".zdebug_static_func" },
323 { ".debug_static_vars", ".zdebug_static_vars" },
324 { ".debug_str", ".zdebug_str", },
325 { ".debug_str", ".zdebug_str", },
326 { ".debug_types", ".zdebug_types" },
327 /* GNU DWARF 1 extensions */
328 { ".debug_sfnames", ".zdebug_sfnames" },
329 { ".debug_srcinfo", ".zebug_srcinfo" },
330 /* SGI/MIPS DWARF 2 extensions */
331 { ".debug_funcnames", ".zdebug_funcnames" },
332 { ".debug_typenames", ".zdebug_typenames" },
333 { ".debug_varnames", ".zdebug_varnames" },
334 { ".debug_weaknames", ".zdebug_weaknames" },
338 /* NB/ Numbers in this enum must match up with indicies
339 into the dwarf_debug_sections[] array above. */
340 enum dwarf_debug_section_enum
367 #ifndef ABBREV_HASH_SIZE
368 #define ABBREV_HASH_SIZE 121
370 #ifndef ATTR_ALLOC_CHUNK
371 #define ATTR_ALLOC_CHUNK 4
374 /* Variable and function hash tables. This is used to speed up look-up
375 in lookup_symbol_in_var_table() and lookup_symbol_in_function_table().
376 In order to share code between variable and function infos, we use
377 a list of untyped pointer for all variable/function info associated with
378 a symbol. We waste a bit of memory for list with one node but that
379 simplifies the code. */
381 struct info_list_node
383 struct info_list_node *next;
387 /* Info hash entry. */
388 struct info_hash_entry
390 struct bfd_hash_entry root;
391 struct info_list_node *head;
394 struct info_hash_table
396 struct bfd_hash_table base;
399 /* Function to create a new entry in info hash table. */
401 static struct bfd_hash_entry *
402 info_hash_table_newfunc (struct bfd_hash_entry *entry,
403 struct bfd_hash_table *table,
406 struct info_hash_entry *ret = (struct info_hash_entry *) entry;
408 /* Allocate the structure if it has not already been allocated by a
412 ret = (struct info_hash_entry *) bfd_hash_allocate (table,
418 /* Call the allocation method of the base class. */
419 ret = ((struct info_hash_entry *)
420 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
422 /* Initialize the local fields here. */
426 return (struct bfd_hash_entry *) ret;
429 /* Function to create a new info hash table. It returns a pointer to the
430 newly created table or NULL if there is any error. We need abfd
431 solely for memory allocation. */
433 static struct info_hash_table *
434 create_info_hash_table (bfd *abfd)
436 struct info_hash_table *hash_table;
438 hash_table = ((struct info_hash_table *)
439 bfd_alloc (abfd, sizeof (struct info_hash_table)));
443 if (!bfd_hash_table_init (&hash_table->base, info_hash_table_newfunc,
444 sizeof (struct info_hash_entry)))
446 bfd_release (abfd, hash_table);
453 /* Insert an info entry into an info hash table. We do not check of
454 duplicate entries. Also, the caller need to guarantee that the
455 right type of info in inserted as info is passed as a void* pointer.
456 This function returns true if there is no error. */
459 insert_info_hash_table (struct info_hash_table *hash_table,
464 struct info_hash_entry *entry;
465 struct info_list_node *node;
467 entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base,
472 node = (struct info_list_node *) bfd_hash_allocate (&hash_table->base,
478 node->next = entry->head;
484 /* Look up an info entry list from an info hash table. Return NULL
487 static struct info_list_node *
488 lookup_info_hash_table (struct info_hash_table *hash_table, const char *key)
490 struct info_hash_entry *entry;
492 entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base, key,
494 return entry ? entry->head : NULL;
497 /* Read a section into its appropriate place in the dwarf2_debug
498 struct (indicated by SECTION_BUFFER and SECTION_SIZE). If SYMS is
499 not NULL, use bfd_simple_get_relocated_section_contents to read the
500 section contents, otherwise use bfd_get_section_contents. Fail if
501 the located section does not contain at least OFFSET bytes. */
504 read_section (bfd * abfd,
505 const struct dwarf_debug_section *sec,
508 bfd_byte ** section_buffer,
509 bfd_size_type * section_size)
512 const char *section_name = sec->uncompressed_name;
514 /* The section may have already been read. */
515 if (*section_buffer == NULL)
517 msec = bfd_get_section_by_name (abfd, section_name);
520 section_name = sec->compressed_name;
521 if (section_name != NULL)
522 msec = bfd_get_section_by_name (abfd, section_name);
526 _bfd_error_handler (_("Dwarf Error: Can't find %s section."),
527 sec->uncompressed_name);
528 bfd_set_error (bfd_error_bad_value);
532 *section_size = msec->rawsize ? msec->rawsize : msec->size;
536 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL, syms);
537 if (! *section_buffer)
542 *section_buffer = (bfd_byte *) bfd_malloc (*section_size);
543 if (! *section_buffer)
545 if (! bfd_get_section_contents (abfd, msec, *section_buffer,
551 /* It is possible to get a bad value for the offset into the section
552 that the client wants. Validate it here to avoid trouble later. */
553 if (offset != 0 && offset >= *section_size)
555 /* xgettext: c-format */
556 _bfd_error_handler (_("Dwarf Error: Offset (%lu)"
557 " greater than or equal to %s size (%lu)."),
558 (long) offset, section_name, *section_size);
559 bfd_set_error (bfd_error_bad_value);
566 /* Read dwarf information from a buffer. */
569 read_1_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf, bfd_byte *end)
573 return bfd_get_8 (abfd, buf);
577 read_1_signed_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf, bfd_byte *end)
581 return bfd_get_signed_8 (abfd, buf);
585 read_2_bytes (bfd *abfd, bfd_byte *buf, bfd_byte *end)
589 return bfd_get_16 (abfd, buf);
593 read_4_bytes (bfd *abfd, bfd_byte *buf, bfd_byte *end)
597 return bfd_get_32 (abfd, buf);
601 read_8_bytes (bfd *abfd, bfd_byte *buf, bfd_byte *end)
605 return bfd_get_64 (abfd, buf);
609 read_n_bytes (bfd *abfd ATTRIBUTE_UNUSED,
612 unsigned int size ATTRIBUTE_UNUSED)
614 if (buf + size > end)
619 /* Scans a NUL terminated string starting at BUF, returning a pointer to it.
620 Returns the number of characters in the string, *including* the NUL byte,
621 in BYTES_READ_PTR. This value is set even if the function fails. Bytes
622 at or beyond BUF_END will not be read. Returns NULL if there was a
623 problem, or if the string is empty. */
626 read_string (bfd * abfd ATTRIBUTE_UNUSED,
629 unsigned int * bytes_read_ptr)
635 * bytes_read_ptr = 0;
641 * bytes_read_ptr = 1;
645 while (buf < buf_end)
648 * bytes_read_ptr = buf - str;
652 * bytes_read_ptr = buf - str;
656 /* Reads an offset from BUF and then locates the string at this offset
657 inside the debug string section. Returns a pointer to the string.
658 Returns the number of bytes read from BUF, *not* the length of the string,
659 in BYTES_READ_PTR. This value is set even if the function fails. Bytes
660 at or beyond BUF_END will not be read from BUF. Returns NULL if there was
661 a problem, or if the string is empty. Does not check for NUL termination
665 read_indirect_string (struct comp_unit * unit,
668 unsigned int * bytes_read_ptr)
671 struct dwarf2_debug *stash = unit->stash;
674 if (buf + unit->offset_size > buf_end)
676 * bytes_read_ptr = 0;
680 if (unit->offset_size == 4)
681 offset = read_4_bytes (unit->abfd, buf, buf_end);
683 offset = read_8_bytes (unit->abfd, buf, buf_end);
685 *bytes_read_ptr = unit->offset_size;
687 if (! read_section (unit->abfd, &stash->debug_sections[debug_str],
689 &stash->dwarf_str_buffer, &stash->dwarf_str_size))
692 if (offset >= stash->dwarf_str_size)
694 str = (char *) stash->dwarf_str_buffer + offset;
700 /* Like read_indirect_string but uses a .debug_str located in
701 an alternate file pointed to by the .gnu_debugaltlink section.
702 Used to impement DW_FORM_GNU_strp_alt. */
705 read_alt_indirect_string (struct comp_unit * unit,
708 unsigned int * bytes_read_ptr)
711 struct dwarf2_debug *stash = unit->stash;
714 if (buf + unit->offset_size > buf_end)
716 * bytes_read_ptr = 0;
720 if (unit->offset_size == 4)
721 offset = read_4_bytes (unit->abfd, buf, buf_end);
723 offset = read_8_bytes (unit->abfd, buf, buf_end);
725 *bytes_read_ptr = unit->offset_size;
727 if (stash->alt_bfd_ptr == NULL)
730 char * debug_filename = bfd_follow_gnu_debugaltlink (unit->abfd, DEBUGDIR);
732 if (debug_filename == NULL)
735 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
736 || ! bfd_check_format (debug_bfd, bfd_object))
739 bfd_close (debug_bfd);
741 /* FIXME: Should we report our failure to follow the debuglink ? */
742 free (debug_filename);
745 stash->alt_bfd_ptr = debug_bfd;
748 if (! read_section (unit->stash->alt_bfd_ptr,
749 stash->debug_sections + debug_str_alt,
750 NULL, /* FIXME: Do we need to load alternate symbols ? */
752 &stash->alt_dwarf_str_buffer,
753 &stash->alt_dwarf_str_size))
756 if (offset >= stash->alt_dwarf_str_size)
758 str = (char *) stash->alt_dwarf_str_buffer + offset;
765 /* Resolve an alternate reference from UNIT at OFFSET.
766 Returns a pointer into the loaded alternate CU upon success
767 or NULL upon failure. */
770 read_alt_indirect_ref (struct comp_unit * unit,
773 struct dwarf2_debug *stash = unit->stash;
775 if (stash->alt_bfd_ptr == NULL)
778 char * debug_filename = bfd_follow_gnu_debugaltlink (unit->abfd, DEBUGDIR);
780 if (debug_filename == NULL)
783 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
784 || ! bfd_check_format (debug_bfd, bfd_object))
787 bfd_close (debug_bfd);
789 /* FIXME: Should we report our failure to follow the debuglink ? */
790 free (debug_filename);
793 stash->alt_bfd_ptr = debug_bfd;
796 if (! read_section (unit->stash->alt_bfd_ptr,
797 stash->debug_sections + debug_info_alt,
798 NULL, /* FIXME: Do we need to load alternate symbols ? */
800 &stash->alt_dwarf_info_buffer,
801 &stash->alt_dwarf_info_size))
804 if (offset >= stash->alt_dwarf_info_size)
806 return stash->alt_dwarf_info_buffer + offset;
810 read_address (struct comp_unit *unit, bfd_byte *buf, bfd_byte * buf_end)
814 if (bfd_get_flavour (unit->abfd) == bfd_target_elf_flavour)
815 signed_vma = get_elf_backend_data (unit->abfd)->sign_extend_vma;
817 if (buf + unit->addr_size > buf_end)
822 switch (unit->addr_size)
825 return bfd_get_signed_64 (unit->abfd, buf);
827 return bfd_get_signed_32 (unit->abfd, buf);
829 return bfd_get_signed_16 (unit->abfd, buf);
836 switch (unit->addr_size)
839 return bfd_get_64 (unit->abfd, buf);
841 return bfd_get_32 (unit->abfd, buf);
843 return bfd_get_16 (unit->abfd, buf);
850 /* Lookup an abbrev_info structure in the abbrev hash table. */
852 static struct abbrev_info *
853 lookup_abbrev (unsigned int number, struct abbrev_info **abbrevs)
855 unsigned int hash_number;
856 struct abbrev_info *abbrev;
858 hash_number = number % ABBREV_HASH_SIZE;
859 abbrev = abbrevs[hash_number];
863 if (abbrev->number == number)
866 abbrev = abbrev->next;
872 /* In DWARF version 2, the description of the debugging information is
873 stored in a separate .debug_abbrev section. Before we read any
874 dies from a section we read in all abbreviations and install them
877 static struct abbrev_info**
878 read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
880 struct abbrev_info **abbrevs;
881 bfd_byte *abbrev_ptr;
882 bfd_byte *abbrev_end;
883 struct abbrev_info *cur_abbrev;
884 unsigned int abbrev_number, bytes_read, abbrev_name;
885 unsigned int abbrev_form, hash_number;
888 if (! read_section (abfd, &stash->debug_sections[debug_abbrev],
890 &stash->dwarf_abbrev_buffer, &stash->dwarf_abbrev_size))
893 if (offset >= stash->dwarf_abbrev_size)
896 amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
897 abbrevs = (struct abbrev_info **) bfd_zalloc (abfd, amt);
901 abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
902 abbrev_end = stash->dwarf_abbrev_buffer + stash->dwarf_abbrev_size;
903 abbrev_number = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
904 abbrev_ptr += bytes_read;
906 /* Loop until we reach an abbrev number of 0. */
907 while (abbrev_number)
909 amt = sizeof (struct abbrev_info);
910 cur_abbrev = (struct abbrev_info *) bfd_zalloc (abfd, amt);
911 if (cur_abbrev == NULL)
914 /* Read in abbrev header. */
915 cur_abbrev->number = abbrev_number;
916 cur_abbrev->tag = (enum dwarf_tag)
917 safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
918 abbrev_ptr += bytes_read;
919 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr, abbrev_end);
922 /* Now read in declarations. */
923 abbrev_name = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
924 abbrev_ptr += bytes_read;
925 abbrev_form = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
926 abbrev_ptr += bytes_read;
930 if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
932 struct attr_abbrev *tmp;
934 amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
935 amt *= sizeof (struct attr_abbrev);
936 tmp = (struct attr_abbrev *) bfd_realloc (cur_abbrev->attrs, amt);
941 for (i = 0; i < ABBREV_HASH_SIZE; i++)
943 struct abbrev_info *abbrev = abbrevs[i];
947 free (abbrev->attrs);
948 abbrev = abbrev->next;
953 cur_abbrev->attrs = tmp;
956 cur_abbrev->attrs[cur_abbrev->num_attrs].name
957 = (enum dwarf_attribute) abbrev_name;
958 cur_abbrev->attrs[cur_abbrev->num_attrs++].form
959 = (enum dwarf_form) abbrev_form;
960 abbrev_name = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
961 abbrev_ptr += bytes_read;
962 abbrev_form = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
963 abbrev_ptr += bytes_read;
966 hash_number = abbrev_number % ABBREV_HASH_SIZE;
967 cur_abbrev->next = abbrevs[hash_number];
968 abbrevs[hash_number] = cur_abbrev;
970 /* Get next abbreviation.
971 Under Irix6 the abbreviations for a compilation unit are not
972 always properly terminated with an abbrev number of 0.
973 Exit loop if we encounter an abbreviation which we have
974 already read (which means we are about to read the abbreviations
975 for the next compile unit) or if the end of the abbreviation
977 if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
978 >= stash->dwarf_abbrev_size)
980 abbrev_number = safe_read_leb128 (abfd, abbrev_ptr, &bytes_read, FALSE, abbrev_end);
981 abbrev_ptr += bytes_read;
982 if (lookup_abbrev (abbrev_number, abbrevs) != NULL)
989 /* Returns true if the form is one which has a string value. */
991 static inline bfd_boolean
992 is_str_attr (enum dwarf_form form)
994 return form == DW_FORM_string || form == DW_FORM_strp || form == DW_FORM_GNU_strp_alt;
997 /* Read and fill in the value of attribute ATTR as described by FORM.
998 Read data starting from INFO_PTR, but never at or beyond INFO_PTR_END.
999 Returns an updated INFO_PTR taking into account the amount of data read. */
1002 read_attribute_value (struct attribute * attr,
1004 struct comp_unit * unit,
1005 bfd_byte * info_ptr,
1006 bfd_byte * info_ptr_end)
1008 bfd *abfd = unit->abfd;
1009 unsigned int bytes_read;
1010 struct dwarf_block *blk;
1013 if (info_ptr >= info_ptr_end && form != DW_FORM_flag_present)
1015 _bfd_error_handler (_("Dwarf Error: Info pointer extends beyond end of attributes"));
1016 bfd_set_error (bfd_error_bad_value);
1020 attr->form = (enum dwarf_form) form;
1024 case DW_FORM_ref_addr:
1025 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
1027 if (unit->version == 3 || unit->version == 4)
1029 if (unit->offset_size == 4)
1030 attr->u.val = read_4_bytes (unit->abfd, info_ptr, info_ptr_end);
1032 attr->u.val = read_8_bytes (unit->abfd, info_ptr, info_ptr_end);
1033 info_ptr += unit->offset_size;
1038 attr->u.val = read_address (unit, info_ptr, info_ptr_end);
1039 info_ptr += unit->addr_size;
1041 case DW_FORM_GNU_ref_alt:
1042 case DW_FORM_sec_offset:
1043 if (unit->offset_size == 4)
1044 attr->u.val = read_4_bytes (unit->abfd, info_ptr, info_ptr_end);
1046 attr->u.val = read_8_bytes (unit->abfd, info_ptr, info_ptr_end);
1047 info_ptr += unit->offset_size;
1049 case DW_FORM_block2:
1050 amt = sizeof (struct dwarf_block);
1051 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1054 blk->size = read_2_bytes (abfd, info_ptr, info_ptr_end);
1056 blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
1057 info_ptr += blk->size;
1060 case DW_FORM_block4:
1061 amt = sizeof (struct dwarf_block);
1062 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1065 blk->size = read_4_bytes (abfd, info_ptr, info_ptr_end);
1067 blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
1068 info_ptr += blk->size;
1072 attr->u.val = read_2_bytes (abfd, info_ptr, info_ptr_end);
1076 attr->u.val = read_4_bytes (abfd, info_ptr, info_ptr_end);
1080 attr->u.val = read_8_bytes (abfd, info_ptr, info_ptr_end);
1083 case DW_FORM_string:
1084 attr->u.str = read_string (abfd, info_ptr, info_ptr_end, &bytes_read);
1085 info_ptr += bytes_read;
1088 attr->u.str = read_indirect_string (unit, info_ptr, info_ptr_end, &bytes_read);
1089 info_ptr += bytes_read;
1091 case DW_FORM_GNU_strp_alt:
1092 attr->u.str = read_alt_indirect_string (unit, info_ptr, info_ptr_end, &bytes_read);
1093 info_ptr += bytes_read;
1095 case DW_FORM_exprloc:
1097 amt = sizeof (struct dwarf_block);
1098 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1101 blk->size = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
1102 info_ptr += bytes_read;
1103 blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
1104 info_ptr += blk->size;
1107 case DW_FORM_block1:
1108 amt = sizeof (struct dwarf_block);
1109 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
1112 blk->size = read_1_byte (abfd, info_ptr, info_ptr_end);
1114 blk->data = read_n_bytes (abfd, info_ptr, info_ptr_end, blk->size);
1115 info_ptr += blk->size;
1119 attr->u.val = read_1_byte (abfd, info_ptr, info_ptr_end);
1123 attr->u.val = read_1_byte (abfd, info_ptr, info_ptr_end);
1126 case DW_FORM_flag_present:
1130 attr->u.sval = safe_read_leb128 (abfd, info_ptr, &bytes_read, TRUE, info_ptr_end);
1131 info_ptr += bytes_read;
1134 attr->u.val = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
1135 info_ptr += bytes_read;
1138 attr->u.val = read_1_byte (abfd, info_ptr, info_ptr_end);
1142 attr->u.val = read_2_bytes (abfd, info_ptr, info_ptr_end);
1146 attr->u.val = read_4_bytes (abfd, info_ptr, info_ptr_end);
1150 attr->u.val = read_8_bytes (abfd, info_ptr, info_ptr_end);
1153 case DW_FORM_ref_sig8:
1154 attr->u.val = read_8_bytes (abfd, info_ptr, info_ptr_end);
1157 case DW_FORM_ref_udata:
1158 attr->u.val = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
1159 info_ptr += bytes_read;
1161 case DW_FORM_indirect:
1162 form = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
1163 info_ptr += bytes_read;
1164 info_ptr = read_attribute_value (attr, form, unit, info_ptr, info_ptr_end);
1167 _bfd_error_handler (_("Dwarf Error: Invalid or unhandled FORM value: %#x."),
1169 bfd_set_error (bfd_error_bad_value);
1175 /* Read an attribute described by an abbreviated attribute. */
1178 read_attribute (struct attribute * attr,
1179 struct attr_abbrev * abbrev,
1180 struct comp_unit * unit,
1181 bfd_byte * info_ptr,
1182 bfd_byte * info_ptr_end)
1184 attr->name = abbrev->name;
1185 info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr, info_ptr_end);
1189 /* Return whether DW_AT_name will return the same as DW_AT_linkage_name
1193 non_mangled (int lang)
1203 case DW_LANG_Cobol74:
1204 case DW_LANG_Cobol85:
1205 case DW_LANG_Fortran77:
1206 case DW_LANG_Pascal83:
1216 /* Source line information table routines. */
1218 #define FILE_ALLOC_CHUNK 5
1219 #define DIR_ALLOC_CHUNK 5
1223 struct line_info * prev_line;
1227 unsigned int column;
1228 unsigned int discriminator;
1229 unsigned char op_index;
1230 unsigned char end_sequence; /* End of (sequential) code sequence. */
1241 struct line_sequence
1244 struct line_sequence* prev_sequence;
1245 struct line_info* last_line; /* Largest VMA. */
1246 struct line_info** line_info_lookup;
1247 bfd_size_type num_lines;
1250 struct line_info_table
1253 unsigned int num_files;
1254 unsigned int num_dirs;
1255 unsigned int num_sequences;
1258 struct fileinfo* files;
1259 struct line_sequence* sequences;
1260 struct line_info* lcl_head; /* Local head; used in 'add_line_info'. */
1263 /* Remember some information about each function. If the function is
1264 inlined (DW_TAG_inlined_subroutine) it may have two additional
1265 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
1266 source code location where this function was inlined. */
1270 /* Pointer to previous function in list of all functions. */
1271 struct funcinfo * prev_func;
1272 /* Pointer to function one scope higher. */
1273 struct funcinfo * caller_func;
1274 /* Source location file name where caller_func inlines this func. */
1276 /* Source location file name. */
1278 /* Source location line number where caller_func inlines this func. */
1280 /* Source location line number. */
1283 bfd_boolean is_linkage;
1285 struct arange arange;
1286 /* Where the symbol is defined. */
1290 struct lookup_funcinfo
1292 /* Function information corresponding to this lookup table entry. */
1293 struct funcinfo * funcinfo;
1295 /* The lowest address for this specific function. */
1298 /* The highest address of this function before the lookup table is sorted.
1299 The highest address of all prior functions after the lookup table is
1300 sorted, which is used for binary search. */
1306 /* Pointer to previous variable in list of all variables */
1307 struct varinfo *prev_var;
1308 /* Source location file name */
1310 /* Source location line number */
1315 /* Where the symbol is defined */
1317 /* Is this a stack variable? */
1318 unsigned int stack: 1;
1321 /* Return TRUE if NEW_LINE should sort after LINE. */
1323 static inline bfd_boolean
1324 new_line_sorts_after (struct line_info *new_line, struct line_info *line)
1326 return (new_line->address > line->address
1327 || (new_line->address == line->address
1328 && (new_line->op_index > line->op_index
1329 || (new_line->op_index == line->op_index
1330 && new_line->end_sequence < line->end_sequence))));
1334 /* Adds a new entry to the line_info list in the line_info_table, ensuring
1335 that the list is sorted. Note that the line_info list is sorted from
1336 highest to lowest VMA (with possible duplicates); that is,
1337 line_info->prev_line always accesses an equal or smaller VMA. */
1340 add_line_info (struct line_info_table *table,
1342 unsigned char op_index,
1345 unsigned int column,
1346 unsigned int discriminator,
1349 bfd_size_type amt = sizeof (struct line_info);
1350 struct line_sequence* seq = table->sequences;
1351 struct line_info* info = (struct line_info *) bfd_alloc (table->abfd, amt);
1356 /* Set member data of 'info'. */
1357 info->prev_line = NULL;
1358 info->address = address;
1359 info->op_index = op_index;
1361 info->column = column;
1362 info->discriminator = discriminator;
1363 info->end_sequence = end_sequence;
1365 if (filename && filename[0])
1367 info->filename = (char *) bfd_alloc (table->abfd, strlen (filename) + 1);
1368 if (info->filename == NULL)
1370 strcpy (info->filename, filename);
1373 info->filename = NULL;
1375 /* Find the correct location for 'info'. Normally we will receive
1376 new line_info data 1) in order and 2) with increasing VMAs.
1377 However some compilers break the rules (cf. decode_line_info) and
1378 so we include some heuristics for quickly finding the correct
1379 location for 'info'. In particular, these heuristics optimize for
1380 the common case in which the VMA sequence that we receive is a
1381 list of locally sorted VMAs such as
1382 p...z a...j (where a < j < p < z)
1384 Note: table->lcl_head is used to head an *actual* or *possible*
1385 sub-sequence within the list (such as a...j) that is not directly
1386 headed by table->last_line
1388 Note: we may receive duplicate entries from 'decode_line_info'. */
1391 && seq->last_line->address == address
1392 && seq->last_line->op_index == op_index
1393 && seq->last_line->end_sequence == end_sequence)
1395 /* We only keep the last entry with the same address and end
1396 sequence. See PR ld/4986. */
1397 if (table->lcl_head == seq->last_line)
1398 table->lcl_head = info;
1399 info->prev_line = seq->last_line->prev_line;
1400 seq->last_line = info;
1402 else if (!seq || seq->last_line->end_sequence)
1404 /* Start a new line sequence. */
1405 amt = sizeof (struct line_sequence);
1406 seq = (struct line_sequence *) bfd_malloc (amt);
1409 seq->low_pc = address;
1410 seq->prev_sequence = table->sequences;
1411 seq->last_line = info;
1412 table->lcl_head = info;
1413 table->sequences = seq;
1414 table->num_sequences++;
1416 else if (new_line_sorts_after (info, seq->last_line))
1418 /* Normal case: add 'info' to the beginning of the current sequence. */
1419 info->prev_line = seq->last_line;
1420 seq->last_line = info;
1422 /* lcl_head: initialize to head a *possible* sequence at the end. */
1423 if (!table->lcl_head)
1424 table->lcl_head = info;
1426 else if (!new_line_sorts_after (info, table->lcl_head)
1427 && (!table->lcl_head->prev_line
1428 || new_line_sorts_after (info, table->lcl_head->prev_line)))
1430 /* Abnormal but easy: lcl_head is the head of 'info'. */
1431 info->prev_line = table->lcl_head->prev_line;
1432 table->lcl_head->prev_line = info;
1436 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head'
1437 are valid heads for 'info'. Reset 'lcl_head'. */
1438 struct line_info* li2 = seq->last_line; /* Always non-NULL. */
1439 struct line_info* li1 = li2->prev_line;
1443 if (!new_line_sorts_after (info, li2)
1444 && new_line_sorts_after (info, li1))
1447 li2 = li1; /* always non-NULL */
1448 li1 = li1->prev_line;
1450 table->lcl_head = li2;
1451 info->prev_line = table->lcl_head->prev_line;
1452 table->lcl_head->prev_line = info;
1453 if (address < seq->low_pc)
1454 seq->low_pc = address;
1459 /* Extract a fully qualified filename from a line info table.
1460 The returned string has been malloc'ed and it is the caller's
1461 responsibility to free it. */
1464 concat_filename (struct line_info_table *table, unsigned int file)
1468 if (file - 1 >= table->num_files)
1470 /* FILE == 0 means unknown. */
1473 (_("Dwarf Error: mangled line number section (bad file number)."));
1474 return strdup ("<unknown>");
1477 filename = table->files[file - 1].name;
1479 if (!IS_ABSOLUTE_PATH (filename))
1481 char *dir_name = NULL;
1482 char *subdir_name = NULL;
1486 if (table->files[file - 1].dir
1487 /* PR 17512: file: 0317e960. */
1488 && table->files[file - 1].dir <= table->num_dirs
1489 /* PR 17512: file: 7f3d2e4b. */
1490 && table->dirs != NULL)
1491 subdir_name = table->dirs[table->files[file - 1].dir - 1];
1493 if (!subdir_name || !IS_ABSOLUTE_PATH (subdir_name))
1494 dir_name = table->comp_dir;
1498 dir_name = subdir_name;
1503 return strdup (filename);
1505 len = strlen (dir_name) + strlen (filename) + 2;
1509 len += strlen (subdir_name) + 1;
1510 name = (char *) bfd_malloc (len);
1512 sprintf (name, "%s/%s/%s", dir_name, subdir_name, filename);
1516 name = (char *) bfd_malloc (len);
1518 sprintf (name, "%s/%s", dir_name, filename);
1524 return strdup (filename);
1528 arange_add (const struct comp_unit *unit, struct arange *first_arange,
1529 bfd_vma low_pc, bfd_vma high_pc)
1531 struct arange *arange;
1533 /* Ignore empty ranges. */
1534 if (low_pc == high_pc)
1537 /* If the first arange is empty, use it. */
1538 if (first_arange->high == 0)
1540 first_arange->low = low_pc;
1541 first_arange->high = high_pc;
1545 /* Next see if we can cheaply extend an existing range. */
1546 arange = first_arange;
1549 if (low_pc == arange->high)
1551 arange->high = high_pc;
1554 if (high_pc == arange->low)
1556 arange->low = low_pc;
1559 arange = arange->next;
1563 /* Need to allocate a new arange and insert it into the arange list.
1564 Order isn't significant, so just insert after the first arange. */
1565 arange = (struct arange *) bfd_alloc (unit->abfd, sizeof (*arange));
1568 arange->low = low_pc;
1569 arange->high = high_pc;
1570 arange->next = first_arange->next;
1571 first_arange->next = arange;
1575 /* Compare function for line sequences. */
1578 compare_sequences (const void* a, const void* b)
1580 const struct line_sequence* seq1 = a;
1581 const struct line_sequence* seq2 = b;
1583 /* Sort by low_pc as the primary key. */
1584 if (seq1->low_pc < seq2->low_pc)
1586 if (seq1->low_pc > seq2->low_pc)
1589 /* If low_pc values are equal, sort in reverse order of
1590 high_pc, so that the largest region comes first. */
1591 if (seq1->last_line->address < seq2->last_line->address)
1593 if (seq1->last_line->address > seq2->last_line->address)
1596 if (seq1->last_line->op_index < seq2->last_line->op_index)
1598 if (seq1->last_line->op_index > seq2->last_line->op_index)
1604 /* Construct the line information table for quick lookup. */
1607 build_line_info_table (struct line_info_table * table,
1608 struct line_sequence * seq)
1611 struct line_info** line_info_lookup;
1612 struct line_info* each_line;
1613 unsigned int num_lines;
1614 unsigned int line_index;
1616 if (seq->line_info_lookup != NULL)
1619 /* Count the number of line information entries. We could do this while
1620 scanning the debug information, but some entries may be added via
1621 lcl_head without having a sequence handy to increment the number of
1624 for (each_line = seq->last_line; each_line; each_line = each_line->prev_line)
1630 /* Allocate space for the line information lookup table. */
1631 amt = sizeof (struct line_info*) * num_lines;
1632 line_info_lookup = (struct line_info**) bfd_alloc (table->abfd, amt);
1633 if (line_info_lookup == NULL)
1636 /* Create the line information lookup table. */
1637 line_index = num_lines;
1638 for (each_line = seq->last_line; each_line; each_line = each_line->prev_line)
1639 line_info_lookup[--line_index] = each_line;
1641 BFD_ASSERT (line_index == 0);
1643 seq->num_lines = num_lines;
1644 seq->line_info_lookup = line_info_lookup;
1649 /* Sort the line sequences for quick lookup. */
1652 sort_line_sequences (struct line_info_table* table)
1655 struct line_sequence* sequences;
1656 struct line_sequence* seq;
1658 unsigned int num_sequences = table->num_sequences;
1659 bfd_vma last_high_pc;
1661 if (num_sequences == 0)
1664 /* Allocate space for an array of sequences. */
1665 amt = sizeof (struct line_sequence) * num_sequences;
1666 sequences = (struct line_sequence *) bfd_alloc (table->abfd, amt);
1667 if (sequences == NULL)
1670 /* Copy the linked list into the array, freeing the original nodes. */
1671 seq = table->sequences;
1672 for (n = 0; n < num_sequences; n++)
1674 struct line_sequence* last_seq = seq;
1677 sequences[n].low_pc = seq->low_pc;
1678 sequences[n].prev_sequence = NULL;
1679 sequences[n].last_line = seq->last_line;
1680 sequences[n].line_info_lookup = NULL;
1681 sequences[n].num_lines = 0;
1682 seq = seq->prev_sequence;
1685 BFD_ASSERT (seq == NULL);
1687 qsort (sequences, n, sizeof (struct line_sequence), compare_sequences);
1689 /* Make the list binary-searchable by trimming overlapping entries
1690 and removing nested entries. */
1692 last_high_pc = sequences[0].last_line->address;
1693 for (n = 1; n < table->num_sequences; n++)
1695 if (sequences[n].low_pc < last_high_pc)
1697 if (sequences[n].last_line->address <= last_high_pc)
1698 /* Skip nested entries. */
1701 /* Trim overlapping entries. */
1702 sequences[n].low_pc = last_high_pc;
1704 last_high_pc = sequences[n].last_line->address;
1705 if (n > num_sequences)
1707 /* Close up the gap. */
1708 sequences[num_sequences].low_pc = sequences[n].low_pc;
1709 sequences[num_sequences].last_line = sequences[n].last_line;
1714 table->sequences = sequences;
1715 table->num_sequences = num_sequences;
1719 /* Decode the line number information for UNIT. */
1721 static struct line_info_table*
1722 decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
1724 bfd *abfd = unit->abfd;
1725 struct line_info_table* table;
1728 struct line_head lh;
1729 unsigned int i, bytes_read, offset_size;
1730 char *cur_file, *cur_dir;
1731 unsigned char op_code, extended_op, adj_opcode;
1732 unsigned int exop_len;
1735 if (! read_section (abfd, &stash->debug_sections[debug_line],
1736 stash->syms, unit->line_offset,
1737 &stash->dwarf_line_buffer, &stash->dwarf_line_size))
1740 amt = sizeof (struct line_info_table);
1741 table = (struct line_info_table *) bfd_alloc (abfd, amt);
1745 table->comp_dir = unit->comp_dir;
1747 table->num_files = 0;
1748 table->files = NULL;
1750 table->num_dirs = 0;
1753 table->num_sequences = 0;
1754 table->sequences = NULL;
1756 table->lcl_head = NULL;
1758 if (stash->dwarf_line_size < 16)
1761 (_("Dwarf Error: Line info section is too small (%ld)"),
1762 (long) stash->dwarf_line_size);
1763 bfd_set_error (bfd_error_bad_value);
1766 line_ptr = stash->dwarf_line_buffer + unit->line_offset;
1767 line_end = stash->dwarf_line_buffer + stash->dwarf_line_size;
1769 /* Read in the prologue. */
1770 lh.total_length = read_4_bytes (abfd, line_ptr, line_end);
1773 if (lh.total_length == 0xffffffff)
1775 lh.total_length = read_8_bytes (abfd, line_ptr, line_end);
1779 else if (lh.total_length == 0 && unit->addr_size == 8)
1781 /* Handle (non-standard) 64-bit DWARF2 formats. */
1782 lh.total_length = read_4_bytes (abfd, line_ptr, line_end);
1787 if (lh.total_length > stash->dwarf_line_size)
1790 /* xgettext: c-format */
1791 (_("Dwarf Error: Line info data is bigger (0x%lx) than the section (0x%lx)"),
1792 (long) lh.total_length, (long) stash->dwarf_line_size);
1793 bfd_set_error (bfd_error_bad_value);
1797 line_end = line_ptr + lh.total_length;
1799 lh.version = read_2_bytes (abfd, line_ptr, line_end);
1800 if (lh.version < 2 || lh.version > 4)
1803 (_("Dwarf Error: Unhandled .debug_line version %d."), lh.version);
1804 bfd_set_error (bfd_error_bad_value);
1809 if (line_ptr + offset_size + (lh.version >=4 ? 6 : 5) >= line_end)
1812 (_("Dwarf Error: Ran out of room reading prologue"));
1813 bfd_set_error (bfd_error_bad_value);
1817 if (offset_size == 4)
1818 lh.prologue_length = read_4_bytes (abfd, line_ptr, line_end);
1820 lh.prologue_length = read_8_bytes (abfd, line_ptr, line_end);
1821 line_ptr += offset_size;
1823 lh.minimum_instruction_length = read_1_byte (abfd, line_ptr, line_end);
1826 if (lh.version >= 4)
1828 lh.maximum_ops_per_insn = read_1_byte (abfd, line_ptr, line_end);
1832 lh.maximum_ops_per_insn = 1;
1834 if (lh.maximum_ops_per_insn == 0)
1837 (_("Dwarf Error: Invalid maximum operations per instruction."));
1838 bfd_set_error (bfd_error_bad_value);
1842 lh.default_is_stmt = read_1_byte (abfd, line_ptr, line_end);
1845 lh.line_base = read_1_signed_byte (abfd, line_ptr, line_end);
1848 lh.line_range = read_1_byte (abfd, line_ptr, line_end);
1851 lh.opcode_base = read_1_byte (abfd, line_ptr, line_end);
1854 if (line_ptr + (lh.opcode_base - 1) >= line_end)
1856 _bfd_error_handler (_("Dwarf Error: Ran out of room reading opcodes"));
1857 bfd_set_error (bfd_error_bad_value);
1861 amt = lh.opcode_base * sizeof (unsigned char);
1862 lh.standard_opcode_lengths = (unsigned char *) bfd_alloc (abfd, amt);
1864 lh.standard_opcode_lengths[0] = 1;
1866 for (i = 1; i < lh.opcode_base; ++i)
1868 lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr, line_end);
1872 /* Read directory table. */
1873 while ((cur_dir = read_string (abfd, line_ptr, line_end, &bytes_read)) != NULL)
1875 line_ptr += bytes_read;
1877 if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
1881 amt = table->num_dirs + DIR_ALLOC_CHUNK;
1882 amt *= sizeof (char *);
1884 tmp = (char **) bfd_realloc (table->dirs, amt);
1890 table->dirs[table->num_dirs++] = cur_dir;
1893 line_ptr += bytes_read;
1895 /* Read file name table. */
1896 while ((cur_file = read_string (abfd, line_ptr, line_end, &bytes_read)) != NULL)
1898 line_ptr += bytes_read;
1900 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1902 struct fileinfo *tmp;
1904 amt = table->num_files + FILE_ALLOC_CHUNK;
1905 amt *= sizeof (struct fileinfo);
1907 tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
1913 table->files[table->num_files].name = cur_file;
1914 table->files[table->num_files].dir =
1915 safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1916 line_ptr += bytes_read;
1917 table->files[table->num_files].time = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1918 line_ptr += bytes_read;
1919 table->files[table->num_files].size = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1920 line_ptr += bytes_read;
1924 line_ptr += bytes_read;
1926 /* Read the statement sequences until there's nothing left. */
1927 while (line_ptr < line_end)
1929 /* State machine registers. */
1930 bfd_vma address = 0;
1931 unsigned char op_index = 0;
1932 char * filename = table->num_files ? concat_filename (table, 1) : NULL;
1933 unsigned int line = 1;
1934 unsigned int column = 0;
1935 unsigned int discriminator = 0;
1936 int is_stmt = lh.default_is_stmt;
1937 int end_sequence = 0;
1938 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1939 compilers generate address sequences that are wildly out of
1940 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1941 for ia64-Linux). Thus, to determine the low and high
1942 address, we must compare on every DW_LNS_copy, etc. */
1943 bfd_vma low_pc = (bfd_vma) -1;
1944 bfd_vma high_pc = 0;
1946 /* Decode the table. */
1947 while (! end_sequence)
1949 op_code = read_1_byte (abfd, line_ptr, line_end);
1952 if (op_code >= lh.opcode_base)
1954 /* Special operand. */
1955 adj_opcode = op_code - lh.opcode_base;
1956 if (lh.line_range == 0)
1958 if (lh.maximum_ops_per_insn == 1)
1959 address += (adj_opcode / lh.line_range
1960 * lh.minimum_instruction_length);
1963 address += ((op_index + adj_opcode / lh.line_range)
1964 / lh.maximum_ops_per_insn
1965 * lh.minimum_instruction_length);
1966 op_index = ((op_index + adj_opcode / lh.line_range)
1967 % lh.maximum_ops_per_insn);
1969 line += lh.line_base + (adj_opcode % lh.line_range);
1970 /* Append row to matrix using current values. */
1971 if (!add_line_info (table, address, op_index, filename,
1972 line, column, discriminator, 0))
1975 if (address < low_pc)
1977 if (address > high_pc)
1980 else switch (op_code)
1982 case DW_LNS_extended_op:
1983 exop_len = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
1984 line_ptr += bytes_read;
1985 extended_op = read_1_byte (abfd, line_ptr, line_end);
1988 switch (extended_op)
1990 case DW_LNE_end_sequence:
1992 if (!add_line_info (table, address, op_index, filename, line,
1993 column, discriminator, end_sequence))
1996 if (address < low_pc)
1998 if (address > high_pc)
2000 if (!arange_add (unit, &unit->arange, low_pc, high_pc))
2003 case DW_LNE_set_address:
2004 address = read_address (unit, line_ptr, line_end);
2006 line_ptr += unit->addr_size;
2008 case DW_LNE_define_file:
2009 cur_file = read_string (abfd, line_ptr, line_end, &bytes_read);
2010 line_ptr += bytes_read;
2011 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
2013 struct fileinfo *tmp;
2015 amt = table->num_files + FILE_ALLOC_CHUNK;
2016 amt *= sizeof (struct fileinfo);
2017 tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
2022 table->files[table->num_files].name = cur_file;
2023 table->files[table->num_files].dir =
2024 safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
2025 line_ptr += bytes_read;
2026 table->files[table->num_files].time =
2027 safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
2028 line_ptr += bytes_read;
2029 table->files[table->num_files].size =
2030 safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
2031 line_ptr += bytes_read;
2034 case DW_LNE_set_discriminator:
2036 safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
2037 line_ptr += bytes_read;
2039 case DW_LNE_HP_source_file_correlation:
2040 line_ptr += exop_len - 1;
2044 (_("Dwarf Error: mangled line number section."));
2045 bfd_set_error (bfd_error_bad_value);
2047 if (filename != NULL)
2053 if (!add_line_info (table, address, op_index,
2054 filename, line, column, discriminator, 0))
2057 if (address < low_pc)
2059 if (address > high_pc)
2062 case DW_LNS_advance_pc:
2063 if (lh.maximum_ops_per_insn == 1)
2064 address += (lh.minimum_instruction_length
2065 * safe_read_leb128 (abfd, line_ptr, &bytes_read,
2069 bfd_vma adjust = safe_read_leb128 (abfd, line_ptr, &bytes_read,
2071 address = ((op_index + adjust) / lh.maximum_ops_per_insn
2072 * lh.minimum_instruction_length);
2073 op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
2075 line_ptr += bytes_read;
2077 case DW_LNS_advance_line:
2078 line += safe_read_leb128 (abfd, line_ptr, &bytes_read, TRUE, line_end);
2079 line_ptr += bytes_read;
2081 case DW_LNS_set_file:
2085 /* The file and directory tables are 0
2086 based, the references are 1 based. */
2087 file = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
2088 line_ptr += bytes_read;
2091 filename = concat_filename (table, file);
2094 case DW_LNS_set_column:
2095 column = safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
2096 line_ptr += bytes_read;
2098 case DW_LNS_negate_stmt:
2099 is_stmt = (!is_stmt);
2101 case DW_LNS_set_basic_block:
2103 case DW_LNS_const_add_pc:
2104 if (lh.maximum_ops_per_insn == 1)
2105 address += (lh.minimum_instruction_length
2106 * ((255 - lh.opcode_base) / lh.line_range));
2109 bfd_vma adjust = ((255 - lh.opcode_base) / lh.line_range);
2110 address += (lh.minimum_instruction_length
2111 * ((op_index + adjust)
2112 / lh.maximum_ops_per_insn));
2113 op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
2116 case DW_LNS_fixed_advance_pc:
2117 address += read_2_bytes (abfd, line_ptr, line_end);
2122 /* Unknown standard opcode, ignore it. */
2123 for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
2125 (void) safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
2126 line_ptr += bytes_read;
2136 if (sort_line_sequences (table))
2140 if (table->sequences != NULL)
2141 free (table->sequences);
2142 if (table->files != NULL)
2143 free (table->files);
2144 if (table->dirs != NULL)
2149 /* If ADDR is within TABLE set the output parameters and return the
2150 range of addresses covered by the entry used to fill them out.
2151 Otherwise set * FILENAME_PTR to NULL and return 0.
2152 The parameters FILENAME_PTR, LINENUMBER_PTR and DISCRIMINATOR_PTR
2153 are pointers to the objects to be filled in. */
2156 lookup_address_in_line_info_table (struct line_info_table *table,
2158 const char **filename_ptr,
2159 unsigned int *linenumber_ptr,
2160 unsigned int *discriminator_ptr)
2162 struct line_sequence *seq = NULL;
2163 struct line_info *info;
2166 /* Binary search the array of sequences. */
2168 high = table->num_sequences;
2171 mid = (low + high) / 2;
2172 seq = &table->sequences[mid];
2173 if (addr < seq->low_pc)
2175 else if (addr >= seq->last_line->address)
2181 /* Check for a valid sequence. */
2182 if (!seq || addr < seq->low_pc || addr >= seq->last_line->address)
2185 if (!build_line_info_table (table, seq))
2188 /* Binary search the array of line information. */
2190 high = seq->num_lines;
2194 mid = (low + high) / 2;
2195 info = seq->line_info_lookup[mid];
2196 if (addr < info->address)
2198 else if (addr >= seq->line_info_lookup[mid + 1]->address)
2204 /* Check for a valid line information entry. */
2206 && addr >= info->address
2207 && addr < seq->line_info_lookup[mid + 1]->address
2208 && !(info->end_sequence || info == seq->last_line))
2210 *filename_ptr = info->filename;
2211 *linenumber_ptr = info->line;
2212 if (discriminator_ptr)
2213 *discriminator_ptr = info->discriminator;
2214 return seq->last_line->address - seq->low_pc;
2218 *filename_ptr = NULL;
2222 /* Read in the .debug_ranges section for future reference. */
2225 read_debug_ranges (struct comp_unit * unit)
2227 struct dwarf2_debug * stash = unit->stash;
2229 return read_section (unit->abfd, &stash->debug_sections[debug_ranges],
2231 &stash->dwarf_ranges_buffer,
2232 &stash->dwarf_ranges_size);
2235 /* Function table functions. */
2238 compare_lookup_funcinfos (const void * a, const void * b)
2240 const struct lookup_funcinfo * lookup1 = a;
2241 const struct lookup_funcinfo * lookup2 = b;
2243 if (lookup1->low_addr < lookup2->low_addr)
2245 if (lookup1->low_addr > lookup2->low_addr)
2247 if (lookup1->high_addr < lookup2->high_addr)
2249 if (lookup1->high_addr > lookup2->high_addr)
2256 build_lookup_funcinfo_table (struct comp_unit * unit)
2258 struct lookup_funcinfo *lookup_funcinfo_table = unit->lookup_funcinfo_table;
2259 unsigned int number_of_functions = unit->number_of_functions;
2260 struct funcinfo *each;
2261 struct lookup_funcinfo *entry;
2263 struct arange *range;
2264 bfd_vma low_addr, high_addr;
2266 if (lookup_funcinfo_table || number_of_functions == 0)
2269 /* Create the function info lookup table. */
2270 lookup_funcinfo_table = (struct lookup_funcinfo *)
2271 bfd_malloc (number_of_functions * sizeof (struct lookup_funcinfo));
2272 if (lookup_funcinfo_table == NULL)
2275 /* Populate the function info lookup table. */
2276 func_index = number_of_functions;
2277 for (each = unit->function_table; each; each = each->prev_func)
2279 entry = &lookup_funcinfo_table[--func_index];
2280 entry->funcinfo = each;
2282 /* Calculate the lowest and highest address for this function entry. */
2283 low_addr = entry->funcinfo->arange.low;
2284 high_addr = entry->funcinfo->arange.high;
2286 for (range = entry->funcinfo->arange.next; range; range = range->next)
2288 if (range->low < low_addr)
2289 low_addr = range->low;
2290 if (range->high > high_addr)
2291 high_addr = range->high;
2294 entry->low_addr = low_addr;
2295 entry->high_addr = high_addr;
2298 BFD_ASSERT (func_index == 0);
2300 /* Sort the function by address. */
2301 qsort (lookup_funcinfo_table,
2302 number_of_functions,
2303 sizeof (struct lookup_funcinfo),
2304 compare_lookup_funcinfos);
2306 /* Calculate the high watermark for each function in the lookup table. */
2307 high_addr = lookup_funcinfo_table[0].high_addr;
2308 for (func_index = 1; func_index < number_of_functions; func_index++)
2310 entry = &lookup_funcinfo_table[func_index];
2311 if (entry->high_addr > high_addr)
2312 high_addr = entry->high_addr;
2314 entry->high_addr = high_addr;
2317 unit->lookup_funcinfo_table = lookup_funcinfo_table;
2321 /* If ADDR is within UNIT's function tables, set FUNCTION_PTR, and return
2322 TRUE. Note that we need to find the function that has the smallest range
2323 that contains ADDR, to handle inlined functions without depending upon
2324 them being ordered in TABLE by increasing range. */
2327 lookup_address_in_function_table (struct comp_unit *unit,
2329 struct funcinfo **function_ptr)
2331 unsigned int number_of_functions = unit->number_of_functions;
2332 struct lookup_funcinfo* lookup_funcinfo = NULL;
2333 struct funcinfo* funcinfo = NULL;
2334 struct funcinfo* best_fit = NULL;
2335 bfd_vma best_fit_len = 0;
2336 bfd_size_type low, high, mid, first;
2337 struct arange *arange;
2339 if (number_of_functions == 0)
2342 if (!build_lookup_funcinfo_table (unit))
2345 if (unit->lookup_funcinfo_table[number_of_functions - 1].high_addr < addr)
2348 /* Find the first function in the lookup table which may contain the
2349 specified address. */
2351 high = number_of_functions;
2355 mid = (low + high) / 2;
2356 lookup_funcinfo = &unit->lookup_funcinfo_table[mid];
2357 if (addr < lookup_funcinfo->low_addr)
2359 else if (addr >= lookup_funcinfo->high_addr)
2365 /* Find the 'best' match for the address. The prior algorithm defined the
2366 best match as the function with the smallest address range containing
2367 the specified address. This definition should probably be changed to the
2368 innermost inline routine containing the address, but right now we want
2369 to get the same results we did before. */
2370 while (first < number_of_functions)
2372 if (addr < unit->lookup_funcinfo_table[first].low_addr)
2374 funcinfo = unit->lookup_funcinfo_table[first].funcinfo;
2376 for (arange = &funcinfo->arange; arange; arange = arange->next)
2378 if (addr < arange->low || addr >= arange->high)
2382 || arange->high - arange->low < best_fit_len
2383 /* The following comparison is designed to return the same
2384 match as the previous algorithm for routines which have the
2385 same best fit length. */
2386 || (arange->high - arange->low == best_fit_len
2387 && funcinfo > best_fit))
2389 best_fit = funcinfo;
2390 best_fit_len = arange->high - arange->low;
2400 *function_ptr = best_fit;
2404 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
2405 and LINENUMBER_PTR, and return TRUE. */
2408 lookup_symbol_in_function_table (struct comp_unit *unit,
2411 const char **filename_ptr,
2412 unsigned int *linenumber_ptr)
2414 struct funcinfo* each_func;
2415 struct funcinfo* best_fit = NULL;
2416 bfd_vma best_fit_len = 0;
2417 struct arange *arange;
2418 const char *name = bfd_asymbol_name (sym);
2419 asection *sec = bfd_get_section (sym);
2421 for (each_func = unit->function_table;
2423 each_func = each_func->prev_func)
2425 for (arange = &each_func->arange;
2427 arange = arange->next)
2429 if ((!each_func->sec || each_func->sec == sec)
2430 && addr >= arange->low
2431 && addr < arange->high
2433 && strcmp (name, each_func->name) == 0
2435 || arange->high - arange->low < best_fit_len))
2437 best_fit = each_func;
2438 best_fit_len = arange->high - arange->low;
2445 best_fit->sec = sec;
2446 *filename_ptr = best_fit->file;
2447 *linenumber_ptr = best_fit->line;
2454 /* Variable table functions. */
2456 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
2457 LINENUMBER_PTR, and return TRUE. */
2460 lookup_symbol_in_variable_table (struct comp_unit *unit,
2463 const char **filename_ptr,
2464 unsigned int *linenumber_ptr)
2466 const char *name = bfd_asymbol_name (sym);
2467 asection *sec = bfd_get_section (sym);
2468 struct varinfo* each;
2470 for (each = unit->variable_table; each; each = each->prev_var)
2471 if (each->stack == 0
2472 && each->file != NULL
2473 && each->name != NULL
2474 && each->addr == addr
2475 && (!each->sec || each->sec == sec)
2476 && strcmp (name, each->name) == 0)
2482 *filename_ptr = each->file;
2483 *linenumber_ptr = each->line;
2491 find_abstract_instance_name (struct comp_unit *unit,
2492 struct attribute *attr_ptr,
2493 bfd_boolean *is_linkage)
2495 bfd *abfd = unit->abfd;
2497 bfd_byte *info_ptr_end;
2498 unsigned int abbrev_number, bytes_read, i;
2499 struct abbrev_info *abbrev;
2500 bfd_uint64_t die_ref = attr_ptr->u.val;
2501 struct attribute attr;
2504 /* DW_FORM_ref_addr can reference an entry in a different CU. It
2505 is an offset from the .debug_info section, not the current CU. */
2506 if (attr_ptr->form == DW_FORM_ref_addr)
2508 /* We only support DW_FORM_ref_addr within the same file, so
2509 any relocations should be resolved already. */
2513 info_ptr = unit->sec_info_ptr + die_ref;
2514 info_ptr_end = unit->end_ptr;
2516 /* Now find the CU containing this pointer. */
2517 if (info_ptr >= unit->info_ptr_unit && info_ptr < unit->end_ptr)
2521 /* Check other CUs to see if they contain the abbrev. */
2522 struct comp_unit * u;
2524 for (u = unit->prev_unit; u != NULL; u = u->prev_unit)
2525 if (info_ptr >= u->info_ptr_unit && info_ptr < u->end_ptr)
2529 for (u = unit->next_unit; u != NULL; u = u->next_unit)
2530 if (info_ptr >= u->info_ptr_unit && info_ptr < u->end_ptr)
2535 /* else FIXME: What do we do now ? */
2538 else if (attr_ptr->form == DW_FORM_GNU_ref_alt)
2540 info_ptr = read_alt_indirect_ref (unit, die_ref);
2541 if (info_ptr == NULL)
2544 (_("Dwarf Error: Unable to read alt ref %u."), die_ref);
2545 bfd_set_error (bfd_error_bad_value);
2548 info_ptr_end = unit->stash->alt_dwarf_info_buffer + unit->stash->alt_dwarf_info_size;
2550 /* FIXME: Do we need to locate the correct CU, in a similar
2551 fashion to the code in the DW_FORM_ref_addr case above ? */
2555 info_ptr = unit->info_ptr_unit + die_ref;
2556 info_ptr_end = unit->end_ptr;
2559 abbrev_number = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
2560 info_ptr += bytes_read;
2564 abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
2568 (_("Dwarf Error: Could not find abbrev number %u."), abbrev_number);
2569 bfd_set_error (bfd_error_bad_value);
2573 for (i = 0; i < abbrev->num_attrs; ++i)
2575 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit,
2576 info_ptr, info_ptr_end);
2577 if (info_ptr == NULL)
2582 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2584 if (name == NULL && is_str_attr (attr.form))
2587 if (non_mangled (unit->lang))
2591 case DW_AT_specification:
2592 name = find_abstract_instance_name (unit, &attr, is_linkage);
2594 case DW_AT_linkage_name:
2595 case DW_AT_MIPS_linkage_name:
2596 /* PR 16949: Corrupt debug info can place
2597 non-string forms into these attributes. */
2598 if (is_str_attr (attr.form))
2614 read_rangelist (struct comp_unit *unit, struct arange *arange,
2615 bfd_uint64_t offset)
2617 bfd_byte *ranges_ptr;
2618 bfd_byte *ranges_end;
2619 bfd_vma base_address = unit->base_address;
2621 if (! unit->stash->dwarf_ranges_buffer)
2623 if (! read_debug_ranges (unit))
2627 ranges_ptr = unit->stash->dwarf_ranges_buffer + offset;
2628 if (ranges_ptr < unit->stash->dwarf_ranges_buffer)
2630 ranges_end = unit->stash->dwarf_ranges_buffer + unit->stash->dwarf_ranges_size;
2637 /* PR 17512: file: 62cada7d. */
2638 if (ranges_ptr + 2 * unit->addr_size > ranges_end)
2641 low_pc = read_address (unit, ranges_ptr, ranges_end);
2642 ranges_ptr += unit->addr_size;
2643 high_pc = read_address (unit, ranges_ptr, ranges_end);
2644 ranges_ptr += unit->addr_size;
2646 if (low_pc == 0 && high_pc == 0)
2648 if (low_pc == -1UL && high_pc != -1UL)
2649 base_address = high_pc;
2652 if (!arange_add (unit, arange,
2653 base_address + low_pc, base_address + high_pc))
2660 /* DWARF2 Compilation unit functions. */
2662 /* Scan over each die in a comp. unit looking for functions to add
2663 to the function table and variables to the variable table. */
2666 scan_unit_for_symbols (struct comp_unit *unit)
2668 bfd *abfd = unit->abfd;
2669 bfd_byte *info_ptr = unit->first_child_die_ptr;
2670 bfd_byte *info_ptr_end = unit->stash->info_ptr_end;
2671 int nesting_level = 1;
2672 struct funcinfo **nested_funcs;
2673 int nested_funcs_size;
2675 /* Maintain a stack of in-scope functions and inlined functions, which we
2676 can use to set the caller_func field. */
2677 nested_funcs_size = 32;
2678 nested_funcs = (struct funcinfo **)
2679 bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *));
2680 if (nested_funcs == NULL)
2682 nested_funcs[nesting_level] = 0;
2684 while (nesting_level)
2686 unsigned int abbrev_number, bytes_read, i;
2687 struct abbrev_info *abbrev;
2688 struct attribute attr;
2689 struct funcinfo *func;
2690 struct varinfo *var;
2692 bfd_vma high_pc = 0;
2693 bfd_boolean high_pc_relative = FALSE;
2695 /* PR 17512: file: 9f405d9d. */
2696 if (info_ptr >= info_ptr_end)
2699 abbrev_number = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, info_ptr_end);
2700 info_ptr += bytes_read;
2702 if (! abbrev_number)
2708 abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
2712 (_("Dwarf Error: Could not find abbrev number %u."),
2714 bfd_set_error (bfd_error_bad_value);
2719 if (abbrev->tag == DW_TAG_subprogram
2720 || abbrev->tag == DW_TAG_entry_point
2721 || abbrev->tag == DW_TAG_inlined_subroutine)
2723 bfd_size_type amt = sizeof (struct funcinfo);
2724 func = (struct funcinfo *) bfd_zalloc (abfd, amt);
2727 func->tag = abbrev->tag;
2728 func->prev_func = unit->function_table;
2729 unit->function_table = func;
2730 unit->number_of_functions++;
2731 BFD_ASSERT (!unit->cached);
2733 if (func->tag == DW_TAG_inlined_subroutine)
2734 for (i = nesting_level - 1; i >= 1; i--)
2735 if (nested_funcs[i])
2737 func->caller_func = nested_funcs[i];
2740 nested_funcs[nesting_level] = func;
2745 if (abbrev->tag == DW_TAG_variable)
2747 bfd_size_type amt = sizeof (struct varinfo);
2748 var = (struct varinfo *) bfd_zalloc (abfd, amt);
2751 var->tag = abbrev->tag;
2753 var->prev_var = unit->variable_table;
2754 unit->variable_table = var;
2755 BFD_ASSERT (!unit->cached);
2758 /* No inline function in scope at this nesting level. */
2759 nested_funcs[nesting_level] = 0;
2762 for (i = 0; i < abbrev->num_attrs; ++i)
2764 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr, info_ptr_end);
2765 if (info_ptr == NULL)
2772 case DW_AT_call_file:
2773 func->caller_file = concat_filename (unit->line_table,
2777 case DW_AT_call_line:
2778 func->caller_line = attr.u.val;
2781 case DW_AT_abstract_origin:
2782 case DW_AT_specification:
2783 func->name = find_abstract_instance_name (unit, &attr,
2788 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2790 if (func->name == NULL && is_str_attr (attr.form))
2792 func->name = attr.u.str;
2793 if (non_mangled (unit->lang))
2794 func->is_linkage = TRUE;
2798 case DW_AT_linkage_name:
2799 case DW_AT_MIPS_linkage_name:
2800 /* PR 16949: Corrupt debug info can place
2801 non-string forms into these attributes. */
2802 if (is_str_attr (attr.form))
2804 func->name = attr.u.str;
2805 func->is_linkage = TRUE;
2810 low_pc = attr.u.val;
2814 high_pc = attr.u.val;
2815 high_pc_relative = attr.form != DW_FORM_addr;
2819 if (!read_rangelist (unit, &func->arange, attr.u.val))
2823 case DW_AT_decl_file:
2824 func->file = concat_filename (unit->line_table,
2828 case DW_AT_decl_line:
2829 func->line = attr.u.val;
2841 var->name = attr.u.str;
2844 case DW_AT_decl_file:
2845 var->file = concat_filename (unit->line_table,
2849 case DW_AT_decl_line:
2850 var->line = attr.u.val;
2853 case DW_AT_external:
2854 if (attr.u.val != 0)
2858 case DW_AT_location:
2862 case DW_FORM_block1:
2863 case DW_FORM_block2:
2864 case DW_FORM_block4:
2865 case DW_FORM_exprloc:
2866 if (*attr.u.blk->data == DW_OP_addr)
2870 /* Verify that DW_OP_addr is the only opcode in the
2871 location, in which case the block size will be 1
2872 plus the address size. */
2873 /* ??? For TLS variables, gcc can emit
2874 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
2875 which we don't handle here yet. */
2876 if (attr.u.blk->size == unit->addr_size + 1U)
2877 var->addr = bfd_get (unit->addr_size * 8,
2879 attr.u.blk->data + 1);
2894 if (high_pc_relative)
2897 if (func && high_pc != 0)
2899 if (!arange_add (unit, &func->arange, low_pc, high_pc))
2903 if (abbrev->has_children)
2907 if (nesting_level >= nested_funcs_size)
2909 struct funcinfo **tmp;
2911 nested_funcs_size *= 2;
2912 tmp = (struct funcinfo **)
2913 bfd_realloc (nested_funcs,
2914 nested_funcs_size * sizeof (struct funcinfo *));
2919 nested_funcs[nesting_level] = 0;
2923 free (nested_funcs);
2927 free (nested_funcs);
2931 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
2932 includes the compilation unit header that proceeds the DIE's, but
2933 does not include the length field that precedes each compilation
2934 unit header. END_PTR points one past the end of this comp unit.
2935 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
2937 This routine does not read the whole compilation unit; only enough
2938 to get to the line number information for the compilation unit. */
2940 static struct comp_unit *
2941 parse_comp_unit (struct dwarf2_debug *stash,
2942 bfd_vma unit_length,
2943 bfd_byte *info_ptr_unit,
2944 unsigned int offset_size)
2946 struct comp_unit* unit;
2947 unsigned int version;
2948 bfd_uint64_t abbrev_offset = 0;
2949 unsigned int addr_size;
2950 struct abbrev_info** abbrevs;
2951 unsigned int abbrev_number, bytes_read, i;
2952 struct abbrev_info *abbrev;
2953 struct attribute attr;
2954 bfd_byte *info_ptr = stash->info_ptr;
2955 bfd_byte *end_ptr = info_ptr + unit_length;
2958 bfd_vma high_pc = 0;
2959 bfd *abfd = stash->bfd_ptr;
2960 bfd_boolean high_pc_relative = FALSE;
2962 version = read_2_bytes (abfd, info_ptr, end_ptr);
2964 BFD_ASSERT (offset_size == 4 || offset_size == 8);
2965 if (offset_size == 4)
2966 abbrev_offset = read_4_bytes (abfd, info_ptr, end_ptr);
2968 abbrev_offset = read_8_bytes (abfd, info_ptr, end_ptr);
2969 info_ptr += offset_size;
2970 addr_size = read_1_byte (abfd, info_ptr, end_ptr);
2973 if (version != 2 && version != 3 && version != 4)
2975 /* PR 19872: A version number of 0 probably means that there is padding
2976 at the end of the .debug_info section. Gold puts it there when
2977 performing an incremental link, for example. So do not generate
2978 an error, just return a NULL. */
2982 (_("Dwarf Error: found dwarf version '%u', this reader"
2983 " only handles version 2, 3 and 4 information."), version);
2984 bfd_set_error (bfd_error_bad_value);
2989 if (addr_size > sizeof (bfd_vma))
2992 /* xgettext: c-format */
2993 (_("Dwarf Error: found address size '%u', this reader"
2994 " can not handle sizes greater than '%u'."),
2996 (unsigned int) sizeof (bfd_vma));
2997 bfd_set_error (bfd_error_bad_value);
3001 if (addr_size != 2 && addr_size != 4 && addr_size != 8)
3004 ("Dwarf Error: found address size '%u', this reader"
3005 " can only handle address sizes '2', '4' and '8'.", addr_size);
3006 bfd_set_error (bfd_error_bad_value);
3010 /* Read the abbrevs for this compilation unit into a table. */
3011 abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
3015 abbrev_number = safe_read_leb128 (abfd, info_ptr, &bytes_read, FALSE, end_ptr);
3016 info_ptr += bytes_read;
3017 if (! abbrev_number)
3019 /* PR 19872: An abbrev number of 0 probably means that there is padding
3020 at the end of the .debug_abbrev section. Gold puts it there when
3021 performing an incremental link, for example. So do not generate
3022 an error, just return a NULL. */
3026 abbrev = lookup_abbrev (abbrev_number, abbrevs);
3029 _bfd_error_handler (_("Dwarf Error: Could not find abbrev number %u."),
3031 bfd_set_error (bfd_error_bad_value);
3035 amt = sizeof (struct comp_unit);
3036 unit = (struct comp_unit *) bfd_zalloc (abfd, amt);
3040 unit->version = version;
3041 unit->addr_size = addr_size;
3042 unit->offset_size = offset_size;
3043 unit->abbrevs = abbrevs;
3044 unit->end_ptr = end_ptr;
3045 unit->stash = stash;
3046 unit->info_ptr_unit = info_ptr_unit;
3047 unit->sec_info_ptr = stash->sec_info_ptr;
3049 for (i = 0; i < abbrev->num_attrs; ++i)
3051 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr, end_ptr);
3052 if (info_ptr == NULL)
3055 /* Store the data if it is of an attribute we want to keep in a
3056 partial symbol table. */
3059 case DW_AT_stmt_list:
3061 unit->line_offset = attr.u.val;
3065 unit->name = attr.u.str;
3069 low_pc = attr.u.val;
3070 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
3071 this is the base address to use when reading location
3072 lists or range lists. */
3073 if (abbrev->tag == DW_TAG_compile_unit)
3074 unit->base_address = low_pc;
3078 high_pc = attr.u.val;
3079 high_pc_relative = attr.form != DW_FORM_addr;
3083 if (!read_rangelist (unit, &unit->arange, attr.u.val))
3087 case DW_AT_comp_dir:
3089 char *comp_dir = attr.u.str;
3091 /* PR 17512: file: 1fe726be. */
3092 if (! is_str_attr (attr.form))
3095 (_("Dwarf Error: DW_AT_comp_dir attribute encountered with a non-string form."));
3101 /* Irix 6.2 native cc prepends <machine>.: to the compilation
3102 directory, get rid of it. */
3103 char *cp = strchr (comp_dir, ':');
3105 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
3108 unit->comp_dir = comp_dir;
3112 case DW_AT_language:
3113 unit->lang = attr.u.val;
3120 if (high_pc_relative)
3124 if (!arange_add (unit, &unit->arange, low_pc, high_pc))
3128 unit->first_child_die_ptr = info_ptr;
3132 /* Return TRUE if UNIT may contain the address given by ADDR. When
3133 there are functions written entirely with inline asm statements, the
3134 range info in the compilation unit header may not be correct. We
3135 need to consult the line info table to see if a compilation unit
3136 really contains the given address. */
3139 comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
3141 struct arange *arange;
3146 arange = &unit->arange;
3149 if (addr >= arange->low && addr < arange->high)
3151 arange = arange->next;
3158 /* If UNIT contains ADDR, set the output parameters to the values for
3159 the line containing ADDR. The output parameters, FILENAME_PTR,
3160 FUNCTION_PTR, and LINENUMBER_PTR, are pointers to the objects
3163 Returns the range of addresses covered by the entry that was used
3164 to fill in *LINENUMBER_PTR or 0 if it was not filled in. */
3167 comp_unit_find_nearest_line (struct comp_unit *unit,
3169 const char **filename_ptr,
3170 struct funcinfo **function_ptr,
3171 unsigned int *linenumber_ptr,
3172 unsigned int *discriminator_ptr,
3173 struct dwarf2_debug *stash)
3180 if (! unit->line_table)
3182 if (! unit->stmtlist)
3188 unit->line_table = decode_line_info (unit, stash);
3190 if (! unit->line_table)
3196 if (unit->first_child_die_ptr < unit->end_ptr
3197 && ! scan_unit_for_symbols (unit))
3204 *function_ptr = NULL;
3205 func_p = lookup_address_in_function_table (unit, addr, function_ptr);
3206 if (func_p && (*function_ptr)->tag == DW_TAG_inlined_subroutine)
3207 stash->inliner_chain = *function_ptr;
3209 return lookup_address_in_line_info_table (unit->line_table, addr,
3215 /* Check to see if line info is already decoded in a comp_unit.
3216 If not, decode it. Returns TRUE if no errors were encountered;
3220 comp_unit_maybe_decode_line_info (struct comp_unit *unit,
3221 struct dwarf2_debug *stash)
3226 if (! unit->line_table)
3228 if (! unit->stmtlist)
3234 unit->line_table = decode_line_info (unit, stash);
3236 if (! unit->line_table)
3242 if (unit->first_child_die_ptr < unit->end_ptr
3243 && ! scan_unit_for_symbols (unit))
3253 /* If UNIT contains SYM at ADDR, set the output parameters to the
3254 values for the line containing SYM. The output parameters,
3255 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
3258 Return TRUE if UNIT contains SYM, and no errors were encountered;
3262 comp_unit_find_line (struct comp_unit *unit,
3265 const char **filename_ptr,
3266 unsigned int *linenumber_ptr,
3267 struct dwarf2_debug *stash)
3269 if (!comp_unit_maybe_decode_line_info (unit, stash))
3272 if (sym->flags & BSF_FUNCTION)
3273 return lookup_symbol_in_function_table (unit, sym, addr,
3277 return lookup_symbol_in_variable_table (unit, sym, addr,
3282 static struct funcinfo *
3283 reverse_funcinfo_list (struct funcinfo *head)
3285 struct funcinfo *rhead;
3286 struct funcinfo *temp;
3288 for (rhead = NULL; head; head = temp)
3290 temp = head->prev_func;
3291 head->prev_func = rhead;
3297 static struct varinfo *
3298 reverse_varinfo_list (struct varinfo *head)
3300 struct varinfo *rhead;
3301 struct varinfo *temp;
3303 for (rhead = NULL; head; head = temp)
3305 temp = head->prev_var;
3306 head->prev_var = rhead;
3312 /* Extract all interesting funcinfos and varinfos of a compilation
3313 unit into hash tables for faster lookup. Returns TRUE if no
3314 errors were enountered; FALSE otherwise. */
3317 comp_unit_hash_info (struct dwarf2_debug *stash,
3318 struct comp_unit *unit,
3319 struct info_hash_table *funcinfo_hash_table,
3320 struct info_hash_table *varinfo_hash_table)
3322 struct funcinfo* each_func;
3323 struct varinfo* each_var;
3324 bfd_boolean okay = TRUE;
3326 BFD_ASSERT (stash->info_hash_status != STASH_INFO_HASH_DISABLED);
3328 if (!comp_unit_maybe_decode_line_info (unit, stash))
3331 BFD_ASSERT (!unit->cached);
3333 /* To preserve the original search order, we went to visit the function
3334 infos in the reversed order of the list. However, making the list
3335 bi-directional use quite a bit of extra memory. So we reverse
3336 the list first, traverse the list in the now reversed order and
3337 finally reverse the list again to get back the original order. */
3338 unit->function_table = reverse_funcinfo_list (unit->function_table);
3339 for (each_func = unit->function_table;
3341 each_func = each_func->prev_func)
3343 /* Skip nameless functions. */
3344 if (each_func->name)
3345 /* There is no need to copy name string into hash table as
3346 name string is either in the dwarf string buffer or
3347 info in the stash. */
3348 okay = insert_info_hash_table (funcinfo_hash_table, each_func->name,
3349 (void*) each_func, FALSE);
3351 unit->function_table = reverse_funcinfo_list (unit->function_table);
3355 /* We do the same for variable infos. */
3356 unit->variable_table = reverse_varinfo_list (unit->variable_table);
3357 for (each_var = unit->variable_table;
3359 each_var = each_var->prev_var)
3361 /* Skip stack vars and vars with no files or names. */
3362 if (each_var->stack == 0
3363 && each_var->file != NULL
3364 && each_var->name != NULL)
3365 /* There is no need to copy name string into hash table as
3366 name string is either in the dwarf string buffer or
3367 info in the stash. */
3368 okay = insert_info_hash_table (varinfo_hash_table, each_var->name,
3369 (void*) each_var, FALSE);
3372 unit->variable_table = reverse_varinfo_list (unit->variable_table);
3373 unit->cached = TRUE;
3377 /* Locate a section in a BFD containing debugging info. The search starts
3378 from the section after AFTER_SEC, or from the first section in the BFD if
3379 AFTER_SEC is NULL. The search works by examining the names of the
3380 sections. There are three permissiable names. The first two are given
3381 by DEBUG_SECTIONS[debug_info] (whose standard DWARF2 names are .debug_info
3382 and .zdebug_info). The third is a prefix .gnu.linkonce.wi.
3383 This is a variation on the .debug_info section which has a checksum
3384 describing the contents appended onto the name. This allows the linker to
3385 identify and discard duplicate debugging sections for different
3386 compilation units. */
3387 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
3390 find_debug_info (bfd *abfd, const struct dwarf_debug_section *debug_sections,
3391 asection *after_sec)
3396 if (after_sec == NULL)
3398 look = debug_sections[debug_info].uncompressed_name;
3399 msec = bfd_get_section_by_name (abfd, look);
3403 look = debug_sections[debug_info].compressed_name;
3406 msec = bfd_get_section_by_name (abfd, look);
3411 for (msec = abfd->sections; msec != NULL; msec = msec->next)
3412 if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
3418 for (msec = after_sec->next; msec != NULL; msec = msec->next)
3420 look = debug_sections[debug_info].uncompressed_name;
3421 if (strcmp (msec->name, look) == 0)
3424 look = debug_sections[debug_info].compressed_name;
3425 if (look != NULL && strcmp (msec->name, look) == 0)
3428 if (CONST_STRNEQ (msec->name, GNU_LINKONCE_INFO))
3435 /* Transfer VMAs from object file to separate debug file. */
3438 set_debug_vma (bfd *orig_bfd, bfd *debug_bfd)
3442 for (s = orig_bfd->sections, d = debug_bfd->sections;
3443 s != NULL && d != NULL;
3444 s = s->next, d = d->next)
3446 if ((d->flags & SEC_DEBUGGING) != 0)
3448 /* ??? Assumes 1-1 correspondence between sections in the
3450 if (strcmp (s->name, d->name) == 0)
3452 d->output_section = s->output_section;
3453 d->output_offset = s->output_offset;
3459 /* Unset vmas for adjusted sections in STASH. */
3462 unset_sections (struct dwarf2_debug *stash)
3465 struct adjusted_section *p;
3467 i = stash->adjusted_section_count;
3468 p = stash->adjusted_sections;
3469 for (; i > 0; i--, p++)
3470 p->section->vma = 0;
3473 /* Set VMAs for allocated and .debug_info sections in ORIG_BFD, a
3474 relocatable object file. VMAs are normally all zero in relocatable
3475 object files, so if we want to distinguish locations in sections by
3476 address we need to set VMAs so the sections do not overlap. We
3477 also set VMA on .debug_info so that when we have multiple
3478 .debug_info sections (or the linkonce variant) they also do not
3479 overlap. The multiple .debug_info sections make up a single
3480 logical section. ??? We should probably do the same for other
3484 place_sections (bfd *orig_bfd, struct dwarf2_debug *stash)
3487 struct adjusted_section *p;
3489 const char *debug_info_name;
3491 if (stash->adjusted_section_count != 0)
3493 i = stash->adjusted_section_count;
3494 p = stash->adjusted_sections;
3495 for (; i > 0; i--, p++)
3496 p->section->vma = p->adj_vma;
3500 debug_info_name = stash->debug_sections[debug_info].uncompressed_name;
3507 for (sect = abfd->sections; sect != NULL; sect = sect->next)
3511 if ((sect->output_section != NULL
3512 && sect->output_section != sect
3513 && (sect->flags & SEC_DEBUGGING) == 0)
3517 is_debug_info = (strcmp (sect->name, debug_info_name) == 0
3518 || CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO));
3520 if (!((sect->flags & SEC_ALLOC) != 0 && abfd == orig_bfd)
3526 if (abfd == stash->bfd_ptr)
3528 abfd = stash->bfd_ptr;
3532 stash->adjusted_section_count = -1;
3535 bfd_vma last_vma = 0, last_dwarf = 0;
3536 bfd_size_type amt = i * sizeof (struct adjusted_section);
3538 p = (struct adjusted_section *) bfd_malloc (amt);
3542 stash->adjusted_sections = p;
3543 stash->adjusted_section_count = i;
3550 for (sect = abfd->sections; sect != NULL; sect = sect->next)
3555 if ((sect->output_section != NULL
3556 && sect->output_section != sect
3557 && (sect->flags & SEC_DEBUGGING) == 0)
3561 is_debug_info = (strcmp (sect->name, debug_info_name) == 0
3562 || CONST_STRNEQ (sect->name, GNU_LINKONCE_INFO));
3564 if (!((sect->flags & SEC_ALLOC) != 0 && abfd == orig_bfd)
3568 sz = sect->rawsize ? sect->rawsize : sect->size;
3572 BFD_ASSERT (sect->alignment_power == 0);
3573 sect->vma = last_dwarf;
3578 /* Align the new address to the current section
3580 last_vma = ((last_vma
3581 + ~(-((bfd_vma) 1 << sect->alignment_power)))
3582 & (-((bfd_vma) 1 << sect->alignment_power)));
3583 sect->vma = last_vma;
3588 p->adj_vma = sect->vma;
3591 if (abfd == stash->bfd_ptr)
3593 abfd = stash->bfd_ptr;
3597 if (orig_bfd != stash->bfd_ptr)
3598 set_debug_vma (orig_bfd, stash->bfd_ptr);
3603 /* Look up a funcinfo by name using the given info hash table. If found,
3604 also update the locations pointed to by filename_ptr and linenumber_ptr.
3606 This function returns TRUE if a funcinfo that matches the given symbol
3607 and address is found with any error; otherwise it returns FALSE. */
3610 info_hash_lookup_funcinfo (struct info_hash_table *hash_table,
3613 const char **filename_ptr,
3614 unsigned int *linenumber_ptr)
3616 struct funcinfo* each_func;
3617 struct funcinfo* best_fit = NULL;
3618 bfd_vma best_fit_len = 0;
3619 struct info_list_node *node;
3620 struct arange *arange;
3621 const char *name = bfd_asymbol_name (sym);
3622 asection *sec = bfd_get_section (sym);
3624 for (node = lookup_info_hash_table (hash_table, name);
3628 each_func = (struct funcinfo *) node->info;
3629 for (arange = &each_func->arange;
3631 arange = arange->next)
3633 if ((!each_func->sec || each_func->sec == sec)
3634 && addr >= arange->low
3635 && addr < arange->high
3637 || arange->high - arange->low < best_fit_len))
3639 best_fit = each_func;
3640 best_fit_len = arange->high - arange->low;
3647 best_fit->sec = sec;
3648 *filename_ptr = best_fit->file;
3649 *linenumber_ptr = best_fit->line;
3656 /* Look up a varinfo by name using the given info hash table. If found,
3657 also update the locations pointed to by filename_ptr and linenumber_ptr.
3659 This function returns TRUE if a varinfo that matches the given symbol
3660 and address is found with any error; otherwise it returns FALSE. */
3663 info_hash_lookup_varinfo (struct info_hash_table *hash_table,
3666 const char **filename_ptr,
3667 unsigned int *linenumber_ptr)
3669 const char *name = bfd_asymbol_name (sym);
3670 asection *sec = bfd_get_section (sym);
3671 struct varinfo* each;
3672 struct info_list_node *node;
3674 for (node = lookup_info_hash_table (hash_table, name);
3678 each = (struct varinfo *) node->info;
3679 if (each->addr == addr
3680 && (!each->sec || each->sec == sec))
3683 *filename_ptr = each->file;
3684 *linenumber_ptr = each->line;
3692 /* Update the funcinfo and varinfo info hash tables if they are
3693 not up to date. Returns TRUE if there is no error; otherwise
3694 returns FALSE and disable the info hash tables. */
3697 stash_maybe_update_info_hash_tables (struct dwarf2_debug *stash)
3699 struct comp_unit *each;
3701 /* Exit if hash tables are up-to-date. */
3702 if (stash->all_comp_units == stash->hash_units_head)
3705 if (stash->hash_units_head)
3706 each = stash->hash_units_head->prev_unit;
3708 each = stash->last_comp_unit;
3712 if (!comp_unit_hash_info (stash, each, stash->funcinfo_hash_table,
3713 stash->varinfo_hash_table))
3715 stash->info_hash_status = STASH_INFO_HASH_DISABLED;
3718 each = each->prev_unit;
3721 stash->hash_units_head = stash->all_comp_units;
3725 /* Check consistency of info hash tables. This is for debugging only. */
3727 static void ATTRIBUTE_UNUSED
3728 stash_verify_info_hash_table (struct dwarf2_debug *stash)
3730 struct comp_unit *each_unit;
3731 struct funcinfo *each_func;
3732 struct varinfo *each_var;
3733 struct info_list_node *node;
3736 for (each_unit = stash->all_comp_units;
3738 each_unit = each_unit->next_unit)
3740 for (each_func = each_unit->function_table;
3742 each_func = each_func->prev_func)
3744 if (!each_func->name)
3746 node = lookup_info_hash_table (stash->funcinfo_hash_table,
3750 while (node && !found)
3752 found = node->info == each_func;
3758 for (each_var = each_unit->variable_table;
3760 each_var = each_var->prev_var)
3762 if (!each_var->name || !each_var->file || each_var->stack)
3764 node = lookup_info_hash_table (stash->varinfo_hash_table,
3768 while (node && !found)
3770 found = node->info == each_var;
3778 /* Check to see if we want to enable the info hash tables, which consume
3779 quite a bit of memory. Currently we only check the number times
3780 bfd_dwarf2_find_line is called. In the future, we may also want to
3781 take the number of symbols into account. */
3784 stash_maybe_enable_info_hash_tables (bfd *abfd, struct dwarf2_debug *stash)
3786 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_OFF);
3788 if (stash->info_hash_count++ < STASH_INFO_HASH_TRIGGER)
3791 /* FIXME: Maybe we should check the reduce_memory_overheads
3792 and optimize fields in the bfd_link_info structure ? */
3794 /* Create hash tables. */
3795 stash->funcinfo_hash_table = create_info_hash_table (abfd);
3796 stash->varinfo_hash_table = create_info_hash_table (abfd);
3797 if (!stash->funcinfo_hash_table || !stash->varinfo_hash_table)
3799 /* Turn off info hashes if any allocation above fails. */
3800 stash->info_hash_status = STASH_INFO_HASH_DISABLED;
3803 /* We need a forced update so that the info hash tables will
3804 be created even though there is no compilation unit. That
3805 happens if STASH_INFO_HASH_TRIGGER is 0. */
3806 stash_maybe_update_info_hash_tables (stash);
3807 stash->info_hash_status = STASH_INFO_HASH_ON;
3810 /* Find the file and line associated with a symbol and address using the
3811 info hash tables of a stash. If there is a match, the function returns
3812 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
3813 otherwise it returns FALSE. */
3816 stash_find_line_fast (struct dwarf2_debug *stash,
3819 const char **filename_ptr,
3820 unsigned int *linenumber_ptr)
3822 BFD_ASSERT (stash->info_hash_status == STASH_INFO_HASH_ON);
3824 if (sym->flags & BSF_FUNCTION)
3825 return info_hash_lookup_funcinfo (stash->funcinfo_hash_table, sym, addr,
3826 filename_ptr, linenumber_ptr);
3827 return info_hash_lookup_varinfo (stash->varinfo_hash_table, sym, addr,
3828 filename_ptr, linenumber_ptr);
3831 /* Save current section VMAs. */
3834 save_section_vma (const bfd *abfd, struct dwarf2_debug *stash)
3839 if (abfd->section_count == 0)
3841 stash->sec_vma = bfd_malloc (sizeof (*stash->sec_vma) * abfd->section_count);
3842 if (stash->sec_vma == NULL)
3844 for (i = 0, s = abfd->sections; i < abfd->section_count; i++, s = s->next)
3846 if (s->output_section != NULL)
3847 stash->sec_vma[i] = s->output_section->vma + s->output_offset;
3849 stash->sec_vma[i] = s->vma;
3854 /* Compare current section VMAs against those at the time the stash
3855 was created. If find_nearest_line is used in linker warnings or
3856 errors early in the link process, the debug info stash will be
3857 invalid for later calls. This is because we relocate debug info
3858 sections, so the stashed section contents depend on symbol values,
3859 which in turn depend on section VMAs. */
3862 section_vma_same (const bfd *abfd, const struct dwarf2_debug *stash)
3867 for (i = 0, s = abfd->sections; i < abfd->section_count; i++, s = s->next)
3871 if (s->output_section != NULL)
3872 vma = s->output_section->vma + s->output_offset;
3875 if (vma != stash->sec_vma[i])
3881 /* Read debug information from DEBUG_BFD when DEBUG_BFD is specified.
3882 If DEBUG_BFD is not specified, we read debug information from ABFD
3883 or its gnu_debuglink. The results will be stored in PINFO.
3884 The function returns TRUE iff debug information is ready. */
3887 _bfd_dwarf2_slurp_debug_info (bfd *abfd, bfd *debug_bfd,
3888 const struct dwarf_debug_section *debug_sections,
3891 bfd_boolean do_place)
3893 bfd_size_type amt = sizeof (struct dwarf2_debug);
3894 bfd_size_type total_size;
3896 struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
3900 if (section_vma_same (abfd, stash))
3902 _bfd_dwarf2_cleanup_debug_info (abfd, pinfo);
3903 memset (stash, 0, amt);
3907 stash = (struct dwarf2_debug *) bfd_zalloc (abfd, amt);
3911 stash->debug_sections = debug_sections;
3912 stash->syms = symbols;
3913 if (!save_section_vma (abfd, stash))
3918 if (debug_bfd == NULL)
3921 msec = find_debug_info (debug_bfd, debug_sections, NULL);
3922 if (msec == NULL && abfd == debug_bfd)
3924 char * debug_filename = bfd_follow_gnu_debuglink (abfd, DEBUGDIR);
3926 if (debug_filename == NULL)
3927 /* No dwarf2 info, and no gnu_debuglink to follow.
3928 Note that at this point the stash has been allocated, but
3929 contains zeros. This lets future calls to this function
3930 fail more quickly. */
3933 /* Set BFD_DECOMPRESS to decompress debug sections. */
3934 if ((debug_bfd = bfd_openr (debug_filename, NULL)) == NULL
3935 || !(debug_bfd->flags |= BFD_DECOMPRESS,
3936 bfd_check_format (debug_bfd, bfd_object))
3937 || (msec = find_debug_info (debug_bfd,
3938 debug_sections, NULL)) == NULL
3939 || !bfd_generic_link_read_symbols (debug_bfd))
3942 bfd_close (debug_bfd);
3943 /* FIXME: Should we report our failure to follow the debuglink ? */
3944 free (debug_filename);
3948 symbols = bfd_get_outsymbols (debug_bfd);
3949 stash->syms = symbols;
3950 stash->close_on_cleanup = TRUE;
3952 stash->bfd_ptr = debug_bfd;
3955 && !place_sections (abfd, stash))
3958 /* There can be more than one DWARF2 info section in a BFD these
3959 days. First handle the easy case when there's only one. If
3960 there's more than one, try case two: none of the sections is
3961 compressed. In that case, read them all in and produce one
3962 large stash. We do this in two passes - in the first pass we
3963 just accumulate the section sizes, and in the second pass we
3964 read in the section's contents. (The allows us to avoid
3965 reallocing the data as we add sections to the stash.) If
3966 some or all sections are compressed, then do things the slow
3967 way, with a bunch of reallocs. */
3969 if (! find_debug_info (debug_bfd, debug_sections, msec))
3971 /* Case 1: only one info section. */
3972 total_size = msec->size;
3973 if (! read_section (debug_bfd, &stash->debug_sections[debug_info],
3975 &stash->info_ptr_memory, &total_size))
3980 /* Case 2: multiple sections. */
3981 for (total_size = 0;
3983 msec = find_debug_info (debug_bfd, debug_sections, msec))
3984 total_size += msec->size;
3986 stash->info_ptr_memory = (bfd_byte *) bfd_malloc (total_size);
3987 if (stash->info_ptr_memory == NULL)
3991 for (msec = find_debug_info (debug_bfd, debug_sections, NULL);
3993 msec = find_debug_info (debug_bfd, debug_sections, msec))
4001 if (!(bfd_simple_get_relocated_section_contents
4002 (debug_bfd, msec, stash->info_ptr_memory + total_size,
4010 stash->info_ptr = stash->info_ptr_memory;
4011 stash->info_ptr_end = stash->info_ptr + total_size;
4012 stash->sec = find_debug_info (debug_bfd, debug_sections, NULL);
4013 stash->sec_info_ptr = stash->info_ptr;
4017 /* Scan the debug information in PINFO looking for a DW_TAG_subprogram
4018 abbrev with a DW_AT_low_pc attached to it. Then lookup that same
4019 symbol in SYMBOLS and return the difference between the low_pc and
4020 the symbol's address. Returns 0 if no suitable symbol could be found. */
4023 _bfd_dwarf2_find_symbol_bias (asymbol ** symbols, void ** pinfo)
4025 struct dwarf2_debug *stash;
4026 struct comp_unit * unit;
4028 stash = (struct dwarf2_debug *) *pinfo;
4033 for (unit = stash->all_comp_units; unit; unit = unit->next_unit)
4035 struct funcinfo * func;
4037 if (unit->function_table == NULL)
4039 if (unit->line_table == NULL)
4040 unit->line_table = decode_line_info (unit, stash);
4041 if (unit->line_table != NULL)
4042 scan_unit_for_symbols (unit);
4045 for (func = unit->function_table; func != NULL; func = func->prev_func)
4046 if (func->name && func->arange.low)
4050 /* FIXME: Do we need to scan the aranges looking for the lowest pc value ? */
4052 for (psym = symbols; * psym != NULL; psym++)
4054 asymbol * sym = * psym;
4056 if (sym->flags & BSF_FUNCTION
4057 && sym->section != NULL
4058 && strcmp (sym->name, func->name) == 0)
4059 return ((bfd_signed_vma) func->arange.low) -
4060 ((bfd_signed_vma) (sym->value + sym->section->vma));
4068 /* Find the source code location of SYMBOL. If SYMBOL is NULL
4069 then find the nearest source code location corresponding to
4070 the address SECTION + OFFSET.
4071 Returns TRUE if the line is found without error and fills in
4072 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
4073 NULL the FUNCTIONNAME_PTR is also filled in.
4074 SYMBOLS contains the symbol table for ABFD.
4075 DEBUG_SECTIONS contains the name of the dwarf debug sections.
4076 ADDR_SIZE is the number of bytes in the initial .debug_info length
4077 field and in the abbreviation offset, or zero to indicate that the
4078 default value should be used. */
4081 _bfd_dwarf2_find_nearest_line (bfd *abfd,
4086 const char **filename_ptr,
4087 const char **functionname_ptr,
4088 unsigned int *linenumber_ptr,
4089 unsigned int *discriminator_ptr,
4090 const struct dwarf_debug_section *debug_sections,
4091 unsigned int addr_size,
4094 /* Read each compilation unit from the section .debug_info, and check
4095 to see if it contains the address we are searching for. If yes,
4096 lookup the address, and return the line number info. If no, go
4097 on to the next compilation unit.
4099 We keep a list of all the previously read compilation units, and
4100 a pointer to the next un-read compilation unit. Check the
4101 previously read units before reading more. */
4102 struct dwarf2_debug *stash;
4103 /* What address are we looking for? */
4105 struct comp_unit* each;
4106 struct funcinfo *function = NULL;
4107 bfd_boolean found = FALSE;
4108 bfd_boolean do_line;
4110 *filename_ptr = NULL;
4111 if (functionname_ptr != NULL)
4112 *functionname_ptr = NULL;
4113 *linenumber_ptr = 0;
4114 if (discriminator_ptr)
4115 *discriminator_ptr = 0;
4117 if (! _bfd_dwarf2_slurp_debug_info (abfd, NULL, debug_sections,
4119 (abfd->flags & (EXEC_P | DYNAMIC)) == 0))
4122 stash = (struct dwarf2_debug *) *pinfo;
4124 do_line = symbol != NULL;
4127 BFD_ASSERT (section == NULL && offset == 0 && functionname_ptr == NULL);
4128 section = bfd_get_section (symbol);
4129 addr = symbol->value;
4133 BFD_ASSERT (section != NULL && functionname_ptr != NULL);
4137 if (section->output_section)
4138 addr += section->output_section->vma + section->output_offset;
4140 addr += section->vma;
4142 /* A null info_ptr indicates that there is no dwarf2 info
4143 (or that an error occured while setting up the stash). */
4144 if (! stash->info_ptr)
4147 stash->inliner_chain = NULL;
4149 /* Check the previously read comp. units first. */
4152 /* The info hash tables use quite a bit of memory. We may not want to
4153 always use them. We use some heuristics to decide if and when to
4155 if (stash->info_hash_status == STASH_INFO_HASH_OFF)
4156 stash_maybe_enable_info_hash_tables (abfd, stash);
4158 /* Keep info hash table up to date if they are available. Note that we
4159 may disable the hash tables if there is any error duing update. */
4160 if (stash->info_hash_status == STASH_INFO_HASH_ON)
4161 stash_maybe_update_info_hash_tables (stash);
4163 if (stash->info_hash_status == STASH_INFO_HASH_ON)
4165 found = stash_find_line_fast (stash, symbol, addr, filename_ptr,
4172 /* Check the previously read comp. units first. */
4173 for (each = stash->all_comp_units; each; each = each->next_unit)
4174 if ((symbol->flags & BSF_FUNCTION) == 0
4175 || each->arange.high == 0
4176 || comp_unit_contains_address (each, addr))
4178 found = comp_unit_find_line (each, symbol, addr, filename_ptr,
4179 linenumber_ptr, stash);
4187 bfd_vma min_range = (bfd_vma) -1;
4188 const char * local_filename = NULL;
4189 struct funcinfo *local_function = NULL;
4190 unsigned int local_linenumber = 0;
4191 unsigned int local_discriminator = 0;
4193 for (each = stash->all_comp_units; each; each = each->next_unit)
4195 bfd_vma range = (bfd_vma) -1;
4197 found = ((each->arange.high == 0
4198 || comp_unit_contains_address (each, addr))
4199 && (range = comp_unit_find_nearest_line (each, addr,
4203 & local_discriminator,
4207 /* PRs 15935 15994: Bogus debug information may have provided us
4208 with an erroneous match. We attempt to counter this by
4209 selecting the match that has the smallest address range
4210 associated with it. (We are assuming that corrupt debug info
4211 will tend to result in extra large address ranges rather than
4212 extra small ranges).
4214 This does mean that we scan through all of the CUs associated
4215 with the bfd each time this function is called. But this does
4216 have the benefit of producing consistent results every time the
4217 function is called. */
4218 if (range <= min_range)
4220 if (filename_ptr && local_filename)
4221 * filename_ptr = local_filename;
4223 function = local_function;
4224 if (discriminator_ptr && local_discriminator)
4225 * discriminator_ptr = local_discriminator;
4226 if (local_linenumber)
4227 * linenumber_ptr = local_linenumber;
4233 if (* linenumber_ptr)
4240 /* The DWARF2 spec says that the initial length field, and the
4241 offset of the abbreviation table, should both be 4-byte values.
4242 However, some compilers do things differently. */
4245 BFD_ASSERT (addr_size == 4 || addr_size == 8);
4247 /* Read each remaining comp. units checking each as they are read. */
4248 while (stash->info_ptr < stash->info_ptr_end)
4251 unsigned int offset_size = addr_size;
4252 bfd_byte *info_ptr_unit = stash->info_ptr;
4254 length = read_4_bytes (stash->bfd_ptr, stash->info_ptr, stash->info_ptr_end);
4255 /* A 0xffffff length is the DWARF3 way of indicating
4256 we use 64-bit offsets, instead of 32-bit offsets. */
4257 if (length == 0xffffffff)
4260 length = read_8_bytes (stash->bfd_ptr, stash->info_ptr + 4, stash->info_ptr_end);
4261 stash->info_ptr += 12;
4263 /* A zero length is the IRIX way of indicating 64-bit offsets,
4264 mostly because the 64-bit length will generally fit in 32
4265 bits, and the endianness helps. */
4266 else if (length == 0)
4269 length = read_4_bytes (stash->bfd_ptr, stash->info_ptr + 4, stash->info_ptr_end);
4270 stash->info_ptr += 8;
4272 /* In the absence of the hints above, we assume 32-bit DWARF2
4273 offsets even for targets with 64-bit addresses, because:
4274 a) most of the time these targets will not have generated
4275 more than 2Gb of debug info and so will not need 64-bit
4278 b) if they do use 64-bit offsets but they are not using
4279 the size hints that are tested for above then they are
4280 not conforming to the DWARF3 standard anyway. */
4281 else if (addr_size == 8)
4284 stash->info_ptr += 4;
4287 stash->info_ptr += 4;
4293 each = parse_comp_unit (stash, length, info_ptr_unit,
4296 /* The dwarf information is damaged, don't trust it any
4300 new_ptr = stash->info_ptr + length;
4301 /* PR 17512: file: 1500698c. */
4302 if (new_ptr < stash->info_ptr)
4304 /* A corrupt length value - do not trust the info any more. */
4309 stash->info_ptr = new_ptr;
4311 if (stash->all_comp_units)
4312 stash->all_comp_units->prev_unit = each;
4314 stash->last_comp_unit = each;
4316 each->next_unit = stash->all_comp_units;
4317 stash->all_comp_units = each;
4319 /* DW_AT_low_pc and DW_AT_high_pc are optional for
4320 compilation units. If we don't have them (i.e.,
4321 unit->high == 0), we need to consult the line info table
4322 to see if a compilation unit contains the given
4325 found = (((symbol->flags & BSF_FUNCTION) == 0
4326 || each->arange.high == 0
4327 || comp_unit_contains_address (each, addr))
4328 && comp_unit_find_line (each, symbol, addr,
4333 found = ((each->arange.high == 0
4334 || comp_unit_contains_address (each, addr))
4335 && comp_unit_find_nearest_line (each, addr,
4342 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
4343 == stash->sec->size)
4345 stash->sec = find_debug_info (stash->bfd_ptr, debug_sections,
4347 stash->sec_info_ptr = stash->info_ptr;
4358 if (!function->is_linkage)
4363 fun = _bfd_elf_find_function (abfd, symbols, section, offset,
4364 *filename_ptr ? NULL : filename_ptr,
4366 sec_vma = section->vma;
4367 if (section->output_section != NULL)
4368 sec_vma = section->output_section->vma + section->output_offset;
4370 && fun->value + sec_vma == function->arange.low)
4371 function->name = *functionname_ptr;
4372 /* Even if we didn't find a linkage name, say that we have
4373 to stop a repeated search of symbols. */
4374 function->is_linkage = TRUE;
4376 *functionname_ptr = function->name;
4378 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
4379 unset_sections (stash);
4385 _bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED,
4386 const char **filename_ptr,
4387 const char **functionname_ptr,
4388 unsigned int *linenumber_ptr,
4391 struct dwarf2_debug *stash;
4393 stash = (struct dwarf2_debug *) *pinfo;
4396 struct funcinfo *func = stash->inliner_chain;
4398 if (func && func->caller_func)
4400 *filename_ptr = func->caller_file;
4401 *functionname_ptr = func->caller_func->name;
4402 *linenumber_ptr = func->caller_line;
4403 stash->inliner_chain = func->caller_func;
4412 _bfd_dwarf2_cleanup_debug_info (bfd *abfd, void **pinfo)
4414 struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
4415 struct comp_unit *each;
4417 if (abfd == NULL || stash == NULL)
4420 for (each = stash->all_comp_units; each; each = each->next_unit)
4422 struct abbrev_info **abbrevs = each->abbrevs;
4423 struct funcinfo *function_table = each->function_table;
4424 struct varinfo *variable_table = each->variable_table;
4427 for (i = 0; i < ABBREV_HASH_SIZE; i++)
4429 struct abbrev_info *abbrev = abbrevs[i];
4433 free (abbrev->attrs);
4434 abbrev = abbrev->next;
4438 if (each->line_table)
4440 free (each->line_table->dirs);
4441 free (each->line_table->files);
4444 while (function_table)
4446 if (function_table->file)
4448 free (function_table->file);
4449 function_table->file = NULL;
4452 if (function_table->caller_file)
4454 free (function_table->caller_file);
4455 function_table->caller_file = NULL;
4457 function_table = function_table->prev_func;
4460 if (each->lookup_funcinfo_table)
4462 free (each->lookup_funcinfo_table);
4463 each->lookup_funcinfo_table = NULL;
4466 while (variable_table)
4468 if (variable_table->file)
4470 free (variable_table->file);
4471 variable_table->file = NULL;
4474 variable_table = variable_table->prev_var;
4478 if (stash->dwarf_abbrev_buffer)
4479 free (stash->dwarf_abbrev_buffer);
4480 if (stash->dwarf_line_buffer)
4481 free (stash->dwarf_line_buffer);
4482 if (stash->dwarf_str_buffer)
4483 free (stash->dwarf_str_buffer);
4484 if (stash->dwarf_ranges_buffer)
4485 free (stash->dwarf_ranges_buffer);
4486 if (stash->info_ptr_memory)
4487 free (stash->info_ptr_memory);
4488 if (stash->close_on_cleanup)
4489 bfd_close (stash->bfd_ptr);
4490 if (stash->alt_dwarf_str_buffer)
4491 free (stash->alt_dwarf_str_buffer);
4492 if (stash->alt_dwarf_info_buffer)
4493 free (stash->alt_dwarf_info_buffer);
4495 free (stash->sec_vma);
4496 if (stash->adjusted_sections)
4497 free (stash->adjusted_sections);
4498 if (stash->alt_bfd_ptr)
4499 bfd_close (stash->alt_bfd_ptr);
4502 /* Find the function to a particular section and offset,
4503 for error reporting. */
4506 _bfd_elf_find_function (bfd *abfd,
4510 const char **filename_ptr,
4511 const char **functionname_ptr)
4513 struct elf_find_function_cache
4515 asection *last_section;
4517 const char *filename;
4518 bfd_size_type func_size;
4521 if (symbols == NULL)
4524 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
4527 cache = elf_tdata (abfd)->elf_find_function_cache;
4530 cache = bfd_zalloc (abfd, sizeof (*cache));
4531 elf_tdata (abfd)->elf_find_function_cache = cache;
4535 if (cache->last_section != section
4536 || cache->func == NULL
4537 || offset < cache->func->value
4538 || offset >= cache->func->value + cache->func_size)
4543 /* ??? Given multiple file symbols, it is impossible to reliably
4544 choose the right file name for global symbols. File symbols are
4545 local symbols, and thus all file symbols must sort before any
4546 global symbols. The ELF spec may be interpreted to say that a
4547 file symbol must sort before other local symbols, but currently
4548 ld -r doesn't do this. So, for ld -r output, it is possible to
4549 make a better choice of file name for local symbols by ignoring
4550 file symbols appearing after a given local symbol. */
4551 enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
4552 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4556 state = nothing_seen;
4557 cache->filename = NULL;
4559 cache->func_size = 0;
4560 cache->last_section = section;
4562 for (p = symbols; *p != NULL; p++)
4568 if ((sym->flags & BSF_FILE) != 0)
4571 if (state == symbol_seen)
4572 state = file_after_symbol_seen;
4576 size = bed->maybe_function_sym (sym, section, &code_off);
4578 && code_off <= offset
4579 && (code_off > low_func
4580 || (code_off == low_func
4581 && size > cache->func_size)))
4584 cache->func_size = size;
4585 cache->filename = NULL;
4586 low_func = code_off;
4588 && ((sym->flags & BSF_LOCAL) != 0
4589 || state != file_after_symbol_seen))
4590 cache->filename = bfd_asymbol_name (file);
4592 if (state == nothing_seen)
4593 state = symbol_seen;
4597 if (cache->func == NULL)
4601 *filename_ptr = cache->filename;
4602 if (functionname_ptr)
4603 *functionname_ptr = bfd_asymbol_name (cache->func);