2 Copyright (C) 1994-2019 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"
40 /* The data in the .debug_line statement prologue looks like this. */
45 unsigned short version
;
46 bfd_vma prologue_length
;
47 unsigned char minimum_instruction_length
;
48 unsigned char maximum_ops_per_insn
;
49 unsigned char default_is_stmt
;
51 unsigned char line_range
;
52 unsigned char opcode_base
;
53 unsigned char *standard_opcode_lengths
;
56 /* Attributes have a name and a value. */
60 enum dwarf_attribute name
;
65 struct dwarf_block
*blk
;
72 /* Blocks are a bunch of untyped bytes. */
79 struct adjusted_section
87 /* A list of all previously read comp_units. */
88 struct comp_unit
*all_comp_units
;
90 /* Last comp unit in list above. */
91 struct comp_unit
*last_comp_unit
;
93 /* Names of the debug sections. */
94 const struct dwarf_debug_section
*debug_sections
;
96 /* The next unread compilation unit within the .debug_info section.
97 Zero indicates that the .debug_info section has not been loaded
101 /* Pointer to the end of the .debug_info section memory buffer. */
102 bfd_byte
*info_ptr_end
;
104 /* Pointer to the original bfd for which debug was loaded. This is what
105 we use to compare and so check that the cached debug data is still
106 valid - it saves having to possibly dereference the gnu_debuglink each
110 /* Pointer to the bfd, section and address of the beginning of the
111 section. The bfd might be different than expected because of
112 gnu_debuglink sections. */
115 bfd_byte
*sec_info_ptr
;
117 /* Support for alternate debug info sections created by the DWZ utility:
118 This includes a pointer to an alternate bfd which contains *extra*,
119 possibly duplicate debug sections, and pointers to the loaded
120 .debug_str and .debug_info sections from this bfd. */
122 bfd_byte
* alt_dwarf_str_buffer
;
123 bfd_size_type alt_dwarf_str_size
;
124 bfd_byte
* alt_dwarf_info_buffer
;
125 bfd_size_type alt_dwarf_info_size
;
127 /* A pointer to the memory block allocated for info_ptr. Neither
128 info_ptr nor sec_info_ptr are guaranteed to stay pointing to the
129 beginning of the malloc block. */
130 bfd_byte
*info_ptr_memory
;
132 /* Pointer to the symbol table. */
135 /* Pointer to the .debug_abbrev section loaded into memory. */
136 bfd_byte
*dwarf_abbrev_buffer
;
138 /* Length of the loaded .debug_abbrev section. */
139 bfd_size_type dwarf_abbrev_size
;
141 /* Buffer for decode_line_info. */
142 bfd_byte
*dwarf_line_buffer
;
144 /* Length of the loaded .debug_line section. */
145 bfd_size_type dwarf_line_size
;
147 /* Pointer to the .debug_str section loaded into memory. */
148 bfd_byte
*dwarf_str_buffer
;
150 /* Length of the loaded .debug_str section. */
151 bfd_size_type dwarf_str_size
;
153 /* Pointer to the .debug_line_str section loaded into memory. */
154 bfd_byte
*dwarf_line_str_buffer
;
156 /* Length of the loaded .debug_line_str section. */
157 bfd_size_type dwarf_line_str_size
;
159 /* Pointer to the .debug_ranges section loaded into memory. */
160 bfd_byte
*dwarf_ranges_buffer
;
162 /* Length of the loaded .debug_ranges section. */
163 bfd_size_type dwarf_ranges_size
;
165 /* If the most recent call to bfd_find_nearest_line was given an
166 address in an inlined function, preserve a pointer into the
167 calling chain for subsequent calls to bfd_find_inliner_info to
169 struct funcinfo
*inliner_chain
;
171 /* Section VMAs at the time the stash was built. */
173 /* Number of sections in the SEC_VMA table. */
174 unsigned int sec_vma_count
;
176 /* Number of sections whose VMA we must adjust. */
177 int adjusted_section_count
;
179 /* Array of sections with adjusted VMA. */
180 struct adjusted_section
*adjusted_sections
;
182 /* Number of times find_line is called. This is used in
183 the heuristic for enabling the info hash tables. */
186 #define STASH_INFO_HASH_TRIGGER 100
188 /* Hash table mapping symbol names to function infos. */
189 struct info_hash_table
*funcinfo_hash_table
;
191 /* Hash table mapping symbol names to variable infos. */
192 struct info_hash_table
*varinfo_hash_table
;
194 /* Head of comp_unit list in the last hash table update. */
195 struct comp_unit
*hash_units_head
;
197 /* Status of info hash. */
198 int info_hash_status
;
199 #define STASH_INFO_HASH_OFF 0
200 #define STASH_INFO_HASH_ON 1
201 #define STASH_INFO_HASH_DISABLED 2
203 /* True if we opened bfd_ptr. */
204 bfd_boolean close_on_cleanup
;
214 /* A minimal decoding of DWARF2 compilation units. We only decode
215 what's needed to get to the line number information. */
219 /* Chain the previously read compilation units. */
220 struct comp_unit
*next_unit
;
222 /* Likewise, chain the compilation unit read after this one.
223 The comp units are stored in reversed reading order. */
224 struct comp_unit
*prev_unit
;
226 /* Keep the bfd convenient (for memory allocation). */
229 /* The lowest and highest addresses contained in this compilation
230 unit as specified in the compilation unit header. */
231 struct arange arange
;
233 /* The DW_AT_name attribute (for error messages). */
236 /* The abbrev hash table. */
237 struct abbrev_info
**abbrevs
;
239 /* DW_AT_language. */
242 /* Note that an error was found by comp_unit_find_nearest_line. */
245 /* The DW_AT_comp_dir attribute. */
248 /* TRUE if there is a line number table associated with this comp. unit. */
251 /* Pointer to the current comp_unit so that we can find a given entry
253 bfd_byte
*info_ptr_unit
;
255 /* The offset into .debug_line of the line number table. */
256 unsigned long line_offset
;
258 /* Pointer to the first child die for the comp unit. */
259 bfd_byte
*first_child_die_ptr
;
261 /* The end of the comp unit. */
264 /* The decoded line number, NULL if not yet decoded. */
265 struct line_info_table
*line_table
;
267 /* A list of the functions found in this comp. unit. */
268 struct funcinfo
*function_table
;
270 /* A table of function information references searchable by address. */
271 struct lookup_funcinfo
*lookup_funcinfo_table
;
273 /* Number of functions in the function_table and sorted_function_table. */
274 bfd_size_type number_of_functions
;
276 /* A list of the variables found in this comp. unit. */
277 struct varinfo
*variable_table
;
279 /* Pointer to dwarf2_debug structure. */
280 struct dwarf2_debug
*stash
;
282 /* DWARF format version for this unit - from unit header. */
285 /* Address size for this unit - from unit header. */
286 unsigned char addr_size
;
288 /* Offset size for this unit - from unit header. */
289 unsigned char offset_size
;
291 /* Base address for this unit - from DW_AT_low_pc attribute of
292 DW_TAG_compile_unit DIE */
293 bfd_vma base_address
;
295 /* TRUE if symbols are cached in hash table for faster lookup by name. */
299 /* This data structure holds the information of an abbrev. */
302 unsigned int number
; /* Number identifying abbrev. */
303 enum dwarf_tag tag
; /* DWARF tag. */
304 int has_children
; /* Boolean. */
305 unsigned int num_attrs
; /* Number of attributes. */
306 struct attr_abbrev
*attrs
; /* An array of attribute descriptions. */
307 struct abbrev_info
*next
; /* Next in chain. */
312 enum dwarf_attribute name
;
313 enum dwarf_form form
;
314 bfd_vma implicit_const
;
317 /* Map of uncompressed DWARF debug section name to compressed one. It
318 is terminated by NULL uncompressed_name. */
320 const struct dwarf_debug_section dwarf_debug_sections
[] =
322 { ".debug_abbrev", ".zdebug_abbrev" },
323 { ".debug_aranges", ".zdebug_aranges" },
324 { ".debug_frame", ".zdebug_frame" },
325 { ".debug_info", ".zdebug_info" },
326 { ".debug_info", ".zdebug_info" },
327 { ".debug_line", ".zdebug_line" },
328 { ".debug_loc", ".zdebug_loc" },
329 { ".debug_macinfo", ".zdebug_macinfo" },
330 { ".debug_macro", ".zdebug_macro" },
331 { ".debug_pubnames", ".zdebug_pubnames" },
332 { ".debug_pubtypes", ".zdebug_pubtypes" },
333 { ".debug_ranges", ".zdebug_ranges" },
334 { ".debug_static_func", ".zdebug_static_func" },
335 { ".debug_static_vars", ".zdebug_static_vars" },
336 { ".debug_str", ".zdebug_str", },
337 { ".debug_str", ".zdebug_str", },
338 { ".debug_line_str", ".zdebug_line_str", },
339 { ".debug_types", ".zdebug_types" },
340 /* GNU DWARF 1 extensions */
341 { ".debug_sfnames", ".zdebug_sfnames" },
342 { ".debug_srcinfo", ".zebug_srcinfo" },
343 /* SGI/MIPS DWARF 2 extensions */
344 { ".debug_funcnames", ".zdebug_funcnames" },
345 { ".debug_typenames", ".zdebug_typenames" },
346 { ".debug_varnames", ".zdebug_varnames" },
347 { ".debug_weaknames", ".zdebug_weaknames" },
351 /* NB/ Numbers in this enum must match up with indices
352 into the dwarf_debug_sections[] array above. */
353 enum dwarf_debug_section_enum
382 /* A static assertion. */
383 extern int dwarf_debug_section_assert
[ARRAY_SIZE (dwarf_debug_sections
)
384 == debug_max
+ 1 ? 1 : -1];
386 #ifndef ABBREV_HASH_SIZE
387 #define ABBREV_HASH_SIZE 121
389 #ifndef ATTR_ALLOC_CHUNK
390 #define ATTR_ALLOC_CHUNK 4
393 /* Variable and function hash tables. This is used to speed up look-up
394 in lookup_symbol_in_var_table() and lookup_symbol_in_function_table().
395 In order to share code between variable and function infos, we use
396 a list of untyped pointer for all variable/function info associated with
397 a symbol. We waste a bit of memory for list with one node but that
398 simplifies the code. */
400 struct info_list_node
402 struct info_list_node
*next
;
406 /* Info hash entry. */
407 struct info_hash_entry
409 struct bfd_hash_entry root
;
410 struct info_list_node
*head
;
413 struct info_hash_table
415 struct bfd_hash_table base
;
418 /* Function to create a new entry in info hash table. */
420 static struct bfd_hash_entry
*
421 info_hash_table_newfunc (struct bfd_hash_entry
*entry
,
422 struct bfd_hash_table
*table
,
425 struct info_hash_entry
*ret
= (struct info_hash_entry
*) entry
;
427 /* Allocate the structure if it has not already been allocated by a
431 ret
= (struct info_hash_entry
*) bfd_hash_allocate (table
,
437 /* Call the allocation method of the base class. */
438 ret
= ((struct info_hash_entry
*)
439 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
441 /* Initialize the local fields here. */
445 return (struct bfd_hash_entry
*) ret
;
448 /* Function to create a new info hash table. It returns a pointer to the
449 newly created table or NULL if there is any error. We need abfd
450 solely for memory allocation. */
452 static struct info_hash_table
*
453 create_info_hash_table (bfd
*abfd
)
455 struct info_hash_table
*hash_table
;
457 hash_table
= ((struct info_hash_table
*)
458 bfd_alloc (abfd
, sizeof (struct info_hash_table
)));
462 if (!bfd_hash_table_init (&hash_table
->base
, info_hash_table_newfunc
,
463 sizeof (struct info_hash_entry
)))
465 bfd_release (abfd
, hash_table
);
472 /* Insert an info entry into an info hash table. We do not check of
473 duplicate entries. Also, the caller need to guarantee that the
474 right type of info in inserted as info is passed as a void* pointer.
475 This function returns true if there is no error. */
478 insert_info_hash_table (struct info_hash_table
*hash_table
,
483 struct info_hash_entry
*entry
;
484 struct info_list_node
*node
;
486 entry
= (struct info_hash_entry
*) bfd_hash_lookup (&hash_table
->base
,
491 node
= (struct info_list_node
*) bfd_hash_allocate (&hash_table
->base
,
497 node
->next
= entry
->head
;
503 /* Look up an info entry list from an info hash table. Return NULL
506 static struct info_list_node
*
507 lookup_info_hash_table (struct info_hash_table
*hash_table
, const char *key
)
509 struct info_hash_entry
*entry
;
511 entry
= (struct info_hash_entry
*) bfd_hash_lookup (&hash_table
->base
, key
,
513 return entry
? entry
->head
: NULL
;
516 /* Read a section into its appropriate place in the dwarf2_debug
517 struct (indicated by SECTION_BUFFER and SECTION_SIZE). If SYMS is
518 not NULL, use bfd_simple_get_relocated_section_contents to read the
519 section contents, otherwise use bfd_get_section_contents. Fail if
520 the located section does not contain at least OFFSET bytes. */
523 read_section (bfd
* abfd
,
524 const struct dwarf_debug_section
*sec
,
527 bfd_byte
** section_buffer
,
528 bfd_size_type
* section_size
)
531 const char *section_name
= sec
->uncompressed_name
;
532 bfd_byte
*contents
= *section_buffer
;
535 /* The section may have already been read. */
536 if (contents
== NULL
)
538 msec
= bfd_get_section_by_name (abfd
, section_name
);
541 section_name
= sec
->compressed_name
;
542 if (section_name
!= NULL
)
543 msec
= bfd_get_section_by_name (abfd
, section_name
);
547 _bfd_error_handler (_("DWARF error: can't find %s section."),
548 sec
->uncompressed_name
);
549 bfd_set_error (bfd_error_bad_value
);
553 *section_size
= msec
->rawsize
? msec
->rawsize
: msec
->size
;
554 /* Paranoia - alloc one extra so that we can make sure a string
555 section is NUL terminated. */
556 amt
= *section_size
+ 1;
559 bfd_set_error (bfd_error_no_memory
);
562 contents
= (bfd_byte
*) bfd_malloc (amt
);
563 if (contents
== NULL
)
566 ? !bfd_simple_get_relocated_section_contents (abfd
, msec
, contents
,
568 : !bfd_get_section_contents (abfd
, msec
, contents
, 0, *section_size
))
573 contents
[*section_size
] = 0;
574 *section_buffer
= contents
;
577 /* It is possible to get a bad value for the offset into the section
578 that the client wants. Validate it here to avoid trouble later. */
579 if (offset
!= 0 && offset
>= *section_size
)
581 /* xgettext: c-format */
582 _bfd_error_handler (_("DWARF error: offset (%" PRIu64
")"
583 " greater than or equal to %s size (%" PRIu64
")"),
584 (uint64_t) offset
, section_name
,
585 (uint64_t) *section_size
);
586 bfd_set_error (bfd_error_bad_value
);
593 /* Read dwarf information from a buffer. */
596 read_1_byte (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_byte
*buf
, bfd_byte
*end
)
600 return bfd_get_8 (abfd
, buf
);
604 read_1_signed_byte (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_byte
*buf
, bfd_byte
*end
)
608 return bfd_get_signed_8 (abfd
, buf
);
612 read_2_bytes (bfd
*abfd
, bfd_byte
*buf
, bfd_byte
*end
)
616 return bfd_get_16 (abfd
, buf
);
620 read_4_bytes (bfd
*abfd
, bfd_byte
*buf
, bfd_byte
*end
)
624 return bfd_get_32 (abfd
, buf
);
628 read_8_bytes (bfd
*abfd
, bfd_byte
*buf
, bfd_byte
*end
)
632 return bfd_get_64 (abfd
, buf
);
636 read_n_bytes (bfd_byte
* buf
,
638 struct dwarf_block
* block
)
640 unsigned int size
= block
->size
;
641 bfd_byte
* block_end
= buf
+ size
;
643 if (block_end
> end
|| block_end
< buf
)
656 /* Scans a NUL terminated string starting at BUF, returning a pointer to it.
657 Returns the number of characters in the string, *including* the NUL byte,
658 in BYTES_READ_PTR. This value is set even if the function fails. Bytes
659 at or beyond BUF_END will not be read. Returns NULL if there was a
660 problem, or if the string is empty. */
663 read_string (bfd
* abfd ATTRIBUTE_UNUSED
,
666 unsigned int * bytes_read_ptr
)
672 * bytes_read_ptr
= 0;
678 * bytes_read_ptr
= 1;
682 while (buf
< buf_end
)
685 * bytes_read_ptr
= buf
- str
;
689 * bytes_read_ptr
= buf
- str
;
693 /* Reads an offset from BUF and then locates the string at this offset
694 inside the debug string section. Returns a pointer to the string.
695 Returns the number of bytes read from BUF, *not* the length of the string,
696 in BYTES_READ_PTR. This value is set even if the function fails. Bytes
697 at or beyond BUF_END will not be read from BUF. Returns NULL if there was
698 a problem, or if the string is empty. Does not check for NUL termination
702 read_indirect_string (struct comp_unit
* unit
,
705 unsigned int * bytes_read_ptr
)
708 struct dwarf2_debug
*stash
= unit
->stash
;
711 if (buf
+ unit
->offset_size
> buf_end
)
713 * bytes_read_ptr
= 0;
717 if (unit
->offset_size
== 4)
718 offset
= read_4_bytes (unit
->abfd
, buf
, buf_end
);
720 offset
= read_8_bytes (unit
->abfd
, buf
, buf_end
);
722 *bytes_read_ptr
= unit
->offset_size
;
724 if (! read_section (unit
->abfd
, &stash
->debug_sections
[debug_str
],
726 &stash
->dwarf_str_buffer
, &stash
->dwarf_str_size
))
729 if (offset
>= stash
->dwarf_str_size
)
731 str
= (char *) stash
->dwarf_str_buffer
+ offset
;
737 /* Like read_indirect_string but from .debug_line_str section. */
740 read_indirect_line_string (struct comp_unit
* unit
,
743 unsigned int * bytes_read_ptr
)
746 struct dwarf2_debug
*stash
= unit
->stash
;
749 if (buf
+ unit
->offset_size
> buf_end
)
751 * bytes_read_ptr
= 0;
755 if (unit
->offset_size
== 4)
756 offset
= read_4_bytes (unit
->abfd
, buf
, buf_end
);
758 offset
= read_8_bytes (unit
->abfd
, buf
, buf_end
);
760 *bytes_read_ptr
= unit
->offset_size
;
762 if (! read_section (unit
->abfd
, &stash
->debug_sections
[debug_line_str
],
764 &stash
->dwarf_line_str_buffer
,
765 &stash
->dwarf_line_str_size
))
768 if (offset
>= stash
->dwarf_line_str_size
)
770 str
= (char *) stash
->dwarf_line_str_buffer
+ offset
;
776 /* Like read_indirect_string but uses a .debug_str located in
777 an alternate file pointed to by the .gnu_debugaltlink section.
778 Used to impement DW_FORM_GNU_strp_alt. */
781 read_alt_indirect_string (struct comp_unit
* unit
,
784 unsigned int * bytes_read_ptr
)
787 struct dwarf2_debug
*stash
= unit
->stash
;
790 if (buf
+ unit
->offset_size
> buf_end
)
792 * bytes_read_ptr
= 0;
796 if (unit
->offset_size
== 4)
797 offset
= read_4_bytes (unit
->abfd
, buf
, buf_end
);
799 offset
= read_8_bytes (unit
->abfd
, buf
, buf_end
);
801 *bytes_read_ptr
= unit
->offset_size
;
803 if (stash
->alt_bfd_ptr
== NULL
)
806 char *debug_filename
= bfd_follow_gnu_debugaltlink (unit
->abfd
, DEBUGDIR
);
808 if (debug_filename
== NULL
)
811 debug_bfd
= bfd_openr (debug_filename
, NULL
);
812 free (debug_filename
);
813 if (debug_bfd
== NULL
)
814 /* FIXME: Should we report our failure to follow the debuglink ? */
817 if (!bfd_check_format (debug_bfd
, bfd_object
))
819 bfd_close (debug_bfd
);
822 stash
->alt_bfd_ptr
= debug_bfd
;
825 if (! read_section (unit
->stash
->alt_bfd_ptr
,
826 stash
->debug_sections
+ debug_str_alt
,
827 NULL
, /* FIXME: Do we need to load alternate symbols ? */
829 &stash
->alt_dwarf_str_buffer
,
830 &stash
->alt_dwarf_str_size
))
833 if (offset
>= stash
->alt_dwarf_str_size
)
835 str
= (char *) stash
->alt_dwarf_str_buffer
+ offset
;
842 /* Resolve an alternate reference from UNIT at OFFSET.
843 Returns a pointer into the loaded alternate CU upon success
844 or NULL upon failure. */
847 read_alt_indirect_ref (struct comp_unit
* unit
,
850 struct dwarf2_debug
*stash
= unit
->stash
;
852 if (stash
->alt_bfd_ptr
== NULL
)
855 char *debug_filename
= bfd_follow_gnu_debugaltlink (unit
->abfd
, DEBUGDIR
);
857 if (debug_filename
== NULL
)
860 debug_bfd
= bfd_openr (debug_filename
, NULL
);
861 free (debug_filename
);
862 if (debug_bfd
== NULL
)
863 /* FIXME: Should we report our failure to follow the debuglink ? */
866 if (!bfd_check_format (debug_bfd
, bfd_object
))
868 bfd_close (debug_bfd
);
871 stash
->alt_bfd_ptr
= debug_bfd
;
874 if (! read_section (unit
->stash
->alt_bfd_ptr
,
875 stash
->debug_sections
+ debug_info_alt
,
876 NULL
, /* FIXME: Do we need to load alternate symbols ? */
878 &stash
->alt_dwarf_info_buffer
,
879 &stash
->alt_dwarf_info_size
))
882 if (offset
>= stash
->alt_dwarf_info_size
)
884 return stash
->alt_dwarf_info_buffer
+ offset
;
888 read_address (struct comp_unit
*unit
, bfd_byte
*buf
, bfd_byte
* buf_end
)
892 if (bfd_get_flavour (unit
->abfd
) == bfd_target_elf_flavour
)
893 signed_vma
= get_elf_backend_data (unit
->abfd
)->sign_extend_vma
;
895 if (buf
+ unit
->addr_size
> buf_end
)
900 switch (unit
->addr_size
)
903 return bfd_get_signed_64 (unit
->abfd
, buf
);
905 return bfd_get_signed_32 (unit
->abfd
, buf
);
907 return bfd_get_signed_16 (unit
->abfd
, buf
);
914 switch (unit
->addr_size
)
917 return bfd_get_64 (unit
->abfd
, buf
);
919 return bfd_get_32 (unit
->abfd
, buf
);
921 return bfd_get_16 (unit
->abfd
, buf
);
928 /* Lookup an abbrev_info structure in the abbrev hash table. */
930 static struct abbrev_info
*
931 lookup_abbrev (unsigned int number
, struct abbrev_info
**abbrevs
)
933 unsigned int hash_number
;
934 struct abbrev_info
*abbrev
;
936 hash_number
= number
% ABBREV_HASH_SIZE
;
937 abbrev
= abbrevs
[hash_number
];
941 if (abbrev
->number
== number
)
944 abbrev
= abbrev
->next
;
950 /* In DWARF version 2, the description of the debugging information is
951 stored in a separate .debug_abbrev section. Before we read any
952 dies from a section we read in all abbreviations and install them
955 static struct abbrev_info
**
956 read_abbrevs (bfd
*abfd
, bfd_uint64_t offset
, struct dwarf2_debug
*stash
)
958 struct abbrev_info
**abbrevs
;
959 bfd_byte
*abbrev_ptr
;
960 bfd_byte
*abbrev_end
;
961 struct abbrev_info
*cur_abbrev
;
962 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
963 unsigned int abbrev_form
, hash_number
;
966 if (! read_section (abfd
, &stash
->debug_sections
[debug_abbrev
],
968 &stash
->dwarf_abbrev_buffer
, &stash
->dwarf_abbrev_size
))
971 if (offset
>= stash
->dwarf_abbrev_size
)
974 amt
= sizeof (struct abbrev_info
*) * ABBREV_HASH_SIZE
;
975 abbrevs
= (struct abbrev_info
**) bfd_zalloc (abfd
, amt
);
979 abbrev_ptr
= stash
->dwarf_abbrev_buffer
+ offset
;
980 abbrev_end
= stash
->dwarf_abbrev_buffer
+ stash
->dwarf_abbrev_size
;
981 abbrev_number
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
, &bytes_read
,
983 abbrev_ptr
+= bytes_read
;
985 /* Loop until we reach an abbrev number of 0. */
986 while (abbrev_number
)
988 amt
= sizeof (struct abbrev_info
);
989 cur_abbrev
= (struct abbrev_info
*) bfd_zalloc (abfd
, amt
);
990 if (cur_abbrev
== NULL
)
993 /* Read in abbrev header. */
994 cur_abbrev
->number
= abbrev_number
;
995 cur_abbrev
->tag
= (enum dwarf_tag
)
996 _bfd_safe_read_leb128 (abfd
, abbrev_ptr
, &bytes_read
,
998 abbrev_ptr
+= bytes_read
;
999 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
, abbrev_end
);
1002 /* Now read in declarations. */
1005 /* Initialize it just to avoid a GCC false warning. */
1006 bfd_vma implicit_const
= -1;
1008 abbrev_name
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
, &bytes_read
,
1010 abbrev_ptr
+= bytes_read
;
1011 abbrev_form
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
, &bytes_read
,
1013 abbrev_ptr
+= bytes_read
;
1014 if (abbrev_form
== DW_FORM_implicit_const
)
1016 implicit_const
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
,
1019 abbrev_ptr
+= bytes_read
;
1022 if (abbrev_name
== 0)
1025 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
1027 struct attr_abbrev
*tmp
;
1029 amt
= cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
;
1030 amt
*= sizeof (struct attr_abbrev
);
1031 tmp
= (struct attr_abbrev
*) bfd_realloc (cur_abbrev
->attrs
, amt
);
1036 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
1038 struct abbrev_info
*abbrev
= abbrevs
[i
];
1042 free (abbrev
->attrs
);
1043 abbrev
= abbrev
->next
;
1048 cur_abbrev
->attrs
= tmp
;
1051 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
1052 = (enum dwarf_attribute
) abbrev_name
;
1053 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].form
1054 = (enum dwarf_form
) abbrev_form
;
1055 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].implicit_const
1057 ++cur_abbrev
->num_attrs
;
1060 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
1061 cur_abbrev
->next
= abbrevs
[hash_number
];
1062 abbrevs
[hash_number
] = cur_abbrev
;
1064 /* Get next abbreviation.
1065 Under Irix6 the abbreviations for a compilation unit are not
1066 always properly terminated with an abbrev number of 0.
1067 Exit loop if we encounter an abbreviation which we have
1068 already read (which means we are about to read the abbreviations
1069 for the next compile unit) or if the end of the abbreviation
1070 table is reached. */
1071 if ((unsigned int) (abbrev_ptr
- stash
->dwarf_abbrev_buffer
)
1072 >= stash
->dwarf_abbrev_size
)
1074 abbrev_number
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
,
1075 &bytes_read
, FALSE
, abbrev_end
);
1076 abbrev_ptr
+= bytes_read
;
1077 if (lookup_abbrev (abbrev_number
, abbrevs
) != NULL
)
1084 /* Returns true if the form is one which has a string value. */
1086 static inline bfd_boolean
1087 is_str_attr (enum dwarf_form form
)
1089 return (form
== DW_FORM_string
|| form
== DW_FORM_strp
1090 || form
== DW_FORM_line_strp
|| form
== DW_FORM_GNU_strp_alt
);
1093 /* Read and fill in the value of attribute ATTR as described by FORM.
1094 Read data starting from INFO_PTR, but never at or beyond INFO_PTR_END.
1095 Returns an updated INFO_PTR taking into account the amount of data read. */
1098 read_attribute_value (struct attribute
* attr
,
1100 bfd_vma implicit_const
,
1101 struct comp_unit
* unit
,
1102 bfd_byte
* info_ptr
,
1103 bfd_byte
* info_ptr_end
)
1105 bfd
*abfd
= unit
->abfd
;
1106 unsigned int bytes_read
;
1107 struct dwarf_block
*blk
;
1110 if (info_ptr
>= info_ptr_end
&& form
!= DW_FORM_flag_present
)
1112 _bfd_error_handler (_("DWARF error: info pointer extends beyond end of attributes"));
1113 bfd_set_error (bfd_error_bad_value
);
1117 attr
->form
= (enum dwarf_form
) form
;
1121 case DW_FORM_ref_addr
:
1122 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
1124 if (unit
->version
== 3 || unit
->version
== 4)
1126 if (unit
->offset_size
== 4)
1127 attr
->u
.val
= read_4_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1129 attr
->u
.val
= read_8_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1130 info_ptr
+= unit
->offset_size
;
1135 attr
->u
.val
= read_address (unit
, info_ptr
, info_ptr_end
);
1136 info_ptr
+= unit
->addr_size
;
1138 case DW_FORM_GNU_ref_alt
:
1139 case DW_FORM_sec_offset
:
1140 if (unit
->offset_size
== 4)
1141 attr
->u
.val
= read_4_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1143 attr
->u
.val
= read_8_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1144 info_ptr
+= unit
->offset_size
;
1146 case DW_FORM_block2
:
1147 amt
= sizeof (struct dwarf_block
);
1148 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1151 blk
->size
= read_2_bytes (abfd
, info_ptr
, info_ptr_end
);
1153 info_ptr
= read_n_bytes (info_ptr
, info_ptr_end
, blk
);
1156 case DW_FORM_block4
:
1157 amt
= sizeof (struct dwarf_block
);
1158 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1161 blk
->size
= read_4_bytes (abfd
, info_ptr
, info_ptr_end
);
1163 info_ptr
= read_n_bytes (info_ptr
, info_ptr_end
, blk
);
1167 attr
->u
.val
= read_2_bytes (abfd
, info_ptr
, info_ptr_end
);
1171 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
, info_ptr_end
);
1175 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
, info_ptr_end
);
1178 case DW_FORM_string
:
1179 attr
->u
.str
= read_string (abfd
, info_ptr
, info_ptr_end
, &bytes_read
);
1180 info_ptr
+= bytes_read
;
1183 attr
->u
.str
= read_indirect_string (unit
, info_ptr
, info_ptr_end
, &bytes_read
);
1184 info_ptr
+= bytes_read
;
1186 case DW_FORM_line_strp
:
1187 attr
->u
.str
= read_indirect_line_string (unit
, info_ptr
, info_ptr_end
, &bytes_read
);
1188 info_ptr
+= bytes_read
;
1190 case DW_FORM_GNU_strp_alt
:
1191 attr
->u
.str
= read_alt_indirect_string (unit
, info_ptr
, info_ptr_end
, &bytes_read
);
1192 info_ptr
+= bytes_read
;
1194 case DW_FORM_exprloc
:
1196 amt
= sizeof (struct dwarf_block
);
1197 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1200 blk
->size
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1201 FALSE
, info_ptr_end
);
1202 info_ptr
+= bytes_read
;
1203 info_ptr
= read_n_bytes (info_ptr
, info_ptr_end
, blk
);
1206 case DW_FORM_block1
:
1207 amt
= sizeof (struct dwarf_block
);
1208 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1211 blk
->size
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1213 info_ptr
= read_n_bytes (info_ptr
, info_ptr_end
, blk
);
1217 attr
->u
.val
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1221 attr
->u
.val
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1224 case DW_FORM_flag_present
:
1228 attr
->u
.sval
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1229 TRUE
, info_ptr_end
);
1230 info_ptr
+= bytes_read
;
1233 attr
->u
.val
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1234 FALSE
, info_ptr_end
);
1235 info_ptr
+= bytes_read
;
1238 attr
->u
.val
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1242 attr
->u
.val
= read_2_bytes (abfd
, info_ptr
, info_ptr_end
);
1246 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
, info_ptr_end
);
1250 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
, info_ptr_end
);
1253 case DW_FORM_ref_sig8
:
1254 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
, info_ptr_end
);
1257 case DW_FORM_ref_udata
:
1258 attr
->u
.val
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1259 FALSE
, info_ptr_end
);
1260 info_ptr
+= bytes_read
;
1262 case DW_FORM_indirect
:
1263 form
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1264 FALSE
, info_ptr_end
);
1265 info_ptr
+= bytes_read
;
1266 if (form
== DW_FORM_implicit_const
)
1268 implicit_const
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1269 TRUE
, info_ptr_end
);
1270 info_ptr
+= bytes_read
;
1272 info_ptr
= read_attribute_value (attr
, form
, implicit_const
, unit
,
1273 info_ptr
, info_ptr_end
);
1275 case DW_FORM_implicit_const
:
1276 attr
->form
= DW_FORM_sdata
;
1277 attr
->u
.sval
= implicit_const
;
1280 _bfd_error_handler (_("DWARF error: invalid or unhandled FORM value: %#x"),
1282 bfd_set_error (bfd_error_bad_value
);
1288 /* Read an attribute described by an abbreviated attribute. */
1291 read_attribute (struct attribute
* attr
,
1292 struct attr_abbrev
* abbrev
,
1293 struct comp_unit
* unit
,
1294 bfd_byte
* info_ptr
,
1295 bfd_byte
* info_ptr_end
)
1297 attr
->name
= abbrev
->name
;
1298 info_ptr
= read_attribute_value (attr
, abbrev
->form
, abbrev
->implicit_const
,
1299 unit
, info_ptr
, info_ptr_end
);
1303 /* Return whether DW_AT_name will return the same as DW_AT_linkage_name
1307 non_mangled (int lang
)
1317 case DW_LANG_Cobol74
:
1318 case DW_LANG_Cobol85
:
1319 case DW_LANG_Fortran77
:
1320 case DW_LANG_Pascal83
:
1330 /* Source line information table routines. */
1332 #define FILE_ALLOC_CHUNK 5
1333 #define DIR_ALLOC_CHUNK 5
1337 struct line_info
* prev_line
;
1341 unsigned int column
;
1342 unsigned int discriminator
;
1343 unsigned char op_index
;
1344 unsigned char end_sequence
; /* End of (sequential) code sequence. */
1355 struct line_sequence
1358 struct line_sequence
* prev_sequence
;
1359 struct line_info
* last_line
; /* Largest VMA. */
1360 struct line_info
** line_info_lookup
;
1361 bfd_size_type num_lines
;
1364 struct line_info_table
1367 unsigned int num_files
;
1368 unsigned int num_dirs
;
1369 unsigned int num_sequences
;
1372 struct fileinfo
* files
;
1373 struct line_sequence
* sequences
;
1374 struct line_info
* lcl_head
; /* Local head; used in 'add_line_info'. */
1377 /* Remember some information about each function. If the function is
1378 inlined (DW_TAG_inlined_subroutine) it may have two additional
1379 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
1380 source code location where this function was inlined. */
1384 /* Pointer to previous function in list of all functions. */
1385 struct funcinfo
* prev_func
;
1386 /* Pointer to function one scope higher. */
1387 struct funcinfo
* caller_func
;
1388 /* Source location file name where caller_func inlines this func. */
1390 /* Source location file name. */
1392 /* Source location line number where caller_func inlines this func. */
1394 /* Source location line number. */
1397 bfd_boolean is_linkage
;
1399 struct arange arange
;
1400 /* Where the symbol is defined. */
1404 struct lookup_funcinfo
1406 /* Function information corresponding to this lookup table entry. */
1407 struct funcinfo
* funcinfo
;
1409 /* The lowest address for this specific function. */
1412 /* The highest address of this function before the lookup table is sorted.
1413 The highest address of all prior functions after the lookup table is
1414 sorted, which is used for binary search. */
1420 /* Pointer to previous variable in list of all variables */
1421 struct varinfo
*prev_var
;
1422 /* Source location file name */
1424 /* Source location line number */
1429 /* Where the symbol is defined */
1431 /* Is this a stack variable? */
1432 unsigned int stack
: 1;
1435 /* Return TRUE if NEW_LINE should sort after LINE. */
1437 static inline bfd_boolean
1438 new_line_sorts_after (struct line_info
*new_line
, struct line_info
*line
)
1440 return (new_line
->address
> line
->address
1441 || (new_line
->address
== line
->address
1442 && new_line
->op_index
> line
->op_index
));
1446 /* Adds a new entry to the line_info list in the line_info_table, ensuring
1447 that the list is sorted. Note that the line_info list is sorted from
1448 highest to lowest VMA (with possible duplicates); that is,
1449 line_info->prev_line always accesses an equal or smaller VMA. */
1452 add_line_info (struct line_info_table
*table
,
1454 unsigned char op_index
,
1457 unsigned int column
,
1458 unsigned int discriminator
,
1461 bfd_size_type amt
= sizeof (struct line_info
);
1462 struct line_sequence
* seq
= table
->sequences
;
1463 struct line_info
* info
= (struct line_info
*) bfd_alloc (table
->abfd
, amt
);
1468 /* Set member data of 'info'. */
1469 info
->prev_line
= NULL
;
1470 info
->address
= address
;
1471 info
->op_index
= op_index
;
1473 info
->column
= column
;
1474 info
->discriminator
= discriminator
;
1475 info
->end_sequence
= end_sequence
;
1477 if (filename
&& filename
[0])
1479 info
->filename
= (char *) bfd_alloc (table
->abfd
, strlen (filename
) + 1);
1480 if (info
->filename
== NULL
)
1482 strcpy (info
->filename
, filename
);
1485 info
->filename
= NULL
;
1487 /* Find the correct location for 'info'. Normally we will receive
1488 new line_info data 1) in order and 2) with increasing VMAs.
1489 However some compilers break the rules (cf. decode_line_info) and
1490 so we include some heuristics for quickly finding the correct
1491 location for 'info'. In particular, these heuristics optimize for
1492 the common case in which the VMA sequence that we receive is a
1493 list of locally sorted VMAs such as
1494 p...z a...j (where a < j < p < z)
1496 Note: table->lcl_head is used to head an *actual* or *possible*
1497 sub-sequence within the list (such as a...j) that is not directly
1498 headed by table->last_line
1500 Note: we may receive duplicate entries from 'decode_line_info'. */
1503 && seq
->last_line
->address
== address
1504 && seq
->last_line
->op_index
== op_index
1505 && seq
->last_line
->end_sequence
== end_sequence
)
1507 /* We only keep the last entry with the same address and end
1508 sequence. See PR ld/4986. */
1509 if (table
->lcl_head
== seq
->last_line
)
1510 table
->lcl_head
= info
;
1511 info
->prev_line
= seq
->last_line
->prev_line
;
1512 seq
->last_line
= info
;
1514 else if (!seq
|| seq
->last_line
->end_sequence
)
1516 /* Start a new line sequence. */
1517 amt
= sizeof (struct line_sequence
);
1518 seq
= (struct line_sequence
*) bfd_malloc (amt
);
1521 seq
->low_pc
= address
;
1522 seq
->prev_sequence
= table
->sequences
;
1523 seq
->last_line
= info
;
1524 table
->lcl_head
= info
;
1525 table
->sequences
= seq
;
1526 table
->num_sequences
++;
1528 else if (info
->end_sequence
1529 || new_line_sorts_after (info
, seq
->last_line
))
1531 /* Normal case: add 'info' to the beginning of the current sequence. */
1532 info
->prev_line
= seq
->last_line
;
1533 seq
->last_line
= info
;
1535 /* lcl_head: initialize to head a *possible* sequence at the end. */
1536 if (!table
->lcl_head
)
1537 table
->lcl_head
= info
;
1539 else if (!new_line_sorts_after (info
, table
->lcl_head
)
1540 && (!table
->lcl_head
->prev_line
1541 || new_line_sorts_after (info
, table
->lcl_head
->prev_line
)))
1543 /* Abnormal but easy: lcl_head is the head of 'info'. */
1544 info
->prev_line
= table
->lcl_head
->prev_line
;
1545 table
->lcl_head
->prev_line
= info
;
1549 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head'
1550 are valid heads for 'info'. Reset 'lcl_head'. */
1551 struct line_info
* li2
= seq
->last_line
; /* Always non-NULL. */
1552 struct line_info
* li1
= li2
->prev_line
;
1556 if (!new_line_sorts_after (info
, li2
)
1557 && new_line_sorts_after (info
, li1
))
1560 li2
= li1
; /* always non-NULL */
1561 li1
= li1
->prev_line
;
1563 table
->lcl_head
= li2
;
1564 info
->prev_line
= table
->lcl_head
->prev_line
;
1565 table
->lcl_head
->prev_line
= info
;
1566 if (address
< seq
->low_pc
)
1567 seq
->low_pc
= address
;
1572 /* Extract a fully qualified filename from a line info table.
1573 The returned string has been malloc'ed and it is the caller's
1574 responsibility to free it. */
1577 concat_filename (struct line_info_table
*table
, unsigned int file
)
1581 if (table
== NULL
|| file
- 1 >= table
->num_files
)
1583 /* FILE == 0 means unknown. */
1586 (_("DWARF error: mangled line number section (bad file number)"));
1587 return strdup ("<unknown>");
1590 filename
= table
->files
[file
- 1].name
;
1591 if (filename
== NULL
)
1592 return strdup ("<unknown>");
1594 if (!IS_ABSOLUTE_PATH (filename
))
1596 char *dir_name
= NULL
;
1597 char *subdir_name
= NULL
;
1601 if (table
->files
[file
- 1].dir
1602 /* PR 17512: file: 0317e960. */
1603 && table
->files
[file
- 1].dir
<= table
->num_dirs
1604 /* PR 17512: file: 7f3d2e4b. */
1605 && table
->dirs
!= NULL
)
1606 subdir_name
= table
->dirs
[table
->files
[file
- 1].dir
- 1];
1608 if (!subdir_name
|| !IS_ABSOLUTE_PATH (subdir_name
))
1609 dir_name
= table
->comp_dir
;
1613 dir_name
= subdir_name
;
1618 return strdup (filename
);
1620 len
= strlen (dir_name
) + strlen (filename
) + 2;
1624 len
+= strlen (subdir_name
) + 1;
1625 name
= (char *) bfd_malloc (len
);
1627 sprintf (name
, "%s/%s/%s", dir_name
, subdir_name
, filename
);
1631 name
= (char *) bfd_malloc (len
);
1633 sprintf (name
, "%s/%s", dir_name
, filename
);
1639 return strdup (filename
);
1643 arange_add (const struct comp_unit
*unit
, struct arange
*first_arange
,
1644 bfd_vma low_pc
, bfd_vma high_pc
)
1646 struct arange
*arange
;
1648 /* Ignore empty ranges. */
1649 if (low_pc
== high_pc
)
1652 /* If the first arange is empty, use it. */
1653 if (first_arange
->high
== 0)
1655 first_arange
->low
= low_pc
;
1656 first_arange
->high
= high_pc
;
1660 /* Next see if we can cheaply extend an existing range. */
1661 arange
= first_arange
;
1664 if (low_pc
== arange
->high
)
1666 arange
->high
= high_pc
;
1669 if (high_pc
== arange
->low
)
1671 arange
->low
= low_pc
;
1674 arange
= arange
->next
;
1678 /* Need to allocate a new arange and insert it into the arange list.
1679 Order isn't significant, so just insert after the first arange. */
1680 arange
= (struct arange
*) bfd_alloc (unit
->abfd
, sizeof (*arange
));
1683 arange
->low
= low_pc
;
1684 arange
->high
= high_pc
;
1685 arange
->next
= first_arange
->next
;
1686 first_arange
->next
= arange
;
1690 /* Compare function for line sequences. */
1693 compare_sequences (const void* a
, const void* b
)
1695 const struct line_sequence
* seq1
= a
;
1696 const struct line_sequence
* seq2
= b
;
1698 /* Sort by low_pc as the primary key. */
1699 if (seq1
->low_pc
< seq2
->low_pc
)
1701 if (seq1
->low_pc
> seq2
->low_pc
)
1704 /* If low_pc values are equal, sort in reverse order of
1705 high_pc, so that the largest region comes first. */
1706 if (seq1
->last_line
->address
< seq2
->last_line
->address
)
1708 if (seq1
->last_line
->address
> seq2
->last_line
->address
)
1711 if (seq1
->last_line
->op_index
< seq2
->last_line
->op_index
)
1713 if (seq1
->last_line
->op_index
> seq2
->last_line
->op_index
)
1719 /* Construct the line information table for quick lookup. */
1722 build_line_info_table (struct line_info_table
* table
,
1723 struct line_sequence
* seq
)
1726 struct line_info
** line_info_lookup
;
1727 struct line_info
* each_line
;
1728 unsigned int num_lines
;
1729 unsigned int line_index
;
1731 if (seq
->line_info_lookup
!= NULL
)
1734 /* Count the number of line information entries. We could do this while
1735 scanning the debug information, but some entries may be added via
1736 lcl_head without having a sequence handy to increment the number of
1739 for (each_line
= seq
->last_line
; each_line
; each_line
= each_line
->prev_line
)
1745 /* Allocate space for the line information lookup table. */
1746 amt
= sizeof (struct line_info
*) * num_lines
;
1747 line_info_lookup
= (struct line_info
**) bfd_alloc (table
->abfd
, amt
);
1748 if (line_info_lookup
== NULL
)
1751 /* Create the line information lookup table. */
1752 line_index
= num_lines
;
1753 for (each_line
= seq
->last_line
; each_line
; each_line
= each_line
->prev_line
)
1754 line_info_lookup
[--line_index
] = each_line
;
1756 BFD_ASSERT (line_index
== 0);
1758 seq
->num_lines
= num_lines
;
1759 seq
->line_info_lookup
= line_info_lookup
;
1764 /* Sort the line sequences for quick lookup. */
1767 sort_line_sequences (struct line_info_table
* table
)
1770 struct line_sequence
* sequences
;
1771 struct line_sequence
* seq
;
1773 unsigned int num_sequences
= table
->num_sequences
;
1774 bfd_vma last_high_pc
;
1776 if (num_sequences
== 0)
1779 /* Allocate space for an array of sequences. */
1780 amt
= sizeof (struct line_sequence
) * num_sequences
;
1781 sequences
= (struct line_sequence
*) bfd_alloc (table
->abfd
, amt
);
1782 if (sequences
== NULL
)
1785 /* Copy the linked list into the array, freeing the original nodes. */
1786 seq
= table
->sequences
;
1787 for (n
= 0; n
< num_sequences
; n
++)
1789 struct line_sequence
* last_seq
= seq
;
1792 sequences
[n
].low_pc
= seq
->low_pc
;
1793 sequences
[n
].prev_sequence
= NULL
;
1794 sequences
[n
].last_line
= seq
->last_line
;
1795 sequences
[n
].line_info_lookup
= NULL
;
1796 sequences
[n
].num_lines
= 0;
1797 seq
= seq
->prev_sequence
;
1800 BFD_ASSERT (seq
== NULL
);
1802 qsort (sequences
, n
, sizeof (struct line_sequence
), compare_sequences
);
1804 /* Make the list binary-searchable by trimming overlapping entries
1805 and removing nested entries. */
1807 last_high_pc
= sequences
[0].last_line
->address
;
1808 for (n
= 1; n
< table
->num_sequences
; n
++)
1810 if (sequences
[n
].low_pc
< last_high_pc
)
1812 if (sequences
[n
].last_line
->address
<= last_high_pc
)
1813 /* Skip nested entries. */
1816 /* Trim overlapping entries. */
1817 sequences
[n
].low_pc
= last_high_pc
;
1819 last_high_pc
= sequences
[n
].last_line
->address
;
1820 if (n
> num_sequences
)
1822 /* Close up the gap. */
1823 sequences
[num_sequences
].low_pc
= sequences
[n
].low_pc
;
1824 sequences
[num_sequences
].last_line
= sequences
[n
].last_line
;
1829 table
->sequences
= sequences
;
1830 table
->num_sequences
= num_sequences
;
1834 /* Add directory to TABLE. CUR_DIR memory ownership is taken by TABLE. */
1837 line_info_add_include_dir (struct line_info_table
*table
, char *cur_dir
)
1839 if ((table
->num_dirs
% DIR_ALLOC_CHUNK
) == 0)
1844 amt
= table
->num_dirs
+ DIR_ALLOC_CHUNK
;
1845 amt
*= sizeof (char *);
1847 tmp
= (char **) bfd_realloc (table
->dirs
, amt
);
1853 table
->dirs
[table
->num_dirs
++] = cur_dir
;
1858 line_info_add_include_dir_stub (struct line_info_table
*table
, char *cur_dir
,
1859 unsigned int dir ATTRIBUTE_UNUSED
,
1860 unsigned int xtime ATTRIBUTE_UNUSED
,
1861 unsigned int size ATTRIBUTE_UNUSED
)
1863 return line_info_add_include_dir (table
, cur_dir
);
1866 /* Add file to TABLE. CUR_FILE memory ownership is taken by TABLE. */
1869 line_info_add_file_name (struct line_info_table
*table
, char *cur_file
,
1870 unsigned int dir
, unsigned int xtime
,
1873 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
1875 struct fileinfo
*tmp
;
1878 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
1879 amt
*= sizeof (struct fileinfo
);
1881 tmp
= (struct fileinfo
*) bfd_realloc (table
->files
, amt
);
1887 table
->files
[table
->num_files
].name
= cur_file
;
1888 table
->files
[table
->num_files
].dir
= dir
;
1889 table
->files
[table
->num_files
].time
= xtime
;
1890 table
->files
[table
->num_files
].size
= size
;
1895 /* Read directory or file name entry format, starting with byte of
1896 format count entries, ULEB128 pairs of entry formats, ULEB128 of
1897 entries count and the entries themselves in the described entry
1901 read_formatted_entries (struct comp_unit
*unit
, bfd_byte
**bufp
,
1902 bfd_byte
*buf_end
, struct line_info_table
*table
,
1903 bfd_boolean (*callback
) (struct line_info_table
*table
,
1909 bfd
*abfd
= unit
->abfd
;
1910 bfd_byte format_count
, formati
;
1911 bfd_vma data_count
, datai
;
1912 bfd_byte
*buf
= *bufp
;
1913 bfd_byte
*format_header_data
;
1914 unsigned int bytes_read
;
1916 format_count
= read_1_byte (abfd
, buf
, buf_end
);
1918 format_header_data
= buf
;
1919 for (formati
= 0; formati
< format_count
; formati
++)
1921 _bfd_safe_read_leb128 (abfd
, buf
, &bytes_read
, FALSE
, buf_end
);
1923 _bfd_safe_read_leb128 (abfd
, buf
, &bytes_read
, FALSE
, buf_end
);
1927 data_count
= _bfd_safe_read_leb128 (abfd
, buf
, &bytes_read
, FALSE
, buf_end
);
1929 if (format_count
== 0 && data_count
!= 0)
1931 _bfd_error_handler (_("DWARF error: zero format count"));
1932 bfd_set_error (bfd_error_bad_value
);
1936 /* PR 22210. Paranoia check. Don't bother running the loop
1937 if we know that we are going to run out of buffer. */
1938 if (data_count
> (bfd_vma
) (buf_end
- buf
))
1941 (_("DWARF error: data count (%" PRIx64
") larger than buffer size"),
1942 (uint64_t) data_count
);
1943 bfd_set_error (bfd_error_bad_value
);
1947 for (datai
= 0; datai
< data_count
; datai
++)
1949 bfd_byte
*format
= format_header_data
;
1952 memset (&fe
, 0, sizeof fe
);
1953 for (formati
= 0; formati
< format_count
; formati
++)
1955 bfd_vma content_type
, form
;
1957 char **stringp
= &string_trash
;
1958 unsigned int uint_trash
, *uintp
= &uint_trash
;
1959 struct attribute attr
;
1961 content_type
= _bfd_safe_read_leb128 (abfd
, format
, &bytes_read
,
1963 format
+= bytes_read
;
1964 switch (content_type
)
1969 case DW_LNCT_directory_index
:
1972 case DW_LNCT_timestamp
:
1982 (_("DWARF error: unknown format content type %" PRIu64
),
1983 (uint64_t) content_type
);
1984 bfd_set_error (bfd_error_bad_value
);
1988 form
= _bfd_safe_read_leb128 (abfd
, format
, &bytes_read
, FALSE
,
1990 format
+= bytes_read
;
1992 buf
= read_attribute_value (&attr
, form
, 0, unit
, buf
, buf_end
);
1997 case DW_FORM_string
:
1998 case DW_FORM_line_strp
:
1999 *stringp
= attr
.u
.str
;
2007 *uintp
= attr
.u
.val
;
2012 if (!callback (table
, fe
.name
, fe
.dir
, fe
.time
, fe
.size
))
2020 /* Decode the line number information for UNIT. */
2022 static struct line_info_table
*
2023 decode_line_info (struct comp_unit
*unit
, struct dwarf2_debug
*stash
)
2025 bfd
*abfd
= unit
->abfd
;
2026 struct line_info_table
* table
;
2029 struct line_head lh
;
2030 unsigned int i
, bytes_read
, offset_size
;
2031 char *cur_file
, *cur_dir
;
2032 unsigned char op_code
, extended_op
, adj_opcode
;
2033 unsigned int exop_len
;
2036 if (! read_section (abfd
, &stash
->debug_sections
[debug_line
],
2037 stash
->syms
, unit
->line_offset
,
2038 &stash
->dwarf_line_buffer
, &stash
->dwarf_line_size
))
2041 amt
= sizeof (struct line_info_table
);
2042 table
= (struct line_info_table
*) bfd_alloc (abfd
, amt
);
2046 table
->comp_dir
= unit
->comp_dir
;
2048 table
->num_files
= 0;
2049 table
->files
= NULL
;
2051 table
->num_dirs
= 0;
2054 table
->num_sequences
= 0;
2055 table
->sequences
= NULL
;
2057 table
->lcl_head
= NULL
;
2059 if (stash
->dwarf_line_size
< 16)
2062 (_("DWARF error: line info section is too small (%" PRId64
")"),
2063 (int64_t) stash
->dwarf_line_size
);
2064 bfd_set_error (bfd_error_bad_value
);
2067 line_ptr
= stash
->dwarf_line_buffer
+ unit
->line_offset
;
2068 line_end
= stash
->dwarf_line_buffer
+ stash
->dwarf_line_size
;
2070 /* Read in the prologue. */
2071 lh
.total_length
= read_4_bytes (abfd
, line_ptr
, line_end
);
2074 if (lh
.total_length
== 0xffffffff)
2076 lh
.total_length
= read_8_bytes (abfd
, line_ptr
, line_end
);
2080 else if (lh
.total_length
== 0 && unit
->addr_size
== 8)
2082 /* Handle (non-standard) 64-bit DWARF2 formats. */
2083 lh
.total_length
= read_4_bytes (abfd
, line_ptr
, line_end
);
2088 if (lh
.total_length
> (size_t) (line_end
- line_ptr
))
2091 /* xgettext: c-format */
2092 (_("DWARF error: line info data is bigger (%#" PRIx64
")"
2093 " than the space remaining in the section (%#lx)"),
2094 (uint64_t) lh
.total_length
, (unsigned long) (line_end
- line_ptr
));
2095 bfd_set_error (bfd_error_bad_value
);
2099 line_end
= line_ptr
+ lh
.total_length
;
2101 lh
.version
= read_2_bytes (abfd
, line_ptr
, line_end
);
2102 if (lh
.version
< 2 || lh
.version
> 5)
2105 (_("DWARF error: unhandled .debug_line version %d"), lh
.version
);
2106 bfd_set_error (bfd_error_bad_value
);
2111 if (line_ptr
+ offset_size
+ (lh
.version
>= 5 ? 8 : (lh
.version
>= 4 ? 6 : 5))
2115 (_("DWARF error: ran out of room reading prologue"));
2116 bfd_set_error (bfd_error_bad_value
);
2120 if (lh
.version
>= 5)
2122 unsigned int segment_selector_size
;
2124 /* Skip address size. */
2125 read_1_byte (abfd
, line_ptr
, line_end
);
2128 segment_selector_size
= read_1_byte (abfd
, line_ptr
, line_end
);
2130 if (segment_selector_size
!= 0)
2133 (_("DWARF error: line info unsupported segment selector size %u"),
2134 segment_selector_size
);
2135 bfd_set_error (bfd_error_bad_value
);
2140 if (offset_size
== 4)
2141 lh
.prologue_length
= read_4_bytes (abfd
, line_ptr
, line_end
);
2143 lh
.prologue_length
= read_8_bytes (abfd
, line_ptr
, line_end
);
2144 line_ptr
+= offset_size
;
2146 lh
.minimum_instruction_length
= read_1_byte (abfd
, line_ptr
, line_end
);
2149 if (lh
.version
>= 4)
2151 lh
.maximum_ops_per_insn
= read_1_byte (abfd
, line_ptr
, line_end
);
2155 lh
.maximum_ops_per_insn
= 1;
2157 if (lh
.maximum_ops_per_insn
== 0)
2160 (_("DWARF error: invalid maximum operations per instruction"));
2161 bfd_set_error (bfd_error_bad_value
);
2165 lh
.default_is_stmt
= read_1_byte (abfd
, line_ptr
, line_end
);
2168 lh
.line_base
= read_1_signed_byte (abfd
, line_ptr
, line_end
);
2171 lh
.line_range
= read_1_byte (abfd
, line_ptr
, line_end
);
2174 lh
.opcode_base
= read_1_byte (abfd
, line_ptr
, line_end
);
2177 if (line_ptr
+ (lh
.opcode_base
- 1) >= line_end
)
2179 _bfd_error_handler (_("DWARF error: ran out of room reading opcodes"));
2180 bfd_set_error (bfd_error_bad_value
);
2184 amt
= lh
.opcode_base
* sizeof (unsigned char);
2185 lh
.standard_opcode_lengths
= (unsigned char *) bfd_alloc (abfd
, amt
);
2187 lh
.standard_opcode_lengths
[0] = 1;
2189 for (i
= 1; i
< lh
.opcode_base
; ++i
)
2191 lh
.standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
, line_end
);
2195 if (lh
.version
>= 5)
2197 /* Read directory table. */
2198 if (!read_formatted_entries (unit
, &line_ptr
, line_end
, table
,
2199 line_info_add_include_dir_stub
))
2202 /* Read file name table. */
2203 if (!read_formatted_entries (unit
, &line_ptr
, line_end
, table
,
2204 line_info_add_file_name
))
2209 /* Read directory table. */
2210 while ((cur_dir
= read_string (abfd
, line_ptr
, line_end
, &bytes_read
)) != NULL
)
2212 line_ptr
+= bytes_read
;
2214 if (!line_info_add_include_dir (table
, cur_dir
))
2218 line_ptr
+= bytes_read
;
2220 /* Read file name table. */
2221 while ((cur_file
= read_string (abfd
, line_ptr
, line_end
, &bytes_read
)) != NULL
)
2223 unsigned int dir
, xtime
, size
;
2225 line_ptr
+= bytes_read
;
2227 dir
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
, FALSE
, line_end
);
2228 line_ptr
+= bytes_read
;
2229 xtime
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
, FALSE
, line_end
);
2230 line_ptr
+= bytes_read
;
2231 size
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
, FALSE
, line_end
);
2232 line_ptr
+= bytes_read
;
2234 if (!line_info_add_file_name (table
, cur_file
, dir
, xtime
, size
))
2238 line_ptr
+= bytes_read
;
2241 /* Read the statement sequences until there's nothing left. */
2242 while (line_ptr
< line_end
)
2244 /* State machine registers. */
2245 bfd_vma address
= 0;
2246 unsigned char op_index
= 0;
2247 char * filename
= table
->num_files
? concat_filename (table
, 1) : NULL
;
2248 unsigned int line
= 1;
2249 unsigned int column
= 0;
2250 unsigned int discriminator
= 0;
2251 int is_stmt
= lh
.default_is_stmt
;
2252 int end_sequence
= 0;
2253 unsigned int dir
, xtime
, size
;
2254 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
2255 compilers generate address sequences that are wildly out of
2256 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
2257 for ia64-Linux). Thus, to determine the low and high
2258 address, we must compare on every DW_LNS_copy, etc. */
2259 bfd_vma low_pc
= (bfd_vma
) -1;
2260 bfd_vma high_pc
= 0;
2262 /* Decode the table. */
2263 while (!end_sequence
&& line_ptr
< line_end
)
2265 op_code
= read_1_byte (abfd
, line_ptr
, line_end
);
2268 if (op_code
>= lh
.opcode_base
)
2270 /* Special operand. */
2271 adj_opcode
= op_code
- lh
.opcode_base
;
2272 if (lh
.line_range
== 0)
2274 if (lh
.maximum_ops_per_insn
== 1)
2275 address
+= (adj_opcode
/ lh
.line_range
2276 * lh
.minimum_instruction_length
);
2279 address
+= ((op_index
+ adj_opcode
/ lh
.line_range
)
2280 / lh
.maximum_ops_per_insn
2281 * lh
.minimum_instruction_length
);
2282 op_index
= ((op_index
+ adj_opcode
/ lh
.line_range
)
2283 % lh
.maximum_ops_per_insn
);
2285 line
+= lh
.line_base
+ (adj_opcode
% lh
.line_range
);
2286 /* Append row to matrix using current values. */
2287 if (!add_line_info (table
, address
, op_index
, filename
,
2288 line
, column
, discriminator
, 0))
2291 if (address
< low_pc
)
2293 if (address
> high_pc
)
2296 else switch (op_code
)
2298 case DW_LNS_extended_op
:
2299 exop_len
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2301 line_ptr
+= bytes_read
;
2302 extended_op
= read_1_byte (abfd
, line_ptr
, line_end
);
2305 switch (extended_op
)
2307 case DW_LNE_end_sequence
:
2309 if (!add_line_info (table
, address
, op_index
, filename
, line
,
2310 column
, discriminator
, end_sequence
))
2313 if (address
< low_pc
)
2315 if (address
> high_pc
)
2317 if (!arange_add (unit
, &unit
->arange
, low_pc
, high_pc
))
2320 case DW_LNE_set_address
:
2321 address
= read_address (unit
, line_ptr
, line_end
);
2323 line_ptr
+= unit
->addr_size
;
2325 case DW_LNE_define_file
:
2326 cur_file
= read_string (abfd
, line_ptr
, line_end
, &bytes_read
);
2327 line_ptr
+= bytes_read
;
2328 dir
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2330 line_ptr
+= bytes_read
;
2331 xtime
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2333 line_ptr
+= bytes_read
;
2334 size
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2336 line_ptr
+= bytes_read
;
2337 if (!line_info_add_file_name (table
, cur_file
, dir
,
2341 case DW_LNE_set_discriminator
:
2343 _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2345 line_ptr
+= bytes_read
;
2347 case DW_LNE_HP_source_file_correlation
:
2348 line_ptr
+= exop_len
- 1;
2352 (_("DWARF error: mangled line number section"));
2353 bfd_set_error (bfd_error_bad_value
);
2355 if (filename
!= NULL
)
2361 if (!add_line_info (table
, address
, op_index
,
2362 filename
, line
, column
, discriminator
, 0))
2365 if (address
< low_pc
)
2367 if (address
> high_pc
)
2370 case DW_LNS_advance_pc
:
2371 if (lh
.maximum_ops_per_insn
== 1)
2372 address
+= (lh
.minimum_instruction_length
2373 * _bfd_safe_read_leb128 (abfd
, line_ptr
,
2378 bfd_vma adjust
= _bfd_safe_read_leb128 (abfd
, line_ptr
,
2381 address
= ((op_index
+ adjust
) / lh
.maximum_ops_per_insn
2382 * lh
.minimum_instruction_length
);
2383 op_index
= (op_index
+ adjust
) % lh
.maximum_ops_per_insn
;
2385 line_ptr
+= bytes_read
;
2387 case DW_LNS_advance_line
:
2388 line
+= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2390 line_ptr
+= bytes_read
;
2392 case DW_LNS_set_file
:
2396 /* The file and directory tables are 0
2397 based, the references are 1 based. */
2398 file
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2400 line_ptr
+= bytes_read
;
2403 filename
= concat_filename (table
, file
);
2406 case DW_LNS_set_column
:
2407 column
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2409 line_ptr
+= bytes_read
;
2411 case DW_LNS_negate_stmt
:
2412 is_stmt
= (!is_stmt
);
2414 case DW_LNS_set_basic_block
:
2416 case DW_LNS_const_add_pc
:
2417 if (lh
.line_range
== 0)
2419 if (lh
.maximum_ops_per_insn
== 1)
2420 address
+= (lh
.minimum_instruction_length
2421 * ((255 - lh
.opcode_base
) / lh
.line_range
));
2424 bfd_vma adjust
= ((255 - lh
.opcode_base
) / lh
.line_range
);
2425 address
+= (lh
.minimum_instruction_length
2426 * ((op_index
+ adjust
)
2427 / lh
.maximum_ops_per_insn
));
2428 op_index
= (op_index
+ adjust
) % lh
.maximum_ops_per_insn
;
2431 case DW_LNS_fixed_advance_pc
:
2432 address
+= read_2_bytes (abfd
, line_ptr
, line_end
);
2437 /* Unknown standard opcode, ignore it. */
2438 for (i
= 0; i
< lh
.standard_opcode_lengths
[op_code
]; i
++)
2440 (void) _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2442 line_ptr
+= bytes_read
;
2452 if (sort_line_sequences (table
))
2456 while (table
->sequences
!= NULL
)
2458 struct line_sequence
* seq
= table
->sequences
;
2459 table
->sequences
= table
->sequences
->prev_sequence
;
2462 if (table
->files
!= NULL
)
2463 free (table
->files
);
2464 if (table
->dirs
!= NULL
)
2469 /* If ADDR is within TABLE set the output parameters and return the
2470 range of addresses covered by the entry used to fill them out.
2471 Otherwise set * FILENAME_PTR to NULL and return 0.
2472 The parameters FILENAME_PTR, LINENUMBER_PTR and DISCRIMINATOR_PTR
2473 are pointers to the objects to be filled in. */
2476 lookup_address_in_line_info_table (struct line_info_table
*table
,
2478 const char **filename_ptr
,
2479 unsigned int *linenumber_ptr
,
2480 unsigned int *discriminator_ptr
)
2482 struct line_sequence
*seq
= NULL
;
2483 struct line_info
*info
;
2486 /* Binary search the array of sequences. */
2488 high
= table
->num_sequences
;
2491 mid
= (low
+ high
) / 2;
2492 seq
= &table
->sequences
[mid
];
2493 if (addr
< seq
->low_pc
)
2495 else if (addr
>= seq
->last_line
->address
)
2501 /* Check for a valid sequence. */
2502 if (!seq
|| addr
< seq
->low_pc
|| addr
>= seq
->last_line
->address
)
2505 if (!build_line_info_table (table
, seq
))
2508 /* Binary search the array of line information. */
2510 high
= seq
->num_lines
;
2514 mid
= (low
+ high
) / 2;
2515 info
= seq
->line_info_lookup
[mid
];
2516 if (addr
< info
->address
)
2518 else if (addr
>= seq
->line_info_lookup
[mid
+ 1]->address
)
2524 /* Check for a valid line information entry. */
2526 && addr
>= info
->address
2527 && addr
< seq
->line_info_lookup
[mid
+ 1]->address
2528 && !(info
->end_sequence
|| info
== seq
->last_line
))
2530 *filename_ptr
= info
->filename
;
2531 *linenumber_ptr
= info
->line
;
2532 if (discriminator_ptr
)
2533 *discriminator_ptr
= info
->discriminator
;
2534 return seq
->last_line
->address
- seq
->low_pc
;
2538 *filename_ptr
= NULL
;
2542 /* Read in the .debug_ranges section for future reference. */
2545 read_debug_ranges (struct comp_unit
* unit
)
2547 struct dwarf2_debug
* stash
= unit
->stash
;
2549 return read_section (unit
->abfd
, &stash
->debug_sections
[debug_ranges
],
2551 &stash
->dwarf_ranges_buffer
,
2552 &stash
->dwarf_ranges_size
);
2555 /* Function table functions. */
2558 compare_lookup_funcinfos (const void * a
, const void * b
)
2560 const struct lookup_funcinfo
* lookup1
= a
;
2561 const struct lookup_funcinfo
* lookup2
= b
;
2563 if (lookup1
->low_addr
< lookup2
->low_addr
)
2565 if (lookup1
->low_addr
> lookup2
->low_addr
)
2567 if (lookup1
->high_addr
< lookup2
->high_addr
)
2569 if (lookup1
->high_addr
> lookup2
->high_addr
)
2576 build_lookup_funcinfo_table (struct comp_unit
* unit
)
2578 struct lookup_funcinfo
*lookup_funcinfo_table
= unit
->lookup_funcinfo_table
;
2579 unsigned int number_of_functions
= unit
->number_of_functions
;
2580 struct funcinfo
*each
;
2581 struct lookup_funcinfo
*entry
;
2583 struct arange
*range
;
2584 bfd_vma low_addr
, high_addr
;
2586 if (lookup_funcinfo_table
|| number_of_functions
== 0)
2589 /* Create the function info lookup table. */
2590 lookup_funcinfo_table
= (struct lookup_funcinfo
*)
2591 bfd_malloc (number_of_functions
* sizeof (struct lookup_funcinfo
));
2592 if (lookup_funcinfo_table
== NULL
)
2595 /* Populate the function info lookup table. */
2596 func_index
= number_of_functions
;
2597 for (each
= unit
->function_table
; each
; each
= each
->prev_func
)
2599 entry
= &lookup_funcinfo_table
[--func_index
];
2600 entry
->funcinfo
= each
;
2602 /* Calculate the lowest and highest address for this function entry. */
2603 low_addr
= entry
->funcinfo
->arange
.low
;
2604 high_addr
= entry
->funcinfo
->arange
.high
;
2606 for (range
= entry
->funcinfo
->arange
.next
; range
; range
= range
->next
)
2608 if (range
->low
< low_addr
)
2609 low_addr
= range
->low
;
2610 if (range
->high
> high_addr
)
2611 high_addr
= range
->high
;
2614 entry
->low_addr
= low_addr
;
2615 entry
->high_addr
= high_addr
;
2618 BFD_ASSERT (func_index
== 0);
2620 /* Sort the function by address. */
2621 qsort (lookup_funcinfo_table
,
2622 number_of_functions
,
2623 sizeof (struct lookup_funcinfo
),
2624 compare_lookup_funcinfos
);
2626 /* Calculate the high watermark for each function in the lookup table. */
2627 high_addr
= lookup_funcinfo_table
[0].high_addr
;
2628 for (func_index
= 1; func_index
< number_of_functions
; func_index
++)
2630 entry
= &lookup_funcinfo_table
[func_index
];
2631 if (entry
->high_addr
> high_addr
)
2632 high_addr
= entry
->high_addr
;
2634 entry
->high_addr
= high_addr
;
2637 unit
->lookup_funcinfo_table
= lookup_funcinfo_table
;
2641 /* If ADDR is within UNIT's function tables, set FUNCTION_PTR, and return
2642 TRUE. Note that we need to find the function that has the smallest range
2643 that contains ADDR, to handle inlined functions without depending upon
2644 them being ordered in TABLE by increasing range. */
2647 lookup_address_in_function_table (struct comp_unit
*unit
,
2649 struct funcinfo
**function_ptr
)
2651 unsigned int number_of_functions
= unit
->number_of_functions
;
2652 struct lookup_funcinfo
* lookup_funcinfo
= NULL
;
2653 struct funcinfo
* funcinfo
= NULL
;
2654 struct funcinfo
* best_fit
= NULL
;
2655 bfd_vma best_fit_len
= 0;
2656 bfd_size_type low
, high
, mid
, first
;
2657 struct arange
*arange
;
2659 if (number_of_functions
== 0)
2662 if (!build_lookup_funcinfo_table (unit
))
2665 if (unit
->lookup_funcinfo_table
[number_of_functions
- 1].high_addr
< addr
)
2668 /* Find the first function in the lookup table which may contain the
2669 specified address. */
2671 high
= number_of_functions
;
2675 mid
= (low
+ high
) / 2;
2676 lookup_funcinfo
= &unit
->lookup_funcinfo_table
[mid
];
2677 if (addr
< lookup_funcinfo
->low_addr
)
2679 else if (addr
>= lookup_funcinfo
->high_addr
)
2685 /* Find the 'best' match for the address. The prior algorithm defined the
2686 best match as the function with the smallest address range containing
2687 the specified address. This definition should probably be changed to the
2688 innermost inline routine containing the address, but right now we want
2689 to get the same results we did before. */
2690 while (first
< number_of_functions
)
2692 if (addr
< unit
->lookup_funcinfo_table
[first
].low_addr
)
2694 funcinfo
= unit
->lookup_funcinfo_table
[first
].funcinfo
;
2696 for (arange
= &funcinfo
->arange
; arange
; arange
= arange
->next
)
2698 if (addr
< arange
->low
|| addr
>= arange
->high
)
2702 || arange
->high
- arange
->low
< best_fit_len
2703 /* The following comparison is designed to return the same
2704 match as the previous algorithm for routines which have the
2705 same best fit length. */
2706 || (arange
->high
- arange
->low
== best_fit_len
2707 && funcinfo
> best_fit
))
2709 best_fit
= funcinfo
;
2710 best_fit_len
= arange
->high
- arange
->low
;
2720 *function_ptr
= best_fit
;
2724 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
2725 and LINENUMBER_PTR, and return TRUE. */
2728 lookup_symbol_in_function_table (struct comp_unit
*unit
,
2731 const char **filename_ptr
,
2732 unsigned int *linenumber_ptr
)
2734 struct funcinfo
* each_func
;
2735 struct funcinfo
* best_fit
= NULL
;
2736 bfd_vma best_fit_len
= 0;
2737 struct arange
*arange
;
2738 const char *name
= bfd_asymbol_name (sym
);
2739 asection
*sec
= bfd_get_section (sym
);
2741 for (each_func
= unit
->function_table
;
2743 each_func
= each_func
->prev_func
)
2745 for (arange
= &each_func
->arange
;
2747 arange
= arange
->next
)
2749 if ((!each_func
->sec
|| each_func
->sec
== sec
)
2750 && addr
>= arange
->low
2751 && addr
< arange
->high
2753 && strcmp (name
, each_func
->name
) == 0
2755 || arange
->high
- arange
->low
< best_fit_len
))
2757 best_fit
= each_func
;
2758 best_fit_len
= arange
->high
- arange
->low
;
2765 best_fit
->sec
= sec
;
2766 *filename_ptr
= best_fit
->file
;
2767 *linenumber_ptr
= best_fit
->line
;
2774 /* Variable table functions. */
2776 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
2777 LINENUMBER_PTR, and return TRUE. */
2780 lookup_symbol_in_variable_table (struct comp_unit
*unit
,
2783 const char **filename_ptr
,
2784 unsigned int *linenumber_ptr
)
2786 const char *name
= bfd_asymbol_name (sym
);
2787 asection
*sec
= bfd_get_section (sym
);
2788 struct varinfo
* each
;
2790 for (each
= unit
->variable_table
; each
; each
= each
->prev_var
)
2791 if (each
->stack
== 0
2792 && each
->file
!= NULL
2793 && each
->name
!= NULL
2794 && each
->addr
== addr
2795 && (!each
->sec
|| each
->sec
== sec
)
2796 && strcmp (name
, each
->name
) == 0)
2802 *filename_ptr
= each
->file
;
2803 *linenumber_ptr
= each
->line
;
2810 static struct comp_unit
*stash_comp_unit (struct dwarf2_debug
*);
2811 static bfd_boolean
comp_unit_maybe_decode_line_info (struct comp_unit
*,
2812 struct dwarf2_debug
*);
2815 find_abstract_instance (struct comp_unit
* unit
,
2816 bfd_byte
* orig_info_ptr
,
2817 struct attribute
* attr_ptr
,
2818 const char ** pname
,
2819 bfd_boolean
* is_linkage
,
2820 char ** filename_ptr
,
2821 int * linenumber_ptr
)
2823 bfd
*abfd
= unit
->abfd
;
2825 bfd_byte
*info_ptr_end
;
2826 unsigned int abbrev_number
, bytes_read
, i
;
2827 struct abbrev_info
*abbrev
;
2828 bfd_uint64_t die_ref
= attr_ptr
->u
.val
;
2829 struct attribute attr
;
2830 const char *name
= NULL
;
2832 /* DW_FORM_ref_addr can reference an entry in a different CU. It
2833 is an offset from the .debug_info section, not the current CU. */
2834 if (attr_ptr
->form
== DW_FORM_ref_addr
)
2836 /* We only support DW_FORM_ref_addr within the same file, so
2837 any relocations should be resolved already. Check this by
2838 testing for a zero die_ref; There can't be a valid reference
2839 to the header of a .debug_info section.
2840 DW_FORM_ref_addr is an offset relative to .debug_info.
2841 Normally when using the GNU linker this is accomplished by
2842 emitting a symbolic reference to a label, because .debug_info
2843 sections are linked at zero. When there are multiple section
2844 groups containing .debug_info, as there might be in a
2845 relocatable object file, it would be reasonable to assume that
2846 a symbolic reference to a label in any .debug_info section
2847 might be used. Since we lay out multiple .debug_info
2848 sections at non-zero VMAs (see place_sections), and read
2849 them contiguously into stash->info_ptr_memory, that means
2850 the reference is relative to stash->info_ptr_memory. */
2853 info_ptr
= unit
->stash
->info_ptr_memory
;
2854 info_ptr_end
= unit
->stash
->info_ptr_end
;
2855 total
= info_ptr_end
- info_ptr
;
2858 else if (die_ref
>= total
)
2861 (_("DWARF error: invalid abstract instance DIE ref"));
2862 bfd_set_error (bfd_error_bad_value
);
2865 info_ptr
+= die_ref
;
2867 /* Now find the CU containing this pointer. */
2868 if (info_ptr
>= unit
->info_ptr_unit
&& info_ptr
< unit
->end_ptr
)
2869 info_ptr_end
= unit
->end_ptr
;
2872 /* Check other CUs to see if they contain the abbrev. */
2873 struct comp_unit
* u
;
2875 for (u
= unit
->prev_unit
; u
!= NULL
; u
= u
->prev_unit
)
2876 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
2880 for (u
= unit
->next_unit
; u
!= NULL
; u
= u
->next_unit
)
2881 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
2886 u
= stash_comp_unit (unit
->stash
);
2889 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
2897 (_("DWARF error: unable to locate abstract instance DIE ref %"
2898 PRIu64
), (uint64_t) die_ref
);
2899 bfd_set_error (bfd_error_bad_value
);
2903 info_ptr_end
= unit
->end_ptr
;
2906 else if (attr_ptr
->form
== DW_FORM_GNU_ref_alt
)
2908 info_ptr
= read_alt_indirect_ref (unit
, die_ref
);
2909 if (info_ptr
== NULL
)
2912 (_("DWARF error: unable to read alt ref %" PRIu64
),
2913 (uint64_t) die_ref
);
2914 bfd_set_error (bfd_error_bad_value
);
2917 info_ptr_end
= (unit
->stash
->alt_dwarf_info_buffer
2918 + unit
->stash
->alt_dwarf_info_size
);
2920 /* FIXME: Do we need to locate the correct CU, in a similar
2921 fashion to the code in the DW_FORM_ref_addr case above ? */
2925 /* DW_FORM_ref1, DW_FORM_ref2, DW_FORM_ref4, DW_FORM_ref8 or
2926 DW_FORM_ref_udata. These are all references relative to the
2927 start of the current CU. */
2930 info_ptr
= unit
->info_ptr_unit
;
2931 info_ptr_end
= unit
->end_ptr
;
2932 total
= info_ptr_end
- info_ptr
;
2933 if (!die_ref
|| die_ref
>= total
)
2936 (_("DWARF error: invalid abstract instance DIE ref"));
2937 bfd_set_error (bfd_error_bad_value
);
2940 info_ptr
+= die_ref
;
2943 abbrev_number
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
2944 FALSE
, info_ptr_end
);
2945 info_ptr
+= bytes_read
;
2949 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
2953 (_("DWARF error: could not find abbrev number %u"), abbrev_number
);
2954 bfd_set_error (bfd_error_bad_value
);
2959 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
2961 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
,
2962 info_ptr
, info_ptr_end
);
2963 if (info_ptr
== NULL
)
2965 /* It doesn't ever make sense for DW_AT_specification to
2966 refer to the same DIE. Stop simple recursion. */
2967 if (info_ptr
== orig_info_ptr
)
2970 (_("DWARF error: abstract instance recursion detected"));
2971 bfd_set_error (bfd_error_bad_value
);
2977 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2979 if (name
== NULL
&& is_str_attr (attr
.form
))
2982 if (non_mangled (unit
->lang
))
2986 case DW_AT_specification
:
2987 if (!find_abstract_instance (unit
, info_ptr
, &attr
,
2989 filename_ptr
, linenumber_ptr
))
2992 case DW_AT_linkage_name
:
2993 case DW_AT_MIPS_linkage_name
:
2994 /* PR 16949: Corrupt debug info can place
2995 non-string forms into these attributes. */
2996 if (is_str_attr (attr
.form
))
3002 case DW_AT_decl_file
:
3003 if (!comp_unit_maybe_decode_line_info (unit
, unit
->stash
))
3005 *filename_ptr
= concat_filename (unit
->line_table
,
3008 case DW_AT_decl_line
:
3009 *linenumber_ptr
= attr
.u
.val
;
3022 read_rangelist (struct comp_unit
*unit
, struct arange
*arange
,
3023 bfd_uint64_t offset
)
3025 bfd_byte
*ranges_ptr
;
3026 bfd_byte
*ranges_end
;
3027 bfd_vma base_address
= unit
->base_address
;
3029 if (! unit
->stash
->dwarf_ranges_buffer
)
3031 if (! read_debug_ranges (unit
))
3035 ranges_ptr
= unit
->stash
->dwarf_ranges_buffer
+ offset
;
3036 if (ranges_ptr
< unit
->stash
->dwarf_ranges_buffer
)
3038 ranges_end
= unit
->stash
->dwarf_ranges_buffer
+ unit
->stash
->dwarf_ranges_size
;
3045 /* PR 17512: file: 62cada7d. */
3046 if (ranges_ptr
+ 2 * unit
->addr_size
> ranges_end
)
3049 low_pc
= read_address (unit
, ranges_ptr
, ranges_end
);
3050 ranges_ptr
+= unit
->addr_size
;
3051 high_pc
= read_address (unit
, ranges_ptr
, ranges_end
);
3052 ranges_ptr
+= unit
->addr_size
;
3054 if (low_pc
== 0 && high_pc
== 0)
3056 if (low_pc
== -1UL && high_pc
!= -1UL)
3057 base_address
= high_pc
;
3060 if (!arange_add (unit
, arange
,
3061 base_address
+ low_pc
, base_address
+ high_pc
))
3068 /* DWARF2 Compilation unit functions. */
3070 /* Scan over each die in a comp. unit looking for functions to add
3071 to the function table and variables to the variable table. */
3074 scan_unit_for_symbols (struct comp_unit
*unit
)
3076 bfd
*abfd
= unit
->abfd
;
3077 bfd_byte
*info_ptr
= unit
->first_child_die_ptr
;
3078 bfd_byte
*info_ptr_end
= unit
->end_ptr
;
3079 int nesting_level
= 0;
3080 struct nest_funcinfo
{
3081 struct funcinfo
*func
;
3083 int nested_funcs_size
;
3085 /* Maintain a stack of in-scope functions and inlined functions, which we
3086 can use to set the caller_func field. */
3087 nested_funcs_size
= 32;
3088 nested_funcs
= (struct nest_funcinfo
*)
3089 bfd_malloc (nested_funcs_size
* sizeof (*nested_funcs
));
3090 if (nested_funcs
== NULL
)
3092 nested_funcs
[nesting_level
].func
= 0;
3094 while (nesting_level
>= 0)
3096 unsigned int abbrev_number
, bytes_read
, i
;
3097 struct abbrev_info
*abbrev
;
3098 struct attribute attr
;
3099 struct funcinfo
*func
;
3100 struct varinfo
*var
;
3102 bfd_vma high_pc
= 0;
3103 bfd_boolean high_pc_relative
= FALSE
;
3105 /* PR 17512: file: 9f405d9d. */
3106 if (info_ptr
>= info_ptr_end
)
3109 abbrev_number
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
3110 FALSE
, info_ptr_end
);
3111 info_ptr
+= bytes_read
;
3113 if (! abbrev_number
)
3119 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
3122 static unsigned int previous_failed_abbrev
= -1U;
3124 /* Avoid multiple reports of the same missing abbrev. */
3125 if (abbrev_number
!= previous_failed_abbrev
)
3128 (_("DWARF error: could not find abbrev number %u"),
3130 previous_failed_abbrev
= abbrev_number
;
3132 bfd_set_error (bfd_error_bad_value
);
3137 if (abbrev
->tag
== DW_TAG_subprogram
3138 || abbrev
->tag
== DW_TAG_entry_point
3139 || abbrev
->tag
== DW_TAG_inlined_subroutine
)
3141 bfd_size_type amt
= sizeof (struct funcinfo
);
3142 func
= (struct funcinfo
*) bfd_zalloc (abfd
, amt
);
3145 func
->tag
= abbrev
->tag
;
3146 func
->prev_func
= unit
->function_table
;
3147 unit
->function_table
= func
;
3148 unit
->number_of_functions
++;
3149 BFD_ASSERT (!unit
->cached
);
3151 if (func
->tag
== DW_TAG_inlined_subroutine
)
3152 for (i
= nesting_level
; i
-- != 0; )
3153 if (nested_funcs
[i
].func
)
3155 func
->caller_func
= nested_funcs
[i
].func
;
3158 nested_funcs
[nesting_level
].func
= func
;
3163 if (abbrev
->tag
== DW_TAG_variable
)
3165 bfd_size_type amt
= sizeof (struct varinfo
);
3166 var
= (struct varinfo
*) bfd_zalloc (abfd
, amt
);
3169 var
->tag
= abbrev
->tag
;
3171 var
->prev_var
= unit
->variable_table
;
3172 unit
->variable_table
= var
;
3173 /* PR 18205: Missing debug information can cause this
3174 var to be attached to an already cached unit. */
3177 /* No inline function in scope at this nesting level. */
3178 nested_funcs
[nesting_level
].func
= 0;
3181 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3183 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
],
3184 unit
, info_ptr
, info_ptr_end
);
3185 if (info_ptr
== NULL
)
3192 case DW_AT_call_file
:
3193 func
->caller_file
= concat_filename (unit
->line_table
,
3197 case DW_AT_call_line
:
3198 func
->caller_line
= attr
.u
.val
;
3201 case DW_AT_abstract_origin
:
3202 case DW_AT_specification
:
3203 if (!find_abstract_instance (unit
, info_ptr
, &attr
,
3212 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
3214 if (func
->name
== NULL
&& is_str_attr (attr
.form
))
3216 func
->name
= attr
.u
.str
;
3217 if (non_mangled (unit
->lang
))
3218 func
->is_linkage
= TRUE
;
3222 case DW_AT_linkage_name
:
3223 case DW_AT_MIPS_linkage_name
:
3224 /* PR 16949: Corrupt debug info can place
3225 non-string forms into these attributes. */
3226 if (is_str_attr (attr
.form
))
3228 func
->name
= attr
.u
.str
;
3229 func
->is_linkage
= TRUE
;
3234 low_pc
= attr
.u
.val
;
3238 high_pc
= attr
.u
.val
;
3239 high_pc_relative
= attr
.form
!= DW_FORM_addr
;
3243 if (!read_rangelist (unit
, &func
->arange
, attr
.u
.val
))
3247 case DW_AT_decl_file
:
3248 func
->file
= concat_filename (unit
->line_table
,
3252 case DW_AT_decl_line
:
3253 func
->line
= attr
.u
.val
;
3265 if (is_str_attr (attr
.form
))
3266 var
->name
= attr
.u
.str
;
3269 case DW_AT_decl_file
:
3270 var
->file
= concat_filename (unit
->line_table
,
3274 case DW_AT_decl_line
:
3275 var
->line
= attr
.u
.val
;
3278 case DW_AT_external
:
3279 if (attr
.u
.val
!= 0)
3283 case DW_AT_location
:
3287 case DW_FORM_block1
:
3288 case DW_FORM_block2
:
3289 case DW_FORM_block4
:
3290 case DW_FORM_exprloc
:
3291 if (attr
.u
.blk
->data
!= NULL
3292 && *attr
.u
.blk
->data
== DW_OP_addr
)
3296 /* Verify that DW_OP_addr is the only opcode in the
3297 location, in which case the block size will be 1
3298 plus the address size. */
3299 /* ??? For TLS variables, gcc can emit
3300 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
3301 which we don't handle here yet. */
3302 if (attr
.u
.blk
->size
== unit
->addr_size
+ 1U)
3303 var
->addr
= bfd_get (unit
->addr_size
* 8,
3305 attr
.u
.blk
->data
+ 1);
3320 if (high_pc_relative
)
3323 if (func
&& high_pc
!= 0)
3325 if (!arange_add (unit
, &func
->arange
, low_pc
, high_pc
))
3329 if (abbrev
->has_children
)
3333 if (nesting_level
>= nested_funcs_size
)
3335 struct nest_funcinfo
*tmp
;
3337 nested_funcs_size
*= 2;
3338 tmp
= (struct nest_funcinfo
*)
3339 bfd_realloc (nested_funcs
,
3340 nested_funcs_size
* sizeof (*nested_funcs
));
3345 nested_funcs
[nesting_level
].func
= 0;
3349 free (nested_funcs
);
3353 free (nested_funcs
);
3357 /* Parse a DWARF2 compilation unit starting at INFO_PTR. UNIT_LENGTH
3358 includes the compilation unit header that proceeds the DIE's, but
3359 does not include the length field that precedes each compilation
3360 unit header. END_PTR points one past the end of this comp unit.
3361 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
3363 This routine does not read the whole compilation unit; only enough
3364 to get to the line number information for the compilation unit. */
3366 static struct comp_unit
*
3367 parse_comp_unit (struct dwarf2_debug
*stash
,
3368 bfd_vma unit_length
,
3369 bfd_byte
*info_ptr_unit
,
3370 unsigned int offset_size
)
3372 struct comp_unit
* unit
;
3373 unsigned int version
;
3374 bfd_uint64_t abbrev_offset
= 0;
3375 /* Initialize it just to avoid a GCC false warning. */
3376 unsigned int addr_size
= -1;
3377 struct abbrev_info
** abbrevs
;
3378 unsigned int abbrev_number
, bytes_read
, i
;
3379 struct abbrev_info
*abbrev
;
3380 struct attribute attr
;
3381 bfd_byte
*info_ptr
= stash
->info_ptr
;
3382 bfd_byte
*end_ptr
= info_ptr
+ unit_length
;
3385 bfd_vma high_pc
= 0;
3386 bfd
*abfd
= stash
->bfd_ptr
;
3387 bfd_boolean high_pc_relative
= FALSE
;
3388 enum dwarf_unit_type unit_type
;
3390 version
= read_2_bytes (abfd
, info_ptr
, end_ptr
);
3392 if (version
< 2 || version
> 5)
3394 /* PR 19872: A version number of 0 probably means that there is padding
3395 at the end of the .debug_info section. Gold puts it there when
3396 performing an incremental link, for example. So do not generate
3397 an error, just return a NULL. */
3401 (_("DWARF error: found dwarf version '%u', this reader"
3402 " only handles version 2, 3, 4 and 5 information"), version
);
3403 bfd_set_error (bfd_error_bad_value
);
3409 unit_type
= DW_UT_compile
;
3412 unit_type
= read_1_byte (abfd
, info_ptr
, end_ptr
);
3415 addr_size
= read_1_byte (abfd
, info_ptr
, end_ptr
);
3419 BFD_ASSERT (offset_size
== 4 || offset_size
== 8);
3420 if (offset_size
== 4)
3421 abbrev_offset
= read_4_bytes (abfd
, info_ptr
, end_ptr
);
3423 abbrev_offset
= read_8_bytes (abfd
, info_ptr
, end_ptr
);
3424 info_ptr
+= offset_size
;
3428 addr_size
= read_1_byte (abfd
, info_ptr
, end_ptr
);
3432 if (unit_type
== DW_UT_type
)
3434 /* Skip type signature. */
3437 /* Skip type offset. */
3438 info_ptr
+= offset_size
;
3441 if (addr_size
> sizeof (bfd_vma
))
3444 /* xgettext: c-format */
3445 (_("DWARF error: found address size '%u', this reader"
3446 " can not handle sizes greater than '%u'"),
3448 (unsigned int) sizeof (bfd_vma
));
3449 bfd_set_error (bfd_error_bad_value
);
3453 if (addr_size
!= 2 && addr_size
!= 4 && addr_size
!= 8)
3456 ("DWARF error: found address size '%u', this reader"
3457 " can only handle address sizes '2', '4' and '8'", addr_size
);
3458 bfd_set_error (bfd_error_bad_value
);
3462 /* Read the abbrevs for this compilation unit into a table. */
3463 abbrevs
= read_abbrevs (abfd
, abbrev_offset
, stash
);
3467 abbrev_number
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
3469 info_ptr
+= bytes_read
;
3470 if (! abbrev_number
)
3472 /* PR 19872: An abbrev number of 0 probably means that there is padding
3473 at the end of the .debug_abbrev section. Gold puts it there when
3474 performing an incremental link, for example. So do not generate
3475 an error, just return a NULL. */
3479 abbrev
= lookup_abbrev (abbrev_number
, abbrevs
);
3482 _bfd_error_handler (_("DWARF error: could not find abbrev number %u"),
3484 bfd_set_error (bfd_error_bad_value
);
3488 amt
= sizeof (struct comp_unit
);
3489 unit
= (struct comp_unit
*) bfd_zalloc (abfd
, amt
);
3493 unit
->version
= version
;
3494 unit
->addr_size
= addr_size
;
3495 unit
->offset_size
= offset_size
;
3496 unit
->abbrevs
= abbrevs
;
3497 unit
->end_ptr
= end_ptr
;
3498 unit
->stash
= stash
;
3499 unit
->info_ptr_unit
= info_ptr_unit
;
3501 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3503 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
, end_ptr
);
3504 if (info_ptr
== NULL
)
3507 /* Store the data if it is of an attribute we want to keep in a
3508 partial symbol table. */
3511 case DW_AT_stmt_list
:
3513 unit
->line_offset
= attr
.u
.val
;
3517 if (is_str_attr (attr
.form
))
3518 unit
->name
= attr
.u
.str
;
3522 low_pc
= attr
.u
.val
;
3523 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
3524 this is the base address to use when reading location
3525 lists or range lists. */
3526 if (abbrev
->tag
== DW_TAG_compile_unit
)
3527 unit
->base_address
= low_pc
;
3531 high_pc
= attr
.u
.val
;
3532 high_pc_relative
= attr
.form
!= DW_FORM_addr
;
3536 if (!read_rangelist (unit
, &unit
->arange
, attr
.u
.val
))
3540 case DW_AT_comp_dir
:
3542 char *comp_dir
= attr
.u
.str
;
3544 /* PR 17512: file: 1fe726be. */
3545 if (! is_str_attr (attr
.form
))
3548 (_("DWARF error: DW_AT_comp_dir attribute encountered with a non-string form"));
3554 /* Irix 6.2 native cc prepends <machine>.: to the compilation
3555 directory, get rid of it. */
3556 char *cp
= strchr (comp_dir
, ':');
3558 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
3561 unit
->comp_dir
= comp_dir
;
3565 case DW_AT_language
:
3566 unit
->lang
= attr
.u
.val
;
3573 if (high_pc_relative
)
3577 if (!arange_add (unit
, &unit
->arange
, low_pc
, high_pc
))
3581 unit
->first_child_die_ptr
= info_ptr
;
3585 /* Return TRUE if UNIT may contain the address given by ADDR. When
3586 there are functions written entirely with inline asm statements, the
3587 range info in the compilation unit header may not be correct. We
3588 need to consult the line info table to see if a compilation unit
3589 really contains the given address. */
3592 comp_unit_contains_address (struct comp_unit
*unit
, bfd_vma addr
)
3594 struct arange
*arange
;
3599 arange
= &unit
->arange
;
3602 if (addr
>= arange
->low
&& addr
< arange
->high
)
3604 arange
= arange
->next
;
3611 /* If UNIT contains ADDR, set the output parameters to the values for
3612 the line containing ADDR. The output parameters, FILENAME_PTR,
3613 FUNCTION_PTR, and LINENUMBER_PTR, are pointers to the objects
3616 Returns the range of addresses covered by the entry that was used
3617 to fill in *LINENUMBER_PTR or 0 if it was not filled in. */
3620 comp_unit_find_nearest_line (struct comp_unit
*unit
,
3622 const char **filename_ptr
,
3623 struct funcinfo
**function_ptr
,
3624 unsigned int *linenumber_ptr
,
3625 unsigned int *discriminator_ptr
,
3626 struct dwarf2_debug
*stash
)
3630 if (!comp_unit_maybe_decode_line_info (unit
, stash
))
3633 *function_ptr
= NULL
;
3634 func_p
= lookup_address_in_function_table (unit
, addr
, function_ptr
);
3635 if (func_p
&& (*function_ptr
)->tag
== DW_TAG_inlined_subroutine
)
3636 stash
->inliner_chain
= *function_ptr
;
3638 return lookup_address_in_line_info_table (unit
->line_table
, addr
,
3644 /* Check to see if line info is already decoded in a comp_unit.
3645 If not, decode it. Returns TRUE if no errors were encountered;
3649 comp_unit_maybe_decode_line_info (struct comp_unit
*unit
,
3650 struct dwarf2_debug
*stash
)
3655 if (! unit
->line_table
)
3657 if (! unit
->stmtlist
)
3663 unit
->line_table
= decode_line_info (unit
, stash
);
3665 if (! unit
->line_table
)
3671 if (unit
->first_child_die_ptr
< unit
->end_ptr
3672 && ! scan_unit_for_symbols (unit
))
3682 /* If UNIT contains SYM at ADDR, set the output parameters to the
3683 values for the line containing SYM. The output parameters,
3684 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
3687 Return TRUE if UNIT contains SYM, and no errors were encountered;
3691 comp_unit_find_line (struct comp_unit
*unit
,
3694 const char **filename_ptr
,
3695 unsigned int *linenumber_ptr
,
3696 struct dwarf2_debug
*stash
)
3698 if (!comp_unit_maybe_decode_line_info (unit
, stash
))
3701 if (sym
->flags
& BSF_FUNCTION
)
3702 return lookup_symbol_in_function_table (unit
, sym
, addr
,
3706 return lookup_symbol_in_variable_table (unit
, sym
, addr
,
3711 static struct funcinfo
*
3712 reverse_funcinfo_list (struct funcinfo
*head
)
3714 struct funcinfo
*rhead
;
3715 struct funcinfo
*temp
;
3717 for (rhead
= NULL
; head
; head
= temp
)
3719 temp
= head
->prev_func
;
3720 head
->prev_func
= rhead
;
3726 static struct varinfo
*
3727 reverse_varinfo_list (struct varinfo
*head
)
3729 struct varinfo
*rhead
;
3730 struct varinfo
*temp
;
3732 for (rhead
= NULL
; head
; head
= temp
)
3734 temp
= head
->prev_var
;
3735 head
->prev_var
= rhead
;
3741 /* Extract all interesting funcinfos and varinfos of a compilation
3742 unit into hash tables for faster lookup. Returns TRUE if no
3743 errors were enountered; FALSE otherwise. */
3746 comp_unit_hash_info (struct dwarf2_debug
*stash
,
3747 struct comp_unit
*unit
,
3748 struct info_hash_table
*funcinfo_hash_table
,
3749 struct info_hash_table
*varinfo_hash_table
)
3751 struct funcinfo
* each_func
;
3752 struct varinfo
* each_var
;
3753 bfd_boolean okay
= TRUE
;
3755 BFD_ASSERT (stash
->info_hash_status
!= STASH_INFO_HASH_DISABLED
);
3757 if (!comp_unit_maybe_decode_line_info (unit
, stash
))
3760 BFD_ASSERT (!unit
->cached
);
3762 /* To preserve the original search order, we went to visit the function
3763 infos in the reversed order of the list. However, making the list
3764 bi-directional use quite a bit of extra memory. So we reverse
3765 the list first, traverse the list in the now reversed order and
3766 finally reverse the list again to get back the original order. */
3767 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
3768 for (each_func
= unit
->function_table
;
3770 each_func
= each_func
->prev_func
)
3772 /* Skip nameless functions. */
3773 if (each_func
->name
)
3774 /* There is no need to copy name string into hash table as
3775 name string is either in the dwarf string buffer or
3776 info in the stash. */
3777 okay
= insert_info_hash_table (funcinfo_hash_table
, each_func
->name
,
3778 (void*) each_func
, FALSE
);
3780 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
3784 /* We do the same for variable infos. */
3785 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
3786 for (each_var
= unit
->variable_table
;
3788 each_var
= each_var
->prev_var
)
3790 /* Skip stack vars and vars with no files or names. */
3791 if (each_var
->stack
== 0
3792 && each_var
->file
!= NULL
3793 && each_var
->name
!= NULL
)
3794 /* There is no need to copy name string into hash table as
3795 name string is either in the dwarf string buffer or
3796 info in the stash. */
3797 okay
= insert_info_hash_table (varinfo_hash_table
, each_var
->name
,
3798 (void*) each_var
, FALSE
);
3801 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
3802 unit
->cached
= TRUE
;
3806 /* Locate a section in a BFD containing debugging info. The search starts
3807 from the section after AFTER_SEC, or from the first section in the BFD if
3808 AFTER_SEC is NULL. The search works by examining the names of the
3809 sections. There are three permissiable names. The first two are given
3810 by DEBUG_SECTIONS[debug_info] (whose standard DWARF2 names are .debug_info
3811 and .zdebug_info). The third is a prefix .gnu.linkonce.wi.
3812 This is a variation on the .debug_info section which has a checksum
3813 describing the contents appended onto the name. This allows the linker to
3814 identify and discard duplicate debugging sections for different
3815 compilation units. */
3816 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
3819 find_debug_info (bfd
*abfd
, const struct dwarf_debug_section
*debug_sections
,
3820 asection
*after_sec
)
3825 if (after_sec
== NULL
)
3827 look
= debug_sections
[debug_info
].uncompressed_name
;
3828 msec
= bfd_get_section_by_name (abfd
, look
);
3832 look
= debug_sections
[debug_info
].compressed_name
;
3835 msec
= bfd_get_section_by_name (abfd
, look
);
3840 for (msec
= abfd
->sections
; msec
!= NULL
; msec
= msec
->next
)
3841 if (CONST_STRNEQ (msec
->name
, GNU_LINKONCE_INFO
))
3847 for (msec
= after_sec
->next
; msec
!= NULL
; msec
= msec
->next
)
3849 look
= debug_sections
[debug_info
].uncompressed_name
;
3850 if (strcmp (msec
->name
, look
) == 0)
3853 look
= debug_sections
[debug_info
].compressed_name
;
3854 if (look
!= NULL
&& strcmp (msec
->name
, look
) == 0)
3857 if (CONST_STRNEQ (msec
->name
, GNU_LINKONCE_INFO
))
3864 /* Transfer VMAs from object file to separate debug file. */
3867 set_debug_vma (bfd
*orig_bfd
, bfd
*debug_bfd
)
3871 for (s
= orig_bfd
->sections
, d
= debug_bfd
->sections
;
3872 s
!= NULL
&& d
!= NULL
;
3873 s
= s
->next
, d
= d
->next
)
3875 if ((d
->flags
& SEC_DEBUGGING
) != 0)
3877 /* ??? Assumes 1-1 correspondence between sections in the
3879 if (strcmp (s
->name
, d
->name
) == 0)
3881 d
->output_section
= s
->output_section
;
3882 d
->output_offset
= s
->output_offset
;
3888 /* Unset vmas for adjusted sections in STASH. */
3891 unset_sections (struct dwarf2_debug
*stash
)
3894 struct adjusted_section
*p
;
3896 i
= stash
->adjusted_section_count
;
3897 p
= stash
->adjusted_sections
;
3898 for (; i
> 0; i
--, p
++)
3899 p
->section
->vma
= 0;
3902 /* Set VMAs for allocated and .debug_info sections in ORIG_BFD, a
3903 relocatable object file. VMAs are normally all zero in relocatable
3904 object files, so if we want to distinguish locations in sections by
3905 address we need to set VMAs so the sections do not overlap. We
3906 also set VMA on .debug_info so that when we have multiple
3907 .debug_info sections (or the linkonce variant) they also do not
3908 overlap. The multiple .debug_info sections make up a single
3909 logical section. ??? We should probably do the same for other
3913 place_sections (bfd
*orig_bfd
, struct dwarf2_debug
*stash
)
3916 struct adjusted_section
*p
;
3918 const char *debug_info_name
;
3920 if (stash
->adjusted_section_count
!= 0)
3922 i
= stash
->adjusted_section_count
;
3923 p
= stash
->adjusted_sections
;
3924 for (; i
> 0; i
--, p
++)
3925 p
->section
->vma
= p
->adj_vma
;
3929 debug_info_name
= stash
->debug_sections
[debug_info
].uncompressed_name
;
3936 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
3940 if ((sect
->output_section
!= NULL
3941 && sect
->output_section
!= sect
3942 && (sect
->flags
& SEC_DEBUGGING
) == 0)
3946 is_debug_info
= (strcmp (sect
->name
, debug_info_name
) == 0
3947 || CONST_STRNEQ (sect
->name
, GNU_LINKONCE_INFO
));
3949 if (!((sect
->flags
& SEC_ALLOC
) != 0 && abfd
== orig_bfd
)
3955 if (abfd
== stash
->bfd_ptr
)
3957 abfd
= stash
->bfd_ptr
;
3961 stash
->adjusted_section_count
= -1;
3964 bfd_vma last_vma
= 0, last_dwarf
= 0;
3965 bfd_size_type amt
= i
* sizeof (struct adjusted_section
);
3967 p
= (struct adjusted_section
*) bfd_malloc (amt
);
3971 stash
->adjusted_sections
= p
;
3972 stash
->adjusted_section_count
= i
;
3979 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
3984 if ((sect
->output_section
!= NULL
3985 && sect
->output_section
!= sect
3986 && (sect
->flags
& SEC_DEBUGGING
) == 0)
3990 is_debug_info
= (strcmp (sect
->name
, debug_info_name
) == 0
3991 || CONST_STRNEQ (sect
->name
, GNU_LINKONCE_INFO
));
3993 if (!((sect
->flags
& SEC_ALLOC
) != 0 && abfd
== orig_bfd
)
3997 sz
= sect
->rawsize
? sect
->rawsize
: sect
->size
;
4001 BFD_ASSERT (sect
->alignment_power
== 0);
4002 sect
->vma
= last_dwarf
;
4007 /* Align the new address to the current section
4009 last_vma
= ((last_vma
4010 + ~(-((bfd_vma
) 1 << sect
->alignment_power
)))
4011 & (-((bfd_vma
) 1 << sect
->alignment_power
)));
4012 sect
->vma
= last_vma
;
4017 p
->adj_vma
= sect
->vma
;
4020 if (abfd
== stash
->bfd_ptr
)
4022 abfd
= stash
->bfd_ptr
;
4026 if (orig_bfd
!= stash
->bfd_ptr
)
4027 set_debug_vma (orig_bfd
, stash
->bfd_ptr
);
4032 /* Look up a funcinfo by name using the given info hash table. If found,
4033 also update the locations pointed to by filename_ptr and linenumber_ptr.
4035 This function returns TRUE if a funcinfo that matches the given symbol
4036 and address is found with any error; otherwise it returns FALSE. */
4039 info_hash_lookup_funcinfo (struct info_hash_table
*hash_table
,
4042 const char **filename_ptr
,
4043 unsigned int *linenumber_ptr
)
4045 struct funcinfo
* each_func
;
4046 struct funcinfo
* best_fit
= NULL
;
4047 bfd_vma best_fit_len
= 0;
4048 struct info_list_node
*node
;
4049 struct arange
*arange
;
4050 const char *name
= bfd_asymbol_name (sym
);
4051 asection
*sec
= bfd_get_section (sym
);
4053 for (node
= lookup_info_hash_table (hash_table
, name
);
4057 each_func
= (struct funcinfo
*) node
->info
;
4058 for (arange
= &each_func
->arange
;
4060 arange
= arange
->next
)
4062 if ((!each_func
->sec
|| each_func
->sec
== sec
)
4063 && addr
>= arange
->low
4064 && addr
< arange
->high
4066 || arange
->high
- arange
->low
< best_fit_len
))
4068 best_fit
= each_func
;
4069 best_fit_len
= arange
->high
- arange
->low
;
4076 best_fit
->sec
= sec
;
4077 *filename_ptr
= best_fit
->file
;
4078 *linenumber_ptr
= best_fit
->line
;
4085 /* Look up a varinfo by name using the given info hash table. If found,
4086 also update the locations pointed to by filename_ptr and linenumber_ptr.
4088 This function returns TRUE if a varinfo that matches the given symbol
4089 and address is found with any error; otherwise it returns FALSE. */
4092 info_hash_lookup_varinfo (struct info_hash_table
*hash_table
,
4095 const char **filename_ptr
,
4096 unsigned int *linenumber_ptr
)
4098 const char *name
= bfd_asymbol_name (sym
);
4099 asection
*sec
= bfd_get_section (sym
);
4100 struct varinfo
* each
;
4101 struct info_list_node
*node
;
4103 for (node
= lookup_info_hash_table (hash_table
, name
);
4107 each
= (struct varinfo
*) node
->info
;
4108 if (each
->addr
== addr
4109 && (!each
->sec
|| each
->sec
== sec
))
4112 *filename_ptr
= each
->file
;
4113 *linenumber_ptr
= each
->line
;
4121 /* Update the funcinfo and varinfo info hash tables if they are
4122 not up to date. Returns TRUE if there is no error; otherwise
4123 returns FALSE and disable the info hash tables. */
4126 stash_maybe_update_info_hash_tables (struct dwarf2_debug
*stash
)
4128 struct comp_unit
*each
;
4130 /* Exit if hash tables are up-to-date. */
4131 if (stash
->all_comp_units
== stash
->hash_units_head
)
4134 if (stash
->hash_units_head
)
4135 each
= stash
->hash_units_head
->prev_unit
;
4137 each
= stash
->last_comp_unit
;
4141 if (!comp_unit_hash_info (stash
, each
, stash
->funcinfo_hash_table
,
4142 stash
->varinfo_hash_table
))
4144 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
4147 each
= each
->prev_unit
;
4150 stash
->hash_units_head
= stash
->all_comp_units
;
4154 /* Check consistency of info hash tables. This is for debugging only. */
4156 static void ATTRIBUTE_UNUSED
4157 stash_verify_info_hash_table (struct dwarf2_debug
*stash
)
4159 struct comp_unit
*each_unit
;
4160 struct funcinfo
*each_func
;
4161 struct varinfo
*each_var
;
4162 struct info_list_node
*node
;
4165 for (each_unit
= stash
->all_comp_units
;
4167 each_unit
= each_unit
->next_unit
)
4169 for (each_func
= each_unit
->function_table
;
4171 each_func
= each_func
->prev_func
)
4173 if (!each_func
->name
)
4175 node
= lookup_info_hash_table (stash
->funcinfo_hash_table
,
4179 while (node
&& !found
)
4181 found
= node
->info
== each_func
;
4187 for (each_var
= each_unit
->variable_table
;
4189 each_var
= each_var
->prev_var
)
4191 if (!each_var
->name
|| !each_var
->file
|| each_var
->stack
)
4193 node
= lookup_info_hash_table (stash
->varinfo_hash_table
,
4197 while (node
&& !found
)
4199 found
= node
->info
== each_var
;
4207 /* Check to see if we want to enable the info hash tables, which consume
4208 quite a bit of memory. Currently we only check the number times
4209 bfd_dwarf2_find_line is called. In the future, we may also want to
4210 take the number of symbols into account. */
4213 stash_maybe_enable_info_hash_tables (bfd
*abfd
, struct dwarf2_debug
*stash
)
4215 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_OFF
);
4217 if (stash
->info_hash_count
++ < STASH_INFO_HASH_TRIGGER
)
4220 /* FIXME: Maybe we should check the reduce_memory_overheads
4221 and optimize fields in the bfd_link_info structure ? */
4223 /* Create hash tables. */
4224 stash
->funcinfo_hash_table
= create_info_hash_table (abfd
);
4225 stash
->varinfo_hash_table
= create_info_hash_table (abfd
);
4226 if (!stash
->funcinfo_hash_table
|| !stash
->varinfo_hash_table
)
4228 /* Turn off info hashes if any allocation above fails. */
4229 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
4232 /* We need a forced update so that the info hash tables will
4233 be created even though there is no compilation unit. That
4234 happens if STASH_INFO_HASH_TRIGGER is 0. */
4235 stash_maybe_update_info_hash_tables (stash
);
4236 stash
->info_hash_status
= STASH_INFO_HASH_ON
;
4239 /* Find the file and line associated with a symbol and address using the
4240 info hash tables of a stash. If there is a match, the function returns
4241 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
4242 otherwise it returns FALSE. */
4245 stash_find_line_fast (struct dwarf2_debug
*stash
,
4248 const char **filename_ptr
,
4249 unsigned int *linenumber_ptr
)
4251 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_ON
);
4253 if (sym
->flags
& BSF_FUNCTION
)
4254 return info_hash_lookup_funcinfo (stash
->funcinfo_hash_table
, sym
, addr
,
4255 filename_ptr
, linenumber_ptr
);
4256 return info_hash_lookup_varinfo (stash
->varinfo_hash_table
, sym
, addr
,
4257 filename_ptr
, linenumber_ptr
);
4260 /* Save current section VMAs. */
4263 save_section_vma (const bfd
*abfd
, struct dwarf2_debug
*stash
)
4268 if (abfd
->section_count
== 0)
4270 stash
->sec_vma
= bfd_malloc (sizeof (*stash
->sec_vma
) * abfd
->section_count
);
4271 if (stash
->sec_vma
== NULL
)
4273 stash
->sec_vma_count
= abfd
->section_count
;
4274 for (i
= 0, s
= abfd
->sections
;
4275 s
!= NULL
&& i
< abfd
->section_count
;
4278 if (s
->output_section
!= NULL
)
4279 stash
->sec_vma
[i
] = s
->output_section
->vma
+ s
->output_offset
;
4281 stash
->sec_vma
[i
] = s
->vma
;
4286 /* Compare current section VMAs against those at the time the stash
4287 was created. If find_nearest_line is used in linker warnings or
4288 errors early in the link process, the debug info stash will be
4289 invalid for later calls. This is because we relocate debug info
4290 sections, so the stashed section contents depend on symbol values,
4291 which in turn depend on section VMAs. */
4294 section_vma_same (const bfd
*abfd
, const struct dwarf2_debug
*stash
)
4299 /* PR 24334: If the number of sections in ABFD has changed between
4300 when the stash was created and now, then we cannot trust the
4301 stashed vma information. */
4302 if (abfd
->section_count
!= stash
->sec_vma_count
)
4305 for (i
= 0, s
= abfd
->sections
;
4306 s
!= NULL
&& i
< abfd
->section_count
;
4311 if (s
->output_section
!= NULL
)
4312 vma
= s
->output_section
->vma
+ s
->output_offset
;
4315 if (vma
!= stash
->sec_vma
[i
])
4321 /* Read debug information from DEBUG_BFD when DEBUG_BFD is specified.
4322 If DEBUG_BFD is not specified, we read debug information from ABFD
4323 or its gnu_debuglink. The results will be stored in PINFO.
4324 The function returns TRUE iff debug information is ready. */
4327 _bfd_dwarf2_slurp_debug_info (bfd
*abfd
, bfd
*debug_bfd
,
4328 const struct dwarf_debug_section
*debug_sections
,
4331 bfd_boolean do_place
)
4333 bfd_size_type amt
= sizeof (struct dwarf2_debug
);
4334 bfd_size_type total_size
;
4336 struct dwarf2_debug
*stash
= (struct dwarf2_debug
*) *pinfo
;
4340 if (stash
->orig_bfd
== abfd
4341 && section_vma_same (abfd
, stash
))
4343 /* Check that we did previously find some debug information
4344 before attempting to make use of it. */
4345 if (stash
->bfd_ptr
!= NULL
)
4347 if (do_place
&& !place_sections (abfd
, stash
))
4354 _bfd_dwarf2_cleanup_debug_info (abfd
, pinfo
);
4355 memset (stash
, 0, amt
);
4359 stash
= (struct dwarf2_debug
*) bfd_zalloc (abfd
, amt
);
4363 stash
->orig_bfd
= abfd
;
4364 stash
->debug_sections
= debug_sections
;
4365 stash
->syms
= symbols
;
4366 if (!save_section_vma (abfd
, stash
))
4371 if (debug_bfd
== NULL
)
4374 msec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
4375 if (msec
== NULL
&& abfd
== debug_bfd
)
4377 char * debug_filename
;
4379 debug_filename
= bfd_follow_build_id_debuglink (abfd
, DEBUGDIR
);
4380 if (debug_filename
== NULL
)
4381 debug_filename
= bfd_follow_gnu_debuglink (abfd
, DEBUGDIR
);
4383 if (debug_filename
== NULL
)
4384 /* No dwarf2 info, and no gnu_debuglink to follow.
4385 Note that at this point the stash has been allocated, but
4386 contains zeros. This lets future calls to this function
4387 fail more quickly. */
4390 debug_bfd
= bfd_openr (debug_filename
, NULL
);
4391 free (debug_filename
);
4392 if (debug_bfd
== NULL
)
4393 /* FIXME: Should we report our failure to follow the debuglink ? */
4396 /* Set BFD_DECOMPRESS to decompress debug sections. */
4397 debug_bfd
->flags
|= BFD_DECOMPRESS
;
4398 if (!bfd_check_format (debug_bfd
, bfd_object
)
4399 || (msec
= find_debug_info (debug_bfd
,
4400 debug_sections
, NULL
)) == NULL
4401 || !bfd_generic_link_read_symbols (debug_bfd
))
4403 bfd_close (debug_bfd
);
4407 symbols
= bfd_get_outsymbols (debug_bfd
);
4408 stash
->syms
= symbols
;
4409 stash
->close_on_cleanup
= TRUE
;
4411 stash
->bfd_ptr
= debug_bfd
;
4414 && !place_sections (abfd
, stash
))
4417 /* There can be more than one DWARF2 info section in a BFD these
4418 days. First handle the easy case when there's only one. If
4419 there's more than one, try case two: none of the sections is
4420 compressed. In that case, read them all in and produce one
4421 large stash. We do this in two passes - in the first pass we
4422 just accumulate the section sizes, and in the second pass we
4423 read in the section's contents. (The allows us to avoid
4424 reallocing the data as we add sections to the stash.) If
4425 some or all sections are compressed, then do things the slow
4426 way, with a bunch of reallocs. */
4428 if (! find_debug_info (debug_bfd
, debug_sections
, msec
))
4430 /* Case 1: only one info section. */
4431 total_size
= msec
->size
;
4432 if (! read_section (debug_bfd
, &stash
->debug_sections
[debug_info
],
4434 &stash
->info_ptr_memory
, &total_size
))
4439 /* Case 2: multiple sections. */
4440 for (total_size
= 0;
4442 msec
= find_debug_info (debug_bfd
, debug_sections
, msec
))
4443 total_size
+= msec
->size
;
4445 stash
->info_ptr_memory
= (bfd_byte
*) bfd_malloc (total_size
);
4446 if (stash
->info_ptr_memory
== NULL
)
4450 for (msec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
4452 msec
= find_debug_info (debug_bfd
, debug_sections
, msec
))
4460 if (!(bfd_simple_get_relocated_section_contents
4461 (debug_bfd
, msec
, stash
->info_ptr_memory
+ total_size
,
4469 stash
->info_ptr
= stash
->info_ptr_memory
;
4470 stash
->info_ptr_end
= stash
->info_ptr
+ total_size
;
4471 stash
->sec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
4472 stash
->sec_info_ptr
= stash
->info_ptr
;
4476 /* Parse the next DWARF2 compilation unit at STASH->INFO_PTR. */
4478 static struct comp_unit
*
4479 stash_comp_unit (struct dwarf2_debug
*stash
)
4481 bfd_size_type length
;
4482 unsigned int offset_size
;
4483 bfd_byte
*info_ptr_unit
= stash
->info_ptr
;
4485 if (stash
->info_ptr
>= stash
->info_ptr_end
)
4488 length
= read_4_bytes (stash
->bfd_ptr
, stash
->info_ptr
,
4489 stash
->info_ptr_end
);
4490 /* A 0xffffff length is the DWARF3 way of indicating
4491 we use 64-bit offsets, instead of 32-bit offsets. */
4492 if (length
== 0xffffffff)
4495 length
= read_8_bytes (stash
->bfd_ptr
, stash
->info_ptr
+ 4,
4496 stash
->info_ptr_end
);
4497 stash
->info_ptr
+= 12;
4499 /* A zero length is the IRIX way of indicating 64-bit offsets,
4500 mostly because the 64-bit length will generally fit in 32
4501 bits, and the endianness helps. */
4502 else if (length
== 0)
4505 length
= read_4_bytes (stash
->bfd_ptr
, stash
->info_ptr
+ 4,
4506 stash
->info_ptr_end
);
4507 stash
->info_ptr
+= 8;
4509 /* In the absence of the hints above, we assume 32-bit DWARF2
4510 offsets even for targets with 64-bit addresses, because:
4511 a) most of the time these targets will not have generated
4512 more than 2Gb of debug info and so will not need 64-bit
4515 b) if they do use 64-bit offsets but they are not using
4516 the size hints that are tested for above then they are
4517 not conforming to the DWARF3 standard anyway. */
4521 stash
->info_ptr
+= 4;
4525 && stash
->info_ptr
+ length
<= stash
->info_ptr_end
4526 && stash
->info_ptr
+ length
> stash
->info_ptr
)
4528 struct comp_unit
*each
= parse_comp_unit (stash
, length
, info_ptr_unit
,
4532 if (stash
->all_comp_units
)
4533 stash
->all_comp_units
->prev_unit
= each
;
4535 stash
->last_comp_unit
= each
;
4537 each
->next_unit
= stash
->all_comp_units
;
4538 stash
->all_comp_units
= each
;
4540 stash
->info_ptr
+= length
;
4542 if ((bfd_size_type
) (stash
->info_ptr
- stash
->sec_info_ptr
)
4543 == stash
->sec
->size
)
4545 stash
->sec
= find_debug_info (stash
->bfd_ptr
,
4546 stash
->debug_sections
,
4548 stash
->sec_info_ptr
= stash
->info_ptr
;
4554 /* Don't trust any of the DWARF info after a corrupted length or
4556 stash
->info_ptr
= stash
->info_ptr_end
;
4560 /* Hash function for an asymbol. */
4563 hash_asymbol (const void *sym
)
4565 const asymbol
*asym
= sym
;
4566 return htab_hash_string (asym
->name
);
4569 /* Equality function for asymbols. */
4572 eq_asymbol (const void *a
, const void *b
)
4574 const asymbol
*sa
= a
;
4575 const asymbol
*sb
= b
;
4576 return strcmp (sa
->name
, sb
->name
) == 0;
4579 /* Scan the debug information in PINFO looking for a DW_TAG_subprogram
4580 abbrev with a DW_AT_low_pc attached to it. Then lookup that same
4581 symbol in SYMBOLS and return the difference between the low_pc and
4582 the symbol's address. Returns 0 if no suitable symbol could be found. */
4585 _bfd_dwarf2_find_symbol_bias (asymbol
** symbols
, void ** pinfo
)
4587 struct dwarf2_debug
*stash
;
4588 struct comp_unit
* unit
;
4590 bfd_signed_vma result
= 0;
4593 stash
= (struct dwarf2_debug
*) *pinfo
;
4595 if (stash
== NULL
|| symbols
== NULL
)
4598 sym_hash
= htab_create_alloc (10, hash_asymbol
, eq_asymbol
,
4599 NULL
, xcalloc
, free
);
4600 for (psym
= symbols
; * psym
!= NULL
; psym
++)
4602 asymbol
* sym
= * psym
;
4604 if (sym
->flags
& BSF_FUNCTION
&& sym
->section
!= NULL
)
4606 void **slot
= htab_find_slot (sym_hash
, sym
, INSERT
);
4611 for (unit
= stash
->all_comp_units
; unit
; unit
= unit
->next_unit
)
4613 struct funcinfo
* func
;
4615 comp_unit_maybe_decode_line_info (unit
, stash
);
4617 for (func
= unit
->function_table
; func
!= NULL
; func
= func
->prev_func
)
4618 if (func
->name
&& func
->arange
.low
)
4620 asymbol search
, *sym
;
4622 /* FIXME: Do we need to scan the aranges looking for the lowest pc value ? */
4624 search
.name
= func
->name
;
4625 sym
= htab_find (sym_hash
, &search
);
4628 result
= ((bfd_signed_vma
) func
->arange
.low
) -
4629 ((bfd_signed_vma
) (sym
->value
+ sym
->section
->vma
));
4636 htab_delete (sym_hash
);
4640 /* Find the source code location of SYMBOL. If SYMBOL is NULL
4641 then find the nearest source code location corresponding to
4642 the address SECTION + OFFSET.
4643 Returns TRUE if the line is found without error and fills in
4644 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
4645 NULL the FUNCTIONNAME_PTR is also filled in.
4646 SYMBOLS contains the symbol table for ABFD.
4647 DEBUG_SECTIONS contains the name of the dwarf debug sections.
4648 field and in the abbreviation offset, or zero to indicate that the
4649 default value should be used. */
4652 _bfd_dwarf2_find_nearest_line (bfd
*abfd
,
4657 const char **filename_ptr
,
4658 const char **functionname_ptr
,
4659 unsigned int *linenumber_ptr
,
4660 unsigned int *discriminator_ptr
,
4661 const struct dwarf_debug_section
*debug_sections
,
4664 /* Read each compilation unit from the section .debug_info, and check
4665 to see if it contains the address we are searching for. If yes,
4666 lookup the address, and return the line number info. If no, go
4667 on to the next compilation unit.
4669 We keep a list of all the previously read compilation units, and
4670 a pointer to the next un-read compilation unit. Check the
4671 previously read units before reading more. */
4672 struct dwarf2_debug
*stash
;
4673 /* What address are we looking for? */
4675 struct comp_unit
* each
;
4676 struct funcinfo
*function
= NULL
;
4677 bfd_boolean found
= FALSE
;
4678 bfd_boolean do_line
;
4680 *filename_ptr
= NULL
;
4681 if (functionname_ptr
!= NULL
)
4682 *functionname_ptr
= NULL
;
4683 *linenumber_ptr
= 0;
4684 if (discriminator_ptr
)
4685 *discriminator_ptr
= 0;
4687 if (! _bfd_dwarf2_slurp_debug_info (abfd
, NULL
, debug_sections
,
4689 (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0))
4692 stash
= (struct dwarf2_debug
*) *pinfo
;
4694 do_line
= symbol
!= NULL
;
4697 BFD_ASSERT (section
== NULL
&& offset
== 0 && functionname_ptr
== NULL
);
4698 section
= bfd_get_section (symbol
);
4699 addr
= symbol
->value
;
4703 BFD_ASSERT (section
!= NULL
&& functionname_ptr
!= NULL
);
4706 /* If we have no SYMBOL but the section we're looking at is not a
4707 code section, then take a look through the list of symbols to see
4708 if we have a symbol at the address we're looking for. If we do
4709 then use this to look up line information. This will allow us to
4710 give file and line results for data symbols. We exclude code
4711 symbols here, if we look up a function symbol and then look up the
4712 line information we'll actually return the line number for the
4713 opening '{' rather than the function definition line. This is
4714 because looking up by symbol uses the line table, in which the
4715 first line for a function is usually the opening '{', while
4716 looking up the function by section + offset uses the
4717 DW_AT_decl_line from the function DW_TAG_subprogram for the line,
4718 which will be the line of the function name. */
4719 if (symbols
!= NULL
&& (section
->flags
& SEC_CODE
) == 0)
4723 for (tmp
= symbols
; (*tmp
) != NULL
; ++tmp
)
4724 if ((*tmp
)->the_bfd
== abfd
4725 && (*tmp
)->section
== section
4726 && (*tmp
)->value
== offset
4727 && ((*tmp
)->flags
& BSF_SECTION_SYM
) == 0)
4731 /* For local symbols, keep going in the hope we find a
4733 if ((symbol
->flags
& BSF_GLOBAL
) != 0)
4739 if (section
->output_section
)
4740 addr
+= section
->output_section
->vma
+ section
->output_offset
;
4742 addr
+= section
->vma
;
4744 /* A null info_ptr indicates that there is no dwarf2 info
4745 (or that an error occured while setting up the stash). */
4746 if (! stash
->info_ptr
)
4749 stash
->inliner_chain
= NULL
;
4751 /* Check the previously read comp. units first. */
4754 /* The info hash tables use quite a bit of memory. We may not want to
4755 always use them. We use some heuristics to decide if and when to
4757 if (stash
->info_hash_status
== STASH_INFO_HASH_OFF
)
4758 stash_maybe_enable_info_hash_tables (abfd
, stash
);
4760 /* Keep info hash table up to date if they are available. Note that we
4761 may disable the hash tables if there is any error duing update. */
4762 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
4763 stash_maybe_update_info_hash_tables (stash
);
4765 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
4767 found
= stash_find_line_fast (stash
, symbol
, addr
, filename_ptr
,
4774 /* Check the previously read comp. units first. */
4775 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
4776 if ((symbol
->flags
& BSF_FUNCTION
) == 0
4777 || each
->arange
.high
== 0
4778 || comp_unit_contains_address (each
, addr
))
4780 found
= comp_unit_find_line (each
, symbol
, addr
, filename_ptr
,
4781 linenumber_ptr
, stash
);
4789 bfd_vma min_range
= (bfd_vma
) -1;
4790 const char * local_filename
= NULL
;
4791 struct funcinfo
*local_function
= NULL
;
4792 unsigned int local_linenumber
= 0;
4793 unsigned int local_discriminator
= 0;
4795 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
4797 bfd_vma range
= (bfd_vma
) -1;
4799 found
= ((each
->arange
.high
== 0
4800 || comp_unit_contains_address (each
, addr
))
4801 && (range
= comp_unit_find_nearest_line (each
, addr
,
4805 & local_discriminator
,
4809 /* PRs 15935 15994: Bogus debug information may have provided us
4810 with an erroneous match. We attempt to counter this by
4811 selecting the match that has the smallest address range
4812 associated with it. (We are assuming that corrupt debug info
4813 will tend to result in extra large address ranges rather than
4814 extra small ranges).
4816 This does mean that we scan through all of the CUs associated
4817 with the bfd each time this function is called. But this does
4818 have the benefit of producing consistent results every time the
4819 function is called. */
4820 if (range
<= min_range
)
4822 if (filename_ptr
&& local_filename
)
4823 * filename_ptr
= local_filename
;
4825 function
= local_function
;
4826 if (discriminator_ptr
&& local_discriminator
)
4827 * discriminator_ptr
= local_discriminator
;
4828 if (local_linenumber
)
4829 * linenumber_ptr
= local_linenumber
;
4835 if (* linenumber_ptr
)
4842 /* Read each remaining comp. units checking each as they are read. */
4843 while ((each
= stash_comp_unit (stash
)) != NULL
)
4845 /* DW_AT_low_pc and DW_AT_high_pc are optional for
4846 compilation units. If we don't have them (i.e.,
4847 unit->high == 0), we need to consult the line info table
4848 to see if a compilation unit contains the given
4851 found
= (((symbol
->flags
& BSF_FUNCTION
) == 0
4852 || each
->arange
.high
== 0
4853 || comp_unit_contains_address (each
, addr
))
4854 && comp_unit_find_line (each
, symbol
, addr
,
4859 found
= ((each
->arange
.high
== 0
4860 || comp_unit_contains_address (each
, addr
))
4861 && comp_unit_find_nearest_line (each
, addr
,
4875 if (!function
->is_linkage
)
4880 fun
= _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
4881 *filename_ptr
? NULL
: filename_ptr
,
4883 sec_vma
= section
->vma
;
4884 if (section
->output_section
!= NULL
)
4885 sec_vma
= section
->output_section
->vma
+ section
->output_offset
;
4887 && fun
->value
+ sec_vma
== function
->arange
.low
)
4888 function
->name
= *functionname_ptr
;
4889 /* Even if we didn't find a linkage name, say that we have
4890 to stop a repeated search of symbols. */
4891 function
->is_linkage
= TRUE
;
4893 *functionname_ptr
= function
->name
;
4895 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
4896 unset_sections (stash
);
4902 _bfd_dwarf2_find_inliner_info (bfd
*abfd ATTRIBUTE_UNUSED
,
4903 const char **filename_ptr
,
4904 const char **functionname_ptr
,
4905 unsigned int *linenumber_ptr
,
4908 struct dwarf2_debug
*stash
;
4910 stash
= (struct dwarf2_debug
*) *pinfo
;
4913 struct funcinfo
*func
= stash
->inliner_chain
;
4915 if (func
&& func
->caller_func
)
4917 *filename_ptr
= func
->caller_file
;
4918 *functionname_ptr
= func
->caller_func
->name
;
4919 *linenumber_ptr
= func
->caller_line
;
4920 stash
->inliner_chain
= func
->caller_func
;
4929 _bfd_dwarf2_cleanup_debug_info (bfd
*abfd
, void **pinfo
)
4931 struct dwarf2_debug
*stash
= (struct dwarf2_debug
*) *pinfo
;
4932 struct comp_unit
*each
;
4934 if (abfd
== NULL
|| stash
== NULL
)
4937 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
4939 struct abbrev_info
**abbrevs
= each
->abbrevs
;
4940 struct funcinfo
*function_table
= each
->function_table
;
4941 struct varinfo
*variable_table
= each
->variable_table
;
4944 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
4946 struct abbrev_info
*abbrev
= abbrevs
[i
];
4950 free (abbrev
->attrs
);
4951 abbrev
= abbrev
->next
;
4955 if (each
->line_table
)
4957 free (each
->line_table
->dirs
);
4958 free (each
->line_table
->files
);
4961 while (function_table
)
4963 if (function_table
->file
)
4965 free (function_table
->file
);
4966 function_table
->file
= NULL
;
4969 if (function_table
->caller_file
)
4971 free (function_table
->caller_file
);
4972 function_table
->caller_file
= NULL
;
4974 function_table
= function_table
->prev_func
;
4977 if (each
->lookup_funcinfo_table
)
4979 free (each
->lookup_funcinfo_table
);
4980 each
->lookup_funcinfo_table
= NULL
;
4983 while (variable_table
)
4985 if (variable_table
->file
)
4987 free (variable_table
->file
);
4988 variable_table
->file
= NULL
;
4991 variable_table
= variable_table
->prev_var
;
4995 if (stash
->funcinfo_hash_table
)
4996 bfd_hash_table_free (&stash
->funcinfo_hash_table
->base
);
4997 if (stash
->varinfo_hash_table
)
4998 bfd_hash_table_free (&stash
->varinfo_hash_table
->base
);
4999 if (stash
->dwarf_abbrev_buffer
)
5000 free (stash
->dwarf_abbrev_buffer
);
5001 if (stash
->dwarf_line_buffer
)
5002 free (stash
->dwarf_line_buffer
);
5003 if (stash
->dwarf_str_buffer
)
5004 free (stash
->dwarf_str_buffer
);
5005 if (stash
->dwarf_line_str_buffer
)
5006 free (stash
->dwarf_line_str_buffer
);
5007 if (stash
->dwarf_ranges_buffer
)
5008 free (stash
->dwarf_ranges_buffer
);
5009 if (stash
->info_ptr_memory
)
5010 free (stash
->info_ptr_memory
);
5011 if (stash
->close_on_cleanup
)
5012 bfd_close (stash
->bfd_ptr
);
5013 if (stash
->alt_dwarf_str_buffer
)
5014 free (stash
->alt_dwarf_str_buffer
);
5015 if (stash
->alt_dwarf_info_buffer
)
5016 free (stash
->alt_dwarf_info_buffer
);
5018 free (stash
->sec_vma
);
5019 if (stash
->adjusted_sections
)
5020 free (stash
->adjusted_sections
);
5021 if (stash
->alt_bfd_ptr
)
5022 bfd_close (stash
->alt_bfd_ptr
);
5025 /* Find the function to a particular section and offset,
5026 for error reporting. */
5029 _bfd_elf_find_function (bfd
*abfd
,
5033 const char **filename_ptr
,
5034 const char **functionname_ptr
)
5036 struct elf_find_function_cache
5038 asection
*last_section
;
5040 const char *filename
;
5041 bfd_size_type func_size
;
5044 if (symbols
== NULL
)
5047 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
5050 cache
= elf_tdata (abfd
)->elf_find_function_cache
;
5053 cache
= bfd_zalloc (abfd
, sizeof (*cache
));
5054 elf_tdata (abfd
)->elf_find_function_cache
= cache
;
5058 if (cache
->last_section
!= section
5059 || cache
->func
== NULL
5060 || offset
< cache
->func
->value
5061 || offset
>= cache
->func
->value
+ cache
->func_size
)
5066 /* ??? Given multiple file symbols, it is impossible to reliably
5067 choose the right file name for global symbols. File symbols are
5068 local symbols, and thus all file symbols must sort before any
5069 global symbols. The ELF spec may be interpreted to say that a
5070 file symbol must sort before other local symbols, but currently
5071 ld -r doesn't do this. So, for ld -r output, it is possible to
5072 make a better choice of file name for local symbols by ignoring
5073 file symbols appearing after a given local symbol. */
5074 enum { nothing_seen
, symbol_seen
, file_after_symbol_seen
} state
;
5075 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5079 state
= nothing_seen
;
5080 cache
->filename
= NULL
;
5082 cache
->func_size
= 0;
5083 cache
->last_section
= section
;
5085 for (p
= symbols
; *p
!= NULL
; p
++)
5091 if ((sym
->flags
& BSF_FILE
) != 0)
5094 if (state
== symbol_seen
)
5095 state
= file_after_symbol_seen
;
5099 size
= bed
->maybe_function_sym (sym
, section
, &code_off
);
5101 && code_off
<= offset
5102 && (code_off
> low_func
5103 || (code_off
== low_func
5104 && size
> cache
->func_size
)))
5107 cache
->func_size
= size
;
5108 cache
->filename
= NULL
;
5109 low_func
= code_off
;
5111 && ((sym
->flags
& BSF_LOCAL
) != 0
5112 || state
!= file_after_symbol_seen
))
5113 cache
->filename
= bfd_asymbol_name (file
);
5115 if (state
== nothing_seen
)
5116 state
= symbol_seen
;
5120 if (cache
->func
== NULL
)
5124 *filename_ptr
= cache
->filename
;
5125 if (functionname_ptr
)
5126 *functionname_ptr
= bfd_asymbol_name (cache
->func
);