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 if (section_name
!= NULL
)
549 msec
= bfd_get_section_by_name (abfd
, section_name
);
553 _bfd_error_handler (_("DWARF error: can't find %s section."),
554 sec
->uncompressed_name
);
555 bfd_set_error (bfd_error_bad_value
);
559 amt
= bfd_get_section_limit_octets (abfd
, msec
);
560 filesize
= bfd_get_file_size (abfd
);
564 _bfd_error_handler (_("DWARF error: section %s is larger than its filesize! (0x%lx vs 0x%lx)"),
565 section_name
, (long) amt
, (long) filesize
);
566 bfd_set_error (bfd_error_bad_value
);
570 /* Paranoia - alloc one extra so that we can make sure a string
571 section is NUL terminated. */
575 /* Paranoia - this should never happen. */
576 bfd_set_error (bfd_error_no_memory
);
579 contents
= (bfd_byte
*) bfd_malloc (amt
);
580 if (contents
== NULL
)
583 ? !bfd_simple_get_relocated_section_contents (abfd
, msec
, contents
,
585 : !bfd_get_section_contents (abfd
, msec
, contents
, 0, *section_size
))
590 contents
[*section_size
] = 0;
591 *section_buffer
= contents
;
594 /* It is possible to get a bad value for the offset into the section
595 that the client wants. Validate it here to avoid trouble later. */
596 if (offset
!= 0 && offset
>= *section_size
)
598 /* xgettext: c-format */
599 _bfd_error_handler (_("DWARF error: offset (%" PRIu64
")"
600 " greater than or equal to %s size (%" PRIu64
")"),
601 (uint64_t) offset
, section_name
,
602 (uint64_t) *section_size
);
603 bfd_set_error (bfd_error_bad_value
);
610 /* Read dwarf information from a buffer. */
613 read_1_byte (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_byte
*buf
, bfd_byte
*end
)
617 return bfd_get_8 (abfd
, buf
);
621 read_1_signed_byte (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_byte
*buf
, bfd_byte
*end
)
625 return bfd_get_signed_8 (abfd
, buf
);
629 read_2_bytes (bfd
*abfd
, bfd_byte
*buf
, bfd_byte
*end
)
633 return bfd_get_16 (abfd
, buf
);
637 read_4_bytes (bfd
*abfd
, bfd_byte
*buf
, bfd_byte
*end
)
641 return bfd_get_32 (abfd
, buf
);
645 read_8_bytes (bfd
*abfd
, bfd_byte
*buf
, bfd_byte
*end
)
649 return bfd_get_64 (abfd
, buf
);
653 read_n_bytes (bfd_byte
* buf
,
655 struct dwarf_block
* block
)
657 unsigned int size
= block
->size
;
658 bfd_byte
* block_end
= buf
+ size
;
660 if (block_end
> end
|| block_end
< buf
)
673 /* Scans a NUL terminated string starting at BUF, returning a pointer to it.
674 Returns the number of characters in the string, *including* the NUL byte,
675 in BYTES_READ_PTR. This value is set even if the function fails. Bytes
676 at or beyond BUF_END will not be read. Returns NULL if there was a
677 problem, or if the string is empty. */
680 read_string (bfd
* abfd ATTRIBUTE_UNUSED
,
683 unsigned int * bytes_read_ptr
)
689 * bytes_read_ptr
= 0;
695 * bytes_read_ptr
= 1;
699 while (buf
< buf_end
)
702 * bytes_read_ptr
= buf
- str
;
706 * bytes_read_ptr
= buf
- str
;
710 /* Reads an offset from BUF and then locates the string at this offset
711 inside the debug string section. Returns a pointer to the string.
712 Returns the number of bytes read from BUF, *not* the length of the string,
713 in BYTES_READ_PTR. This value is set even if the function fails. Bytes
714 at or beyond BUF_END will not be read from BUF. Returns NULL if there was
715 a problem, or if the string is empty. Does not check for NUL termination
719 read_indirect_string (struct comp_unit
* unit
,
722 unsigned int * bytes_read_ptr
)
725 struct dwarf2_debug
*stash
= unit
->stash
;
726 struct dwarf2_debug_file
*file
= unit
->file
;
729 if (buf
+ unit
->offset_size
> buf_end
)
731 * bytes_read_ptr
= 0;
735 if (unit
->offset_size
== 4)
736 offset
= read_4_bytes (unit
->abfd
, buf
, buf_end
);
738 offset
= read_8_bytes (unit
->abfd
, buf
, buf_end
);
740 *bytes_read_ptr
= unit
->offset_size
;
742 if (! read_section (unit
->abfd
, &stash
->debug_sections
[debug_str
],
744 &file
->dwarf_str_buffer
, &file
->dwarf_str_size
))
747 str
= (char *) file
->dwarf_str_buffer
+ offset
;
753 /* Like read_indirect_string but from .debug_line_str section. */
756 read_indirect_line_string (struct comp_unit
* unit
,
759 unsigned int * bytes_read_ptr
)
762 struct dwarf2_debug
*stash
= unit
->stash
;
763 struct dwarf2_debug_file
*file
= unit
->file
;
766 if (buf
+ unit
->offset_size
> buf_end
)
768 * bytes_read_ptr
= 0;
772 if (unit
->offset_size
== 4)
773 offset
= read_4_bytes (unit
->abfd
, buf
, buf_end
);
775 offset
= read_8_bytes (unit
->abfd
, buf
, buf_end
);
777 *bytes_read_ptr
= unit
->offset_size
;
779 if (! read_section (unit
->abfd
, &stash
->debug_sections
[debug_line_str
],
781 &file
->dwarf_line_str_buffer
,
782 &file
->dwarf_line_str_size
))
785 str
= (char *) file
->dwarf_line_str_buffer
+ offset
;
791 /* Like read_indirect_string but uses a .debug_str located in
792 an alternate file pointed to by the .gnu_debugaltlink section.
793 Used to impement DW_FORM_GNU_strp_alt. */
796 read_alt_indirect_string (struct comp_unit
* unit
,
799 unsigned int * bytes_read_ptr
)
802 struct dwarf2_debug
*stash
= unit
->stash
;
805 if (buf
+ unit
->offset_size
> buf_end
)
807 * bytes_read_ptr
= 0;
811 if (unit
->offset_size
== 4)
812 offset
= read_4_bytes (unit
->abfd
, buf
, buf_end
);
814 offset
= read_8_bytes (unit
->abfd
, buf
, buf_end
);
816 *bytes_read_ptr
= unit
->offset_size
;
818 if (stash
->alt
.bfd_ptr
== NULL
)
821 char *debug_filename
= bfd_follow_gnu_debugaltlink (unit
->abfd
, DEBUGDIR
);
823 if (debug_filename
== NULL
)
826 debug_bfd
= bfd_openr (debug_filename
, NULL
);
827 free (debug_filename
);
828 if (debug_bfd
== NULL
)
829 /* FIXME: Should we report our failure to follow the debuglink ? */
832 if (!bfd_check_format (debug_bfd
, bfd_object
))
834 bfd_close (debug_bfd
);
837 stash
->alt
.bfd_ptr
= debug_bfd
;
840 if (! read_section (unit
->stash
->alt
.bfd_ptr
,
841 stash
->debug_sections
+ debug_str_alt
,
842 stash
->alt
.syms
, offset
,
843 &stash
->alt
.dwarf_str_buffer
,
844 &stash
->alt
.dwarf_str_size
))
847 str
= (char *) stash
->alt
.dwarf_str_buffer
+ offset
;
854 /* Resolve an alternate reference from UNIT at OFFSET.
855 Returns a pointer into the loaded alternate CU upon success
856 or NULL upon failure. */
859 read_alt_indirect_ref (struct comp_unit
* unit
,
862 struct dwarf2_debug
*stash
= unit
->stash
;
864 if (stash
->alt
.bfd_ptr
== NULL
)
867 char *debug_filename
= bfd_follow_gnu_debugaltlink (unit
->abfd
, DEBUGDIR
);
869 if (debug_filename
== NULL
)
872 debug_bfd
= bfd_openr (debug_filename
, NULL
);
873 free (debug_filename
);
874 if (debug_bfd
== NULL
)
875 /* FIXME: Should we report our failure to follow the debuglink ? */
878 if (!bfd_check_format (debug_bfd
, bfd_object
))
880 bfd_close (debug_bfd
);
883 stash
->alt
.bfd_ptr
= debug_bfd
;
886 if (! read_section (unit
->stash
->alt
.bfd_ptr
,
887 stash
->debug_sections
+ debug_info_alt
,
888 stash
->alt
.syms
, offset
,
889 &stash
->alt
.dwarf_info_buffer
,
890 &stash
->alt
.dwarf_info_size
))
893 return stash
->alt
.dwarf_info_buffer
+ offset
;
897 read_address (struct comp_unit
*unit
, bfd_byte
*buf
, bfd_byte
* buf_end
)
901 if (bfd_get_flavour (unit
->abfd
) == bfd_target_elf_flavour
)
902 signed_vma
= get_elf_backend_data (unit
->abfd
)->sign_extend_vma
;
904 if (buf
+ unit
->addr_size
> buf_end
)
909 switch (unit
->addr_size
)
912 return bfd_get_signed_64 (unit
->abfd
, buf
);
914 return bfd_get_signed_32 (unit
->abfd
, buf
);
916 return bfd_get_signed_16 (unit
->abfd
, buf
);
923 switch (unit
->addr_size
)
926 return bfd_get_64 (unit
->abfd
, buf
);
928 return bfd_get_32 (unit
->abfd
, buf
);
930 return bfd_get_16 (unit
->abfd
, buf
);
937 /* Lookup an abbrev_info structure in the abbrev hash table. */
939 static struct abbrev_info
*
940 lookup_abbrev (unsigned int number
, struct abbrev_info
**abbrevs
)
942 unsigned int hash_number
;
943 struct abbrev_info
*abbrev
;
945 hash_number
= number
% ABBREV_HASH_SIZE
;
946 abbrev
= abbrevs
[hash_number
];
950 if (abbrev
->number
== number
)
953 abbrev
= abbrev
->next
;
959 /* We keep a hash table to map .debug_abbrev section offsets to the
960 array of abbrevs, so that compilation units using the same set of
961 abbrevs do not waste memory. */
963 struct abbrev_offset_entry
966 struct abbrev_info
**abbrevs
;
970 hash_abbrev (const void *p
)
972 const struct abbrev_offset_entry
*ent
= p
;
973 return htab_hash_pointer ((void *) ent
->offset
);
977 eq_abbrev (const void *pa
, const void *pb
)
979 const struct abbrev_offset_entry
*a
= pa
;
980 const struct abbrev_offset_entry
*b
= pb
;
981 return a
->offset
== b
->offset
;
987 struct abbrev_offset_entry
*ent
= p
;
988 struct abbrev_info
**abbrevs
= ent
->abbrevs
;
991 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
993 struct abbrev_info
*abbrev
= abbrevs
[i
];
997 free (abbrev
->attrs
);
998 abbrev
= abbrev
->next
;
1004 /* In DWARF version 2, the description of the debugging information is
1005 stored in a separate .debug_abbrev section. Before we read any
1006 dies from a section we read in all abbreviations and install them
1009 static struct abbrev_info
**
1010 read_abbrevs (bfd
*abfd
, bfd_uint64_t offset
, struct dwarf2_debug
*stash
,
1011 struct dwarf2_debug_file
*file
)
1013 struct abbrev_info
**abbrevs
;
1014 bfd_byte
*abbrev_ptr
;
1015 bfd_byte
*abbrev_end
;
1016 struct abbrev_info
*cur_abbrev
;
1017 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
1018 unsigned int abbrev_form
, hash_number
;
1021 struct abbrev_offset_entry ent
= { offset
, NULL
};
1023 if (ent
.offset
!= offset
)
1026 slot
= htab_find_slot (file
->abbrev_offsets
, &ent
, INSERT
);
1030 return ((struct abbrev_offset_entry
*) (*slot
))->abbrevs
;
1032 if (! read_section (abfd
, &stash
->debug_sections
[debug_abbrev
],
1034 &file
->dwarf_abbrev_buffer
,
1035 &file
->dwarf_abbrev_size
))
1038 amt
= sizeof (struct abbrev_info
*) * ABBREV_HASH_SIZE
;
1039 abbrevs
= (struct abbrev_info
**) bfd_zalloc (abfd
, amt
);
1040 if (abbrevs
== NULL
)
1043 abbrev_ptr
= file
->dwarf_abbrev_buffer
+ offset
;
1044 abbrev_end
= file
->dwarf_abbrev_buffer
+ file
->dwarf_abbrev_size
;
1045 abbrev_number
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
, &bytes_read
,
1047 abbrev_ptr
+= bytes_read
;
1049 /* Loop until we reach an abbrev number of 0. */
1050 while (abbrev_number
)
1052 amt
= sizeof (struct abbrev_info
);
1053 cur_abbrev
= (struct abbrev_info
*) bfd_zalloc (abfd
, amt
);
1054 if (cur_abbrev
== NULL
)
1057 /* Read in abbrev header. */
1058 cur_abbrev
->number
= abbrev_number
;
1059 cur_abbrev
->tag
= (enum dwarf_tag
)
1060 _bfd_safe_read_leb128 (abfd
, abbrev_ptr
, &bytes_read
,
1062 abbrev_ptr
+= bytes_read
;
1063 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
, abbrev_end
);
1066 /* Now read in declarations. */
1069 /* Initialize it just to avoid a GCC false warning. */
1070 bfd_vma implicit_const
= -1;
1072 abbrev_name
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
, &bytes_read
,
1074 abbrev_ptr
+= bytes_read
;
1075 abbrev_form
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
, &bytes_read
,
1077 abbrev_ptr
+= bytes_read
;
1078 if (abbrev_form
== DW_FORM_implicit_const
)
1080 implicit_const
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
,
1083 abbrev_ptr
+= bytes_read
;
1086 if (abbrev_name
== 0)
1089 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
1091 struct attr_abbrev
*tmp
;
1093 amt
= cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
;
1094 amt
*= sizeof (struct attr_abbrev
);
1095 tmp
= (struct attr_abbrev
*) bfd_realloc (cur_abbrev
->attrs
, amt
);
1098 cur_abbrev
->attrs
= tmp
;
1101 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
1102 = (enum dwarf_attribute
) abbrev_name
;
1103 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].form
1104 = (enum dwarf_form
) abbrev_form
;
1105 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].implicit_const
1107 ++cur_abbrev
->num_attrs
;
1110 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
1111 cur_abbrev
->next
= abbrevs
[hash_number
];
1112 abbrevs
[hash_number
] = cur_abbrev
;
1114 /* Get next abbreviation.
1115 Under Irix6 the abbreviations for a compilation unit are not
1116 always properly terminated with an abbrev number of 0.
1117 Exit loop if we encounter an abbreviation which we have
1118 already read (which means we are about to read the abbreviations
1119 for the next compile unit) or if the end of the abbreviation
1120 table is reached. */
1121 if ((size_t) (abbrev_ptr
- file
->dwarf_abbrev_buffer
)
1122 >= file
->dwarf_abbrev_size
)
1124 abbrev_number
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
,
1125 &bytes_read
, false, abbrev_end
);
1126 abbrev_ptr
+= bytes_read
;
1127 if (lookup_abbrev (abbrev_number
, abbrevs
) != NULL
)
1131 *slot
= bfd_malloc (sizeof ent
);
1134 ent
.abbrevs
= abbrevs
;
1135 memcpy (*slot
, &ent
, sizeof ent
);
1139 if (abbrevs
!= NULL
)
1143 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
1145 struct abbrev_info
*abbrev
= abbrevs
[i
];
1149 free (abbrev
->attrs
);
1150 abbrev
= abbrev
->next
;
1158 /* Returns true if the form is one which has a string value. */
1161 is_str_attr (enum dwarf_form form
)
1163 return (form
== DW_FORM_string
1164 || form
== DW_FORM_strp
1165 || form
== DW_FORM_strx
1166 || form
== DW_FORM_strx1
1167 || form
== DW_FORM_strx2
1168 || form
== DW_FORM_strx3
1169 || form
== DW_FORM_strx4
1170 || form
== DW_FORM_line_strp
1171 || form
== DW_FORM_GNU_strp_alt
);
1175 read_indexed_string (bfd_uint64_t idx ATTRIBUTE_UNUSED
,
1176 struct comp_unit
* unit ATTRIBUTE_UNUSED
)
1178 /* FIXME: Add support for indexed strings. */
1179 return "<indexed strings not yet supported>";
1182 /* Read and fill in the value of attribute ATTR as described by FORM.
1183 Read data starting from INFO_PTR, but never at or beyond INFO_PTR_END.
1184 Returns an updated INFO_PTR taking into account the amount of data read. */
1187 read_attribute_value (struct attribute
* attr
,
1189 bfd_vma implicit_const
,
1190 struct comp_unit
* unit
,
1191 bfd_byte
* info_ptr
,
1192 bfd_byte
* info_ptr_end
)
1194 bfd
*abfd
= unit
->abfd
;
1195 unsigned int bytes_read
;
1196 struct dwarf_block
*blk
;
1199 if (info_ptr
>= info_ptr_end
&& form
!= DW_FORM_flag_present
)
1201 _bfd_error_handler (_("DWARF error: info pointer extends beyond end of attributes"));
1202 bfd_set_error (bfd_error_bad_value
);
1206 attr
->form
= (enum dwarf_form
) form
;
1210 case DW_FORM_flag_present
:
1213 case DW_FORM_ref_addr
:
1214 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
1216 if (unit
->version
>= 3)
1218 if (unit
->offset_size
== 4)
1219 attr
->u
.val
= read_4_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1221 attr
->u
.val
= read_8_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1222 info_ptr
+= unit
->offset_size
;
1227 attr
->u
.val
= read_address (unit
, info_ptr
, info_ptr_end
);
1228 info_ptr
+= unit
->addr_size
;
1230 case DW_FORM_GNU_ref_alt
:
1231 case DW_FORM_sec_offset
:
1232 if (unit
->offset_size
== 4)
1233 attr
->u
.val
= read_4_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1235 attr
->u
.val
= read_8_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1236 info_ptr
+= unit
->offset_size
;
1238 case DW_FORM_block2
:
1239 amt
= sizeof (struct dwarf_block
);
1240 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1243 blk
->size
= read_2_bytes (abfd
, info_ptr
, info_ptr_end
);
1245 info_ptr
= read_n_bytes (info_ptr
, info_ptr_end
, blk
);
1248 case DW_FORM_block4
:
1249 amt
= sizeof (struct dwarf_block
);
1250 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1253 blk
->size
= read_4_bytes (abfd
, info_ptr
, info_ptr_end
);
1255 info_ptr
= read_n_bytes (info_ptr
, info_ptr_end
, blk
);
1261 case DW_FORM_addrx1
:
1262 attr
->u
.val
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1267 attr
->u
.val
= read_2_bytes (abfd
, info_ptr
, info_ptr_end
);
1270 case DW_FORM_addrx3
:
1271 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
, info_ptr_end
);
1272 attr
->u
.val
&= 0xffffff;
1277 case DW_FORM_addrx4
:
1278 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
, info_ptr_end
);
1283 case DW_FORM_ref_sig8
:
1284 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
, info_ptr_end
);
1287 case DW_FORM_string
:
1288 attr
->u
.str
= read_string (abfd
, info_ptr
, info_ptr_end
, &bytes_read
);
1289 info_ptr
+= bytes_read
;
1292 attr
->u
.str
= read_indirect_string (unit
, info_ptr
, info_ptr_end
, &bytes_read
);
1293 info_ptr
+= bytes_read
;
1295 case DW_FORM_line_strp
:
1296 attr
->u
.str
= read_indirect_line_string (unit
, info_ptr
, info_ptr_end
, &bytes_read
);
1297 info_ptr
+= bytes_read
;
1299 case DW_FORM_GNU_strp_alt
:
1300 attr
->u
.str
= read_alt_indirect_string (unit
, info_ptr
, info_ptr_end
, &bytes_read
);
1301 info_ptr
+= bytes_read
;
1304 attr
->u
.val
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1306 attr
->u
.str
= (char *) read_indexed_string (attr
->u
.val
, unit
);
1309 attr
->u
.val
= read_2_bytes (abfd
, info_ptr
, info_ptr_end
);
1311 attr
->u
.str
= (char *) read_indexed_string (attr
->u
.val
, unit
);
1314 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
, info_ptr_end
);
1316 attr
->u
.val
&= 0xffffff;
1317 attr
->u
.str
= (char *) read_indexed_string (attr
->u
.val
, unit
);
1320 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
, info_ptr_end
);
1322 attr
->u
.str
= (char *) read_indexed_string (attr
->u
.val
, unit
);
1325 attr
->u
.val
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1326 false, info_ptr_end
);
1327 info_ptr
+= bytes_read
;
1328 attr
->u
.str
= (char *) read_indexed_string (attr
->u
.val
, unit
);
1330 case DW_FORM_exprloc
:
1332 amt
= sizeof (struct dwarf_block
);
1333 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1336 blk
->size
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1337 false, info_ptr_end
);
1338 info_ptr
+= bytes_read
;
1339 info_ptr
= read_n_bytes (info_ptr
, info_ptr_end
, blk
);
1342 case DW_FORM_block1
:
1343 amt
= sizeof (struct dwarf_block
);
1344 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1347 blk
->size
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1349 info_ptr
= read_n_bytes (info_ptr
, info_ptr_end
, blk
);
1353 attr
->u
.sval
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1354 true, info_ptr_end
);
1355 info_ptr
+= bytes_read
;
1357 case DW_FORM_ref_udata
:
1360 attr
->u
.val
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1361 false, info_ptr_end
);
1362 info_ptr
+= bytes_read
;
1364 case DW_FORM_indirect
:
1365 form
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1366 false, info_ptr_end
);
1367 info_ptr
+= bytes_read
;
1368 if (form
== DW_FORM_implicit_const
)
1370 implicit_const
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1371 true, info_ptr_end
);
1372 info_ptr
+= bytes_read
;
1374 info_ptr
= read_attribute_value (attr
, form
, implicit_const
, unit
,
1375 info_ptr
, info_ptr_end
);
1377 case DW_FORM_implicit_const
:
1378 attr
->form
= DW_FORM_sdata
;
1379 attr
->u
.sval
= implicit_const
;
1381 case DW_FORM_data16
:
1382 /* This is really a "constant", but there is no way to store that
1383 so pretend it is a 16 byte block instead. */
1384 amt
= sizeof (struct dwarf_block
);
1385 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1389 info_ptr
= read_n_bytes (info_ptr
, info_ptr_end
, blk
);
1394 _bfd_error_handler (_("DWARF error: invalid or unhandled FORM value: %#x"),
1396 bfd_set_error (bfd_error_bad_value
);
1402 /* Read an attribute described by an abbreviated attribute. */
1405 read_attribute (struct attribute
* attr
,
1406 struct attr_abbrev
* abbrev
,
1407 struct comp_unit
* unit
,
1408 bfd_byte
* info_ptr
,
1409 bfd_byte
* info_ptr_end
)
1411 attr
->name
= abbrev
->name
;
1412 info_ptr
= read_attribute_value (attr
, abbrev
->form
, abbrev
->implicit_const
,
1413 unit
, info_ptr
, info_ptr_end
);
1417 /* Return whether DW_AT_name will return the same as DW_AT_linkage_name
1421 non_mangled (int lang
)
1431 case DW_LANG_Cobol74
:
1432 case DW_LANG_Cobol85
:
1433 case DW_LANG_Fortran77
:
1434 case DW_LANG_Pascal83
:
1444 /* Source line information table routines. */
1446 #define FILE_ALLOC_CHUNK 5
1447 #define DIR_ALLOC_CHUNK 5
1451 struct line_info
* prev_line
;
1455 unsigned int column
;
1456 unsigned int discriminator
;
1457 unsigned char op_index
;
1458 unsigned char end_sequence
; /* End of (sequential) code sequence. */
1469 struct line_sequence
1472 struct line_sequence
* prev_sequence
;
1473 struct line_info
* last_line
; /* Largest VMA. */
1474 struct line_info
** line_info_lookup
;
1475 bfd_size_type num_lines
;
1478 struct line_info_table
1481 unsigned int num_files
;
1482 unsigned int num_dirs
;
1483 unsigned int num_sequences
;
1486 struct fileinfo
* files
;
1487 struct line_sequence
* sequences
;
1488 struct line_info
* lcl_head
; /* Local head; used in 'add_line_info'. */
1491 /* Remember some information about each function. If the function is
1492 inlined (DW_TAG_inlined_subroutine) it may have two additional
1493 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
1494 source code location where this function was inlined. */
1498 /* Pointer to previous function in list of all functions. */
1499 struct funcinfo
* prev_func
;
1500 /* Pointer to function one scope higher. */
1501 struct funcinfo
* caller_func
;
1502 /* Source location file name where caller_func inlines this func. */
1504 /* Source location file name. */
1506 /* Source location line number where caller_func inlines this func. */
1508 /* Source location line number. */
1513 struct arange arange
;
1514 /* Where the symbol is defined. */
1516 /* The offset of the funcinfo from the start of the unit. */
1517 bfd_uint64_t unit_offset
;
1520 struct lookup_funcinfo
1522 /* Function information corresponding to this lookup table entry. */
1523 struct funcinfo
* funcinfo
;
1525 /* The lowest address for this specific function. */
1528 /* The highest address of this function before the lookup table is sorted.
1529 The highest address of all prior functions after the lookup table is
1530 sorted, which is used for binary search. */
1532 /* Index of this function, used to ensure qsort is stable. */
1538 /* Pointer to previous variable in list of all variables. */
1539 struct varinfo
*prev_var
;
1540 /* The offset of the varinfo from the start of the unit. */
1541 bfd_uint64_t unit_offset
;
1542 /* Source location file name. */
1544 /* Source location line number. */
1546 /* The type of this variable. */
1548 /* The name of the variable, if it has one. */
1550 /* The address of the variable. */
1552 /* Where the symbol is defined. */
1554 /* Is this a stack variable? */
1558 /* Return TRUE if NEW_LINE should sort after LINE. */
1561 new_line_sorts_after (struct line_info
*new_line
, struct line_info
*line
)
1563 return (new_line
->address
> line
->address
1564 || (new_line
->address
== line
->address
1565 && new_line
->op_index
> line
->op_index
));
1569 /* Adds a new entry to the line_info list in the line_info_table, ensuring
1570 that the list is sorted. Note that the line_info list is sorted from
1571 highest to lowest VMA (with possible duplicates); that is,
1572 line_info->prev_line always accesses an equal or smaller VMA. */
1575 add_line_info (struct line_info_table
*table
,
1577 unsigned char op_index
,
1580 unsigned int column
,
1581 unsigned int discriminator
,
1584 size_t amt
= sizeof (struct line_info
);
1585 struct line_sequence
* seq
= table
->sequences
;
1586 struct line_info
* info
= (struct line_info
*) bfd_alloc (table
->abfd
, amt
);
1591 /* Set member data of 'info'. */
1592 info
->prev_line
= NULL
;
1593 info
->address
= address
;
1594 info
->op_index
= op_index
;
1596 info
->column
= column
;
1597 info
->discriminator
= discriminator
;
1598 info
->end_sequence
= end_sequence
;
1600 if (filename
&& filename
[0])
1602 info
->filename
= (char *) bfd_alloc (table
->abfd
, strlen (filename
) + 1);
1603 if (info
->filename
== NULL
)
1605 strcpy (info
->filename
, filename
);
1608 info
->filename
= NULL
;
1610 /* Find the correct location for 'info'. Normally we will receive
1611 new line_info data 1) in order and 2) with increasing VMAs.
1612 However some compilers break the rules (cf. decode_line_info) and
1613 so we include some heuristics for quickly finding the correct
1614 location for 'info'. In particular, these heuristics optimize for
1615 the common case in which the VMA sequence that we receive is a
1616 list of locally sorted VMAs such as
1617 p...z a...j (where a < j < p < z)
1619 Note: table->lcl_head is used to head an *actual* or *possible*
1620 sub-sequence within the list (such as a...j) that is not directly
1621 headed by table->last_line
1623 Note: we may receive duplicate entries from 'decode_line_info'. */
1626 && seq
->last_line
->address
== address
1627 && seq
->last_line
->op_index
== op_index
1628 && seq
->last_line
->end_sequence
== end_sequence
)
1630 /* We only keep the last entry with the same address and end
1631 sequence. See PR ld/4986. */
1632 if (table
->lcl_head
== seq
->last_line
)
1633 table
->lcl_head
= info
;
1634 info
->prev_line
= seq
->last_line
->prev_line
;
1635 seq
->last_line
= info
;
1637 else if (!seq
|| seq
->last_line
->end_sequence
)
1639 /* Start a new line sequence. */
1640 amt
= sizeof (struct line_sequence
);
1641 seq
= (struct line_sequence
*) bfd_malloc (amt
);
1644 seq
->low_pc
= address
;
1645 seq
->prev_sequence
= table
->sequences
;
1646 seq
->last_line
= info
;
1647 table
->lcl_head
= info
;
1648 table
->sequences
= seq
;
1649 table
->num_sequences
++;
1651 else if (info
->end_sequence
1652 || new_line_sorts_after (info
, seq
->last_line
))
1654 /* Normal case: add 'info' to the beginning of the current sequence. */
1655 info
->prev_line
= seq
->last_line
;
1656 seq
->last_line
= info
;
1658 /* lcl_head: initialize to head a *possible* sequence at the end. */
1659 if (!table
->lcl_head
)
1660 table
->lcl_head
= info
;
1662 else if (!new_line_sorts_after (info
, table
->lcl_head
)
1663 && (!table
->lcl_head
->prev_line
1664 || new_line_sorts_after (info
, table
->lcl_head
->prev_line
)))
1666 /* Abnormal but easy: lcl_head is the head of 'info'. */
1667 info
->prev_line
= table
->lcl_head
->prev_line
;
1668 table
->lcl_head
->prev_line
= info
;
1672 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head'
1673 are valid heads for 'info'. Reset 'lcl_head'. */
1674 struct line_info
* li2
= seq
->last_line
; /* Always non-NULL. */
1675 struct line_info
* li1
= li2
->prev_line
;
1679 if (!new_line_sorts_after (info
, li2
)
1680 && new_line_sorts_after (info
, li1
))
1683 li2
= li1
; /* always non-NULL */
1684 li1
= li1
->prev_line
;
1686 table
->lcl_head
= li2
;
1687 info
->prev_line
= table
->lcl_head
->prev_line
;
1688 table
->lcl_head
->prev_line
= info
;
1689 if (address
< seq
->low_pc
)
1690 seq
->low_pc
= address
;
1695 /* Extract a fully qualified filename from a line info table.
1696 The returned string has been malloc'ed and it is the caller's
1697 responsibility to free it. */
1700 concat_filename (struct line_info_table
*table
, unsigned int file
)
1704 if (table
== NULL
|| file
- 1 >= table
->num_files
)
1706 /* FILE == 0 means unknown. */
1709 (_("DWARF error: mangled line number section (bad file number)"));
1710 return strdup ("<unknown>");
1713 filename
= table
->files
[file
- 1].name
;
1714 if (filename
== NULL
)
1715 return strdup ("<unknown>");
1717 if (!IS_ABSOLUTE_PATH (filename
))
1719 char *dir_name
= NULL
;
1720 char *subdir_name
= NULL
;
1724 if (table
->files
[file
- 1].dir
1725 /* PR 17512: file: 0317e960. */
1726 && table
->files
[file
- 1].dir
<= table
->num_dirs
1727 /* PR 17512: file: 7f3d2e4b. */
1728 && table
->dirs
!= NULL
)
1729 subdir_name
= table
->dirs
[table
->files
[file
- 1].dir
- 1];
1731 if (!subdir_name
|| !IS_ABSOLUTE_PATH (subdir_name
))
1732 dir_name
= table
->comp_dir
;
1736 dir_name
= subdir_name
;
1741 return strdup (filename
);
1743 len
= strlen (dir_name
) + strlen (filename
) + 2;
1747 len
+= strlen (subdir_name
) + 1;
1748 name
= (char *) bfd_malloc (len
);
1750 sprintf (name
, "%s/%s/%s", dir_name
, subdir_name
, filename
);
1754 name
= (char *) bfd_malloc (len
);
1756 sprintf (name
, "%s/%s", dir_name
, filename
);
1762 return strdup (filename
);
1766 arange_add (const struct comp_unit
*unit
, struct arange
*first_arange
,
1767 bfd_vma low_pc
, bfd_vma high_pc
)
1769 struct arange
*arange
;
1771 /* Ignore empty ranges. */
1772 if (low_pc
== high_pc
)
1775 /* If the first arange is empty, use it. */
1776 if (first_arange
->high
== 0)
1778 first_arange
->low
= low_pc
;
1779 first_arange
->high
= high_pc
;
1783 /* Next see if we can cheaply extend an existing range. */
1784 arange
= first_arange
;
1787 if (low_pc
== arange
->high
)
1789 arange
->high
= high_pc
;
1792 if (high_pc
== arange
->low
)
1794 arange
->low
= low_pc
;
1797 arange
= arange
->next
;
1801 /* Need to allocate a new arange and insert it into the arange list.
1802 Order isn't significant, so just insert after the first arange. */
1803 arange
= (struct arange
*) bfd_alloc (unit
->abfd
, sizeof (*arange
));
1806 arange
->low
= low_pc
;
1807 arange
->high
= high_pc
;
1808 arange
->next
= first_arange
->next
;
1809 first_arange
->next
= arange
;
1813 /* Compare function for line sequences. */
1816 compare_sequences (const void* a
, const void* b
)
1818 const struct line_sequence
* seq1
= a
;
1819 const struct line_sequence
* seq2
= b
;
1821 /* Sort by low_pc as the primary key. */
1822 if (seq1
->low_pc
< seq2
->low_pc
)
1824 if (seq1
->low_pc
> seq2
->low_pc
)
1827 /* If low_pc values are equal, sort in reverse order of
1828 high_pc, so that the largest region comes first. */
1829 if (seq1
->last_line
->address
< seq2
->last_line
->address
)
1831 if (seq1
->last_line
->address
> seq2
->last_line
->address
)
1834 if (seq1
->last_line
->op_index
< seq2
->last_line
->op_index
)
1836 if (seq1
->last_line
->op_index
> seq2
->last_line
->op_index
)
1839 /* num_lines is initially an index, to make the sort stable. */
1840 if (seq1
->num_lines
< seq2
->num_lines
)
1842 if (seq1
->num_lines
> seq2
->num_lines
)
1847 /* Construct the line information table for quick lookup. */
1850 build_line_info_table (struct line_info_table
* table
,
1851 struct line_sequence
* seq
)
1854 struct line_info
**line_info_lookup
;
1855 struct line_info
*each_line
;
1856 unsigned int num_lines
;
1857 unsigned int line_index
;
1859 if (seq
->line_info_lookup
!= NULL
)
1862 /* Count the number of line information entries. We could do this while
1863 scanning the debug information, but some entries may be added via
1864 lcl_head without having a sequence handy to increment the number of
1867 for (each_line
= seq
->last_line
; each_line
; each_line
= each_line
->prev_line
)
1870 seq
->num_lines
= num_lines
;
1874 /* Allocate space for the line information lookup table. */
1875 amt
= sizeof (struct line_info
*) * num_lines
;
1876 line_info_lookup
= (struct line_info
**) bfd_alloc (table
->abfd
, amt
);
1877 seq
->line_info_lookup
= line_info_lookup
;
1878 if (line_info_lookup
== NULL
)
1881 /* Create the line information lookup table. */
1882 line_index
= num_lines
;
1883 for (each_line
= seq
->last_line
; each_line
; each_line
= each_line
->prev_line
)
1884 line_info_lookup
[--line_index
] = each_line
;
1886 BFD_ASSERT (line_index
== 0);
1890 /* Sort the line sequences for quick lookup. */
1893 sort_line_sequences (struct line_info_table
* table
)
1896 struct line_sequence
*sequences
;
1897 struct line_sequence
*seq
;
1899 unsigned int num_sequences
= table
->num_sequences
;
1900 bfd_vma last_high_pc
;
1902 if (num_sequences
== 0)
1905 /* Allocate space for an array of sequences. */
1906 amt
= sizeof (struct line_sequence
) * num_sequences
;
1907 sequences
= (struct line_sequence
*) bfd_alloc (table
->abfd
, amt
);
1908 if (sequences
== NULL
)
1911 /* Copy the linked list into the array, freeing the original nodes. */
1912 seq
= table
->sequences
;
1913 for (n
= 0; n
< num_sequences
; n
++)
1915 struct line_sequence
* last_seq
= seq
;
1918 sequences
[n
].low_pc
= seq
->low_pc
;
1919 sequences
[n
].prev_sequence
= NULL
;
1920 sequences
[n
].last_line
= seq
->last_line
;
1921 sequences
[n
].line_info_lookup
= NULL
;
1922 sequences
[n
].num_lines
= n
;
1923 seq
= seq
->prev_sequence
;
1926 BFD_ASSERT (seq
== NULL
);
1928 qsort (sequences
, n
, sizeof (struct line_sequence
), compare_sequences
);
1930 /* Make the list binary-searchable by trimming overlapping entries
1931 and removing nested entries. */
1933 last_high_pc
= sequences
[0].last_line
->address
;
1934 for (n
= 1; n
< table
->num_sequences
; n
++)
1936 if (sequences
[n
].low_pc
< last_high_pc
)
1938 if (sequences
[n
].last_line
->address
<= last_high_pc
)
1939 /* Skip nested entries. */
1942 /* Trim overlapping entries. */
1943 sequences
[n
].low_pc
= last_high_pc
;
1945 last_high_pc
= sequences
[n
].last_line
->address
;
1946 if (n
> num_sequences
)
1948 /* Close up the gap. */
1949 sequences
[num_sequences
].low_pc
= sequences
[n
].low_pc
;
1950 sequences
[num_sequences
].last_line
= sequences
[n
].last_line
;
1955 table
->sequences
= sequences
;
1956 table
->num_sequences
= num_sequences
;
1960 /* Add directory to TABLE. CUR_DIR memory ownership is taken by TABLE. */
1963 line_info_add_include_dir (struct line_info_table
*table
, char *cur_dir
)
1965 if ((table
->num_dirs
% DIR_ALLOC_CHUNK
) == 0)
1970 amt
= table
->num_dirs
+ DIR_ALLOC_CHUNK
;
1971 amt
*= sizeof (char *);
1973 tmp
= (char **) bfd_realloc (table
->dirs
, amt
);
1979 table
->dirs
[table
->num_dirs
++] = cur_dir
;
1984 line_info_add_include_dir_stub (struct line_info_table
*table
, char *cur_dir
,
1985 unsigned int dir ATTRIBUTE_UNUSED
,
1986 unsigned int xtime ATTRIBUTE_UNUSED
,
1987 unsigned int size ATTRIBUTE_UNUSED
)
1989 return line_info_add_include_dir (table
, cur_dir
);
1992 /* Add file to TABLE. CUR_FILE memory ownership is taken by TABLE. */
1995 line_info_add_file_name (struct line_info_table
*table
, char *cur_file
,
1996 unsigned int dir
, unsigned int xtime
,
1999 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
2001 struct fileinfo
*tmp
;
2004 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
2005 amt
*= sizeof (struct fileinfo
);
2007 tmp
= (struct fileinfo
*) bfd_realloc (table
->files
, amt
);
2013 table
->files
[table
->num_files
].name
= cur_file
;
2014 table
->files
[table
->num_files
].dir
= dir
;
2015 table
->files
[table
->num_files
].time
= xtime
;
2016 table
->files
[table
->num_files
].size
= size
;
2021 /* Read directory or file name entry format, starting with byte of
2022 format count entries, ULEB128 pairs of entry formats, ULEB128 of
2023 entries count and the entries themselves in the described entry
2027 read_formatted_entries (struct comp_unit
*unit
, bfd_byte
**bufp
,
2028 bfd_byte
*buf_end
, struct line_info_table
*table
,
2029 bool (*callback
) (struct line_info_table
*table
,
2035 bfd
*abfd
= unit
->abfd
;
2036 bfd_byte format_count
, formati
;
2037 bfd_vma data_count
, datai
;
2038 bfd_byte
*buf
= *bufp
;
2039 bfd_byte
*format_header_data
;
2040 unsigned int bytes_read
;
2042 format_count
= read_1_byte (abfd
, buf
, buf_end
);
2044 format_header_data
= buf
;
2045 for (formati
= 0; formati
< format_count
; formati
++)
2047 _bfd_safe_read_leb128 (abfd
, buf
, &bytes_read
, false, buf_end
);
2049 _bfd_safe_read_leb128 (abfd
, buf
, &bytes_read
, false, buf_end
);
2053 data_count
= _bfd_safe_read_leb128 (abfd
, buf
, &bytes_read
, false, buf_end
);
2055 if (format_count
== 0 && data_count
!= 0)
2057 _bfd_error_handler (_("DWARF error: zero format count"));
2058 bfd_set_error (bfd_error_bad_value
);
2062 /* PR 22210. Paranoia check. Don't bother running the loop
2063 if we know that we are going to run out of buffer. */
2064 if (data_count
> (bfd_vma
) (buf_end
- buf
))
2067 (_("DWARF error: data count (%" PRIx64
") larger than buffer size"),
2068 (uint64_t) data_count
);
2069 bfd_set_error (bfd_error_bad_value
);
2073 for (datai
= 0; datai
< data_count
; datai
++)
2075 bfd_byte
*format
= format_header_data
;
2078 memset (&fe
, 0, sizeof fe
);
2079 for (formati
= 0; formati
< format_count
; formati
++)
2081 bfd_vma content_type
, form
;
2083 char **stringp
= &string_trash
;
2084 unsigned int uint_trash
, *uintp
= &uint_trash
;
2085 struct attribute attr
;
2087 content_type
= _bfd_safe_read_leb128 (abfd
, format
, &bytes_read
,
2089 format
+= bytes_read
;
2090 switch (content_type
)
2095 case DW_LNCT_directory_index
:
2098 case DW_LNCT_timestamp
:
2108 (_("DWARF error: unknown format content type %" PRIu64
),
2109 (uint64_t) content_type
);
2110 bfd_set_error (bfd_error_bad_value
);
2114 form
= _bfd_safe_read_leb128 (abfd
, format
, &bytes_read
, false,
2116 format
+= bytes_read
;
2118 buf
= read_attribute_value (&attr
, form
, 0, unit
, buf
, buf_end
);
2123 case DW_FORM_string
:
2124 case DW_FORM_line_strp
:
2125 *stringp
= attr
.u
.str
;
2133 *uintp
= attr
.u
.val
;
2136 case DW_FORM_data16
:
2137 /* MD5 data is in the attr.blk, but we are ignoring those. */
2142 /* Skip the first "zero entry", which is the compilation dir/file. */
2144 if (!callback (table
, fe
.name
, fe
.dir
, fe
.time
, fe
.size
))
2152 /* Decode the line number information for UNIT. */
2154 static struct line_info_table
*
2155 decode_line_info (struct comp_unit
*unit
)
2157 bfd
*abfd
= unit
->abfd
;
2158 struct dwarf2_debug
*stash
= unit
->stash
;
2159 struct dwarf2_debug_file
*file
= unit
->file
;
2160 struct line_info_table
* table
;
2163 struct line_head lh
;
2164 unsigned int i
, bytes_read
, offset_size
;
2165 char *cur_file
, *cur_dir
;
2166 unsigned char op_code
, extended_op
, adj_opcode
;
2167 unsigned int exop_len
;
2170 if (unit
->line_offset
== 0 && file
->line_table
)
2171 return file
->line_table
;
2173 if (! read_section (abfd
, &stash
->debug_sections
[debug_line
],
2174 file
->syms
, unit
->line_offset
,
2175 &file
->dwarf_line_buffer
, &file
->dwarf_line_size
))
2178 if (file
->dwarf_line_size
< 16)
2181 (_("DWARF error: line info section is too small (%" PRId64
")"),
2182 (int64_t) file
->dwarf_line_size
);
2183 bfd_set_error (bfd_error_bad_value
);
2186 line_ptr
= file
->dwarf_line_buffer
+ unit
->line_offset
;
2187 line_end
= file
->dwarf_line_buffer
+ file
->dwarf_line_size
;
2189 /* Read in the prologue. */
2190 lh
.total_length
= read_4_bytes (abfd
, line_ptr
, line_end
);
2193 if (lh
.total_length
== 0xffffffff)
2195 lh
.total_length
= read_8_bytes (abfd
, line_ptr
, line_end
);
2199 else if (lh
.total_length
== 0 && unit
->addr_size
== 8)
2201 /* Handle (non-standard) 64-bit DWARF2 formats. */
2202 lh
.total_length
= read_4_bytes (abfd
, line_ptr
, line_end
);
2207 if (lh
.total_length
> (size_t) (line_end
- line_ptr
))
2210 /* xgettext: c-format */
2211 (_("DWARF error: line info data is bigger (%#" PRIx64
")"
2212 " than the space remaining in the section (%#lx)"),
2213 (uint64_t) lh
.total_length
, (unsigned long) (line_end
- line_ptr
));
2214 bfd_set_error (bfd_error_bad_value
);
2218 line_end
= line_ptr
+ lh
.total_length
;
2220 lh
.version
= read_2_bytes (abfd
, line_ptr
, line_end
);
2221 if (lh
.version
< 2 || lh
.version
> 5)
2224 (_("DWARF error: unhandled .debug_line version %d"), lh
.version
);
2225 bfd_set_error (bfd_error_bad_value
);
2230 if (line_ptr
+ offset_size
+ (lh
.version
>= 5 ? 8 : (lh
.version
>= 4 ? 6 : 5))
2234 (_("DWARF error: ran out of room reading prologue"));
2235 bfd_set_error (bfd_error_bad_value
);
2239 if (lh
.version
>= 5)
2241 unsigned int segment_selector_size
;
2243 /* Skip address size. */
2244 read_1_byte (abfd
, line_ptr
, line_end
);
2247 segment_selector_size
= read_1_byte (abfd
, line_ptr
, line_end
);
2249 if (segment_selector_size
!= 0)
2252 (_("DWARF error: line info unsupported segment selector size %u"),
2253 segment_selector_size
);
2254 bfd_set_error (bfd_error_bad_value
);
2259 if (offset_size
== 4)
2260 lh
.prologue_length
= read_4_bytes (abfd
, line_ptr
, line_end
);
2262 lh
.prologue_length
= read_8_bytes (abfd
, line_ptr
, line_end
);
2263 line_ptr
+= offset_size
;
2265 lh
.minimum_instruction_length
= read_1_byte (abfd
, line_ptr
, line_end
);
2268 if (lh
.version
>= 4)
2270 lh
.maximum_ops_per_insn
= read_1_byte (abfd
, line_ptr
, line_end
);
2274 lh
.maximum_ops_per_insn
= 1;
2276 if (lh
.maximum_ops_per_insn
== 0)
2279 (_("DWARF error: invalid maximum operations per instruction"));
2280 bfd_set_error (bfd_error_bad_value
);
2284 lh
.default_is_stmt
= read_1_byte (abfd
, line_ptr
, line_end
);
2287 lh
.line_base
= read_1_signed_byte (abfd
, line_ptr
, line_end
);
2290 lh
.line_range
= read_1_byte (abfd
, line_ptr
, line_end
);
2293 lh
.opcode_base
= read_1_byte (abfd
, line_ptr
, line_end
);
2296 if (line_ptr
+ (lh
.opcode_base
- 1) >= line_end
)
2298 _bfd_error_handler (_("DWARF error: ran out of room reading opcodes"));
2299 bfd_set_error (bfd_error_bad_value
);
2303 amt
= lh
.opcode_base
* sizeof (unsigned char);
2304 lh
.standard_opcode_lengths
= (unsigned char *) bfd_alloc (abfd
, amt
);
2306 lh
.standard_opcode_lengths
[0] = 1;
2308 for (i
= 1; i
< lh
.opcode_base
; ++i
)
2310 lh
.standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
, line_end
);
2314 amt
= sizeof (struct line_info_table
);
2315 table
= (struct line_info_table
*) bfd_alloc (abfd
, amt
);
2319 table
->comp_dir
= unit
->comp_dir
;
2321 table
->num_files
= 0;
2322 table
->files
= NULL
;
2324 table
->num_dirs
= 0;
2327 table
->num_sequences
= 0;
2328 table
->sequences
= NULL
;
2330 table
->lcl_head
= NULL
;
2332 if (lh
.version
>= 5)
2334 /* Read directory table. */
2335 if (!read_formatted_entries (unit
, &line_ptr
, line_end
, table
,
2336 line_info_add_include_dir_stub
))
2339 /* Read file name table. */
2340 if (!read_formatted_entries (unit
, &line_ptr
, line_end
, table
,
2341 line_info_add_file_name
))
2346 /* Read directory table. */
2347 while ((cur_dir
= read_string (abfd
, line_ptr
, line_end
, &bytes_read
)) != NULL
)
2349 line_ptr
+= bytes_read
;
2351 if (!line_info_add_include_dir (table
, cur_dir
))
2355 line_ptr
+= bytes_read
;
2357 /* Read file name table. */
2358 while ((cur_file
= read_string (abfd
, line_ptr
, line_end
, &bytes_read
)) != NULL
)
2360 unsigned int dir
, xtime
, size
;
2362 line_ptr
+= bytes_read
;
2364 dir
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
, false, line_end
);
2365 line_ptr
+= bytes_read
;
2366 xtime
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
, false, line_end
);
2367 line_ptr
+= bytes_read
;
2368 size
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
, false, line_end
);
2369 line_ptr
+= bytes_read
;
2371 if (!line_info_add_file_name (table
, cur_file
, dir
, xtime
, size
))
2375 line_ptr
+= bytes_read
;
2378 /* Read the statement sequences until there's nothing left. */
2379 while (line_ptr
< line_end
)
2381 /* State machine registers. */
2382 bfd_vma address
= 0;
2383 unsigned char op_index
= 0;
2384 char * filename
= table
->num_files
? concat_filename (table
, 1) : NULL
;
2385 unsigned int line
= 1;
2386 unsigned int column
= 0;
2387 unsigned int discriminator
= 0;
2388 int is_stmt
= lh
.default_is_stmt
;
2389 int end_sequence
= 0;
2390 unsigned int dir
, xtime
, size
;
2391 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
2392 compilers generate address sequences that are wildly out of
2393 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
2394 for ia64-Linux). Thus, to determine the low and high
2395 address, we must compare on every DW_LNS_copy, etc. */
2396 bfd_vma low_pc
= (bfd_vma
) -1;
2397 bfd_vma high_pc
= 0;
2399 /* Decode the table. */
2400 while (!end_sequence
&& line_ptr
< line_end
)
2402 op_code
= read_1_byte (abfd
, line_ptr
, line_end
);
2405 if (op_code
>= lh
.opcode_base
)
2407 /* Special operand. */
2408 adj_opcode
= op_code
- lh
.opcode_base
;
2409 if (lh
.line_range
== 0)
2411 if (lh
.maximum_ops_per_insn
== 1)
2412 address
+= (adj_opcode
/ lh
.line_range
2413 * lh
.minimum_instruction_length
);
2416 address
+= ((op_index
+ adj_opcode
/ lh
.line_range
)
2417 / lh
.maximum_ops_per_insn
2418 * lh
.minimum_instruction_length
);
2419 op_index
= ((op_index
+ adj_opcode
/ lh
.line_range
)
2420 % lh
.maximum_ops_per_insn
);
2422 line
+= lh
.line_base
+ (adj_opcode
% lh
.line_range
);
2423 /* Append row to matrix using current values. */
2424 if (!add_line_info (table
, address
, op_index
, filename
,
2425 line
, column
, discriminator
, 0))
2428 if (address
< low_pc
)
2430 if (address
> high_pc
)
2433 else switch (op_code
)
2435 case DW_LNS_extended_op
:
2436 exop_len
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2438 line_ptr
+= bytes_read
;
2439 extended_op
= read_1_byte (abfd
, line_ptr
, line_end
);
2442 switch (extended_op
)
2444 case DW_LNE_end_sequence
:
2446 if (!add_line_info (table
, address
, op_index
, filename
, line
,
2447 column
, discriminator
, end_sequence
))
2450 if (address
< low_pc
)
2452 if (address
> high_pc
)
2454 if (!arange_add (unit
, &unit
->arange
, low_pc
, high_pc
))
2457 case DW_LNE_set_address
:
2458 address
= read_address (unit
, line_ptr
, line_end
);
2460 line_ptr
+= unit
->addr_size
;
2462 case DW_LNE_define_file
:
2463 cur_file
= read_string (abfd
, line_ptr
, line_end
, &bytes_read
);
2464 line_ptr
+= bytes_read
;
2465 dir
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2467 line_ptr
+= bytes_read
;
2468 xtime
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2470 line_ptr
+= bytes_read
;
2471 size
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2473 line_ptr
+= bytes_read
;
2474 if (!line_info_add_file_name (table
, cur_file
, dir
,
2478 case DW_LNE_set_discriminator
:
2480 _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2482 line_ptr
+= bytes_read
;
2484 case DW_LNE_HP_source_file_correlation
:
2485 line_ptr
+= exop_len
- 1;
2489 (_("DWARF error: mangled line number section"));
2490 bfd_set_error (bfd_error_bad_value
);
2497 if (!add_line_info (table
, address
, op_index
,
2498 filename
, line
, column
, discriminator
, 0))
2501 if (address
< low_pc
)
2503 if (address
> high_pc
)
2506 case DW_LNS_advance_pc
:
2507 if (lh
.maximum_ops_per_insn
== 1)
2508 address
+= (lh
.minimum_instruction_length
2509 * _bfd_safe_read_leb128 (abfd
, line_ptr
,
2514 bfd_vma adjust
= _bfd_safe_read_leb128 (abfd
, line_ptr
,
2517 address
= ((op_index
+ adjust
) / lh
.maximum_ops_per_insn
2518 * lh
.minimum_instruction_length
);
2519 op_index
= (op_index
+ adjust
) % lh
.maximum_ops_per_insn
;
2521 line_ptr
+= bytes_read
;
2523 case DW_LNS_advance_line
:
2524 line
+= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2526 line_ptr
+= bytes_read
;
2528 case DW_LNS_set_file
:
2530 unsigned int filenum
;
2532 /* The file and directory tables are 0
2533 based, the references are 1 based. */
2534 filenum
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2536 line_ptr
+= bytes_read
;
2538 filename
= concat_filename (table
, filenum
);
2541 case DW_LNS_set_column
:
2542 column
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2544 line_ptr
+= bytes_read
;
2546 case DW_LNS_negate_stmt
:
2547 is_stmt
= (!is_stmt
);
2549 case DW_LNS_set_basic_block
:
2551 case DW_LNS_const_add_pc
:
2552 if (lh
.line_range
== 0)
2554 if (lh
.maximum_ops_per_insn
== 1)
2555 address
+= (lh
.minimum_instruction_length
2556 * ((255 - lh
.opcode_base
) / lh
.line_range
));
2559 bfd_vma adjust
= ((255 - lh
.opcode_base
) / lh
.line_range
);
2560 address
+= (lh
.minimum_instruction_length
2561 * ((op_index
+ adjust
)
2562 / lh
.maximum_ops_per_insn
));
2563 op_index
= (op_index
+ adjust
) % lh
.maximum_ops_per_insn
;
2566 case DW_LNS_fixed_advance_pc
:
2567 address
+= read_2_bytes (abfd
, line_ptr
, line_end
);
2572 /* Unknown standard opcode, ignore it. */
2573 for (i
= 0; i
< lh
.standard_opcode_lengths
[op_code
]; i
++)
2575 (void) _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2577 line_ptr
+= bytes_read
;
2586 if (unit
->line_offset
== 0)
2587 file
->line_table
= table
;
2588 if (sort_line_sequences (table
))
2592 while (table
->sequences
!= NULL
)
2594 struct line_sequence
* seq
= table
->sequences
;
2595 table
->sequences
= table
->sequences
->prev_sequence
;
2598 free (table
->files
);
2603 /* If ADDR is within TABLE set the output parameters and return the
2604 range of addresses covered by the entry used to fill them out.
2605 Otherwise set * FILENAME_PTR to NULL and return 0.
2606 The parameters FILENAME_PTR, LINENUMBER_PTR and DISCRIMINATOR_PTR
2607 are pointers to the objects to be filled in. */
2610 lookup_address_in_line_info_table (struct line_info_table
*table
,
2612 const char **filename_ptr
,
2613 unsigned int *linenumber_ptr
,
2614 unsigned int *discriminator_ptr
)
2616 struct line_sequence
*seq
= NULL
;
2617 struct line_info
*info
;
2620 /* Binary search the array of sequences. */
2622 high
= table
->num_sequences
;
2625 mid
= (low
+ high
) / 2;
2626 seq
= &table
->sequences
[mid
];
2627 if (addr
< seq
->low_pc
)
2629 else if (addr
>= seq
->last_line
->address
)
2635 /* Check for a valid sequence. */
2636 if (!seq
|| addr
< seq
->low_pc
|| addr
>= seq
->last_line
->address
)
2639 if (!build_line_info_table (table
, seq
))
2642 /* Binary search the array of line information. */
2644 high
= seq
->num_lines
;
2648 mid
= (low
+ high
) / 2;
2649 info
= seq
->line_info_lookup
[mid
];
2650 if (addr
< info
->address
)
2652 else if (addr
>= seq
->line_info_lookup
[mid
+ 1]->address
)
2658 /* Check for a valid line information entry. */
2660 && addr
>= info
->address
2661 && addr
< seq
->line_info_lookup
[mid
+ 1]->address
2662 && !(info
->end_sequence
|| info
== seq
->last_line
))
2664 *filename_ptr
= info
->filename
;
2665 *linenumber_ptr
= info
->line
;
2666 if (discriminator_ptr
)
2667 *discriminator_ptr
= info
->discriminator
;
2668 return seq
->last_line
->address
- seq
->low_pc
;
2672 *filename_ptr
= NULL
;
2676 /* Read in the .debug_ranges section for future reference. */
2679 read_debug_ranges (struct comp_unit
* unit
)
2681 struct dwarf2_debug
*stash
= unit
->stash
;
2682 struct dwarf2_debug_file
*file
= unit
->file
;
2684 return read_section (unit
->abfd
, &stash
->debug_sections
[debug_ranges
],
2686 &file
->dwarf_ranges_buffer
, &file
->dwarf_ranges_size
);
2689 /* Read in the .debug_rnglists section for future reference. */
2692 read_debug_rnglists (struct comp_unit
* unit
)
2694 struct dwarf2_debug
*stash
= unit
->stash
;
2695 struct dwarf2_debug_file
*file
= unit
->file
;
2697 return read_section (unit
->abfd
, &stash
->debug_sections
[debug_rnglists
],
2699 &file
->dwarf_rnglists_buffer
, &file
->dwarf_rnglists_size
);
2702 /* Function table functions. */
2705 compare_lookup_funcinfos (const void * a
, const void * b
)
2707 const struct lookup_funcinfo
* lookup1
= a
;
2708 const struct lookup_funcinfo
* lookup2
= b
;
2710 if (lookup1
->low_addr
< lookup2
->low_addr
)
2712 if (lookup1
->low_addr
> lookup2
->low_addr
)
2714 if (lookup1
->high_addr
< lookup2
->high_addr
)
2716 if (lookup1
->high_addr
> lookup2
->high_addr
)
2719 if (lookup1
->idx
< lookup2
->idx
)
2721 if (lookup1
->idx
> lookup2
->idx
)
2727 build_lookup_funcinfo_table (struct comp_unit
* unit
)
2729 struct lookup_funcinfo
*lookup_funcinfo_table
= unit
->lookup_funcinfo_table
;
2730 unsigned int number_of_functions
= unit
->number_of_functions
;
2731 struct funcinfo
*each
;
2732 struct lookup_funcinfo
*entry
;
2734 struct arange
*range
;
2735 bfd_vma low_addr
, high_addr
;
2737 if (lookup_funcinfo_table
|| number_of_functions
== 0)
2740 /* Create the function info lookup table. */
2741 lookup_funcinfo_table
= (struct lookup_funcinfo
*)
2742 bfd_malloc (number_of_functions
* sizeof (struct lookup_funcinfo
));
2743 if (lookup_funcinfo_table
== NULL
)
2746 /* Populate the function info lookup table. */
2747 func_index
= number_of_functions
;
2748 for (each
= unit
->function_table
; each
; each
= each
->prev_func
)
2750 entry
= &lookup_funcinfo_table
[--func_index
];
2751 entry
->funcinfo
= each
;
2752 entry
->idx
= func_index
;
2754 /* Calculate the lowest and highest address for this function entry. */
2755 low_addr
= entry
->funcinfo
->arange
.low
;
2756 high_addr
= entry
->funcinfo
->arange
.high
;
2758 for (range
= entry
->funcinfo
->arange
.next
; range
; range
= range
->next
)
2760 if (range
->low
< low_addr
)
2761 low_addr
= range
->low
;
2762 if (range
->high
> high_addr
)
2763 high_addr
= range
->high
;
2766 entry
->low_addr
= low_addr
;
2767 entry
->high_addr
= high_addr
;
2770 BFD_ASSERT (func_index
== 0);
2772 /* Sort the function by address. */
2773 qsort (lookup_funcinfo_table
,
2774 number_of_functions
,
2775 sizeof (struct lookup_funcinfo
),
2776 compare_lookup_funcinfos
);
2778 /* Calculate the high watermark for each function in the lookup table. */
2779 high_addr
= lookup_funcinfo_table
[0].high_addr
;
2780 for (func_index
= 1; func_index
< number_of_functions
; func_index
++)
2782 entry
= &lookup_funcinfo_table
[func_index
];
2783 if (entry
->high_addr
> high_addr
)
2784 high_addr
= entry
->high_addr
;
2786 entry
->high_addr
= high_addr
;
2789 unit
->lookup_funcinfo_table
= lookup_funcinfo_table
;
2793 /* If ADDR is within UNIT's function tables, set FUNCTION_PTR, and return
2794 TRUE. Note that we need to find the function that has the smallest range
2795 that contains ADDR, to handle inlined functions without depending upon
2796 them being ordered in TABLE by increasing range. */
2799 lookup_address_in_function_table (struct comp_unit
*unit
,
2801 struct funcinfo
**function_ptr
)
2803 unsigned int number_of_functions
= unit
->number_of_functions
;
2804 struct lookup_funcinfo
* lookup_funcinfo
= NULL
;
2805 struct funcinfo
* funcinfo
= NULL
;
2806 struct funcinfo
* best_fit
= NULL
;
2807 bfd_vma best_fit_len
= 0;
2808 bfd_size_type low
, high
, mid
, first
;
2809 struct arange
*arange
;
2811 if (number_of_functions
== 0)
2814 if (!build_lookup_funcinfo_table (unit
))
2817 if (unit
->lookup_funcinfo_table
[number_of_functions
- 1].high_addr
< addr
)
2820 /* Find the first function in the lookup table which may contain the
2821 specified address. */
2823 high
= number_of_functions
;
2827 mid
= (low
+ high
) / 2;
2828 lookup_funcinfo
= &unit
->lookup_funcinfo_table
[mid
];
2829 if (addr
< lookup_funcinfo
->low_addr
)
2831 else if (addr
>= lookup_funcinfo
->high_addr
)
2837 /* Find the 'best' match for the address. The prior algorithm defined the
2838 best match as the function with the smallest address range containing
2839 the specified address. This definition should probably be changed to the
2840 innermost inline routine containing the address, but right now we want
2841 to get the same results we did before. */
2842 while (first
< number_of_functions
)
2844 if (addr
< unit
->lookup_funcinfo_table
[first
].low_addr
)
2846 funcinfo
= unit
->lookup_funcinfo_table
[first
].funcinfo
;
2848 for (arange
= &funcinfo
->arange
; arange
; arange
= arange
->next
)
2850 if (addr
< arange
->low
|| addr
>= arange
->high
)
2854 || arange
->high
- arange
->low
< best_fit_len
2855 /* The following comparison is designed to return the same
2856 match as the previous algorithm for routines which have the
2857 same best fit length. */
2858 || (arange
->high
- arange
->low
== best_fit_len
2859 && funcinfo
> best_fit
))
2861 best_fit
= funcinfo
;
2862 best_fit_len
= arange
->high
- arange
->low
;
2872 *function_ptr
= best_fit
;
2876 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
2877 and LINENUMBER_PTR, and return TRUE. */
2880 lookup_symbol_in_function_table (struct comp_unit
*unit
,
2883 const char **filename_ptr
,
2884 unsigned int *linenumber_ptr
)
2886 struct funcinfo
* each_func
;
2887 struct funcinfo
* best_fit
= NULL
;
2888 bfd_vma best_fit_len
= 0;
2889 struct arange
*arange
;
2890 const char *name
= bfd_asymbol_name (sym
);
2891 asection
*sec
= bfd_asymbol_section (sym
);
2893 for (each_func
= unit
->function_table
;
2895 each_func
= each_func
->prev_func
)
2897 for (arange
= &each_func
->arange
;
2899 arange
= arange
->next
)
2901 if ((!each_func
->sec
|| each_func
->sec
== sec
)
2902 && addr
>= arange
->low
2903 && addr
< arange
->high
2905 && strcmp (name
, each_func
->name
) == 0
2907 || arange
->high
- arange
->low
< best_fit_len
))
2909 best_fit
= each_func
;
2910 best_fit_len
= arange
->high
- arange
->low
;
2917 best_fit
->sec
= sec
;
2918 *filename_ptr
= best_fit
->file
;
2919 *linenumber_ptr
= best_fit
->line
;
2926 /* Variable table functions. */
2928 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
2929 LINENUMBER_PTR, and return TRUE. */
2932 lookup_symbol_in_variable_table (struct comp_unit
*unit
,
2935 const char **filename_ptr
,
2936 unsigned int *linenumber_ptr
)
2938 const char *name
= bfd_asymbol_name (sym
);
2939 asection
*sec
= bfd_asymbol_section (sym
);
2940 struct varinfo
* each
;
2942 for (each
= unit
->variable_table
; each
; each
= each
->prev_var
)
2944 && each
->file
!= NULL
2945 && each
->name
!= NULL
2946 && each
->addr
== addr
2947 && (!each
->sec
|| each
->sec
== sec
)
2948 && strcmp (name
, each
->name
) == 0)
2954 *filename_ptr
= each
->file
;
2955 *linenumber_ptr
= each
->line
;
2962 static struct comp_unit
*stash_comp_unit (struct dwarf2_debug
*,
2963 struct dwarf2_debug_file
*);
2964 static bool comp_unit_maybe_decode_line_info (struct comp_unit
*);
2967 find_abstract_instance (struct comp_unit
*unit
,
2968 struct attribute
*attr_ptr
,
2969 unsigned int recur_count
,
2972 char **filename_ptr
,
2973 int *linenumber_ptr
)
2975 bfd
*abfd
= unit
->abfd
;
2976 bfd_byte
*info_ptr
= NULL
;
2977 bfd_byte
*info_ptr_end
;
2978 unsigned int abbrev_number
, bytes_read
, i
;
2979 struct abbrev_info
*abbrev
;
2980 bfd_uint64_t die_ref
= attr_ptr
->u
.val
;
2981 struct attribute attr
;
2982 const char *name
= NULL
;
2984 if (recur_count
== 100)
2987 (_("DWARF error: abstract instance recursion detected"));
2988 bfd_set_error (bfd_error_bad_value
);
2992 /* DW_FORM_ref_addr can reference an entry in a different CU. It
2993 is an offset from the .debug_info section, not the current CU. */
2994 if (attr_ptr
->form
== DW_FORM_ref_addr
)
2996 /* We only support DW_FORM_ref_addr within the same file, so
2997 any relocations should be resolved already. Check this by
2998 testing for a zero die_ref; There can't be a valid reference
2999 to the header of a .debug_info section.
3000 DW_FORM_ref_addr is an offset relative to .debug_info.
3001 Normally when using the GNU linker this is accomplished by
3002 emitting a symbolic reference to a label, because .debug_info
3003 sections are linked at zero. When there are multiple section
3004 groups containing .debug_info, as there might be in a
3005 relocatable object file, it would be reasonable to assume that
3006 a symbolic reference to a label in any .debug_info section
3007 might be used. Since we lay out multiple .debug_info
3008 sections at non-zero VMAs (see place_sections), and read
3009 them contiguously into dwarf_info_buffer, that means the
3010 reference is relative to dwarf_info_buffer. */
3013 info_ptr
= unit
->file
->dwarf_info_buffer
;
3014 info_ptr_end
= info_ptr
+ unit
->file
->dwarf_info_size
;
3015 total
= info_ptr_end
- info_ptr
;
3018 else if (die_ref
>= total
)
3021 (_("DWARF error: invalid abstract instance DIE ref"));
3022 bfd_set_error (bfd_error_bad_value
);
3025 info_ptr
+= die_ref
;
3027 else if (attr_ptr
->form
== DW_FORM_GNU_ref_alt
)
3029 bool first_time
= unit
->stash
->alt
.dwarf_info_buffer
== NULL
;
3031 info_ptr
= read_alt_indirect_ref (unit
, die_ref
);
3033 unit
->stash
->alt
.info_ptr
= unit
->stash
->alt
.dwarf_info_buffer
;
3034 if (info_ptr
== NULL
)
3037 (_("DWARF error: unable to read alt ref %" PRIu64
),
3038 (uint64_t) die_ref
);
3039 bfd_set_error (bfd_error_bad_value
);
3042 info_ptr_end
= (unit
->stash
->alt
.dwarf_info_buffer
3043 + unit
->stash
->alt
.dwarf_info_size
);
3044 if (unit
->stash
->alt
.all_comp_units
)
3045 unit
= unit
->stash
->alt
.all_comp_units
;
3048 if (attr_ptr
->form
== DW_FORM_ref_addr
3049 || attr_ptr
->form
== DW_FORM_GNU_ref_alt
)
3051 /* Now find the CU containing this pointer. */
3052 if (info_ptr
>= unit
->info_ptr_unit
&& info_ptr
< unit
->end_ptr
)
3053 info_ptr_end
= unit
->end_ptr
;
3056 /* Check other CUs to see if they contain the abbrev. */
3057 struct comp_unit
*u
;
3059 for (u
= unit
->prev_unit
; u
!= NULL
; u
= u
->prev_unit
)
3060 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
3064 for (u
= unit
->next_unit
; u
!= NULL
; u
= u
->next_unit
)
3065 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
3068 if (attr_ptr
->form
== DW_FORM_ref_addr
)
3071 u
= stash_comp_unit (unit
->stash
, &unit
->stash
->f
);
3074 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
3079 if (attr_ptr
->form
== DW_FORM_GNU_ref_alt
)
3082 u
= stash_comp_unit (unit
->stash
, &unit
->stash
->alt
);
3085 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
3093 (_("DWARF error: unable to locate abstract instance DIE ref %"
3094 PRIu64
), (uint64_t) die_ref
);
3095 bfd_set_error (bfd_error_bad_value
);
3099 info_ptr_end
= unit
->end_ptr
;
3104 /* DW_FORM_ref1, DW_FORM_ref2, DW_FORM_ref4, DW_FORM_ref8 or
3105 DW_FORM_ref_udata. These are all references relative to the
3106 start of the current CU. */
3109 info_ptr
= unit
->info_ptr_unit
;
3110 info_ptr_end
= unit
->end_ptr
;
3111 total
= info_ptr_end
- info_ptr
;
3112 if (!die_ref
|| die_ref
>= total
)
3115 (_("DWARF error: invalid abstract instance DIE ref"));
3116 bfd_set_error (bfd_error_bad_value
);
3119 info_ptr
+= die_ref
;
3122 abbrev_number
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
3123 false, info_ptr_end
);
3124 info_ptr
+= bytes_read
;
3128 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
3132 (_("DWARF error: could not find abbrev number %u"), abbrev_number
);
3133 bfd_set_error (bfd_error_bad_value
);
3138 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3140 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
,
3141 info_ptr
, info_ptr_end
);
3142 if (info_ptr
== NULL
)
3147 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
3149 if (name
== NULL
&& is_str_attr (attr
.form
))
3152 if (non_mangled (unit
->lang
))
3156 case DW_AT_specification
:
3157 if (!find_abstract_instance (unit
, &attr
, recur_count
+ 1,
3159 filename_ptr
, linenumber_ptr
))
3162 case DW_AT_linkage_name
:
3163 case DW_AT_MIPS_linkage_name
:
3164 /* PR 16949: Corrupt debug info can place
3165 non-string forms into these attributes. */
3166 if (is_str_attr (attr
.form
))
3172 case DW_AT_decl_file
:
3173 if (!comp_unit_maybe_decode_line_info (unit
))
3175 *filename_ptr
= concat_filename (unit
->line_table
,
3178 case DW_AT_decl_line
:
3179 *linenumber_ptr
= attr
.u
.val
;
3192 read_ranges (struct comp_unit
*unit
, struct arange
*arange
,
3193 bfd_uint64_t offset
)
3195 bfd_byte
*ranges_ptr
;
3196 bfd_byte
*ranges_end
;
3197 bfd_vma base_address
= unit
->base_address
;
3199 if (! unit
->file
->dwarf_ranges_buffer
)
3201 if (! read_debug_ranges (unit
))
3205 ranges_ptr
= unit
->file
->dwarf_ranges_buffer
+ offset
;
3206 if (ranges_ptr
< unit
->file
->dwarf_ranges_buffer
)
3208 ranges_end
= unit
->file
->dwarf_ranges_buffer
+ unit
->file
->dwarf_ranges_size
;
3215 /* PR 17512: file: 62cada7d. */
3216 if (ranges_ptr
+ 2 * unit
->addr_size
> ranges_end
)
3219 low_pc
= read_address (unit
, ranges_ptr
, ranges_end
);
3220 ranges_ptr
+= unit
->addr_size
;
3221 high_pc
= read_address (unit
, ranges_ptr
, ranges_end
);
3222 ranges_ptr
+= unit
->addr_size
;
3224 if (low_pc
== 0 && high_pc
== 0)
3226 if (low_pc
== -1UL && high_pc
!= -1UL)
3227 base_address
= high_pc
;
3230 if (!arange_add (unit
, arange
,
3231 base_address
+ low_pc
, base_address
+ high_pc
))
3239 read_rnglists (struct comp_unit
*unit
, struct arange
*arange
,
3240 bfd_uint64_t offset
)
3244 bfd_vma base_address
= unit
->base_address
;
3247 bfd
*abfd
= unit
->abfd
;
3249 if (! unit
->file
->dwarf_rnglists_buffer
)
3251 if (! read_debug_rnglists (unit
))
3255 rngs_ptr
= unit
->file
->dwarf_rnglists_buffer
+ offset
;
3256 if (rngs_ptr
< unit
->file
->dwarf_rnglists_buffer
)
3258 rngs_end
= unit
->file
->dwarf_rnglists_buffer
;
3259 rngs_end
+= unit
->file
->dwarf_rnglists_size
;
3263 enum dwarf_range_list_entry rlet
;
3264 unsigned int bytes_read
;
3266 if (rngs_ptr
+ 1 > rngs_end
)
3269 rlet
= read_1_byte (abfd
, rngs_ptr
, rngs_end
);
3274 case DW_RLE_end_of_list
:
3277 case DW_RLE_base_address
:
3278 if (rngs_ptr
+ unit
->addr_size
> rngs_end
)
3280 base_address
= read_address (unit
, rngs_ptr
, rngs_end
);
3281 rngs_ptr
+= unit
->addr_size
;
3284 case DW_RLE_start_length
:
3285 if (rngs_ptr
+ unit
->addr_size
> rngs_end
)
3287 low_pc
= read_address (unit
, rngs_ptr
, rngs_end
);
3288 rngs_ptr
+= unit
->addr_size
;
3290 high_pc
+= _bfd_safe_read_leb128 (abfd
, rngs_ptr
, &bytes_read
,
3292 rngs_ptr
+= bytes_read
;
3295 case DW_RLE_offset_pair
:
3296 low_pc
= base_address
;
3297 low_pc
+= _bfd_safe_read_leb128 (abfd
, rngs_ptr
, &bytes_read
,
3299 rngs_ptr
+= bytes_read
;
3300 high_pc
= base_address
;
3301 high_pc
+= _bfd_safe_read_leb128 (abfd
, rngs_ptr
, &bytes_read
,
3303 rngs_ptr
+= bytes_read
;
3306 case DW_RLE_start_end
:
3307 if (rngs_ptr
+ 2 * unit
->addr_size
> rngs_end
)
3309 low_pc
= read_address (unit
, rngs_ptr
, rngs_end
);
3310 rngs_ptr
+= unit
->addr_size
;
3311 high_pc
= read_address (unit
, rngs_ptr
, rngs_end
);
3312 rngs_ptr
+= unit
->addr_size
;
3315 /* TODO x-variants need .debug_addr support used for split-dwarf. */
3316 case DW_RLE_base_addressx
:
3317 case DW_RLE_startx_endx
:
3318 case DW_RLE_startx_length
:
3323 if (!arange_add (unit
, arange
, low_pc
, high_pc
))
3329 read_rangelist (struct comp_unit
*unit
, struct arange
*arange
,
3330 bfd_uint64_t offset
)
3332 if (unit
->version
<= 4)
3333 return read_ranges (unit
, arange
, offset
);
3335 return read_rnglists (unit
, arange
, offset
);
3338 static struct funcinfo
*
3339 lookup_func_by_offset (bfd_uint64_t offset
, struct funcinfo
* table
)
3341 for (; table
!= NULL
; table
= table
->prev_func
)
3342 if (table
->unit_offset
== offset
)
3347 static struct varinfo
*
3348 lookup_var_by_offset (bfd_uint64_t offset
, struct varinfo
* table
)
3352 if (table
->unit_offset
== offset
)
3354 table
= table
->prev_var
;
3361 /* DWARF2 Compilation unit functions. */
3363 /* Scan over each die in a comp. unit looking for functions to add
3364 to the function table and variables to the variable table. */
3367 scan_unit_for_symbols (struct comp_unit
*unit
)
3369 bfd
*abfd
= unit
->abfd
;
3370 bfd_byte
*info_ptr
= unit
->first_child_die_ptr
;
3371 bfd_byte
*info_ptr_end
= unit
->end_ptr
;
3372 int nesting_level
= 0;
3373 struct nest_funcinfo
3375 struct funcinfo
*func
;
3377 int nested_funcs_size
;
3379 /* Maintain a stack of in-scope functions and inlined functions, which we
3380 can use to set the caller_func field. */
3381 nested_funcs_size
= 32;
3382 nested_funcs
= (struct nest_funcinfo
*)
3383 bfd_malloc (nested_funcs_size
* sizeof (*nested_funcs
));
3384 if (nested_funcs
== NULL
)
3386 nested_funcs
[nesting_level
].func
= 0;
3388 /* PR 27484: We must scan the DIEs twice. The first time we look for
3389 function and variable tags and accumulate them into their respective
3390 tables. The second time through we process the attributes of the
3391 functions/variables and augment the table entries. */
3392 while (nesting_level
>= 0)
3394 unsigned int abbrev_number
, bytes_read
, i
;
3395 struct abbrev_info
*abbrev
;
3396 struct funcinfo
*func
;
3397 struct varinfo
*var
;
3398 bfd_uint64_t current_offset
;
3400 /* PR 17512: file: 9f405d9d. */
3401 if (info_ptr
>= info_ptr_end
)
3404 current_offset
= info_ptr
- unit
->info_ptr_unit
;
3405 abbrev_number
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
3406 false, info_ptr_end
);
3407 info_ptr
+= bytes_read
;
3409 if (abbrev_number
== 0)
3415 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
3418 static unsigned int previous_failed_abbrev
= -1U;
3420 /* Avoid multiple reports of the same missing abbrev. */
3421 if (abbrev_number
!= previous_failed_abbrev
)
3424 (_("DWARF error: could not find abbrev number %u"),
3426 previous_failed_abbrev
= abbrev_number
;
3428 bfd_set_error (bfd_error_bad_value
);
3432 if (abbrev
->tag
== DW_TAG_subprogram
3433 || abbrev
->tag
== DW_TAG_entry_point
3434 || abbrev
->tag
== DW_TAG_inlined_subroutine
)
3436 size_t amt
= sizeof (struct funcinfo
);
3439 func
= (struct funcinfo
*) bfd_zalloc (abfd
, amt
);
3442 func
->tag
= abbrev
->tag
;
3443 func
->prev_func
= unit
->function_table
;
3444 func
->unit_offset
= current_offset
;
3445 unit
->function_table
= func
;
3446 unit
->number_of_functions
++;
3447 BFD_ASSERT (!unit
->cached
);
3449 if (func
->tag
== DW_TAG_inlined_subroutine
)
3450 for (i
= nesting_level
; i
-- != 0; )
3451 if (nested_funcs
[i
].func
)
3453 func
->caller_func
= nested_funcs
[i
].func
;
3456 nested_funcs
[nesting_level
].func
= func
;
3461 if (abbrev
->tag
== DW_TAG_variable
3462 || abbrev
->tag
== DW_TAG_member
)
3464 size_t amt
= sizeof (struct varinfo
);
3466 var
= (struct varinfo
*) bfd_zalloc (abfd
, amt
);
3469 var
->tag
= abbrev
->tag
;
3471 var
->prev_var
= unit
->variable_table
;
3472 unit
->variable_table
= var
;
3473 var
->unit_offset
= current_offset
;
3474 /* PR 18205: Missing debug information can cause this
3475 var to be attached to an already cached unit. */
3480 /* No inline function in scope at this nesting level. */
3481 nested_funcs
[nesting_level
].func
= 0;
3484 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3486 struct attribute attr
;
3488 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
],
3489 unit
, info_ptr
, info_ptr_end
);
3490 if (info_ptr
== NULL
)
3494 if (abbrev
->has_children
)
3498 if (nesting_level
>= nested_funcs_size
)
3500 struct nest_funcinfo
*tmp
;
3502 nested_funcs_size
*= 2;
3503 tmp
= (struct nest_funcinfo
*)
3504 bfd_realloc (nested_funcs
,
3505 nested_funcs_size
* sizeof (*nested_funcs
));
3510 nested_funcs
[nesting_level
].func
= 0;
3514 /* This is the second pass over the abbrevs. */
3515 info_ptr
= unit
->first_child_die_ptr
;
3518 while (nesting_level
>= 0)
3520 unsigned int abbrev_number
, bytes_read
, i
;
3521 struct abbrev_info
*abbrev
;
3522 struct attribute attr
;
3523 struct funcinfo
*func
;
3524 struct varinfo
*var
;
3526 bfd_vma high_pc
= 0;
3527 bool high_pc_relative
= false;
3528 bfd_uint64_t current_offset
;
3530 /* PR 17512: file: 9f405d9d. */
3531 if (info_ptr
>= info_ptr_end
)
3534 current_offset
= info_ptr
- unit
->info_ptr_unit
;
3535 abbrev_number
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
3536 false, info_ptr_end
);
3537 info_ptr
+= bytes_read
;
3539 if (! abbrev_number
)
3545 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
3546 /* This should have been handled above. */
3547 BFD_ASSERT (abbrev
!= NULL
);
3551 if (abbrev
->tag
== DW_TAG_subprogram
3552 || abbrev
->tag
== DW_TAG_entry_point
3553 || abbrev
->tag
== DW_TAG_inlined_subroutine
)
3555 func
= lookup_func_by_offset (current_offset
, unit
->function_table
);
3559 else if (abbrev
->tag
== DW_TAG_variable
3560 || abbrev
->tag
== DW_TAG_member
)
3562 var
= lookup_var_by_offset (current_offset
, unit
->variable_table
);
3567 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3569 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
],
3570 unit
, info_ptr
, info_ptr_end
);
3571 if (info_ptr
== NULL
)
3578 case DW_AT_call_file
:
3579 func
->caller_file
= concat_filename (unit
->line_table
,
3583 case DW_AT_call_line
:
3584 func
->caller_line
= attr
.u
.val
;
3587 case DW_AT_abstract_origin
:
3588 case DW_AT_specification
:
3589 if (!find_abstract_instance (unit
, &attr
, 0,
3598 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
3600 if (func
->name
== NULL
&& is_str_attr (attr
.form
))
3602 func
->name
= attr
.u
.str
;
3603 if (non_mangled (unit
->lang
))
3604 func
->is_linkage
= true;
3608 case DW_AT_linkage_name
:
3609 case DW_AT_MIPS_linkage_name
:
3610 /* PR 16949: Corrupt debug info can place
3611 non-string forms into these attributes. */
3612 if (is_str_attr (attr
.form
))
3614 func
->name
= attr
.u
.str
;
3615 func
->is_linkage
= true;
3620 low_pc
= attr
.u
.val
;
3624 high_pc
= attr
.u
.val
;
3625 high_pc_relative
= attr
.form
!= DW_FORM_addr
;
3629 if (!read_rangelist (unit
, &func
->arange
, attr
.u
.val
))
3633 case DW_AT_decl_file
:
3634 func
->file
= concat_filename (unit
->line_table
,
3638 case DW_AT_decl_line
:
3639 func
->line
= attr
.u
.val
;
3650 case DW_AT_specification
:
3653 struct varinfo
* spec_var
;
3655 spec_var
= lookup_var_by_offset (attr
.u
.val
,
3656 unit
->variable_table
);
3657 if (spec_var
== NULL
)
3659 _bfd_error_handler (_("DWARF error: could not find "
3660 "variable specification "
3662 (unsigned long) attr
.u
.val
);
3666 if (var
->name
== NULL
)
3667 var
->name
= spec_var
->name
;
3668 if (var
->file
== NULL
&& spec_var
->file
!= NULL
)
3669 var
->file
= strdup (spec_var
->file
);
3671 var
->line
= spec_var
->line
;
3672 if (var
->sec
== NULL
)
3673 var
->sec
= spec_var
->sec
;
3678 if (is_str_attr (attr
.form
))
3679 var
->name
= attr
.u
.str
;
3682 case DW_AT_decl_file
:
3683 var
->file
= concat_filename (unit
->line_table
,
3687 case DW_AT_decl_line
:
3688 var
->line
= attr
.u
.val
;
3691 case DW_AT_external
:
3692 if (attr
.u
.val
!= 0)
3696 case DW_AT_location
:
3700 case DW_FORM_block1
:
3701 case DW_FORM_block2
:
3702 case DW_FORM_block4
:
3703 case DW_FORM_exprloc
:
3704 if (attr
.u
.blk
->data
!= NULL
3705 && *attr
.u
.blk
->data
== DW_OP_addr
)
3709 /* Verify that DW_OP_addr is the only opcode in the
3710 location, in which case the block size will be 1
3711 plus the address size. */
3712 /* ??? For TLS variables, gcc can emit
3713 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
3714 which we don't handle here yet. */
3715 if (attr
.u
.blk
->size
== unit
->addr_size
+ 1U)
3716 var
->addr
= bfd_get (unit
->addr_size
* 8,
3718 attr
.u
.blk
->data
+ 1);
3733 if (abbrev
->has_children
)
3736 if (high_pc_relative
)
3739 if (func
&& high_pc
!= 0)
3741 if (!arange_add (unit
, &func
->arange
, low_pc
, high_pc
))
3746 free (nested_funcs
);
3750 free (nested_funcs
);
3754 /* Parse a DWARF2 compilation unit starting at INFO_PTR. UNIT_LENGTH
3755 includes the compilation unit header that proceeds the DIE's, but
3756 does not include the length field that precedes each compilation
3757 unit header. END_PTR points one past the end of this comp unit.
3758 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
3760 This routine does not read the whole compilation unit; only enough
3761 to get to the line number information for the compilation unit. */
3763 static struct comp_unit
*
3764 parse_comp_unit (struct dwarf2_debug
*stash
,
3765 struct dwarf2_debug_file
*file
,
3767 bfd_vma unit_length
,
3768 bfd_byte
*info_ptr_unit
,
3769 unsigned int offset_size
)
3771 struct comp_unit
* unit
;
3772 unsigned int version
;
3773 bfd_uint64_t abbrev_offset
= 0;
3774 /* Initialize it just to avoid a GCC false warning. */
3775 unsigned int addr_size
= -1;
3776 struct abbrev_info
** abbrevs
;
3777 unsigned int abbrev_number
, bytes_read
, i
;
3778 struct abbrev_info
*abbrev
;
3779 struct attribute attr
;
3780 bfd_byte
*end_ptr
= info_ptr
+ unit_length
;
3783 bfd_vma high_pc
= 0;
3784 bfd
*abfd
= file
->bfd_ptr
;
3785 bool high_pc_relative
= false;
3786 enum dwarf_unit_type unit_type
;
3788 version
= read_2_bytes (abfd
, info_ptr
, end_ptr
);
3790 if (version
< 2 || version
> 5)
3792 /* PR 19872: A version number of 0 probably means that there is padding
3793 at the end of the .debug_info section. Gold puts it there when
3794 performing an incremental link, for example. So do not generate
3795 an error, just return a NULL. */
3799 (_("DWARF error: found dwarf version '%u', this reader"
3800 " only handles version 2, 3, 4 and 5 information"), version
);
3801 bfd_set_error (bfd_error_bad_value
);
3807 unit_type
= DW_UT_compile
;
3810 unit_type
= read_1_byte (abfd
, info_ptr
, end_ptr
);
3813 addr_size
= read_1_byte (abfd
, info_ptr
, end_ptr
);
3817 BFD_ASSERT (offset_size
== 4 || offset_size
== 8);
3818 if (offset_size
== 4)
3819 abbrev_offset
= read_4_bytes (abfd
, info_ptr
, end_ptr
);
3821 abbrev_offset
= read_8_bytes (abfd
, info_ptr
, end_ptr
);
3822 info_ptr
+= offset_size
;
3826 addr_size
= read_1_byte (abfd
, info_ptr
, end_ptr
);
3830 if (unit_type
== DW_UT_type
)
3832 /* Skip type signature. */
3835 /* Skip type offset. */
3836 info_ptr
+= offset_size
;
3839 if (addr_size
> sizeof (bfd_vma
))
3842 /* xgettext: c-format */
3843 (_("DWARF error: found address size '%u', this reader"
3844 " can not handle sizes greater than '%u'"),
3846 (unsigned int) sizeof (bfd_vma
));
3847 bfd_set_error (bfd_error_bad_value
);
3851 if (addr_size
!= 2 && addr_size
!= 4 && addr_size
!= 8)
3854 ("DWARF error: found address size '%u', this reader"
3855 " can only handle address sizes '2', '4' and '8'", addr_size
);
3856 bfd_set_error (bfd_error_bad_value
);
3860 /* Read the abbrevs for this compilation unit into a table. */
3861 abbrevs
= read_abbrevs (abfd
, abbrev_offset
, stash
, file
);
3865 abbrev_number
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
3867 info_ptr
+= bytes_read
;
3868 if (! abbrev_number
)
3870 /* PR 19872: An abbrev number of 0 probably means that there is padding
3871 at the end of the .debug_abbrev section. Gold puts it there when
3872 performing an incremental link, for example. So do not generate
3873 an error, just return a NULL. */
3877 abbrev
= lookup_abbrev (abbrev_number
, abbrevs
);
3880 _bfd_error_handler (_("DWARF error: could not find abbrev number %u"),
3882 bfd_set_error (bfd_error_bad_value
);
3886 amt
= sizeof (struct comp_unit
);
3887 unit
= (struct comp_unit
*) bfd_zalloc (abfd
, amt
);
3891 unit
->version
= version
;
3892 unit
->addr_size
= addr_size
;
3893 unit
->offset_size
= offset_size
;
3894 unit
->abbrevs
= abbrevs
;
3895 unit
->end_ptr
= end_ptr
;
3896 unit
->stash
= stash
;
3898 unit
->info_ptr_unit
= info_ptr_unit
;
3900 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3902 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
, end_ptr
);
3903 if (info_ptr
== NULL
)
3906 /* Store the data if it is of an attribute we want to keep in a
3907 partial symbol table. */
3910 case DW_AT_stmt_list
:
3912 unit
->line_offset
= attr
.u
.val
;
3916 if (is_str_attr (attr
.form
))
3917 unit
->name
= attr
.u
.str
;
3921 low_pc
= attr
.u
.val
;
3922 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
3923 this is the base address to use when reading location
3924 lists or range lists. */
3925 if (abbrev
->tag
== DW_TAG_compile_unit
)
3926 unit
->base_address
= low_pc
;
3930 high_pc
= attr
.u
.val
;
3931 high_pc_relative
= attr
.form
!= DW_FORM_addr
;
3935 if (!read_rangelist (unit
, &unit
->arange
, attr
.u
.val
))
3939 case DW_AT_comp_dir
:
3941 char *comp_dir
= attr
.u
.str
;
3943 /* PR 17512: file: 1fe726be. */
3944 if (! is_str_attr (attr
.form
))
3947 (_("DWARF error: DW_AT_comp_dir attribute encountered with a non-string form"));
3953 /* Irix 6.2 native cc prepends <machine>.: to the compilation
3954 directory, get rid of it. */
3955 char *cp
= strchr (comp_dir
, ':');
3957 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
3960 unit
->comp_dir
= comp_dir
;
3964 case DW_AT_language
:
3965 unit
->lang
= attr
.u
.val
;
3972 if (high_pc_relative
)
3976 if (!arange_add (unit
, &unit
->arange
, low_pc
, high_pc
))
3980 unit
->first_child_die_ptr
= info_ptr
;
3984 /* Return TRUE if UNIT may contain the address given by ADDR. When
3985 there are functions written entirely with inline asm statements, the
3986 range info in the compilation unit header may not be correct. We
3987 need to consult the line info table to see if a compilation unit
3988 really contains the given address. */
3991 comp_unit_contains_address (struct comp_unit
*unit
, bfd_vma addr
)
3993 struct arange
*arange
;
3998 arange
= &unit
->arange
;
4001 if (addr
>= arange
->low
&& addr
< arange
->high
)
4003 arange
= arange
->next
;
4010 /* If UNIT contains ADDR, set the output parameters to the values for
4011 the line containing ADDR. The output parameters, FILENAME_PTR,
4012 FUNCTION_PTR, and LINENUMBER_PTR, are pointers to the objects
4015 Returns the range of addresses covered by the entry that was used
4016 to fill in *LINENUMBER_PTR or 0 if it was not filled in. */
4019 comp_unit_find_nearest_line (struct comp_unit
*unit
,
4021 const char **filename_ptr
,
4022 struct funcinfo
**function_ptr
,
4023 unsigned int *linenumber_ptr
,
4024 unsigned int *discriminator_ptr
)
4028 if (!comp_unit_maybe_decode_line_info (unit
))
4031 *function_ptr
= NULL
;
4032 func_p
= lookup_address_in_function_table (unit
, addr
, function_ptr
);
4033 if (func_p
&& (*function_ptr
)->tag
== DW_TAG_inlined_subroutine
)
4034 unit
->stash
->inliner_chain
= *function_ptr
;
4036 return lookup_address_in_line_info_table (unit
->line_table
, addr
,
4042 /* Check to see if line info is already decoded in a comp_unit.
4043 If not, decode it. Returns TRUE if no errors were encountered;
4047 comp_unit_maybe_decode_line_info (struct comp_unit
*unit
)
4052 if (! unit
->line_table
)
4054 if (! unit
->stmtlist
)
4060 unit
->line_table
= decode_line_info (unit
);
4062 if (! unit
->line_table
)
4068 if (unit
->first_child_die_ptr
< unit
->end_ptr
4069 && ! scan_unit_for_symbols (unit
))
4079 /* If UNIT contains SYM at ADDR, set the output parameters to the
4080 values for the line containing SYM. The output parameters,
4081 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
4084 Return TRUE if UNIT contains SYM, and no errors were encountered;
4088 comp_unit_find_line (struct comp_unit
*unit
,
4091 const char **filename_ptr
,
4092 unsigned int *linenumber_ptr
)
4094 if (!comp_unit_maybe_decode_line_info (unit
))
4097 if (sym
->flags
& BSF_FUNCTION
)
4098 return lookup_symbol_in_function_table (unit
, sym
, addr
,
4102 return lookup_symbol_in_variable_table (unit
, sym
, addr
,
4107 static struct funcinfo
*
4108 reverse_funcinfo_list (struct funcinfo
*head
)
4110 struct funcinfo
*rhead
;
4111 struct funcinfo
*temp
;
4113 for (rhead
= NULL
; head
; head
= temp
)
4115 temp
= head
->prev_func
;
4116 head
->prev_func
= rhead
;
4122 static struct varinfo
*
4123 reverse_varinfo_list (struct varinfo
*head
)
4125 struct varinfo
*rhead
;
4126 struct varinfo
*temp
;
4128 for (rhead
= NULL
; head
; head
= temp
)
4130 temp
= head
->prev_var
;
4131 head
->prev_var
= rhead
;
4137 /* Extract all interesting funcinfos and varinfos of a compilation
4138 unit into hash tables for faster lookup. Returns TRUE if no
4139 errors were enountered; FALSE otherwise. */
4142 comp_unit_hash_info (struct dwarf2_debug
*stash
,
4143 struct comp_unit
*unit
,
4144 struct info_hash_table
*funcinfo_hash_table
,
4145 struct info_hash_table
*varinfo_hash_table
)
4147 struct funcinfo
* each_func
;
4148 struct varinfo
* each_var
;
4151 BFD_ASSERT (stash
->info_hash_status
!= STASH_INFO_HASH_DISABLED
);
4153 if (!comp_unit_maybe_decode_line_info (unit
))
4156 BFD_ASSERT (!unit
->cached
);
4158 /* To preserve the original search order, we went to visit the function
4159 infos in the reversed order of the list. However, making the list
4160 bi-directional use quite a bit of extra memory. So we reverse
4161 the list first, traverse the list in the now reversed order and
4162 finally reverse the list again to get back the original order. */
4163 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
4164 for (each_func
= unit
->function_table
;
4166 each_func
= each_func
->prev_func
)
4168 /* Skip nameless functions. */
4169 if (each_func
->name
)
4170 /* There is no need to copy name string into hash table as
4171 name string is either in the dwarf string buffer or
4172 info in the stash. */
4173 okay
= insert_info_hash_table (funcinfo_hash_table
, each_func
->name
,
4174 (void*) each_func
, false);
4176 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
4180 /* We do the same for variable infos. */
4181 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
4182 for (each_var
= unit
->variable_table
;
4184 each_var
= each_var
->prev_var
)
4186 /* Skip stack vars and vars with no files or names. */
4187 if (! each_var
->stack
4188 && each_var
->file
!= NULL
4189 && each_var
->name
!= NULL
)
4190 /* There is no need to copy name string into hash table as
4191 name string is either in the dwarf string buffer or
4192 info in the stash. */
4193 okay
= insert_info_hash_table (varinfo_hash_table
, each_var
->name
,
4194 (void*) each_var
, false);
4197 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
4198 unit
->cached
= true;
4202 /* Locate a section in a BFD containing debugging info. The search starts
4203 from the section after AFTER_SEC, or from the first section in the BFD if
4204 AFTER_SEC is NULL. The search works by examining the names of the
4205 sections. There are three permissiable names. The first two are given
4206 by DEBUG_SECTIONS[debug_info] (whose standard DWARF2 names are .debug_info
4207 and .zdebug_info). The third is a prefix .gnu.linkonce.wi.
4208 This is a variation on the .debug_info section which has a checksum
4209 describing the contents appended onto the name. This allows the linker to
4210 identify and discard duplicate debugging sections for different
4211 compilation units. */
4212 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
4215 find_debug_info (bfd
*abfd
, const struct dwarf_debug_section
*debug_sections
,
4216 asection
*after_sec
)
4221 if (after_sec
== NULL
)
4223 look
= debug_sections
[debug_info
].uncompressed_name
;
4224 msec
= bfd_get_section_by_name (abfd
, look
);
4228 look
= debug_sections
[debug_info
].compressed_name
;
4231 msec
= bfd_get_section_by_name (abfd
, look
);
4236 for (msec
= abfd
->sections
; msec
!= NULL
; msec
= msec
->next
)
4237 if (startswith (msec
->name
, GNU_LINKONCE_INFO
))
4243 for (msec
= after_sec
->next
; msec
!= NULL
; msec
= msec
->next
)
4245 look
= debug_sections
[debug_info
].uncompressed_name
;
4246 if (strcmp (msec
->name
, look
) == 0)
4249 look
= debug_sections
[debug_info
].compressed_name
;
4250 if (look
!= NULL
&& strcmp (msec
->name
, look
) == 0)
4253 if (startswith (msec
->name
, GNU_LINKONCE_INFO
))
4260 /* Transfer VMAs from object file to separate debug file. */
4263 set_debug_vma (bfd
*orig_bfd
, bfd
*debug_bfd
)
4267 for (s
= orig_bfd
->sections
, d
= debug_bfd
->sections
;
4268 s
!= NULL
&& d
!= NULL
;
4269 s
= s
->next
, d
= d
->next
)
4271 if ((d
->flags
& SEC_DEBUGGING
) != 0)
4273 /* ??? Assumes 1-1 correspondence between sections in the
4275 if (strcmp (s
->name
, d
->name
) == 0)
4277 d
->output_section
= s
->output_section
;
4278 d
->output_offset
= s
->output_offset
;
4284 /* If the dwarf2 info was found in a separate debug file, return the
4285 debug file section corresponding to the section in the original file
4286 and the debug file symbols. */
4289 _bfd_dwarf2_stash_syms (struct dwarf2_debug
*stash
, bfd
*abfd
,
4290 asection
**sec
, asymbol
***syms
)
4292 if (stash
->f
.bfd_ptr
!= abfd
)
4298 *syms
= stash
->f
.syms
;
4302 for (s
= abfd
->sections
, d
= stash
->f
.bfd_ptr
->sections
;
4303 s
!= NULL
&& d
!= NULL
;
4304 s
= s
->next
, d
= d
->next
)
4306 if ((d
->flags
& SEC_DEBUGGING
) != 0)
4309 && strcmp (s
->name
, d
->name
) == 0)
4312 *syms
= stash
->f
.syms
;
4319 /* Unset vmas for adjusted sections in STASH. */
4322 unset_sections (struct dwarf2_debug
*stash
)
4325 struct adjusted_section
*p
;
4327 i
= stash
->adjusted_section_count
;
4328 p
= stash
->adjusted_sections
;
4329 for (; i
> 0; i
--, p
++)
4330 p
->section
->vma
= 0;
4333 /* Set VMAs for allocated and .debug_info sections in ORIG_BFD, a
4334 relocatable object file. VMAs are normally all zero in relocatable
4335 object files, so if we want to distinguish locations in sections by
4336 address we need to set VMAs so the sections do not overlap. We
4337 also set VMA on .debug_info so that when we have multiple
4338 .debug_info sections (or the linkonce variant) they also do not
4339 overlap. The multiple .debug_info sections make up a single
4340 logical section. ??? We should probably do the same for other
4344 place_sections (bfd
*orig_bfd
, struct dwarf2_debug
*stash
)
4347 struct adjusted_section
*p
;
4349 const char *debug_info_name
;
4351 if (stash
->adjusted_section_count
!= 0)
4353 i
= stash
->adjusted_section_count
;
4354 p
= stash
->adjusted_sections
;
4355 for (; i
> 0; i
--, p
++)
4356 p
->section
->vma
= p
->adj_vma
;
4360 debug_info_name
= stash
->debug_sections
[debug_info
].uncompressed_name
;
4367 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
4371 if ((sect
->output_section
!= NULL
4372 && sect
->output_section
!= sect
4373 && (sect
->flags
& SEC_DEBUGGING
) == 0)
4377 is_debug_info
= (strcmp (sect
->name
, debug_info_name
) == 0
4378 || startswith (sect
->name
, GNU_LINKONCE_INFO
));
4380 if (!((sect
->flags
& SEC_ALLOC
) != 0 && abfd
== orig_bfd
)
4386 if (abfd
== stash
->f
.bfd_ptr
)
4388 abfd
= stash
->f
.bfd_ptr
;
4392 stash
->adjusted_section_count
= -1;
4395 bfd_vma last_vma
= 0, last_dwarf
= 0;
4396 size_t amt
= i
* sizeof (struct adjusted_section
);
4398 p
= (struct adjusted_section
*) bfd_malloc (amt
);
4402 stash
->adjusted_sections
= p
;
4403 stash
->adjusted_section_count
= i
;
4410 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
4415 if ((sect
->output_section
!= NULL
4416 && sect
->output_section
!= sect
4417 && (sect
->flags
& SEC_DEBUGGING
) == 0)
4421 is_debug_info
= (strcmp (sect
->name
, debug_info_name
) == 0
4422 || startswith (sect
->name
, GNU_LINKONCE_INFO
));
4424 if (!((sect
->flags
& SEC_ALLOC
) != 0 && abfd
== orig_bfd
)
4428 sz
= sect
->rawsize
? sect
->rawsize
: sect
->size
;
4432 BFD_ASSERT (sect
->alignment_power
== 0);
4433 sect
->vma
= last_dwarf
;
4438 /* Align the new address to the current section
4440 last_vma
= ((last_vma
4441 + ~(-((bfd_vma
) 1 << sect
->alignment_power
)))
4442 & (-((bfd_vma
) 1 << sect
->alignment_power
)));
4443 sect
->vma
= last_vma
;
4448 p
->adj_vma
= sect
->vma
;
4451 if (abfd
== stash
->f
.bfd_ptr
)
4453 abfd
= stash
->f
.bfd_ptr
;
4457 if (orig_bfd
!= stash
->f
.bfd_ptr
)
4458 set_debug_vma (orig_bfd
, stash
->f
.bfd_ptr
);
4463 /* Look up a funcinfo by name using the given info hash table. If found,
4464 also update the locations pointed to by filename_ptr and linenumber_ptr.
4466 This function returns TRUE if a funcinfo that matches the given symbol
4467 and address is found with any error; otherwise it returns FALSE. */
4470 info_hash_lookup_funcinfo (struct info_hash_table
*hash_table
,
4473 const char **filename_ptr
,
4474 unsigned int *linenumber_ptr
)
4476 struct funcinfo
* each_func
;
4477 struct funcinfo
* best_fit
= NULL
;
4478 bfd_vma best_fit_len
= 0;
4479 struct info_list_node
*node
;
4480 struct arange
*arange
;
4481 const char *name
= bfd_asymbol_name (sym
);
4482 asection
*sec
= bfd_asymbol_section (sym
);
4484 for (node
= lookup_info_hash_table (hash_table
, name
);
4488 each_func
= (struct funcinfo
*) node
->info
;
4489 for (arange
= &each_func
->arange
;
4491 arange
= arange
->next
)
4493 if ((!each_func
->sec
|| each_func
->sec
== sec
)
4494 && addr
>= arange
->low
4495 && addr
< arange
->high
4497 || arange
->high
- arange
->low
< best_fit_len
))
4499 best_fit
= each_func
;
4500 best_fit_len
= arange
->high
- arange
->low
;
4507 best_fit
->sec
= sec
;
4508 *filename_ptr
= best_fit
->file
;
4509 *linenumber_ptr
= best_fit
->line
;
4516 /* Look up a varinfo by name using the given info hash table. If found,
4517 also update the locations pointed to by filename_ptr and linenumber_ptr.
4519 This function returns TRUE if a varinfo that matches the given symbol
4520 and address is found with any error; otherwise it returns FALSE. */
4523 info_hash_lookup_varinfo (struct info_hash_table
*hash_table
,
4526 const char **filename_ptr
,
4527 unsigned int *linenumber_ptr
)
4529 const char *name
= bfd_asymbol_name (sym
);
4530 asection
*sec
= bfd_asymbol_section (sym
);
4531 struct varinfo
* each
;
4532 struct info_list_node
*node
;
4534 for (node
= lookup_info_hash_table (hash_table
, name
);
4538 each
= (struct varinfo
*) node
->info
;
4539 if (each
->addr
== addr
4540 && (!each
->sec
|| each
->sec
== sec
))
4543 *filename_ptr
= each
->file
;
4544 *linenumber_ptr
= each
->line
;
4552 /* Update the funcinfo and varinfo info hash tables if they are
4553 not up to date. Returns TRUE if there is no error; otherwise
4554 returns FALSE and disable the info hash tables. */
4557 stash_maybe_update_info_hash_tables (struct dwarf2_debug
*stash
)
4559 struct comp_unit
*each
;
4561 /* Exit if hash tables are up-to-date. */
4562 if (stash
->f
.all_comp_units
== stash
->hash_units_head
)
4565 if (stash
->hash_units_head
)
4566 each
= stash
->hash_units_head
->prev_unit
;
4568 each
= stash
->f
.last_comp_unit
;
4572 if (!comp_unit_hash_info (stash
, each
, stash
->funcinfo_hash_table
,
4573 stash
->varinfo_hash_table
))
4575 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
4578 each
= each
->prev_unit
;
4581 stash
->hash_units_head
= stash
->f
.all_comp_units
;
4585 /* Check consistency of info hash tables. This is for debugging only. */
4587 static void ATTRIBUTE_UNUSED
4588 stash_verify_info_hash_table (struct dwarf2_debug
*stash
)
4590 struct comp_unit
*each_unit
;
4591 struct funcinfo
*each_func
;
4592 struct varinfo
*each_var
;
4593 struct info_list_node
*node
;
4596 for (each_unit
= stash
->f
.all_comp_units
;
4598 each_unit
= each_unit
->next_unit
)
4600 for (each_func
= each_unit
->function_table
;
4602 each_func
= each_func
->prev_func
)
4604 if (!each_func
->name
)
4606 node
= lookup_info_hash_table (stash
->funcinfo_hash_table
,
4610 while (node
&& !found
)
4612 found
= node
->info
== each_func
;
4618 for (each_var
= each_unit
->variable_table
;
4620 each_var
= each_var
->prev_var
)
4622 if (!each_var
->name
|| !each_var
->file
|| each_var
->stack
)
4624 node
= lookup_info_hash_table (stash
->varinfo_hash_table
,
4628 while (node
&& !found
)
4630 found
= node
->info
== each_var
;
4638 /* Check to see if we want to enable the info hash tables, which consume
4639 quite a bit of memory. Currently we only check the number times
4640 bfd_dwarf2_find_line is called. In the future, we may also want to
4641 take the number of symbols into account. */
4644 stash_maybe_enable_info_hash_tables (bfd
*abfd
, struct dwarf2_debug
*stash
)
4646 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_OFF
);
4648 if (stash
->info_hash_count
++ < STASH_INFO_HASH_TRIGGER
)
4651 /* FIXME: Maybe we should check the reduce_memory_overheads
4652 and optimize fields in the bfd_link_info structure ? */
4654 /* Create hash tables. */
4655 stash
->funcinfo_hash_table
= create_info_hash_table (abfd
);
4656 stash
->varinfo_hash_table
= create_info_hash_table (abfd
);
4657 if (!stash
->funcinfo_hash_table
|| !stash
->varinfo_hash_table
)
4659 /* Turn off info hashes if any allocation above fails. */
4660 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
4663 /* We need a forced update so that the info hash tables will
4664 be created even though there is no compilation unit. That
4665 happens if STASH_INFO_HASH_TRIGGER is 0. */
4666 if (stash_maybe_update_info_hash_tables (stash
))
4667 stash
->info_hash_status
= STASH_INFO_HASH_ON
;
4670 /* Find the file and line associated with a symbol and address using the
4671 info hash tables of a stash. If there is a match, the function returns
4672 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
4673 otherwise it returns FALSE. */
4676 stash_find_line_fast (struct dwarf2_debug
*stash
,
4679 const char **filename_ptr
,
4680 unsigned int *linenumber_ptr
)
4682 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_ON
);
4684 if (sym
->flags
& BSF_FUNCTION
)
4685 return info_hash_lookup_funcinfo (stash
->funcinfo_hash_table
, sym
, addr
,
4686 filename_ptr
, linenumber_ptr
);
4687 return info_hash_lookup_varinfo (stash
->varinfo_hash_table
, sym
, addr
,
4688 filename_ptr
, linenumber_ptr
);
4691 /* Save current section VMAs. */
4694 save_section_vma (const bfd
*abfd
, struct dwarf2_debug
*stash
)
4699 if (abfd
->section_count
== 0)
4701 stash
->sec_vma
= bfd_malloc (sizeof (*stash
->sec_vma
) * abfd
->section_count
);
4702 if (stash
->sec_vma
== NULL
)
4704 stash
->sec_vma_count
= abfd
->section_count
;
4705 for (i
= 0, s
= abfd
->sections
;
4706 s
!= NULL
&& i
< abfd
->section_count
;
4709 if (s
->output_section
!= NULL
)
4710 stash
->sec_vma
[i
] = s
->output_section
->vma
+ s
->output_offset
;
4712 stash
->sec_vma
[i
] = s
->vma
;
4717 /* Compare current section VMAs against those at the time the stash
4718 was created. If find_nearest_line is used in linker warnings or
4719 errors early in the link process, the debug info stash will be
4720 invalid for later calls. This is because we relocate debug info
4721 sections, so the stashed section contents depend on symbol values,
4722 which in turn depend on section VMAs. */
4725 section_vma_same (const bfd
*abfd
, const struct dwarf2_debug
*stash
)
4730 /* PR 24334: If the number of sections in ABFD has changed between
4731 when the stash was created and now, then we cannot trust the
4732 stashed vma information. */
4733 if (abfd
->section_count
!= stash
->sec_vma_count
)
4736 for (i
= 0, s
= abfd
->sections
;
4737 s
!= NULL
&& i
< abfd
->section_count
;
4742 if (s
->output_section
!= NULL
)
4743 vma
= s
->output_section
->vma
+ s
->output_offset
;
4746 if (vma
!= stash
->sec_vma
[i
])
4752 /* Read debug information from DEBUG_BFD when DEBUG_BFD is specified.
4753 If DEBUG_BFD is not specified, we read debug information from ABFD
4754 or its gnu_debuglink. The results will be stored in PINFO.
4755 The function returns TRUE iff debug information is ready. */
4758 _bfd_dwarf2_slurp_debug_info (bfd
*abfd
, bfd
*debug_bfd
,
4759 const struct dwarf_debug_section
*debug_sections
,
4764 size_t amt
= sizeof (struct dwarf2_debug
);
4765 bfd_size_type total_size
;
4767 struct dwarf2_debug
*stash
= (struct dwarf2_debug
*) *pinfo
;
4771 if (stash
->orig_bfd
== abfd
4772 && section_vma_same (abfd
, stash
))
4774 /* Check that we did previously find some debug information
4775 before attempting to make use of it. */
4776 if (stash
->f
.bfd_ptr
!= NULL
)
4778 if (do_place
&& !place_sections (abfd
, stash
))
4785 _bfd_dwarf2_cleanup_debug_info (abfd
, pinfo
);
4786 memset (stash
, 0, amt
);
4790 stash
= (struct dwarf2_debug
*) bfd_zalloc (abfd
, amt
);
4794 stash
->orig_bfd
= abfd
;
4795 stash
->debug_sections
= debug_sections
;
4796 stash
->f
.syms
= symbols
;
4797 if (!save_section_vma (abfd
, stash
))
4800 stash
->f
.abbrev_offsets
= htab_create_alloc (10, hash_abbrev
, eq_abbrev
,
4801 del_abbrev
, calloc
, free
);
4802 if (!stash
->f
.abbrev_offsets
)
4805 stash
->alt
.abbrev_offsets
= htab_create_alloc (10, hash_abbrev
, eq_abbrev
,
4806 del_abbrev
, calloc
, free
);
4807 if (!stash
->alt
.abbrev_offsets
)
4812 if (debug_bfd
== NULL
)
4815 msec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
4816 if (msec
== NULL
&& abfd
== debug_bfd
)
4818 char * debug_filename
;
4820 debug_filename
= bfd_follow_build_id_debuglink (abfd
, DEBUGDIR
);
4821 if (debug_filename
== NULL
)
4822 debug_filename
= bfd_follow_gnu_debuglink (abfd
, DEBUGDIR
);
4824 if (debug_filename
== NULL
)
4825 /* No dwarf2 info, and no gnu_debuglink to follow.
4826 Note that at this point the stash has been allocated, but
4827 contains zeros. This lets future calls to this function
4828 fail more quickly. */
4831 debug_bfd
= bfd_openr (debug_filename
, NULL
);
4832 free (debug_filename
);
4833 if (debug_bfd
== NULL
)
4834 /* FIXME: Should we report our failure to follow the debuglink ? */
4837 /* Set BFD_DECOMPRESS to decompress debug sections. */
4838 debug_bfd
->flags
|= BFD_DECOMPRESS
;
4839 if (!bfd_check_format (debug_bfd
, bfd_object
)
4840 || (msec
= find_debug_info (debug_bfd
,
4841 debug_sections
, NULL
)) == NULL
4842 || !bfd_generic_link_read_symbols (debug_bfd
))
4844 bfd_close (debug_bfd
);
4848 symbols
= bfd_get_outsymbols (debug_bfd
);
4849 stash
->f
.syms
= symbols
;
4850 stash
->close_on_cleanup
= true;
4852 stash
->f
.bfd_ptr
= debug_bfd
;
4855 && !place_sections (abfd
, stash
))
4858 /* There can be more than one DWARF2 info section in a BFD these
4859 days. First handle the easy case when there's only one. If
4860 there's more than one, try case two: none of the sections is
4861 compressed. In that case, read them all in and produce one
4862 large stash. We do this in two passes - in the first pass we
4863 just accumulate the section sizes, and in the second pass we
4864 read in the section's contents. (The allows us to avoid
4865 reallocing the data as we add sections to the stash.) If
4866 some or all sections are compressed, then do things the slow
4867 way, with a bunch of reallocs. */
4869 if (! find_debug_info (debug_bfd
, debug_sections
, msec
))
4871 /* Case 1: only one info section. */
4872 total_size
= msec
->size
;
4873 if (! read_section (debug_bfd
, &stash
->debug_sections
[debug_info
],
4875 &stash
->f
.dwarf_info_buffer
, &total_size
))
4880 /* Case 2: multiple sections. */
4881 for (total_size
= 0;
4883 msec
= find_debug_info (debug_bfd
, debug_sections
, msec
))
4885 /* Catch PR25070 testcase overflowing size calculation here. */
4886 if (total_size
+ msec
->size
< total_size
4887 || total_size
+ msec
->size
< msec
->size
)
4889 bfd_set_error (bfd_error_no_memory
);
4892 total_size
+= msec
->size
;
4895 stash
->f
.dwarf_info_buffer
= (bfd_byte
*) bfd_malloc (total_size
);
4896 if (stash
->f
.dwarf_info_buffer
== NULL
)
4900 for (msec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
4902 msec
= find_debug_info (debug_bfd
, debug_sections
, msec
))
4910 if (!(bfd_simple_get_relocated_section_contents
4911 (debug_bfd
, msec
, stash
->f
.dwarf_info_buffer
+ total_size
,
4919 stash
->f
.info_ptr
= stash
->f
.dwarf_info_buffer
;
4920 stash
->f
.dwarf_info_size
= total_size
;
4924 /* Parse the next DWARF2 compilation unit at FILE->INFO_PTR. */
4926 static struct comp_unit
*
4927 stash_comp_unit (struct dwarf2_debug
*stash
, struct dwarf2_debug_file
*file
)
4929 bfd_size_type length
;
4930 unsigned int offset_size
;
4931 bfd_byte
*info_ptr_unit
= file
->info_ptr
;
4932 bfd_byte
*info_ptr_end
= file
->dwarf_info_buffer
+ file
->dwarf_info_size
;
4934 if (file
->info_ptr
>= info_ptr_end
)
4937 length
= read_4_bytes (file
->bfd_ptr
, file
->info_ptr
, info_ptr_end
);
4938 /* A 0xffffff length is the DWARF3 way of indicating
4939 we use 64-bit offsets, instead of 32-bit offsets. */
4940 if (length
== 0xffffffff)
4943 length
= read_8_bytes (file
->bfd_ptr
, file
->info_ptr
+ 4,
4945 file
->info_ptr
+= 12;
4947 /* A zero length is the IRIX way of indicating 64-bit offsets,
4948 mostly because the 64-bit length will generally fit in 32
4949 bits, and the endianness helps. */
4950 else if (length
== 0)
4953 length
= read_4_bytes (file
->bfd_ptr
, file
->info_ptr
+ 4,
4955 file
->info_ptr
+= 8;
4957 /* In the absence of the hints above, we assume 32-bit DWARF2
4958 offsets even for targets with 64-bit addresses, because:
4959 a) most of the time these targets will not have generated
4960 more than 2Gb of debug info and so will not need 64-bit
4963 b) if they do use 64-bit offsets but they are not using
4964 the size hints that are tested for above then they are
4965 not conforming to the DWARF3 standard anyway. */
4969 file
->info_ptr
+= 4;
4973 && file
->info_ptr
+ length
<= info_ptr_end
4974 && file
->info_ptr
+ length
> file
->info_ptr
)
4976 struct comp_unit
*each
= parse_comp_unit (stash
, file
,
4977 file
->info_ptr
, length
,
4978 info_ptr_unit
, offset_size
);
4981 if (file
->all_comp_units
)
4982 file
->all_comp_units
->prev_unit
= each
;
4984 file
->last_comp_unit
= each
;
4986 each
->next_unit
= file
->all_comp_units
;
4987 file
->all_comp_units
= each
;
4989 file
->info_ptr
+= length
;
4994 /* Don't trust any of the DWARF info after a corrupted length or
4996 file
->info_ptr
= info_ptr_end
;
5000 /* Hash function for an asymbol. */
5003 hash_asymbol (const void *sym
)
5005 const asymbol
*asym
= sym
;
5006 return htab_hash_string (asym
->name
);
5009 /* Equality function for asymbols. */
5012 eq_asymbol (const void *a
, const void *b
)
5014 const asymbol
*sa
= a
;
5015 const asymbol
*sb
= b
;
5016 return strcmp (sa
->name
, sb
->name
) == 0;
5019 /* Scan the debug information in PINFO looking for a DW_TAG_subprogram
5020 abbrev with a DW_AT_low_pc attached to it. Then lookup that same
5021 symbol in SYMBOLS and return the difference between the low_pc and
5022 the symbol's address. Returns 0 if no suitable symbol could be found. */
5025 _bfd_dwarf2_find_symbol_bias (asymbol
** symbols
, void ** pinfo
)
5027 struct dwarf2_debug
*stash
;
5028 struct comp_unit
* unit
;
5030 bfd_signed_vma result
= 0;
5033 stash
= (struct dwarf2_debug
*) *pinfo
;
5035 if (stash
== NULL
|| symbols
== NULL
)
5038 sym_hash
= htab_create_alloc (10, hash_asymbol
, eq_asymbol
,
5039 NULL
, xcalloc
, free
);
5040 for (psym
= symbols
; * psym
!= NULL
; psym
++)
5042 asymbol
* sym
= * psym
;
5044 if (sym
->flags
& BSF_FUNCTION
&& sym
->section
!= NULL
)
5046 void **slot
= htab_find_slot (sym_hash
, sym
, INSERT
);
5051 for (unit
= stash
->f
.all_comp_units
; unit
; unit
= unit
->next_unit
)
5053 struct funcinfo
* func
;
5055 comp_unit_maybe_decode_line_info (unit
);
5057 for (func
= unit
->function_table
; func
!= NULL
; func
= func
->prev_func
)
5058 if (func
->name
&& func
->arange
.low
)
5060 asymbol search
, *sym
;
5062 /* FIXME: Do we need to scan the aranges looking for the lowest pc value ? */
5064 search
.name
= func
->name
;
5065 sym
= htab_find (sym_hash
, &search
);
5068 result
= ((bfd_signed_vma
) func
->arange
.low
) -
5069 ((bfd_signed_vma
) (sym
->value
+ sym
->section
->vma
));
5076 htab_delete (sym_hash
);
5080 /* Find the source code location of SYMBOL. If SYMBOL is NULL
5081 then find the nearest source code location corresponding to
5082 the address SECTION + OFFSET.
5083 Returns 1 if the line is found without error and fills in
5084 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
5085 NULL the FUNCTIONNAME_PTR is also filled in.
5086 Returns 2 if partial information from _bfd_elf_find_function is
5087 returned (function and maybe file) by looking at symbols. DWARF2
5088 info is present but not regarding the requested code location.
5089 Returns 0 otherwise.
5090 SYMBOLS contains the symbol table for ABFD.
5091 DEBUG_SECTIONS contains the name of the dwarf debug sections. */
5094 _bfd_dwarf2_find_nearest_line (bfd
*abfd
,
5099 const char **filename_ptr
,
5100 const char **functionname_ptr
,
5101 unsigned int *linenumber_ptr
,
5102 unsigned int *discriminator_ptr
,
5103 const struct dwarf_debug_section
*debug_sections
,
5106 /* Read each compilation unit from the section .debug_info, and check
5107 to see if it contains the address we are searching for. If yes,
5108 lookup the address, and return the line number info. If no, go
5109 on to the next compilation unit.
5111 We keep a list of all the previously read compilation units, and
5112 a pointer to the next un-read compilation unit. Check the
5113 previously read units before reading more. */
5114 struct dwarf2_debug
*stash
;
5115 /* What address are we looking for? */
5117 struct comp_unit
* each
;
5118 struct funcinfo
*function
= NULL
;
5122 *filename_ptr
= NULL
;
5123 if (functionname_ptr
!= NULL
)
5124 *functionname_ptr
= NULL
;
5125 *linenumber_ptr
= 0;
5126 if (discriminator_ptr
)
5127 *discriminator_ptr
= 0;
5129 if (! _bfd_dwarf2_slurp_debug_info (abfd
, NULL
, debug_sections
,
5131 (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0))
5134 stash
= (struct dwarf2_debug
*) *pinfo
;
5136 do_line
= symbol
!= NULL
;
5139 BFD_ASSERT (section
== NULL
&& offset
== 0 && functionname_ptr
== NULL
);
5140 section
= bfd_asymbol_section (symbol
);
5141 addr
= symbol
->value
;
5145 BFD_ASSERT (section
!= NULL
&& functionname_ptr
!= NULL
);
5148 /* If we have no SYMBOL but the section we're looking at is not a
5149 code section, then take a look through the list of symbols to see
5150 if we have a symbol at the address we're looking for. If we do
5151 then use this to look up line information. This will allow us to
5152 give file and line results for data symbols. We exclude code
5153 symbols here, if we look up a function symbol and then look up the
5154 line information we'll actually return the line number for the
5155 opening '{' rather than the function definition line. This is
5156 because looking up by symbol uses the line table, in which the
5157 first line for a function is usually the opening '{', while
5158 looking up the function by section + offset uses the
5159 DW_AT_decl_line from the function DW_TAG_subprogram for the line,
5160 which will be the line of the function name. */
5161 if (symbols
!= NULL
&& (section
->flags
& SEC_CODE
) == 0)
5165 for (tmp
= symbols
; (*tmp
) != NULL
; ++tmp
)
5166 if ((*tmp
)->the_bfd
== abfd
5167 && (*tmp
)->section
== section
5168 && (*tmp
)->value
== offset
5169 && ((*tmp
)->flags
& BSF_SECTION_SYM
) == 0)
5173 /* For local symbols, keep going in the hope we find a
5175 if ((symbol
->flags
& BSF_GLOBAL
) != 0)
5181 if (section
->output_section
)
5182 addr
+= section
->output_section
->vma
+ section
->output_offset
;
5184 addr
+= section
->vma
;
5186 /* A null info_ptr indicates that there is no dwarf2 info
5187 (or that an error occured while setting up the stash). */
5188 if (! stash
->f
.info_ptr
)
5191 stash
->inliner_chain
= NULL
;
5193 /* Check the previously read comp. units first. */
5196 /* The info hash tables use quite a bit of memory. We may not want to
5197 always use them. We use some heuristics to decide if and when to
5199 if (stash
->info_hash_status
== STASH_INFO_HASH_OFF
)
5200 stash_maybe_enable_info_hash_tables (abfd
, stash
);
5202 /* Keep info hash table up to date if they are available. Note that we
5203 may disable the hash tables if there is any error duing update. */
5204 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
5205 stash_maybe_update_info_hash_tables (stash
);
5207 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
5209 found
= stash_find_line_fast (stash
, symbol
, addr
, filename_ptr
,
5216 /* Check the previously read comp. units first. */
5217 for (each
= stash
->f
.all_comp_units
; each
; each
= each
->next_unit
)
5218 if ((symbol
->flags
& BSF_FUNCTION
) == 0
5219 || each
->arange
.high
== 0
5220 || comp_unit_contains_address (each
, addr
))
5222 found
= comp_unit_find_line (each
, symbol
, addr
, filename_ptr
,
5231 bfd_vma min_range
= (bfd_vma
) -1;
5232 const char * local_filename
= NULL
;
5233 struct funcinfo
*local_function
= NULL
;
5234 unsigned int local_linenumber
= 0;
5235 unsigned int local_discriminator
= 0;
5237 for (each
= stash
->f
.all_comp_units
; each
; each
= each
->next_unit
)
5239 bfd_vma range
= (bfd_vma
) -1;
5241 found
= ((each
->arange
.high
== 0
5242 || comp_unit_contains_address (each
, addr
))
5243 && (range
= (comp_unit_find_nearest_line
5244 (each
, addr
, &local_filename
,
5245 &local_function
, &local_linenumber
,
5246 &local_discriminator
))) != 0);
5249 /* PRs 15935 15994: Bogus debug information may have provided us
5250 with an erroneous match. We attempt to counter this by
5251 selecting the match that has the smallest address range
5252 associated with it. (We are assuming that corrupt debug info
5253 will tend to result in extra large address ranges rather than
5254 extra small ranges).
5256 This does mean that we scan through all of the CUs associated
5257 with the bfd each time this function is called. But this does
5258 have the benefit of producing consistent results every time the
5259 function is called. */
5260 if (range
<= min_range
)
5262 if (filename_ptr
&& local_filename
)
5263 * filename_ptr
= local_filename
;
5265 function
= local_function
;
5266 if (discriminator_ptr
&& local_discriminator
)
5267 * discriminator_ptr
= local_discriminator
;
5268 if (local_linenumber
)
5269 * linenumber_ptr
= local_linenumber
;
5275 if (* linenumber_ptr
)
5282 /* Read each remaining comp. units checking each as they are read. */
5283 while ((each
= stash_comp_unit (stash
, &stash
->f
)) != NULL
)
5285 /* DW_AT_low_pc and DW_AT_high_pc are optional for
5286 compilation units. If we don't have them (i.e.,
5287 unit->high == 0), we need to consult the line info table
5288 to see if a compilation unit contains the given
5291 found
= (((symbol
->flags
& BSF_FUNCTION
) == 0
5292 || each
->arange
.high
== 0
5293 || comp_unit_contains_address (each
, addr
))
5294 && comp_unit_find_line (each
, symbol
, addr
,
5295 filename_ptr
, linenumber_ptr
));
5297 found
= ((each
->arange
.high
== 0
5298 || comp_unit_contains_address (each
, addr
))
5299 && comp_unit_find_nearest_line (each
, addr
,
5303 discriminator_ptr
) != 0);
5310 if (functionname_ptr
&& function
&& function
->is_linkage
)
5311 *functionname_ptr
= function
->name
;
5312 else if (functionname_ptr
5313 && (!*functionname_ptr
5314 || (function
&& !function
->is_linkage
)))
5317 asymbol
**syms
= symbols
;
5318 asection
*sec
= section
;
5320 _bfd_dwarf2_stash_syms (stash
, abfd
, &sec
, &syms
);
5321 fun
= _bfd_elf_find_function (abfd
, syms
, sec
, offset
,
5322 *filename_ptr
? NULL
: filename_ptr
,
5325 if (!found
&& fun
!= NULL
)
5328 if (function
&& !function
->is_linkage
)
5332 sec_vma
= section
->vma
;
5333 if (section
->output_section
!= NULL
)
5334 sec_vma
= section
->output_section
->vma
+ section
->output_offset
;
5336 && fun
->value
+ sec_vma
== function
->arange
.low
)
5337 function
->name
= *functionname_ptr
;
5338 /* Even if we didn't find a linkage name, say that we have
5339 to stop a repeated search of symbols. */
5340 function
->is_linkage
= true;
5344 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
5345 unset_sections (stash
);
5351 _bfd_dwarf2_find_inliner_info (bfd
*abfd ATTRIBUTE_UNUSED
,
5352 const char **filename_ptr
,
5353 const char **functionname_ptr
,
5354 unsigned int *linenumber_ptr
,
5357 struct dwarf2_debug
*stash
;
5359 stash
= (struct dwarf2_debug
*) *pinfo
;
5362 struct funcinfo
*func
= stash
->inliner_chain
;
5364 if (func
&& func
->caller_func
)
5366 *filename_ptr
= func
->caller_file
;
5367 *functionname_ptr
= func
->caller_func
->name
;
5368 *linenumber_ptr
= func
->caller_line
;
5369 stash
->inliner_chain
= func
->caller_func
;
5378 _bfd_dwarf2_cleanup_debug_info (bfd
*abfd
, void **pinfo
)
5380 struct dwarf2_debug
*stash
= (struct dwarf2_debug
*) *pinfo
;
5381 struct comp_unit
*each
;
5382 struct dwarf2_debug_file
*file
;
5384 if (abfd
== NULL
|| stash
== NULL
)
5387 if (stash
->varinfo_hash_table
)
5388 bfd_hash_table_free (&stash
->varinfo_hash_table
->base
);
5389 if (stash
->funcinfo_hash_table
)
5390 bfd_hash_table_free (&stash
->funcinfo_hash_table
->base
);
5395 for (each
= file
->all_comp_units
; each
; each
= each
->next_unit
)
5397 struct funcinfo
*function_table
= each
->function_table
;
5398 struct varinfo
*variable_table
= each
->variable_table
;
5400 if (each
->line_table
&& each
->line_table
!= file
->line_table
)
5402 free (each
->line_table
->files
);
5403 free (each
->line_table
->dirs
);
5406 free (each
->lookup_funcinfo_table
);
5407 each
->lookup_funcinfo_table
= NULL
;
5409 while (function_table
)
5411 free (function_table
->file
);
5412 function_table
->file
= NULL
;
5413 free (function_table
->caller_file
);
5414 function_table
->caller_file
= NULL
;
5415 function_table
= function_table
->prev_func
;
5418 while (variable_table
)
5420 free (variable_table
->file
);
5421 variable_table
->file
= NULL
;
5422 variable_table
= variable_table
->prev_var
;
5426 if (file
->line_table
)
5428 free (file
->line_table
->files
);
5429 free (file
->line_table
->dirs
);
5431 htab_delete (file
->abbrev_offsets
);
5433 free (file
->dwarf_line_str_buffer
);
5434 free (file
->dwarf_str_buffer
);
5435 free (file
->dwarf_ranges_buffer
);
5436 free (file
->dwarf_line_buffer
);
5437 free (file
->dwarf_abbrev_buffer
);
5438 free (file
->dwarf_info_buffer
);
5439 if (file
== &stash
->alt
)
5443 free (stash
->sec_vma
);
5444 free (stash
->adjusted_sections
);
5445 if (stash
->close_on_cleanup
)
5446 bfd_close (stash
->f
.bfd_ptr
);
5447 if (stash
->alt
.bfd_ptr
)
5448 bfd_close (stash
->alt
.bfd_ptr
);
5451 /* Find the function to a particular section and offset,
5452 for error reporting. */
5455 _bfd_elf_find_function (bfd
*abfd
,
5459 const char **filename_ptr
,
5460 const char **functionname_ptr
)
5462 struct elf_find_function_cache
5464 asection
*last_section
;
5466 const char *filename
;
5467 bfd_size_type func_size
;
5470 if (symbols
== NULL
)
5473 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
5476 cache
= elf_tdata (abfd
)->elf_find_function_cache
;
5479 cache
= bfd_zalloc (abfd
, sizeof (*cache
));
5480 elf_tdata (abfd
)->elf_find_function_cache
= cache
;
5484 if (cache
->last_section
!= section
5485 || cache
->func
== NULL
5486 || offset
< cache
->func
->value
5487 || offset
>= cache
->func
->value
+ cache
->func_size
)
5492 /* ??? Given multiple file symbols, it is impossible to reliably
5493 choose the right file name for global symbols. File symbols are
5494 local symbols, and thus all file symbols must sort before any
5495 global symbols. The ELF spec may be interpreted to say that a
5496 file symbol must sort before other local symbols, but currently
5497 ld -r doesn't do this. So, for ld -r output, it is possible to
5498 make a better choice of file name for local symbols by ignoring
5499 file symbols appearing after a given local symbol. */
5500 enum { nothing_seen
, symbol_seen
, file_after_symbol_seen
} state
;
5501 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5505 state
= nothing_seen
;
5506 cache
->filename
= NULL
;
5508 cache
->func_size
= 0;
5509 cache
->last_section
= section
;
5511 for (p
= symbols
; *p
!= NULL
; p
++)
5517 if ((sym
->flags
& BSF_FILE
) != 0)
5520 if (state
== symbol_seen
)
5521 state
= file_after_symbol_seen
;
5525 size
= bed
->maybe_function_sym (sym
, section
, &code_off
);
5527 && code_off
<= offset
5528 && (code_off
> low_func
5529 || (code_off
== low_func
5530 && size
> cache
->func_size
)))
5533 cache
->func_size
= size
;
5534 cache
->filename
= NULL
;
5535 low_func
= code_off
;
5537 && ((sym
->flags
& BSF_LOCAL
) != 0
5538 || state
!= file_after_symbol_seen
))
5539 cache
->filename
= bfd_asymbol_name (file
);
5541 if (state
== nothing_seen
)
5542 state
= symbol_seen
;
5546 if (cache
->func
== NULL
)
5550 *filename_ptr
= cache
->filename
;
5551 if (functionname_ptr
)
5552 *functionname_ptr
= bfd_asymbol_name (cache
->func
);