2 Copyright (C) 1994-2022 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
85 struct dwarf2_debug_file
87 /* The actual bfd from which debug info was loaded. Might be
88 different to orig_bfd because of gnu_debuglink sections. */
91 /* Pointer to the symbol table. */
94 /* The current info pointer for the .debug_info section being parsed. */
97 /* A pointer to the memory block allocated for .debug_info sections. */
98 bfd_byte
*dwarf_info_buffer
;
100 /* Length of the loaded .debug_info sections. */
101 bfd_size_type dwarf_info_size
;
103 /* Pointer to the .debug_abbrev section loaded into memory. */
104 bfd_byte
*dwarf_abbrev_buffer
;
106 /* Length of the loaded .debug_abbrev section. */
107 bfd_size_type dwarf_abbrev_size
;
109 /* Buffer for decode_line_info. */
110 bfd_byte
*dwarf_line_buffer
;
112 /* Length of the loaded .debug_line section. */
113 bfd_size_type dwarf_line_size
;
115 /* Pointer to the .debug_str section loaded into memory. */
116 bfd_byte
*dwarf_str_buffer
;
118 /* Length of the loaded .debug_str section. */
119 bfd_size_type dwarf_str_size
;
121 /* Pointer to the .debug_line_str section loaded into memory. */
122 bfd_byte
*dwarf_line_str_buffer
;
124 /* Length of the loaded .debug_line_str section. */
125 bfd_size_type dwarf_line_str_size
;
127 /* Pointer to the .debug_ranges section loaded into memory. */
128 bfd_byte
*dwarf_ranges_buffer
;
130 /* Length of the loaded .debug_ranges section. */
131 bfd_size_type dwarf_ranges_size
;
133 /* Pointer to the .debug_rnglists section loaded into memory. */
134 bfd_byte
*dwarf_rnglists_buffer
;
136 /* Length of the loaded .debug_rnglists section. */
137 bfd_size_type dwarf_rnglists_size
;
139 /* A list of all previously read comp_units. */
140 struct comp_unit
*all_comp_units
;
142 /* Last comp unit in list above. */
143 struct comp_unit
*last_comp_unit
;
145 /* Line table at line_offset zero. */
146 struct line_info_table
*line_table
;
148 /* Hash table to map offsets to decoded abbrevs. */
149 htab_t abbrev_offsets
;
154 /* Names of the debug sections. */
155 const struct dwarf_debug_section
*debug_sections
;
157 /* Per-file stuff. */
158 struct dwarf2_debug_file f
, alt
;
160 /* Pointer to the original bfd for which debug was loaded. This is what
161 we use to compare and so check that the cached debug data is still
162 valid - it saves having to possibly dereference the gnu_debuglink each
166 /* If the most recent call to bfd_find_nearest_line was given an
167 address in an inlined function, preserve a pointer into the
168 calling chain for subsequent calls to bfd_find_inliner_info to
170 struct funcinfo
*inliner_chain
;
172 /* Section VMAs at the time the stash was built. */
174 /* Number of sections in the SEC_VMA table. */
175 unsigned int sec_vma_count
;
177 /* Number of sections whose VMA we must adjust. */
178 int adjusted_section_count
;
180 /* Array of sections with adjusted VMA. */
181 struct adjusted_section
*adjusted_sections
;
183 /* Number of times find_line is called. This is used in
184 the heuristic for enabling the info hash tables. */
187 #define STASH_INFO_HASH_TRIGGER 100
189 /* Hash table mapping symbol names to function infos. */
190 struct info_hash_table
*funcinfo_hash_table
;
192 /* Hash table mapping symbol names to variable infos. */
193 struct info_hash_table
*varinfo_hash_table
;
195 /* Head of comp_unit list in the last hash table update. */
196 struct comp_unit
*hash_units_head
;
198 /* Status of info hash. */
199 int info_hash_status
;
200 #define STASH_INFO_HASH_OFF 0
201 #define STASH_INFO_HASH_ON 1
202 #define STASH_INFO_HASH_DISABLED 2
204 /* True if we opened bfd_ptr. */
205 bool close_on_cleanup
;
215 /* A minimal decoding of DWARF2 compilation units. We only decode
216 what's needed to get to the line number information. */
220 /* Chain the previously read compilation units. */
221 struct comp_unit
*next_unit
;
223 /* Likewise, chain the compilation unit read after this one.
224 The comp units are stored in reversed reading order. */
225 struct comp_unit
*prev_unit
;
227 /* Keep the bfd convenient (for memory allocation). */
230 /* The lowest and highest addresses contained in this compilation
231 unit as specified in the compilation unit header. */
232 struct arange arange
;
234 /* The DW_AT_name attribute (for error messages). */
237 /* The abbrev hash table. */
238 struct abbrev_info
**abbrevs
;
240 /* DW_AT_language. */
243 /* Note that an error was found by comp_unit_find_nearest_line. */
246 /* The DW_AT_comp_dir attribute. */
249 /* TRUE if there is a line number table associated with this comp. unit. */
252 /* Pointer to the current comp_unit so that we can find a given entry
254 bfd_byte
*info_ptr_unit
;
256 /* The offset into .debug_line of the line number table. */
257 unsigned long line_offset
;
259 /* Pointer to the first child die for the comp unit. */
260 bfd_byte
*first_child_die_ptr
;
262 /* The end of the comp unit. */
265 /* The decoded line number, NULL if not yet decoded. */
266 struct line_info_table
*line_table
;
268 /* A list of the functions found in this comp. unit. */
269 struct funcinfo
*function_table
;
271 /* A table of function information references searchable by address. */
272 struct lookup_funcinfo
*lookup_funcinfo_table
;
274 /* Number of functions in the function_table and sorted_function_table. */
275 bfd_size_type number_of_functions
;
277 /* A list of the variables found in this comp. unit. */
278 struct varinfo
*variable_table
;
280 /* Pointers to dwarf2_debug structures. */
281 struct dwarf2_debug
*stash
;
282 struct dwarf2_debug_file
*file
;
284 /* DWARF format version for this unit - from unit header. */
287 /* Address size for this unit - from unit header. */
288 unsigned char addr_size
;
290 /* Offset size for this unit - from unit header. */
291 unsigned char offset_size
;
293 /* Base address for this unit - from DW_AT_low_pc attribute of
294 DW_TAG_compile_unit DIE */
295 bfd_vma base_address
;
297 /* TRUE if symbols are cached in hash table for faster lookup by name. */
301 /* This data structure holds the information of an abbrev. */
304 unsigned int number
; /* Number identifying abbrev. */
305 enum dwarf_tag tag
; /* DWARF tag. */
306 bool has_children
; /* TRUE if the abbrev has children. */
307 unsigned int num_attrs
; /* Number of attributes. */
308 struct attr_abbrev
* attrs
; /* An array of attribute descriptions. */
309 struct abbrev_info
* next
; /* Next in chain. */
314 enum dwarf_attribute name
;
315 enum dwarf_form form
;
316 bfd_vma implicit_const
;
319 /* Map of uncompressed DWARF debug section name to compressed one. It
320 is terminated by NULL uncompressed_name. */
322 const struct dwarf_debug_section dwarf_debug_sections
[] =
324 { ".debug_abbrev", ".zdebug_abbrev" },
325 { ".debug_aranges", ".zdebug_aranges" },
326 { ".debug_frame", ".zdebug_frame" },
327 { ".debug_info", ".zdebug_info" },
328 { ".debug_info", ".zdebug_info" },
329 { ".debug_line", ".zdebug_line" },
330 { ".debug_loc", ".zdebug_loc" },
331 { ".debug_macinfo", ".zdebug_macinfo" },
332 { ".debug_macro", ".zdebug_macro" },
333 { ".debug_pubnames", ".zdebug_pubnames" },
334 { ".debug_pubtypes", ".zdebug_pubtypes" },
335 { ".debug_ranges", ".zdebug_ranges" },
336 { ".debug_rnglists", ".zdebug_rnglist" },
337 { ".debug_static_func", ".zdebug_static_func" },
338 { ".debug_static_vars", ".zdebug_static_vars" },
339 { ".debug_str", ".zdebug_str", },
340 { ".debug_str", ".zdebug_str", },
341 { ".debug_line_str", ".zdebug_line_str", },
342 { ".debug_types", ".zdebug_types" },
343 /* GNU DWARF 1 extensions */
344 { ".debug_sfnames", ".zdebug_sfnames" },
345 { ".debug_srcinfo", ".zebug_srcinfo" },
346 /* SGI/MIPS DWARF 2 extensions */
347 { ".debug_funcnames", ".zdebug_funcnames" },
348 { ".debug_typenames", ".zdebug_typenames" },
349 { ".debug_varnames", ".zdebug_varnames" },
350 { ".debug_weaknames", ".zdebug_weaknames" },
354 /* NB/ Numbers in this enum must match up with indices
355 into the dwarf_debug_sections[] array above. */
356 enum dwarf_debug_section_enum
386 /* A static assertion. */
387 extern int dwarf_debug_section_assert
[ARRAY_SIZE (dwarf_debug_sections
)
388 == debug_max
+ 1 ? 1 : -1];
390 #ifndef ABBREV_HASH_SIZE
391 #define ABBREV_HASH_SIZE 121
393 #ifndef ATTR_ALLOC_CHUNK
394 #define ATTR_ALLOC_CHUNK 4
397 /* Variable and function hash tables. This is used to speed up look-up
398 in lookup_symbol_in_var_table() and lookup_symbol_in_function_table().
399 In order to share code between variable and function infos, we use
400 a list of untyped pointer for all variable/function info associated with
401 a symbol. We waste a bit of memory for list with one node but that
402 simplifies the code. */
404 struct info_list_node
406 struct info_list_node
*next
;
410 /* Info hash entry. */
411 struct info_hash_entry
413 struct bfd_hash_entry root
;
414 struct info_list_node
*head
;
417 struct info_hash_table
419 struct bfd_hash_table base
;
422 /* Function to create a new entry in info hash table. */
424 static struct bfd_hash_entry
*
425 info_hash_table_newfunc (struct bfd_hash_entry
*entry
,
426 struct bfd_hash_table
*table
,
429 struct info_hash_entry
*ret
= (struct info_hash_entry
*) entry
;
431 /* Allocate the structure if it has not already been allocated by a
435 ret
= (struct info_hash_entry
*) bfd_hash_allocate (table
,
441 /* Call the allocation method of the base class. */
442 ret
= ((struct info_hash_entry
*)
443 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
445 /* Initialize the local fields here. */
449 return (struct bfd_hash_entry
*) ret
;
452 /* Function to create a new info hash table. It returns a pointer to the
453 newly created table or NULL if there is any error. We need abfd
454 solely for memory allocation. */
456 static struct info_hash_table
*
457 create_info_hash_table (bfd
*abfd
)
459 struct info_hash_table
*hash_table
;
461 hash_table
= ((struct info_hash_table
*)
462 bfd_alloc (abfd
, sizeof (struct info_hash_table
)));
466 if (!bfd_hash_table_init (&hash_table
->base
, info_hash_table_newfunc
,
467 sizeof (struct info_hash_entry
)))
469 bfd_release (abfd
, hash_table
);
476 /* Insert an info entry into an info hash table. We do not check of
477 duplicate entries. Also, the caller need to guarantee that the
478 right type of info in inserted as info is passed as a void* pointer.
479 This function returns true if there is no error. */
482 insert_info_hash_table (struct info_hash_table
*hash_table
,
487 struct info_hash_entry
*entry
;
488 struct info_list_node
*node
;
490 entry
= (struct info_hash_entry
*) bfd_hash_lookup (&hash_table
->base
,
495 node
= (struct info_list_node
*) bfd_hash_allocate (&hash_table
->base
,
501 node
->next
= entry
->head
;
507 /* Look up an info entry list from an info hash table. Return NULL
510 static struct info_list_node
*
511 lookup_info_hash_table (struct info_hash_table
*hash_table
, const char *key
)
513 struct info_hash_entry
*entry
;
515 entry
= (struct info_hash_entry
*) bfd_hash_lookup (&hash_table
->base
, key
,
517 return entry
? entry
->head
: NULL
;
520 /* Read a section into its appropriate place in the dwarf2_debug
521 struct (indicated by SECTION_BUFFER and SECTION_SIZE). If SYMS is
522 not NULL, use bfd_simple_get_relocated_section_contents to read the
523 section contents, otherwise use bfd_get_section_contents. Fail if
524 the located section does not contain at least OFFSET bytes. */
527 read_section (bfd
* abfd
,
528 const struct dwarf_debug_section
*sec
,
531 bfd_byte
** section_buffer
,
532 bfd_size_type
* section_size
)
534 const char *section_name
= sec
->uncompressed_name
;
535 bfd_byte
*contents
= *section_buffer
;
537 /* The section may have already been read. */
538 if (contents
== NULL
)
544 msec
= bfd_get_section_by_name (abfd
, section_name
);
547 section_name
= sec
->compressed_name
;
548 msec
= bfd_get_section_by_name (abfd
, section_name
);
552 _bfd_error_handler (_("DWARF error: can't find %s section."),
553 sec
->uncompressed_name
);
554 bfd_set_error (bfd_error_bad_value
);
558 amt
= bfd_get_section_limit_octets (abfd
, msec
);
559 filesize
= bfd_get_file_size (abfd
);
560 /* PR 28834: A compressed debug section could well decompress to a size
561 larger than the file, so we choose an arbitrary modifier of 10x in
562 the test below. If this ever turns out to be insufficient, it can
563 be changed by a future update. */
564 if (amt
>= filesize
* 10)
567 _bfd_error_handler (_("DWARF error: section %s is larger than 10x its filesize! (0x%lx vs 0x%lx)"),
568 section_name
, (long) amt
, (long) filesize
);
569 bfd_set_error (bfd_error_bad_value
);
573 /* Paranoia - alloc one extra so that we can make sure a string
574 section is NUL terminated. */
578 /* Paranoia - this should never happen. */
579 bfd_set_error (bfd_error_no_memory
);
582 contents
= (bfd_byte
*) bfd_malloc (amt
);
583 if (contents
== NULL
)
586 ? !bfd_simple_get_relocated_section_contents (abfd
, msec
, contents
,
588 : !bfd_get_section_contents (abfd
, msec
, contents
, 0, *section_size
))
593 contents
[*section_size
] = 0;
594 *section_buffer
= contents
;
597 /* It is possible to get a bad value for the offset into the section
598 that the client wants. Validate it here to avoid trouble later. */
599 if (offset
!= 0 && offset
>= *section_size
)
601 /* xgettext: c-format */
602 _bfd_error_handler (_("DWARF error: offset (%" PRIu64
")"
603 " greater than or equal to %s size (%" PRIu64
")"),
604 (uint64_t) offset
, section_name
,
605 (uint64_t) *section_size
);
606 bfd_set_error (bfd_error_bad_value
);
613 /* Read dwarf information from a buffer. */
615 static inline uint64_t
616 read_n_bytes (bfd
*abfd
, bfd_byte
**ptr
, bfd_byte
*end
, int n
)
618 bfd_byte
*buf
= *ptr
;
625 return bfd_get (n
* 8, abfd
, buf
);
629 read_1_byte (bfd
*abfd
, bfd_byte
**ptr
, bfd_byte
*end
)
631 return read_n_bytes (abfd
, ptr
, end
, 1);
635 read_1_signed_byte (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_byte
**ptr
, bfd_byte
*end
)
637 bfd_byte
*buf
= *ptr
;
644 return bfd_get_signed_8 (abfd
, buf
);
648 read_2_bytes (bfd
*abfd
, bfd_byte
**ptr
, bfd_byte
*end
)
650 return read_n_bytes (abfd
, ptr
, end
, 2);
654 read_3_bytes (bfd
*abfd
, bfd_byte
**ptr
, bfd_byte
*end
)
656 unsigned int val
= read_1_byte (abfd
, ptr
, end
);
658 val
|= read_1_byte (abfd
, ptr
, end
);
660 val
|= read_1_byte (abfd
, ptr
, end
);
661 if (bfd_little_endian (abfd
))
662 val
= (((val
>> 16) & 0xff)
664 | ((val
& 0xff) << 16));
669 read_4_bytes (bfd
*abfd
, bfd_byte
**ptr
, bfd_byte
*end
)
671 return read_n_bytes (abfd
, ptr
, end
, 4);
675 read_8_bytes (bfd
*abfd
, bfd_byte
**ptr
, bfd_byte
*end
)
677 return read_n_bytes (abfd
, ptr
, end
, 8);
680 static struct dwarf_block
*
681 read_blk (bfd
*abfd
, bfd_byte
**ptr
, bfd_byte
*end
, size_t size
)
683 bfd_byte
*buf
= *ptr
;
684 struct dwarf_block
*block
;
686 block
= (struct dwarf_block
*) bfd_alloc (abfd
, sizeof (*block
));
690 if (size
> (size_t) (end
- buf
))
705 /* Scans a NUL terminated string starting at *PTR, returning a pointer to it.
706 Bytes at or beyond BUF_END will not be read. Returns NULL if the
707 terminator is not found or if the string is empty. *PTR is
708 incremented over the bytes scanned, including the terminator. */
711 read_string (bfd_byte
**ptr
,
714 bfd_byte
*buf
= *ptr
;
717 while (buf
< buf_end
)
730 /* Reads an offset from *PTR and then locates the string at this offset
731 inside the debug string section. Returns a pointer to the string.
732 Increments *PTR by the number of bytes read for the offset. This
733 value is set even if the function fails. Bytes at or beyond
734 BUF_END will not be read. Returns NULL if there was a problem, or
735 if the string is empty. Does not check for NUL termination of the
739 read_indirect_string (struct comp_unit
*unit
,
744 struct dwarf2_debug
*stash
= unit
->stash
;
745 struct dwarf2_debug_file
*file
= unit
->file
;
748 if (unit
->offset_size
> (size_t) (buf_end
- *ptr
))
754 if (unit
->offset_size
== 4)
755 offset
= read_4_bytes (unit
->abfd
, ptr
, buf_end
);
757 offset
= read_8_bytes (unit
->abfd
, ptr
, buf_end
);
759 if (! read_section (unit
->abfd
, &stash
->debug_sections
[debug_str
],
761 &file
->dwarf_str_buffer
, &file
->dwarf_str_size
))
764 str
= (char *) file
->dwarf_str_buffer
+ offset
;
770 /* Like read_indirect_string but from .debug_line_str section. */
773 read_indirect_line_string (struct comp_unit
*unit
,
778 struct dwarf2_debug
*stash
= unit
->stash
;
779 struct dwarf2_debug_file
*file
= unit
->file
;
782 if (unit
->offset_size
> (size_t) (buf_end
- *ptr
))
788 if (unit
->offset_size
== 4)
789 offset
= read_4_bytes (unit
->abfd
, ptr
, buf_end
);
791 offset
= read_8_bytes (unit
->abfd
, ptr
, buf_end
);
793 if (! read_section (unit
->abfd
, &stash
->debug_sections
[debug_line_str
],
795 &file
->dwarf_line_str_buffer
,
796 &file
->dwarf_line_str_size
))
799 str
= (char *) file
->dwarf_line_str_buffer
+ offset
;
805 /* Like read_indirect_string but uses a .debug_str located in
806 an alternate file pointed to by the .gnu_debugaltlink section.
807 Used to impement DW_FORM_GNU_strp_alt. */
810 read_alt_indirect_string (struct comp_unit
*unit
,
815 struct dwarf2_debug
*stash
= unit
->stash
;
818 if (unit
->offset_size
> (size_t) (buf_end
- *ptr
))
824 if (unit
->offset_size
== 4)
825 offset
= read_4_bytes (unit
->abfd
, ptr
, buf_end
);
827 offset
= read_8_bytes (unit
->abfd
, ptr
, buf_end
);
829 if (stash
->alt
.bfd_ptr
== NULL
)
832 char *debug_filename
= bfd_follow_gnu_debugaltlink (unit
->abfd
, DEBUGDIR
);
834 if (debug_filename
== NULL
)
837 debug_bfd
= bfd_openr (debug_filename
, NULL
);
838 free (debug_filename
);
839 if (debug_bfd
== NULL
)
840 /* FIXME: Should we report our failure to follow the debuglink ? */
843 if (!bfd_check_format (debug_bfd
, bfd_object
))
845 bfd_close (debug_bfd
);
848 stash
->alt
.bfd_ptr
= debug_bfd
;
851 if (! read_section (unit
->stash
->alt
.bfd_ptr
,
852 stash
->debug_sections
+ debug_str_alt
,
853 stash
->alt
.syms
, offset
,
854 &stash
->alt
.dwarf_str_buffer
,
855 &stash
->alt
.dwarf_str_size
))
858 str
= (char *) stash
->alt
.dwarf_str_buffer
+ offset
;
865 /* Resolve an alternate reference from UNIT at OFFSET.
866 Returns a pointer into the loaded alternate CU upon success
867 or NULL upon failure. */
870 read_alt_indirect_ref (struct comp_unit
* unit
,
873 struct dwarf2_debug
*stash
= unit
->stash
;
875 if (stash
->alt
.bfd_ptr
== NULL
)
878 char *debug_filename
= bfd_follow_gnu_debugaltlink (unit
->abfd
, DEBUGDIR
);
880 if (debug_filename
== NULL
)
883 debug_bfd
= bfd_openr (debug_filename
, NULL
);
884 free (debug_filename
);
885 if (debug_bfd
== NULL
)
886 /* FIXME: Should we report our failure to follow the debuglink ? */
889 if (!bfd_check_format (debug_bfd
, bfd_object
))
891 bfd_close (debug_bfd
);
894 stash
->alt
.bfd_ptr
= debug_bfd
;
897 if (! read_section (unit
->stash
->alt
.bfd_ptr
,
898 stash
->debug_sections
+ debug_info_alt
,
899 stash
->alt
.syms
, offset
,
900 &stash
->alt
.dwarf_info_buffer
,
901 &stash
->alt
.dwarf_info_size
))
904 return stash
->alt
.dwarf_info_buffer
+ offset
;
908 read_address (struct comp_unit
*unit
, bfd_byte
**ptr
, bfd_byte
*buf_end
)
910 bfd_byte
*buf
= *ptr
;
913 if (bfd_get_flavour (unit
->abfd
) == bfd_target_elf_flavour
)
914 signed_vma
= get_elf_backend_data (unit
->abfd
)->sign_extend_vma
;
916 if (unit
->addr_size
> (size_t) (buf_end
- buf
))
922 *ptr
= buf
+ unit
->addr_size
;
925 switch (unit
->addr_size
)
928 return bfd_get_signed_64 (unit
->abfd
, buf
);
930 return bfd_get_signed_32 (unit
->abfd
, buf
);
932 return bfd_get_signed_16 (unit
->abfd
, buf
);
939 switch (unit
->addr_size
)
942 return bfd_get_64 (unit
->abfd
, buf
);
944 return bfd_get_32 (unit
->abfd
, buf
);
946 return bfd_get_16 (unit
->abfd
, buf
);
953 /* Lookup an abbrev_info structure in the abbrev hash table. */
955 static struct abbrev_info
*
956 lookup_abbrev (unsigned int number
, struct abbrev_info
**abbrevs
)
958 unsigned int hash_number
;
959 struct abbrev_info
*abbrev
;
961 hash_number
= number
% ABBREV_HASH_SIZE
;
962 abbrev
= abbrevs
[hash_number
];
966 if (abbrev
->number
== number
)
969 abbrev
= abbrev
->next
;
975 /* We keep a hash table to map .debug_abbrev section offsets to the
976 array of abbrevs, so that compilation units using the same set of
977 abbrevs do not waste memory. */
979 struct abbrev_offset_entry
982 struct abbrev_info
**abbrevs
;
986 hash_abbrev (const void *p
)
988 const struct abbrev_offset_entry
*ent
= p
;
989 return htab_hash_pointer ((void *) ent
->offset
);
993 eq_abbrev (const void *pa
, const void *pb
)
995 const struct abbrev_offset_entry
*a
= pa
;
996 const struct abbrev_offset_entry
*b
= pb
;
997 return a
->offset
== b
->offset
;
1001 del_abbrev (void *p
)
1003 struct abbrev_offset_entry
*ent
= p
;
1004 struct abbrev_info
**abbrevs
= ent
->abbrevs
;
1007 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
1009 struct abbrev_info
*abbrev
= abbrevs
[i
];
1013 free (abbrev
->attrs
);
1014 abbrev
= abbrev
->next
;
1020 /* In DWARF version 2, the description of the debugging information is
1021 stored in a separate .debug_abbrev section. Before we read any
1022 dies from a section we read in all abbreviations and install them
1025 static struct abbrev_info
**
1026 read_abbrevs (bfd
*abfd
, bfd_uint64_t offset
, struct dwarf2_debug
*stash
,
1027 struct dwarf2_debug_file
*file
)
1029 struct abbrev_info
**abbrevs
;
1030 bfd_byte
*abbrev_ptr
;
1031 bfd_byte
*abbrev_end
;
1032 struct abbrev_info
*cur_abbrev
;
1033 unsigned int abbrev_number
, abbrev_name
;
1034 unsigned int abbrev_form
, hash_number
;
1037 struct abbrev_offset_entry ent
= { offset
, NULL
};
1039 if (ent
.offset
!= offset
)
1042 slot
= htab_find_slot (file
->abbrev_offsets
, &ent
, INSERT
);
1046 return ((struct abbrev_offset_entry
*) (*slot
))->abbrevs
;
1048 if (! read_section (abfd
, &stash
->debug_sections
[debug_abbrev
],
1050 &file
->dwarf_abbrev_buffer
,
1051 &file
->dwarf_abbrev_size
))
1054 amt
= sizeof (struct abbrev_info
*) * ABBREV_HASH_SIZE
;
1055 abbrevs
= (struct abbrev_info
**) bfd_zalloc (abfd
, amt
);
1056 if (abbrevs
== NULL
)
1059 abbrev_ptr
= file
->dwarf_abbrev_buffer
+ offset
;
1060 abbrev_end
= file
->dwarf_abbrev_buffer
+ file
->dwarf_abbrev_size
;
1061 abbrev_number
= _bfd_safe_read_leb128 (abfd
, &abbrev_ptr
,
1064 /* Loop until we reach an abbrev number of 0. */
1065 while (abbrev_number
)
1067 amt
= sizeof (struct abbrev_info
);
1068 cur_abbrev
= (struct abbrev_info
*) bfd_zalloc (abfd
, amt
);
1069 if (cur_abbrev
== NULL
)
1072 /* Read in abbrev header. */
1073 cur_abbrev
->number
= abbrev_number
;
1074 cur_abbrev
->tag
= (enum dwarf_tag
)
1075 _bfd_safe_read_leb128 (abfd
, &abbrev_ptr
,
1077 cur_abbrev
->has_children
= read_1_byte (abfd
, &abbrev_ptr
, abbrev_end
);
1079 /* Now read in declarations. */
1082 /* Initialize it just to avoid a GCC false warning. */
1083 bfd_vma implicit_const
= -1;
1085 abbrev_name
= _bfd_safe_read_leb128 (abfd
, &abbrev_ptr
,
1087 abbrev_form
= _bfd_safe_read_leb128 (abfd
, &abbrev_ptr
,
1089 if (abbrev_form
== DW_FORM_implicit_const
)
1090 implicit_const
= _bfd_safe_read_leb128 (abfd
, &abbrev_ptr
,
1092 if (abbrev_name
== 0)
1095 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
1097 struct attr_abbrev
*tmp
;
1099 amt
= cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
;
1100 amt
*= sizeof (struct attr_abbrev
);
1101 tmp
= (struct attr_abbrev
*) bfd_realloc (cur_abbrev
->attrs
, amt
);
1104 cur_abbrev
->attrs
= tmp
;
1107 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
1108 = (enum dwarf_attribute
) abbrev_name
;
1109 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].form
1110 = (enum dwarf_form
) abbrev_form
;
1111 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].implicit_const
1113 ++cur_abbrev
->num_attrs
;
1116 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
1117 cur_abbrev
->next
= abbrevs
[hash_number
];
1118 abbrevs
[hash_number
] = cur_abbrev
;
1120 /* Get next abbreviation.
1121 Under Irix6 the abbreviations for a compilation unit are not
1122 always properly terminated with an abbrev number of 0.
1123 Exit loop if we encounter an abbreviation which we have
1124 already read (which means we are about to read the abbreviations
1125 for the next compile unit) or if the end of the abbreviation
1126 table is reached. */
1127 if ((size_t) (abbrev_ptr
- file
->dwarf_abbrev_buffer
)
1128 >= file
->dwarf_abbrev_size
)
1130 abbrev_number
= _bfd_safe_read_leb128 (abfd
, &abbrev_ptr
,
1132 if (lookup_abbrev (abbrev_number
, abbrevs
) != NULL
)
1136 *slot
= bfd_malloc (sizeof ent
);
1139 ent
.abbrevs
= abbrevs
;
1140 memcpy (*slot
, &ent
, sizeof ent
);
1144 if (abbrevs
!= NULL
)
1148 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
1150 struct abbrev_info
*abbrev
= abbrevs
[i
];
1154 free (abbrev
->attrs
);
1155 abbrev
= abbrev
->next
;
1163 /* Returns true if the form is one which has a string value. */
1166 is_str_form (const struct attribute
*attr
)
1170 case DW_FORM_string
:
1177 case DW_FORM_line_strp
:
1178 case DW_FORM_GNU_strp_alt
:
1186 /* Returns true if the form is one which has an integer value. */
1189 is_int_form (const struct attribute
*attr
)
1201 case DW_FORM_ref_addr
:
1206 case DW_FORM_ref_udata
:
1207 case DW_FORM_sec_offset
:
1208 case DW_FORM_flag_present
:
1209 case DW_FORM_ref_sig8
:
1211 case DW_FORM_implicit_const
:
1212 case DW_FORM_addrx1
:
1213 case DW_FORM_addrx2
:
1214 case DW_FORM_addrx3
:
1215 case DW_FORM_addrx4
:
1216 case DW_FORM_GNU_ref_alt
:
1225 read_indexed_string (bfd_uint64_t idx ATTRIBUTE_UNUSED
,
1226 struct comp_unit
* unit ATTRIBUTE_UNUSED
)
1228 /* FIXME: Add support for indexed strings. */
1229 return "<indexed strings not yet supported>";
1232 /* Read and fill in the value of attribute ATTR as described by FORM.
1233 Read data starting from INFO_PTR, but never at or beyond INFO_PTR_END.
1234 Returns an updated INFO_PTR taking into account the amount of data read. */
1237 read_attribute_value (struct attribute
* attr
,
1239 bfd_vma implicit_const
,
1240 struct comp_unit
* unit
,
1241 bfd_byte
* info_ptr
,
1242 bfd_byte
* info_ptr_end
)
1244 bfd
*abfd
= unit
->abfd
;
1247 if (info_ptr
>= info_ptr_end
&& form
!= DW_FORM_flag_present
)
1249 _bfd_error_handler (_("DWARF error: info pointer extends beyond end of attributes"));
1250 bfd_set_error (bfd_error_bad_value
);
1254 attr
->form
= (enum dwarf_form
) form
;
1258 case DW_FORM_flag_present
:
1261 case DW_FORM_ref_addr
:
1262 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
1264 if (unit
->version
>= 3)
1266 if (unit
->offset_size
== 4)
1267 attr
->u
.val
= read_4_bytes (unit
->abfd
, &info_ptr
, info_ptr_end
);
1269 attr
->u
.val
= read_8_bytes (unit
->abfd
, &info_ptr
, info_ptr_end
);
1274 attr
->u
.val
= read_address (unit
, &info_ptr
, info_ptr_end
);
1276 case DW_FORM_GNU_ref_alt
:
1277 case DW_FORM_sec_offset
:
1278 if (unit
->offset_size
== 4)
1279 attr
->u
.val
= read_4_bytes (unit
->abfd
, &info_ptr
, info_ptr_end
);
1281 attr
->u
.val
= read_8_bytes (unit
->abfd
, &info_ptr
, info_ptr_end
);
1283 case DW_FORM_block2
:
1284 amt
= read_2_bytes (abfd
, &info_ptr
, info_ptr_end
);
1285 attr
->u
.blk
= read_blk (abfd
, &info_ptr
, info_ptr_end
, amt
);
1286 if (attr
->u
.blk
== NULL
)
1289 case DW_FORM_block4
:
1290 amt
= read_4_bytes (abfd
, &info_ptr
, info_ptr_end
);
1291 attr
->u
.blk
= read_blk (abfd
, &info_ptr
, info_ptr_end
, amt
);
1292 if (attr
->u
.blk
== NULL
)
1298 case DW_FORM_addrx1
:
1299 attr
->u
.val
= read_1_byte (abfd
, &info_ptr
, info_ptr_end
);
1302 case DW_FORM_addrx2
:
1304 attr
->u
.val
= read_2_bytes (abfd
, &info_ptr
, info_ptr_end
);
1306 case DW_FORM_addrx3
:
1307 attr
->u
.val
= read_3_bytes (abfd
, &info_ptr
, info_ptr_end
);
1311 case DW_FORM_addrx4
:
1312 attr
->u
.val
= read_4_bytes (abfd
, &info_ptr
, info_ptr_end
);
1316 case DW_FORM_ref_sig8
:
1317 attr
->u
.val
= read_8_bytes (abfd
, &info_ptr
, info_ptr_end
);
1319 case DW_FORM_string
:
1320 attr
->u
.str
= read_string (&info_ptr
, info_ptr_end
);
1323 attr
->u
.str
= read_indirect_string (unit
, &info_ptr
, info_ptr_end
);
1325 case DW_FORM_line_strp
:
1326 attr
->u
.str
= read_indirect_line_string (unit
, &info_ptr
, info_ptr_end
);
1328 case DW_FORM_GNU_strp_alt
:
1329 attr
->u
.str
= read_alt_indirect_string (unit
, &info_ptr
, info_ptr_end
);
1332 attr
->u
.val
= read_1_byte (abfd
, &info_ptr
, info_ptr_end
);
1333 attr
->u
.str
= (char *) read_indexed_string (attr
->u
.val
, unit
);
1336 attr
->u
.val
= read_2_bytes (abfd
, &info_ptr
, info_ptr_end
);
1337 attr
->u
.str
= (char *) read_indexed_string (attr
->u
.val
, unit
);
1340 attr
->u
.val
= read_3_bytes (abfd
, &info_ptr
, info_ptr_end
);
1341 attr
->u
.str
= (char *) read_indexed_string (attr
->u
.val
, unit
);
1344 attr
->u
.val
= read_4_bytes (abfd
, &info_ptr
, info_ptr_end
);
1345 attr
->u
.str
= (char *) read_indexed_string (attr
->u
.val
, unit
);
1348 attr
->u
.val
= _bfd_safe_read_leb128 (abfd
, &info_ptr
,
1349 false, info_ptr_end
);
1350 attr
->u
.str
= (char *) read_indexed_string (attr
->u
.val
, unit
);
1352 case DW_FORM_exprloc
:
1354 amt
= _bfd_safe_read_leb128 (abfd
, &info_ptr
,
1355 false, info_ptr_end
);
1356 attr
->u
.blk
= read_blk (abfd
, &info_ptr
, info_ptr_end
, amt
);
1357 if (attr
->u
.blk
== NULL
)
1360 case DW_FORM_block1
:
1361 amt
= read_1_byte (abfd
, &info_ptr
, info_ptr_end
);
1362 attr
->u
.blk
= read_blk (abfd
, &info_ptr
, info_ptr_end
, amt
);
1363 if (attr
->u
.blk
== NULL
)
1367 attr
->u
.sval
= _bfd_safe_read_leb128 (abfd
, &info_ptr
,
1368 true, info_ptr_end
);
1370 case DW_FORM_ref_udata
:
1373 attr
->u
.val
= _bfd_safe_read_leb128 (abfd
, &info_ptr
,
1374 false, info_ptr_end
);
1376 case DW_FORM_indirect
:
1377 form
= _bfd_safe_read_leb128 (abfd
, &info_ptr
,
1378 false, info_ptr_end
);
1379 if (form
== DW_FORM_implicit_const
)
1380 implicit_const
= _bfd_safe_read_leb128 (abfd
, &info_ptr
,
1381 true, info_ptr_end
);
1382 info_ptr
= read_attribute_value (attr
, form
, implicit_const
, unit
,
1383 info_ptr
, info_ptr_end
);
1385 case DW_FORM_implicit_const
:
1386 attr
->form
= DW_FORM_sdata
;
1387 attr
->u
.sval
= implicit_const
;
1389 case DW_FORM_data16
:
1390 /* This is really a "constant", but there is no way to store that
1391 so pretend it is a 16 byte block instead. */
1392 attr
->u
.blk
= read_blk (abfd
, &info_ptr
, info_ptr_end
, 16);
1393 if (attr
->u
.blk
== NULL
)
1398 _bfd_error_handler (_("DWARF error: invalid or unhandled FORM value: %#x"),
1400 bfd_set_error (bfd_error_bad_value
);
1406 /* Read an attribute described by an abbreviated attribute. */
1409 read_attribute (struct attribute
* attr
,
1410 struct attr_abbrev
* abbrev
,
1411 struct comp_unit
* unit
,
1412 bfd_byte
* info_ptr
,
1413 bfd_byte
* info_ptr_end
)
1415 attr
->name
= abbrev
->name
;
1416 info_ptr
= read_attribute_value (attr
, abbrev
->form
, abbrev
->implicit_const
,
1417 unit
, info_ptr
, info_ptr_end
);
1421 /* Return whether DW_AT_name will return the same as DW_AT_linkage_name
1425 non_mangled (int lang
)
1435 case DW_LANG_Cobol74
:
1436 case DW_LANG_Cobol85
:
1437 case DW_LANG_Fortran77
:
1438 case DW_LANG_Pascal83
:
1444 case DW_LANG_Mips_Assembler
:
1449 /* Source line information table routines. */
1451 #define FILE_ALLOC_CHUNK 5
1452 #define DIR_ALLOC_CHUNK 5
1456 struct line_info
* prev_line
;
1460 unsigned int column
;
1461 unsigned int discriminator
;
1462 unsigned char op_index
;
1463 unsigned char end_sequence
; /* End of (sequential) code sequence. */
1474 struct line_sequence
1477 struct line_sequence
* prev_sequence
;
1478 struct line_info
* last_line
; /* Largest VMA. */
1479 struct line_info
** line_info_lookup
;
1480 bfd_size_type num_lines
;
1483 struct line_info_table
1486 unsigned int num_files
;
1487 unsigned int num_dirs
;
1488 unsigned int num_sequences
;
1491 struct fileinfo
* files
;
1492 struct line_sequence
* sequences
;
1493 struct line_info
* lcl_head
; /* Local head; used in 'add_line_info'. */
1496 /* Remember some information about each function. If the function is
1497 inlined (DW_TAG_inlined_subroutine) it may have two additional
1498 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
1499 source code location where this function was inlined. */
1503 /* Pointer to previous function in list of all functions. */
1504 struct funcinfo
* prev_func
;
1505 /* Pointer to function one scope higher. */
1506 struct funcinfo
* caller_func
;
1507 /* Source location file name where caller_func inlines this func. */
1509 /* Source location file name. */
1511 /* Source location line number where caller_func inlines this func. */
1513 /* Source location line number. */
1518 struct arange arange
;
1519 /* Where the symbol is defined. */
1521 /* The offset of the funcinfo from the start of the unit. */
1522 bfd_uint64_t unit_offset
;
1525 struct lookup_funcinfo
1527 /* Function information corresponding to this lookup table entry. */
1528 struct funcinfo
* funcinfo
;
1530 /* The lowest address for this specific function. */
1533 /* The highest address of this function before the lookup table is sorted.
1534 The highest address of all prior functions after the lookup table is
1535 sorted, which is used for binary search. */
1537 /* Index of this function, used to ensure qsort is stable. */
1543 /* Pointer to previous variable in list of all variables. */
1544 struct varinfo
*prev_var
;
1545 /* The offset of the varinfo from the start of the unit. */
1546 bfd_uint64_t unit_offset
;
1547 /* Source location file name. */
1549 /* Source location line number. */
1551 /* The type of this variable. */
1553 /* The name of the variable, if it has one. */
1555 /* The address of the variable. */
1557 /* Where the symbol is defined. */
1559 /* Is this a stack variable? */
1563 /* Return TRUE if NEW_LINE should sort after LINE. */
1566 new_line_sorts_after (struct line_info
*new_line
, struct line_info
*line
)
1568 return (new_line
->address
> line
->address
1569 || (new_line
->address
== line
->address
1570 && new_line
->op_index
> line
->op_index
));
1574 /* Adds a new entry to the line_info list in the line_info_table, ensuring
1575 that the list is sorted. Note that the line_info list is sorted from
1576 highest to lowest VMA (with possible duplicates); that is,
1577 line_info->prev_line always accesses an equal or smaller VMA. */
1580 add_line_info (struct line_info_table
*table
,
1582 unsigned char op_index
,
1585 unsigned int column
,
1586 unsigned int discriminator
,
1589 size_t amt
= sizeof (struct line_info
);
1590 struct line_sequence
* seq
= table
->sequences
;
1591 struct line_info
* info
= (struct line_info
*) bfd_alloc (table
->abfd
, amt
);
1596 /* Set member data of 'info'. */
1597 info
->prev_line
= NULL
;
1598 info
->address
= address
;
1599 info
->op_index
= op_index
;
1601 info
->column
= column
;
1602 info
->discriminator
= discriminator
;
1603 info
->end_sequence
= end_sequence
;
1605 if (filename
&& filename
[0])
1607 info
->filename
= (char *) bfd_alloc (table
->abfd
, strlen (filename
) + 1);
1608 if (info
->filename
== NULL
)
1610 strcpy (info
->filename
, filename
);
1613 info
->filename
= NULL
;
1615 /* Find the correct location for 'info'. Normally we will receive
1616 new line_info data 1) in order and 2) with increasing VMAs.
1617 However some compilers break the rules (cf. decode_line_info) and
1618 so we include some heuristics for quickly finding the correct
1619 location for 'info'. In particular, these heuristics optimize for
1620 the common case in which the VMA sequence that we receive is a
1621 list of locally sorted VMAs such as
1622 p...z a...j (where a < j < p < z)
1624 Note: table->lcl_head is used to head an *actual* or *possible*
1625 sub-sequence within the list (such as a...j) that is not directly
1626 headed by table->last_line
1628 Note: we may receive duplicate entries from 'decode_line_info'. */
1631 && seq
->last_line
->address
== address
1632 && seq
->last_line
->op_index
== op_index
1633 && seq
->last_line
->end_sequence
== end_sequence
)
1635 /* We only keep the last entry with the same address and end
1636 sequence. See PR ld/4986. */
1637 if (table
->lcl_head
== seq
->last_line
)
1638 table
->lcl_head
= info
;
1639 info
->prev_line
= seq
->last_line
->prev_line
;
1640 seq
->last_line
= info
;
1642 else if (!seq
|| seq
->last_line
->end_sequence
)
1644 /* Start a new line sequence. */
1645 amt
= sizeof (struct line_sequence
);
1646 seq
= (struct line_sequence
*) bfd_malloc (amt
);
1649 seq
->low_pc
= address
;
1650 seq
->prev_sequence
= table
->sequences
;
1651 seq
->last_line
= info
;
1652 table
->lcl_head
= info
;
1653 table
->sequences
= seq
;
1654 table
->num_sequences
++;
1656 else if (info
->end_sequence
1657 || new_line_sorts_after (info
, seq
->last_line
))
1659 /* Normal case: add 'info' to the beginning of the current sequence. */
1660 info
->prev_line
= seq
->last_line
;
1661 seq
->last_line
= info
;
1663 /* lcl_head: initialize to head a *possible* sequence at the end. */
1664 if (!table
->lcl_head
)
1665 table
->lcl_head
= info
;
1667 else if (!new_line_sorts_after (info
, table
->lcl_head
)
1668 && (!table
->lcl_head
->prev_line
1669 || new_line_sorts_after (info
, table
->lcl_head
->prev_line
)))
1671 /* Abnormal but easy: lcl_head is the head of 'info'. */
1672 info
->prev_line
= table
->lcl_head
->prev_line
;
1673 table
->lcl_head
->prev_line
= info
;
1677 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head'
1678 are valid heads for 'info'. Reset 'lcl_head'. */
1679 struct line_info
* li2
= seq
->last_line
; /* Always non-NULL. */
1680 struct line_info
* li1
= li2
->prev_line
;
1684 if (!new_line_sorts_after (info
, li2
)
1685 && new_line_sorts_after (info
, li1
))
1688 li2
= li1
; /* always non-NULL */
1689 li1
= li1
->prev_line
;
1691 table
->lcl_head
= li2
;
1692 info
->prev_line
= table
->lcl_head
->prev_line
;
1693 table
->lcl_head
->prev_line
= info
;
1694 if (address
< seq
->low_pc
)
1695 seq
->low_pc
= address
;
1700 /* Extract a fully qualified filename from a line info table.
1701 The returned string has been malloc'ed and it is the caller's
1702 responsibility to free it. */
1705 concat_filename (struct line_info_table
*table
, unsigned int file
)
1709 if (table
== NULL
|| file
- 1 >= table
->num_files
)
1711 /* FILE == 0 means unknown. */
1714 (_("DWARF error: mangled line number section (bad file number)"));
1715 return strdup ("<unknown>");
1718 filename
= table
->files
[file
- 1].name
;
1719 if (filename
== NULL
)
1720 return strdup ("<unknown>");
1722 if (!IS_ABSOLUTE_PATH (filename
))
1724 char *dir_name
= NULL
;
1725 char *subdir_name
= NULL
;
1729 if (table
->files
[file
- 1].dir
1730 /* PR 17512: file: 0317e960. */
1731 && table
->files
[file
- 1].dir
<= table
->num_dirs
1732 /* PR 17512: file: 7f3d2e4b. */
1733 && table
->dirs
!= NULL
)
1734 subdir_name
= table
->dirs
[table
->files
[file
- 1].dir
- 1];
1736 if (!subdir_name
|| !IS_ABSOLUTE_PATH (subdir_name
))
1737 dir_name
= table
->comp_dir
;
1741 dir_name
= subdir_name
;
1746 return strdup (filename
);
1748 len
= strlen (dir_name
) + strlen (filename
) + 2;
1752 len
+= strlen (subdir_name
) + 1;
1753 name
= (char *) bfd_malloc (len
);
1755 sprintf (name
, "%s/%s/%s", dir_name
, subdir_name
, filename
);
1759 name
= (char *) bfd_malloc (len
);
1761 sprintf (name
, "%s/%s", dir_name
, filename
);
1767 return strdup (filename
);
1771 arange_add (const struct comp_unit
*unit
, struct arange
*first_arange
,
1772 bfd_vma low_pc
, bfd_vma high_pc
)
1774 struct arange
*arange
;
1776 /* Ignore empty ranges. */
1777 if (low_pc
== high_pc
)
1780 /* If the first arange is empty, use it. */
1781 if (first_arange
->high
== 0)
1783 first_arange
->low
= low_pc
;
1784 first_arange
->high
= high_pc
;
1788 /* Next see if we can cheaply extend an existing range. */
1789 arange
= first_arange
;
1792 if (low_pc
== arange
->high
)
1794 arange
->high
= high_pc
;
1797 if (high_pc
== arange
->low
)
1799 arange
->low
= low_pc
;
1802 arange
= arange
->next
;
1806 /* Need to allocate a new arange and insert it into the arange list.
1807 Order isn't significant, so just insert after the first arange. */
1808 arange
= (struct arange
*) bfd_alloc (unit
->abfd
, sizeof (*arange
));
1811 arange
->low
= low_pc
;
1812 arange
->high
= high_pc
;
1813 arange
->next
= first_arange
->next
;
1814 first_arange
->next
= arange
;
1818 /* Compare function for line sequences. */
1821 compare_sequences (const void* a
, const void* b
)
1823 const struct line_sequence
* seq1
= a
;
1824 const struct line_sequence
* seq2
= b
;
1826 /* Sort by low_pc as the primary key. */
1827 if (seq1
->low_pc
< seq2
->low_pc
)
1829 if (seq1
->low_pc
> seq2
->low_pc
)
1832 /* If low_pc values are equal, sort in reverse order of
1833 high_pc, so that the largest region comes first. */
1834 if (seq1
->last_line
->address
< seq2
->last_line
->address
)
1836 if (seq1
->last_line
->address
> seq2
->last_line
->address
)
1839 if (seq1
->last_line
->op_index
< seq2
->last_line
->op_index
)
1841 if (seq1
->last_line
->op_index
> seq2
->last_line
->op_index
)
1844 /* num_lines is initially an index, to make the sort stable. */
1845 if (seq1
->num_lines
< seq2
->num_lines
)
1847 if (seq1
->num_lines
> seq2
->num_lines
)
1852 /* Construct the line information table for quick lookup. */
1855 build_line_info_table (struct line_info_table
* table
,
1856 struct line_sequence
* seq
)
1859 struct line_info
**line_info_lookup
;
1860 struct line_info
*each_line
;
1861 unsigned int num_lines
;
1862 unsigned int line_index
;
1864 if (seq
->line_info_lookup
!= NULL
)
1867 /* Count the number of line information entries. We could do this while
1868 scanning the debug information, but some entries may be added via
1869 lcl_head without having a sequence handy to increment the number of
1872 for (each_line
= seq
->last_line
; each_line
; each_line
= each_line
->prev_line
)
1875 seq
->num_lines
= num_lines
;
1879 /* Allocate space for the line information lookup table. */
1880 amt
= sizeof (struct line_info
*) * num_lines
;
1881 line_info_lookup
= (struct line_info
**) bfd_alloc (table
->abfd
, amt
);
1882 seq
->line_info_lookup
= line_info_lookup
;
1883 if (line_info_lookup
== NULL
)
1886 /* Create the line information lookup table. */
1887 line_index
= num_lines
;
1888 for (each_line
= seq
->last_line
; each_line
; each_line
= each_line
->prev_line
)
1889 line_info_lookup
[--line_index
] = each_line
;
1891 BFD_ASSERT (line_index
== 0);
1895 /* Sort the line sequences for quick lookup. */
1898 sort_line_sequences (struct line_info_table
* table
)
1901 struct line_sequence
*sequences
;
1902 struct line_sequence
*seq
;
1904 unsigned int num_sequences
= table
->num_sequences
;
1905 bfd_vma last_high_pc
;
1907 if (num_sequences
== 0)
1910 /* Allocate space for an array of sequences. */
1911 amt
= sizeof (struct line_sequence
) * num_sequences
;
1912 sequences
= (struct line_sequence
*) bfd_alloc (table
->abfd
, amt
);
1913 if (sequences
== NULL
)
1916 /* Copy the linked list into the array, freeing the original nodes. */
1917 seq
= table
->sequences
;
1918 for (n
= 0; n
< num_sequences
; n
++)
1920 struct line_sequence
* last_seq
= seq
;
1923 sequences
[n
].low_pc
= seq
->low_pc
;
1924 sequences
[n
].prev_sequence
= NULL
;
1925 sequences
[n
].last_line
= seq
->last_line
;
1926 sequences
[n
].line_info_lookup
= NULL
;
1927 sequences
[n
].num_lines
= n
;
1928 seq
= seq
->prev_sequence
;
1931 BFD_ASSERT (seq
== NULL
);
1933 qsort (sequences
, n
, sizeof (struct line_sequence
), compare_sequences
);
1935 /* Make the list binary-searchable by trimming overlapping entries
1936 and removing nested entries. */
1938 last_high_pc
= sequences
[0].last_line
->address
;
1939 for (n
= 1; n
< table
->num_sequences
; n
++)
1941 if (sequences
[n
].low_pc
< last_high_pc
)
1943 if (sequences
[n
].last_line
->address
<= last_high_pc
)
1944 /* Skip nested entries. */
1947 /* Trim overlapping entries. */
1948 sequences
[n
].low_pc
= last_high_pc
;
1950 last_high_pc
= sequences
[n
].last_line
->address
;
1951 if (n
> num_sequences
)
1953 /* Close up the gap. */
1954 sequences
[num_sequences
].low_pc
= sequences
[n
].low_pc
;
1955 sequences
[num_sequences
].last_line
= sequences
[n
].last_line
;
1960 table
->sequences
= sequences
;
1961 table
->num_sequences
= num_sequences
;
1965 /* Add directory to TABLE. CUR_DIR memory ownership is taken by TABLE. */
1968 line_info_add_include_dir (struct line_info_table
*table
, char *cur_dir
)
1970 if ((table
->num_dirs
% DIR_ALLOC_CHUNK
) == 0)
1975 amt
= table
->num_dirs
+ DIR_ALLOC_CHUNK
;
1976 amt
*= sizeof (char *);
1978 tmp
= (char **) bfd_realloc (table
->dirs
, amt
);
1984 table
->dirs
[table
->num_dirs
++] = cur_dir
;
1989 line_info_add_include_dir_stub (struct line_info_table
*table
, char *cur_dir
,
1990 unsigned int dir ATTRIBUTE_UNUSED
,
1991 unsigned int xtime ATTRIBUTE_UNUSED
,
1992 unsigned int size ATTRIBUTE_UNUSED
)
1994 return line_info_add_include_dir (table
, cur_dir
);
1997 /* Add file to TABLE. CUR_FILE memory ownership is taken by TABLE. */
2000 line_info_add_file_name (struct line_info_table
*table
, char *cur_file
,
2001 unsigned int dir
, unsigned int xtime
,
2004 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
2006 struct fileinfo
*tmp
;
2009 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
2010 amt
*= sizeof (struct fileinfo
);
2012 tmp
= (struct fileinfo
*) bfd_realloc (table
->files
, amt
);
2018 table
->files
[table
->num_files
].name
= cur_file
;
2019 table
->files
[table
->num_files
].dir
= dir
;
2020 table
->files
[table
->num_files
].time
= xtime
;
2021 table
->files
[table
->num_files
].size
= size
;
2026 /* Read directory or file name entry format, starting with byte of
2027 format count entries, ULEB128 pairs of entry formats, ULEB128 of
2028 entries count and the entries themselves in the described entry
2032 read_formatted_entries (struct comp_unit
*unit
, bfd_byte
**bufp
,
2033 bfd_byte
*buf_end
, struct line_info_table
*table
,
2034 bool (*callback
) (struct line_info_table
*table
,
2040 bfd
*abfd
= unit
->abfd
;
2041 bfd_byte format_count
, formati
;
2042 bfd_vma data_count
, datai
;
2043 bfd_byte
*buf
= *bufp
;
2044 bfd_byte
*format_header_data
;
2046 format_count
= read_1_byte (abfd
, &buf
, buf_end
);
2047 format_header_data
= buf
;
2048 for (formati
= 0; formati
< format_count
; formati
++)
2050 _bfd_safe_read_leb128 (abfd
, &buf
, false, buf_end
);
2051 _bfd_safe_read_leb128 (abfd
, &buf
, false, buf_end
);
2054 data_count
= _bfd_safe_read_leb128 (abfd
, &buf
, false, buf_end
);
2055 if (format_count
== 0 && data_count
!= 0)
2057 _bfd_error_handler (_("DWARF error: zero format count"));
2058 bfd_set_error (bfd_error_bad_value
);
2062 /* PR 22210. Paranoia check. Don't bother running the loop
2063 if we know that we are going to run out of buffer. */
2064 if (data_count
> (bfd_vma
) (buf_end
- buf
))
2067 (_("DWARF error: data count (%" PRIx64
") larger than buffer size"),
2068 (uint64_t) data_count
);
2069 bfd_set_error (bfd_error_bad_value
);
2073 for (datai
= 0; datai
< data_count
; datai
++)
2075 bfd_byte
*format
= format_header_data
;
2078 memset (&fe
, 0, sizeof fe
);
2079 for (formati
= 0; formati
< format_count
; formati
++)
2081 bfd_vma content_type
, form
;
2083 char **stringp
= &string_trash
;
2084 unsigned int uint_trash
, *uintp
= &uint_trash
;
2085 struct attribute attr
;
2087 content_type
= _bfd_safe_read_leb128 (abfd
, &format
, false, buf_end
);
2088 switch (content_type
)
2093 case DW_LNCT_directory_index
:
2096 case DW_LNCT_timestamp
:
2106 (_("DWARF error: unknown format content type %" PRIu64
),
2107 (uint64_t) content_type
);
2108 bfd_set_error (bfd_error_bad_value
);
2112 form
= _bfd_safe_read_leb128 (abfd
, &format
, false, buf_end
);
2113 buf
= read_attribute_value (&attr
, form
, 0, unit
, buf
, buf_end
);
2118 case DW_FORM_string
:
2119 case DW_FORM_line_strp
:
2120 *stringp
= attr
.u
.str
;
2128 *uintp
= attr
.u
.val
;
2131 case DW_FORM_data16
:
2132 /* MD5 data is in the attr.blk, but we are ignoring those. */
2137 /* Skip the first "zero entry", which is the compilation dir/file. */
2139 if (!callback (table
, fe
.name
, fe
.dir
, fe
.time
, fe
.size
))
2147 /* Decode the line number information for UNIT. */
2149 static struct line_info_table
*
2150 decode_line_info (struct comp_unit
*unit
)
2152 bfd
*abfd
= unit
->abfd
;
2153 struct dwarf2_debug
*stash
= unit
->stash
;
2154 struct dwarf2_debug_file
*file
= unit
->file
;
2155 struct line_info_table
* table
;
2158 struct line_head lh
;
2159 unsigned int i
, offset_size
;
2160 char *cur_file
, *cur_dir
;
2161 unsigned char op_code
, extended_op
, adj_opcode
;
2162 unsigned int exop_len
;
2165 if (unit
->line_offset
== 0 && file
->line_table
)
2166 return file
->line_table
;
2168 if (! read_section (abfd
, &stash
->debug_sections
[debug_line
],
2169 file
->syms
, unit
->line_offset
,
2170 &file
->dwarf_line_buffer
, &file
->dwarf_line_size
))
2173 if (file
->dwarf_line_size
< 16)
2176 (_("DWARF error: line info section is too small (%" PRId64
")"),
2177 (int64_t) file
->dwarf_line_size
);
2178 bfd_set_error (bfd_error_bad_value
);
2181 line_ptr
= file
->dwarf_line_buffer
+ unit
->line_offset
;
2182 line_end
= file
->dwarf_line_buffer
+ file
->dwarf_line_size
;
2184 /* Read in the prologue. */
2185 lh
.total_length
= read_4_bytes (abfd
, &line_ptr
, line_end
);
2187 if (lh
.total_length
== 0xffffffff)
2189 lh
.total_length
= read_8_bytes (abfd
, &line_ptr
, line_end
);
2192 else if (lh
.total_length
== 0 && unit
->addr_size
== 8)
2194 /* Handle (non-standard) 64-bit DWARF2 formats. */
2195 lh
.total_length
= read_4_bytes (abfd
, &line_ptr
, line_end
);
2199 if (lh
.total_length
> (size_t) (line_end
- line_ptr
))
2202 /* xgettext: c-format */
2203 (_("DWARF error: line info data is bigger (%#" PRIx64
")"
2204 " than the space remaining in the section (%#lx)"),
2205 (uint64_t) lh
.total_length
, (unsigned long) (line_end
- line_ptr
));
2206 bfd_set_error (bfd_error_bad_value
);
2210 line_end
= line_ptr
+ lh
.total_length
;
2212 lh
.version
= read_2_bytes (abfd
, &line_ptr
, line_end
);
2213 if (lh
.version
< 2 || lh
.version
> 5)
2216 (_("DWARF error: unhandled .debug_line version %d"), lh
.version
);
2217 bfd_set_error (bfd_error_bad_value
);
2221 if (line_ptr
+ offset_size
+ (lh
.version
>= 5 ? 8 : (lh
.version
>= 4 ? 6 : 5))
2225 (_("DWARF error: ran out of room reading prologue"));
2226 bfd_set_error (bfd_error_bad_value
);
2230 if (lh
.version
>= 5)
2232 unsigned int segment_selector_size
;
2234 /* Skip address size. */
2235 read_1_byte (abfd
, &line_ptr
, line_end
);
2237 segment_selector_size
= read_1_byte (abfd
, &line_ptr
, line_end
);
2238 if (segment_selector_size
!= 0)
2241 (_("DWARF error: line info unsupported segment selector size %u"),
2242 segment_selector_size
);
2243 bfd_set_error (bfd_error_bad_value
);
2248 if (offset_size
== 4)
2249 lh
.prologue_length
= read_4_bytes (abfd
, &line_ptr
, line_end
);
2251 lh
.prologue_length
= read_8_bytes (abfd
, &line_ptr
, line_end
);
2253 lh
.minimum_instruction_length
= read_1_byte (abfd
, &line_ptr
, line_end
);
2255 if (lh
.version
>= 4)
2256 lh
.maximum_ops_per_insn
= read_1_byte (abfd
, &line_ptr
, line_end
);
2258 lh
.maximum_ops_per_insn
= 1;
2260 if (lh
.maximum_ops_per_insn
== 0)
2263 (_("DWARF error: invalid maximum operations per instruction"));
2264 bfd_set_error (bfd_error_bad_value
);
2268 lh
.default_is_stmt
= read_1_byte (abfd
, &line_ptr
, line_end
);
2269 lh
.line_base
= read_1_signed_byte (abfd
, &line_ptr
, line_end
);
2270 lh
.line_range
= read_1_byte (abfd
, &line_ptr
, line_end
);
2271 lh
.opcode_base
= read_1_byte (abfd
, &line_ptr
, line_end
);
2273 if (line_ptr
+ (lh
.opcode_base
- 1) >= line_end
)
2275 _bfd_error_handler (_("DWARF error: ran out of room reading opcodes"));
2276 bfd_set_error (bfd_error_bad_value
);
2280 amt
= lh
.opcode_base
* sizeof (unsigned char);
2281 lh
.standard_opcode_lengths
= (unsigned char *) bfd_alloc (abfd
, amt
);
2283 lh
.standard_opcode_lengths
[0] = 1;
2285 for (i
= 1; i
< lh
.opcode_base
; ++i
)
2286 lh
.standard_opcode_lengths
[i
] = read_1_byte (abfd
, &line_ptr
, line_end
);
2288 amt
= sizeof (struct line_info_table
);
2289 table
= (struct line_info_table
*) bfd_alloc (abfd
, amt
);
2293 table
->comp_dir
= unit
->comp_dir
;
2295 table
->num_files
= 0;
2296 table
->files
= NULL
;
2298 table
->num_dirs
= 0;
2301 table
->num_sequences
= 0;
2302 table
->sequences
= NULL
;
2304 table
->lcl_head
= NULL
;
2306 if (lh
.version
>= 5)
2308 /* Read directory table. */
2309 if (!read_formatted_entries (unit
, &line_ptr
, line_end
, table
,
2310 line_info_add_include_dir_stub
))
2313 /* Read file name table. */
2314 if (!read_formatted_entries (unit
, &line_ptr
, line_end
, table
,
2315 line_info_add_file_name
))
2320 /* Read directory table. */
2321 while ((cur_dir
= read_string (&line_ptr
, line_end
)) != NULL
)
2323 if (!line_info_add_include_dir (table
, cur_dir
))
2327 /* Read file name table. */
2328 while ((cur_file
= read_string (&line_ptr
, line_end
)) != NULL
)
2330 unsigned int dir
, xtime
, size
;
2332 dir
= _bfd_safe_read_leb128 (abfd
, &line_ptr
, false, line_end
);
2333 xtime
= _bfd_safe_read_leb128 (abfd
, &line_ptr
, false, line_end
);
2334 size
= _bfd_safe_read_leb128 (abfd
, &line_ptr
, false, line_end
);
2336 if (!line_info_add_file_name (table
, cur_file
, dir
, xtime
, size
))
2341 /* Read the statement sequences until there's nothing left. */
2342 while (line_ptr
< line_end
)
2344 /* State machine registers. */
2345 bfd_vma address
= 0;
2346 unsigned char op_index
= 0;
2347 char * filename
= table
->num_files
? concat_filename (table
, 1) : NULL
;
2348 unsigned int line
= 1;
2349 unsigned int column
= 0;
2350 unsigned int discriminator
= 0;
2351 int is_stmt
= lh
.default_is_stmt
;
2352 int end_sequence
= 0;
2353 unsigned int dir
, xtime
, size
;
2354 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
2355 compilers generate address sequences that are wildly out of
2356 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
2357 for ia64-Linux). Thus, to determine the low and high
2358 address, we must compare on every DW_LNS_copy, etc. */
2359 bfd_vma low_pc
= (bfd_vma
) -1;
2360 bfd_vma high_pc
= 0;
2362 /* Decode the table. */
2363 while (!end_sequence
&& line_ptr
< line_end
)
2365 op_code
= read_1_byte (abfd
, &line_ptr
, line_end
);
2367 if (op_code
>= lh
.opcode_base
)
2369 /* Special operand. */
2370 adj_opcode
= op_code
- lh
.opcode_base
;
2371 if (lh
.line_range
== 0)
2373 if (lh
.maximum_ops_per_insn
== 1)
2374 address
+= (adj_opcode
/ lh
.line_range
2375 * lh
.minimum_instruction_length
);
2378 address
+= ((op_index
+ adj_opcode
/ lh
.line_range
)
2379 / lh
.maximum_ops_per_insn
2380 * lh
.minimum_instruction_length
);
2381 op_index
= ((op_index
+ adj_opcode
/ lh
.line_range
)
2382 % lh
.maximum_ops_per_insn
);
2384 line
+= lh
.line_base
+ (adj_opcode
% lh
.line_range
);
2385 /* Append row to matrix using current values. */
2386 if (!add_line_info (table
, address
, op_index
, filename
,
2387 line
, column
, discriminator
, 0))
2390 if (address
< low_pc
)
2392 if (address
> high_pc
)
2395 else switch (op_code
)
2397 case DW_LNS_extended_op
:
2398 exop_len
= _bfd_safe_read_leb128 (abfd
, &line_ptr
,
2400 extended_op
= read_1_byte (abfd
, &line_ptr
, line_end
);
2402 switch (extended_op
)
2404 case DW_LNE_end_sequence
:
2406 if (!add_line_info (table
, address
, op_index
, filename
, line
,
2407 column
, discriminator
, end_sequence
))
2410 if (address
< low_pc
)
2412 if (address
> high_pc
)
2414 if (!arange_add (unit
, &unit
->arange
, low_pc
, high_pc
))
2417 case DW_LNE_set_address
:
2418 address
= read_address (unit
, &line_ptr
, line_end
);
2421 case DW_LNE_define_file
:
2422 cur_file
= read_string (&line_ptr
, line_end
);
2423 dir
= _bfd_safe_read_leb128 (abfd
, &line_ptr
,
2425 xtime
= _bfd_safe_read_leb128 (abfd
, &line_ptr
,
2427 size
= _bfd_safe_read_leb128 (abfd
, &line_ptr
,
2429 if (!line_info_add_file_name (table
, cur_file
, dir
,
2433 case DW_LNE_set_discriminator
:
2435 _bfd_safe_read_leb128 (abfd
, &line_ptr
,
2438 case DW_LNE_HP_source_file_correlation
:
2439 line_ptr
+= exop_len
- 1;
2443 (_("DWARF error: mangled line number section"));
2444 bfd_set_error (bfd_error_bad_value
);
2451 if (!add_line_info (table
, address
, op_index
,
2452 filename
, line
, column
, discriminator
, 0))
2455 if (address
< low_pc
)
2457 if (address
> high_pc
)
2460 case DW_LNS_advance_pc
:
2461 if (lh
.maximum_ops_per_insn
== 1)
2462 address
+= (lh
.minimum_instruction_length
2463 * _bfd_safe_read_leb128 (abfd
, &line_ptr
,
2467 bfd_vma adjust
= _bfd_safe_read_leb128 (abfd
, &line_ptr
,
2469 address
= ((op_index
+ adjust
) / lh
.maximum_ops_per_insn
2470 * lh
.minimum_instruction_length
);
2471 op_index
= (op_index
+ adjust
) % lh
.maximum_ops_per_insn
;
2474 case DW_LNS_advance_line
:
2475 line
+= _bfd_safe_read_leb128 (abfd
, &line_ptr
,
2478 case DW_LNS_set_file
:
2480 unsigned int filenum
;
2482 /* The file and directory tables are 0
2483 based, the references are 1 based. */
2484 filenum
= _bfd_safe_read_leb128 (abfd
, &line_ptr
,
2487 filename
= concat_filename (table
, filenum
);
2490 case DW_LNS_set_column
:
2491 column
= _bfd_safe_read_leb128 (abfd
, &line_ptr
,
2494 case DW_LNS_negate_stmt
:
2495 is_stmt
= (!is_stmt
);
2497 case DW_LNS_set_basic_block
:
2499 case DW_LNS_const_add_pc
:
2500 if (lh
.line_range
== 0)
2502 if (lh
.maximum_ops_per_insn
== 1)
2503 address
+= (lh
.minimum_instruction_length
2504 * ((255 - lh
.opcode_base
) / lh
.line_range
));
2507 bfd_vma adjust
= ((255 - lh
.opcode_base
) / lh
.line_range
);
2508 address
+= (lh
.minimum_instruction_length
2509 * ((op_index
+ adjust
)
2510 / lh
.maximum_ops_per_insn
));
2511 op_index
= (op_index
+ adjust
) % lh
.maximum_ops_per_insn
;
2514 case DW_LNS_fixed_advance_pc
:
2515 address
+= read_2_bytes (abfd
, &line_ptr
, line_end
);
2519 /* Unknown standard opcode, ignore it. */
2520 for (i
= 0; i
< lh
.standard_opcode_lengths
[op_code
]; i
++)
2521 (void) _bfd_safe_read_leb128 (abfd
, &line_ptr
,
2530 if (unit
->line_offset
== 0)
2531 file
->line_table
= table
;
2532 if (sort_line_sequences (table
))
2536 while (table
->sequences
!= NULL
)
2538 struct line_sequence
* seq
= table
->sequences
;
2539 table
->sequences
= table
->sequences
->prev_sequence
;
2542 free (table
->files
);
2547 /* If ADDR is within TABLE set the output parameters and return the
2548 range of addresses covered by the entry used to fill them out.
2549 Otherwise set * FILENAME_PTR to NULL and return 0.
2550 The parameters FILENAME_PTR, LINENUMBER_PTR and DISCRIMINATOR_PTR
2551 are pointers to the objects to be filled in. */
2554 lookup_address_in_line_info_table (struct line_info_table
*table
,
2556 const char **filename_ptr
,
2557 unsigned int *linenumber_ptr
,
2558 unsigned int *discriminator_ptr
)
2560 struct line_sequence
*seq
= NULL
;
2561 struct line_info
*info
;
2564 /* Binary search the array of sequences. */
2566 high
= table
->num_sequences
;
2569 mid
= (low
+ high
) / 2;
2570 seq
= &table
->sequences
[mid
];
2571 if (addr
< seq
->low_pc
)
2573 else if (addr
>= seq
->last_line
->address
)
2579 /* Check for a valid sequence. */
2580 if (!seq
|| addr
< seq
->low_pc
|| addr
>= seq
->last_line
->address
)
2583 if (!build_line_info_table (table
, seq
))
2586 /* Binary search the array of line information. */
2588 high
= seq
->num_lines
;
2592 mid
= (low
+ high
) / 2;
2593 info
= seq
->line_info_lookup
[mid
];
2594 if (addr
< info
->address
)
2596 else if (addr
>= seq
->line_info_lookup
[mid
+ 1]->address
)
2602 /* Check for a valid line information entry. */
2604 && addr
>= info
->address
2605 && addr
< seq
->line_info_lookup
[mid
+ 1]->address
2606 && !(info
->end_sequence
|| info
== seq
->last_line
))
2608 *filename_ptr
= info
->filename
;
2609 *linenumber_ptr
= info
->line
;
2610 if (discriminator_ptr
)
2611 *discriminator_ptr
= info
->discriminator
;
2612 return seq
->last_line
->address
- seq
->low_pc
;
2616 *filename_ptr
= NULL
;
2620 /* Read in the .debug_ranges section for future reference. */
2623 read_debug_ranges (struct comp_unit
* unit
)
2625 struct dwarf2_debug
*stash
= unit
->stash
;
2626 struct dwarf2_debug_file
*file
= unit
->file
;
2628 return read_section (unit
->abfd
, &stash
->debug_sections
[debug_ranges
],
2630 &file
->dwarf_ranges_buffer
, &file
->dwarf_ranges_size
);
2633 /* Read in the .debug_rnglists section for future reference. */
2636 read_debug_rnglists (struct comp_unit
* unit
)
2638 struct dwarf2_debug
*stash
= unit
->stash
;
2639 struct dwarf2_debug_file
*file
= unit
->file
;
2641 return read_section (unit
->abfd
, &stash
->debug_sections
[debug_rnglists
],
2643 &file
->dwarf_rnglists_buffer
, &file
->dwarf_rnglists_size
);
2646 /* Function table functions. */
2649 compare_lookup_funcinfos (const void * a
, const void * b
)
2651 const struct lookup_funcinfo
* lookup1
= a
;
2652 const struct lookup_funcinfo
* lookup2
= b
;
2654 if (lookup1
->low_addr
< lookup2
->low_addr
)
2656 if (lookup1
->low_addr
> lookup2
->low_addr
)
2658 if (lookup1
->high_addr
< lookup2
->high_addr
)
2660 if (lookup1
->high_addr
> lookup2
->high_addr
)
2663 if (lookup1
->idx
< lookup2
->idx
)
2665 if (lookup1
->idx
> lookup2
->idx
)
2671 build_lookup_funcinfo_table (struct comp_unit
* unit
)
2673 struct lookup_funcinfo
*lookup_funcinfo_table
= unit
->lookup_funcinfo_table
;
2674 unsigned int number_of_functions
= unit
->number_of_functions
;
2675 struct funcinfo
*each
;
2676 struct lookup_funcinfo
*entry
;
2678 struct arange
*range
;
2679 bfd_vma low_addr
, high_addr
;
2681 if (lookup_funcinfo_table
|| number_of_functions
== 0)
2684 /* Create the function info lookup table. */
2685 lookup_funcinfo_table
= (struct lookup_funcinfo
*)
2686 bfd_malloc (number_of_functions
* sizeof (struct lookup_funcinfo
));
2687 if (lookup_funcinfo_table
== NULL
)
2690 /* Populate the function info lookup table. */
2691 func_index
= number_of_functions
;
2692 for (each
= unit
->function_table
; each
; each
= each
->prev_func
)
2694 entry
= &lookup_funcinfo_table
[--func_index
];
2695 entry
->funcinfo
= each
;
2696 entry
->idx
= func_index
;
2698 /* Calculate the lowest and highest address for this function entry. */
2699 low_addr
= entry
->funcinfo
->arange
.low
;
2700 high_addr
= entry
->funcinfo
->arange
.high
;
2702 for (range
= entry
->funcinfo
->arange
.next
; range
; range
= range
->next
)
2704 if (range
->low
< low_addr
)
2705 low_addr
= range
->low
;
2706 if (range
->high
> high_addr
)
2707 high_addr
= range
->high
;
2710 entry
->low_addr
= low_addr
;
2711 entry
->high_addr
= high_addr
;
2714 BFD_ASSERT (func_index
== 0);
2716 /* Sort the function by address. */
2717 qsort (lookup_funcinfo_table
,
2718 number_of_functions
,
2719 sizeof (struct lookup_funcinfo
),
2720 compare_lookup_funcinfos
);
2722 /* Calculate the high watermark for each function in the lookup table. */
2723 high_addr
= lookup_funcinfo_table
[0].high_addr
;
2724 for (func_index
= 1; func_index
< number_of_functions
; func_index
++)
2726 entry
= &lookup_funcinfo_table
[func_index
];
2727 if (entry
->high_addr
> high_addr
)
2728 high_addr
= entry
->high_addr
;
2730 entry
->high_addr
= high_addr
;
2733 unit
->lookup_funcinfo_table
= lookup_funcinfo_table
;
2737 /* If ADDR is within UNIT's function tables, set FUNCTION_PTR, and return
2738 TRUE. Note that we need to find the function that has the smallest range
2739 that contains ADDR, to handle inlined functions without depending upon
2740 them being ordered in TABLE by increasing range. */
2743 lookup_address_in_function_table (struct comp_unit
*unit
,
2745 struct funcinfo
**function_ptr
)
2747 unsigned int number_of_functions
= unit
->number_of_functions
;
2748 struct lookup_funcinfo
* lookup_funcinfo
= NULL
;
2749 struct funcinfo
* funcinfo
= NULL
;
2750 struct funcinfo
* best_fit
= NULL
;
2751 bfd_vma best_fit_len
= 0;
2752 bfd_size_type low
, high
, mid
, first
;
2753 struct arange
*arange
;
2755 if (number_of_functions
== 0)
2758 if (!build_lookup_funcinfo_table (unit
))
2761 if (unit
->lookup_funcinfo_table
[number_of_functions
- 1].high_addr
< addr
)
2764 /* Find the first function in the lookup table which may contain the
2765 specified address. */
2767 high
= number_of_functions
;
2771 mid
= (low
+ high
) / 2;
2772 lookup_funcinfo
= &unit
->lookup_funcinfo_table
[mid
];
2773 if (addr
< lookup_funcinfo
->low_addr
)
2775 else if (addr
>= lookup_funcinfo
->high_addr
)
2781 /* Find the 'best' match for the address. The prior algorithm defined the
2782 best match as the function with the smallest address range containing
2783 the specified address. This definition should probably be changed to the
2784 innermost inline routine containing the address, but right now we want
2785 to get the same results we did before. */
2786 while (first
< number_of_functions
)
2788 if (addr
< unit
->lookup_funcinfo_table
[first
].low_addr
)
2790 funcinfo
= unit
->lookup_funcinfo_table
[first
].funcinfo
;
2792 for (arange
= &funcinfo
->arange
; arange
; arange
= arange
->next
)
2794 if (addr
< arange
->low
|| addr
>= arange
->high
)
2798 || arange
->high
- arange
->low
< best_fit_len
2799 /* The following comparison is designed to return the same
2800 match as the previous algorithm for routines which have the
2801 same best fit length. */
2802 || (arange
->high
- arange
->low
== best_fit_len
2803 && funcinfo
> best_fit
))
2805 best_fit
= funcinfo
;
2806 best_fit_len
= arange
->high
- arange
->low
;
2816 *function_ptr
= best_fit
;
2820 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
2821 and LINENUMBER_PTR, and return TRUE. */
2824 lookup_symbol_in_function_table (struct comp_unit
*unit
,
2827 const char **filename_ptr
,
2828 unsigned int *linenumber_ptr
)
2830 struct funcinfo
* each_func
;
2831 struct funcinfo
* best_fit
= NULL
;
2832 bfd_vma best_fit_len
= 0;
2833 struct arange
*arange
;
2834 const char *name
= bfd_asymbol_name (sym
);
2835 asection
*sec
= bfd_asymbol_section (sym
);
2837 for (each_func
= unit
->function_table
;
2839 each_func
= each_func
->prev_func
)
2841 for (arange
= &each_func
->arange
;
2843 arange
= arange
->next
)
2845 if ((!each_func
->sec
|| each_func
->sec
== sec
)
2846 && addr
>= arange
->low
2847 && addr
< arange
->high
2849 && strcmp (name
, each_func
->name
) == 0
2851 || arange
->high
- arange
->low
< best_fit_len
))
2853 best_fit
= each_func
;
2854 best_fit_len
= arange
->high
- arange
->low
;
2861 best_fit
->sec
= sec
;
2862 *filename_ptr
= best_fit
->file
;
2863 *linenumber_ptr
= best_fit
->line
;
2870 /* Variable table functions. */
2872 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
2873 LINENUMBER_PTR, and return TRUE. */
2876 lookup_symbol_in_variable_table (struct comp_unit
*unit
,
2879 const char **filename_ptr
,
2880 unsigned int *linenumber_ptr
)
2882 const char *name
= bfd_asymbol_name (sym
);
2883 asection
*sec
= bfd_asymbol_section (sym
);
2884 struct varinfo
* each
;
2886 for (each
= unit
->variable_table
; each
; each
= each
->prev_var
)
2888 && each
->file
!= NULL
2889 && each
->name
!= NULL
2890 && each
->addr
== addr
2891 && (!each
->sec
|| each
->sec
== sec
)
2892 && strcmp (name
, each
->name
) == 0)
2898 *filename_ptr
= each
->file
;
2899 *linenumber_ptr
= each
->line
;
2906 static struct comp_unit
*stash_comp_unit (struct dwarf2_debug
*,
2907 struct dwarf2_debug_file
*);
2908 static bool comp_unit_maybe_decode_line_info (struct comp_unit
*);
2911 find_abstract_instance (struct comp_unit
*unit
,
2912 struct attribute
*attr_ptr
,
2913 unsigned int recur_count
,
2916 char **filename_ptr
,
2917 int *linenumber_ptr
)
2919 bfd
*abfd
= unit
->abfd
;
2920 bfd_byte
*info_ptr
= NULL
;
2921 bfd_byte
*info_ptr_end
;
2922 unsigned int abbrev_number
, i
;
2923 struct abbrev_info
*abbrev
;
2924 bfd_uint64_t die_ref
= attr_ptr
->u
.val
;
2925 struct attribute attr
;
2926 const char *name
= NULL
;
2928 if (recur_count
== 100)
2931 (_("DWARF error: abstract instance recursion detected"));
2932 bfd_set_error (bfd_error_bad_value
);
2936 /* DW_FORM_ref_addr can reference an entry in a different CU. It
2937 is an offset from the .debug_info section, not the current CU. */
2938 if (attr_ptr
->form
== DW_FORM_ref_addr
)
2940 /* We only support DW_FORM_ref_addr within the same file, so
2941 any relocations should be resolved already. Check this by
2942 testing for a zero die_ref; There can't be a valid reference
2943 to the header of a .debug_info section.
2944 DW_FORM_ref_addr is an offset relative to .debug_info.
2945 Normally when using the GNU linker this is accomplished by
2946 emitting a symbolic reference to a label, because .debug_info
2947 sections are linked at zero. When there are multiple section
2948 groups containing .debug_info, as there might be in a
2949 relocatable object file, it would be reasonable to assume that
2950 a symbolic reference to a label in any .debug_info section
2951 might be used. Since we lay out multiple .debug_info
2952 sections at non-zero VMAs (see place_sections), and read
2953 them contiguously into dwarf_info_buffer, that means the
2954 reference is relative to dwarf_info_buffer. */
2957 info_ptr
= unit
->file
->dwarf_info_buffer
;
2958 info_ptr_end
= info_ptr
+ unit
->file
->dwarf_info_size
;
2959 total
= info_ptr_end
- info_ptr
;
2962 else if (die_ref
>= total
)
2965 (_("DWARF error: invalid abstract instance DIE ref"));
2966 bfd_set_error (bfd_error_bad_value
);
2969 info_ptr
+= die_ref
;
2971 else if (attr_ptr
->form
== DW_FORM_GNU_ref_alt
)
2973 bool first_time
= unit
->stash
->alt
.dwarf_info_buffer
== NULL
;
2975 info_ptr
= read_alt_indirect_ref (unit
, die_ref
);
2977 unit
->stash
->alt
.info_ptr
= unit
->stash
->alt
.dwarf_info_buffer
;
2978 if (info_ptr
== NULL
)
2981 (_("DWARF error: unable to read alt ref %" PRIu64
),
2982 (uint64_t) die_ref
);
2983 bfd_set_error (bfd_error_bad_value
);
2986 info_ptr_end
= (unit
->stash
->alt
.dwarf_info_buffer
2987 + unit
->stash
->alt
.dwarf_info_size
);
2988 if (unit
->stash
->alt
.all_comp_units
)
2989 unit
= unit
->stash
->alt
.all_comp_units
;
2992 if (attr_ptr
->form
== DW_FORM_ref_addr
2993 || attr_ptr
->form
== DW_FORM_GNU_ref_alt
)
2995 /* Now find the CU containing this pointer. */
2996 if (info_ptr
>= unit
->info_ptr_unit
&& info_ptr
< unit
->end_ptr
)
2997 info_ptr_end
= unit
->end_ptr
;
3000 /* Check other CUs to see if they contain the abbrev. */
3001 struct comp_unit
*u
;
3003 for (u
= unit
->prev_unit
; u
!= NULL
; u
= u
->prev_unit
)
3004 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
3008 for (u
= unit
->next_unit
; u
!= NULL
; u
= u
->next_unit
)
3009 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
3012 if (attr_ptr
->form
== DW_FORM_ref_addr
)
3015 u
= stash_comp_unit (unit
->stash
, &unit
->stash
->f
);
3018 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
3023 if (attr_ptr
->form
== DW_FORM_GNU_ref_alt
)
3026 u
= stash_comp_unit (unit
->stash
, &unit
->stash
->alt
);
3029 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
3037 (_("DWARF error: unable to locate abstract instance DIE ref %"
3038 PRIu64
), (uint64_t) die_ref
);
3039 bfd_set_error (bfd_error_bad_value
);
3043 info_ptr_end
= unit
->end_ptr
;
3048 /* DW_FORM_ref1, DW_FORM_ref2, DW_FORM_ref4, DW_FORM_ref8 or
3049 DW_FORM_ref_udata. These are all references relative to the
3050 start of the current CU. */
3053 info_ptr
= unit
->info_ptr_unit
;
3054 info_ptr_end
= unit
->end_ptr
;
3055 total
= info_ptr_end
- info_ptr
;
3056 if (!die_ref
|| die_ref
>= total
)
3059 (_("DWARF error: invalid abstract instance DIE ref"));
3060 bfd_set_error (bfd_error_bad_value
);
3063 info_ptr
+= die_ref
;
3066 abbrev_number
= _bfd_safe_read_leb128 (abfd
, &info_ptr
,
3067 false, info_ptr_end
);
3070 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
3074 (_("DWARF error: could not find abbrev number %u"), abbrev_number
);
3075 bfd_set_error (bfd_error_bad_value
);
3080 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3082 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
,
3083 info_ptr
, info_ptr_end
);
3084 if (info_ptr
== NULL
)
3089 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
3091 if (name
== NULL
&& is_str_form (&attr
))
3094 if (non_mangled (unit
->lang
))
3098 case DW_AT_specification
:
3099 if (is_int_form (&attr
)
3100 && !find_abstract_instance (unit
, &attr
, recur_count
+ 1,
3102 filename_ptr
, linenumber_ptr
))
3105 case DW_AT_linkage_name
:
3106 case DW_AT_MIPS_linkage_name
:
3107 /* PR 16949: Corrupt debug info can place
3108 non-string forms into these attributes. */
3109 if (is_str_form (&attr
))
3115 case DW_AT_decl_file
:
3116 if (!comp_unit_maybe_decode_line_info (unit
))
3118 if (is_int_form (&attr
))
3119 *filename_ptr
= concat_filename (unit
->line_table
,
3122 case DW_AT_decl_line
:
3123 if (is_int_form (&attr
))
3124 *linenumber_ptr
= attr
.u
.val
;
3137 read_ranges (struct comp_unit
*unit
, struct arange
*arange
,
3138 bfd_uint64_t offset
)
3140 bfd_byte
*ranges_ptr
;
3141 bfd_byte
*ranges_end
;
3142 bfd_vma base_address
= unit
->base_address
;
3144 if (! unit
->file
->dwarf_ranges_buffer
)
3146 if (! read_debug_ranges (unit
))
3150 if (offset
> unit
->file
->dwarf_ranges_size
)
3152 ranges_ptr
= unit
->file
->dwarf_ranges_buffer
+ offset
;
3153 ranges_end
= unit
->file
->dwarf_ranges_buffer
+ unit
->file
->dwarf_ranges_size
;
3160 /* PR 17512: file: 62cada7d. */
3161 if (2u * unit
->addr_size
> (size_t) (ranges_end
- ranges_ptr
))
3164 low_pc
= read_address (unit
, &ranges_ptr
, ranges_end
);
3165 high_pc
= read_address (unit
, &ranges_ptr
, ranges_end
);
3167 if (low_pc
== 0 && high_pc
== 0)
3169 if (low_pc
== -1UL && high_pc
!= -1UL)
3170 base_address
= high_pc
;
3173 if (!arange_add (unit
, arange
,
3174 base_address
+ low_pc
, base_address
+ high_pc
))
3182 read_rnglists (struct comp_unit
*unit
, struct arange
*arange
,
3183 bfd_uint64_t offset
)
3187 bfd_vma base_address
= unit
->base_address
;
3190 bfd
*abfd
= unit
->abfd
;
3192 if (! unit
->file
->dwarf_rnglists_buffer
)
3194 if (! read_debug_rnglists (unit
))
3198 rngs_ptr
= unit
->file
->dwarf_rnglists_buffer
+ offset
;
3199 if (rngs_ptr
< unit
->file
->dwarf_rnglists_buffer
)
3201 rngs_end
= unit
->file
->dwarf_rnglists_buffer
;
3202 rngs_end
+= unit
->file
->dwarf_rnglists_size
;
3206 enum dwarf_range_list_entry rlet
;
3208 if (rngs_ptr
>= rngs_end
)
3211 rlet
= read_1_byte (abfd
, &rngs_ptr
, rngs_end
);
3215 case DW_RLE_end_of_list
:
3218 case DW_RLE_base_address
:
3219 if (unit
->addr_size
> (size_t) (rngs_end
- rngs_ptr
))
3221 base_address
= read_address (unit
, &rngs_ptr
, rngs_end
);
3224 case DW_RLE_start_length
:
3225 if (unit
->addr_size
> (size_t) (rngs_end
- rngs_ptr
))
3227 low_pc
= read_address (unit
, &rngs_ptr
, rngs_end
);
3229 high_pc
+= _bfd_safe_read_leb128 (abfd
, &rngs_ptr
,
3233 case DW_RLE_offset_pair
:
3234 low_pc
= base_address
;
3235 low_pc
+= _bfd_safe_read_leb128 (abfd
, &rngs_ptr
,
3237 high_pc
= base_address
;
3238 high_pc
+= _bfd_safe_read_leb128 (abfd
, &rngs_ptr
,
3242 case DW_RLE_start_end
:
3243 if (2u * unit
->addr_size
> (size_t) (rngs_end
- rngs_ptr
))
3245 low_pc
= read_address (unit
, &rngs_ptr
, rngs_end
);
3246 high_pc
= read_address (unit
, &rngs_ptr
, rngs_end
);
3249 /* TODO x-variants need .debug_addr support used for split-dwarf. */
3250 case DW_RLE_base_addressx
:
3251 case DW_RLE_startx_endx
:
3252 case DW_RLE_startx_length
:
3257 if (!arange_add (unit
, arange
, low_pc
, high_pc
))
3263 read_rangelist (struct comp_unit
*unit
, struct arange
*arange
,
3264 bfd_uint64_t offset
)
3266 if (unit
->version
<= 4)
3267 return read_ranges (unit
, arange
, offset
);
3269 return read_rnglists (unit
, arange
, offset
);
3272 static struct funcinfo
*
3273 lookup_func_by_offset (bfd_uint64_t offset
, struct funcinfo
* table
)
3275 for (; table
!= NULL
; table
= table
->prev_func
)
3276 if (table
->unit_offset
== offset
)
3281 static struct varinfo
*
3282 lookup_var_by_offset (bfd_uint64_t offset
, struct varinfo
* table
)
3286 if (table
->unit_offset
== offset
)
3288 table
= table
->prev_var
;
3295 /* DWARF2 Compilation unit functions. */
3297 static struct funcinfo
*
3298 reverse_funcinfo_list (struct funcinfo
*head
)
3300 struct funcinfo
*rhead
;
3301 struct funcinfo
*temp
;
3303 for (rhead
= NULL
; head
; head
= temp
)
3305 temp
= head
->prev_func
;
3306 head
->prev_func
= rhead
;
3312 static struct varinfo
*
3313 reverse_varinfo_list (struct varinfo
*head
)
3315 struct varinfo
*rhead
;
3316 struct varinfo
*temp
;
3318 for (rhead
= NULL
; head
; head
= temp
)
3320 temp
= head
->prev_var
;
3321 head
->prev_var
= rhead
;
3327 /* Scan over each die in a comp. unit looking for functions to add
3328 to the function table and variables to the variable table. */
3331 scan_unit_for_symbols (struct comp_unit
*unit
)
3333 bfd
*abfd
= unit
->abfd
;
3334 bfd_byte
*info_ptr
= unit
->first_child_die_ptr
;
3335 bfd_byte
*info_ptr_end
= unit
->end_ptr
;
3336 int nesting_level
= 0;
3337 struct nest_funcinfo
3339 struct funcinfo
*func
;
3341 int nested_funcs_size
;
3342 struct funcinfo
*last_func
;
3343 struct varinfo
*last_var
;
3345 /* Maintain a stack of in-scope functions and inlined functions, which we
3346 can use to set the caller_func field. */
3347 nested_funcs_size
= 32;
3348 nested_funcs
= (struct nest_funcinfo
*)
3349 bfd_malloc (nested_funcs_size
* sizeof (*nested_funcs
));
3350 if (nested_funcs
== NULL
)
3352 nested_funcs
[nesting_level
].func
= 0;
3354 /* PR 27484: We must scan the DIEs twice. The first time we look for
3355 function and variable tags and accumulate them into their respective
3356 tables. The second time through we process the attributes of the
3357 functions/variables and augment the table entries. */
3358 while (nesting_level
>= 0)
3360 unsigned int abbrev_number
, i
;
3361 struct abbrev_info
*abbrev
;
3362 struct funcinfo
*func
;
3363 struct varinfo
*var
;
3364 bfd_uint64_t current_offset
;
3366 /* PR 17512: file: 9f405d9d. */
3367 if (info_ptr
>= info_ptr_end
)
3370 current_offset
= info_ptr
- unit
->info_ptr_unit
;
3371 abbrev_number
= _bfd_safe_read_leb128 (abfd
, &info_ptr
,
3372 false, info_ptr_end
);
3373 if (abbrev_number
== 0)
3379 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
3382 static unsigned int previous_failed_abbrev
= -1U;
3384 /* Avoid multiple reports of the same missing abbrev. */
3385 if (abbrev_number
!= previous_failed_abbrev
)
3388 (_("DWARF error: could not find abbrev number %u"),
3390 previous_failed_abbrev
= abbrev_number
;
3392 bfd_set_error (bfd_error_bad_value
);
3396 if (abbrev
->tag
== DW_TAG_subprogram
3397 || abbrev
->tag
== DW_TAG_entry_point
3398 || abbrev
->tag
== DW_TAG_inlined_subroutine
)
3400 size_t amt
= sizeof (struct funcinfo
);
3403 func
= (struct funcinfo
*) bfd_zalloc (abfd
, amt
);
3406 func
->tag
= abbrev
->tag
;
3407 func
->prev_func
= unit
->function_table
;
3408 func
->unit_offset
= current_offset
;
3409 unit
->function_table
= func
;
3410 unit
->number_of_functions
++;
3411 BFD_ASSERT (!unit
->cached
);
3413 if (func
->tag
== DW_TAG_inlined_subroutine
)
3414 for (i
= nesting_level
; i
-- != 0; )
3415 if (nested_funcs
[i
].func
)
3417 func
->caller_func
= nested_funcs
[i
].func
;
3420 nested_funcs
[nesting_level
].func
= func
;
3425 if (abbrev
->tag
== DW_TAG_variable
3426 || abbrev
->tag
== DW_TAG_member
)
3428 size_t amt
= sizeof (struct varinfo
);
3430 var
= (struct varinfo
*) bfd_zalloc (abfd
, amt
);
3433 var
->tag
= abbrev
->tag
;
3435 var
->prev_var
= unit
->variable_table
;
3436 unit
->variable_table
= var
;
3437 var
->unit_offset
= current_offset
;
3438 /* PR 18205: Missing debug information can cause this
3439 var to be attached to an already cached unit. */
3444 /* No inline function in scope at this nesting level. */
3445 nested_funcs
[nesting_level
].func
= 0;
3448 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3450 struct attribute attr
;
3452 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
],
3453 unit
, info_ptr
, info_ptr_end
);
3454 if (info_ptr
== NULL
)
3458 if (abbrev
->has_children
)
3462 if (nesting_level
>= nested_funcs_size
)
3464 struct nest_funcinfo
*tmp
;
3466 nested_funcs_size
*= 2;
3467 tmp
= (struct nest_funcinfo
*)
3468 bfd_realloc (nested_funcs
,
3469 nested_funcs_size
* sizeof (*nested_funcs
));
3474 nested_funcs
[nesting_level
].func
= 0;
3478 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
3479 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
3481 /* This is the second pass over the abbrevs. */
3482 info_ptr
= unit
->first_child_die_ptr
;
3488 while (nesting_level
>= 0)
3490 unsigned int abbrev_number
, i
;
3491 struct abbrev_info
*abbrev
;
3492 struct attribute attr
;
3493 struct funcinfo
*func
;
3494 struct varinfo
*var
;
3496 bfd_vma high_pc
= 0;
3497 bool high_pc_relative
= false;
3498 bfd_uint64_t current_offset
;
3500 /* PR 17512: file: 9f405d9d. */
3501 if (info_ptr
>= info_ptr_end
)
3504 current_offset
= info_ptr
- unit
->info_ptr_unit
;
3505 abbrev_number
= _bfd_safe_read_leb128 (abfd
, &info_ptr
,
3506 false, info_ptr_end
);
3507 if (! abbrev_number
)
3513 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
3514 /* This should have been handled above. */
3515 BFD_ASSERT (abbrev
!= NULL
);
3519 if (abbrev
->tag
== DW_TAG_subprogram
3520 || abbrev
->tag
== DW_TAG_entry_point
3521 || abbrev
->tag
== DW_TAG_inlined_subroutine
)
3524 && last_func
->prev_func
3525 && last_func
->prev_func
->unit_offset
== current_offset
)
3526 func
= last_func
->prev_func
;
3528 func
= lookup_func_by_offset (current_offset
, unit
->function_table
);
3535 else if (abbrev
->tag
== DW_TAG_variable
3536 || abbrev
->tag
== DW_TAG_member
)
3539 && last_var
->prev_var
3540 && last_var
->prev_var
->unit_offset
== current_offset
)
3541 var
= last_var
->prev_var
;
3543 var
= lookup_var_by_offset (current_offset
, unit
->variable_table
);
3551 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3553 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
],
3554 unit
, info_ptr
, info_ptr_end
);
3555 if (info_ptr
== NULL
)
3562 case DW_AT_call_file
:
3563 if (is_int_form (&attr
))
3564 func
->caller_file
= concat_filename (unit
->line_table
,
3568 case DW_AT_call_line
:
3569 if (is_int_form (&attr
))
3570 func
->caller_line
= attr
.u
.val
;
3573 case DW_AT_abstract_origin
:
3574 case DW_AT_specification
:
3575 if (is_int_form (&attr
)
3576 && !find_abstract_instance (unit
, &attr
, 0,
3585 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
3587 if (func
->name
== NULL
&& is_str_form (&attr
))
3589 func
->name
= attr
.u
.str
;
3590 if (non_mangled (unit
->lang
))
3591 func
->is_linkage
= true;
3595 case DW_AT_linkage_name
:
3596 case DW_AT_MIPS_linkage_name
:
3597 /* PR 16949: Corrupt debug info can place
3598 non-string forms into these attributes. */
3599 if (is_str_form (&attr
))
3601 func
->name
= attr
.u
.str
;
3602 func
->is_linkage
= true;
3607 if (is_int_form (&attr
))
3608 low_pc
= attr
.u
.val
;
3612 if (is_int_form (&attr
))
3614 high_pc
= attr
.u
.val
;
3615 high_pc_relative
= attr
.form
!= DW_FORM_addr
;
3620 if (is_int_form (&attr
)
3621 && !read_rangelist (unit
, &func
->arange
, attr
.u
.val
))
3625 case DW_AT_decl_file
:
3626 if (is_int_form (&attr
))
3627 func
->file
= concat_filename (unit
->line_table
,
3631 case DW_AT_decl_line
:
3632 if (is_int_form (&attr
))
3633 func
->line
= attr
.u
.val
;
3644 case DW_AT_specification
:
3645 if (is_int_form (&attr
) && attr
.u
.val
)
3647 struct varinfo
* spec_var
;
3649 spec_var
= lookup_var_by_offset (attr
.u
.val
,
3650 unit
->variable_table
);
3651 if (spec_var
== NULL
)
3653 _bfd_error_handler (_("DWARF error: could not find "
3654 "variable specification "
3656 (unsigned long) attr
.u
.val
);
3660 if (var
->name
== NULL
)
3661 var
->name
= spec_var
->name
;
3662 if (var
->file
== NULL
&& spec_var
->file
!= NULL
)
3663 var
->file
= strdup (spec_var
->file
);
3665 var
->line
= spec_var
->line
;
3666 if (var
->sec
== NULL
)
3667 var
->sec
= spec_var
->sec
;
3672 if (is_str_form (&attr
))
3673 var
->name
= attr
.u
.str
;
3676 case DW_AT_decl_file
:
3677 if (is_int_form (&attr
))
3678 var
->file
= concat_filename (unit
->line_table
,
3682 case DW_AT_decl_line
:
3683 if (is_int_form (&attr
))
3684 var
->line
= attr
.u
.val
;
3687 case DW_AT_external
:
3688 if (is_int_form (&attr
) && attr
.u
.val
!= 0)
3692 case DW_AT_location
:
3696 case DW_FORM_block1
:
3697 case DW_FORM_block2
:
3698 case DW_FORM_block4
:
3699 case DW_FORM_exprloc
:
3700 if (attr
.u
.blk
->data
!= NULL
3701 && *attr
.u
.blk
->data
== DW_OP_addr
)
3705 /* Verify that DW_OP_addr is the only opcode in the
3706 location, in which case the block size will be 1
3707 plus the address size. */
3708 /* ??? For TLS variables, gcc can emit
3709 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
3710 which we don't handle here yet. */
3711 if (attr
.u
.blk
->size
== unit
->addr_size
+ 1U)
3712 var
->addr
= bfd_get (unit
->addr_size
* 8,
3714 attr
.u
.blk
->data
+ 1);
3729 if (abbrev
->has_children
)
3732 if (high_pc_relative
)
3735 if (func
&& high_pc
!= 0)
3737 if (!arange_add (unit
, &func
->arange
, low_pc
, high_pc
))
3742 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
3743 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
3745 free (nested_funcs
);
3749 free (nested_funcs
);
3753 /* Parse a DWARF2 compilation unit starting at INFO_PTR. UNIT_LENGTH
3754 includes the compilation unit header that proceeds the DIE's, but
3755 does not include the length field that precedes each compilation
3756 unit header. END_PTR points one past the end of this comp unit.
3757 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
3759 This routine does not read the whole compilation unit; only enough
3760 to get to the line number information for the compilation unit. */
3762 static struct comp_unit
*
3763 parse_comp_unit (struct dwarf2_debug
*stash
,
3764 struct dwarf2_debug_file
*file
,
3766 bfd_vma unit_length
,
3767 bfd_byte
*info_ptr_unit
,
3768 unsigned int offset_size
)
3770 struct comp_unit
* unit
;
3771 unsigned int version
;
3772 bfd_uint64_t abbrev_offset
= 0;
3773 /* Initialize it just to avoid a GCC false warning. */
3774 unsigned int addr_size
= -1;
3775 struct abbrev_info
** abbrevs
;
3776 unsigned int abbrev_number
, i
;
3777 struct abbrev_info
*abbrev
;
3778 struct attribute attr
;
3779 bfd_byte
*end_ptr
= info_ptr
+ unit_length
;
3782 bfd_vma high_pc
= 0;
3783 bfd
*abfd
= file
->bfd_ptr
;
3784 bool high_pc_relative
= false;
3785 enum dwarf_unit_type unit_type
;
3787 version
= read_2_bytes (abfd
, &info_ptr
, end_ptr
);
3788 if (version
< 2 || version
> 5)
3790 /* PR 19872: A version number of 0 probably means that there is padding
3791 at the end of the .debug_info section. Gold puts it there when
3792 performing an incremental link, for example. So do not generate
3793 an error, just return a NULL. */
3797 (_("DWARF error: found dwarf version '%u', this reader"
3798 " only handles version 2, 3, 4 and 5 information"), version
);
3799 bfd_set_error (bfd_error_bad_value
);
3805 unit_type
= DW_UT_compile
;
3808 unit_type
= read_1_byte (abfd
, &info_ptr
, end_ptr
);
3809 addr_size
= read_1_byte (abfd
, &info_ptr
, end_ptr
);
3812 BFD_ASSERT (offset_size
== 4 || offset_size
== 8);
3813 if (offset_size
== 4)
3814 abbrev_offset
= read_4_bytes (abfd
, &info_ptr
, end_ptr
);
3816 abbrev_offset
= read_8_bytes (abfd
, &info_ptr
, end_ptr
);
3819 addr_size
= read_1_byte (abfd
, &info_ptr
, end_ptr
);
3821 if (unit_type
== DW_UT_type
)
3823 /* Skip type signature. */
3826 /* Skip type offset. */
3827 info_ptr
+= offset_size
;
3830 if (addr_size
> sizeof (bfd_vma
))
3833 /* xgettext: c-format */
3834 (_("DWARF error: found address size '%u', this reader"
3835 " can not handle sizes greater than '%u'"),
3837 (unsigned int) sizeof (bfd_vma
));
3838 bfd_set_error (bfd_error_bad_value
);
3842 if (addr_size
!= 2 && addr_size
!= 4 && addr_size
!= 8)
3845 ("DWARF error: found address size '%u', this reader"
3846 " can only handle address sizes '2', '4' and '8'", addr_size
);
3847 bfd_set_error (bfd_error_bad_value
);
3851 /* Read the abbrevs for this compilation unit into a table. */
3852 abbrevs
= read_abbrevs (abfd
, abbrev_offset
, stash
, file
);
3856 abbrev_number
= _bfd_safe_read_leb128 (abfd
, &info_ptr
,
3858 if (! abbrev_number
)
3860 /* PR 19872: An abbrev number of 0 probably means that there is padding
3861 at the end of the .debug_abbrev section. Gold puts it there when
3862 performing an incremental link, for example. So do not generate
3863 an error, just return a NULL. */
3867 abbrev
= lookup_abbrev (abbrev_number
, abbrevs
);
3870 _bfd_error_handler (_("DWARF error: could not find abbrev number %u"),
3872 bfd_set_error (bfd_error_bad_value
);
3876 amt
= sizeof (struct comp_unit
);
3877 unit
= (struct comp_unit
*) bfd_zalloc (abfd
, amt
);
3881 unit
->version
= version
;
3882 unit
->addr_size
= addr_size
;
3883 unit
->offset_size
= offset_size
;
3884 unit
->abbrevs
= abbrevs
;
3885 unit
->end_ptr
= end_ptr
;
3886 unit
->stash
= stash
;
3888 unit
->info_ptr_unit
= info_ptr_unit
;
3890 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3892 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
, end_ptr
);
3893 if (info_ptr
== NULL
)
3896 /* Store the data if it is of an attribute we want to keep in a
3897 partial symbol table. */
3900 case DW_AT_stmt_list
:
3901 if (is_int_form (&attr
))
3904 unit
->line_offset
= attr
.u
.val
;
3909 if (is_str_form (&attr
))
3910 unit
->name
= attr
.u
.str
;
3914 if (is_int_form (&attr
))
3916 low_pc
= attr
.u
.val
;
3917 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
3918 this is the base address to use when reading location
3919 lists or range lists. */
3920 if (abbrev
->tag
== DW_TAG_compile_unit
)
3921 unit
->base_address
= low_pc
;
3926 if (is_int_form (&attr
))
3928 high_pc
= attr
.u
.val
;
3929 high_pc_relative
= attr
.form
!= DW_FORM_addr
;
3934 if (is_int_form (&attr
)
3935 && !read_rangelist (unit
, &unit
->arange
, attr
.u
.val
))
3939 case DW_AT_comp_dir
:
3941 char *comp_dir
= attr
.u
.str
;
3943 /* PR 17512: file: 1fe726be. */
3944 if (!is_str_form (&attr
))
3947 (_("DWARF error: DW_AT_comp_dir attribute encountered with a non-string form"));
3953 /* Irix 6.2 native cc prepends <machine>.: to the compilation
3954 directory, get rid of it. */
3955 char *cp
= strchr (comp_dir
, ':');
3957 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
3960 unit
->comp_dir
= comp_dir
;
3964 case DW_AT_language
:
3965 if (is_int_form (&attr
))
3966 unit
->lang
= attr
.u
.val
;
3973 if (high_pc_relative
)
3977 if (!arange_add (unit
, &unit
->arange
, low_pc
, high_pc
))
3981 unit
->first_child_die_ptr
= info_ptr
;
3985 /* Return TRUE if UNIT may contain the address given by ADDR. When
3986 there are functions written entirely with inline asm statements, the
3987 range info in the compilation unit header may not be correct. We
3988 need to consult the line info table to see if a compilation unit
3989 really contains the given address. */
3992 comp_unit_contains_address (struct comp_unit
*unit
, bfd_vma addr
)
3994 struct arange
*arange
;
3999 arange
= &unit
->arange
;
4002 if (addr
>= arange
->low
&& addr
< arange
->high
)
4004 arange
= arange
->next
;
4011 /* If UNIT contains ADDR, set the output parameters to the values for
4012 the line containing ADDR. The output parameters, FILENAME_PTR,
4013 FUNCTION_PTR, and LINENUMBER_PTR, are pointers to the objects
4016 Returns the range of addresses covered by the entry that was used
4017 to fill in *LINENUMBER_PTR or 0 if it was not filled in. */
4020 comp_unit_find_nearest_line (struct comp_unit
*unit
,
4022 const char **filename_ptr
,
4023 struct funcinfo
**function_ptr
,
4024 unsigned int *linenumber_ptr
,
4025 unsigned int *discriminator_ptr
)
4029 if (!comp_unit_maybe_decode_line_info (unit
))
4032 *function_ptr
= NULL
;
4033 func_p
= lookup_address_in_function_table (unit
, addr
, function_ptr
);
4034 if (func_p
&& (*function_ptr
)->tag
== DW_TAG_inlined_subroutine
)
4035 unit
->stash
->inliner_chain
= *function_ptr
;
4037 return lookup_address_in_line_info_table (unit
->line_table
, addr
,
4043 /* Check to see if line info is already decoded in a comp_unit.
4044 If not, decode it. Returns TRUE if no errors were encountered;
4048 comp_unit_maybe_decode_line_info (struct comp_unit
*unit
)
4053 if (! unit
->line_table
)
4055 if (! unit
->stmtlist
)
4061 unit
->line_table
= decode_line_info (unit
);
4063 if (! unit
->line_table
)
4069 if (unit
->first_child_die_ptr
< unit
->end_ptr
4070 && ! scan_unit_for_symbols (unit
))
4080 /* If UNIT contains SYM at ADDR, set the output parameters to the
4081 values for the line containing SYM. The output parameters,
4082 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
4085 Return TRUE if UNIT contains SYM, and no errors were encountered;
4089 comp_unit_find_line (struct comp_unit
*unit
,
4092 const char **filename_ptr
,
4093 unsigned int *linenumber_ptr
)
4095 if (!comp_unit_maybe_decode_line_info (unit
))
4098 if (sym
->flags
& BSF_FUNCTION
)
4099 return lookup_symbol_in_function_table (unit
, sym
, addr
,
4103 return lookup_symbol_in_variable_table (unit
, sym
, addr
,
4108 /* Extract all interesting funcinfos and varinfos of a compilation
4109 unit into hash tables for faster lookup. Returns TRUE if no
4110 errors were enountered; FALSE otherwise. */
4113 comp_unit_hash_info (struct dwarf2_debug
*stash
,
4114 struct comp_unit
*unit
,
4115 struct info_hash_table
*funcinfo_hash_table
,
4116 struct info_hash_table
*varinfo_hash_table
)
4118 struct funcinfo
* each_func
;
4119 struct varinfo
* each_var
;
4122 BFD_ASSERT (stash
->info_hash_status
!= STASH_INFO_HASH_DISABLED
);
4124 if (!comp_unit_maybe_decode_line_info (unit
))
4127 BFD_ASSERT (!unit
->cached
);
4129 /* To preserve the original search order, we went to visit the function
4130 infos in the reversed order of the list. However, making the list
4131 bi-directional use quite a bit of extra memory. So we reverse
4132 the list first, traverse the list in the now reversed order and
4133 finally reverse the list again to get back the original order. */
4134 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
4135 for (each_func
= unit
->function_table
;
4137 each_func
= each_func
->prev_func
)
4139 /* Skip nameless functions. */
4140 if (each_func
->name
)
4141 /* There is no need to copy name string into hash table as
4142 name string is either in the dwarf string buffer or
4143 info in the stash. */
4144 okay
= insert_info_hash_table (funcinfo_hash_table
, each_func
->name
,
4145 (void*) each_func
, false);
4147 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
4151 /* We do the same for variable infos. */
4152 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
4153 for (each_var
= unit
->variable_table
;
4155 each_var
= each_var
->prev_var
)
4157 /* Skip stack vars and vars with no files or names. */
4158 if (! each_var
->stack
4159 && each_var
->file
!= NULL
4160 && each_var
->name
!= NULL
)
4161 /* There is no need to copy name string into hash table as
4162 name string is either in the dwarf string buffer or
4163 info in the stash. */
4164 okay
= insert_info_hash_table (varinfo_hash_table
, each_var
->name
,
4165 (void*) each_var
, false);
4168 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
4169 unit
->cached
= true;
4173 /* Locate a section in a BFD containing debugging info. The search starts
4174 from the section after AFTER_SEC, or from the first section in the BFD if
4175 AFTER_SEC is NULL. The search works by examining the names of the
4176 sections. There are three permissiable names. The first two are given
4177 by DEBUG_SECTIONS[debug_info] (whose standard DWARF2 names are .debug_info
4178 and .zdebug_info). The third is a prefix .gnu.linkonce.wi.
4179 This is a variation on the .debug_info section which has a checksum
4180 describing the contents appended onto the name. This allows the linker to
4181 identify and discard duplicate debugging sections for different
4182 compilation units. */
4183 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
4186 find_debug_info (bfd
*abfd
, const struct dwarf_debug_section
*debug_sections
,
4187 asection
*after_sec
)
4192 if (after_sec
== NULL
)
4194 look
= debug_sections
[debug_info
].uncompressed_name
;
4195 msec
= bfd_get_section_by_name (abfd
, look
);
4199 look
= debug_sections
[debug_info
].compressed_name
;
4200 msec
= bfd_get_section_by_name (abfd
, look
);
4204 for (msec
= abfd
->sections
; msec
!= NULL
; msec
= msec
->next
)
4205 if (startswith (msec
->name
, GNU_LINKONCE_INFO
))
4211 for (msec
= after_sec
->next
; msec
!= NULL
; msec
= msec
->next
)
4213 look
= debug_sections
[debug_info
].uncompressed_name
;
4214 if (strcmp (msec
->name
, look
) == 0)
4217 look
= debug_sections
[debug_info
].compressed_name
;
4218 if (look
!= NULL
&& strcmp (msec
->name
, look
) == 0)
4221 if (startswith (msec
->name
, GNU_LINKONCE_INFO
))
4228 /* Transfer VMAs from object file to separate debug file. */
4231 set_debug_vma (bfd
*orig_bfd
, bfd
*debug_bfd
)
4235 for (s
= orig_bfd
->sections
, d
= debug_bfd
->sections
;
4236 s
!= NULL
&& d
!= NULL
;
4237 s
= s
->next
, d
= d
->next
)
4239 if ((d
->flags
& SEC_DEBUGGING
) != 0)
4241 /* ??? Assumes 1-1 correspondence between sections in the
4243 if (strcmp (s
->name
, d
->name
) == 0)
4245 d
->output_section
= s
->output_section
;
4246 d
->output_offset
= s
->output_offset
;
4252 /* If the dwarf2 info was found in a separate debug file, return the
4253 debug file section corresponding to the section in the original file
4254 and the debug file symbols. */
4257 _bfd_dwarf2_stash_syms (struct dwarf2_debug
*stash
, bfd
*abfd
,
4258 asection
**sec
, asymbol
***syms
)
4260 if (stash
->f
.bfd_ptr
!= abfd
)
4266 *syms
= stash
->f
.syms
;
4270 for (s
= abfd
->sections
, d
= stash
->f
.bfd_ptr
->sections
;
4271 s
!= NULL
&& d
!= NULL
;
4272 s
= s
->next
, d
= d
->next
)
4274 if ((d
->flags
& SEC_DEBUGGING
) != 0)
4277 && strcmp (s
->name
, d
->name
) == 0)
4280 *syms
= stash
->f
.syms
;
4287 /* Unset vmas for adjusted sections in STASH. */
4290 unset_sections (struct dwarf2_debug
*stash
)
4293 struct adjusted_section
*p
;
4295 i
= stash
->adjusted_section_count
;
4296 p
= stash
->adjusted_sections
;
4297 for (; i
> 0; i
--, p
++)
4298 p
->section
->vma
= 0;
4301 /* Set VMAs for allocated and .debug_info sections in ORIG_BFD, a
4302 relocatable object file. VMAs are normally all zero in relocatable
4303 object files, so if we want to distinguish locations in sections by
4304 address we need to set VMAs so the sections do not overlap. We
4305 also set VMA on .debug_info so that when we have multiple
4306 .debug_info sections (or the linkonce variant) they also do not
4307 overlap. The multiple .debug_info sections make up a single
4308 logical section. ??? We should probably do the same for other
4312 place_sections (bfd
*orig_bfd
, struct dwarf2_debug
*stash
)
4315 struct adjusted_section
*p
;
4317 const char *debug_info_name
;
4319 if (stash
->adjusted_section_count
!= 0)
4321 i
= stash
->adjusted_section_count
;
4322 p
= stash
->adjusted_sections
;
4323 for (; i
> 0; i
--, p
++)
4324 p
->section
->vma
= p
->adj_vma
;
4328 debug_info_name
= stash
->debug_sections
[debug_info
].uncompressed_name
;
4335 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
4339 if ((sect
->output_section
!= NULL
4340 && sect
->output_section
!= sect
4341 && (sect
->flags
& SEC_DEBUGGING
) == 0)
4345 is_debug_info
= (strcmp (sect
->name
, debug_info_name
) == 0
4346 || startswith (sect
->name
, GNU_LINKONCE_INFO
));
4348 if (!((sect
->flags
& SEC_ALLOC
) != 0 && abfd
== orig_bfd
)
4354 if (abfd
== stash
->f
.bfd_ptr
)
4356 abfd
= stash
->f
.bfd_ptr
;
4360 stash
->adjusted_section_count
= -1;
4363 bfd_vma last_vma
= 0, last_dwarf
= 0;
4364 size_t amt
= i
* sizeof (struct adjusted_section
);
4366 p
= (struct adjusted_section
*) bfd_malloc (amt
);
4370 stash
->adjusted_sections
= p
;
4371 stash
->adjusted_section_count
= i
;
4378 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
4383 if ((sect
->output_section
!= NULL
4384 && sect
->output_section
!= sect
4385 && (sect
->flags
& SEC_DEBUGGING
) == 0)
4389 is_debug_info
= (strcmp (sect
->name
, debug_info_name
) == 0
4390 || startswith (sect
->name
, GNU_LINKONCE_INFO
));
4392 if (!((sect
->flags
& SEC_ALLOC
) != 0 && abfd
== orig_bfd
)
4396 sz
= sect
->rawsize
? sect
->rawsize
: sect
->size
;
4400 BFD_ASSERT (sect
->alignment_power
== 0);
4401 sect
->vma
= last_dwarf
;
4406 /* Align the new address to the current section
4408 last_vma
= ((last_vma
4409 + ~(-((bfd_vma
) 1 << sect
->alignment_power
)))
4410 & (-((bfd_vma
) 1 << sect
->alignment_power
)));
4411 sect
->vma
= last_vma
;
4416 p
->adj_vma
= sect
->vma
;
4419 if (abfd
== stash
->f
.bfd_ptr
)
4421 abfd
= stash
->f
.bfd_ptr
;
4425 if (orig_bfd
!= stash
->f
.bfd_ptr
)
4426 set_debug_vma (orig_bfd
, stash
->f
.bfd_ptr
);
4431 /* Look up a funcinfo by name using the given info hash table. If found,
4432 also update the locations pointed to by filename_ptr and linenumber_ptr.
4434 This function returns TRUE if a funcinfo that matches the given symbol
4435 and address is found with any error; otherwise it returns FALSE. */
4438 info_hash_lookup_funcinfo (struct info_hash_table
*hash_table
,
4441 const char **filename_ptr
,
4442 unsigned int *linenumber_ptr
)
4444 struct funcinfo
* each_func
;
4445 struct funcinfo
* best_fit
= NULL
;
4446 bfd_vma best_fit_len
= 0;
4447 struct info_list_node
*node
;
4448 struct arange
*arange
;
4449 const char *name
= bfd_asymbol_name (sym
);
4450 asection
*sec
= bfd_asymbol_section (sym
);
4452 for (node
= lookup_info_hash_table (hash_table
, name
);
4456 each_func
= (struct funcinfo
*) node
->info
;
4457 for (arange
= &each_func
->arange
;
4459 arange
= arange
->next
)
4461 if ((!each_func
->sec
|| each_func
->sec
== sec
)
4462 && addr
>= arange
->low
4463 && addr
< arange
->high
4465 || arange
->high
- arange
->low
< best_fit_len
))
4467 best_fit
= each_func
;
4468 best_fit_len
= arange
->high
- arange
->low
;
4475 best_fit
->sec
= sec
;
4476 *filename_ptr
= best_fit
->file
;
4477 *linenumber_ptr
= best_fit
->line
;
4484 /* Look up a varinfo by name using the given info hash table. If found,
4485 also update the locations pointed to by filename_ptr and linenumber_ptr.
4487 This function returns TRUE if a varinfo that matches the given symbol
4488 and address is found with any error; otherwise it returns FALSE. */
4491 info_hash_lookup_varinfo (struct info_hash_table
*hash_table
,
4494 const char **filename_ptr
,
4495 unsigned int *linenumber_ptr
)
4497 const char *name
= bfd_asymbol_name (sym
);
4498 asection
*sec
= bfd_asymbol_section (sym
);
4499 struct varinfo
* each
;
4500 struct info_list_node
*node
;
4502 for (node
= lookup_info_hash_table (hash_table
, name
);
4506 each
= (struct varinfo
*) node
->info
;
4507 if (each
->addr
== addr
4508 && (!each
->sec
|| each
->sec
== sec
))
4511 *filename_ptr
= each
->file
;
4512 *linenumber_ptr
= each
->line
;
4520 /* Update the funcinfo and varinfo info hash tables if they are
4521 not up to date. Returns TRUE if there is no error; otherwise
4522 returns FALSE and disable the info hash tables. */
4525 stash_maybe_update_info_hash_tables (struct dwarf2_debug
*stash
)
4527 struct comp_unit
*each
;
4529 /* Exit if hash tables are up-to-date. */
4530 if (stash
->f
.all_comp_units
== stash
->hash_units_head
)
4533 if (stash
->hash_units_head
)
4534 each
= stash
->hash_units_head
->prev_unit
;
4536 each
= stash
->f
.last_comp_unit
;
4540 if (!comp_unit_hash_info (stash
, each
, stash
->funcinfo_hash_table
,
4541 stash
->varinfo_hash_table
))
4543 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
4546 each
= each
->prev_unit
;
4549 stash
->hash_units_head
= stash
->f
.all_comp_units
;
4553 /* Check consistency of info hash tables. This is for debugging only. */
4555 static void ATTRIBUTE_UNUSED
4556 stash_verify_info_hash_table (struct dwarf2_debug
*stash
)
4558 struct comp_unit
*each_unit
;
4559 struct funcinfo
*each_func
;
4560 struct varinfo
*each_var
;
4561 struct info_list_node
*node
;
4564 for (each_unit
= stash
->f
.all_comp_units
;
4566 each_unit
= each_unit
->next_unit
)
4568 for (each_func
= each_unit
->function_table
;
4570 each_func
= each_func
->prev_func
)
4572 if (!each_func
->name
)
4574 node
= lookup_info_hash_table (stash
->funcinfo_hash_table
,
4578 while (node
&& !found
)
4580 found
= node
->info
== each_func
;
4586 for (each_var
= each_unit
->variable_table
;
4588 each_var
= each_var
->prev_var
)
4590 if (!each_var
->name
|| !each_var
->file
|| each_var
->stack
)
4592 node
= lookup_info_hash_table (stash
->varinfo_hash_table
,
4596 while (node
&& !found
)
4598 found
= node
->info
== each_var
;
4606 /* Check to see if we want to enable the info hash tables, which consume
4607 quite a bit of memory. Currently we only check the number times
4608 bfd_dwarf2_find_line is called. In the future, we may also want to
4609 take the number of symbols into account. */
4612 stash_maybe_enable_info_hash_tables (bfd
*abfd
, struct dwarf2_debug
*stash
)
4614 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_OFF
);
4616 if (stash
->info_hash_count
++ < STASH_INFO_HASH_TRIGGER
)
4619 /* FIXME: Maybe we should check the reduce_memory_overheads
4620 and optimize fields in the bfd_link_info structure ? */
4622 /* Create hash tables. */
4623 stash
->funcinfo_hash_table
= create_info_hash_table (abfd
);
4624 stash
->varinfo_hash_table
= create_info_hash_table (abfd
);
4625 if (!stash
->funcinfo_hash_table
|| !stash
->varinfo_hash_table
)
4627 /* Turn off info hashes if any allocation above fails. */
4628 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
4631 /* We need a forced update so that the info hash tables will
4632 be created even though there is no compilation unit. That
4633 happens if STASH_INFO_HASH_TRIGGER is 0. */
4634 if (stash_maybe_update_info_hash_tables (stash
))
4635 stash
->info_hash_status
= STASH_INFO_HASH_ON
;
4638 /* Find the file and line associated with a symbol and address using the
4639 info hash tables of a stash. If there is a match, the function returns
4640 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
4641 otherwise it returns FALSE. */
4644 stash_find_line_fast (struct dwarf2_debug
*stash
,
4647 const char **filename_ptr
,
4648 unsigned int *linenumber_ptr
)
4650 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_ON
);
4652 if (sym
->flags
& BSF_FUNCTION
)
4653 return info_hash_lookup_funcinfo (stash
->funcinfo_hash_table
, sym
, addr
,
4654 filename_ptr
, linenumber_ptr
);
4655 return info_hash_lookup_varinfo (stash
->varinfo_hash_table
, sym
, addr
,
4656 filename_ptr
, linenumber_ptr
);
4659 /* Save current section VMAs. */
4662 save_section_vma (const bfd
*abfd
, struct dwarf2_debug
*stash
)
4667 if (abfd
->section_count
== 0)
4669 stash
->sec_vma
= bfd_malloc (sizeof (*stash
->sec_vma
) * abfd
->section_count
);
4670 if (stash
->sec_vma
== NULL
)
4672 stash
->sec_vma_count
= abfd
->section_count
;
4673 for (i
= 0, s
= abfd
->sections
;
4674 s
!= NULL
&& i
< abfd
->section_count
;
4677 if (s
->output_section
!= NULL
)
4678 stash
->sec_vma
[i
] = s
->output_section
->vma
+ s
->output_offset
;
4680 stash
->sec_vma
[i
] = s
->vma
;
4685 /* Compare current section VMAs against those at the time the stash
4686 was created. If find_nearest_line is used in linker warnings or
4687 errors early in the link process, the debug info stash will be
4688 invalid for later calls. This is because we relocate debug info
4689 sections, so the stashed section contents depend on symbol values,
4690 which in turn depend on section VMAs. */
4693 section_vma_same (const bfd
*abfd
, const struct dwarf2_debug
*stash
)
4698 /* PR 24334: If the number of sections in ABFD has changed between
4699 when the stash was created and now, then we cannot trust the
4700 stashed vma information. */
4701 if (abfd
->section_count
!= stash
->sec_vma_count
)
4704 for (i
= 0, s
= abfd
->sections
;
4705 s
!= NULL
&& i
< abfd
->section_count
;
4710 if (s
->output_section
!= NULL
)
4711 vma
= s
->output_section
->vma
+ s
->output_offset
;
4714 if (vma
!= stash
->sec_vma
[i
])
4720 /* Read debug information from DEBUG_BFD when DEBUG_BFD is specified.
4721 If DEBUG_BFD is not specified, we read debug information from ABFD
4722 or its gnu_debuglink. The results will be stored in PINFO.
4723 The function returns TRUE iff debug information is ready. */
4726 _bfd_dwarf2_slurp_debug_info (bfd
*abfd
, bfd
*debug_bfd
,
4727 const struct dwarf_debug_section
*debug_sections
,
4732 size_t amt
= sizeof (struct dwarf2_debug
);
4733 bfd_size_type total_size
;
4735 struct dwarf2_debug
*stash
= (struct dwarf2_debug
*) *pinfo
;
4739 if (stash
->orig_bfd
== abfd
4740 && section_vma_same (abfd
, stash
))
4742 /* Check that we did previously find some debug information
4743 before attempting to make use of it. */
4744 if (stash
->f
.bfd_ptr
!= NULL
)
4746 if (do_place
&& !place_sections (abfd
, stash
))
4753 _bfd_dwarf2_cleanup_debug_info (abfd
, pinfo
);
4754 memset (stash
, 0, amt
);
4758 stash
= (struct dwarf2_debug
*) bfd_zalloc (abfd
, amt
);
4762 stash
->orig_bfd
= abfd
;
4763 stash
->debug_sections
= debug_sections
;
4764 stash
->f
.syms
= symbols
;
4765 if (!save_section_vma (abfd
, stash
))
4768 stash
->f
.abbrev_offsets
= htab_create_alloc (10, hash_abbrev
, eq_abbrev
,
4769 del_abbrev
, calloc
, free
);
4770 if (!stash
->f
.abbrev_offsets
)
4773 stash
->alt
.abbrev_offsets
= htab_create_alloc (10, hash_abbrev
, eq_abbrev
,
4774 del_abbrev
, calloc
, free
);
4775 if (!stash
->alt
.abbrev_offsets
)
4780 if (debug_bfd
== NULL
)
4783 msec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
4784 if (msec
== NULL
&& abfd
== debug_bfd
)
4786 char * debug_filename
;
4788 debug_filename
= bfd_follow_build_id_debuglink (abfd
, DEBUGDIR
);
4789 if (debug_filename
== NULL
)
4790 debug_filename
= bfd_follow_gnu_debuglink (abfd
, DEBUGDIR
);
4792 if (debug_filename
== NULL
)
4793 /* No dwarf2 info, and no gnu_debuglink to follow.
4794 Note that at this point the stash has been allocated, but
4795 contains zeros. This lets future calls to this function
4796 fail more quickly. */
4799 debug_bfd
= bfd_openr (debug_filename
, NULL
);
4800 free (debug_filename
);
4801 if (debug_bfd
== NULL
)
4802 /* FIXME: Should we report our failure to follow the debuglink ? */
4805 /* Set BFD_DECOMPRESS to decompress debug sections. */
4806 debug_bfd
->flags
|= BFD_DECOMPRESS
;
4807 if (!bfd_check_format (debug_bfd
, bfd_object
)
4808 || (msec
= find_debug_info (debug_bfd
,
4809 debug_sections
, NULL
)) == NULL
4810 || !bfd_generic_link_read_symbols (debug_bfd
))
4812 bfd_close (debug_bfd
);
4816 symbols
= bfd_get_outsymbols (debug_bfd
);
4817 stash
->f
.syms
= symbols
;
4818 stash
->close_on_cleanup
= true;
4820 stash
->f
.bfd_ptr
= debug_bfd
;
4823 && !place_sections (abfd
, stash
))
4826 /* There can be more than one DWARF2 info section in a BFD these
4827 days. First handle the easy case when there's only one. If
4828 there's more than one, try case two: none of the sections is
4829 compressed. In that case, read them all in and produce one
4830 large stash. We do this in two passes - in the first pass we
4831 just accumulate the section sizes, and in the second pass we
4832 read in the section's contents. (The allows us to avoid
4833 reallocing the data as we add sections to the stash.) If
4834 some or all sections are compressed, then do things the slow
4835 way, with a bunch of reallocs. */
4837 if (! find_debug_info (debug_bfd
, debug_sections
, msec
))
4839 /* Case 1: only one info section. */
4840 total_size
= msec
->size
;
4841 if (! read_section (debug_bfd
, &stash
->debug_sections
[debug_info
],
4843 &stash
->f
.dwarf_info_buffer
, &total_size
))
4848 /* Case 2: multiple sections. */
4849 for (total_size
= 0;
4851 msec
= find_debug_info (debug_bfd
, debug_sections
, msec
))
4853 /* Catch PR25070 testcase overflowing size calculation here. */
4854 if (total_size
+ msec
->size
< total_size
4855 || total_size
+ msec
->size
< msec
->size
)
4857 bfd_set_error (bfd_error_no_memory
);
4860 total_size
+= msec
->size
;
4863 stash
->f
.dwarf_info_buffer
= (bfd_byte
*) bfd_malloc (total_size
);
4864 if (stash
->f
.dwarf_info_buffer
== NULL
)
4868 for (msec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
4870 msec
= find_debug_info (debug_bfd
, debug_sections
, msec
))
4878 if (!(bfd_simple_get_relocated_section_contents
4879 (debug_bfd
, msec
, stash
->f
.dwarf_info_buffer
+ total_size
,
4887 stash
->f
.info_ptr
= stash
->f
.dwarf_info_buffer
;
4888 stash
->f
.dwarf_info_size
= total_size
;
4892 /* Parse the next DWARF2 compilation unit at FILE->INFO_PTR. */
4894 static struct comp_unit
*
4895 stash_comp_unit (struct dwarf2_debug
*stash
, struct dwarf2_debug_file
*file
)
4897 bfd_size_type length
;
4898 unsigned int offset_size
;
4899 bfd_byte
*info_ptr_unit
= file
->info_ptr
;
4900 bfd_byte
*info_ptr_end
= file
->dwarf_info_buffer
+ file
->dwarf_info_size
;
4902 if (file
->info_ptr
>= info_ptr_end
)
4905 length
= read_4_bytes (file
->bfd_ptr
, &file
->info_ptr
, info_ptr_end
);
4906 /* A 0xffffff length is the DWARF3 way of indicating
4907 we use 64-bit offsets, instead of 32-bit offsets. */
4908 if (length
== 0xffffffff)
4911 length
= read_8_bytes (file
->bfd_ptr
, &file
->info_ptr
, info_ptr_end
);
4913 /* A zero length is the IRIX way of indicating 64-bit offsets,
4914 mostly because the 64-bit length will generally fit in 32
4915 bits, and the endianness helps. */
4916 else if (length
== 0)
4919 length
= read_4_bytes (file
->bfd_ptr
, &file
->info_ptr
, info_ptr_end
);
4921 /* In the absence of the hints above, we assume 32-bit DWARF2
4922 offsets even for targets with 64-bit addresses, because:
4923 a) most of the time these targets will not have generated
4924 more than 2Gb of debug info and so will not need 64-bit
4927 b) if they do use 64-bit offsets but they are not using
4928 the size hints that are tested for above then they are
4929 not conforming to the DWARF3 standard anyway. */
4934 && length
<= (size_t) (info_ptr_end
- file
->info_ptr
))
4936 struct comp_unit
*each
= parse_comp_unit (stash
, file
,
4937 file
->info_ptr
, length
,
4938 info_ptr_unit
, offset_size
);
4941 if (file
->all_comp_units
)
4942 file
->all_comp_units
->prev_unit
= each
;
4944 file
->last_comp_unit
= each
;
4946 each
->next_unit
= file
->all_comp_units
;
4947 file
->all_comp_units
= each
;
4949 file
->info_ptr
+= length
;
4954 /* Don't trust any of the DWARF info after a corrupted length or
4956 file
->info_ptr
= info_ptr_end
;
4960 /* Hash function for an asymbol. */
4963 hash_asymbol (const void *sym
)
4965 const asymbol
*asym
= sym
;
4966 return htab_hash_string (asym
->name
);
4969 /* Equality function for asymbols. */
4972 eq_asymbol (const void *a
, const void *b
)
4974 const asymbol
*sa
= a
;
4975 const asymbol
*sb
= b
;
4976 return strcmp (sa
->name
, sb
->name
) == 0;
4979 /* Scan the debug information in PINFO looking for a DW_TAG_subprogram
4980 abbrev with a DW_AT_low_pc attached to it. Then lookup that same
4981 symbol in SYMBOLS and return the difference between the low_pc and
4982 the symbol's address. Returns 0 if no suitable symbol could be found. */
4985 _bfd_dwarf2_find_symbol_bias (asymbol
** symbols
, void ** pinfo
)
4987 struct dwarf2_debug
*stash
;
4988 struct comp_unit
* unit
;
4990 bfd_signed_vma result
= 0;
4993 stash
= (struct dwarf2_debug
*) *pinfo
;
4995 if (stash
== NULL
|| symbols
== NULL
)
4998 sym_hash
= htab_create_alloc (10, hash_asymbol
, eq_asymbol
,
4999 NULL
, xcalloc
, free
);
5000 for (psym
= symbols
; * psym
!= NULL
; psym
++)
5002 asymbol
* sym
= * psym
;
5004 if (sym
->flags
& BSF_FUNCTION
&& sym
->section
!= NULL
)
5006 void **slot
= htab_find_slot (sym_hash
, sym
, INSERT
);
5011 for (unit
= stash
->f
.all_comp_units
; unit
; unit
= unit
->next_unit
)
5013 struct funcinfo
* func
;
5015 comp_unit_maybe_decode_line_info (unit
);
5017 for (func
= unit
->function_table
; func
!= NULL
; func
= func
->prev_func
)
5018 if (func
->name
&& func
->arange
.low
)
5020 asymbol search
, *sym
;
5022 /* FIXME: Do we need to scan the aranges looking for the lowest pc value ? */
5024 search
.name
= func
->name
;
5025 sym
= htab_find (sym_hash
, &search
);
5028 result
= ((bfd_signed_vma
) func
->arange
.low
) -
5029 ((bfd_signed_vma
) (sym
->value
+ sym
->section
->vma
));
5036 htab_delete (sym_hash
);
5040 /* Find the source code location of SYMBOL. If SYMBOL is NULL
5041 then find the nearest source code location corresponding to
5042 the address SECTION + OFFSET.
5043 Returns 1 if the line is found without error and fills in
5044 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
5045 NULL the FUNCTIONNAME_PTR is also filled in.
5046 Returns 2 if partial information from _bfd_elf_find_function is
5047 returned (function and maybe file) by looking at symbols. DWARF2
5048 info is present but not regarding the requested code location.
5049 Returns 0 otherwise.
5050 SYMBOLS contains the symbol table for ABFD.
5051 DEBUG_SECTIONS contains the name of the dwarf debug sections. */
5054 _bfd_dwarf2_find_nearest_line (bfd
*abfd
,
5059 const char **filename_ptr
,
5060 const char **functionname_ptr
,
5061 unsigned int *linenumber_ptr
,
5062 unsigned int *discriminator_ptr
,
5063 const struct dwarf_debug_section
*debug_sections
,
5066 /* Read each compilation unit from the section .debug_info, and check
5067 to see if it contains the address we are searching for. If yes,
5068 lookup the address, and return the line number info. If no, go
5069 on to the next compilation unit.
5071 We keep a list of all the previously read compilation units, and
5072 a pointer to the next un-read compilation unit. Check the
5073 previously read units before reading more. */
5074 struct dwarf2_debug
*stash
;
5075 /* What address are we looking for? */
5077 struct comp_unit
* each
;
5078 struct funcinfo
*function
= NULL
;
5082 *filename_ptr
= NULL
;
5083 if (functionname_ptr
!= NULL
)
5084 *functionname_ptr
= NULL
;
5085 *linenumber_ptr
= 0;
5086 if (discriminator_ptr
)
5087 *discriminator_ptr
= 0;
5089 if (! _bfd_dwarf2_slurp_debug_info (abfd
, NULL
, debug_sections
,
5091 (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0))
5094 stash
= (struct dwarf2_debug
*) *pinfo
;
5096 do_line
= symbol
!= NULL
;
5099 BFD_ASSERT (section
== NULL
&& offset
== 0 && functionname_ptr
== NULL
);
5100 section
= bfd_asymbol_section (symbol
);
5101 addr
= symbol
->value
;
5105 BFD_ASSERT (section
!= NULL
&& functionname_ptr
!= NULL
);
5108 /* If we have no SYMBOL but the section we're looking at is not a
5109 code section, then take a look through the list of symbols to see
5110 if we have a symbol at the address we're looking for. If we do
5111 then use this to look up line information. This will allow us to
5112 give file and line results for data symbols. We exclude code
5113 symbols here, if we look up a function symbol and then look up the
5114 line information we'll actually return the line number for the
5115 opening '{' rather than the function definition line. This is
5116 because looking up by symbol uses the line table, in which the
5117 first line for a function is usually the opening '{', while
5118 looking up the function by section + offset uses the
5119 DW_AT_decl_line from the function DW_TAG_subprogram for the line,
5120 which will be the line of the function name. */
5121 if (symbols
!= NULL
&& (section
->flags
& SEC_CODE
) == 0)
5125 for (tmp
= symbols
; (*tmp
) != NULL
; ++tmp
)
5126 if ((*tmp
)->the_bfd
== abfd
5127 && (*tmp
)->section
== section
5128 && (*tmp
)->value
== offset
5129 && ((*tmp
)->flags
& BSF_SECTION_SYM
) == 0)
5133 /* For local symbols, keep going in the hope we find a
5135 if ((symbol
->flags
& BSF_GLOBAL
) != 0)
5141 if (section
->output_section
)
5142 addr
+= section
->output_section
->vma
+ section
->output_offset
;
5144 addr
+= section
->vma
;
5146 /* A null info_ptr indicates that there is no dwarf2 info
5147 (or that an error occured while setting up the stash). */
5148 if (! stash
->f
.info_ptr
)
5151 stash
->inliner_chain
= NULL
;
5153 /* Check the previously read comp. units first. */
5156 /* The info hash tables use quite a bit of memory. We may not want to
5157 always use them. We use some heuristics to decide if and when to
5159 if (stash
->info_hash_status
== STASH_INFO_HASH_OFF
)
5160 stash_maybe_enable_info_hash_tables (abfd
, stash
);
5162 /* Keep info hash table up to date if they are available. Note that we
5163 may disable the hash tables if there is any error duing update. */
5164 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
5165 stash_maybe_update_info_hash_tables (stash
);
5167 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
5169 found
= stash_find_line_fast (stash
, symbol
, addr
, filename_ptr
,
5176 /* Check the previously read comp. units first. */
5177 for (each
= stash
->f
.all_comp_units
; each
; each
= each
->next_unit
)
5178 if ((symbol
->flags
& BSF_FUNCTION
) == 0
5179 || each
->arange
.high
== 0
5180 || comp_unit_contains_address (each
, addr
))
5182 found
= comp_unit_find_line (each
, symbol
, addr
, filename_ptr
,
5191 bfd_vma min_range
= (bfd_vma
) -1;
5192 const char * local_filename
= NULL
;
5193 struct funcinfo
*local_function
= NULL
;
5194 unsigned int local_linenumber
= 0;
5195 unsigned int local_discriminator
= 0;
5197 for (each
= stash
->f
.all_comp_units
; each
; each
= each
->next_unit
)
5199 bfd_vma range
= (bfd_vma
) -1;
5201 found
= ((each
->arange
.high
== 0
5202 || comp_unit_contains_address (each
, addr
))
5203 && (range
= (comp_unit_find_nearest_line
5204 (each
, addr
, &local_filename
,
5205 &local_function
, &local_linenumber
,
5206 &local_discriminator
))) != 0);
5209 /* PRs 15935 15994: Bogus debug information may have provided us
5210 with an erroneous match. We attempt to counter this by
5211 selecting the match that has the smallest address range
5212 associated with it. (We are assuming that corrupt debug info
5213 will tend to result in extra large address ranges rather than
5214 extra small ranges).
5216 This does mean that we scan through all of the CUs associated
5217 with the bfd each time this function is called. But this does
5218 have the benefit of producing consistent results every time the
5219 function is called. */
5220 if (range
<= min_range
)
5222 if (filename_ptr
&& local_filename
)
5223 * filename_ptr
= local_filename
;
5225 function
= local_function
;
5226 if (discriminator_ptr
&& local_discriminator
)
5227 * discriminator_ptr
= local_discriminator
;
5228 if (local_linenumber
)
5229 * linenumber_ptr
= local_linenumber
;
5235 if (* linenumber_ptr
)
5242 /* Read each remaining comp. units checking each as they are read. */
5243 while ((each
= stash_comp_unit (stash
, &stash
->f
)) != NULL
)
5245 /* DW_AT_low_pc and DW_AT_high_pc are optional for
5246 compilation units. If we don't have them (i.e.,
5247 unit->high == 0), we need to consult the line info table
5248 to see if a compilation unit contains the given
5251 found
= (((symbol
->flags
& BSF_FUNCTION
) == 0
5252 || each
->arange
.high
== 0
5253 || comp_unit_contains_address (each
, addr
))
5254 && comp_unit_find_line (each
, symbol
, addr
,
5255 filename_ptr
, linenumber_ptr
));
5257 found
= ((each
->arange
.high
== 0
5258 || comp_unit_contains_address (each
, addr
))
5259 && comp_unit_find_nearest_line (each
, addr
,
5263 discriminator_ptr
) != 0);
5270 if (functionname_ptr
&& function
&& function
->is_linkage
)
5272 *functionname_ptr
= function
->name
;
5276 else if (functionname_ptr
5277 && (!*functionname_ptr
5278 || (function
&& !function
->is_linkage
)))
5281 asymbol
**syms
= symbols
;
5282 asection
*sec
= section
;
5284 _bfd_dwarf2_stash_syms (stash
, abfd
, &sec
, &syms
);
5285 fun
= _bfd_elf_find_function (abfd
, syms
, sec
, offset
,
5286 *filename_ptr
? NULL
: filename_ptr
,
5289 if (!found
&& fun
!= NULL
)
5292 if (function
&& !function
->is_linkage
)
5296 sec_vma
= section
->vma
;
5297 if (section
->output_section
!= NULL
)
5298 sec_vma
= section
->output_section
->vma
+ section
->output_offset
;
5300 *functionname_ptr
= function
->name
;
5301 else if (fun
->value
+ sec_vma
== function
->arange
.low
)
5302 function
->name
= *functionname_ptr
;
5303 /* Even if we didn't find a linkage name, say that we have
5304 to stop a repeated search of symbols. */
5305 function
->is_linkage
= true;
5309 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
5310 unset_sections (stash
);
5316 _bfd_dwarf2_find_inliner_info (bfd
*abfd ATTRIBUTE_UNUSED
,
5317 const char **filename_ptr
,
5318 const char **functionname_ptr
,
5319 unsigned int *linenumber_ptr
,
5322 struct dwarf2_debug
*stash
;
5324 stash
= (struct dwarf2_debug
*) *pinfo
;
5327 struct funcinfo
*func
= stash
->inliner_chain
;
5329 if (func
&& func
->caller_func
)
5331 *filename_ptr
= func
->caller_file
;
5332 *functionname_ptr
= func
->caller_func
->name
;
5333 *linenumber_ptr
= func
->caller_line
;
5334 stash
->inliner_chain
= func
->caller_func
;
5343 _bfd_dwarf2_cleanup_debug_info (bfd
*abfd
, void **pinfo
)
5345 struct dwarf2_debug
*stash
= (struct dwarf2_debug
*) *pinfo
;
5346 struct comp_unit
*each
;
5347 struct dwarf2_debug_file
*file
;
5349 if (abfd
== NULL
|| stash
== NULL
)
5352 if (stash
->varinfo_hash_table
)
5353 bfd_hash_table_free (&stash
->varinfo_hash_table
->base
);
5354 if (stash
->funcinfo_hash_table
)
5355 bfd_hash_table_free (&stash
->funcinfo_hash_table
->base
);
5360 for (each
= file
->all_comp_units
; each
; each
= each
->next_unit
)
5362 struct funcinfo
*function_table
= each
->function_table
;
5363 struct varinfo
*variable_table
= each
->variable_table
;
5365 if (each
->line_table
&& each
->line_table
!= file
->line_table
)
5367 free (each
->line_table
->files
);
5368 free (each
->line_table
->dirs
);
5371 free (each
->lookup_funcinfo_table
);
5372 each
->lookup_funcinfo_table
= NULL
;
5374 while (function_table
)
5376 free (function_table
->file
);
5377 function_table
->file
= NULL
;
5378 free (function_table
->caller_file
);
5379 function_table
->caller_file
= NULL
;
5380 function_table
= function_table
->prev_func
;
5383 while (variable_table
)
5385 free (variable_table
->file
);
5386 variable_table
->file
= NULL
;
5387 variable_table
= variable_table
->prev_var
;
5391 if (file
->line_table
)
5393 free (file
->line_table
->files
);
5394 free (file
->line_table
->dirs
);
5396 htab_delete (file
->abbrev_offsets
);
5398 free (file
->dwarf_line_str_buffer
);
5399 free (file
->dwarf_str_buffer
);
5400 free (file
->dwarf_ranges_buffer
);
5401 free (file
->dwarf_line_buffer
);
5402 free (file
->dwarf_abbrev_buffer
);
5403 free (file
->dwarf_info_buffer
);
5404 if (file
== &stash
->alt
)
5408 free (stash
->sec_vma
);
5409 free (stash
->adjusted_sections
);
5410 if (stash
->close_on_cleanup
)
5411 bfd_close (stash
->f
.bfd_ptr
);
5412 if (stash
->alt
.bfd_ptr
)
5413 bfd_close (stash
->alt
.bfd_ptr
);
5416 /* Find the function to a particular section and offset,
5417 for error reporting. */
5420 _bfd_elf_find_function (bfd
*abfd
,
5424 const char **filename_ptr
,
5425 const char **functionname_ptr
)
5427 struct elf_find_function_cache
5429 asection
*last_section
;
5431 const char *filename
;
5432 bfd_size_type func_size
;
5435 if (symbols
== NULL
)
5438 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
5441 cache
= elf_tdata (abfd
)->elf_find_function_cache
;
5444 cache
= bfd_zalloc (abfd
, sizeof (*cache
));
5445 elf_tdata (abfd
)->elf_find_function_cache
= cache
;
5449 if (cache
->last_section
!= section
5450 || cache
->func
== NULL
5451 || offset
< cache
->func
->value
5452 || offset
>= cache
->func
->value
+ cache
->func_size
)
5457 /* ??? Given multiple file symbols, it is impossible to reliably
5458 choose the right file name for global symbols. File symbols are
5459 local symbols, and thus all file symbols must sort before any
5460 global symbols. The ELF spec may be interpreted to say that a
5461 file symbol must sort before other local symbols, but currently
5462 ld -r doesn't do this. So, for ld -r output, it is possible to
5463 make a better choice of file name for local symbols by ignoring
5464 file symbols appearing after a given local symbol. */
5465 enum { nothing_seen
, symbol_seen
, file_after_symbol_seen
} state
;
5466 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5470 state
= nothing_seen
;
5471 cache
->filename
= NULL
;
5473 cache
->func_size
= 0;
5474 cache
->last_section
= section
;
5476 for (p
= symbols
; *p
!= NULL
; p
++)
5482 if ((sym
->flags
& BSF_FILE
) != 0)
5485 if (state
== symbol_seen
)
5486 state
= file_after_symbol_seen
;
5490 size
= bed
->maybe_function_sym (sym
, section
, &code_off
);
5492 && code_off
<= offset
5493 && (code_off
> low_func
5494 || (code_off
== low_func
5495 && size
> cache
->func_size
)))
5498 cache
->func_size
= size
;
5499 cache
->filename
= NULL
;
5500 low_func
= code_off
;
5502 && ((sym
->flags
& BSF_LOCAL
) != 0
5503 || state
!= file_after_symbol_seen
))
5504 cache
->filename
= bfd_asymbol_name (file
);
5506 if (state
== nothing_seen
)
5507 state
= symbol_seen
;
5511 if (cache
->func
== NULL
)
5515 *filename_ptr
= cache
->filename
;
5516 if (functionname_ptr
)
5517 *functionname_ptr
= bfd_asymbol_name (cache
->func
);