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 bfd_boolean 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 bfd_boolean 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. */
1160 static inline bfd_boolean
1161 is_str_attr (enum dwarf_form form
)
1163 return (form
== DW_FORM_string
|| form
== DW_FORM_strp
1164 || form
== DW_FORM_line_strp
|| form
== DW_FORM_GNU_strp_alt
);
1167 /* Read and fill in the value of attribute ATTR as described by FORM.
1168 Read data starting from INFO_PTR, but never at or beyond INFO_PTR_END.
1169 Returns an updated INFO_PTR taking into account the amount of data read. */
1172 read_attribute_value (struct attribute
* attr
,
1174 bfd_vma implicit_const
,
1175 struct comp_unit
* unit
,
1176 bfd_byte
* info_ptr
,
1177 bfd_byte
* info_ptr_end
)
1179 bfd
*abfd
= unit
->abfd
;
1180 unsigned int bytes_read
;
1181 struct dwarf_block
*blk
;
1184 if (info_ptr
>= info_ptr_end
&& form
!= DW_FORM_flag_present
)
1186 _bfd_error_handler (_("DWARF error: info pointer extends beyond end of attributes"));
1187 bfd_set_error (bfd_error_bad_value
);
1191 attr
->form
= (enum dwarf_form
) form
;
1195 case DW_FORM_ref_addr
:
1196 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
1198 if (unit
->version
== 3 || unit
->version
== 4)
1200 if (unit
->offset_size
== 4)
1201 attr
->u
.val
= read_4_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1203 attr
->u
.val
= read_8_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1204 info_ptr
+= unit
->offset_size
;
1209 attr
->u
.val
= read_address (unit
, info_ptr
, info_ptr_end
);
1210 info_ptr
+= unit
->addr_size
;
1212 case DW_FORM_GNU_ref_alt
:
1213 case DW_FORM_sec_offset
:
1214 if (unit
->offset_size
== 4)
1215 attr
->u
.val
= read_4_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1217 attr
->u
.val
= read_8_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1218 info_ptr
+= unit
->offset_size
;
1220 case DW_FORM_block2
:
1221 amt
= sizeof (struct dwarf_block
);
1222 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1225 blk
->size
= read_2_bytes (abfd
, info_ptr
, info_ptr_end
);
1227 info_ptr
= read_n_bytes (info_ptr
, info_ptr_end
, blk
);
1230 case DW_FORM_block4
:
1231 amt
= sizeof (struct dwarf_block
);
1232 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1235 blk
->size
= read_4_bytes (abfd
, info_ptr
, info_ptr_end
);
1237 info_ptr
= read_n_bytes (info_ptr
, info_ptr_end
, blk
);
1241 attr
->u
.val
= read_2_bytes (abfd
, info_ptr
, info_ptr_end
);
1245 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
, info_ptr_end
);
1249 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
, info_ptr_end
);
1252 case DW_FORM_string
:
1253 attr
->u
.str
= read_string (abfd
, info_ptr
, info_ptr_end
, &bytes_read
);
1254 info_ptr
+= bytes_read
;
1257 attr
->u
.str
= read_indirect_string (unit
, info_ptr
, info_ptr_end
, &bytes_read
);
1258 info_ptr
+= bytes_read
;
1260 case DW_FORM_line_strp
:
1261 attr
->u
.str
= read_indirect_line_string (unit
, info_ptr
, info_ptr_end
, &bytes_read
);
1262 info_ptr
+= bytes_read
;
1264 case DW_FORM_GNU_strp_alt
:
1265 attr
->u
.str
= read_alt_indirect_string (unit
, info_ptr
, info_ptr_end
, &bytes_read
);
1266 info_ptr
+= bytes_read
;
1268 case DW_FORM_exprloc
:
1270 amt
= sizeof (struct dwarf_block
);
1271 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1274 blk
->size
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1275 FALSE
, info_ptr_end
);
1276 info_ptr
+= bytes_read
;
1277 info_ptr
= read_n_bytes (info_ptr
, info_ptr_end
, blk
);
1280 case DW_FORM_block1
:
1281 amt
= sizeof (struct dwarf_block
);
1282 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1285 blk
->size
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1287 info_ptr
= read_n_bytes (info_ptr
, info_ptr_end
, blk
);
1291 attr
->u
.val
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1295 attr
->u
.val
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1298 case DW_FORM_flag_present
:
1302 attr
->u
.sval
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1303 TRUE
, info_ptr_end
);
1304 info_ptr
+= bytes_read
;
1307 attr
->u
.val
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1308 FALSE
, info_ptr_end
);
1309 info_ptr
+= bytes_read
;
1312 attr
->u
.val
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1316 attr
->u
.val
= read_2_bytes (abfd
, info_ptr
, info_ptr_end
);
1320 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
, info_ptr_end
);
1324 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
, info_ptr_end
);
1327 case DW_FORM_ref_sig8
:
1328 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
, info_ptr_end
);
1331 case DW_FORM_ref_udata
:
1332 attr
->u
.val
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1333 FALSE
, info_ptr_end
);
1334 info_ptr
+= bytes_read
;
1336 case DW_FORM_indirect
:
1337 form
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1338 FALSE
, info_ptr_end
);
1339 info_ptr
+= bytes_read
;
1340 if (form
== DW_FORM_implicit_const
)
1342 implicit_const
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1343 TRUE
, info_ptr_end
);
1344 info_ptr
+= bytes_read
;
1346 info_ptr
= read_attribute_value (attr
, form
, implicit_const
, unit
,
1347 info_ptr
, info_ptr_end
);
1349 case DW_FORM_implicit_const
:
1350 attr
->form
= DW_FORM_sdata
;
1351 attr
->u
.sval
= implicit_const
;
1353 case DW_FORM_data16
:
1354 /* This is really a "constant", but there is no way to store that
1355 so pretend it is a 16 byte block instead. */
1356 amt
= sizeof (struct dwarf_block
);
1357 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1361 info_ptr
= read_n_bytes (info_ptr
, info_ptr_end
, blk
);
1365 _bfd_error_handler (_("DWARF error: invalid or unhandled FORM value: %#x"),
1367 bfd_set_error (bfd_error_bad_value
);
1373 /* Read an attribute described by an abbreviated attribute. */
1376 read_attribute (struct attribute
* attr
,
1377 struct attr_abbrev
* abbrev
,
1378 struct comp_unit
* unit
,
1379 bfd_byte
* info_ptr
,
1380 bfd_byte
* info_ptr_end
)
1382 attr
->name
= abbrev
->name
;
1383 info_ptr
= read_attribute_value (attr
, abbrev
->form
, abbrev
->implicit_const
,
1384 unit
, info_ptr
, info_ptr_end
);
1388 /* Return whether DW_AT_name will return the same as DW_AT_linkage_name
1392 non_mangled (int lang
)
1402 case DW_LANG_Cobol74
:
1403 case DW_LANG_Cobol85
:
1404 case DW_LANG_Fortran77
:
1405 case DW_LANG_Pascal83
:
1415 /* Source line information table routines. */
1417 #define FILE_ALLOC_CHUNK 5
1418 #define DIR_ALLOC_CHUNK 5
1422 struct line_info
* prev_line
;
1426 unsigned int column
;
1427 unsigned int discriminator
;
1428 unsigned char op_index
;
1429 unsigned char end_sequence
; /* End of (sequential) code sequence. */
1440 struct line_sequence
1443 struct line_sequence
* prev_sequence
;
1444 struct line_info
* last_line
; /* Largest VMA. */
1445 struct line_info
** line_info_lookup
;
1446 bfd_size_type num_lines
;
1449 struct line_info_table
1452 unsigned int num_files
;
1453 unsigned int num_dirs
;
1454 unsigned int num_sequences
;
1457 struct fileinfo
* files
;
1458 struct line_sequence
* sequences
;
1459 struct line_info
* lcl_head
; /* Local head; used in 'add_line_info'. */
1462 /* Remember some information about each function. If the function is
1463 inlined (DW_TAG_inlined_subroutine) it may have two additional
1464 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
1465 source code location where this function was inlined. */
1469 /* Pointer to previous function in list of all functions. */
1470 struct funcinfo
* prev_func
;
1471 /* Pointer to function one scope higher. */
1472 struct funcinfo
* caller_func
;
1473 /* Source location file name where caller_func inlines this func. */
1475 /* Source location file name. */
1477 /* Source location line number where caller_func inlines this func. */
1479 /* Source location line number. */
1482 bfd_boolean is_linkage
;
1484 struct arange arange
;
1485 /* Where the symbol is defined. */
1487 /* The offset of the funcinfo from the start of the unit. */
1488 bfd_uint64_t unit_offset
;
1491 struct lookup_funcinfo
1493 /* Function information corresponding to this lookup table entry. */
1494 struct funcinfo
* funcinfo
;
1496 /* The lowest address for this specific function. */
1499 /* The highest address of this function before the lookup table is sorted.
1500 The highest address of all prior functions after the lookup table is
1501 sorted, which is used for binary search. */
1503 /* Index of this function, used to ensure qsort is stable. */
1509 /* Pointer to previous variable in list of all variables. */
1510 struct varinfo
*prev_var
;
1511 /* The offset of the varinfo from the start of the unit. */
1512 bfd_uint64_t unit_offset
;
1513 /* Source location file name. */
1515 /* Source location line number. */
1517 /* The type of this variable. */
1519 /* The name of the variable, if it has one. */
1521 /* The address of the variable. */
1523 /* Where the symbol is defined. */
1525 /* Is this a stack variable? */
1529 /* Return TRUE if NEW_LINE should sort after LINE. */
1531 static inline bfd_boolean
1532 new_line_sorts_after (struct line_info
*new_line
, struct line_info
*line
)
1534 return (new_line
->address
> line
->address
1535 || (new_line
->address
== line
->address
1536 && new_line
->op_index
> line
->op_index
));
1540 /* Adds a new entry to the line_info list in the line_info_table, ensuring
1541 that the list is sorted. Note that the line_info list is sorted from
1542 highest to lowest VMA (with possible duplicates); that is,
1543 line_info->prev_line always accesses an equal or smaller VMA. */
1546 add_line_info (struct line_info_table
*table
,
1548 unsigned char op_index
,
1551 unsigned int column
,
1552 unsigned int discriminator
,
1555 size_t amt
= sizeof (struct line_info
);
1556 struct line_sequence
* seq
= table
->sequences
;
1557 struct line_info
* info
= (struct line_info
*) bfd_alloc (table
->abfd
, amt
);
1562 /* Set member data of 'info'. */
1563 info
->prev_line
= NULL
;
1564 info
->address
= address
;
1565 info
->op_index
= op_index
;
1567 info
->column
= column
;
1568 info
->discriminator
= discriminator
;
1569 info
->end_sequence
= end_sequence
;
1571 if (filename
&& filename
[0])
1573 info
->filename
= (char *) bfd_alloc (table
->abfd
, strlen (filename
) + 1);
1574 if (info
->filename
== NULL
)
1576 strcpy (info
->filename
, filename
);
1579 info
->filename
= NULL
;
1581 /* Find the correct location for 'info'. Normally we will receive
1582 new line_info data 1) in order and 2) with increasing VMAs.
1583 However some compilers break the rules (cf. decode_line_info) and
1584 so we include some heuristics for quickly finding the correct
1585 location for 'info'. In particular, these heuristics optimize for
1586 the common case in which the VMA sequence that we receive is a
1587 list of locally sorted VMAs such as
1588 p...z a...j (where a < j < p < z)
1590 Note: table->lcl_head is used to head an *actual* or *possible*
1591 sub-sequence within the list (such as a...j) that is not directly
1592 headed by table->last_line
1594 Note: we may receive duplicate entries from 'decode_line_info'. */
1597 && seq
->last_line
->address
== address
1598 && seq
->last_line
->op_index
== op_index
1599 && seq
->last_line
->end_sequence
== end_sequence
)
1601 /* We only keep the last entry with the same address and end
1602 sequence. See PR ld/4986. */
1603 if (table
->lcl_head
== seq
->last_line
)
1604 table
->lcl_head
= info
;
1605 info
->prev_line
= seq
->last_line
->prev_line
;
1606 seq
->last_line
= info
;
1608 else if (!seq
|| seq
->last_line
->end_sequence
)
1610 /* Start a new line sequence. */
1611 amt
= sizeof (struct line_sequence
);
1612 seq
= (struct line_sequence
*) bfd_malloc (amt
);
1615 seq
->low_pc
= address
;
1616 seq
->prev_sequence
= table
->sequences
;
1617 seq
->last_line
= info
;
1618 table
->lcl_head
= info
;
1619 table
->sequences
= seq
;
1620 table
->num_sequences
++;
1622 else if (info
->end_sequence
1623 || new_line_sorts_after (info
, seq
->last_line
))
1625 /* Normal case: add 'info' to the beginning of the current sequence. */
1626 info
->prev_line
= seq
->last_line
;
1627 seq
->last_line
= info
;
1629 /* lcl_head: initialize to head a *possible* sequence at the end. */
1630 if (!table
->lcl_head
)
1631 table
->lcl_head
= info
;
1633 else if (!new_line_sorts_after (info
, table
->lcl_head
)
1634 && (!table
->lcl_head
->prev_line
1635 || new_line_sorts_after (info
, table
->lcl_head
->prev_line
)))
1637 /* Abnormal but easy: lcl_head is the head of 'info'. */
1638 info
->prev_line
= table
->lcl_head
->prev_line
;
1639 table
->lcl_head
->prev_line
= info
;
1643 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head'
1644 are valid heads for 'info'. Reset 'lcl_head'. */
1645 struct line_info
* li2
= seq
->last_line
; /* Always non-NULL. */
1646 struct line_info
* li1
= li2
->prev_line
;
1650 if (!new_line_sorts_after (info
, li2
)
1651 && new_line_sorts_after (info
, li1
))
1654 li2
= li1
; /* always non-NULL */
1655 li1
= li1
->prev_line
;
1657 table
->lcl_head
= li2
;
1658 info
->prev_line
= table
->lcl_head
->prev_line
;
1659 table
->lcl_head
->prev_line
= info
;
1660 if (address
< seq
->low_pc
)
1661 seq
->low_pc
= address
;
1666 /* Extract a fully qualified filename from a line info table.
1667 The returned string has been malloc'ed and it is the caller's
1668 responsibility to free it. */
1671 concat_filename (struct line_info_table
*table
, unsigned int file
)
1675 if (table
== NULL
|| file
- 1 >= table
->num_files
)
1677 /* FILE == 0 means unknown. */
1680 (_("DWARF error: mangled line number section (bad file number)"));
1681 return strdup ("<unknown>");
1684 filename
= table
->files
[file
- 1].name
;
1685 if (filename
== NULL
)
1686 return strdup ("<unknown>");
1688 if (!IS_ABSOLUTE_PATH (filename
))
1690 char *dir_name
= NULL
;
1691 char *subdir_name
= NULL
;
1695 if (table
->files
[file
- 1].dir
1696 /* PR 17512: file: 0317e960. */
1697 && table
->files
[file
- 1].dir
<= table
->num_dirs
1698 /* PR 17512: file: 7f3d2e4b. */
1699 && table
->dirs
!= NULL
)
1700 subdir_name
= table
->dirs
[table
->files
[file
- 1].dir
- 1];
1702 if (!subdir_name
|| !IS_ABSOLUTE_PATH (subdir_name
))
1703 dir_name
= table
->comp_dir
;
1707 dir_name
= subdir_name
;
1712 return strdup (filename
);
1714 len
= strlen (dir_name
) + strlen (filename
) + 2;
1718 len
+= strlen (subdir_name
) + 1;
1719 name
= (char *) bfd_malloc (len
);
1721 sprintf (name
, "%s/%s/%s", dir_name
, subdir_name
, filename
);
1725 name
= (char *) bfd_malloc (len
);
1727 sprintf (name
, "%s/%s", dir_name
, filename
);
1733 return strdup (filename
);
1737 arange_add (const struct comp_unit
*unit
, struct arange
*first_arange
,
1738 bfd_vma low_pc
, bfd_vma high_pc
)
1740 struct arange
*arange
;
1742 /* Ignore empty ranges. */
1743 if (low_pc
== high_pc
)
1746 /* If the first arange is empty, use it. */
1747 if (first_arange
->high
== 0)
1749 first_arange
->low
= low_pc
;
1750 first_arange
->high
= high_pc
;
1754 /* Next see if we can cheaply extend an existing range. */
1755 arange
= first_arange
;
1758 if (low_pc
== arange
->high
)
1760 arange
->high
= high_pc
;
1763 if (high_pc
== arange
->low
)
1765 arange
->low
= low_pc
;
1768 arange
= arange
->next
;
1772 /* Need to allocate a new arange and insert it into the arange list.
1773 Order isn't significant, so just insert after the first arange. */
1774 arange
= (struct arange
*) bfd_alloc (unit
->abfd
, sizeof (*arange
));
1777 arange
->low
= low_pc
;
1778 arange
->high
= high_pc
;
1779 arange
->next
= first_arange
->next
;
1780 first_arange
->next
= arange
;
1784 /* Compare function for line sequences. */
1787 compare_sequences (const void* a
, const void* b
)
1789 const struct line_sequence
* seq1
= a
;
1790 const struct line_sequence
* seq2
= b
;
1792 /* Sort by low_pc as the primary key. */
1793 if (seq1
->low_pc
< seq2
->low_pc
)
1795 if (seq1
->low_pc
> seq2
->low_pc
)
1798 /* If low_pc values are equal, sort in reverse order of
1799 high_pc, so that the largest region comes first. */
1800 if (seq1
->last_line
->address
< seq2
->last_line
->address
)
1802 if (seq1
->last_line
->address
> seq2
->last_line
->address
)
1805 if (seq1
->last_line
->op_index
< seq2
->last_line
->op_index
)
1807 if (seq1
->last_line
->op_index
> seq2
->last_line
->op_index
)
1810 /* num_lines is initially an index, to make the sort stable. */
1811 if (seq1
->num_lines
< seq2
->num_lines
)
1813 if (seq1
->num_lines
> seq2
->num_lines
)
1818 /* Construct the line information table for quick lookup. */
1821 build_line_info_table (struct line_info_table
* table
,
1822 struct line_sequence
* seq
)
1825 struct line_info
**line_info_lookup
;
1826 struct line_info
*each_line
;
1827 unsigned int num_lines
;
1828 unsigned int line_index
;
1830 if (seq
->line_info_lookup
!= NULL
)
1833 /* Count the number of line information entries. We could do this while
1834 scanning the debug information, but some entries may be added via
1835 lcl_head without having a sequence handy to increment the number of
1838 for (each_line
= seq
->last_line
; each_line
; each_line
= each_line
->prev_line
)
1841 seq
->num_lines
= num_lines
;
1845 /* Allocate space for the line information lookup table. */
1846 amt
= sizeof (struct line_info
*) * num_lines
;
1847 line_info_lookup
= (struct line_info
**) bfd_alloc (table
->abfd
, amt
);
1848 seq
->line_info_lookup
= line_info_lookup
;
1849 if (line_info_lookup
== NULL
)
1852 /* Create the line information lookup table. */
1853 line_index
= num_lines
;
1854 for (each_line
= seq
->last_line
; each_line
; each_line
= each_line
->prev_line
)
1855 line_info_lookup
[--line_index
] = each_line
;
1857 BFD_ASSERT (line_index
== 0);
1861 /* Sort the line sequences for quick lookup. */
1864 sort_line_sequences (struct line_info_table
* table
)
1867 struct line_sequence
*sequences
;
1868 struct line_sequence
*seq
;
1870 unsigned int num_sequences
= table
->num_sequences
;
1871 bfd_vma last_high_pc
;
1873 if (num_sequences
== 0)
1876 /* Allocate space for an array of sequences. */
1877 amt
= sizeof (struct line_sequence
) * num_sequences
;
1878 sequences
= (struct line_sequence
*) bfd_alloc (table
->abfd
, amt
);
1879 if (sequences
== NULL
)
1882 /* Copy the linked list into the array, freeing the original nodes. */
1883 seq
= table
->sequences
;
1884 for (n
= 0; n
< num_sequences
; n
++)
1886 struct line_sequence
* last_seq
= seq
;
1889 sequences
[n
].low_pc
= seq
->low_pc
;
1890 sequences
[n
].prev_sequence
= NULL
;
1891 sequences
[n
].last_line
= seq
->last_line
;
1892 sequences
[n
].line_info_lookup
= NULL
;
1893 sequences
[n
].num_lines
= n
;
1894 seq
= seq
->prev_sequence
;
1897 BFD_ASSERT (seq
== NULL
);
1899 qsort (sequences
, n
, sizeof (struct line_sequence
), compare_sequences
);
1901 /* Make the list binary-searchable by trimming overlapping entries
1902 and removing nested entries. */
1904 last_high_pc
= sequences
[0].last_line
->address
;
1905 for (n
= 1; n
< table
->num_sequences
; n
++)
1907 if (sequences
[n
].low_pc
< last_high_pc
)
1909 if (sequences
[n
].last_line
->address
<= last_high_pc
)
1910 /* Skip nested entries. */
1913 /* Trim overlapping entries. */
1914 sequences
[n
].low_pc
= last_high_pc
;
1916 last_high_pc
= sequences
[n
].last_line
->address
;
1917 if (n
> num_sequences
)
1919 /* Close up the gap. */
1920 sequences
[num_sequences
].low_pc
= sequences
[n
].low_pc
;
1921 sequences
[num_sequences
].last_line
= sequences
[n
].last_line
;
1926 table
->sequences
= sequences
;
1927 table
->num_sequences
= num_sequences
;
1931 /* Add directory to TABLE. CUR_DIR memory ownership is taken by TABLE. */
1934 line_info_add_include_dir (struct line_info_table
*table
, char *cur_dir
)
1936 if ((table
->num_dirs
% DIR_ALLOC_CHUNK
) == 0)
1941 amt
= table
->num_dirs
+ DIR_ALLOC_CHUNK
;
1942 amt
*= sizeof (char *);
1944 tmp
= (char **) bfd_realloc (table
->dirs
, amt
);
1950 table
->dirs
[table
->num_dirs
++] = cur_dir
;
1955 line_info_add_include_dir_stub (struct line_info_table
*table
, char *cur_dir
,
1956 unsigned int dir ATTRIBUTE_UNUSED
,
1957 unsigned int xtime ATTRIBUTE_UNUSED
,
1958 unsigned int size ATTRIBUTE_UNUSED
)
1960 return line_info_add_include_dir (table
, cur_dir
);
1963 /* Add file to TABLE. CUR_FILE memory ownership is taken by TABLE. */
1966 line_info_add_file_name (struct line_info_table
*table
, char *cur_file
,
1967 unsigned int dir
, unsigned int xtime
,
1970 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
1972 struct fileinfo
*tmp
;
1975 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
1976 amt
*= sizeof (struct fileinfo
);
1978 tmp
= (struct fileinfo
*) bfd_realloc (table
->files
, amt
);
1984 table
->files
[table
->num_files
].name
= cur_file
;
1985 table
->files
[table
->num_files
].dir
= dir
;
1986 table
->files
[table
->num_files
].time
= xtime
;
1987 table
->files
[table
->num_files
].size
= size
;
1992 /* Read directory or file name entry format, starting with byte of
1993 format count entries, ULEB128 pairs of entry formats, ULEB128 of
1994 entries count and the entries themselves in the described entry
1998 read_formatted_entries (struct comp_unit
*unit
, bfd_byte
**bufp
,
1999 bfd_byte
*buf_end
, struct line_info_table
*table
,
2000 bfd_boolean (*callback
) (struct line_info_table
*table
,
2006 bfd
*abfd
= unit
->abfd
;
2007 bfd_byte format_count
, formati
;
2008 bfd_vma data_count
, datai
;
2009 bfd_byte
*buf
= *bufp
;
2010 bfd_byte
*format_header_data
;
2011 unsigned int bytes_read
;
2013 format_count
= read_1_byte (abfd
, buf
, buf_end
);
2015 format_header_data
= buf
;
2016 for (formati
= 0; formati
< format_count
; formati
++)
2018 _bfd_safe_read_leb128 (abfd
, buf
, &bytes_read
, FALSE
, buf_end
);
2020 _bfd_safe_read_leb128 (abfd
, buf
, &bytes_read
, FALSE
, buf_end
);
2024 data_count
= _bfd_safe_read_leb128 (abfd
, buf
, &bytes_read
, FALSE
, buf_end
);
2026 if (format_count
== 0 && data_count
!= 0)
2028 _bfd_error_handler (_("DWARF error: zero format count"));
2029 bfd_set_error (bfd_error_bad_value
);
2033 /* PR 22210. Paranoia check. Don't bother running the loop
2034 if we know that we are going to run out of buffer. */
2035 if (data_count
> (bfd_vma
) (buf_end
- buf
))
2038 (_("DWARF error: data count (%" PRIx64
") larger than buffer size"),
2039 (uint64_t) data_count
);
2040 bfd_set_error (bfd_error_bad_value
);
2044 for (datai
= 0; datai
< data_count
; datai
++)
2046 bfd_byte
*format
= format_header_data
;
2049 memset (&fe
, 0, sizeof fe
);
2050 for (formati
= 0; formati
< format_count
; formati
++)
2052 bfd_vma content_type
, form
;
2054 char **stringp
= &string_trash
;
2055 unsigned int uint_trash
, *uintp
= &uint_trash
;
2056 struct attribute attr
;
2058 content_type
= _bfd_safe_read_leb128 (abfd
, format
, &bytes_read
,
2060 format
+= bytes_read
;
2061 switch (content_type
)
2066 case DW_LNCT_directory_index
:
2069 case DW_LNCT_timestamp
:
2079 (_("DWARF error: unknown format content type %" PRIu64
),
2080 (uint64_t) content_type
);
2081 bfd_set_error (bfd_error_bad_value
);
2085 form
= _bfd_safe_read_leb128 (abfd
, format
, &bytes_read
, FALSE
,
2087 format
+= bytes_read
;
2089 buf
= read_attribute_value (&attr
, form
, 0, unit
, buf
, buf_end
);
2094 case DW_FORM_string
:
2095 case DW_FORM_line_strp
:
2096 *stringp
= attr
.u
.str
;
2104 *uintp
= attr
.u
.val
;
2107 case DW_FORM_data16
:
2108 /* MD5 data is in the attr.blk, but we are ignoring those. */
2113 /* Skip the first "zero entry", which is the compilation dir/file. */
2115 if (!callback (table
, fe
.name
, fe
.dir
, fe
.time
, fe
.size
))
2123 /* Decode the line number information for UNIT. */
2125 static struct line_info_table
*
2126 decode_line_info (struct comp_unit
*unit
)
2128 bfd
*abfd
= unit
->abfd
;
2129 struct dwarf2_debug
*stash
= unit
->stash
;
2130 struct dwarf2_debug_file
*file
= unit
->file
;
2131 struct line_info_table
* table
;
2134 struct line_head lh
;
2135 unsigned int i
, bytes_read
, offset_size
;
2136 char *cur_file
, *cur_dir
;
2137 unsigned char op_code
, extended_op
, adj_opcode
;
2138 unsigned int exop_len
;
2141 if (unit
->line_offset
== 0 && file
->line_table
)
2142 return file
->line_table
;
2144 if (! read_section (abfd
, &stash
->debug_sections
[debug_line
],
2145 file
->syms
, unit
->line_offset
,
2146 &file
->dwarf_line_buffer
, &file
->dwarf_line_size
))
2149 if (file
->dwarf_line_size
< 16)
2152 (_("DWARF error: line info section is too small (%" PRId64
")"),
2153 (int64_t) file
->dwarf_line_size
);
2154 bfd_set_error (bfd_error_bad_value
);
2157 line_ptr
= file
->dwarf_line_buffer
+ unit
->line_offset
;
2158 line_end
= file
->dwarf_line_buffer
+ file
->dwarf_line_size
;
2160 /* Read in the prologue. */
2161 lh
.total_length
= read_4_bytes (abfd
, line_ptr
, line_end
);
2164 if (lh
.total_length
== 0xffffffff)
2166 lh
.total_length
= read_8_bytes (abfd
, line_ptr
, line_end
);
2170 else if (lh
.total_length
== 0 && unit
->addr_size
== 8)
2172 /* Handle (non-standard) 64-bit DWARF2 formats. */
2173 lh
.total_length
= read_4_bytes (abfd
, line_ptr
, line_end
);
2178 if (lh
.total_length
> (size_t) (line_end
- line_ptr
))
2181 /* xgettext: c-format */
2182 (_("DWARF error: line info data is bigger (%#" PRIx64
")"
2183 " than the space remaining in the section (%#lx)"),
2184 (uint64_t) lh
.total_length
, (unsigned long) (line_end
- line_ptr
));
2185 bfd_set_error (bfd_error_bad_value
);
2189 line_end
= line_ptr
+ lh
.total_length
;
2191 lh
.version
= read_2_bytes (abfd
, line_ptr
, line_end
);
2192 if (lh
.version
< 2 || lh
.version
> 5)
2195 (_("DWARF error: unhandled .debug_line version %d"), lh
.version
);
2196 bfd_set_error (bfd_error_bad_value
);
2201 if (line_ptr
+ offset_size
+ (lh
.version
>= 5 ? 8 : (lh
.version
>= 4 ? 6 : 5))
2205 (_("DWARF error: ran out of room reading prologue"));
2206 bfd_set_error (bfd_error_bad_value
);
2210 if (lh
.version
>= 5)
2212 unsigned int segment_selector_size
;
2214 /* Skip address size. */
2215 read_1_byte (abfd
, line_ptr
, line_end
);
2218 segment_selector_size
= read_1_byte (abfd
, line_ptr
, line_end
);
2220 if (segment_selector_size
!= 0)
2223 (_("DWARF error: line info unsupported segment selector size %u"),
2224 segment_selector_size
);
2225 bfd_set_error (bfd_error_bad_value
);
2230 if (offset_size
== 4)
2231 lh
.prologue_length
= read_4_bytes (abfd
, line_ptr
, line_end
);
2233 lh
.prologue_length
= read_8_bytes (abfd
, line_ptr
, line_end
);
2234 line_ptr
+= offset_size
;
2236 lh
.minimum_instruction_length
= read_1_byte (abfd
, line_ptr
, line_end
);
2239 if (lh
.version
>= 4)
2241 lh
.maximum_ops_per_insn
= read_1_byte (abfd
, line_ptr
, line_end
);
2245 lh
.maximum_ops_per_insn
= 1;
2247 if (lh
.maximum_ops_per_insn
== 0)
2250 (_("DWARF error: invalid maximum operations per instruction"));
2251 bfd_set_error (bfd_error_bad_value
);
2255 lh
.default_is_stmt
= read_1_byte (abfd
, line_ptr
, line_end
);
2258 lh
.line_base
= read_1_signed_byte (abfd
, line_ptr
, line_end
);
2261 lh
.line_range
= read_1_byte (abfd
, line_ptr
, line_end
);
2264 lh
.opcode_base
= read_1_byte (abfd
, line_ptr
, line_end
);
2267 if (line_ptr
+ (lh
.opcode_base
- 1) >= line_end
)
2269 _bfd_error_handler (_("DWARF error: ran out of room reading opcodes"));
2270 bfd_set_error (bfd_error_bad_value
);
2274 amt
= lh
.opcode_base
* sizeof (unsigned char);
2275 lh
.standard_opcode_lengths
= (unsigned char *) bfd_alloc (abfd
, amt
);
2277 lh
.standard_opcode_lengths
[0] = 1;
2279 for (i
= 1; i
< lh
.opcode_base
; ++i
)
2281 lh
.standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
, line_end
);
2285 amt
= sizeof (struct line_info_table
);
2286 table
= (struct line_info_table
*) bfd_alloc (abfd
, amt
);
2290 table
->comp_dir
= unit
->comp_dir
;
2292 table
->num_files
= 0;
2293 table
->files
= NULL
;
2295 table
->num_dirs
= 0;
2298 table
->num_sequences
= 0;
2299 table
->sequences
= NULL
;
2301 table
->lcl_head
= NULL
;
2303 if (lh
.version
>= 5)
2305 /* Read directory table. */
2306 if (!read_formatted_entries (unit
, &line_ptr
, line_end
, table
,
2307 line_info_add_include_dir_stub
))
2310 /* Read file name table. */
2311 if (!read_formatted_entries (unit
, &line_ptr
, line_end
, table
,
2312 line_info_add_file_name
))
2317 /* Read directory table. */
2318 while ((cur_dir
= read_string (abfd
, line_ptr
, line_end
, &bytes_read
)) != NULL
)
2320 line_ptr
+= bytes_read
;
2322 if (!line_info_add_include_dir (table
, cur_dir
))
2326 line_ptr
+= bytes_read
;
2328 /* Read file name table. */
2329 while ((cur_file
= read_string (abfd
, line_ptr
, line_end
, &bytes_read
)) != NULL
)
2331 unsigned int dir
, xtime
, size
;
2333 line_ptr
+= bytes_read
;
2335 dir
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
, FALSE
, line_end
);
2336 line_ptr
+= bytes_read
;
2337 xtime
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
, FALSE
, line_end
);
2338 line_ptr
+= bytes_read
;
2339 size
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
, FALSE
, line_end
);
2340 line_ptr
+= bytes_read
;
2342 if (!line_info_add_file_name (table
, cur_file
, dir
, xtime
, size
))
2346 line_ptr
+= bytes_read
;
2349 /* Read the statement sequences until there's nothing left. */
2350 while (line_ptr
< line_end
)
2352 /* State machine registers. */
2353 bfd_vma address
= 0;
2354 unsigned char op_index
= 0;
2355 char * filename
= table
->num_files
? concat_filename (table
, 1) : NULL
;
2356 unsigned int line
= 1;
2357 unsigned int column
= 0;
2358 unsigned int discriminator
= 0;
2359 int is_stmt
= lh
.default_is_stmt
;
2360 int end_sequence
= 0;
2361 unsigned int dir
, xtime
, size
;
2362 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
2363 compilers generate address sequences that are wildly out of
2364 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
2365 for ia64-Linux). Thus, to determine the low and high
2366 address, we must compare on every DW_LNS_copy, etc. */
2367 bfd_vma low_pc
= (bfd_vma
) -1;
2368 bfd_vma high_pc
= 0;
2370 /* Decode the table. */
2371 while (!end_sequence
&& line_ptr
< line_end
)
2373 op_code
= read_1_byte (abfd
, line_ptr
, line_end
);
2376 if (op_code
>= lh
.opcode_base
)
2378 /* Special operand. */
2379 adj_opcode
= op_code
- lh
.opcode_base
;
2380 if (lh
.line_range
== 0)
2382 if (lh
.maximum_ops_per_insn
== 1)
2383 address
+= (adj_opcode
/ lh
.line_range
2384 * lh
.minimum_instruction_length
);
2387 address
+= ((op_index
+ adj_opcode
/ lh
.line_range
)
2388 / lh
.maximum_ops_per_insn
2389 * lh
.minimum_instruction_length
);
2390 op_index
= ((op_index
+ adj_opcode
/ lh
.line_range
)
2391 % lh
.maximum_ops_per_insn
);
2393 line
+= lh
.line_base
+ (adj_opcode
% lh
.line_range
);
2394 /* Append row to matrix using current values. */
2395 if (!add_line_info (table
, address
, op_index
, filename
,
2396 line
, column
, discriminator
, 0))
2399 if (address
< low_pc
)
2401 if (address
> high_pc
)
2404 else switch (op_code
)
2406 case DW_LNS_extended_op
:
2407 exop_len
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2409 line_ptr
+= bytes_read
;
2410 extended_op
= read_1_byte (abfd
, line_ptr
, line_end
);
2413 switch (extended_op
)
2415 case DW_LNE_end_sequence
:
2417 if (!add_line_info (table
, address
, op_index
, filename
, line
,
2418 column
, discriminator
, end_sequence
))
2421 if (address
< low_pc
)
2423 if (address
> high_pc
)
2425 if (!arange_add (unit
, &unit
->arange
, low_pc
, high_pc
))
2428 case DW_LNE_set_address
:
2429 address
= read_address (unit
, line_ptr
, line_end
);
2431 line_ptr
+= unit
->addr_size
;
2433 case DW_LNE_define_file
:
2434 cur_file
= read_string (abfd
, line_ptr
, line_end
, &bytes_read
);
2435 line_ptr
+= bytes_read
;
2436 dir
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2438 line_ptr
+= bytes_read
;
2439 xtime
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2441 line_ptr
+= bytes_read
;
2442 size
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2444 line_ptr
+= bytes_read
;
2445 if (!line_info_add_file_name (table
, cur_file
, dir
,
2449 case DW_LNE_set_discriminator
:
2451 _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2453 line_ptr
+= bytes_read
;
2455 case DW_LNE_HP_source_file_correlation
:
2456 line_ptr
+= exop_len
- 1;
2460 (_("DWARF error: mangled line number section"));
2461 bfd_set_error (bfd_error_bad_value
);
2468 if (!add_line_info (table
, address
, op_index
,
2469 filename
, line
, column
, discriminator
, 0))
2472 if (address
< low_pc
)
2474 if (address
> high_pc
)
2477 case DW_LNS_advance_pc
:
2478 if (lh
.maximum_ops_per_insn
== 1)
2479 address
+= (lh
.minimum_instruction_length
2480 * _bfd_safe_read_leb128 (abfd
, line_ptr
,
2485 bfd_vma adjust
= _bfd_safe_read_leb128 (abfd
, line_ptr
,
2488 address
= ((op_index
+ adjust
) / lh
.maximum_ops_per_insn
2489 * lh
.minimum_instruction_length
);
2490 op_index
= (op_index
+ adjust
) % lh
.maximum_ops_per_insn
;
2492 line_ptr
+= bytes_read
;
2494 case DW_LNS_advance_line
:
2495 line
+= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2497 line_ptr
+= bytes_read
;
2499 case DW_LNS_set_file
:
2501 unsigned int filenum
;
2503 /* The file and directory tables are 0
2504 based, the references are 1 based. */
2505 filenum
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2507 line_ptr
+= bytes_read
;
2509 filename
= concat_filename (table
, filenum
);
2512 case DW_LNS_set_column
:
2513 column
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2515 line_ptr
+= bytes_read
;
2517 case DW_LNS_negate_stmt
:
2518 is_stmt
= (!is_stmt
);
2520 case DW_LNS_set_basic_block
:
2522 case DW_LNS_const_add_pc
:
2523 if (lh
.line_range
== 0)
2525 if (lh
.maximum_ops_per_insn
== 1)
2526 address
+= (lh
.minimum_instruction_length
2527 * ((255 - lh
.opcode_base
) / lh
.line_range
));
2530 bfd_vma adjust
= ((255 - lh
.opcode_base
) / lh
.line_range
);
2531 address
+= (lh
.minimum_instruction_length
2532 * ((op_index
+ adjust
)
2533 / lh
.maximum_ops_per_insn
));
2534 op_index
= (op_index
+ adjust
) % lh
.maximum_ops_per_insn
;
2537 case DW_LNS_fixed_advance_pc
:
2538 address
+= read_2_bytes (abfd
, line_ptr
, line_end
);
2543 /* Unknown standard opcode, ignore it. */
2544 for (i
= 0; i
< lh
.standard_opcode_lengths
[op_code
]; i
++)
2546 (void) _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2548 line_ptr
+= bytes_read
;
2557 if (unit
->line_offset
== 0)
2558 file
->line_table
= table
;
2559 if (sort_line_sequences (table
))
2563 while (table
->sequences
!= NULL
)
2565 struct line_sequence
* seq
= table
->sequences
;
2566 table
->sequences
= table
->sequences
->prev_sequence
;
2569 free (table
->files
);
2574 /* If ADDR is within TABLE set the output parameters and return the
2575 range of addresses covered by the entry used to fill them out.
2576 Otherwise set * FILENAME_PTR to NULL and return 0.
2577 The parameters FILENAME_PTR, LINENUMBER_PTR and DISCRIMINATOR_PTR
2578 are pointers to the objects to be filled in. */
2581 lookup_address_in_line_info_table (struct line_info_table
*table
,
2583 const char **filename_ptr
,
2584 unsigned int *linenumber_ptr
,
2585 unsigned int *discriminator_ptr
)
2587 struct line_sequence
*seq
= NULL
;
2588 struct line_info
*info
;
2591 /* Binary search the array of sequences. */
2593 high
= table
->num_sequences
;
2596 mid
= (low
+ high
) / 2;
2597 seq
= &table
->sequences
[mid
];
2598 if (addr
< seq
->low_pc
)
2600 else if (addr
>= seq
->last_line
->address
)
2606 /* Check for a valid sequence. */
2607 if (!seq
|| addr
< seq
->low_pc
|| addr
>= seq
->last_line
->address
)
2610 if (!build_line_info_table (table
, seq
))
2613 /* Binary search the array of line information. */
2615 high
= seq
->num_lines
;
2619 mid
= (low
+ high
) / 2;
2620 info
= seq
->line_info_lookup
[mid
];
2621 if (addr
< info
->address
)
2623 else if (addr
>= seq
->line_info_lookup
[mid
+ 1]->address
)
2629 /* Check for a valid line information entry. */
2631 && addr
>= info
->address
2632 && addr
< seq
->line_info_lookup
[mid
+ 1]->address
2633 && !(info
->end_sequence
|| info
== seq
->last_line
))
2635 *filename_ptr
= info
->filename
;
2636 *linenumber_ptr
= info
->line
;
2637 if (discriminator_ptr
)
2638 *discriminator_ptr
= info
->discriminator
;
2639 return seq
->last_line
->address
- seq
->low_pc
;
2643 *filename_ptr
= NULL
;
2647 /* Read in the .debug_ranges section for future reference. */
2650 read_debug_ranges (struct comp_unit
* unit
)
2652 struct dwarf2_debug
*stash
= unit
->stash
;
2653 struct dwarf2_debug_file
*file
= unit
->file
;
2655 return read_section (unit
->abfd
, &stash
->debug_sections
[debug_ranges
],
2657 &file
->dwarf_ranges_buffer
, &file
->dwarf_ranges_size
);
2660 /* Read in the .debug_rnglists section for future reference. */
2663 read_debug_rnglists (struct comp_unit
* unit
)
2665 struct dwarf2_debug
*stash
= unit
->stash
;
2666 struct dwarf2_debug_file
*file
= unit
->file
;
2668 return read_section (unit
->abfd
, &stash
->debug_sections
[debug_rnglists
],
2670 &file
->dwarf_rnglists_buffer
, &file
->dwarf_rnglists_size
);
2673 /* Function table functions. */
2676 compare_lookup_funcinfos (const void * a
, const void * b
)
2678 const struct lookup_funcinfo
* lookup1
= a
;
2679 const struct lookup_funcinfo
* lookup2
= b
;
2681 if (lookup1
->low_addr
< lookup2
->low_addr
)
2683 if (lookup1
->low_addr
> lookup2
->low_addr
)
2685 if (lookup1
->high_addr
< lookup2
->high_addr
)
2687 if (lookup1
->high_addr
> lookup2
->high_addr
)
2690 if (lookup1
->idx
< lookup2
->idx
)
2692 if (lookup1
->idx
> lookup2
->idx
)
2698 build_lookup_funcinfo_table (struct comp_unit
* unit
)
2700 struct lookup_funcinfo
*lookup_funcinfo_table
= unit
->lookup_funcinfo_table
;
2701 unsigned int number_of_functions
= unit
->number_of_functions
;
2702 struct funcinfo
*each
;
2703 struct lookup_funcinfo
*entry
;
2705 struct arange
*range
;
2706 bfd_vma low_addr
, high_addr
;
2708 if (lookup_funcinfo_table
|| number_of_functions
== 0)
2711 /* Create the function info lookup table. */
2712 lookup_funcinfo_table
= (struct lookup_funcinfo
*)
2713 bfd_malloc (number_of_functions
* sizeof (struct lookup_funcinfo
));
2714 if (lookup_funcinfo_table
== NULL
)
2717 /* Populate the function info lookup table. */
2718 func_index
= number_of_functions
;
2719 for (each
= unit
->function_table
; each
; each
= each
->prev_func
)
2721 entry
= &lookup_funcinfo_table
[--func_index
];
2722 entry
->funcinfo
= each
;
2723 entry
->idx
= func_index
;
2725 /* Calculate the lowest and highest address for this function entry. */
2726 low_addr
= entry
->funcinfo
->arange
.low
;
2727 high_addr
= entry
->funcinfo
->arange
.high
;
2729 for (range
= entry
->funcinfo
->arange
.next
; range
; range
= range
->next
)
2731 if (range
->low
< low_addr
)
2732 low_addr
= range
->low
;
2733 if (range
->high
> high_addr
)
2734 high_addr
= range
->high
;
2737 entry
->low_addr
= low_addr
;
2738 entry
->high_addr
= high_addr
;
2741 BFD_ASSERT (func_index
== 0);
2743 /* Sort the function by address. */
2744 qsort (lookup_funcinfo_table
,
2745 number_of_functions
,
2746 sizeof (struct lookup_funcinfo
),
2747 compare_lookup_funcinfos
);
2749 /* Calculate the high watermark for each function in the lookup table. */
2750 high_addr
= lookup_funcinfo_table
[0].high_addr
;
2751 for (func_index
= 1; func_index
< number_of_functions
; func_index
++)
2753 entry
= &lookup_funcinfo_table
[func_index
];
2754 if (entry
->high_addr
> high_addr
)
2755 high_addr
= entry
->high_addr
;
2757 entry
->high_addr
= high_addr
;
2760 unit
->lookup_funcinfo_table
= lookup_funcinfo_table
;
2764 /* If ADDR is within UNIT's function tables, set FUNCTION_PTR, and return
2765 TRUE. Note that we need to find the function that has the smallest range
2766 that contains ADDR, to handle inlined functions without depending upon
2767 them being ordered in TABLE by increasing range. */
2770 lookup_address_in_function_table (struct comp_unit
*unit
,
2772 struct funcinfo
**function_ptr
)
2774 unsigned int number_of_functions
= unit
->number_of_functions
;
2775 struct lookup_funcinfo
* lookup_funcinfo
= NULL
;
2776 struct funcinfo
* funcinfo
= NULL
;
2777 struct funcinfo
* best_fit
= NULL
;
2778 bfd_vma best_fit_len
= 0;
2779 bfd_size_type low
, high
, mid
, first
;
2780 struct arange
*arange
;
2782 if (number_of_functions
== 0)
2785 if (!build_lookup_funcinfo_table (unit
))
2788 if (unit
->lookup_funcinfo_table
[number_of_functions
- 1].high_addr
< addr
)
2791 /* Find the first function in the lookup table which may contain the
2792 specified address. */
2794 high
= number_of_functions
;
2798 mid
= (low
+ high
) / 2;
2799 lookup_funcinfo
= &unit
->lookup_funcinfo_table
[mid
];
2800 if (addr
< lookup_funcinfo
->low_addr
)
2802 else if (addr
>= lookup_funcinfo
->high_addr
)
2808 /* Find the 'best' match for the address. The prior algorithm defined the
2809 best match as the function with the smallest address range containing
2810 the specified address. This definition should probably be changed to the
2811 innermost inline routine containing the address, but right now we want
2812 to get the same results we did before. */
2813 while (first
< number_of_functions
)
2815 if (addr
< unit
->lookup_funcinfo_table
[first
].low_addr
)
2817 funcinfo
= unit
->lookup_funcinfo_table
[first
].funcinfo
;
2819 for (arange
= &funcinfo
->arange
; arange
; arange
= arange
->next
)
2821 if (addr
< arange
->low
|| addr
>= arange
->high
)
2825 || arange
->high
- arange
->low
< best_fit_len
2826 /* The following comparison is designed to return the same
2827 match as the previous algorithm for routines which have the
2828 same best fit length. */
2829 || (arange
->high
- arange
->low
== best_fit_len
2830 && funcinfo
> best_fit
))
2832 best_fit
= funcinfo
;
2833 best_fit_len
= arange
->high
- arange
->low
;
2843 *function_ptr
= best_fit
;
2847 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
2848 and LINENUMBER_PTR, and return TRUE. */
2851 lookup_symbol_in_function_table (struct comp_unit
*unit
,
2854 const char **filename_ptr
,
2855 unsigned int *linenumber_ptr
)
2857 struct funcinfo
* each_func
;
2858 struct funcinfo
* best_fit
= NULL
;
2859 bfd_vma best_fit_len
= 0;
2860 struct arange
*arange
;
2861 const char *name
= bfd_asymbol_name (sym
);
2862 asection
*sec
= bfd_asymbol_section (sym
);
2864 for (each_func
= unit
->function_table
;
2866 each_func
= each_func
->prev_func
)
2868 for (arange
= &each_func
->arange
;
2870 arange
= arange
->next
)
2872 if ((!each_func
->sec
|| each_func
->sec
== sec
)
2873 && addr
>= arange
->low
2874 && addr
< arange
->high
2876 && strcmp (name
, each_func
->name
) == 0
2878 || arange
->high
- arange
->low
< best_fit_len
))
2880 best_fit
= each_func
;
2881 best_fit_len
= arange
->high
- arange
->low
;
2888 best_fit
->sec
= sec
;
2889 *filename_ptr
= best_fit
->file
;
2890 *linenumber_ptr
= best_fit
->line
;
2897 /* Variable table functions. */
2899 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
2900 LINENUMBER_PTR, and return TRUE. */
2903 lookup_symbol_in_variable_table (struct comp_unit
*unit
,
2906 const char **filename_ptr
,
2907 unsigned int *linenumber_ptr
)
2909 const char *name
= bfd_asymbol_name (sym
);
2910 asection
*sec
= bfd_asymbol_section (sym
);
2911 struct varinfo
* each
;
2913 for (each
= unit
->variable_table
; each
; each
= each
->prev_var
)
2915 && each
->file
!= NULL
2916 && each
->name
!= NULL
2917 && each
->addr
== addr
2918 && (!each
->sec
|| each
->sec
== sec
)
2919 && strcmp (name
, each
->name
) == 0)
2925 *filename_ptr
= each
->file
;
2926 *linenumber_ptr
= each
->line
;
2933 static struct comp_unit
*stash_comp_unit (struct dwarf2_debug
*,
2934 struct dwarf2_debug_file
*);
2935 static bfd_boolean
comp_unit_maybe_decode_line_info (struct comp_unit
*);
2938 find_abstract_instance (struct comp_unit
*unit
,
2939 struct attribute
*attr_ptr
,
2940 unsigned int recur_count
,
2942 bfd_boolean
*is_linkage
,
2943 char **filename_ptr
,
2944 int *linenumber_ptr
)
2946 bfd
*abfd
= unit
->abfd
;
2947 bfd_byte
*info_ptr
= NULL
;
2948 bfd_byte
*info_ptr_end
;
2949 unsigned int abbrev_number
, bytes_read
, i
;
2950 struct abbrev_info
*abbrev
;
2951 bfd_uint64_t die_ref
= attr_ptr
->u
.val
;
2952 struct attribute attr
;
2953 const char *name
= NULL
;
2955 if (recur_count
== 100)
2958 (_("DWARF error: abstract instance recursion detected"));
2959 bfd_set_error (bfd_error_bad_value
);
2963 /* DW_FORM_ref_addr can reference an entry in a different CU. It
2964 is an offset from the .debug_info section, not the current CU. */
2965 if (attr_ptr
->form
== DW_FORM_ref_addr
)
2967 /* We only support DW_FORM_ref_addr within the same file, so
2968 any relocations should be resolved already. Check this by
2969 testing for a zero die_ref; There can't be a valid reference
2970 to the header of a .debug_info section.
2971 DW_FORM_ref_addr is an offset relative to .debug_info.
2972 Normally when using the GNU linker this is accomplished by
2973 emitting a symbolic reference to a label, because .debug_info
2974 sections are linked at zero. When there are multiple section
2975 groups containing .debug_info, as there might be in a
2976 relocatable object file, it would be reasonable to assume that
2977 a symbolic reference to a label in any .debug_info section
2978 might be used. Since we lay out multiple .debug_info
2979 sections at non-zero VMAs (see place_sections), and read
2980 them contiguously into dwarf_info_buffer, that means the
2981 reference is relative to dwarf_info_buffer. */
2984 info_ptr
= unit
->file
->dwarf_info_buffer
;
2985 info_ptr_end
= info_ptr
+ unit
->file
->dwarf_info_size
;
2986 total
= info_ptr_end
- info_ptr
;
2989 else if (die_ref
>= total
)
2992 (_("DWARF error: invalid abstract instance DIE ref"));
2993 bfd_set_error (bfd_error_bad_value
);
2996 info_ptr
+= die_ref
;
2998 else if (attr_ptr
->form
== DW_FORM_GNU_ref_alt
)
3000 bfd_boolean first_time
= unit
->stash
->alt
.dwarf_info_buffer
== NULL
;
3002 info_ptr
= read_alt_indirect_ref (unit
, die_ref
);
3004 unit
->stash
->alt
.info_ptr
= unit
->stash
->alt
.dwarf_info_buffer
;
3005 if (info_ptr
== NULL
)
3008 (_("DWARF error: unable to read alt ref %" PRIu64
),
3009 (uint64_t) die_ref
);
3010 bfd_set_error (bfd_error_bad_value
);
3013 info_ptr_end
= (unit
->stash
->alt
.dwarf_info_buffer
3014 + unit
->stash
->alt
.dwarf_info_size
);
3015 if (unit
->stash
->alt
.all_comp_units
)
3016 unit
= unit
->stash
->alt
.all_comp_units
;
3019 if (attr_ptr
->form
== DW_FORM_ref_addr
3020 || attr_ptr
->form
== DW_FORM_GNU_ref_alt
)
3022 /* Now find the CU containing this pointer. */
3023 if (info_ptr
>= unit
->info_ptr_unit
&& info_ptr
< unit
->end_ptr
)
3024 info_ptr_end
= unit
->end_ptr
;
3027 /* Check other CUs to see if they contain the abbrev. */
3028 struct comp_unit
*u
;
3030 for (u
= unit
->prev_unit
; u
!= NULL
; u
= u
->prev_unit
)
3031 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
3035 for (u
= unit
->next_unit
; u
!= NULL
; u
= u
->next_unit
)
3036 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
3039 if (attr_ptr
->form
== DW_FORM_ref_addr
)
3042 u
= stash_comp_unit (unit
->stash
, &unit
->stash
->f
);
3045 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
3050 if (attr_ptr
->form
== DW_FORM_GNU_ref_alt
)
3053 u
= stash_comp_unit (unit
->stash
, &unit
->stash
->alt
);
3056 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
3064 (_("DWARF error: unable to locate abstract instance DIE ref %"
3065 PRIu64
), (uint64_t) die_ref
);
3066 bfd_set_error (bfd_error_bad_value
);
3070 info_ptr_end
= unit
->end_ptr
;
3075 /* DW_FORM_ref1, DW_FORM_ref2, DW_FORM_ref4, DW_FORM_ref8 or
3076 DW_FORM_ref_udata. These are all references relative to the
3077 start of the current CU. */
3080 info_ptr
= unit
->info_ptr_unit
;
3081 info_ptr_end
= unit
->end_ptr
;
3082 total
= info_ptr_end
- info_ptr
;
3083 if (!die_ref
|| die_ref
>= total
)
3086 (_("DWARF error: invalid abstract instance DIE ref"));
3087 bfd_set_error (bfd_error_bad_value
);
3090 info_ptr
+= die_ref
;
3093 abbrev_number
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
3094 FALSE
, info_ptr_end
);
3095 info_ptr
+= bytes_read
;
3099 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
3103 (_("DWARF error: could not find abbrev number %u"), abbrev_number
);
3104 bfd_set_error (bfd_error_bad_value
);
3109 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3111 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
,
3112 info_ptr
, info_ptr_end
);
3113 if (info_ptr
== NULL
)
3118 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
3120 if (name
== NULL
&& is_str_attr (attr
.form
))
3123 if (non_mangled (unit
->lang
))
3127 case DW_AT_specification
:
3128 if (!find_abstract_instance (unit
, &attr
, recur_count
+ 1,
3130 filename_ptr
, linenumber_ptr
))
3133 case DW_AT_linkage_name
:
3134 case DW_AT_MIPS_linkage_name
:
3135 /* PR 16949: Corrupt debug info can place
3136 non-string forms into these attributes. */
3137 if (is_str_attr (attr
.form
))
3143 case DW_AT_decl_file
:
3144 if (!comp_unit_maybe_decode_line_info (unit
))
3146 *filename_ptr
= concat_filename (unit
->line_table
,
3149 case DW_AT_decl_line
:
3150 *linenumber_ptr
= attr
.u
.val
;
3163 read_ranges (struct comp_unit
*unit
, struct arange
*arange
,
3164 bfd_uint64_t offset
)
3166 bfd_byte
*ranges_ptr
;
3167 bfd_byte
*ranges_end
;
3168 bfd_vma base_address
= unit
->base_address
;
3170 if (! unit
->file
->dwarf_ranges_buffer
)
3172 if (! read_debug_ranges (unit
))
3176 ranges_ptr
= unit
->file
->dwarf_ranges_buffer
+ offset
;
3177 if (ranges_ptr
< unit
->file
->dwarf_ranges_buffer
)
3179 ranges_end
= unit
->file
->dwarf_ranges_buffer
+ unit
->file
->dwarf_ranges_size
;
3186 /* PR 17512: file: 62cada7d. */
3187 if (ranges_ptr
+ 2 * unit
->addr_size
> ranges_end
)
3190 low_pc
= read_address (unit
, ranges_ptr
, ranges_end
);
3191 ranges_ptr
+= unit
->addr_size
;
3192 high_pc
= read_address (unit
, ranges_ptr
, ranges_end
);
3193 ranges_ptr
+= unit
->addr_size
;
3195 if (low_pc
== 0 && high_pc
== 0)
3197 if (low_pc
== -1UL && high_pc
!= -1UL)
3198 base_address
= high_pc
;
3201 if (!arange_add (unit
, arange
,
3202 base_address
+ low_pc
, base_address
+ high_pc
))
3210 read_rnglists (struct comp_unit
*unit
, struct arange
*arange
,
3211 bfd_uint64_t offset
)
3215 bfd_vma base_address
= unit
->base_address
;
3218 bfd
*abfd
= unit
->abfd
;
3220 if (! unit
->file
->dwarf_rnglists_buffer
)
3222 if (! read_debug_rnglists (unit
))
3226 rngs_ptr
= unit
->file
->dwarf_rnglists_buffer
+ offset
;
3227 if (rngs_ptr
< unit
->file
->dwarf_rnglists_buffer
)
3229 rngs_end
= unit
->file
->dwarf_rnglists_buffer
;
3230 rngs_end
+= unit
->file
->dwarf_rnglists_size
;
3234 enum dwarf_range_list_entry rlet
;
3235 unsigned int bytes_read
;
3237 if (rngs_ptr
+ 1 > rngs_end
)
3240 rlet
= read_1_byte (abfd
, rngs_ptr
, rngs_end
);
3245 case DW_RLE_end_of_list
:
3248 case DW_RLE_base_address
:
3249 if (rngs_ptr
+ unit
->addr_size
> rngs_end
)
3251 base_address
= read_address (unit
, rngs_ptr
, rngs_end
);
3252 rngs_ptr
+= unit
->addr_size
;
3255 case DW_RLE_start_length
:
3256 if (rngs_ptr
+ unit
->addr_size
> rngs_end
)
3258 low_pc
= read_address (unit
, rngs_ptr
, rngs_end
);
3259 rngs_ptr
+= unit
->addr_size
;
3261 high_pc
+= _bfd_safe_read_leb128 (abfd
, rngs_ptr
, &bytes_read
,
3263 rngs_ptr
+= bytes_read
;
3266 case DW_RLE_offset_pair
:
3267 low_pc
= base_address
;
3268 low_pc
+= _bfd_safe_read_leb128 (abfd
, rngs_ptr
, &bytes_read
,
3270 rngs_ptr
+= bytes_read
;
3271 high_pc
= base_address
;
3272 high_pc
+= _bfd_safe_read_leb128 (abfd
, rngs_ptr
, &bytes_read
,
3274 rngs_ptr
+= bytes_read
;
3277 case DW_RLE_start_end
:
3278 if (rngs_ptr
+ 2 * unit
->addr_size
> rngs_end
)
3280 low_pc
= read_address (unit
, rngs_ptr
, rngs_end
);
3281 rngs_ptr
+= unit
->addr_size
;
3282 high_pc
= read_address (unit
, rngs_ptr
, rngs_end
);
3283 rngs_ptr
+= unit
->addr_size
;
3286 /* TODO x-variants need .debug_addr support used for split-dwarf. */
3287 case DW_RLE_base_addressx
:
3288 case DW_RLE_startx_endx
:
3289 case DW_RLE_startx_length
:
3294 if (!arange_add (unit
, arange
, low_pc
, high_pc
))
3300 read_rangelist (struct comp_unit
*unit
, struct arange
*arange
,
3301 bfd_uint64_t offset
)
3303 if (unit
->version
<= 4)
3304 return read_ranges (unit
, arange
, offset
);
3306 return read_rnglists (unit
, arange
, offset
);
3309 static struct funcinfo
*
3310 lookup_func_by_offset (bfd_uint64_t offset
, struct funcinfo
* table
)
3312 for (; table
!= NULL
; table
= table
->prev_func
)
3313 if (table
->unit_offset
== offset
)
3318 static struct varinfo
*
3319 lookup_var_by_offset (bfd_uint64_t offset
, struct varinfo
* table
)
3323 if (table
->unit_offset
== offset
)
3325 table
= table
->prev_var
;
3332 /* DWARF2 Compilation unit functions. */
3334 /* Scan over each die in a comp. unit looking for functions to add
3335 to the function table and variables to the variable table. */
3338 scan_unit_for_symbols (struct comp_unit
*unit
)
3340 bfd
*abfd
= unit
->abfd
;
3341 bfd_byte
*info_ptr
= unit
->first_child_die_ptr
;
3342 bfd_byte
*info_ptr_end
= unit
->end_ptr
;
3343 int nesting_level
= 0;
3344 struct nest_funcinfo
3346 struct funcinfo
*func
;
3348 int nested_funcs_size
;
3350 /* Maintain a stack of in-scope functions and inlined functions, which we
3351 can use to set the caller_func field. */
3352 nested_funcs_size
= 32;
3353 nested_funcs
= (struct nest_funcinfo
*)
3354 bfd_malloc (nested_funcs_size
* sizeof (*nested_funcs
));
3355 if (nested_funcs
== NULL
)
3357 nested_funcs
[nesting_level
].func
= 0;
3359 /* PR 27484: We must scan the DIEs twice. The first time we look for
3360 function and variable tags and accumulate them into their respective
3361 tables. The second time through we process the attributes of the
3362 functions/variables and augment the table entries. */
3363 while (nesting_level
>= 0)
3365 unsigned int abbrev_number
, bytes_read
, i
;
3366 struct abbrev_info
*abbrev
;
3367 struct funcinfo
*func
;
3368 struct varinfo
*var
;
3369 bfd_uint64_t current_offset
;
3371 /* PR 17512: file: 9f405d9d. */
3372 if (info_ptr
>= info_ptr_end
)
3375 current_offset
= info_ptr
- unit
->info_ptr_unit
;
3376 abbrev_number
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
3377 FALSE
, info_ptr_end
);
3378 info_ptr
+= bytes_read
;
3380 if (abbrev_number
== 0)
3386 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
3389 static unsigned int previous_failed_abbrev
= -1U;
3391 /* Avoid multiple reports of the same missing abbrev. */
3392 if (abbrev_number
!= previous_failed_abbrev
)
3395 (_("DWARF error: could not find abbrev number %u"),
3397 previous_failed_abbrev
= abbrev_number
;
3399 bfd_set_error (bfd_error_bad_value
);
3403 if (abbrev
->tag
== DW_TAG_subprogram
3404 || abbrev
->tag
== DW_TAG_entry_point
3405 || abbrev
->tag
== DW_TAG_inlined_subroutine
)
3407 size_t amt
= sizeof (struct funcinfo
);
3410 func
= (struct funcinfo
*) bfd_zalloc (abfd
, amt
);
3413 func
->tag
= abbrev
->tag
;
3414 func
->prev_func
= unit
->function_table
;
3415 func
->unit_offset
= current_offset
;
3416 unit
->function_table
= func
;
3417 unit
->number_of_functions
++;
3418 BFD_ASSERT (!unit
->cached
);
3420 if (func
->tag
== DW_TAG_inlined_subroutine
)
3421 for (i
= nesting_level
; i
-- != 0; )
3422 if (nested_funcs
[i
].func
)
3424 func
->caller_func
= nested_funcs
[i
].func
;
3427 nested_funcs
[nesting_level
].func
= func
;
3432 if (abbrev
->tag
== DW_TAG_variable
3433 || abbrev
->tag
== DW_TAG_member
)
3435 size_t amt
= sizeof (struct varinfo
);
3437 var
= (struct varinfo
*) bfd_zalloc (abfd
, amt
);
3440 var
->tag
= abbrev
->tag
;
3442 var
->prev_var
= unit
->variable_table
;
3443 unit
->variable_table
= var
;
3444 var
->unit_offset
= current_offset
;
3445 /* PR 18205: Missing debug information can cause this
3446 var to be attached to an already cached unit. */
3451 /* No inline function in scope at this nesting level. */
3452 nested_funcs
[nesting_level
].func
= 0;
3455 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3457 struct attribute attr
;
3459 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
],
3460 unit
, info_ptr
, info_ptr_end
);
3461 if (info_ptr
== NULL
)
3465 if (abbrev
->has_children
)
3469 if (nesting_level
>= nested_funcs_size
)
3471 struct nest_funcinfo
*tmp
;
3473 nested_funcs_size
*= 2;
3474 tmp
= (struct nest_funcinfo
*)
3475 bfd_realloc (nested_funcs
,
3476 nested_funcs_size
* sizeof (*nested_funcs
));
3481 nested_funcs
[nesting_level
].func
= 0;
3485 /* This is the second pass over the abbrevs. */
3486 info_ptr
= unit
->first_child_die_ptr
;
3489 while (nesting_level
>= 0)
3491 unsigned int abbrev_number
, bytes_read
, i
;
3492 struct abbrev_info
*abbrev
;
3493 struct attribute attr
;
3494 struct funcinfo
*func
;
3495 struct varinfo
*var
;
3497 bfd_vma high_pc
= 0;
3498 bfd_boolean high_pc_relative
= FALSE
;
3499 bfd_uint64_t current_offset
;
3501 /* PR 17512: file: 9f405d9d. */
3502 if (info_ptr
>= info_ptr_end
)
3505 current_offset
= info_ptr
- unit
->info_ptr_unit
;
3506 abbrev_number
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
3507 FALSE
, info_ptr_end
);
3508 info_ptr
+= bytes_read
;
3510 if (! abbrev_number
)
3516 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
3517 /* This should have been handled above. */
3518 BFD_ASSERT (abbrev
!= NULL
);
3522 if (abbrev
->tag
== DW_TAG_subprogram
3523 || abbrev
->tag
== DW_TAG_entry_point
3524 || abbrev
->tag
== DW_TAG_inlined_subroutine
)
3526 func
= lookup_func_by_offset (current_offset
, unit
->function_table
);
3530 else if (abbrev
->tag
== DW_TAG_variable
3531 || abbrev
->tag
== DW_TAG_member
)
3533 var
= lookup_var_by_offset (current_offset
, unit
->variable_table
);
3538 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3540 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
],
3541 unit
, info_ptr
, info_ptr_end
);
3542 if (info_ptr
== NULL
)
3549 case DW_AT_call_file
:
3550 func
->caller_file
= concat_filename (unit
->line_table
,
3554 case DW_AT_call_line
:
3555 func
->caller_line
= attr
.u
.val
;
3558 case DW_AT_abstract_origin
:
3559 case DW_AT_specification
:
3560 if (!find_abstract_instance (unit
, &attr
, 0,
3569 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
3571 if (func
->name
== NULL
&& is_str_attr (attr
.form
))
3573 func
->name
= attr
.u
.str
;
3574 if (non_mangled (unit
->lang
))
3575 func
->is_linkage
= TRUE
;
3579 case DW_AT_linkage_name
:
3580 case DW_AT_MIPS_linkage_name
:
3581 /* PR 16949: Corrupt debug info can place
3582 non-string forms into these attributes. */
3583 if (is_str_attr (attr
.form
))
3585 func
->name
= attr
.u
.str
;
3586 func
->is_linkage
= TRUE
;
3591 low_pc
= attr
.u
.val
;
3595 high_pc
= attr
.u
.val
;
3596 high_pc_relative
= attr
.form
!= DW_FORM_addr
;
3600 if (!read_rangelist (unit
, &func
->arange
, attr
.u
.val
))
3604 case DW_AT_decl_file
:
3605 func
->file
= concat_filename (unit
->line_table
,
3609 case DW_AT_decl_line
:
3610 func
->line
= attr
.u
.val
;
3621 case DW_AT_specification
:
3624 struct varinfo
* spec_var
;
3626 spec_var
= lookup_var_by_offset (attr
.u
.val
,
3627 unit
->variable_table
);
3628 if (spec_var
== NULL
)
3630 _bfd_error_handler (_("DWARF error: could not find "
3631 "variable specification "
3633 (unsigned long) attr
.u
.val
);
3637 if (var
->name
== NULL
)
3638 var
->name
= spec_var
->name
;
3639 if (var
->file
== NULL
&& spec_var
->file
!= NULL
)
3640 var
->file
= strdup (spec_var
->file
);
3642 var
->line
= spec_var
->line
;
3643 if (var
->sec
== NULL
)
3644 var
->sec
= spec_var
->sec
;
3649 if (is_str_attr (attr
.form
))
3650 var
->name
= attr
.u
.str
;
3653 case DW_AT_decl_file
:
3654 var
->file
= concat_filename (unit
->line_table
,
3658 case DW_AT_decl_line
:
3659 var
->line
= attr
.u
.val
;
3662 case DW_AT_external
:
3663 if (attr
.u
.val
!= 0)
3667 case DW_AT_location
:
3671 case DW_FORM_block1
:
3672 case DW_FORM_block2
:
3673 case DW_FORM_block4
:
3674 case DW_FORM_exprloc
:
3675 if (attr
.u
.blk
->data
!= NULL
3676 && *attr
.u
.blk
->data
== DW_OP_addr
)
3680 /* Verify that DW_OP_addr is the only opcode in the
3681 location, in which case the block size will be 1
3682 plus the address size. */
3683 /* ??? For TLS variables, gcc can emit
3684 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
3685 which we don't handle here yet. */
3686 if (attr
.u
.blk
->size
== unit
->addr_size
+ 1U)
3687 var
->addr
= bfd_get (unit
->addr_size
* 8,
3689 attr
.u
.blk
->data
+ 1);
3704 if (abbrev
->has_children
)
3707 if (high_pc_relative
)
3710 if (func
&& high_pc
!= 0)
3712 if (!arange_add (unit
, &func
->arange
, low_pc
, high_pc
))
3717 free (nested_funcs
);
3721 free (nested_funcs
);
3725 /* Parse a DWARF2 compilation unit starting at INFO_PTR. UNIT_LENGTH
3726 includes the compilation unit header that proceeds the DIE's, but
3727 does not include the length field that precedes each compilation
3728 unit header. END_PTR points one past the end of this comp unit.
3729 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
3731 This routine does not read the whole compilation unit; only enough
3732 to get to the line number information for the compilation unit. */
3734 static struct comp_unit
*
3735 parse_comp_unit (struct dwarf2_debug
*stash
,
3736 struct dwarf2_debug_file
*file
,
3738 bfd_vma unit_length
,
3739 bfd_byte
*info_ptr_unit
,
3740 unsigned int offset_size
)
3742 struct comp_unit
* unit
;
3743 unsigned int version
;
3744 bfd_uint64_t abbrev_offset
= 0;
3745 /* Initialize it just to avoid a GCC false warning. */
3746 unsigned int addr_size
= -1;
3747 struct abbrev_info
** abbrevs
;
3748 unsigned int abbrev_number
, bytes_read
, i
;
3749 struct abbrev_info
*abbrev
;
3750 struct attribute attr
;
3751 bfd_byte
*end_ptr
= info_ptr
+ unit_length
;
3754 bfd_vma high_pc
= 0;
3755 bfd
*abfd
= file
->bfd_ptr
;
3756 bfd_boolean high_pc_relative
= FALSE
;
3757 enum dwarf_unit_type unit_type
;
3759 version
= read_2_bytes (abfd
, info_ptr
, end_ptr
);
3761 if (version
< 2 || version
> 5)
3763 /* PR 19872: A version number of 0 probably means that there is padding
3764 at the end of the .debug_info section. Gold puts it there when
3765 performing an incremental link, for example. So do not generate
3766 an error, just return a NULL. */
3770 (_("DWARF error: found dwarf version '%u', this reader"
3771 " only handles version 2, 3, 4 and 5 information"), version
);
3772 bfd_set_error (bfd_error_bad_value
);
3778 unit_type
= DW_UT_compile
;
3781 unit_type
= read_1_byte (abfd
, info_ptr
, end_ptr
);
3784 addr_size
= read_1_byte (abfd
, info_ptr
, end_ptr
);
3788 BFD_ASSERT (offset_size
== 4 || offset_size
== 8);
3789 if (offset_size
== 4)
3790 abbrev_offset
= read_4_bytes (abfd
, info_ptr
, end_ptr
);
3792 abbrev_offset
= read_8_bytes (abfd
, info_ptr
, end_ptr
);
3793 info_ptr
+= offset_size
;
3797 addr_size
= read_1_byte (abfd
, info_ptr
, end_ptr
);
3801 if (unit_type
== DW_UT_type
)
3803 /* Skip type signature. */
3806 /* Skip type offset. */
3807 info_ptr
+= offset_size
;
3810 if (addr_size
> sizeof (bfd_vma
))
3813 /* xgettext: c-format */
3814 (_("DWARF error: found address size '%u', this reader"
3815 " can not handle sizes greater than '%u'"),
3817 (unsigned int) sizeof (bfd_vma
));
3818 bfd_set_error (bfd_error_bad_value
);
3822 if (addr_size
!= 2 && addr_size
!= 4 && addr_size
!= 8)
3825 ("DWARF error: found address size '%u', this reader"
3826 " can only handle address sizes '2', '4' and '8'", addr_size
);
3827 bfd_set_error (bfd_error_bad_value
);
3831 /* Read the abbrevs for this compilation unit into a table. */
3832 abbrevs
= read_abbrevs (abfd
, abbrev_offset
, stash
, file
);
3836 abbrev_number
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
3838 info_ptr
+= bytes_read
;
3839 if (! abbrev_number
)
3841 /* PR 19872: An abbrev number of 0 probably means that there is padding
3842 at the end of the .debug_abbrev section. Gold puts it there when
3843 performing an incremental link, for example. So do not generate
3844 an error, just return a NULL. */
3848 abbrev
= lookup_abbrev (abbrev_number
, abbrevs
);
3851 _bfd_error_handler (_("DWARF error: could not find abbrev number %u"),
3853 bfd_set_error (bfd_error_bad_value
);
3857 amt
= sizeof (struct comp_unit
);
3858 unit
= (struct comp_unit
*) bfd_zalloc (abfd
, amt
);
3862 unit
->version
= version
;
3863 unit
->addr_size
= addr_size
;
3864 unit
->offset_size
= offset_size
;
3865 unit
->abbrevs
= abbrevs
;
3866 unit
->end_ptr
= end_ptr
;
3867 unit
->stash
= stash
;
3869 unit
->info_ptr_unit
= info_ptr_unit
;
3871 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3873 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
, end_ptr
);
3874 if (info_ptr
== NULL
)
3877 /* Store the data if it is of an attribute we want to keep in a
3878 partial symbol table. */
3881 case DW_AT_stmt_list
:
3883 unit
->line_offset
= attr
.u
.val
;
3887 if (is_str_attr (attr
.form
))
3888 unit
->name
= attr
.u
.str
;
3892 low_pc
= attr
.u
.val
;
3893 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
3894 this is the base address to use when reading location
3895 lists or range lists. */
3896 if (abbrev
->tag
== DW_TAG_compile_unit
)
3897 unit
->base_address
= low_pc
;
3901 high_pc
= attr
.u
.val
;
3902 high_pc_relative
= attr
.form
!= DW_FORM_addr
;
3906 if (!read_rangelist (unit
, &unit
->arange
, attr
.u
.val
))
3910 case DW_AT_comp_dir
:
3912 char *comp_dir
= attr
.u
.str
;
3914 /* PR 17512: file: 1fe726be. */
3915 if (! is_str_attr (attr
.form
))
3918 (_("DWARF error: DW_AT_comp_dir attribute encountered with a non-string form"));
3924 /* Irix 6.2 native cc prepends <machine>.: to the compilation
3925 directory, get rid of it. */
3926 char *cp
= strchr (comp_dir
, ':');
3928 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
3931 unit
->comp_dir
= comp_dir
;
3935 case DW_AT_language
:
3936 unit
->lang
= attr
.u
.val
;
3943 if (high_pc_relative
)
3947 if (!arange_add (unit
, &unit
->arange
, low_pc
, high_pc
))
3951 unit
->first_child_die_ptr
= info_ptr
;
3955 /* Return TRUE if UNIT may contain the address given by ADDR. When
3956 there are functions written entirely with inline asm statements, the
3957 range info in the compilation unit header may not be correct. We
3958 need to consult the line info table to see if a compilation unit
3959 really contains the given address. */
3962 comp_unit_contains_address (struct comp_unit
*unit
, bfd_vma addr
)
3964 struct arange
*arange
;
3969 arange
= &unit
->arange
;
3972 if (addr
>= arange
->low
&& addr
< arange
->high
)
3974 arange
= arange
->next
;
3981 /* If UNIT contains ADDR, set the output parameters to the values for
3982 the line containing ADDR. The output parameters, FILENAME_PTR,
3983 FUNCTION_PTR, and LINENUMBER_PTR, are pointers to the objects
3986 Returns the range of addresses covered by the entry that was used
3987 to fill in *LINENUMBER_PTR or 0 if it was not filled in. */
3990 comp_unit_find_nearest_line (struct comp_unit
*unit
,
3992 const char **filename_ptr
,
3993 struct funcinfo
**function_ptr
,
3994 unsigned int *linenumber_ptr
,
3995 unsigned int *discriminator_ptr
)
3999 if (!comp_unit_maybe_decode_line_info (unit
))
4002 *function_ptr
= NULL
;
4003 func_p
= lookup_address_in_function_table (unit
, addr
, function_ptr
);
4004 if (func_p
&& (*function_ptr
)->tag
== DW_TAG_inlined_subroutine
)
4005 unit
->stash
->inliner_chain
= *function_ptr
;
4007 return lookup_address_in_line_info_table (unit
->line_table
, addr
,
4013 /* Check to see if line info is already decoded in a comp_unit.
4014 If not, decode it. Returns TRUE if no errors were encountered;
4018 comp_unit_maybe_decode_line_info (struct comp_unit
*unit
)
4023 if (! unit
->line_table
)
4025 if (! unit
->stmtlist
)
4031 unit
->line_table
= decode_line_info (unit
);
4033 if (! unit
->line_table
)
4039 if (unit
->first_child_die_ptr
< unit
->end_ptr
4040 && ! scan_unit_for_symbols (unit
))
4050 /* If UNIT contains SYM at ADDR, set the output parameters to the
4051 values for the line containing SYM. The output parameters,
4052 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
4055 Return TRUE if UNIT contains SYM, and no errors were encountered;
4059 comp_unit_find_line (struct comp_unit
*unit
,
4062 const char **filename_ptr
,
4063 unsigned int *linenumber_ptr
)
4065 if (!comp_unit_maybe_decode_line_info (unit
))
4068 if (sym
->flags
& BSF_FUNCTION
)
4069 return lookup_symbol_in_function_table (unit
, sym
, addr
,
4073 return lookup_symbol_in_variable_table (unit
, sym
, addr
,
4078 static struct funcinfo
*
4079 reverse_funcinfo_list (struct funcinfo
*head
)
4081 struct funcinfo
*rhead
;
4082 struct funcinfo
*temp
;
4084 for (rhead
= NULL
; head
; head
= temp
)
4086 temp
= head
->prev_func
;
4087 head
->prev_func
= rhead
;
4093 static struct varinfo
*
4094 reverse_varinfo_list (struct varinfo
*head
)
4096 struct varinfo
*rhead
;
4097 struct varinfo
*temp
;
4099 for (rhead
= NULL
; head
; head
= temp
)
4101 temp
= head
->prev_var
;
4102 head
->prev_var
= rhead
;
4108 /* Extract all interesting funcinfos and varinfos of a compilation
4109 unit into hash tables for faster lookup. Returns TRUE if no
4110 errors were enountered; FALSE otherwise. */
4113 comp_unit_hash_info (struct dwarf2_debug
*stash
,
4114 struct comp_unit
*unit
,
4115 struct info_hash_table
*funcinfo_hash_table
,
4116 struct info_hash_table
*varinfo_hash_table
)
4118 struct funcinfo
* each_func
;
4119 struct varinfo
* each_var
;
4120 bfd_boolean okay
= TRUE
;
4122 BFD_ASSERT (stash
->info_hash_status
!= STASH_INFO_HASH_DISABLED
);
4124 if (!comp_unit_maybe_decode_line_info (unit
))
4127 BFD_ASSERT (!unit
->cached
);
4129 /* To preserve the original search order, we went to visit the function
4130 infos in the reversed order of the list. However, making the list
4131 bi-directional use quite a bit of extra memory. So we reverse
4132 the list first, traverse the list in the now reversed order and
4133 finally reverse the list again to get back the original order. */
4134 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
4135 for (each_func
= unit
->function_table
;
4137 each_func
= each_func
->prev_func
)
4139 /* Skip nameless functions. */
4140 if (each_func
->name
)
4141 /* There is no need to copy name string into hash table as
4142 name string is either in the dwarf string buffer or
4143 info in the stash. */
4144 okay
= insert_info_hash_table (funcinfo_hash_table
, each_func
->name
,
4145 (void*) each_func
, FALSE
);
4147 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
4151 /* We do the same for variable infos. */
4152 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
4153 for (each_var
= unit
->variable_table
;
4155 each_var
= each_var
->prev_var
)
4157 /* Skip stack vars and vars with no files or names. */
4158 if (! each_var
->stack
4159 && each_var
->file
!= NULL
4160 && each_var
->name
!= NULL
)
4161 /* There is no need to copy name string into hash table as
4162 name string is either in the dwarf string buffer or
4163 info in the stash. */
4164 okay
= insert_info_hash_table (varinfo_hash_table
, each_var
->name
,
4165 (void*) each_var
, FALSE
);
4168 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
4169 unit
->cached
= TRUE
;
4173 /* Locate a section in a BFD containing debugging info. The search starts
4174 from the section after AFTER_SEC, or from the first section in the BFD if
4175 AFTER_SEC is NULL. The search works by examining the names of the
4176 sections. There are three permissiable names. The first two are given
4177 by DEBUG_SECTIONS[debug_info] (whose standard DWARF2 names are .debug_info
4178 and .zdebug_info). The third is a prefix .gnu.linkonce.wi.
4179 This is a variation on the .debug_info section which has a checksum
4180 describing the contents appended onto the name. This allows the linker to
4181 identify and discard duplicate debugging sections for different
4182 compilation units. */
4183 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
4186 find_debug_info (bfd
*abfd
, const struct dwarf_debug_section
*debug_sections
,
4187 asection
*after_sec
)
4192 if (after_sec
== NULL
)
4194 look
= debug_sections
[debug_info
].uncompressed_name
;
4195 msec
= bfd_get_section_by_name (abfd
, look
);
4199 look
= debug_sections
[debug_info
].compressed_name
;
4202 msec
= bfd_get_section_by_name (abfd
, look
);
4207 for (msec
= abfd
->sections
; msec
!= NULL
; msec
= msec
->next
)
4208 if (CONST_STRNEQ (msec
->name
, GNU_LINKONCE_INFO
))
4214 for (msec
= after_sec
->next
; msec
!= NULL
; msec
= msec
->next
)
4216 look
= debug_sections
[debug_info
].uncompressed_name
;
4217 if (strcmp (msec
->name
, look
) == 0)
4220 look
= debug_sections
[debug_info
].compressed_name
;
4221 if (look
!= NULL
&& strcmp (msec
->name
, look
) == 0)
4224 if (CONST_STRNEQ (msec
->name
, GNU_LINKONCE_INFO
))
4231 /* Transfer VMAs from object file to separate debug file. */
4234 set_debug_vma (bfd
*orig_bfd
, bfd
*debug_bfd
)
4238 for (s
= orig_bfd
->sections
, d
= debug_bfd
->sections
;
4239 s
!= NULL
&& d
!= NULL
;
4240 s
= s
->next
, d
= d
->next
)
4242 if ((d
->flags
& SEC_DEBUGGING
) != 0)
4244 /* ??? Assumes 1-1 correspondence between sections in the
4246 if (strcmp (s
->name
, d
->name
) == 0)
4248 d
->output_section
= s
->output_section
;
4249 d
->output_offset
= s
->output_offset
;
4255 /* If the dwarf2 info was found in a separate debug file, return the
4256 debug file section corresponding to the section in the original file
4257 and the debug file symbols. */
4260 _bfd_dwarf2_stash_syms (struct dwarf2_debug
*stash
, bfd
*abfd
,
4261 asection
**sec
, asymbol
***syms
)
4263 if (stash
->f
.bfd_ptr
!= abfd
)
4269 *syms
= stash
->f
.syms
;
4273 for (s
= abfd
->sections
, d
= stash
->f
.bfd_ptr
->sections
;
4274 s
!= NULL
&& d
!= NULL
;
4275 s
= s
->next
, d
= d
->next
)
4277 if ((d
->flags
& SEC_DEBUGGING
) != 0)
4280 && strcmp (s
->name
, d
->name
) == 0)
4283 *syms
= stash
->f
.syms
;
4290 /* Unset vmas for adjusted sections in STASH. */
4293 unset_sections (struct dwarf2_debug
*stash
)
4296 struct adjusted_section
*p
;
4298 i
= stash
->adjusted_section_count
;
4299 p
= stash
->adjusted_sections
;
4300 for (; i
> 0; i
--, p
++)
4301 p
->section
->vma
= 0;
4304 /* Set VMAs for allocated and .debug_info sections in ORIG_BFD, a
4305 relocatable object file. VMAs are normally all zero in relocatable
4306 object files, so if we want to distinguish locations in sections by
4307 address we need to set VMAs so the sections do not overlap. We
4308 also set VMA on .debug_info so that when we have multiple
4309 .debug_info sections (or the linkonce variant) they also do not
4310 overlap. The multiple .debug_info sections make up a single
4311 logical section. ??? We should probably do the same for other
4315 place_sections (bfd
*orig_bfd
, struct dwarf2_debug
*stash
)
4318 struct adjusted_section
*p
;
4320 const char *debug_info_name
;
4322 if (stash
->adjusted_section_count
!= 0)
4324 i
= stash
->adjusted_section_count
;
4325 p
= stash
->adjusted_sections
;
4326 for (; i
> 0; i
--, p
++)
4327 p
->section
->vma
= p
->adj_vma
;
4331 debug_info_name
= stash
->debug_sections
[debug_info
].uncompressed_name
;
4338 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
4342 if ((sect
->output_section
!= NULL
4343 && sect
->output_section
!= sect
4344 && (sect
->flags
& SEC_DEBUGGING
) == 0)
4348 is_debug_info
= (strcmp (sect
->name
, debug_info_name
) == 0
4349 || CONST_STRNEQ (sect
->name
, GNU_LINKONCE_INFO
));
4351 if (!((sect
->flags
& SEC_ALLOC
) != 0 && abfd
== orig_bfd
)
4357 if (abfd
== stash
->f
.bfd_ptr
)
4359 abfd
= stash
->f
.bfd_ptr
;
4363 stash
->adjusted_section_count
= -1;
4366 bfd_vma last_vma
= 0, last_dwarf
= 0;
4367 size_t amt
= i
* sizeof (struct adjusted_section
);
4369 p
= (struct adjusted_section
*) bfd_malloc (amt
);
4373 stash
->adjusted_sections
= p
;
4374 stash
->adjusted_section_count
= i
;
4381 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
4386 if ((sect
->output_section
!= NULL
4387 && sect
->output_section
!= sect
4388 && (sect
->flags
& SEC_DEBUGGING
) == 0)
4392 is_debug_info
= (strcmp (sect
->name
, debug_info_name
) == 0
4393 || CONST_STRNEQ (sect
->name
, GNU_LINKONCE_INFO
));
4395 if (!((sect
->flags
& SEC_ALLOC
) != 0 && abfd
== orig_bfd
)
4399 sz
= sect
->rawsize
? sect
->rawsize
: sect
->size
;
4403 BFD_ASSERT (sect
->alignment_power
== 0);
4404 sect
->vma
= last_dwarf
;
4409 /* Align the new address to the current section
4411 last_vma
= ((last_vma
4412 + ~(-((bfd_vma
) 1 << sect
->alignment_power
)))
4413 & (-((bfd_vma
) 1 << sect
->alignment_power
)));
4414 sect
->vma
= last_vma
;
4419 p
->adj_vma
= sect
->vma
;
4422 if (abfd
== stash
->f
.bfd_ptr
)
4424 abfd
= stash
->f
.bfd_ptr
;
4428 if (orig_bfd
!= stash
->f
.bfd_ptr
)
4429 set_debug_vma (orig_bfd
, stash
->f
.bfd_ptr
);
4434 /* Look up a funcinfo by name using the given info hash table. If found,
4435 also update the locations pointed to by filename_ptr and linenumber_ptr.
4437 This function returns TRUE if a funcinfo that matches the given symbol
4438 and address is found with any error; otherwise it returns FALSE. */
4441 info_hash_lookup_funcinfo (struct info_hash_table
*hash_table
,
4444 const char **filename_ptr
,
4445 unsigned int *linenumber_ptr
)
4447 struct funcinfo
* each_func
;
4448 struct funcinfo
* best_fit
= NULL
;
4449 bfd_vma best_fit_len
= 0;
4450 struct info_list_node
*node
;
4451 struct arange
*arange
;
4452 const char *name
= bfd_asymbol_name (sym
);
4453 asection
*sec
= bfd_asymbol_section (sym
);
4455 for (node
= lookup_info_hash_table (hash_table
, name
);
4459 each_func
= (struct funcinfo
*) node
->info
;
4460 for (arange
= &each_func
->arange
;
4462 arange
= arange
->next
)
4464 if ((!each_func
->sec
|| each_func
->sec
== sec
)
4465 && addr
>= arange
->low
4466 && addr
< arange
->high
4468 || arange
->high
- arange
->low
< best_fit_len
))
4470 best_fit
= each_func
;
4471 best_fit_len
= arange
->high
- arange
->low
;
4478 best_fit
->sec
= sec
;
4479 *filename_ptr
= best_fit
->file
;
4480 *linenumber_ptr
= best_fit
->line
;
4487 /* Look up a varinfo by name using the given info hash table. If found,
4488 also update the locations pointed to by filename_ptr and linenumber_ptr.
4490 This function returns TRUE if a varinfo that matches the given symbol
4491 and address is found with any error; otherwise it returns FALSE. */
4494 info_hash_lookup_varinfo (struct info_hash_table
*hash_table
,
4497 const char **filename_ptr
,
4498 unsigned int *linenumber_ptr
)
4500 const char *name
= bfd_asymbol_name (sym
);
4501 asection
*sec
= bfd_asymbol_section (sym
);
4502 struct varinfo
* each
;
4503 struct info_list_node
*node
;
4505 for (node
= lookup_info_hash_table (hash_table
, name
);
4509 each
= (struct varinfo
*) node
->info
;
4510 if (each
->addr
== addr
4511 && (!each
->sec
|| each
->sec
== sec
))
4514 *filename_ptr
= each
->file
;
4515 *linenumber_ptr
= each
->line
;
4523 /* Update the funcinfo and varinfo info hash tables if they are
4524 not up to date. Returns TRUE if there is no error; otherwise
4525 returns FALSE and disable the info hash tables. */
4528 stash_maybe_update_info_hash_tables (struct dwarf2_debug
*stash
)
4530 struct comp_unit
*each
;
4532 /* Exit if hash tables are up-to-date. */
4533 if (stash
->f
.all_comp_units
== stash
->hash_units_head
)
4536 if (stash
->hash_units_head
)
4537 each
= stash
->hash_units_head
->prev_unit
;
4539 each
= stash
->f
.last_comp_unit
;
4543 if (!comp_unit_hash_info (stash
, each
, stash
->funcinfo_hash_table
,
4544 stash
->varinfo_hash_table
))
4546 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
4549 each
= each
->prev_unit
;
4552 stash
->hash_units_head
= stash
->f
.all_comp_units
;
4556 /* Check consistency of info hash tables. This is for debugging only. */
4558 static void ATTRIBUTE_UNUSED
4559 stash_verify_info_hash_table (struct dwarf2_debug
*stash
)
4561 struct comp_unit
*each_unit
;
4562 struct funcinfo
*each_func
;
4563 struct varinfo
*each_var
;
4564 struct info_list_node
*node
;
4567 for (each_unit
= stash
->f
.all_comp_units
;
4569 each_unit
= each_unit
->next_unit
)
4571 for (each_func
= each_unit
->function_table
;
4573 each_func
= each_func
->prev_func
)
4575 if (!each_func
->name
)
4577 node
= lookup_info_hash_table (stash
->funcinfo_hash_table
,
4581 while (node
&& !found
)
4583 found
= node
->info
== each_func
;
4589 for (each_var
= each_unit
->variable_table
;
4591 each_var
= each_var
->prev_var
)
4593 if (!each_var
->name
|| !each_var
->file
|| each_var
->stack
)
4595 node
= lookup_info_hash_table (stash
->varinfo_hash_table
,
4599 while (node
&& !found
)
4601 found
= node
->info
== each_var
;
4609 /* Check to see if we want to enable the info hash tables, which consume
4610 quite a bit of memory. Currently we only check the number times
4611 bfd_dwarf2_find_line is called. In the future, we may also want to
4612 take the number of symbols into account. */
4615 stash_maybe_enable_info_hash_tables (bfd
*abfd
, struct dwarf2_debug
*stash
)
4617 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_OFF
);
4619 if (stash
->info_hash_count
++ < STASH_INFO_HASH_TRIGGER
)
4622 /* FIXME: Maybe we should check the reduce_memory_overheads
4623 and optimize fields in the bfd_link_info structure ? */
4625 /* Create hash tables. */
4626 stash
->funcinfo_hash_table
= create_info_hash_table (abfd
);
4627 stash
->varinfo_hash_table
= create_info_hash_table (abfd
);
4628 if (!stash
->funcinfo_hash_table
|| !stash
->varinfo_hash_table
)
4630 /* Turn off info hashes if any allocation above fails. */
4631 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
4634 /* We need a forced update so that the info hash tables will
4635 be created even though there is no compilation unit. That
4636 happens if STASH_INFO_HASH_TRIGGER is 0. */
4637 if (stash_maybe_update_info_hash_tables (stash
))
4638 stash
->info_hash_status
= STASH_INFO_HASH_ON
;
4641 /* Find the file and line associated with a symbol and address using the
4642 info hash tables of a stash. If there is a match, the function returns
4643 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
4644 otherwise it returns FALSE. */
4647 stash_find_line_fast (struct dwarf2_debug
*stash
,
4650 const char **filename_ptr
,
4651 unsigned int *linenumber_ptr
)
4653 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_ON
);
4655 if (sym
->flags
& BSF_FUNCTION
)
4656 return info_hash_lookup_funcinfo (stash
->funcinfo_hash_table
, sym
, addr
,
4657 filename_ptr
, linenumber_ptr
);
4658 return info_hash_lookup_varinfo (stash
->varinfo_hash_table
, sym
, addr
,
4659 filename_ptr
, linenumber_ptr
);
4662 /* Save current section VMAs. */
4665 save_section_vma (const bfd
*abfd
, struct dwarf2_debug
*stash
)
4670 if (abfd
->section_count
== 0)
4672 stash
->sec_vma
= bfd_malloc (sizeof (*stash
->sec_vma
) * abfd
->section_count
);
4673 if (stash
->sec_vma
== NULL
)
4675 stash
->sec_vma_count
= abfd
->section_count
;
4676 for (i
= 0, s
= abfd
->sections
;
4677 s
!= NULL
&& i
< abfd
->section_count
;
4680 if (s
->output_section
!= NULL
)
4681 stash
->sec_vma
[i
] = s
->output_section
->vma
+ s
->output_offset
;
4683 stash
->sec_vma
[i
] = s
->vma
;
4688 /* Compare current section VMAs against those at the time the stash
4689 was created. If find_nearest_line is used in linker warnings or
4690 errors early in the link process, the debug info stash will be
4691 invalid for later calls. This is because we relocate debug info
4692 sections, so the stashed section contents depend on symbol values,
4693 which in turn depend on section VMAs. */
4696 section_vma_same (const bfd
*abfd
, const struct dwarf2_debug
*stash
)
4701 /* PR 24334: If the number of sections in ABFD has changed between
4702 when the stash was created and now, then we cannot trust the
4703 stashed vma information. */
4704 if (abfd
->section_count
!= stash
->sec_vma_count
)
4707 for (i
= 0, s
= abfd
->sections
;
4708 s
!= NULL
&& i
< abfd
->section_count
;
4713 if (s
->output_section
!= NULL
)
4714 vma
= s
->output_section
->vma
+ s
->output_offset
;
4717 if (vma
!= stash
->sec_vma
[i
])
4723 /* Read debug information from DEBUG_BFD when DEBUG_BFD is specified.
4724 If DEBUG_BFD is not specified, we read debug information from ABFD
4725 or its gnu_debuglink. The results will be stored in PINFO.
4726 The function returns TRUE iff debug information is ready. */
4729 _bfd_dwarf2_slurp_debug_info (bfd
*abfd
, bfd
*debug_bfd
,
4730 const struct dwarf_debug_section
*debug_sections
,
4733 bfd_boolean do_place
)
4735 size_t amt
= sizeof (struct dwarf2_debug
);
4736 bfd_size_type total_size
;
4738 struct dwarf2_debug
*stash
= (struct dwarf2_debug
*) *pinfo
;
4742 if (stash
->orig_bfd
== abfd
4743 && section_vma_same (abfd
, stash
))
4745 /* Check that we did previously find some debug information
4746 before attempting to make use of it. */
4747 if (stash
->f
.bfd_ptr
!= NULL
)
4749 if (do_place
&& !place_sections (abfd
, stash
))
4756 _bfd_dwarf2_cleanup_debug_info (abfd
, pinfo
);
4757 memset (stash
, 0, amt
);
4761 stash
= (struct dwarf2_debug
*) bfd_zalloc (abfd
, amt
);
4765 stash
->orig_bfd
= abfd
;
4766 stash
->debug_sections
= debug_sections
;
4767 stash
->f
.syms
= symbols
;
4768 if (!save_section_vma (abfd
, stash
))
4771 stash
->f
.abbrev_offsets
= htab_create_alloc (10, hash_abbrev
, eq_abbrev
,
4772 del_abbrev
, calloc
, free
);
4773 if (!stash
->f
.abbrev_offsets
)
4776 stash
->alt
.abbrev_offsets
= htab_create_alloc (10, hash_abbrev
, eq_abbrev
,
4777 del_abbrev
, calloc
, free
);
4778 if (!stash
->alt
.abbrev_offsets
)
4783 if (debug_bfd
== NULL
)
4786 msec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
4787 if (msec
== NULL
&& abfd
== debug_bfd
)
4789 char * debug_filename
;
4791 debug_filename
= bfd_follow_build_id_debuglink (abfd
, DEBUGDIR
);
4792 if (debug_filename
== NULL
)
4793 debug_filename
= bfd_follow_gnu_debuglink (abfd
, DEBUGDIR
);
4795 if (debug_filename
== NULL
)
4796 /* No dwarf2 info, and no gnu_debuglink to follow.
4797 Note that at this point the stash has been allocated, but
4798 contains zeros. This lets future calls to this function
4799 fail more quickly. */
4802 debug_bfd
= bfd_openr (debug_filename
, NULL
);
4803 free (debug_filename
);
4804 if (debug_bfd
== NULL
)
4805 /* FIXME: Should we report our failure to follow the debuglink ? */
4808 /* Set BFD_DECOMPRESS to decompress debug sections. */
4809 debug_bfd
->flags
|= BFD_DECOMPRESS
;
4810 if (!bfd_check_format (debug_bfd
, bfd_object
)
4811 || (msec
= find_debug_info (debug_bfd
,
4812 debug_sections
, NULL
)) == NULL
4813 || !bfd_generic_link_read_symbols (debug_bfd
))
4815 bfd_close (debug_bfd
);
4819 symbols
= bfd_get_outsymbols (debug_bfd
);
4820 stash
->f
.syms
= symbols
;
4821 stash
->close_on_cleanup
= TRUE
;
4823 stash
->f
.bfd_ptr
= debug_bfd
;
4826 && !place_sections (abfd
, stash
))
4829 /* There can be more than one DWARF2 info section in a BFD these
4830 days. First handle the easy case when there's only one. If
4831 there's more than one, try case two: none of the sections is
4832 compressed. In that case, read them all in and produce one
4833 large stash. We do this in two passes - in the first pass we
4834 just accumulate the section sizes, and in the second pass we
4835 read in the section's contents. (The allows us to avoid
4836 reallocing the data as we add sections to the stash.) If
4837 some or all sections are compressed, then do things the slow
4838 way, with a bunch of reallocs. */
4840 if (! find_debug_info (debug_bfd
, debug_sections
, msec
))
4842 /* Case 1: only one info section. */
4843 total_size
= msec
->size
;
4844 if (! read_section (debug_bfd
, &stash
->debug_sections
[debug_info
],
4846 &stash
->f
.dwarf_info_buffer
, &total_size
))
4851 /* Case 2: multiple sections. */
4852 for (total_size
= 0;
4854 msec
= find_debug_info (debug_bfd
, debug_sections
, msec
))
4856 /* Catch PR25070 testcase overflowing size calculation here. */
4857 if (total_size
+ msec
->size
< total_size
4858 || total_size
+ msec
->size
< msec
->size
)
4860 bfd_set_error (bfd_error_no_memory
);
4863 total_size
+= msec
->size
;
4866 stash
->f
.dwarf_info_buffer
= (bfd_byte
*) bfd_malloc (total_size
);
4867 if (stash
->f
.dwarf_info_buffer
== NULL
)
4871 for (msec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
4873 msec
= find_debug_info (debug_bfd
, debug_sections
, msec
))
4881 if (!(bfd_simple_get_relocated_section_contents
4882 (debug_bfd
, msec
, stash
->f
.dwarf_info_buffer
+ total_size
,
4890 stash
->f
.info_ptr
= stash
->f
.dwarf_info_buffer
;
4891 stash
->f
.dwarf_info_size
= total_size
;
4895 /* Parse the next DWARF2 compilation unit at FILE->INFO_PTR. */
4897 static struct comp_unit
*
4898 stash_comp_unit (struct dwarf2_debug
*stash
, struct dwarf2_debug_file
*file
)
4900 bfd_size_type length
;
4901 unsigned int offset_size
;
4902 bfd_byte
*info_ptr_unit
= file
->info_ptr
;
4903 bfd_byte
*info_ptr_end
= file
->dwarf_info_buffer
+ file
->dwarf_info_size
;
4905 if (file
->info_ptr
>= info_ptr_end
)
4908 length
= read_4_bytes (file
->bfd_ptr
, file
->info_ptr
, info_ptr_end
);
4909 /* A 0xffffff length is the DWARF3 way of indicating
4910 we use 64-bit offsets, instead of 32-bit offsets. */
4911 if (length
== 0xffffffff)
4914 length
= read_8_bytes (file
->bfd_ptr
, file
->info_ptr
+ 4,
4916 file
->info_ptr
+= 12;
4918 /* A zero length is the IRIX way of indicating 64-bit offsets,
4919 mostly because the 64-bit length will generally fit in 32
4920 bits, and the endianness helps. */
4921 else if (length
== 0)
4924 length
= read_4_bytes (file
->bfd_ptr
, file
->info_ptr
+ 4,
4926 file
->info_ptr
+= 8;
4928 /* In the absence of the hints above, we assume 32-bit DWARF2
4929 offsets even for targets with 64-bit addresses, because:
4930 a) most of the time these targets will not have generated
4931 more than 2Gb of debug info and so will not need 64-bit
4934 b) if they do use 64-bit offsets but they are not using
4935 the size hints that are tested for above then they are
4936 not conforming to the DWARF3 standard anyway. */
4940 file
->info_ptr
+= 4;
4944 && file
->info_ptr
+ length
<= info_ptr_end
4945 && file
->info_ptr
+ length
> file
->info_ptr
)
4947 struct comp_unit
*each
= parse_comp_unit (stash
, file
,
4948 file
->info_ptr
, length
,
4949 info_ptr_unit
, offset_size
);
4952 if (file
->all_comp_units
)
4953 file
->all_comp_units
->prev_unit
= each
;
4955 file
->last_comp_unit
= each
;
4957 each
->next_unit
= file
->all_comp_units
;
4958 file
->all_comp_units
= each
;
4960 file
->info_ptr
+= length
;
4965 /* Don't trust any of the DWARF info after a corrupted length or
4967 file
->info_ptr
= info_ptr_end
;
4971 /* Hash function for an asymbol. */
4974 hash_asymbol (const void *sym
)
4976 const asymbol
*asym
= sym
;
4977 return htab_hash_string (asym
->name
);
4980 /* Equality function for asymbols. */
4983 eq_asymbol (const void *a
, const void *b
)
4985 const asymbol
*sa
= a
;
4986 const asymbol
*sb
= b
;
4987 return strcmp (sa
->name
, sb
->name
) == 0;
4990 /* Scan the debug information in PINFO looking for a DW_TAG_subprogram
4991 abbrev with a DW_AT_low_pc attached to it. Then lookup that same
4992 symbol in SYMBOLS and return the difference between the low_pc and
4993 the symbol's address. Returns 0 if no suitable symbol could be found. */
4996 _bfd_dwarf2_find_symbol_bias (asymbol
** symbols
, void ** pinfo
)
4998 struct dwarf2_debug
*stash
;
4999 struct comp_unit
* unit
;
5001 bfd_signed_vma result
= 0;
5004 stash
= (struct dwarf2_debug
*) *pinfo
;
5006 if (stash
== NULL
|| symbols
== NULL
)
5009 sym_hash
= htab_create_alloc (10, hash_asymbol
, eq_asymbol
,
5010 NULL
, xcalloc
, free
);
5011 for (psym
= symbols
; * psym
!= NULL
; psym
++)
5013 asymbol
* sym
= * psym
;
5015 if (sym
->flags
& BSF_FUNCTION
&& sym
->section
!= NULL
)
5017 void **slot
= htab_find_slot (sym_hash
, sym
, INSERT
);
5022 for (unit
= stash
->f
.all_comp_units
; unit
; unit
= unit
->next_unit
)
5024 struct funcinfo
* func
;
5026 comp_unit_maybe_decode_line_info (unit
);
5028 for (func
= unit
->function_table
; func
!= NULL
; func
= func
->prev_func
)
5029 if (func
->name
&& func
->arange
.low
)
5031 asymbol search
, *sym
;
5033 /* FIXME: Do we need to scan the aranges looking for the lowest pc value ? */
5035 search
.name
= func
->name
;
5036 sym
= htab_find (sym_hash
, &search
);
5039 result
= ((bfd_signed_vma
) func
->arange
.low
) -
5040 ((bfd_signed_vma
) (sym
->value
+ sym
->section
->vma
));
5047 htab_delete (sym_hash
);
5051 /* Find the source code location of SYMBOL. If SYMBOL is NULL
5052 then find the nearest source code location corresponding to
5053 the address SECTION + OFFSET.
5054 Returns 1 if the line is found without error and fills in
5055 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
5056 NULL the FUNCTIONNAME_PTR is also filled in.
5057 Returns 2 if partial information from _bfd_elf_find_function is
5058 returned (function and maybe file) by looking at symbols. DWARF2
5059 info is present but not regarding the requested code location.
5060 Returns 0 otherwise.
5061 SYMBOLS contains the symbol table for ABFD.
5062 DEBUG_SECTIONS contains the name of the dwarf debug sections. */
5065 _bfd_dwarf2_find_nearest_line (bfd
*abfd
,
5070 const char **filename_ptr
,
5071 const char **functionname_ptr
,
5072 unsigned int *linenumber_ptr
,
5073 unsigned int *discriminator_ptr
,
5074 const struct dwarf_debug_section
*debug_sections
,
5077 /* Read each compilation unit from the section .debug_info, and check
5078 to see if it contains the address we are searching for. If yes,
5079 lookup the address, and return the line number info. If no, go
5080 on to the next compilation unit.
5082 We keep a list of all the previously read compilation units, and
5083 a pointer to the next un-read compilation unit. Check the
5084 previously read units before reading more. */
5085 struct dwarf2_debug
*stash
;
5086 /* What address are we looking for? */
5088 struct comp_unit
* each
;
5089 struct funcinfo
*function
= NULL
;
5091 bfd_boolean do_line
;
5093 *filename_ptr
= NULL
;
5094 if (functionname_ptr
!= NULL
)
5095 *functionname_ptr
= NULL
;
5096 *linenumber_ptr
= 0;
5097 if (discriminator_ptr
)
5098 *discriminator_ptr
= 0;
5100 if (! _bfd_dwarf2_slurp_debug_info (abfd
, NULL
, debug_sections
,
5102 (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0))
5105 stash
= (struct dwarf2_debug
*) *pinfo
;
5107 do_line
= symbol
!= NULL
;
5110 BFD_ASSERT (section
== NULL
&& offset
== 0 && functionname_ptr
== NULL
);
5111 section
= bfd_asymbol_section (symbol
);
5112 addr
= symbol
->value
;
5116 BFD_ASSERT (section
!= NULL
&& functionname_ptr
!= NULL
);
5119 /* If we have no SYMBOL but the section we're looking at is not a
5120 code section, then take a look through the list of symbols to see
5121 if we have a symbol at the address we're looking for. If we do
5122 then use this to look up line information. This will allow us to
5123 give file and line results for data symbols. We exclude code
5124 symbols here, if we look up a function symbol and then look up the
5125 line information we'll actually return the line number for the
5126 opening '{' rather than the function definition line. This is
5127 because looking up by symbol uses the line table, in which the
5128 first line for a function is usually the opening '{', while
5129 looking up the function by section + offset uses the
5130 DW_AT_decl_line from the function DW_TAG_subprogram for the line,
5131 which will be the line of the function name. */
5132 if (symbols
!= NULL
&& (section
->flags
& SEC_CODE
) == 0)
5136 for (tmp
= symbols
; (*tmp
) != NULL
; ++tmp
)
5137 if ((*tmp
)->the_bfd
== abfd
5138 && (*tmp
)->section
== section
5139 && (*tmp
)->value
== offset
5140 && ((*tmp
)->flags
& BSF_SECTION_SYM
) == 0)
5144 /* For local symbols, keep going in the hope we find a
5146 if ((symbol
->flags
& BSF_GLOBAL
) != 0)
5152 if (section
->output_section
)
5153 addr
+= section
->output_section
->vma
+ section
->output_offset
;
5155 addr
+= section
->vma
;
5157 /* A null info_ptr indicates that there is no dwarf2 info
5158 (or that an error occured while setting up the stash). */
5159 if (! stash
->f
.info_ptr
)
5162 stash
->inliner_chain
= NULL
;
5164 /* Check the previously read comp. units first. */
5167 /* The info hash tables use quite a bit of memory. We may not want to
5168 always use them. We use some heuristics to decide if and when to
5170 if (stash
->info_hash_status
== STASH_INFO_HASH_OFF
)
5171 stash_maybe_enable_info_hash_tables (abfd
, stash
);
5173 /* Keep info hash table up to date if they are available. Note that we
5174 may disable the hash tables if there is any error duing update. */
5175 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
5176 stash_maybe_update_info_hash_tables (stash
);
5178 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
5180 found
= stash_find_line_fast (stash
, symbol
, addr
, filename_ptr
,
5187 /* Check the previously read comp. units first. */
5188 for (each
= stash
->f
.all_comp_units
; each
; each
= each
->next_unit
)
5189 if ((symbol
->flags
& BSF_FUNCTION
) == 0
5190 || each
->arange
.high
== 0
5191 || comp_unit_contains_address (each
, addr
))
5193 found
= comp_unit_find_line (each
, symbol
, addr
, filename_ptr
,
5202 bfd_vma min_range
= (bfd_vma
) -1;
5203 const char * local_filename
= NULL
;
5204 struct funcinfo
*local_function
= NULL
;
5205 unsigned int local_linenumber
= 0;
5206 unsigned int local_discriminator
= 0;
5208 for (each
= stash
->f
.all_comp_units
; each
; each
= each
->next_unit
)
5210 bfd_vma range
= (bfd_vma
) -1;
5212 found
= ((each
->arange
.high
== 0
5213 || comp_unit_contains_address (each
, addr
))
5214 && (range
= (comp_unit_find_nearest_line
5215 (each
, addr
, &local_filename
,
5216 &local_function
, &local_linenumber
,
5217 &local_discriminator
))) != 0);
5220 /* PRs 15935 15994: Bogus debug information may have provided us
5221 with an erroneous match. We attempt to counter this by
5222 selecting the match that has the smallest address range
5223 associated with it. (We are assuming that corrupt debug info
5224 will tend to result in extra large address ranges rather than
5225 extra small ranges).
5227 This does mean that we scan through all of the CUs associated
5228 with the bfd each time this function is called. But this does
5229 have the benefit of producing consistent results every time the
5230 function is called. */
5231 if (range
<= min_range
)
5233 if (filename_ptr
&& local_filename
)
5234 * filename_ptr
= local_filename
;
5236 function
= local_function
;
5237 if (discriminator_ptr
&& local_discriminator
)
5238 * discriminator_ptr
= local_discriminator
;
5239 if (local_linenumber
)
5240 * linenumber_ptr
= local_linenumber
;
5246 if (* linenumber_ptr
)
5253 /* Read each remaining comp. units checking each as they are read. */
5254 while ((each
= stash_comp_unit (stash
, &stash
->f
)) != NULL
)
5256 /* DW_AT_low_pc and DW_AT_high_pc are optional for
5257 compilation units. If we don't have them (i.e.,
5258 unit->high == 0), we need to consult the line info table
5259 to see if a compilation unit contains the given
5262 found
= (((symbol
->flags
& BSF_FUNCTION
) == 0
5263 || each
->arange
.high
== 0
5264 || comp_unit_contains_address (each
, addr
))
5265 && comp_unit_find_line (each
, symbol
, addr
,
5266 filename_ptr
, linenumber_ptr
));
5268 found
= ((each
->arange
.high
== 0
5269 || comp_unit_contains_address (each
, addr
))
5270 && comp_unit_find_nearest_line (each
, addr
,
5274 discriminator_ptr
) != 0);
5281 if (functionname_ptr
&& function
&& function
->is_linkage
)
5282 *functionname_ptr
= function
->name
;
5283 else if (functionname_ptr
5284 && (!*functionname_ptr
5285 || (function
&& !function
->is_linkage
)))
5288 asymbol
**syms
= symbols
;
5289 asection
*sec
= section
;
5291 _bfd_dwarf2_stash_syms (stash
, abfd
, &sec
, &syms
);
5292 fun
= _bfd_elf_find_function (abfd
, syms
, sec
, offset
,
5293 *filename_ptr
? NULL
: filename_ptr
,
5296 if (!found
&& fun
!= NULL
)
5299 if (function
&& !function
->is_linkage
)
5303 sec_vma
= section
->vma
;
5304 if (section
->output_section
!= NULL
)
5305 sec_vma
= section
->output_section
->vma
+ section
->output_offset
;
5307 && fun
->value
+ sec_vma
== function
->arange
.low
)
5308 function
->name
= *functionname_ptr
;
5309 /* Even if we didn't find a linkage name, say that we have
5310 to stop a repeated search of symbols. */
5311 function
->is_linkage
= TRUE
;
5315 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
5316 unset_sections (stash
);
5322 _bfd_dwarf2_find_inliner_info (bfd
*abfd ATTRIBUTE_UNUSED
,
5323 const char **filename_ptr
,
5324 const char **functionname_ptr
,
5325 unsigned int *linenumber_ptr
,
5328 struct dwarf2_debug
*stash
;
5330 stash
= (struct dwarf2_debug
*) *pinfo
;
5333 struct funcinfo
*func
= stash
->inliner_chain
;
5335 if (func
&& func
->caller_func
)
5337 *filename_ptr
= func
->caller_file
;
5338 *functionname_ptr
= func
->caller_func
->name
;
5339 *linenumber_ptr
= func
->caller_line
;
5340 stash
->inliner_chain
= func
->caller_func
;
5349 _bfd_dwarf2_cleanup_debug_info (bfd
*abfd
, void **pinfo
)
5351 struct dwarf2_debug
*stash
= (struct dwarf2_debug
*) *pinfo
;
5352 struct comp_unit
*each
;
5353 struct dwarf2_debug_file
*file
;
5355 if (abfd
== NULL
|| stash
== NULL
)
5358 if (stash
->varinfo_hash_table
)
5359 bfd_hash_table_free (&stash
->varinfo_hash_table
->base
);
5360 if (stash
->funcinfo_hash_table
)
5361 bfd_hash_table_free (&stash
->funcinfo_hash_table
->base
);
5366 for (each
= file
->all_comp_units
; each
; each
= each
->next_unit
)
5368 struct funcinfo
*function_table
= each
->function_table
;
5369 struct varinfo
*variable_table
= each
->variable_table
;
5371 if (each
->line_table
&& each
->line_table
!= file
->line_table
)
5373 free (each
->line_table
->files
);
5374 free (each
->line_table
->dirs
);
5377 free (each
->lookup_funcinfo_table
);
5378 each
->lookup_funcinfo_table
= NULL
;
5380 while (function_table
)
5382 free (function_table
->file
);
5383 function_table
->file
= NULL
;
5384 free (function_table
->caller_file
);
5385 function_table
->caller_file
= NULL
;
5386 function_table
= function_table
->prev_func
;
5389 while (variable_table
)
5391 free (variable_table
->file
);
5392 variable_table
->file
= NULL
;
5393 variable_table
= variable_table
->prev_var
;
5397 if (file
->line_table
)
5399 free (file
->line_table
->files
);
5400 free (file
->line_table
->dirs
);
5402 htab_delete (file
->abbrev_offsets
);
5404 free (file
->dwarf_line_str_buffer
);
5405 free (file
->dwarf_str_buffer
);
5406 free (file
->dwarf_ranges_buffer
);
5407 free (file
->dwarf_line_buffer
);
5408 free (file
->dwarf_abbrev_buffer
);
5409 free (file
->dwarf_info_buffer
);
5410 if (file
== &stash
->alt
)
5414 free (stash
->sec_vma
);
5415 free (stash
->adjusted_sections
);
5416 if (stash
->close_on_cleanup
)
5417 bfd_close (stash
->f
.bfd_ptr
);
5418 if (stash
->alt
.bfd_ptr
)
5419 bfd_close (stash
->alt
.bfd_ptr
);
5422 /* Find the function to a particular section and offset,
5423 for error reporting. */
5426 _bfd_elf_find_function (bfd
*abfd
,
5430 const char **filename_ptr
,
5431 const char **functionname_ptr
)
5433 struct elf_find_function_cache
5435 asection
*last_section
;
5437 const char *filename
;
5438 bfd_size_type func_size
;
5441 if (symbols
== NULL
)
5444 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
5447 cache
= elf_tdata (abfd
)->elf_find_function_cache
;
5450 cache
= bfd_zalloc (abfd
, sizeof (*cache
));
5451 elf_tdata (abfd
)->elf_find_function_cache
= cache
;
5455 if (cache
->last_section
!= section
5456 || cache
->func
== NULL
5457 || offset
< cache
->func
->value
5458 || offset
>= cache
->func
->value
+ cache
->func_size
)
5463 /* ??? Given multiple file symbols, it is impossible to reliably
5464 choose the right file name for global symbols. File symbols are
5465 local symbols, and thus all file symbols must sort before any
5466 global symbols. The ELF spec may be interpreted to say that a
5467 file symbol must sort before other local symbols, but currently
5468 ld -r doesn't do this. So, for ld -r output, it is possible to
5469 make a better choice of file name for local symbols by ignoring
5470 file symbols appearing after a given local symbol. */
5471 enum { nothing_seen
, symbol_seen
, file_after_symbol_seen
} state
;
5472 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5476 state
= nothing_seen
;
5477 cache
->filename
= NULL
;
5479 cache
->func_size
= 0;
5480 cache
->last_section
= section
;
5482 for (p
= symbols
; *p
!= NULL
; p
++)
5488 if ((sym
->flags
& BSF_FILE
) != 0)
5491 if (state
== symbol_seen
)
5492 state
= file_after_symbol_seen
;
5496 size
= bed
->maybe_function_sym (sym
, section
, &code_off
);
5498 && code_off
<= offset
5499 && (code_off
> low_func
5500 || (code_off
== low_func
5501 && size
> cache
->func_size
)))
5504 cache
->func_size
= size
;
5505 cache
->filename
= NULL
;
5506 low_func
= code_off
;
5508 && ((sym
->flags
& BSF_LOCAL
) != 0
5509 || state
!= file_after_symbol_seen
))
5510 cache
->filename
= bfd_asymbol_name (file
);
5512 if (state
== nothing_seen
)
5513 state
= symbol_seen
;
5517 if (cache
->func
== NULL
)
5521 *filename_ptr
= cache
->filename
;
5522 if (functionname_ptr
)
5523 *functionname_ptr
= bfd_asymbol_name (cache
->func
);