2 Copyright (C) 1994-2021 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
);
563 _bfd_error_handler (_("DWARF error: section %s is larger than its filesize! (0x%lx vs 0x%lx)"),
564 section_name
, (long) amt
, (long) filesize
);
565 bfd_set_error (bfd_error_bad_value
);
569 /* Paranoia - alloc one extra so that we can make sure a string
570 section is NUL terminated. */
574 /* Paranoia - this should never happen. */
575 bfd_set_error (bfd_error_no_memory
);
578 contents
= (bfd_byte
*) bfd_malloc (amt
);
579 if (contents
== NULL
)
582 ? !bfd_simple_get_relocated_section_contents (abfd
, msec
, contents
,
584 : !bfd_get_section_contents (abfd
, msec
, contents
, 0, *section_size
))
589 contents
[*section_size
] = 0;
590 *section_buffer
= contents
;
593 /* It is possible to get a bad value for the offset into the section
594 that the client wants. Validate it here to avoid trouble later. */
595 if (offset
!= 0 && offset
>= *section_size
)
597 /* xgettext: c-format */
598 _bfd_error_handler (_("DWARF error: offset (%" PRIu64
")"
599 " greater than or equal to %s size (%" PRIu64
")"),
600 (uint64_t) offset
, section_name
,
601 (uint64_t) *section_size
);
602 bfd_set_error (bfd_error_bad_value
);
609 /* Read dwarf information from a buffer. */
611 static inline uint64_t
612 read_n_bytes (bfd
*abfd
, bfd_byte
**ptr
, bfd_byte
*end
, int n
)
614 bfd_byte
*buf
= *ptr
;
621 return bfd_get (n
* 8, abfd
, buf
);
625 read_1_byte (bfd
*abfd
, bfd_byte
**ptr
, bfd_byte
*end
)
627 return read_n_bytes (abfd
, ptr
, end
, 1);
631 read_1_signed_byte (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_byte
**ptr
, bfd_byte
*end
)
633 bfd_byte
*buf
= *ptr
;
640 return bfd_get_signed_8 (abfd
, buf
);
644 read_2_bytes (bfd
*abfd
, bfd_byte
**ptr
, bfd_byte
*end
)
646 return read_n_bytes (abfd
, ptr
, end
, 2);
650 read_3_bytes (bfd
*abfd
, bfd_byte
**ptr
, bfd_byte
*end
)
652 unsigned int val
= read_1_byte (abfd
, ptr
, end
);
654 val
|= read_1_byte (abfd
, ptr
, end
);
656 val
|= read_1_byte (abfd
, ptr
, end
);
657 if (bfd_little_endian (abfd
))
658 val
= (((val
>> 16) & 0xff)
660 | ((val
& 0xff) << 16));
665 read_4_bytes (bfd
*abfd
, bfd_byte
**ptr
, bfd_byte
*end
)
667 return read_n_bytes (abfd
, ptr
, end
, 4);
671 read_8_bytes (bfd
*abfd
, bfd_byte
**ptr
, bfd_byte
*end
)
673 return read_n_bytes (abfd
, ptr
, end
, 8);
676 static struct dwarf_block
*
677 read_blk (bfd
*abfd
, bfd_byte
**ptr
, bfd_byte
*end
, size_t size
)
679 bfd_byte
*buf
= *ptr
;
680 struct dwarf_block
*block
;
682 block
= (struct dwarf_block
*) bfd_alloc (abfd
, sizeof (*block
));
686 if (size
> (size_t) (end
- buf
))
701 /* Scans a NUL terminated string starting at *PTR, returning a pointer to it.
702 Bytes at or beyond BUF_END will not be read. Returns NULL if the
703 terminator is not found or if the string is empty. *PTR is
704 incremented over the bytes scanned, including the terminator. */
707 read_string (bfd_byte
**ptr
,
710 bfd_byte
*buf
= *ptr
;
713 while (buf
< buf_end
)
726 /* Reads an offset from *PTR and then locates the string at this offset
727 inside the debug string section. Returns a pointer to the string.
728 Increments *PTR by the number of bytes read for the offset. This
729 value is set even if the function fails. Bytes at or beyond
730 BUF_END will not be read. Returns NULL if there was a problem, or
731 if the string is empty. Does not check for NUL termination of the
735 read_indirect_string (struct comp_unit
*unit
,
740 struct dwarf2_debug
*stash
= unit
->stash
;
741 struct dwarf2_debug_file
*file
= unit
->file
;
744 if (unit
->offset_size
> (size_t) (buf_end
- *ptr
))
750 if (unit
->offset_size
== 4)
751 offset
= read_4_bytes (unit
->abfd
, ptr
, buf_end
);
753 offset
= read_8_bytes (unit
->abfd
, ptr
, buf_end
);
755 if (! read_section (unit
->abfd
, &stash
->debug_sections
[debug_str
],
757 &file
->dwarf_str_buffer
, &file
->dwarf_str_size
))
760 str
= (char *) file
->dwarf_str_buffer
+ offset
;
766 /* Like read_indirect_string but from .debug_line_str section. */
769 read_indirect_line_string (struct comp_unit
*unit
,
774 struct dwarf2_debug
*stash
= unit
->stash
;
775 struct dwarf2_debug_file
*file
= unit
->file
;
778 if (unit
->offset_size
> (size_t) (buf_end
- *ptr
))
784 if (unit
->offset_size
== 4)
785 offset
= read_4_bytes (unit
->abfd
, ptr
, buf_end
);
787 offset
= read_8_bytes (unit
->abfd
, ptr
, buf_end
);
789 if (! read_section (unit
->abfd
, &stash
->debug_sections
[debug_line_str
],
791 &file
->dwarf_line_str_buffer
,
792 &file
->dwarf_line_str_size
))
795 str
= (char *) file
->dwarf_line_str_buffer
+ offset
;
801 /* Like read_indirect_string but uses a .debug_str located in
802 an alternate file pointed to by the .gnu_debugaltlink section.
803 Used to impement DW_FORM_GNU_strp_alt. */
806 read_alt_indirect_string (struct comp_unit
*unit
,
811 struct dwarf2_debug
*stash
= unit
->stash
;
814 if (unit
->offset_size
> (size_t) (buf_end
- *ptr
))
820 if (unit
->offset_size
== 4)
821 offset
= read_4_bytes (unit
->abfd
, ptr
, buf_end
);
823 offset
= read_8_bytes (unit
->abfd
, ptr
, buf_end
);
825 if (stash
->alt
.bfd_ptr
== NULL
)
828 char *debug_filename
= bfd_follow_gnu_debugaltlink (unit
->abfd
, DEBUGDIR
);
830 if (debug_filename
== NULL
)
833 debug_bfd
= bfd_openr (debug_filename
, NULL
);
834 free (debug_filename
);
835 if (debug_bfd
== NULL
)
836 /* FIXME: Should we report our failure to follow the debuglink ? */
839 if (!bfd_check_format (debug_bfd
, bfd_object
))
841 bfd_close (debug_bfd
);
844 stash
->alt
.bfd_ptr
= debug_bfd
;
847 if (! read_section (unit
->stash
->alt
.bfd_ptr
,
848 stash
->debug_sections
+ debug_str_alt
,
849 stash
->alt
.syms
, offset
,
850 &stash
->alt
.dwarf_str_buffer
,
851 &stash
->alt
.dwarf_str_size
))
854 str
= (char *) stash
->alt
.dwarf_str_buffer
+ offset
;
861 /* Resolve an alternate reference from UNIT at OFFSET.
862 Returns a pointer into the loaded alternate CU upon success
863 or NULL upon failure. */
866 read_alt_indirect_ref (struct comp_unit
* unit
,
869 struct dwarf2_debug
*stash
= unit
->stash
;
871 if (stash
->alt
.bfd_ptr
== NULL
)
874 char *debug_filename
= bfd_follow_gnu_debugaltlink (unit
->abfd
, DEBUGDIR
);
876 if (debug_filename
== NULL
)
879 debug_bfd
= bfd_openr (debug_filename
, NULL
);
880 free (debug_filename
);
881 if (debug_bfd
== NULL
)
882 /* FIXME: Should we report our failure to follow the debuglink ? */
885 if (!bfd_check_format (debug_bfd
, bfd_object
))
887 bfd_close (debug_bfd
);
890 stash
->alt
.bfd_ptr
= debug_bfd
;
893 if (! read_section (unit
->stash
->alt
.bfd_ptr
,
894 stash
->debug_sections
+ debug_info_alt
,
895 stash
->alt
.syms
, offset
,
896 &stash
->alt
.dwarf_info_buffer
,
897 &stash
->alt
.dwarf_info_size
))
900 return stash
->alt
.dwarf_info_buffer
+ offset
;
904 read_address (struct comp_unit
*unit
, bfd_byte
**ptr
, bfd_byte
*buf_end
)
906 bfd_byte
*buf
= *ptr
;
909 if (bfd_get_flavour (unit
->abfd
) == bfd_target_elf_flavour
)
910 signed_vma
= get_elf_backend_data (unit
->abfd
)->sign_extend_vma
;
912 if (unit
->addr_size
> (size_t) (buf_end
- buf
))
918 *ptr
= buf
+ unit
->addr_size
;
921 switch (unit
->addr_size
)
924 return bfd_get_signed_64 (unit
->abfd
, buf
);
926 return bfd_get_signed_32 (unit
->abfd
, buf
);
928 return bfd_get_signed_16 (unit
->abfd
, buf
);
935 switch (unit
->addr_size
)
938 return bfd_get_64 (unit
->abfd
, buf
);
940 return bfd_get_32 (unit
->abfd
, buf
);
942 return bfd_get_16 (unit
->abfd
, buf
);
949 /* Lookup an abbrev_info structure in the abbrev hash table. */
951 static struct abbrev_info
*
952 lookup_abbrev (unsigned int number
, struct abbrev_info
**abbrevs
)
954 unsigned int hash_number
;
955 struct abbrev_info
*abbrev
;
957 hash_number
= number
% ABBREV_HASH_SIZE
;
958 abbrev
= abbrevs
[hash_number
];
962 if (abbrev
->number
== number
)
965 abbrev
= abbrev
->next
;
971 /* We keep a hash table to map .debug_abbrev section offsets to the
972 array of abbrevs, so that compilation units using the same set of
973 abbrevs do not waste memory. */
975 struct abbrev_offset_entry
978 struct abbrev_info
**abbrevs
;
982 hash_abbrev (const void *p
)
984 const struct abbrev_offset_entry
*ent
= p
;
985 return htab_hash_pointer ((void *) ent
->offset
);
989 eq_abbrev (const void *pa
, const void *pb
)
991 const struct abbrev_offset_entry
*a
= pa
;
992 const struct abbrev_offset_entry
*b
= pb
;
993 return a
->offset
== b
->offset
;
999 struct abbrev_offset_entry
*ent
= p
;
1000 struct abbrev_info
**abbrevs
= ent
->abbrevs
;
1003 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
1005 struct abbrev_info
*abbrev
= abbrevs
[i
];
1009 free (abbrev
->attrs
);
1010 abbrev
= abbrev
->next
;
1016 /* In DWARF version 2, the description of the debugging information is
1017 stored in a separate .debug_abbrev section. Before we read any
1018 dies from a section we read in all abbreviations and install them
1021 static struct abbrev_info
**
1022 read_abbrevs (bfd
*abfd
, bfd_uint64_t offset
, struct dwarf2_debug
*stash
,
1023 struct dwarf2_debug_file
*file
)
1025 struct abbrev_info
**abbrevs
;
1026 bfd_byte
*abbrev_ptr
;
1027 bfd_byte
*abbrev_end
;
1028 struct abbrev_info
*cur_abbrev
;
1029 unsigned int abbrev_number
, abbrev_name
;
1030 unsigned int abbrev_form
, hash_number
;
1033 struct abbrev_offset_entry ent
= { offset
, NULL
};
1035 if (ent
.offset
!= offset
)
1038 slot
= htab_find_slot (file
->abbrev_offsets
, &ent
, INSERT
);
1042 return ((struct abbrev_offset_entry
*) (*slot
))->abbrevs
;
1044 if (! read_section (abfd
, &stash
->debug_sections
[debug_abbrev
],
1046 &file
->dwarf_abbrev_buffer
,
1047 &file
->dwarf_abbrev_size
))
1050 amt
= sizeof (struct abbrev_info
*) * ABBREV_HASH_SIZE
;
1051 abbrevs
= (struct abbrev_info
**) bfd_zalloc (abfd
, amt
);
1052 if (abbrevs
== NULL
)
1055 abbrev_ptr
= file
->dwarf_abbrev_buffer
+ offset
;
1056 abbrev_end
= file
->dwarf_abbrev_buffer
+ file
->dwarf_abbrev_size
;
1057 abbrev_number
= _bfd_safe_read_leb128 (abfd
, &abbrev_ptr
,
1060 /* Loop until we reach an abbrev number of 0. */
1061 while (abbrev_number
)
1063 amt
= sizeof (struct abbrev_info
);
1064 cur_abbrev
= (struct abbrev_info
*) bfd_zalloc (abfd
, amt
);
1065 if (cur_abbrev
== NULL
)
1068 /* Read in abbrev header. */
1069 cur_abbrev
->number
= abbrev_number
;
1070 cur_abbrev
->tag
= (enum dwarf_tag
)
1071 _bfd_safe_read_leb128 (abfd
, &abbrev_ptr
,
1073 cur_abbrev
->has_children
= read_1_byte (abfd
, &abbrev_ptr
, abbrev_end
);
1075 /* Now read in declarations. */
1078 /* Initialize it just to avoid a GCC false warning. */
1079 bfd_vma implicit_const
= -1;
1081 abbrev_name
= _bfd_safe_read_leb128 (abfd
, &abbrev_ptr
,
1083 abbrev_form
= _bfd_safe_read_leb128 (abfd
, &abbrev_ptr
,
1085 if (abbrev_form
== DW_FORM_implicit_const
)
1086 implicit_const
= _bfd_safe_read_leb128 (abfd
, &abbrev_ptr
,
1088 if (abbrev_name
== 0)
1091 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
1093 struct attr_abbrev
*tmp
;
1095 amt
= cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
;
1096 amt
*= sizeof (struct attr_abbrev
);
1097 tmp
= (struct attr_abbrev
*) bfd_realloc (cur_abbrev
->attrs
, amt
);
1100 cur_abbrev
->attrs
= tmp
;
1103 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
1104 = (enum dwarf_attribute
) abbrev_name
;
1105 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].form
1106 = (enum dwarf_form
) abbrev_form
;
1107 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].implicit_const
1109 ++cur_abbrev
->num_attrs
;
1112 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
1113 cur_abbrev
->next
= abbrevs
[hash_number
];
1114 abbrevs
[hash_number
] = cur_abbrev
;
1116 /* Get next abbreviation.
1117 Under Irix6 the abbreviations for a compilation unit are not
1118 always properly terminated with an abbrev number of 0.
1119 Exit loop if we encounter an abbreviation which we have
1120 already read (which means we are about to read the abbreviations
1121 for the next compile unit) or if the end of the abbreviation
1122 table is reached. */
1123 if ((size_t) (abbrev_ptr
- file
->dwarf_abbrev_buffer
)
1124 >= file
->dwarf_abbrev_size
)
1126 abbrev_number
= _bfd_safe_read_leb128 (abfd
, &abbrev_ptr
,
1128 if (lookup_abbrev (abbrev_number
, abbrevs
) != NULL
)
1132 *slot
= bfd_malloc (sizeof ent
);
1135 ent
.abbrevs
= abbrevs
;
1136 memcpy (*slot
, &ent
, sizeof ent
);
1140 if (abbrevs
!= NULL
)
1144 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
1146 struct abbrev_info
*abbrev
= abbrevs
[i
];
1150 free (abbrev
->attrs
);
1151 abbrev
= abbrev
->next
;
1159 /* Returns true if the form is one which has a string value. */
1162 is_str_attr (enum dwarf_form form
)
1164 return (form
== DW_FORM_string
1165 || form
== DW_FORM_strp
1166 || form
== DW_FORM_strx
1167 || form
== DW_FORM_strx1
1168 || form
== DW_FORM_strx2
1169 || form
== DW_FORM_strx3
1170 || form
== DW_FORM_strx4
1171 || form
== DW_FORM_line_strp
1172 || form
== DW_FORM_GNU_strp_alt
);
1176 read_indexed_string (bfd_uint64_t idx ATTRIBUTE_UNUSED
,
1177 struct comp_unit
* unit ATTRIBUTE_UNUSED
)
1179 /* FIXME: Add support for indexed strings. */
1180 return "<indexed strings not yet supported>";
1183 /* Read and fill in the value of attribute ATTR as described by FORM.
1184 Read data starting from INFO_PTR, but never at or beyond INFO_PTR_END.
1185 Returns an updated INFO_PTR taking into account the amount of data read. */
1188 read_attribute_value (struct attribute
* attr
,
1190 bfd_vma implicit_const
,
1191 struct comp_unit
* unit
,
1192 bfd_byte
* info_ptr
,
1193 bfd_byte
* info_ptr_end
)
1195 bfd
*abfd
= unit
->abfd
;
1198 if (info_ptr
>= info_ptr_end
&& form
!= DW_FORM_flag_present
)
1200 _bfd_error_handler (_("DWARF error: info pointer extends beyond end of attributes"));
1201 bfd_set_error (bfd_error_bad_value
);
1205 attr
->form
= (enum dwarf_form
) form
;
1209 case DW_FORM_flag_present
:
1212 case DW_FORM_ref_addr
:
1213 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
1215 if (unit
->version
>= 3)
1217 if (unit
->offset_size
== 4)
1218 attr
->u
.val
= read_4_bytes (unit
->abfd
, &info_ptr
, info_ptr_end
);
1220 attr
->u
.val
= read_8_bytes (unit
->abfd
, &info_ptr
, info_ptr_end
);
1225 attr
->u
.val
= read_address (unit
, &info_ptr
, info_ptr_end
);
1227 case DW_FORM_GNU_ref_alt
:
1228 case DW_FORM_sec_offset
:
1229 if (unit
->offset_size
== 4)
1230 attr
->u
.val
= read_4_bytes (unit
->abfd
, &info_ptr
, info_ptr_end
);
1232 attr
->u
.val
= read_8_bytes (unit
->abfd
, &info_ptr
, info_ptr_end
);
1234 case DW_FORM_block2
:
1235 amt
= read_2_bytes (abfd
, &info_ptr
, info_ptr_end
);
1236 attr
->u
.blk
= read_blk (abfd
, &info_ptr
, info_ptr_end
, amt
);
1237 if (attr
->u
.blk
== NULL
)
1240 case DW_FORM_block4
:
1241 amt
= read_4_bytes (abfd
, &info_ptr
, info_ptr_end
);
1242 attr
->u
.blk
= read_blk (abfd
, &info_ptr
, info_ptr_end
, amt
);
1243 if (attr
->u
.blk
== NULL
)
1249 case DW_FORM_addrx1
:
1250 attr
->u
.val
= read_1_byte (abfd
, &info_ptr
, info_ptr_end
);
1254 attr
->u
.val
= read_2_bytes (abfd
, &info_ptr
, info_ptr_end
);
1256 case DW_FORM_addrx3
:
1257 attr
->u
.val
= read_3_bytes (abfd
, &info_ptr
, info_ptr_end
);
1261 case DW_FORM_addrx4
:
1262 attr
->u
.val
= read_4_bytes (abfd
, &info_ptr
, info_ptr_end
);
1266 case DW_FORM_ref_sig8
:
1267 attr
->u
.val
= read_8_bytes (abfd
, &info_ptr
, info_ptr_end
);
1269 case DW_FORM_string
:
1270 attr
->u
.str
= read_string (&info_ptr
, info_ptr_end
);
1273 attr
->u
.str
= read_indirect_string (unit
, &info_ptr
, info_ptr_end
);
1275 case DW_FORM_line_strp
:
1276 attr
->u
.str
= read_indirect_line_string (unit
, &info_ptr
, info_ptr_end
);
1278 case DW_FORM_GNU_strp_alt
:
1279 attr
->u
.str
= read_alt_indirect_string (unit
, &info_ptr
, info_ptr_end
);
1282 attr
->u
.val
= read_1_byte (abfd
, &info_ptr
, info_ptr_end
);
1283 attr
->u
.str
= (char *) read_indexed_string (attr
->u
.val
, unit
);
1286 attr
->u
.val
= read_2_bytes (abfd
, &info_ptr
, info_ptr_end
);
1287 attr
->u
.str
= (char *) read_indexed_string (attr
->u
.val
, unit
);
1290 attr
->u
.val
= read_3_bytes (abfd
, &info_ptr
, info_ptr_end
);
1291 attr
->u
.str
= (char *) read_indexed_string (attr
->u
.val
, unit
);
1294 attr
->u
.val
= read_4_bytes (abfd
, &info_ptr
, info_ptr_end
);
1295 attr
->u
.str
= (char *) read_indexed_string (attr
->u
.val
, unit
);
1298 attr
->u
.val
= _bfd_safe_read_leb128 (abfd
, &info_ptr
,
1299 false, info_ptr_end
);
1300 attr
->u
.str
= (char *) read_indexed_string (attr
->u
.val
, unit
);
1302 case DW_FORM_exprloc
:
1304 amt
= _bfd_safe_read_leb128 (abfd
, &info_ptr
,
1305 false, info_ptr_end
);
1306 attr
->u
.blk
= read_blk (abfd
, &info_ptr
, info_ptr_end
, amt
);
1307 if (attr
->u
.blk
== NULL
)
1310 case DW_FORM_block1
:
1311 amt
= read_1_byte (abfd
, &info_ptr
, info_ptr_end
);
1312 attr
->u
.blk
= read_blk (abfd
, &info_ptr
, info_ptr_end
, amt
);
1313 if (attr
->u
.blk
== NULL
)
1317 attr
->u
.sval
= _bfd_safe_read_leb128 (abfd
, &info_ptr
,
1318 true, info_ptr_end
);
1320 case DW_FORM_ref_udata
:
1323 attr
->u
.val
= _bfd_safe_read_leb128 (abfd
, &info_ptr
,
1324 false, info_ptr_end
);
1326 case DW_FORM_indirect
:
1327 form
= _bfd_safe_read_leb128 (abfd
, &info_ptr
,
1328 false, info_ptr_end
);
1329 if (form
== DW_FORM_implicit_const
)
1330 implicit_const
= _bfd_safe_read_leb128 (abfd
, &info_ptr
,
1331 true, info_ptr_end
);
1332 info_ptr
= read_attribute_value (attr
, form
, implicit_const
, unit
,
1333 info_ptr
, info_ptr_end
);
1335 case DW_FORM_implicit_const
:
1336 attr
->form
= DW_FORM_sdata
;
1337 attr
->u
.sval
= implicit_const
;
1339 case DW_FORM_data16
:
1340 /* This is really a "constant", but there is no way to store that
1341 so pretend it is a 16 byte block instead. */
1342 attr
->u
.blk
= read_blk (abfd
, &info_ptr
, info_ptr_end
, 16);
1343 if (attr
->u
.blk
== NULL
)
1348 _bfd_error_handler (_("DWARF error: invalid or unhandled FORM value: %#x"),
1350 bfd_set_error (bfd_error_bad_value
);
1356 /* Read an attribute described by an abbreviated attribute. */
1359 read_attribute (struct attribute
* attr
,
1360 struct attr_abbrev
* abbrev
,
1361 struct comp_unit
* unit
,
1362 bfd_byte
* info_ptr
,
1363 bfd_byte
* info_ptr_end
)
1365 attr
->name
= abbrev
->name
;
1366 info_ptr
= read_attribute_value (attr
, abbrev
->form
, abbrev
->implicit_const
,
1367 unit
, info_ptr
, info_ptr_end
);
1371 /* Return whether DW_AT_name will return the same as DW_AT_linkage_name
1375 non_mangled (int lang
)
1385 case DW_LANG_Cobol74
:
1386 case DW_LANG_Cobol85
:
1387 case DW_LANG_Fortran77
:
1388 case DW_LANG_Pascal83
:
1398 /* Source line information table routines. */
1400 #define FILE_ALLOC_CHUNK 5
1401 #define DIR_ALLOC_CHUNK 5
1405 struct line_info
* prev_line
;
1409 unsigned int column
;
1410 unsigned int discriminator
;
1411 unsigned char op_index
;
1412 unsigned char end_sequence
; /* End of (sequential) code sequence. */
1423 struct line_sequence
1426 struct line_sequence
* prev_sequence
;
1427 struct line_info
* last_line
; /* Largest VMA. */
1428 struct line_info
** line_info_lookup
;
1429 bfd_size_type num_lines
;
1432 struct line_info_table
1435 unsigned int num_files
;
1436 unsigned int num_dirs
;
1437 unsigned int num_sequences
;
1440 struct fileinfo
* files
;
1441 struct line_sequence
* sequences
;
1442 struct line_info
* lcl_head
; /* Local head; used in 'add_line_info'. */
1445 /* Remember some information about each function. If the function is
1446 inlined (DW_TAG_inlined_subroutine) it may have two additional
1447 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
1448 source code location where this function was inlined. */
1452 /* Pointer to previous function in list of all functions. */
1453 struct funcinfo
* prev_func
;
1454 /* Pointer to function one scope higher. */
1455 struct funcinfo
* caller_func
;
1456 /* Source location file name where caller_func inlines this func. */
1458 /* Source location file name. */
1460 /* Source location line number where caller_func inlines this func. */
1462 /* Source location line number. */
1467 struct arange arange
;
1468 /* Where the symbol is defined. */
1470 /* The offset of the funcinfo from the start of the unit. */
1471 bfd_uint64_t unit_offset
;
1474 struct lookup_funcinfo
1476 /* Function information corresponding to this lookup table entry. */
1477 struct funcinfo
* funcinfo
;
1479 /* The lowest address for this specific function. */
1482 /* The highest address of this function before the lookup table is sorted.
1483 The highest address of all prior functions after the lookup table is
1484 sorted, which is used for binary search. */
1486 /* Index of this function, used to ensure qsort is stable. */
1492 /* Pointer to previous variable in list of all variables. */
1493 struct varinfo
*prev_var
;
1494 /* The offset of the varinfo from the start of the unit. */
1495 bfd_uint64_t unit_offset
;
1496 /* Source location file name. */
1498 /* Source location line number. */
1500 /* The type of this variable. */
1502 /* The name of the variable, if it has one. */
1504 /* The address of the variable. */
1506 /* Where the symbol is defined. */
1508 /* Is this a stack variable? */
1512 /* Return TRUE if NEW_LINE should sort after LINE. */
1515 new_line_sorts_after (struct line_info
*new_line
, struct line_info
*line
)
1517 return (new_line
->address
> line
->address
1518 || (new_line
->address
== line
->address
1519 && new_line
->op_index
> line
->op_index
));
1523 /* Adds a new entry to the line_info list in the line_info_table, ensuring
1524 that the list is sorted. Note that the line_info list is sorted from
1525 highest to lowest VMA (with possible duplicates); that is,
1526 line_info->prev_line always accesses an equal or smaller VMA. */
1529 add_line_info (struct line_info_table
*table
,
1531 unsigned char op_index
,
1534 unsigned int column
,
1535 unsigned int discriminator
,
1538 size_t amt
= sizeof (struct line_info
);
1539 struct line_sequence
* seq
= table
->sequences
;
1540 struct line_info
* info
= (struct line_info
*) bfd_alloc (table
->abfd
, amt
);
1545 /* Set member data of 'info'. */
1546 info
->prev_line
= NULL
;
1547 info
->address
= address
;
1548 info
->op_index
= op_index
;
1550 info
->column
= column
;
1551 info
->discriminator
= discriminator
;
1552 info
->end_sequence
= end_sequence
;
1554 if (filename
&& filename
[0])
1556 info
->filename
= (char *) bfd_alloc (table
->abfd
, strlen (filename
) + 1);
1557 if (info
->filename
== NULL
)
1559 strcpy (info
->filename
, filename
);
1562 info
->filename
= NULL
;
1564 /* Find the correct location for 'info'. Normally we will receive
1565 new line_info data 1) in order and 2) with increasing VMAs.
1566 However some compilers break the rules (cf. decode_line_info) and
1567 so we include some heuristics for quickly finding the correct
1568 location for 'info'. In particular, these heuristics optimize for
1569 the common case in which the VMA sequence that we receive is a
1570 list of locally sorted VMAs such as
1571 p...z a...j (where a < j < p < z)
1573 Note: table->lcl_head is used to head an *actual* or *possible*
1574 sub-sequence within the list (such as a...j) that is not directly
1575 headed by table->last_line
1577 Note: we may receive duplicate entries from 'decode_line_info'. */
1580 && seq
->last_line
->address
== address
1581 && seq
->last_line
->op_index
== op_index
1582 && seq
->last_line
->end_sequence
== end_sequence
)
1584 /* We only keep the last entry with the same address and end
1585 sequence. See PR ld/4986. */
1586 if (table
->lcl_head
== seq
->last_line
)
1587 table
->lcl_head
= info
;
1588 info
->prev_line
= seq
->last_line
->prev_line
;
1589 seq
->last_line
= info
;
1591 else if (!seq
|| seq
->last_line
->end_sequence
)
1593 /* Start a new line sequence. */
1594 amt
= sizeof (struct line_sequence
);
1595 seq
= (struct line_sequence
*) bfd_malloc (amt
);
1598 seq
->low_pc
= address
;
1599 seq
->prev_sequence
= table
->sequences
;
1600 seq
->last_line
= info
;
1601 table
->lcl_head
= info
;
1602 table
->sequences
= seq
;
1603 table
->num_sequences
++;
1605 else if (info
->end_sequence
1606 || new_line_sorts_after (info
, seq
->last_line
))
1608 /* Normal case: add 'info' to the beginning of the current sequence. */
1609 info
->prev_line
= seq
->last_line
;
1610 seq
->last_line
= info
;
1612 /* lcl_head: initialize to head a *possible* sequence at the end. */
1613 if (!table
->lcl_head
)
1614 table
->lcl_head
= info
;
1616 else if (!new_line_sorts_after (info
, table
->lcl_head
)
1617 && (!table
->lcl_head
->prev_line
1618 || new_line_sorts_after (info
, table
->lcl_head
->prev_line
)))
1620 /* Abnormal but easy: lcl_head is the head of 'info'. */
1621 info
->prev_line
= table
->lcl_head
->prev_line
;
1622 table
->lcl_head
->prev_line
= info
;
1626 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head'
1627 are valid heads for 'info'. Reset 'lcl_head'. */
1628 struct line_info
* li2
= seq
->last_line
; /* Always non-NULL. */
1629 struct line_info
* li1
= li2
->prev_line
;
1633 if (!new_line_sorts_after (info
, li2
)
1634 && new_line_sorts_after (info
, li1
))
1637 li2
= li1
; /* always non-NULL */
1638 li1
= li1
->prev_line
;
1640 table
->lcl_head
= li2
;
1641 info
->prev_line
= table
->lcl_head
->prev_line
;
1642 table
->lcl_head
->prev_line
= info
;
1643 if (address
< seq
->low_pc
)
1644 seq
->low_pc
= address
;
1649 /* Extract a fully qualified filename from a line info table.
1650 The returned string has been malloc'ed and it is the caller's
1651 responsibility to free it. */
1654 concat_filename (struct line_info_table
*table
, unsigned int file
)
1658 if (table
== NULL
|| file
- 1 >= table
->num_files
)
1660 /* FILE == 0 means unknown. */
1663 (_("DWARF error: mangled line number section (bad file number)"));
1664 return strdup ("<unknown>");
1667 filename
= table
->files
[file
- 1].name
;
1668 if (filename
== NULL
)
1669 return strdup ("<unknown>");
1671 if (!IS_ABSOLUTE_PATH (filename
))
1673 char *dir_name
= NULL
;
1674 char *subdir_name
= NULL
;
1678 if (table
->files
[file
- 1].dir
1679 /* PR 17512: file: 0317e960. */
1680 && table
->files
[file
- 1].dir
<= table
->num_dirs
1681 /* PR 17512: file: 7f3d2e4b. */
1682 && table
->dirs
!= NULL
)
1683 subdir_name
= table
->dirs
[table
->files
[file
- 1].dir
- 1];
1685 if (!subdir_name
|| !IS_ABSOLUTE_PATH (subdir_name
))
1686 dir_name
= table
->comp_dir
;
1690 dir_name
= subdir_name
;
1695 return strdup (filename
);
1697 len
= strlen (dir_name
) + strlen (filename
) + 2;
1701 len
+= strlen (subdir_name
) + 1;
1702 name
= (char *) bfd_malloc (len
);
1704 sprintf (name
, "%s/%s/%s", dir_name
, subdir_name
, filename
);
1708 name
= (char *) bfd_malloc (len
);
1710 sprintf (name
, "%s/%s", dir_name
, filename
);
1716 return strdup (filename
);
1720 arange_add (const struct comp_unit
*unit
, struct arange
*first_arange
,
1721 bfd_vma low_pc
, bfd_vma high_pc
)
1723 struct arange
*arange
;
1725 /* Ignore empty ranges. */
1726 if (low_pc
== high_pc
)
1729 /* If the first arange is empty, use it. */
1730 if (first_arange
->high
== 0)
1732 first_arange
->low
= low_pc
;
1733 first_arange
->high
= high_pc
;
1737 /* Next see if we can cheaply extend an existing range. */
1738 arange
= first_arange
;
1741 if (low_pc
== arange
->high
)
1743 arange
->high
= high_pc
;
1746 if (high_pc
== arange
->low
)
1748 arange
->low
= low_pc
;
1751 arange
= arange
->next
;
1755 /* Need to allocate a new arange and insert it into the arange list.
1756 Order isn't significant, so just insert after the first arange. */
1757 arange
= (struct arange
*) bfd_alloc (unit
->abfd
, sizeof (*arange
));
1760 arange
->low
= low_pc
;
1761 arange
->high
= high_pc
;
1762 arange
->next
= first_arange
->next
;
1763 first_arange
->next
= arange
;
1767 /* Compare function for line sequences. */
1770 compare_sequences (const void* a
, const void* b
)
1772 const struct line_sequence
* seq1
= a
;
1773 const struct line_sequence
* seq2
= b
;
1775 /* Sort by low_pc as the primary key. */
1776 if (seq1
->low_pc
< seq2
->low_pc
)
1778 if (seq1
->low_pc
> seq2
->low_pc
)
1781 /* If low_pc values are equal, sort in reverse order of
1782 high_pc, so that the largest region comes first. */
1783 if (seq1
->last_line
->address
< seq2
->last_line
->address
)
1785 if (seq1
->last_line
->address
> seq2
->last_line
->address
)
1788 if (seq1
->last_line
->op_index
< seq2
->last_line
->op_index
)
1790 if (seq1
->last_line
->op_index
> seq2
->last_line
->op_index
)
1793 /* num_lines is initially an index, to make the sort stable. */
1794 if (seq1
->num_lines
< seq2
->num_lines
)
1796 if (seq1
->num_lines
> seq2
->num_lines
)
1801 /* Construct the line information table for quick lookup. */
1804 build_line_info_table (struct line_info_table
* table
,
1805 struct line_sequence
* seq
)
1808 struct line_info
**line_info_lookup
;
1809 struct line_info
*each_line
;
1810 unsigned int num_lines
;
1811 unsigned int line_index
;
1813 if (seq
->line_info_lookup
!= NULL
)
1816 /* Count the number of line information entries. We could do this while
1817 scanning the debug information, but some entries may be added via
1818 lcl_head without having a sequence handy to increment the number of
1821 for (each_line
= seq
->last_line
; each_line
; each_line
= each_line
->prev_line
)
1824 seq
->num_lines
= num_lines
;
1828 /* Allocate space for the line information lookup table. */
1829 amt
= sizeof (struct line_info
*) * num_lines
;
1830 line_info_lookup
= (struct line_info
**) bfd_alloc (table
->abfd
, amt
);
1831 seq
->line_info_lookup
= line_info_lookup
;
1832 if (line_info_lookup
== NULL
)
1835 /* Create the line information lookup table. */
1836 line_index
= num_lines
;
1837 for (each_line
= seq
->last_line
; each_line
; each_line
= each_line
->prev_line
)
1838 line_info_lookup
[--line_index
] = each_line
;
1840 BFD_ASSERT (line_index
== 0);
1844 /* Sort the line sequences for quick lookup. */
1847 sort_line_sequences (struct line_info_table
* table
)
1850 struct line_sequence
*sequences
;
1851 struct line_sequence
*seq
;
1853 unsigned int num_sequences
= table
->num_sequences
;
1854 bfd_vma last_high_pc
;
1856 if (num_sequences
== 0)
1859 /* Allocate space for an array of sequences. */
1860 amt
= sizeof (struct line_sequence
) * num_sequences
;
1861 sequences
= (struct line_sequence
*) bfd_alloc (table
->abfd
, amt
);
1862 if (sequences
== NULL
)
1865 /* Copy the linked list into the array, freeing the original nodes. */
1866 seq
= table
->sequences
;
1867 for (n
= 0; n
< num_sequences
; n
++)
1869 struct line_sequence
* last_seq
= seq
;
1872 sequences
[n
].low_pc
= seq
->low_pc
;
1873 sequences
[n
].prev_sequence
= NULL
;
1874 sequences
[n
].last_line
= seq
->last_line
;
1875 sequences
[n
].line_info_lookup
= NULL
;
1876 sequences
[n
].num_lines
= n
;
1877 seq
= seq
->prev_sequence
;
1880 BFD_ASSERT (seq
== NULL
);
1882 qsort (sequences
, n
, sizeof (struct line_sequence
), compare_sequences
);
1884 /* Make the list binary-searchable by trimming overlapping entries
1885 and removing nested entries. */
1887 last_high_pc
= sequences
[0].last_line
->address
;
1888 for (n
= 1; n
< table
->num_sequences
; n
++)
1890 if (sequences
[n
].low_pc
< last_high_pc
)
1892 if (sequences
[n
].last_line
->address
<= last_high_pc
)
1893 /* Skip nested entries. */
1896 /* Trim overlapping entries. */
1897 sequences
[n
].low_pc
= last_high_pc
;
1899 last_high_pc
= sequences
[n
].last_line
->address
;
1900 if (n
> num_sequences
)
1902 /* Close up the gap. */
1903 sequences
[num_sequences
].low_pc
= sequences
[n
].low_pc
;
1904 sequences
[num_sequences
].last_line
= sequences
[n
].last_line
;
1909 table
->sequences
= sequences
;
1910 table
->num_sequences
= num_sequences
;
1914 /* Add directory to TABLE. CUR_DIR memory ownership is taken by TABLE. */
1917 line_info_add_include_dir (struct line_info_table
*table
, char *cur_dir
)
1919 if ((table
->num_dirs
% DIR_ALLOC_CHUNK
) == 0)
1924 amt
= table
->num_dirs
+ DIR_ALLOC_CHUNK
;
1925 amt
*= sizeof (char *);
1927 tmp
= (char **) bfd_realloc (table
->dirs
, amt
);
1933 table
->dirs
[table
->num_dirs
++] = cur_dir
;
1938 line_info_add_include_dir_stub (struct line_info_table
*table
, char *cur_dir
,
1939 unsigned int dir ATTRIBUTE_UNUSED
,
1940 unsigned int xtime ATTRIBUTE_UNUSED
,
1941 unsigned int size ATTRIBUTE_UNUSED
)
1943 return line_info_add_include_dir (table
, cur_dir
);
1946 /* Add file to TABLE. CUR_FILE memory ownership is taken by TABLE. */
1949 line_info_add_file_name (struct line_info_table
*table
, char *cur_file
,
1950 unsigned int dir
, unsigned int xtime
,
1953 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
1955 struct fileinfo
*tmp
;
1958 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
1959 amt
*= sizeof (struct fileinfo
);
1961 tmp
= (struct fileinfo
*) bfd_realloc (table
->files
, amt
);
1967 table
->files
[table
->num_files
].name
= cur_file
;
1968 table
->files
[table
->num_files
].dir
= dir
;
1969 table
->files
[table
->num_files
].time
= xtime
;
1970 table
->files
[table
->num_files
].size
= size
;
1975 /* Read directory or file name entry format, starting with byte of
1976 format count entries, ULEB128 pairs of entry formats, ULEB128 of
1977 entries count and the entries themselves in the described entry
1981 read_formatted_entries (struct comp_unit
*unit
, bfd_byte
**bufp
,
1982 bfd_byte
*buf_end
, struct line_info_table
*table
,
1983 bool (*callback
) (struct line_info_table
*table
,
1989 bfd
*abfd
= unit
->abfd
;
1990 bfd_byte format_count
, formati
;
1991 bfd_vma data_count
, datai
;
1992 bfd_byte
*buf
= *bufp
;
1993 bfd_byte
*format_header_data
;
1995 format_count
= read_1_byte (abfd
, &buf
, buf_end
);
1996 format_header_data
= buf
;
1997 for (formati
= 0; formati
< format_count
; formati
++)
1999 _bfd_safe_read_leb128 (abfd
, &buf
, false, buf_end
);
2000 _bfd_safe_read_leb128 (abfd
, &buf
, false, buf_end
);
2003 data_count
= _bfd_safe_read_leb128 (abfd
, &buf
, false, buf_end
);
2004 if (format_count
== 0 && data_count
!= 0)
2006 _bfd_error_handler (_("DWARF error: zero format count"));
2007 bfd_set_error (bfd_error_bad_value
);
2011 /* PR 22210. Paranoia check. Don't bother running the loop
2012 if we know that we are going to run out of buffer. */
2013 if (data_count
> (bfd_vma
) (buf_end
- buf
))
2016 (_("DWARF error: data count (%" PRIx64
") larger than buffer size"),
2017 (uint64_t) data_count
);
2018 bfd_set_error (bfd_error_bad_value
);
2022 for (datai
= 0; datai
< data_count
; datai
++)
2024 bfd_byte
*format
= format_header_data
;
2027 memset (&fe
, 0, sizeof fe
);
2028 for (formati
= 0; formati
< format_count
; formati
++)
2030 bfd_vma content_type
, form
;
2032 char **stringp
= &string_trash
;
2033 unsigned int uint_trash
, *uintp
= &uint_trash
;
2034 struct attribute attr
;
2036 content_type
= _bfd_safe_read_leb128 (abfd
, &format
, false, buf_end
);
2037 switch (content_type
)
2042 case DW_LNCT_directory_index
:
2045 case DW_LNCT_timestamp
:
2055 (_("DWARF error: unknown format content type %" PRIu64
),
2056 (uint64_t) content_type
);
2057 bfd_set_error (bfd_error_bad_value
);
2061 form
= _bfd_safe_read_leb128 (abfd
, &format
, false, buf_end
);
2062 buf
= read_attribute_value (&attr
, form
, 0, unit
, buf
, buf_end
);
2067 case DW_FORM_string
:
2068 case DW_FORM_line_strp
:
2069 *stringp
= attr
.u
.str
;
2077 *uintp
= attr
.u
.val
;
2080 case DW_FORM_data16
:
2081 /* MD5 data is in the attr.blk, but we are ignoring those. */
2086 /* Skip the first "zero entry", which is the compilation dir/file. */
2088 if (!callback (table
, fe
.name
, fe
.dir
, fe
.time
, fe
.size
))
2096 /* Decode the line number information for UNIT. */
2098 static struct line_info_table
*
2099 decode_line_info (struct comp_unit
*unit
)
2101 bfd
*abfd
= unit
->abfd
;
2102 struct dwarf2_debug
*stash
= unit
->stash
;
2103 struct dwarf2_debug_file
*file
= unit
->file
;
2104 struct line_info_table
* table
;
2107 struct line_head lh
;
2108 unsigned int i
, offset_size
;
2109 char *cur_file
, *cur_dir
;
2110 unsigned char op_code
, extended_op
, adj_opcode
;
2111 unsigned int exop_len
;
2114 if (unit
->line_offset
== 0 && file
->line_table
)
2115 return file
->line_table
;
2117 if (! read_section (abfd
, &stash
->debug_sections
[debug_line
],
2118 file
->syms
, unit
->line_offset
,
2119 &file
->dwarf_line_buffer
, &file
->dwarf_line_size
))
2122 if (file
->dwarf_line_size
< 16)
2125 (_("DWARF error: line info section is too small (%" PRId64
")"),
2126 (int64_t) file
->dwarf_line_size
);
2127 bfd_set_error (bfd_error_bad_value
);
2130 line_ptr
= file
->dwarf_line_buffer
+ unit
->line_offset
;
2131 line_end
= file
->dwarf_line_buffer
+ file
->dwarf_line_size
;
2133 /* Read in the prologue. */
2134 lh
.total_length
= read_4_bytes (abfd
, &line_ptr
, line_end
);
2136 if (lh
.total_length
== 0xffffffff)
2138 lh
.total_length
= read_8_bytes (abfd
, &line_ptr
, line_end
);
2141 else if (lh
.total_length
== 0 && unit
->addr_size
== 8)
2143 /* Handle (non-standard) 64-bit DWARF2 formats. */
2144 lh
.total_length
= read_4_bytes (abfd
, &line_ptr
, line_end
);
2148 if (lh
.total_length
> (size_t) (line_end
- line_ptr
))
2151 /* xgettext: c-format */
2152 (_("DWARF error: line info data is bigger (%#" PRIx64
")"
2153 " than the space remaining in the section (%#lx)"),
2154 (uint64_t) lh
.total_length
, (unsigned long) (line_end
- line_ptr
));
2155 bfd_set_error (bfd_error_bad_value
);
2159 line_end
= line_ptr
+ lh
.total_length
;
2161 lh
.version
= read_2_bytes (abfd
, &line_ptr
, line_end
);
2162 if (lh
.version
< 2 || lh
.version
> 5)
2165 (_("DWARF error: unhandled .debug_line version %d"), lh
.version
);
2166 bfd_set_error (bfd_error_bad_value
);
2170 if (line_ptr
+ offset_size
+ (lh
.version
>= 5 ? 8 : (lh
.version
>= 4 ? 6 : 5))
2174 (_("DWARF error: ran out of room reading prologue"));
2175 bfd_set_error (bfd_error_bad_value
);
2179 if (lh
.version
>= 5)
2181 unsigned int segment_selector_size
;
2183 /* Skip address size. */
2184 read_1_byte (abfd
, &line_ptr
, line_end
);
2186 segment_selector_size
= read_1_byte (abfd
, &line_ptr
, line_end
);
2187 if (segment_selector_size
!= 0)
2190 (_("DWARF error: line info unsupported segment selector size %u"),
2191 segment_selector_size
);
2192 bfd_set_error (bfd_error_bad_value
);
2197 if (offset_size
== 4)
2198 lh
.prologue_length
= read_4_bytes (abfd
, &line_ptr
, line_end
);
2200 lh
.prologue_length
= read_8_bytes (abfd
, &line_ptr
, line_end
);
2202 lh
.minimum_instruction_length
= read_1_byte (abfd
, &line_ptr
, line_end
);
2204 if (lh
.version
>= 4)
2205 lh
.maximum_ops_per_insn
= read_1_byte (abfd
, &line_ptr
, line_end
);
2207 lh
.maximum_ops_per_insn
= 1;
2209 if (lh
.maximum_ops_per_insn
== 0)
2212 (_("DWARF error: invalid maximum operations per instruction"));
2213 bfd_set_error (bfd_error_bad_value
);
2217 lh
.default_is_stmt
= read_1_byte (abfd
, &line_ptr
, line_end
);
2218 lh
.line_base
= read_1_signed_byte (abfd
, &line_ptr
, line_end
);
2219 lh
.line_range
= read_1_byte (abfd
, &line_ptr
, line_end
);
2220 lh
.opcode_base
= read_1_byte (abfd
, &line_ptr
, line_end
);
2222 if (line_ptr
+ (lh
.opcode_base
- 1) >= line_end
)
2224 _bfd_error_handler (_("DWARF error: ran out of room reading opcodes"));
2225 bfd_set_error (bfd_error_bad_value
);
2229 amt
= lh
.opcode_base
* sizeof (unsigned char);
2230 lh
.standard_opcode_lengths
= (unsigned char *) bfd_alloc (abfd
, amt
);
2232 lh
.standard_opcode_lengths
[0] = 1;
2234 for (i
= 1; i
< lh
.opcode_base
; ++i
)
2235 lh
.standard_opcode_lengths
[i
] = read_1_byte (abfd
, &line_ptr
, line_end
);
2237 amt
= sizeof (struct line_info_table
);
2238 table
= (struct line_info_table
*) bfd_alloc (abfd
, amt
);
2242 table
->comp_dir
= unit
->comp_dir
;
2244 table
->num_files
= 0;
2245 table
->files
= NULL
;
2247 table
->num_dirs
= 0;
2250 table
->num_sequences
= 0;
2251 table
->sequences
= NULL
;
2253 table
->lcl_head
= NULL
;
2255 if (lh
.version
>= 5)
2257 /* Read directory table. */
2258 if (!read_formatted_entries (unit
, &line_ptr
, line_end
, table
,
2259 line_info_add_include_dir_stub
))
2262 /* Read file name table. */
2263 if (!read_formatted_entries (unit
, &line_ptr
, line_end
, table
,
2264 line_info_add_file_name
))
2269 /* Read directory table. */
2270 while ((cur_dir
= read_string (&line_ptr
, line_end
)) != NULL
)
2272 if (!line_info_add_include_dir (table
, cur_dir
))
2276 /* Read file name table. */
2277 while ((cur_file
= read_string (&line_ptr
, line_end
)) != NULL
)
2279 unsigned int dir
, xtime
, size
;
2281 dir
= _bfd_safe_read_leb128 (abfd
, &line_ptr
, false, line_end
);
2282 xtime
= _bfd_safe_read_leb128 (abfd
, &line_ptr
, false, line_end
);
2283 size
= _bfd_safe_read_leb128 (abfd
, &line_ptr
, false, line_end
);
2285 if (!line_info_add_file_name (table
, cur_file
, dir
, xtime
, size
))
2290 /* Read the statement sequences until there's nothing left. */
2291 while (line_ptr
< line_end
)
2293 /* State machine registers. */
2294 bfd_vma address
= 0;
2295 unsigned char op_index
= 0;
2296 char * filename
= table
->num_files
? concat_filename (table
, 1) : NULL
;
2297 unsigned int line
= 1;
2298 unsigned int column
= 0;
2299 unsigned int discriminator
= 0;
2300 int is_stmt
= lh
.default_is_stmt
;
2301 int end_sequence
= 0;
2302 unsigned int dir
, xtime
, size
;
2303 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
2304 compilers generate address sequences that are wildly out of
2305 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
2306 for ia64-Linux). Thus, to determine the low and high
2307 address, we must compare on every DW_LNS_copy, etc. */
2308 bfd_vma low_pc
= (bfd_vma
) -1;
2309 bfd_vma high_pc
= 0;
2311 /* Decode the table. */
2312 while (!end_sequence
&& line_ptr
< line_end
)
2314 op_code
= read_1_byte (abfd
, &line_ptr
, line_end
);
2316 if (op_code
>= lh
.opcode_base
)
2318 /* Special operand. */
2319 adj_opcode
= op_code
- lh
.opcode_base
;
2320 if (lh
.line_range
== 0)
2322 if (lh
.maximum_ops_per_insn
== 1)
2323 address
+= (adj_opcode
/ lh
.line_range
2324 * lh
.minimum_instruction_length
);
2327 address
+= ((op_index
+ adj_opcode
/ lh
.line_range
)
2328 / lh
.maximum_ops_per_insn
2329 * lh
.minimum_instruction_length
);
2330 op_index
= ((op_index
+ adj_opcode
/ lh
.line_range
)
2331 % lh
.maximum_ops_per_insn
);
2333 line
+= lh
.line_base
+ (adj_opcode
% lh
.line_range
);
2334 /* Append row to matrix using current values. */
2335 if (!add_line_info (table
, address
, op_index
, filename
,
2336 line
, column
, discriminator
, 0))
2339 if (address
< low_pc
)
2341 if (address
> high_pc
)
2344 else switch (op_code
)
2346 case DW_LNS_extended_op
:
2347 exop_len
= _bfd_safe_read_leb128 (abfd
, &line_ptr
,
2349 extended_op
= read_1_byte (abfd
, &line_ptr
, line_end
);
2351 switch (extended_op
)
2353 case DW_LNE_end_sequence
:
2355 if (!add_line_info (table
, address
, op_index
, filename
, line
,
2356 column
, discriminator
, end_sequence
))
2359 if (address
< low_pc
)
2361 if (address
> high_pc
)
2363 if (!arange_add (unit
, &unit
->arange
, low_pc
, high_pc
))
2366 case DW_LNE_set_address
:
2367 address
= read_address (unit
, &line_ptr
, line_end
);
2370 case DW_LNE_define_file
:
2371 cur_file
= read_string (&line_ptr
, line_end
);
2372 dir
= _bfd_safe_read_leb128 (abfd
, &line_ptr
,
2374 xtime
= _bfd_safe_read_leb128 (abfd
, &line_ptr
,
2376 size
= _bfd_safe_read_leb128 (abfd
, &line_ptr
,
2378 if (!line_info_add_file_name (table
, cur_file
, dir
,
2382 case DW_LNE_set_discriminator
:
2384 _bfd_safe_read_leb128 (abfd
, &line_ptr
,
2387 case DW_LNE_HP_source_file_correlation
:
2388 line_ptr
+= exop_len
- 1;
2392 (_("DWARF error: mangled line number section"));
2393 bfd_set_error (bfd_error_bad_value
);
2400 if (!add_line_info (table
, address
, op_index
,
2401 filename
, line
, column
, discriminator
, 0))
2404 if (address
< low_pc
)
2406 if (address
> high_pc
)
2409 case DW_LNS_advance_pc
:
2410 if (lh
.maximum_ops_per_insn
== 1)
2411 address
+= (lh
.minimum_instruction_length
2412 * _bfd_safe_read_leb128 (abfd
, &line_ptr
,
2416 bfd_vma adjust
= _bfd_safe_read_leb128 (abfd
, &line_ptr
,
2418 address
= ((op_index
+ adjust
) / lh
.maximum_ops_per_insn
2419 * lh
.minimum_instruction_length
);
2420 op_index
= (op_index
+ adjust
) % lh
.maximum_ops_per_insn
;
2423 case DW_LNS_advance_line
:
2424 line
+= _bfd_safe_read_leb128 (abfd
, &line_ptr
,
2427 case DW_LNS_set_file
:
2429 unsigned int filenum
;
2431 /* The file and directory tables are 0
2432 based, the references are 1 based. */
2433 filenum
= _bfd_safe_read_leb128 (abfd
, &line_ptr
,
2436 filename
= concat_filename (table
, filenum
);
2439 case DW_LNS_set_column
:
2440 column
= _bfd_safe_read_leb128 (abfd
, &line_ptr
,
2443 case DW_LNS_negate_stmt
:
2444 is_stmt
= (!is_stmt
);
2446 case DW_LNS_set_basic_block
:
2448 case DW_LNS_const_add_pc
:
2449 if (lh
.line_range
== 0)
2451 if (lh
.maximum_ops_per_insn
== 1)
2452 address
+= (lh
.minimum_instruction_length
2453 * ((255 - lh
.opcode_base
) / lh
.line_range
));
2456 bfd_vma adjust
= ((255 - lh
.opcode_base
) / lh
.line_range
);
2457 address
+= (lh
.minimum_instruction_length
2458 * ((op_index
+ adjust
)
2459 / lh
.maximum_ops_per_insn
));
2460 op_index
= (op_index
+ adjust
) % lh
.maximum_ops_per_insn
;
2463 case DW_LNS_fixed_advance_pc
:
2464 address
+= read_2_bytes (abfd
, &line_ptr
, line_end
);
2468 /* Unknown standard opcode, ignore it. */
2469 for (i
= 0; i
< lh
.standard_opcode_lengths
[op_code
]; i
++)
2470 (void) _bfd_safe_read_leb128 (abfd
, &line_ptr
,
2479 if (unit
->line_offset
== 0)
2480 file
->line_table
= table
;
2481 if (sort_line_sequences (table
))
2485 while (table
->sequences
!= NULL
)
2487 struct line_sequence
* seq
= table
->sequences
;
2488 table
->sequences
= table
->sequences
->prev_sequence
;
2491 free (table
->files
);
2496 /* If ADDR is within TABLE set the output parameters and return the
2497 range of addresses covered by the entry used to fill them out.
2498 Otherwise set * FILENAME_PTR to NULL and return 0.
2499 The parameters FILENAME_PTR, LINENUMBER_PTR and DISCRIMINATOR_PTR
2500 are pointers to the objects to be filled in. */
2503 lookup_address_in_line_info_table (struct line_info_table
*table
,
2505 const char **filename_ptr
,
2506 unsigned int *linenumber_ptr
,
2507 unsigned int *discriminator_ptr
)
2509 struct line_sequence
*seq
= NULL
;
2510 struct line_info
*info
;
2513 /* Binary search the array of sequences. */
2515 high
= table
->num_sequences
;
2518 mid
= (low
+ high
) / 2;
2519 seq
= &table
->sequences
[mid
];
2520 if (addr
< seq
->low_pc
)
2522 else if (addr
>= seq
->last_line
->address
)
2528 /* Check for a valid sequence. */
2529 if (!seq
|| addr
< seq
->low_pc
|| addr
>= seq
->last_line
->address
)
2532 if (!build_line_info_table (table
, seq
))
2535 /* Binary search the array of line information. */
2537 high
= seq
->num_lines
;
2541 mid
= (low
+ high
) / 2;
2542 info
= seq
->line_info_lookup
[mid
];
2543 if (addr
< info
->address
)
2545 else if (addr
>= seq
->line_info_lookup
[mid
+ 1]->address
)
2551 /* Check for a valid line information entry. */
2553 && addr
>= info
->address
2554 && addr
< seq
->line_info_lookup
[mid
+ 1]->address
2555 && !(info
->end_sequence
|| info
== seq
->last_line
))
2557 *filename_ptr
= info
->filename
;
2558 *linenumber_ptr
= info
->line
;
2559 if (discriminator_ptr
)
2560 *discriminator_ptr
= info
->discriminator
;
2561 return seq
->last_line
->address
- seq
->low_pc
;
2565 *filename_ptr
= NULL
;
2569 /* Read in the .debug_ranges section for future reference. */
2572 read_debug_ranges (struct comp_unit
* unit
)
2574 struct dwarf2_debug
*stash
= unit
->stash
;
2575 struct dwarf2_debug_file
*file
= unit
->file
;
2577 return read_section (unit
->abfd
, &stash
->debug_sections
[debug_ranges
],
2579 &file
->dwarf_ranges_buffer
, &file
->dwarf_ranges_size
);
2582 /* Read in the .debug_rnglists section for future reference. */
2585 read_debug_rnglists (struct comp_unit
* unit
)
2587 struct dwarf2_debug
*stash
= unit
->stash
;
2588 struct dwarf2_debug_file
*file
= unit
->file
;
2590 return read_section (unit
->abfd
, &stash
->debug_sections
[debug_rnglists
],
2592 &file
->dwarf_rnglists_buffer
, &file
->dwarf_rnglists_size
);
2595 /* Function table functions. */
2598 compare_lookup_funcinfos (const void * a
, const void * b
)
2600 const struct lookup_funcinfo
* lookup1
= a
;
2601 const struct lookup_funcinfo
* lookup2
= b
;
2603 if (lookup1
->low_addr
< lookup2
->low_addr
)
2605 if (lookup1
->low_addr
> lookup2
->low_addr
)
2607 if (lookup1
->high_addr
< lookup2
->high_addr
)
2609 if (lookup1
->high_addr
> lookup2
->high_addr
)
2612 if (lookup1
->idx
< lookup2
->idx
)
2614 if (lookup1
->idx
> lookup2
->idx
)
2620 build_lookup_funcinfo_table (struct comp_unit
* unit
)
2622 struct lookup_funcinfo
*lookup_funcinfo_table
= unit
->lookup_funcinfo_table
;
2623 unsigned int number_of_functions
= unit
->number_of_functions
;
2624 struct funcinfo
*each
;
2625 struct lookup_funcinfo
*entry
;
2627 struct arange
*range
;
2628 bfd_vma low_addr
, high_addr
;
2630 if (lookup_funcinfo_table
|| number_of_functions
== 0)
2633 /* Create the function info lookup table. */
2634 lookup_funcinfo_table
= (struct lookup_funcinfo
*)
2635 bfd_malloc (number_of_functions
* sizeof (struct lookup_funcinfo
));
2636 if (lookup_funcinfo_table
== NULL
)
2639 /* Populate the function info lookup table. */
2640 func_index
= number_of_functions
;
2641 for (each
= unit
->function_table
; each
; each
= each
->prev_func
)
2643 entry
= &lookup_funcinfo_table
[--func_index
];
2644 entry
->funcinfo
= each
;
2645 entry
->idx
= func_index
;
2647 /* Calculate the lowest and highest address for this function entry. */
2648 low_addr
= entry
->funcinfo
->arange
.low
;
2649 high_addr
= entry
->funcinfo
->arange
.high
;
2651 for (range
= entry
->funcinfo
->arange
.next
; range
; range
= range
->next
)
2653 if (range
->low
< low_addr
)
2654 low_addr
= range
->low
;
2655 if (range
->high
> high_addr
)
2656 high_addr
= range
->high
;
2659 entry
->low_addr
= low_addr
;
2660 entry
->high_addr
= high_addr
;
2663 BFD_ASSERT (func_index
== 0);
2665 /* Sort the function by address. */
2666 qsort (lookup_funcinfo_table
,
2667 number_of_functions
,
2668 sizeof (struct lookup_funcinfo
),
2669 compare_lookup_funcinfos
);
2671 /* Calculate the high watermark for each function in the lookup table. */
2672 high_addr
= lookup_funcinfo_table
[0].high_addr
;
2673 for (func_index
= 1; func_index
< number_of_functions
; func_index
++)
2675 entry
= &lookup_funcinfo_table
[func_index
];
2676 if (entry
->high_addr
> high_addr
)
2677 high_addr
= entry
->high_addr
;
2679 entry
->high_addr
= high_addr
;
2682 unit
->lookup_funcinfo_table
= lookup_funcinfo_table
;
2686 /* If ADDR is within UNIT's function tables, set FUNCTION_PTR, and return
2687 TRUE. Note that we need to find the function that has the smallest range
2688 that contains ADDR, to handle inlined functions without depending upon
2689 them being ordered in TABLE by increasing range. */
2692 lookup_address_in_function_table (struct comp_unit
*unit
,
2694 struct funcinfo
**function_ptr
)
2696 unsigned int number_of_functions
= unit
->number_of_functions
;
2697 struct lookup_funcinfo
* lookup_funcinfo
= NULL
;
2698 struct funcinfo
* funcinfo
= NULL
;
2699 struct funcinfo
* best_fit
= NULL
;
2700 bfd_vma best_fit_len
= 0;
2701 bfd_size_type low
, high
, mid
, first
;
2702 struct arange
*arange
;
2704 if (number_of_functions
== 0)
2707 if (!build_lookup_funcinfo_table (unit
))
2710 if (unit
->lookup_funcinfo_table
[number_of_functions
- 1].high_addr
< addr
)
2713 /* Find the first function in the lookup table which may contain the
2714 specified address. */
2716 high
= number_of_functions
;
2720 mid
= (low
+ high
) / 2;
2721 lookup_funcinfo
= &unit
->lookup_funcinfo_table
[mid
];
2722 if (addr
< lookup_funcinfo
->low_addr
)
2724 else if (addr
>= lookup_funcinfo
->high_addr
)
2730 /* Find the 'best' match for the address. The prior algorithm defined the
2731 best match as the function with the smallest address range containing
2732 the specified address. This definition should probably be changed to the
2733 innermost inline routine containing the address, but right now we want
2734 to get the same results we did before. */
2735 while (first
< number_of_functions
)
2737 if (addr
< unit
->lookup_funcinfo_table
[first
].low_addr
)
2739 funcinfo
= unit
->lookup_funcinfo_table
[first
].funcinfo
;
2741 for (arange
= &funcinfo
->arange
; arange
; arange
= arange
->next
)
2743 if (addr
< arange
->low
|| addr
>= arange
->high
)
2747 || arange
->high
- arange
->low
< best_fit_len
2748 /* The following comparison is designed to return the same
2749 match as the previous algorithm for routines which have the
2750 same best fit length. */
2751 || (arange
->high
- arange
->low
== best_fit_len
2752 && funcinfo
> best_fit
))
2754 best_fit
= funcinfo
;
2755 best_fit_len
= arange
->high
- arange
->low
;
2765 *function_ptr
= best_fit
;
2769 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
2770 and LINENUMBER_PTR, and return TRUE. */
2773 lookup_symbol_in_function_table (struct comp_unit
*unit
,
2776 const char **filename_ptr
,
2777 unsigned int *linenumber_ptr
)
2779 struct funcinfo
* each_func
;
2780 struct funcinfo
* best_fit
= NULL
;
2781 bfd_vma best_fit_len
= 0;
2782 struct arange
*arange
;
2783 const char *name
= bfd_asymbol_name (sym
);
2784 asection
*sec
= bfd_asymbol_section (sym
);
2786 for (each_func
= unit
->function_table
;
2788 each_func
= each_func
->prev_func
)
2790 for (arange
= &each_func
->arange
;
2792 arange
= arange
->next
)
2794 if ((!each_func
->sec
|| each_func
->sec
== sec
)
2795 && addr
>= arange
->low
2796 && addr
< arange
->high
2798 && strcmp (name
, each_func
->name
) == 0
2800 || arange
->high
- arange
->low
< best_fit_len
))
2802 best_fit
= each_func
;
2803 best_fit_len
= arange
->high
- arange
->low
;
2810 best_fit
->sec
= sec
;
2811 *filename_ptr
= best_fit
->file
;
2812 *linenumber_ptr
= best_fit
->line
;
2819 /* Variable table functions. */
2821 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
2822 LINENUMBER_PTR, and return TRUE. */
2825 lookup_symbol_in_variable_table (struct comp_unit
*unit
,
2828 const char **filename_ptr
,
2829 unsigned int *linenumber_ptr
)
2831 const char *name
= bfd_asymbol_name (sym
);
2832 asection
*sec
= bfd_asymbol_section (sym
);
2833 struct varinfo
* each
;
2835 for (each
= unit
->variable_table
; each
; each
= each
->prev_var
)
2837 && each
->file
!= NULL
2838 && each
->name
!= NULL
2839 && each
->addr
== addr
2840 && (!each
->sec
|| each
->sec
== sec
)
2841 && strcmp (name
, each
->name
) == 0)
2847 *filename_ptr
= each
->file
;
2848 *linenumber_ptr
= each
->line
;
2855 static struct comp_unit
*stash_comp_unit (struct dwarf2_debug
*,
2856 struct dwarf2_debug_file
*);
2857 static bool comp_unit_maybe_decode_line_info (struct comp_unit
*);
2860 find_abstract_instance (struct comp_unit
*unit
,
2861 struct attribute
*attr_ptr
,
2862 unsigned int recur_count
,
2865 char **filename_ptr
,
2866 int *linenumber_ptr
)
2868 bfd
*abfd
= unit
->abfd
;
2869 bfd_byte
*info_ptr
= NULL
;
2870 bfd_byte
*info_ptr_end
;
2871 unsigned int abbrev_number
, i
;
2872 struct abbrev_info
*abbrev
;
2873 bfd_uint64_t die_ref
= attr_ptr
->u
.val
;
2874 struct attribute attr
;
2875 const char *name
= NULL
;
2877 if (recur_count
== 100)
2880 (_("DWARF error: abstract instance recursion detected"));
2881 bfd_set_error (bfd_error_bad_value
);
2885 /* DW_FORM_ref_addr can reference an entry in a different CU. It
2886 is an offset from the .debug_info section, not the current CU. */
2887 if (attr_ptr
->form
== DW_FORM_ref_addr
)
2889 /* We only support DW_FORM_ref_addr within the same file, so
2890 any relocations should be resolved already. Check this by
2891 testing for a zero die_ref; There can't be a valid reference
2892 to the header of a .debug_info section.
2893 DW_FORM_ref_addr is an offset relative to .debug_info.
2894 Normally when using the GNU linker this is accomplished by
2895 emitting a symbolic reference to a label, because .debug_info
2896 sections are linked at zero. When there are multiple section
2897 groups containing .debug_info, as there might be in a
2898 relocatable object file, it would be reasonable to assume that
2899 a symbolic reference to a label in any .debug_info section
2900 might be used. Since we lay out multiple .debug_info
2901 sections at non-zero VMAs (see place_sections), and read
2902 them contiguously into dwarf_info_buffer, that means the
2903 reference is relative to dwarf_info_buffer. */
2906 info_ptr
= unit
->file
->dwarf_info_buffer
;
2907 info_ptr_end
= info_ptr
+ unit
->file
->dwarf_info_size
;
2908 total
= info_ptr_end
- info_ptr
;
2911 else if (die_ref
>= total
)
2914 (_("DWARF error: invalid abstract instance DIE ref"));
2915 bfd_set_error (bfd_error_bad_value
);
2918 info_ptr
+= die_ref
;
2920 else if (attr_ptr
->form
== DW_FORM_GNU_ref_alt
)
2922 bool first_time
= unit
->stash
->alt
.dwarf_info_buffer
== NULL
;
2924 info_ptr
= read_alt_indirect_ref (unit
, die_ref
);
2926 unit
->stash
->alt
.info_ptr
= unit
->stash
->alt
.dwarf_info_buffer
;
2927 if (info_ptr
== NULL
)
2930 (_("DWARF error: unable to read alt ref %" PRIu64
),
2931 (uint64_t) die_ref
);
2932 bfd_set_error (bfd_error_bad_value
);
2935 info_ptr_end
= (unit
->stash
->alt
.dwarf_info_buffer
2936 + unit
->stash
->alt
.dwarf_info_size
);
2937 if (unit
->stash
->alt
.all_comp_units
)
2938 unit
= unit
->stash
->alt
.all_comp_units
;
2941 if (attr_ptr
->form
== DW_FORM_ref_addr
2942 || attr_ptr
->form
== DW_FORM_GNU_ref_alt
)
2944 /* Now find the CU containing this pointer. */
2945 if (info_ptr
>= unit
->info_ptr_unit
&& info_ptr
< unit
->end_ptr
)
2946 info_ptr_end
= unit
->end_ptr
;
2949 /* Check other CUs to see if they contain the abbrev. */
2950 struct comp_unit
*u
;
2952 for (u
= unit
->prev_unit
; u
!= NULL
; u
= u
->prev_unit
)
2953 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
2957 for (u
= unit
->next_unit
; u
!= NULL
; u
= u
->next_unit
)
2958 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
2961 if (attr_ptr
->form
== DW_FORM_ref_addr
)
2964 u
= stash_comp_unit (unit
->stash
, &unit
->stash
->f
);
2967 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
2972 if (attr_ptr
->form
== DW_FORM_GNU_ref_alt
)
2975 u
= stash_comp_unit (unit
->stash
, &unit
->stash
->alt
);
2978 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
2986 (_("DWARF error: unable to locate abstract instance DIE ref %"
2987 PRIu64
), (uint64_t) die_ref
);
2988 bfd_set_error (bfd_error_bad_value
);
2992 info_ptr_end
= unit
->end_ptr
;
2997 /* DW_FORM_ref1, DW_FORM_ref2, DW_FORM_ref4, DW_FORM_ref8 or
2998 DW_FORM_ref_udata. These are all references relative to the
2999 start of the current CU. */
3002 info_ptr
= unit
->info_ptr_unit
;
3003 info_ptr_end
= unit
->end_ptr
;
3004 total
= info_ptr_end
- info_ptr
;
3005 if (!die_ref
|| die_ref
>= total
)
3008 (_("DWARF error: invalid abstract instance DIE ref"));
3009 bfd_set_error (bfd_error_bad_value
);
3012 info_ptr
+= die_ref
;
3015 abbrev_number
= _bfd_safe_read_leb128 (abfd
, &info_ptr
,
3016 false, info_ptr_end
);
3019 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
3023 (_("DWARF error: could not find abbrev number %u"), abbrev_number
);
3024 bfd_set_error (bfd_error_bad_value
);
3029 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3031 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
,
3032 info_ptr
, info_ptr_end
);
3033 if (info_ptr
== NULL
)
3038 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
3040 if (name
== NULL
&& is_str_attr (attr
.form
))
3043 if (non_mangled (unit
->lang
))
3047 case DW_AT_specification
:
3048 if (!find_abstract_instance (unit
, &attr
, recur_count
+ 1,
3050 filename_ptr
, linenumber_ptr
))
3053 case DW_AT_linkage_name
:
3054 case DW_AT_MIPS_linkage_name
:
3055 /* PR 16949: Corrupt debug info can place
3056 non-string forms into these attributes. */
3057 if (is_str_attr (attr
.form
))
3063 case DW_AT_decl_file
:
3064 if (!comp_unit_maybe_decode_line_info (unit
))
3066 *filename_ptr
= concat_filename (unit
->line_table
,
3069 case DW_AT_decl_line
:
3070 *linenumber_ptr
= attr
.u
.val
;
3083 read_ranges (struct comp_unit
*unit
, struct arange
*arange
,
3084 bfd_uint64_t offset
)
3086 bfd_byte
*ranges_ptr
;
3087 bfd_byte
*ranges_end
;
3088 bfd_vma base_address
= unit
->base_address
;
3090 if (! unit
->file
->dwarf_ranges_buffer
)
3092 if (! read_debug_ranges (unit
))
3096 if (offset
> unit
->file
->dwarf_ranges_size
)
3098 ranges_ptr
= unit
->file
->dwarf_ranges_buffer
+ offset
;
3099 ranges_end
= unit
->file
->dwarf_ranges_buffer
+ unit
->file
->dwarf_ranges_size
;
3106 /* PR 17512: file: 62cada7d. */
3107 if (2u * unit
->addr_size
> (size_t) (ranges_end
- ranges_ptr
))
3110 low_pc
= read_address (unit
, &ranges_ptr
, ranges_end
);
3111 high_pc
= read_address (unit
, &ranges_ptr
, ranges_end
);
3113 if (low_pc
== 0 && high_pc
== 0)
3115 if (low_pc
== -1UL && high_pc
!= -1UL)
3116 base_address
= high_pc
;
3119 if (!arange_add (unit
, arange
,
3120 base_address
+ low_pc
, base_address
+ high_pc
))
3128 read_rnglists (struct comp_unit
*unit
, struct arange
*arange
,
3129 bfd_uint64_t offset
)
3133 bfd_vma base_address
= unit
->base_address
;
3136 bfd
*abfd
= unit
->abfd
;
3138 if (! unit
->file
->dwarf_rnglists_buffer
)
3140 if (! read_debug_rnglists (unit
))
3144 rngs_ptr
= unit
->file
->dwarf_rnglists_buffer
+ offset
;
3145 if (rngs_ptr
< unit
->file
->dwarf_rnglists_buffer
)
3147 rngs_end
= unit
->file
->dwarf_rnglists_buffer
;
3148 rngs_end
+= unit
->file
->dwarf_rnglists_size
;
3152 enum dwarf_range_list_entry rlet
;
3154 if (rngs_ptr
>= rngs_end
)
3157 rlet
= read_1_byte (abfd
, &rngs_ptr
, rngs_end
);
3161 case DW_RLE_end_of_list
:
3164 case DW_RLE_base_address
:
3165 if (unit
->addr_size
> (size_t) (rngs_end
- rngs_ptr
))
3167 base_address
= read_address (unit
, &rngs_ptr
, rngs_end
);
3170 case DW_RLE_start_length
:
3171 if (unit
->addr_size
> (size_t) (rngs_end
- rngs_ptr
))
3173 low_pc
= read_address (unit
, &rngs_ptr
, rngs_end
);
3175 high_pc
+= _bfd_safe_read_leb128 (abfd
, &rngs_ptr
,
3179 case DW_RLE_offset_pair
:
3180 low_pc
= base_address
;
3181 low_pc
+= _bfd_safe_read_leb128 (abfd
, &rngs_ptr
,
3183 high_pc
= base_address
;
3184 high_pc
+= _bfd_safe_read_leb128 (abfd
, &rngs_ptr
,
3188 case DW_RLE_start_end
:
3189 if (2u * unit
->addr_size
> (size_t) (rngs_end
- rngs_ptr
))
3191 low_pc
= read_address (unit
, &rngs_ptr
, rngs_end
);
3192 high_pc
= read_address (unit
, &rngs_ptr
, rngs_end
);
3195 /* TODO x-variants need .debug_addr support used for split-dwarf. */
3196 case DW_RLE_base_addressx
:
3197 case DW_RLE_startx_endx
:
3198 case DW_RLE_startx_length
:
3203 if (!arange_add (unit
, arange
, low_pc
, high_pc
))
3209 read_rangelist (struct comp_unit
*unit
, struct arange
*arange
,
3210 bfd_uint64_t offset
)
3212 if (unit
->version
<= 4)
3213 return read_ranges (unit
, arange
, offset
);
3215 return read_rnglists (unit
, arange
, offset
);
3218 static struct funcinfo
*
3219 lookup_func_by_offset (bfd_uint64_t offset
, struct funcinfo
* table
)
3221 for (; table
!= NULL
; table
= table
->prev_func
)
3222 if (table
->unit_offset
== offset
)
3227 static struct varinfo
*
3228 lookup_var_by_offset (bfd_uint64_t offset
, struct varinfo
* table
)
3232 if (table
->unit_offset
== offset
)
3234 table
= table
->prev_var
;
3241 /* DWARF2 Compilation unit functions. */
3243 /* Scan over each die in a comp. unit looking for functions to add
3244 to the function table and variables to the variable table. */
3247 scan_unit_for_symbols (struct comp_unit
*unit
)
3249 bfd
*abfd
= unit
->abfd
;
3250 bfd_byte
*info_ptr
= unit
->first_child_die_ptr
;
3251 bfd_byte
*info_ptr_end
= unit
->end_ptr
;
3252 int nesting_level
= 0;
3253 struct nest_funcinfo
3255 struct funcinfo
*func
;
3257 int nested_funcs_size
;
3259 /* Maintain a stack of in-scope functions and inlined functions, which we
3260 can use to set the caller_func field. */
3261 nested_funcs_size
= 32;
3262 nested_funcs
= (struct nest_funcinfo
*)
3263 bfd_malloc (nested_funcs_size
* sizeof (*nested_funcs
));
3264 if (nested_funcs
== NULL
)
3266 nested_funcs
[nesting_level
].func
= 0;
3268 /* PR 27484: We must scan the DIEs twice. The first time we look for
3269 function and variable tags and accumulate them into their respective
3270 tables. The second time through we process the attributes of the
3271 functions/variables and augment the table entries. */
3272 while (nesting_level
>= 0)
3274 unsigned int abbrev_number
, i
;
3275 struct abbrev_info
*abbrev
;
3276 struct funcinfo
*func
;
3277 struct varinfo
*var
;
3278 bfd_uint64_t current_offset
;
3280 /* PR 17512: file: 9f405d9d. */
3281 if (info_ptr
>= info_ptr_end
)
3284 current_offset
= info_ptr
- unit
->info_ptr_unit
;
3285 abbrev_number
= _bfd_safe_read_leb128 (abfd
, &info_ptr
,
3286 false, info_ptr_end
);
3287 if (abbrev_number
== 0)
3293 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
3296 static unsigned int previous_failed_abbrev
= -1U;
3298 /* Avoid multiple reports of the same missing abbrev. */
3299 if (abbrev_number
!= previous_failed_abbrev
)
3302 (_("DWARF error: could not find abbrev number %u"),
3304 previous_failed_abbrev
= abbrev_number
;
3306 bfd_set_error (bfd_error_bad_value
);
3310 if (abbrev
->tag
== DW_TAG_subprogram
3311 || abbrev
->tag
== DW_TAG_entry_point
3312 || abbrev
->tag
== DW_TAG_inlined_subroutine
)
3314 size_t amt
= sizeof (struct funcinfo
);
3317 func
= (struct funcinfo
*) bfd_zalloc (abfd
, amt
);
3320 func
->tag
= abbrev
->tag
;
3321 func
->prev_func
= unit
->function_table
;
3322 func
->unit_offset
= current_offset
;
3323 unit
->function_table
= func
;
3324 unit
->number_of_functions
++;
3325 BFD_ASSERT (!unit
->cached
);
3327 if (func
->tag
== DW_TAG_inlined_subroutine
)
3328 for (i
= nesting_level
; i
-- != 0; )
3329 if (nested_funcs
[i
].func
)
3331 func
->caller_func
= nested_funcs
[i
].func
;
3334 nested_funcs
[nesting_level
].func
= func
;
3339 if (abbrev
->tag
== DW_TAG_variable
3340 || abbrev
->tag
== DW_TAG_member
)
3342 size_t amt
= sizeof (struct varinfo
);
3344 var
= (struct varinfo
*) bfd_zalloc (abfd
, amt
);
3347 var
->tag
= abbrev
->tag
;
3349 var
->prev_var
= unit
->variable_table
;
3350 unit
->variable_table
= var
;
3351 var
->unit_offset
= current_offset
;
3352 /* PR 18205: Missing debug information can cause this
3353 var to be attached to an already cached unit. */
3358 /* No inline function in scope at this nesting level. */
3359 nested_funcs
[nesting_level
].func
= 0;
3362 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3364 struct attribute attr
;
3366 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
],
3367 unit
, info_ptr
, info_ptr_end
);
3368 if (info_ptr
== NULL
)
3372 if (abbrev
->has_children
)
3376 if (nesting_level
>= nested_funcs_size
)
3378 struct nest_funcinfo
*tmp
;
3380 nested_funcs_size
*= 2;
3381 tmp
= (struct nest_funcinfo
*)
3382 bfd_realloc (nested_funcs
,
3383 nested_funcs_size
* sizeof (*nested_funcs
));
3388 nested_funcs
[nesting_level
].func
= 0;
3392 /* This is the second pass over the abbrevs. */
3393 info_ptr
= unit
->first_child_die_ptr
;
3396 while (nesting_level
>= 0)
3398 unsigned int abbrev_number
, i
;
3399 struct abbrev_info
*abbrev
;
3400 struct attribute attr
;
3401 struct funcinfo
*func
;
3402 struct varinfo
*var
;
3404 bfd_vma high_pc
= 0;
3405 bool high_pc_relative
= false;
3406 bfd_uint64_t current_offset
;
3408 /* PR 17512: file: 9f405d9d. */
3409 if (info_ptr
>= info_ptr_end
)
3412 current_offset
= info_ptr
- unit
->info_ptr_unit
;
3413 abbrev_number
= _bfd_safe_read_leb128 (abfd
, &info_ptr
,
3414 false, info_ptr_end
);
3415 if (! abbrev_number
)
3421 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
3422 /* This should have been handled above. */
3423 BFD_ASSERT (abbrev
!= NULL
);
3427 if (abbrev
->tag
== DW_TAG_subprogram
3428 || abbrev
->tag
== DW_TAG_entry_point
3429 || abbrev
->tag
== DW_TAG_inlined_subroutine
)
3431 func
= lookup_func_by_offset (current_offset
, unit
->function_table
);
3435 else if (abbrev
->tag
== DW_TAG_variable
3436 || abbrev
->tag
== DW_TAG_member
)
3438 var
= lookup_var_by_offset (current_offset
, unit
->variable_table
);
3443 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3445 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
],
3446 unit
, info_ptr
, info_ptr_end
);
3447 if (info_ptr
== NULL
)
3454 case DW_AT_call_file
:
3455 func
->caller_file
= concat_filename (unit
->line_table
,
3459 case DW_AT_call_line
:
3460 func
->caller_line
= attr
.u
.val
;
3463 case DW_AT_abstract_origin
:
3464 case DW_AT_specification
:
3465 if (!find_abstract_instance (unit
, &attr
, 0,
3474 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
3476 if (func
->name
== NULL
&& is_str_attr (attr
.form
))
3478 func
->name
= attr
.u
.str
;
3479 if (non_mangled (unit
->lang
))
3480 func
->is_linkage
= true;
3484 case DW_AT_linkage_name
:
3485 case DW_AT_MIPS_linkage_name
:
3486 /* PR 16949: Corrupt debug info can place
3487 non-string forms into these attributes. */
3488 if (is_str_attr (attr
.form
))
3490 func
->name
= attr
.u
.str
;
3491 func
->is_linkage
= true;
3496 low_pc
= attr
.u
.val
;
3500 high_pc
= attr
.u
.val
;
3501 high_pc_relative
= attr
.form
!= DW_FORM_addr
;
3505 if (!read_rangelist (unit
, &func
->arange
, attr
.u
.val
))
3509 case DW_AT_decl_file
:
3510 func
->file
= concat_filename (unit
->line_table
,
3514 case DW_AT_decl_line
:
3515 func
->line
= attr
.u
.val
;
3526 case DW_AT_specification
:
3529 struct varinfo
* spec_var
;
3531 spec_var
= lookup_var_by_offset (attr
.u
.val
,
3532 unit
->variable_table
);
3533 if (spec_var
== NULL
)
3535 _bfd_error_handler (_("DWARF error: could not find "
3536 "variable specification "
3538 (unsigned long) attr
.u
.val
);
3542 if (var
->name
== NULL
)
3543 var
->name
= spec_var
->name
;
3544 if (var
->file
== NULL
&& spec_var
->file
!= NULL
)
3545 var
->file
= strdup (spec_var
->file
);
3547 var
->line
= spec_var
->line
;
3548 if (var
->sec
== NULL
)
3549 var
->sec
= spec_var
->sec
;
3554 if (is_str_attr (attr
.form
))
3555 var
->name
= attr
.u
.str
;
3558 case DW_AT_decl_file
:
3559 var
->file
= concat_filename (unit
->line_table
,
3563 case DW_AT_decl_line
:
3564 var
->line
= attr
.u
.val
;
3567 case DW_AT_external
:
3568 if (attr
.u
.val
!= 0)
3572 case DW_AT_location
:
3576 case DW_FORM_block1
:
3577 case DW_FORM_block2
:
3578 case DW_FORM_block4
:
3579 case DW_FORM_exprloc
:
3580 if (attr
.u
.blk
->data
!= NULL
3581 && *attr
.u
.blk
->data
== DW_OP_addr
)
3585 /* Verify that DW_OP_addr is the only opcode in the
3586 location, in which case the block size will be 1
3587 plus the address size. */
3588 /* ??? For TLS variables, gcc can emit
3589 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
3590 which we don't handle here yet. */
3591 if (attr
.u
.blk
->size
== unit
->addr_size
+ 1U)
3592 var
->addr
= bfd_get (unit
->addr_size
* 8,
3594 attr
.u
.blk
->data
+ 1);
3609 if (abbrev
->has_children
)
3612 if (high_pc_relative
)
3615 if (func
&& high_pc
!= 0)
3617 if (!arange_add (unit
, &func
->arange
, low_pc
, high_pc
))
3622 free (nested_funcs
);
3626 free (nested_funcs
);
3630 /* Parse a DWARF2 compilation unit starting at INFO_PTR. UNIT_LENGTH
3631 includes the compilation unit header that proceeds the DIE's, but
3632 does not include the length field that precedes each compilation
3633 unit header. END_PTR points one past the end of this comp unit.
3634 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
3636 This routine does not read the whole compilation unit; only enough
3637 to get to the line number information for the compilation unit. */
3639 static struct comp_unit
*
3640 parse_comp_unit (struct dwarf2_debug
*stash
,
3641 struct dwarf2_debug_file
*file
,
3643 bfd_vma unit_length
,
3644 bfd_byte
*info_ptr_unit
,
3645 unsigned int offset_size
)
3647 struct comp_unit
* unit
;
3648 unsigned int version
;
3649 bfd_uint64_t abbrev_offset
= 0;
3650 /* Initialize it just to avoid a GCC false warning. */
3651 unsigned int addr_size
= -1;
3652 struct abbrev_info
** abbrevs
;
3653 unsigned int abbrev_number
, i
;
3654 struct abbrev_info
*abbrev
;
3655 struct attribute attr
;
3656 bfd_byte
*end_ptr
= info_ptr
+ unit_length
;
3659 bfd_vma high_pc
= 0;
3660 bfd
*abfd
= file
->bfd_ptr
;
3661 bool high_pc_relative
= false;
3662 enum dwarf_unit_type unit_type
;
3664 version
= read_2_bytes (abfd
, &info_ptr
, end_ptr
);
3665 if (version
< 2 || version
> 5)
3667 /* PR 19872: A version number of 0 probably means that there is padding
3668 at the end of the .debug_info section. Gold puts it there when
3669 performing an incremental link, for example. So do not generate
3670 an error, just return a NULL. */
3674 (_("DWARF error: found dwarf version '%u', this reader"
3675 " only handles version 2, 3, 4 and 5 information"), version
);
3676 bfd_set_error (bfd_error_bad_value
);
3682 unit_type
= DW_UT_compile
;
3685 unit_type
= read_1_byte (abfd
, &info_ptr
, end_ptr
);
3686 addr_size
= read_1_byte (abfd
, &info_ptr
, end_ptr
);
3689 BFD_ASSERT (offset_size
== 4 || offset_size
== 8);
3690 if (offset_size
== 4)
3691 abbrev_offset
= read_4_bytes (abfd
, &info_ptr
, end_ptr
);
3693 abbrev_offset
= read_8_bytes (abfd
, &info_ptr
, end_ptr
);
3696 addr_size
= read_1_byte (abfd
, &info_ptr
, end_ptr
);
3698 if (unit_type
== DW_UT_type
)
3700 /* Skip type signature. */
3703 /* Skip type offset. */
3704 info_ptr
+= offset_size
;
3707 if (addr_size
> sizeof (bfd_vma
))
3710 /* xgettext: c-format */
3711 (_("DWARF error: found address size '%u', this reader"
3712 " can not handle sizes greater than '%u'"),
3714 (unsigned int) sizeof (bfd_vma
));
3715 bfd_set_error (bfd_error_bad_value
);
3719 if (addr_size
!= 2 && addr_size
!= 4 && addr_size
!= 8)
3722 ("DWARF error: found address size '%u', this reader"
3723 " can only handle address sizes '2', '4' and '8'", addr_size
);
3724 bfd_set_error (bfd_error_bad_value
);
3728 /* Read the abbrevs for this compilation unit into a table. */
3729 abbrevs
= read_abbrevs (abfd
, abbrev_offset
, stash
, file
);
3733 abbrev_number
= _bfd_safe_read_leb128 (abfd
, &info_ptr
,
3735 if (! abbrev_number
)
3737 /* PR 19872: An abbrev number of 0 probably means that there is padding
3738 at the end of the .debug_abbrev section. Gold puts it there when
3739 performing an incremental link, for example. So do not generate
3740 an error, just return a NULL. */
3744 abbrev
= lookup_abbrev (abbrev_number
, abbrevs
);
3747 _bfd_error_handler (_("DWARF error: could not find abbrev number %u"),
3749 bfd_set_error (bfd_error_bad_value
);
3753 amt
= sizeof (struct comp_unit
);
3754 unit
= (struct comp_unit
*) bfd_zalloc (abfd
, amt
);
3758 unit
->version
= version
;
3759 unit
->addr_size
= addr_size
;
3760 unit
->offset_size
= offset_size
;
3761 unit
->abbrevs
= abbrevs
;
3762 unit
->end_ptr
= end_ptr
;
3763 unit
->stash
= stash
;
3765 unit
->info_ptr_unit
= info_ptr_unit
;
3767 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3769 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
, end_ptr
);
3770 if (info_ptr
== NULL
)
3773 /* Store the data if it is of an attribute we want to keep in a
3774 partial symbol table. */
3777 case DW_AT_stmt_list
:
3779 unit
->line_offset
= attr
.u
.val
;
3783 if (is_str_attr (attr
.form
))
3784 unit
->name
= attr
.u
.str
;
3788 low_pc
= attr
.u
.val
;
3789 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
3790 this is the base address to use when reading location
3791 lists or range lists. */
3792 if (abbrev
->tag
== DW_TAG_compile_unit
)
3793 unit
->base_address
= low_pc
;
3797 high_pc
= attr
.u
.val
;
3798 high_pc_relative
= attr
.form
!= DW_FORM_addr
;
3802 if (!read_rangelist (unit
, &unit
->arange
, attr
.u
.val
))
3806 case DW_AT_comp_dir
:
3808 char *comp_dir
= attr
.u
.str
;
3810 /* PR 17512: file: 1fe726be. */
3811 if (! is_str_attr (attr
.form
))
3814 (_("DWARF error: DW_AT_comp_dir attribute encountered with a non-string form"));
3820 /* Irix 6.2 native cc prepends <machine>.: to the compilation
3821 directory, get rid of it. */
3822 char *cp
= strchr (comp_dir
, ':');
3824 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
3827 unit
->comp_dir
= comp_dir
;
3831 case DW_AT_language
:
3832 unit
->lang
= attr
.u
.val
;
3839 if (high_pc_relative
)
3843 if (!arange_add (unit
, &unit
->arange
, low_pc
, high_pc
))
3847 unit
->first_child_die_ptr
= info_ptr
;
3851 /* Return TRUE if UNIT may contain the address given by ADDR. When
3852 there are functions written entirely with inline asm statements, the
3853 range info in the compilation unit header may not be correct. We
3854 need to consult the line info table to see if a compilation unit
3855 really contains the given address. */
3858 comp_unit_contains_address (struct comp_unit
*unit
, bfd_vma addr
)
3860 struct arange
*arange
;
3865 arange
= &unit
->arange
;
3868 if (addr
>= arange
->low
&& addr
< arange
->high
)
3870 arange
= arange
->next
;
3877 /* If UNIT contains ADDR, set the output parameters to the values for
3878 the line containing ADDR. The output parameters, FILENAME_PTR,
3879 FUNCTION_PTR, and LINENUMBER_PTR, are pointers to the objects
3882 Returns the range of addresses covered by the entry that was used
3883 to fill in *LINENUMBER_PTR or 0 if it was not filled in. */
3886 comp_unit_find_nearest_line (struct comp_unit
*unit
,
3888 const char **filename_ptr
,
3889 struct funcinfo
**function_ptr
,
3890 unsigned int *linenumber_ptr
,
3891 unsigned int *discriminator_ptr
)
3895 if (!comp_unit_maybe_decode_line_info (unit
))
3898 *function_ptr
= NULL
;
3899 func_p
= lookup_address_in_function_table (unit
, addr
, function_ptr
);
3900 if (func_p
&& (*function_ptr
)->tag
== DW_TAG_inlined_subroutine
)
3901 unit
->stash
->inliner_chain
= *function_ptr
;
3903 return lookup_address_in_line_info_table (unit
->line_table
, addr
,
3909 /* Check to see if line info is already decoded in a comp_unit.
3910 If not, decode it. Returns TRUE if no errors were encountered;
3914 comp_unit_maybe_decode_line_info (struct comp_unit
*unit
)
3919 if (! unit
->line_table
)
3921 if (! unit
->stmtlist
)
3927 unit
->line_table
= decode_line_info (unit
);
3929 if (! unit
->line_table
)
3935 if (unit
->first_child_die_ptr
< unit
->end_ptr
3936 && ! scan_unit_for_symbols (unit
))
3946 /* If UNIT contains SYM at ADDR, set the output parameters to the
3947 values for the line containing SYM. The output parameters,
3948 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
3951 Return TRUE if UNIT contains SYM, and no errors were encountered;
3955 comp_unit_find_line (struct comp_unit
*unit
,
3958 const char **filename_ptr
,
3959 unsigned int *linenumber_ptr
)
3961 if (!comp_unit_maybe_decode_line_info (unit
))
3964 if (sym
->flags
& BSF_FUNCTION
)
3965 return lookup_symbol_in_function_table (unit
, sym
, addr
,
3969 return lookup_symbol_in_variable_table (unit
, sym
, addr
,
3974 static struct funcinfo
*
3975 reverse_funcinfo_list (struct funcinfo
*head
)
3977 struct funcinfo
*rhead
;
3978 struct funcinfo
*temp
;
3980 for (rhead
= NULL
; head
; head
= temp
)
3982 temp
= head
->prev_func
;
3983 head
->prev_func
= rhead
;
3989 static struct varinfo
*
3990 reverse_varinfo_list (struct varinfo
*head
)
3992 struct varinfo
*rhead
;
3993 struct varinfo
*temp
;
3995 for (rhead
= NULL
; head
; head
= temp
)
3997 temp
= head
->prev_var
;
3998 head
->prev_var
= rhead
;
4004 /* Extract all interesting funcinfos and varinfos of a compilation
4005 unit into hash tables for faster lookup. Returns TRUE if no
4006 errors were enountered; FALSE otherwise. */
4009 comp_unit_hash_info (struct dwarf2_debug
*stash
,
4010 struct comp_unit
*unit
,
4011 struct info_hash_table
*funcinfo_hash_table
,
4012 struct info_hash_table
*varinfo_hash_table
)
4014 struct funcinfo
* each_func
;
4015 struct varinfo
* each_var
;
4018 BFD_ASSERT (stash
->info_hash_status
!= STASH_INFO_HASH_DISABLED
);
4020 if (!comp_unit_maybe_decode_line_info (unit
))
4023 BFD_ASSERT (!unit
->cached
);
4025 /* To preserve the original search order, we went to visit the function
4026 infos in the reversed order of the list. However, making the list
4027 bi-directional use quite a bit of extra memory. So we reverse
4028 the list first, traverse the list in the now reversed order and
4029 finally reverse the list again to get back the original order. */
4030 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
4031 for (each_func
= unit
->function_table
;
4033 each_func
= each_func
->prev_func
)
4035 /* Skip nameless functions. */
4036 if (each_func
->name
)
4037 /* There is no need to copy name string into hash table as
4038 name string is either in the dwarf string buffer or
4039 info in the stash. */
4040 okay
= insert_info_hash_table (funcinfo_hash_table
, each_func
->name
,
4041 (void*) each_func
, false);
4043 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
4047 /* We do the same for variable infos. */
4048 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
4049 for (each_var
= unit
->variable_table
;
4051 each_var
= each_var
->prev_var
)
4053 /* Skip stack vars and vars with no files or names. */
4054 if (! each_var
->stack
4055 && each_var
->file
!= NULL
4056 && each_var
->name
!= NULL
)
4057 /* There is no need to copy name string into hash table as
4058 name string is either in the dwarf string buffer or
4059 info in the stash. */
4060 okay
= insert_info_hash_table (varinfo_hash_table
, each_var
->name
,
4061 (void*) each_var
, false);
4064 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
4065 unit
->cached
= true;
4069 /* Locate a section in a BFD containing debugging info. The search starts
4070 from the section after AFTER_SEC, or from the first section in the BFD if
4071 AFTER_SEC is NULL. The search works by examining the names of the
4072 sections. There are three permissiable names. The first two are given
4073 by DEBUG_SECTIONS[debug_info] (whose standard DWARF2 names are .debug_info
4074 and .zdebug_info). The third is a prefix .gnu.linkonce.wi.
4075 This is a variation on the .debug_info section which has a checksum
4076 describing the contents appended onto the name. This allows the linker to
4077 identify and discard duplicate debugging sections for different
4078 compilation units. */
4079 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
4082 find_debug_info (bfd
*abfd
, const struct dwarf_debug_section
*debug_sections
,
4083 asection
*after_sec
)
4088 if (after_sec
== NULL
)
4090 look
= debug_sections
[debug_info
].uncompressed_name
;
4091 msec
= bfd_get_section_by_name (abfd
, look
);
4095 look
= debug_sections
[debug_info
].compressed_name
;
4096 msec
= bfd_get_section_by_name (abfd
, look
);
4100 for (msec
= abfd
->sections
; msec
!= NULL
; msec
= msec
->next
)
4101 if (startswith (msec
->name
, GNU_LINKONCE_INFO
))
4107 for (msec
= after_sec
->next
; msec
!= NULL
; msec
= msec
->next
)
4109 look
= debug_sections
[debug_info
].uncompressed_name
;
4110 if (strcmp (msec
->name
, look
) == 0)
4113 look
= debug_sections
[debug_info
].compressed_name
;
4114 if (look
!= NULL
&& strcmp (msec
->name
, look
) == 0)
4117 if (startswith (msec
->name
, GNU_LINKONCE_INFO
))
4124 /* Transfer VMAs from object file to separate debug file. */
4127 set_debug_vma (bfd
*orig_bfd
, bfd
*debug_bfd
)
4131 for (s
= orig_bfd
->sections
, d
= debug_bfd
->sections
;
4132 s
!= NULL
&& d
!= NULL
;
4133 s
= s
->next
, d
= d
->next
)
4135 if ((d
->flags
& SEC_DEBUGGING
) != 0)
4137 /* ??? Assumes 1-1 correspondence between sections in the
4139 if (strcmp (s
->name
, d
->name
) == 0)
4141 d
->output_section
= s
->output_section
;
4142 d
->output_offset
= s
->output_offset
;
4148 /* If the dwarf2 info was found in a separate debug file, return the
4149 debug file section corresponding to the section in the original file
4150 and the debug file symbols. */
4153 _bfd_dwarf2_stash_syms (struct dwarf2_debug
*stash
, bfd
*abfd
,
4154 asection
**sec
, asymbol
***syms
)
4156 if (stash
->f
.bfd_ptr
!= abfd
)
4162 *syms
= stash
->f
.syms
;
4166 for (s
= abfd
->sections
, d
= stash
->f
.bfd_ptr
->sections
;
4167 s
!= NULL
&& d
!= NULL
;
4168 s
= s
->next
, d
= d
->next
)
4170 if ((d
->flags
& SEC_DEBUGGING
) != 0)
4173 && strcmp (s
->name
, d
->name
) == 0)
4176 *syms
= stash
->f
.syms
;
4183 /* Unset vmas for adjusted sections in STASH. */
4186 unset_sections (struct dwarf2_debug
*stash
)
4189 struct adjusted_section
*p
;
4191 i
= stash
->adjusted_section_count
;
4192 p
= stash
->adjusted_sections
;
4193 for (; i
> 0; i
--, p
++)
4194 p
->section
->vma
= 0;
4197 /* Set VMAs for allocated and .debug_info sections in ORIG_BFD, a
4198 relocatable object file. VMAs are normally all zero in relocatable
4199 object files, so if we want to distinguish locations in sections by
4200 address we need to set VMAs so the sections do not overlap. We
4201 also set VMA on .debug_info so that when we have multiple
4202 .debug_info sections (or the linkonce variant) they also do not
4203 overlap. The multiple .debug_info sections make up a single
4204 logical section. ??? We should probably do the same for other
4208 place_sections (bfd
*orig_bfd
, struct dwarf2_debug
*stash
)
4211 struct adjusted_section
*p
;
4213 const char *debug_info_name
;
4215 if (stash
->adjusted_section_count
!= 0)
4217 i
= stash
->adjusted_section_count
;
4218 p
= stash
->adjusted_sections
;
4219 for (; i
> 0; i
--, p
++)
4220 p
->section
->vma
= p
->adj_vma
;
4224 debug_info_name
= stash
->debug_sections
[debug_info
].uncompressed_name
;
4231 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
4235 if ((sect
->output_section
!= NULL
4236 && sect
->output_section
!= sect
4237 && (sect
->flags
& SEC_DEBUGGING
) == 0)
4241 is_debug_info
= (strcmp (sect
->name
, debug_info_name
) == 0
4242 || startswith (sect
->name
, GNU_LINKONCE_INFO
));
4244 if (!((sect
->flags
& SEC_ALLOC
) != 0 && abfd
== orig_bfd
)
4250 if (abfd
== stash
->f
.bfd_ptr
)
4252 abfd
= stash
->f
.bfd_ptr
;
4256 stash
->adjusted_section_count
= -1;
4259 bfd_vma last_vma
= 0, last_dwarf
= 0;
4260 size_t amt
= i
* sizeof (struct adjusted_section
);
4262 p
= (struct adjusted_section
*) bfd_malloc (amt
);
4266 stash
->adjusted_sections
= p
;
4267 stash
->adjusted_section_count
= i
;
4274 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
4279 if ((sect
->output_section
!= NULL
4280 && sect
->output_section
!= sect
4281 && (sect
->flags
& SEC_DEBUGGING
) == 0)
4285 is_debug_info
= (strcmp (sect
->name
, debug_info_name
) == 0
4286 || startswith (sect
->name
, GNU_LINKONCE_INFO
));
4288 if (!((sect
->flags
& SEC_ALLOC
) != 0 && abfd
== orig_bfd
)
4292 sz
= sect
->rawsize
? sect
->rawsize
: sect
->size
;
4296 BFD_ASSERT (sect
->alignment_power
== 0);
4297 sect
->vma
= last_dwarf
;
4302 /* Align the new address to the current section
4304 last_vma
= ((last_vma
4305 + ~(-((bfd_vma
) 1 << sect
->alignment_power
)))
4306 & (-((bfd_vma
) 1 << sect
->alignment_power
)));
4307 sect
->vma
= last_vma
;
4312 p
->adj_vma
= sect
->vma
;
4315 if (abfd
== stash
->f
.bfd_ptr
)
4317 abfd
= stash
->f
.bfd_ptr
;
4321 if (orig_bfd
!= stash
->f
.bfd_ptr
)
4322 set_debug_vma (orig_bfd
, stash
->f
.bfd_ptr
);
4327 /* Look up a funcinfo by name using the given info hash table. If found,
4328 also update the locations pointed to by filename_ptr and linenumber_ptr.
4330 This function returns TRUE if a funcinfo that matches the given symbol
4331 and address is found with any error; otherwise it returns FALSE. */
4334 info_hash_lookup_funcinfo (struct info_hash_table
*hash_table
,
4337 const char **filename_ptr
,
4338 unsigned int *linenumber_ptr
)
4340 struct funcinfo
* each_func
;
4341 struct funcinfo
* best_fit
= NULL
;
4342 bfd_vma best_fit_len
= 0;
4343 struct info_list_node
*node
;
4344 struct arange
*arange
;
4345 const char *name
= bfd_asymbol_name (sym
);
4346 asection
*sec
= bfd_asymbol_section (sym
);
4348 for (node
= lookup_info_hash_table (hash_table
, name
);
4352 each_func
= (struct funcinfo
*) node
->info
;
4353 for (arange
= &each_func
->arange
;
4355 arange
= arange
->next
)
4357 if ((!each_func
->sec
|| each_func
->sec
== sec
)
4358 && addr
>= arange
->low
4359 && addr
< arange
->high
4361 || arange
->high
- arange
->low
< best_fit_len
))
4363 best_fit
= each_func
;
4364 best_fit_len
= arange
->high
- arange
->low
;
4371 best_fit
->sec
= sec
;
4372 *filename_ptr
= best_fit
->file
;
4373 *linenumber_ptr
= best_fit
->line
;
4380 /* Look up a varinfo by name using the given info hash table. If found,
4381 also update the locations pointed to by filename_ptr and linenumber_ptr.
4383 This function returns TRUE if a varinfo that matches the given symbol
4384 and address is found with any error; otherwise it returns FALSE. */
4387 info_hash_lookup_varinfo (struct info_hash_table
*hash_table
,
4390 const char **filename_ptr
,
4391 unsigned int *linenumber_ptr
)
4393 const char *name
= bfd_asymbol_name (sym
);
4394 asection
*sec
= bfd_asymbol_section (sym
);
4395 struct varinfo
* each
;
4396 struct info_list_node
*node
;
4398 for (node
= lookup_info_hash_table (hash_table
, name
);
4402 each
= (struct varinfo
*) node
->info
;
4403 if (each
->addr
== addr
4404 && (!each
->sec
|| each
->sec
== sec
))
4407 *filename_ptr
= each
->file
;
4408 *linenumber_ptr
= each
->line
;
4416 /* Update the funcinfo and varinfo info hash tables if they are
4417 not up to date. Returns TRUE if there is no error; otherwise
4418 returns FALSE and disable the info hash tables. */
4421 stash_maybe_update_info_hash_tables (struct dwarf2_debug
*stash
)
4423 struct comp_unit
*each
;
4425 /* Exit if hash tables are up-to-date. */
4426 if (stash
->f
.all_comp_units
== stash
->hash_units_head
)
4429 if (stash
->hash_units_head
)
4430 each
= stash
->hash_units_head
->prev_unit
;
4432 each
= stash
->f
.last_comp_unit
;
4436 if (!comp_unit_hash_info (stash
, each
, stash
->funcinfo_hash_table
,
4437 stash
->varinfo_hash_table
))
4439 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
4442 each
= each
->prev_unit
;
4445 stash
->hash_units_head
= stash
->f
.all_comp_units
;
4449 /* Check consistency of info hash tables. This is for debugging only. */
4451 static void ATTRIBUTE_UNUSED
4452 stash_verify_info_hash_table (struct dwarf2_debug
*stash
)
4454 struct comp_unit
*each_unit
;
4455 struct funcinfo
*each_func
;
4456 struct varinfo
*each_var
;
4457 struct info_list_node
*node
;
4460 for (each_unit
= stash
->f
.all_comp_units
;
4462 each_unit
= each_unit
->next_unit
)
4464 for (each_func
= each_unit
->function_table
;
4466 each_func
= each_func
->prev_func
)
4468 if (!each_func
->name
)
4470 node
= lookup_info_hash_table (stash
->funcinfo_hash_table
,
4474 while (node
&& !found
)
4476 found
= node
->info
== each_func
;
4482 for (each_var
= each_unit
->variable_table
;
4484 each_var
= each_var
->prev_var
)
4486 if (!each_var
->name
|| !each_var
->file
|| each_var
->stack
)
4488 node
= lookup_info_hash_table (stash
->varinfo_hash_table
,
4492 while (node
&& !found
)
4494 found
= node
->info
== each_var
;
4502 /* Check to see if we want to enable the info hash tables, which consume
4503 quite a bit of memory. Currently we only check the number times
4504 bfd_dwarf2_find_line is called. In the future, we may also want to
4505 take the number of symbols into account. */
4508 stash_maybe_enable_info_hash_tables (bfd
*abfd
, struct dwarf2_debug
*stash
)
4510 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_OFF
);
4512 if (stash
->info_hash_count
++ < STASH_INFO_HASH_TRIGGER
)
4515 /* FIXME: Maybe we should check the reduce_memory_overheads
4516 and optimize fields in the bfd_link_info structure ? */
4518 /* Create hash tables. */
4519 stash
->funcinfo_hash_table
= create_info_hash_table (abfd
);
4520 stash
->varinfo_hash_table
= create_info_hash_table (abfd
);
4521 if (!stash
->funcinfo_hash_table
|| !stash
->varinfo_hash_table
)
4523 /* Turn off info hashes if any allocation above fails. */
4524 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
4527 /* We need a forced update so that the info hash tables will
4528 be created even though there is no compilation unit. That
4529 happens if STASH_INFO_HASH_TRIGGER is 0. */
4530 if (stash_maybe_update_info_hash_tables (stash
))
4531 stash
->info_hash_status
= STASH_INFO_HASH_ON
;
4534 /* Find the file and line associated with a symbol and address using the
4535 info hash tables of a stash. If there is a match, the function returns
4536 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
4537 otherwise it returns FALSE. */
4540 stash_find_line_fast (struct dwarf2_debug
*stash
,
4543 const char **filename_ptr
,
4544 unsigned int *linenumber_ptr
)
4546 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_ON
);
4548 if (sym
->flags
& BSF_FUNCTION
)
4549 return info_hash_lookup_funcinfo (stash
->funcinfo_hash_table
, sym
, addr
,
4550 filename_ptr
, linenumber_ptr
);
4551 return info_hash_lookup_varinfo (stash
->varinfo_hash_table
, sym
, addr
,
4552 filename_ptr
, linenumber_ptr
);
4555 /* Save current section VMAs. */
4558 save_section_vma (const bfd
*abfd
, struct dwarf2_debug
*stash
)
4563 if (abfd
->section_count
== 0)
4565 stash
->sec_vma
= bfd_malloc (sizeof (*stash
->sec_vma
) * abfd
->section_count
);
4566 if (stash
->sec_vma
== NULL
)
4568 stash
->sec_vma_count
= abfd
->section_count
;
4569 for (i
= 0, s
= abfd
->sections
;
4570 s
!= NULL
&& i
< abfd
->section_count
;
4573 if (s
->output_section
!= NULL
)
4574 stash
->sec_vma
[i
] = s
->output_section
->vma
+ s
->output_offset
;
4576 stash
->sec_vma
[i
] = s
->vma
;
4581 /* Compare current section VMAs against those at the time the stash
4582 was created. If find_nearest_line is used in linker warnings or
4583 errors early in the link process, the debug info stash will be
4584 invalid for later calls. This is because we relocate debug info
4585 sections, so the stashed section contents depend on symbol values,
4586 which in turn depend on section VMAs. */
4589 section_vma_same (const bfd
*abfd
, const struct dwarf2_debug
*stash
)
4594 /* PR 24334: If the number of sections in ABFD has changed between
4595 when the stash was created and now, then we cannot trust the
4596 stashed vma information. */
4597 if (abfd
->section_count
!= stash
->sec_vma_count
)
4600 for (i
= 0, s
= abfd
->sections
;
4601 s
!= NULL
&& i
< abfd
->section_count
;
4606 if (s
->output_section
!= NULL
)
4607 vma
= s
->output_section
->vma
+ s
->output_offset
;
4610 if (vma
!= stash
->sec_vma
[i
])
4616 /* Read debug information from DEBUG_BFD when DEBUG_BFD is specified.
4617 If DEBUG_BFD is not specified, we read debug information from ABFD
4618 or its gnu_debuglink. The results will be stored in PINFO.
4619 The function returns TRUE iff debug information is ready. */
4622 _bfd_dwarf2_slurp_debug_info (bfd
*abfd
, bfd
*debug_bfd
,
4623 const struct dwarf_debug_section
*debug_sections
,
4628 size_t amt
= sizeof (struct dwarf2_debug
);
4629 bfd_size_type total_size
;
4631 struct dwarf2_debug
*stash
= (struct dwarf2_debug
*) *pinfo
;
4635 if (stash
->orig_bfd
== abfd
4636 && section_vma_same (abfd
, stash
))
4638 /* Check that we did previously find some debug information
4639 before attempting to make use of it. */
4640 if (stash
->f
.bfd_ptr
!= NULL
)
4642 if (do_place
&& !place_sections (abfd
, stash
))
4649 _bfd_dwarf2_cleanup_debug_info (abfd
, pinfo
);
4650 memset (stash
, 0, amt
);
4654 stash
= (struct dwarf2_debug
*) bfd_zalloc (abfd
, amt
);
4658 stash
->orig_bfd
= abfd
;
4659 stash
->debug_sections
= debug_sections
;
4660 stash
->f
.syms
= symbols
;
4661 if (!save_section_vma (abfd
, stash
))
4664 stash
->f
.abbrev_offsets
= htab_create_alloc (10, hash_abbrev
, eq_abbrev
,
4665 del_abbrev
, calloc
, free
);
4666 if (!stash
->f
.abbrev_offsets
)
4669 stash
->alt
.abbrev_offsets
= htab_create_alloc (10, hash_abbrev
, eq_abbrev
,
4670 del_abbrev
, calloc
, free
);
4671 if (!stash
->alt
.abbrev_offsets
)
4676 if (debug_bfd
== NULL
)
4679 msec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
4680 if (msec
== NULL
&& abfd
== debug_bfd
)
4682 char * debug_filename
;
4684 debug_filename
= bfd_follow_build_id_debuglink (abfd
, DEBUGDIR
);
4685 if (debug_filename
== NULL
)
4686 debug_filename
= bfd_follow_gnu_debuglink (abfd
, DEBUGDIR
);
4688 if (debug_filename
== NULL
)
4689 /* No dwarf2 info, and no gnu_debuglink to follow.
4690 Note that at this point the stash has been allocated, but
4691 contains zeros. This lets future calls to this function
4692 fail more quickly. */
4695 debug_bfd
= bfd_openr (debug_filename
, NULL
);
4696 free (debug_filename
);
4697 if (debug_bfd
== NULL
)
4698 /* FIXME: Should we report our failure to follow the debuglink ? */
4701 /* Set BFD_DECOMPRESS to decompress debug sections. */
4702 debug_bfd
->flags
|= BFD_DECOMPRESS
;
4703 if (!bfd_check_format (debug_bfd
, bfd_object
)
4704 || (msec
= find_debug_info (debug_bfd
,
4705 debug_sections
, NULL
)) == NULL
4706 || !bfd_generic_link_read_symbols (debug_bfd
))
4708 bfd_close (debug_bfd
);
4712 symbols
= bfd_get_outsymbols (debug_bfd
);
4713 stash
->f
.syms
= symbols
;
4714 stash
->close_on_cleanup
= true;
4716 stash
->f
.bfd_ptr
= debug_bfd
;
4719 && !place_sections (abfd
, stash
))
4722 /* There can be more than one DWARF2 info section in a BFD these
4723 days. First handle the easy case when there's only one. If
4724 there's more than one, try case two: none of the sections is
4725 compressed. In that case, read them all in and produce one
4726 large stash. We do this in two passes - in the first pass we
4727 just accumulate the section sizes, and in the second pass we
4728 read in the section's contents. (The allows us to avoid
4729 reallocing the data as we add sections to the stash.) If
4730 some or all sections are compressed, then do things the slow
4731 way, with a bunch of reallocs. */
4733 if (! find_debug_info (debug_bfd
, debug_sections
, msec
))
4735 /* Case 1: only one info section. */
4736 total_size
= msec
->size
;
4737 if (! read_section (debug_bfd
, &stash
->debug_sections
[debug_info
],
4739 &stash
->f
.dwarf_info_buffer
, &total_size
))
4744 /* Case 2: multiple sections. */
4745 for (total_size
= 0;
4747 msec
= find_debug_info (debug_bfd
, debug_sections
, msec
))
4749 /* Catch PR25070 testcase overflowing size calculation here. */
4750 if (total_size
+ msec
->size
< total_size
4751 || total_size
+ msec
->size
< msec
->size
)
4753 bfd_set_error (bfd_error_no_memory
);
4756 total_size
+= msec
->size
;
4759 stash
->f
.dwarf_info_buffer
= (bfd_byte
*) bfd_malloc (total_size
);
4760 if (stash
->f
.dwarf_info_buffer
== NULL
)
4764 for (msec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
4766 msec
= find_debug_info (debug_bfd
, debug_sections
, msec
))
4774 if (!(bfd_simple_get_relocated_section_contents
4775 (debug_bfd
, msec
, stash
->f
.dwarf_info_buffer
+ total_size
,
4783 stash
->f
.info_ptr
= stash
->f
.dwarf_info_buffer
;
4784 stash
->f
.dwarf_info_size
= total_size
;
4788 /* Parse the next DWARF2 compilation unit at FILE->INFO_PTR. */
4790 static struct comp_unit
*
4791 stash_comp_unit (struct dwarf2_debug
*stash
, struct dwarf2_debug_file
*file
)
4793 bfd_size_type length
;
4794 unsigned int offset_size
;
4795 bfd_byte
*info_ptr_unit
= file
->info_ptr
;
4796 bfd_byte
*info_ptr_end
= file
->dwarf_info_buffer
+ file
->dwarf_info_size
;
4798 if (file
->info_ptr
>= info_ptr_end
)
4801 length
= read_4_bytes (file
->bfd_ptr
, &file
->info_ptr
, info_ptr_end
);
4802 /* A 0xffffff length is the DWARF3 way of indicating
4803 we use 64-bit offsets, instead of 32-bit offsets. */
4804 if (length
== 0xffffffff)
4807 length
= read_8_bytes (file
->bfd_ptr
, &file
->info_ptr
, info_ptr_end
);
4809 /* A zero length is the IRIX way of indicating 64-bit offsets,
4810 mostly because the 64-bit length will generally fit in 32
4811 bits, and the endianness helps. */
4812 else if (length
== 0)
4815 length
= read_4_bytes (file
->bfd_ptr
, &file
->info_ptr
, info_ptr_end
);
4817 /* In the absence of the hints above, we assume 32-bit DWARF2
4818 offsets even for targets with 64-bit addresses, because:
4819 a) most of the time these targets will not have generated
4820 more than 2Gb of debug info and so will not need 64-bit
4823 b) if they do use 64-bit offsets but they are not using
4824 the size hints that are tested for above then they are
4825 not conforming to the DWARF3 standard anyway. */
4830 && length
<= (size_t) (info_ptr_end
- file
->info_ptr
))
4832 struct comp_unit
*each
= parse_comp_unit (stash
, file
,
4833 file
->info_ptr
, length
,
4834 info_ptr_unit
, offset_size
);
4837 if (file
->all_comp_units
)
4838 file
->all_comp_units
->prev_unit
= each
;
4840 file
->last_comp_unit
= each
;
4842 each
->next_unit
= file
->all_comp_units
;
4843 file
->all_comp_units
= each
;
4845 file
->info_ptr
+= length
;
4850 /* Don't trust any of the DWARF info after a corrupted length or
4852 file
->info_ptr
= info_ptr_end
;
4856 /* Hash function for an asymbol. */
4859 hash_asymbol (const void *sym
)
4861 const asymbol
*asym
= sym
;
4862 return htab_hash_string (asym
->name
);
4865 /* Equality function for asymbols. */
4868 eq_asymbol (const void *a
, const void *b
)
4870 const asymbol
*sa
= a
;
4871 const asymbol
*sb
= b
;
4872 return strcmp (sa
->name
, sb
->name
) == 0;
4875 /* Scan the debug information in PINFO looking for a DW_TAG_subprogram
4876 abbrev with a DW_AT_low_pc attached to it. Then lookup that same
4877 symbol in SYMBOLS and return the difference between the low_pc and
4878 the symbol's address. Returns 0 if no suitable symbol could be found. */
4881 _bfd_dwarf2_find_symbol_bias (asymbol
** symbols
, void ** pinfo
)
4883 struct dwarf2_debug
*stash
;
4884 struct comp_unit
* unit
;
4886 bfd_signed_vma result
= 0;
4889 stash
= (struct dwarf2_debug
*) *pinfo
;
4891 if (stash
== NULL
|| symbols
== NULL
)
4894 sym_hash
= htab_create_alloc (10, hash_asymbol
, eq_asymbol
,
4895 NULL
, xcalloc
, free
);
4896 for (psym
= symbols
; * psym
!= NULL
; psym
++)
4898 asymbol
* sym
= * psym
;
4900 if (sym
->flags
& BSF_FUNCTION
&& sym
->section
!= NULL
)
4902 void **slot
= htab_find_slot (sym_hash
, sym
, INSERT
);
4907 for (unit
= stash
->f
.all_comp_units
; unit
; unit
= unit
->next_unit
)
4909 struct funcinfo
* func
;
4911 comp_unit_maybe_decode_line_info (unit
);
4913 for (func
= unit
->function_table
; func
!= NULL
; func
= func
->prev_func
)
4914 if (func
->name
&& func
->arange
.low
)
4916 asymbol search
, *sym
;
4918 /* FIXME: Do we need to scan the aranges looking for the lowest pc value ? */
4920 search
.name
= func
->name
;
4921 sym
= htab_find (sym_hash
, &search
);
4924 result
= ((bfd_signed_vma
) func
->arange
.low
) -
4925 ((bfd_signed_vma
) (sym
->value
+ sym
->section
->vma
));
4932 htab_delete (sym_hash
);
4936 /* Find the source code location of SYMBOL. If SYMBOL is NULL
4937 then find the nearest source code location corresponding to
4938 the address SECTION + OFFSET.
4939 Returns 1 if the line is found without error and fills in
4940 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
4941 NULL the FUNCTIONNAME_PTR is also filled in.
4942 Returns 2 if partial information from _bfd_elf_find_function is
4943 returned (function and maybe file) by looking at symbols. DWARF2
4944 info is present but not regarding the requested code location.
4945 Returns 0 otherwise.
4946 SYMBOLS contains the symbol table for ABFD.
4947 DEBUG_SECTIONS contains the name of the dwarf debug sections. */
4950 _bfd_dwarf2_find_nearest_line (bfd
*abfd
,
4955 const char **filename_ptr
,
4956 const char **functionname_ptr
,
4957 unsigned int *linenumber_ptr
,
4958 unsigned int *discriminator_ptr
,
4959 const struct dwarf_debug_section
*debug_sections
,
4962 /* Read each compilation unit from the section .debug_info, and check
4963 to see if it contains the address we are searching for. If yes,
4964 lookup the address, and return the line number info. If no, go
4965 on to the next compilation unit.
4967 We keep a list of all the previously read compilation units, and
4968 a pointer to the next un-read compilation unit. Check the
4969 previously read units before reading more. */
4970 struct dwarf2_debug
*stash
;
4971 /* What address are we looking for? */
4973 struct comp_unit
* each
;
4974 struct funcinfo
*function
= NULL
;
4978 *filename_ptr
= NULL
;
4979 if (functionname_ptr
!= NULL
)
4980 *functionname_ptr
= NULL
;
4981 *linenumber_ptr
= 0;
4982 if (discriminator_ptr
)
4983 *discriminator_ptr
= 0;
4985 if (! _bfd_dwarf2_slurp_debug_info (abfd
, NULL
, debug_sections
,
4987 (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0))
4990 stash
= (struct dwarf2_debug
*) *pinfo
;
4992 do_line
= symbol
!= NULL
;
4995 BFD_ASSERT (section
== NULL
&& offset
== 0 && functionname_ptr
== NULL
);
4996 section
= bfd_asymbol_section (symbol
);
4997 addr
= symbol
->value
;
5001 BFD_ASSERT (section
!= NULL
&& functionname_ptr
!= NULL
);
5004 /* If we have no SYMBOL but the section we're looking at is not a
5005 code section, then take a look through the list of symbols to see
5006 if we have a symbol at the address we're looking for. If we do
5007 then use this to look up line information. This will allow us to
5008 give file and line results for data symbols. We exclude code
5009 symbols here, if we look up a function symbol and then look up the
5010 line information we'll actually return the line number for the
5011 opening '{' rather than the function definition line. This is
5012 because looking up by symbol uses the line table, in which the
5013 first line for a function is usually the opening '{', while
5014 looking up the function by section + offset uses the
5015 DW_AT_decl_line from the function DW_TAG_subprogram for the line,
5016 which will be the line of the function name. */
5017 if (symbols
!= NULL
&& (section
->flags
& SEC_CODE
) == 0)
5021 for (tmp
= symbols
; (*tmp
) != NULL
; ++tmp
)
5022 if ((*tmp
)->the_bfd
== abfd
5023 && (*tmp
)->section
== section
5024 && (*tmp
)->value
== offset
5025 && ((*tmp
)->flags
& BSF_SECTION_SYM
) == 0)
5029 /* For local symbols, keep going in the hope we find a
5031 if ((symbol
->flags
& BSF_GLOBAL
) != 0)
5037 if (section
->output_section
)
5038 addr
+= section
->output_section
->vma
+ section
->output_offset
;
5040 addr
+= section
->vma
;
5042 /* A null info_ptr indicates that there is no dwarf2 info
5043 (or that an error occured while setting up the stash). */
5044 if (! stash
->f
.info_ptr
)
5047 stash
->inliner_chain
= NULL
;
5049 /* Check the previously read comp. units first. */
5052 /* The info hash tables use quite a bit of memory. We may not want to
5053 always use them. We use some heuristics to decide if and when to
5055 if (stash
->info_hash_status
== STASH_INFO_HASH_OFF
)
5056 stash_maybe_enable_info_hash_tables (abfd
, stash
);
5058 /* Keep info hash table up to date if they are available. Note that we
5059 may disable the hash tables if there is any error duing update. */
5060 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
5061 stash_maybe_update_info_hash_tables (stash
);
5063 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
5065 found
= stash_find_line_fast (stash
, symbol
, addr
, filename_ptr
,
5072 /* Check the previously read comp. units first. */
5073 for (each
= stash
->f
.all_comp_units
; each
; each
= each
->next_unit
)
5074 if ((symbol
->flags
& BSF_FUNCTION
) == 0
5075 || each
->arange
.high
== 0
5076 || comp_unit_contains_address (each
, addr
))
5078 found
= comp_unit_find_line (each
, symbol
, addr
, filename_ptr
,
5087 bfd_vma min_range
= (bfd_vma
) -1;
5088 const char * local_filename
= NULL
;
5089 struct funcinfo
*local_function
= NULL
;
5090 unsigned int local_linenumber
= 0;
5091 unsigned int local_discriminator
= 0;
5093 for (each
= stash
->f
.all_comp_units
; each
; each
= each
->next_unit
)
5095 bfd_vma range
= (bfd_vma
) -1;
5097 found
= ((each
->arange
.high
== 0
5098 || comp_unit_contains_address (each
, addr
))
5099 && (range
= (comp_unit_find_nearest_line
5100 (each
, addr
, &local_filename
,
5101 &local_function
, &local_linenumber
,
5102 &local_discriminator
))) != 0);
5105 /* PRs 15935 15994: Bogus debug information may have provided us
5106 with an erroneous match. We attempt to counter this by
5107 selecting the match that has the smallest address range
5108 associated with it. (We are assuming that corrupt debug info
5109 will tend to result in extra large address ranges rather than
5110 extra small ranges).
5112 This does mean that we scan through all of the CUs associated
5113 with the bfd each time this function is called. But this does
5114 have the benefit of producing consistent results every time the
5115 function is called. */
5116 if (range
<= min_range
)
5118 if (filename_ptr
&& local_filename
)
5119 * filename_ptr
= local_filename
;
5121 function
= local_function
;
5122 if (discriminator_ptr
&& local_discriminator
)
5123 * discriminator_ptr
= local_discriminator
;
5124 if (local_linenumber
)
5125 * linenumber_ptr
= local_linenumber
;
5131 if (* linenumber_ptr
)
5138 /* Read each remaining comp. units checking each as they are read. */
5139 while ((each
= stash_comp_unit (stash
, &stash
->f
)) != NULL
)
5141 /* DW_AT_low_pc and DW_AT_high_pc are optional for
5142 compilation units. If we don't have them (i.e.,
5143 unit->high == 0), we need to consult the line info table
5144 to see if a compilation unit contains the given
5147 found
= (((symbol
->flags
& BSF_FUNCTION
) == 0
5148 || each
->arange
.high
== 0
5149 || comp_unit_contains_address (each
, addr
))
5150 && comp_unit_find_line (each
, symbol
, addr
,
5151 filename_ptr
, linenumber_ptr
));
5153 found
= ((each
->arange
.high
== 0
5154 || comp_unit_contains_address (each
, addr
))
5155 && comp_unit_find_nearest_line (each
, addr
,
5159 discriminator_ptr
) != 0);
5166 if (functionname_ptr
&& function
&& function
->is_linkage
)
5167 *functionname_ptr
= function
->name
;
5168 else if (functionname_ptr
5169 && (!*functionname_ptr
5170 || (function
&& !function
->is_linkage
)))
5173 asymbol
**syms
= symbols
;
5174 asection
*sec
= section
;
5176 _bfd_dwarf2_stash_syms (stash
, abfd
, &sec
, &syms
);
5177 fun
= _bfd_elf_find_function (abfd
, syms
, sec
, offset
,
5178 *filename_ptr
? NULL
: filename_ptr
,
5181 if (!found
&& fun
!= NULL
)
5184 if (function
&& !function
->is_linkage
)
5188 sec_vma
= section
->vma
;
5189 if (section
->output_section
!= NULL
)
5190 sec_vma
= section
->output_section
->vma
+ section
->output_offset
;
5192 && fun
->value
+ sec_vma
== function
->arange
.low
)
5193 function
->name
= *functionname_ptr
;
5194 /* Even if we didn't find a linkage name, say that we have
5195 to stop a repeated search of symbols. */
5196 function
->is_linkage
= true;
5200 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
5201 unset_sections (stash
);
5207 _bfd_dwarf2_find_inliner_info (bfd
*abfd ATTRIBUTE_UNUSED
,
5208 const char **filename_ptr
,
5209 const char **functionname_ptr
,
5210 unsigned int *linenumber_ptr
,
5213 struct dwarf2_debug
*stash
;
5215 stash
= (struct dwarf2_debug
*) *pinfo
;
5218 struct funcinfo
*func
= stash
->inliner_chain
;
5220 if (func
&& func
->caller_func
)
5222 *filename_ptr
= func
->caller_file
;
5223 *functionname_ptr
= func
->caller_func
->name
;
5224 *linenumber_ptr
= func
->caller_line
;
5225 stash
->inliner_chain
= func
->caller_func
;
5234 _bfd_dwarf2_cleanup_debug_info (bfd
*abfd
, void **pinfo
)
5236 struct dwarf2_debug
*stash
= (struct dwarf2_debug
*) *pinfo
;
5237 struct comp_unit
*each
;
5238 struct dwarf2_debug_file
*file
;
5240 if (abfd
== NULL
|| stash
== NULL
)
5243 if (stash
->varinfo_hash_table
)
5244 bfd_hash_table_free (&stash
->varinfo_hash_table
->base
);
5245 if (stash
->funcinfo_hash_table
)
5246 bfd_hash_table_free (&stash
->funcinfo_hash_table
->base
);
5251 for (each
= file
->all_comp_units
; each
; each
= each
->next_unit
)
5253 struct funcinfo
*function_table
= each
->function_table
;
5254 struct varinfo
*variable_table
= each
->variable_table
;
5256 if (each
->line_table
&& each
->line_table
!= file
->line_table
)
5258 free (each
->line_table
->files
);
5259 free (each
->line_table
->dirs
);
5262 free (each
->lookup_funcinfo_table
);
5263 each
->lookup_funcinfo_table
= NULL
;
5265 while (function_table
)
5267 free (function_table
->file
);
5268 function_table
->file
= NULL
;
5269 free (function_table
->caller_file
);
5270 function_table
->caller_file
= NULL
;
5271 function_table
= function_table
->prev_func
;
5274 while (variable_table
)
5276 free (variable_table
->file
);
5277 variable_table
->file
= NULL
;
5278 variable_table
= variable_table
->prev_var
;
5282 if (file
->line_table
)
5284 free (file
->line_table
->files
);
5285 free (file
->line_table
->dirs
);
5287 htab_delete (file
->abbrev_offsets
);
5289 free (file
->dwarf_line_str_buffer
);
5290 free (file
->dwarf_str_buffer
);
5291 free (file
->dwarf_ranges_buffer
);
5292 free (file
->dwarf_line_buffer
);
5293 free (file
->dwarf_abbrev_buffer
);
5294 free (file
->dwarf_info_buffer
);
5295 if (file
== &stash
->alt
)
5299 free (stash
->sec_vma
);
5300 free (stash
->adjusted_sections
);
5301 if (stash
->close_on_cleanup
)
5302 bfd_close (stash
->f
.bfd_ptr
);
5303 if (stash
->alt
.bfd_ptr
)
5304 bfd_close (stash
->alt
.bfd_ptr
);
5307 /* Find the function to a particular section and offset,
5308 for error reporting. */
5311 _bfd_elf_find_function (bfd
*abfd
,
5315 const char **filename_ptr
,
5316 const char **functionname_ptr
)
5318 struct elf_find_function_cache
5320 asection
*last_section
;
5322 const char *filename
;
5323 bfd_size_type func_size
;
5326 if (symbols
== NULL
)
5329 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
5332 cache
= elf_tdata (abfd
)->elf_find_function_cache
;
5335 cache
= bfd_zalloc (abfd
, sizeof (*cache
));
5336 elf_tdata (abfd
)->elf_find_function_cache
= cache
;
5340 if (cache
->last_section
!= section
5341 || cache
->func
== NULL
5342 || offset
< cache
->func
->value
5343 || offset
>= cache
->func
->value
+ cache
->func_size
)
5348 /* ??? Given multiple file symbols, it is impossible to reliably
5349 choose the right file name for global symbols. File symbols are
5350 local symbols, and thus all file symbols must sort before any
5351 global symbols. The ELF spec may be interpreted to say that a
5352 file symbol must sort before other local symbols, but currently
5353 ld -r doesn't do this. So, for ld -r output, it is possible to
5354 make a better choice of file name for local symbols by ignoring
5355 file symbols appearing after a given local symbol. */
5356 enum { nothing_seen
, symbol_seen
, file_after_symbol_seen
} state
;
5357 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5361 state
= nothing_seen
;
5362 cache
->filename
= NULL
;
5364 cache
->func_size
= 0;
5365 cache
->last_section
= section
;
5367 for (p
= symbols
; *p
!= NULL
; p
++)
5373 if ((sym
->flags
& BSF_FILE
) != 0)
5376 if (state
== symbol_seen
)
5377 state
= file_after_symbol_seen
;
5381 size
= bed
->maybe_function_sym (sym
, section
, &code_off
);
5383 && code_off
<= offset
5384 && (code_off
> low_func
5385 || (code_off
== low_func
5386 && size
> cache
->func_size
)))
5389 cache
->func_size
= size
;
5390 cache
->filename
= NULL
;
5391 low_func
= code_off
;
5393 && ((sym
->flags
& BSF_LOCAL
) != 0
5394 || state
!= file_after_symbol_seen
))
5395 cache
->filename
= bfd_asymbol_name (file
);
5397 if (state
== nothing_seen
)
5398 state
= symbol_seen
;
5402 if (cache
->func
== NULL
)
5406 *filename_ptr
= cache
->filename
;
5407 if (functionname_ptr
)
5408 *functionname_ptr
= bfd_asymbol_name (cache
->func
);