2 Copyright (C) 1994-2018 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"
39 /* The data in the .debug_line statement prologue looks like this. */
44 unsigned short version
;
45 bfd_vma prologue_length
;
46 unsigned char minimum_instruction_length
;
47 unsigned char maximum_ops_per_insn
;
48 unsigned char default_is_stmt
;
50 unsigned char line_range
;
51 unsigned char opcode_base
;
52 unsigned char *standard_opcode_lengths
;
55 /* Attributes have a name and a value. */
59 enum dwarf_attribute name
;
64 struct dwarf_block
*blk
;
71 /* Blocks are a bunch of untyped bytes. */
78 struct adjusted_section
86 /* A list of all previously read comp_units. */
87 struct comp_unit
*all_comp_units
;
89 /* Last comp unit in list above. */
90 struct comp_unit
*last_comp_unit
;
92 /* Names of the debug sections. */
93 const struct dwarf_debug_section
*debug_sections
;
95 /* The next unread compilation unit within the .debug_info section.
96 Zero indicates that the .debug_info section has not been loaded
100 /* Pointer to the end of the .debug_info section memory buffer. */
101 bfd_byte
*info_ptr_end
;
103 /* Pointer to the original bfd for which debug was loaded. This is what
104 we use to compare and so check that the cached debug data is still
105 valid - it saves having to possibly dereference the gnu_debuglink each
109 /* Pointer to the bfd, section and address of the beginning of the
110 section. The bfd might be different than expected because of
111 gnu_debuglink sections. */
114 bfd_byte
*sec_info_ptr
;
116 /* Support for alternate debug info sections created by the DWZ utility:
117 This includes a pointer to an alternate bfd which contains *extra*,
118 possibly duplicate debug sections, and pointers to the loaded
119 .debug_str and .debug_info sections from this bfd. */
121 bfd_byte
* alt_dwarf_str_buffer
;
122 bfd_size_type alt_dwarf_str_size
;
123 bfd_byte
* alt_dwarf_info_buffer
;
124 bfd_size_type alt_dwarf_info_size
;
126 /* A pointer to the memory block allocated for info_ptr. Neither
127 info_ptr nor sec_info_ptr are guaranteed to stay pointing to the
128 beginning of the malloc block. */
129 bfd_byte
*info_ptr_memory
;
131 /* Pointer to the symbol table. */
134 /* Pointer to the .debug_abbrev section loaded into memory. */
135 bfd_byte
*dwarf_abbrev_buffer
;
137 /* Length of the loaded .debug_abbrev section. */
138 bfd_size_type dwarf_abbrev_size
;
140 /* Buffer for decode_line_info. */
141 bfd_byte
*dwarf_line_buffer
;
143 /* Length of the loaded .debug_line section. */
144 bfd_size_type dwarf_line_size
;
146 /* Pointer to the .debug_str section loaded into memory. */
147 bfd_byte
*dwarf_str_buffer
;
149 /* Length of the loaded .debug_str section. */
150 bfd_size_type dwarf_str_size
;
152 /* Pointer to the .debug_line_str section loaded into memory. */
153 bfd_byte
*dwarf_line_str_buffer
;
155 /* Length of the loaded .debug_line_str section. */
156 bfd_size_type dwarf_line_str_size
;
158 /* Pointer to the .debug_ranges section loaded into memory. */
159 bfd_byte
*dwarf_ranges_buffer
;
161 /* Length of the loaded .debug_ranges section. */
162 bfd_size_type dwarf_ranges_size
;
164 /* If the most recent call to bfd_find_nearest_line was given an
165 address in an inlined function, preserve a pointer into the
166 calling chain for subsequent calls to bfd_find_inliner_info to
168 struct funcinfo
*inliner_chain
;
170 /* Section VMAs at the time the stash was built. */
173 /* Number of sections whose VMA we must adjust. */
174 int adjusted_section_count
;
176 /* Array of sections with adjusted VMA. */
177 struct adjusted_section
*adjusted_sections
;
179 /* Number of times find_line is called. This is used in
180 the heuristic for enabling the info hash tables. */
183 #define STASH_INFO_HASH_TRIGGER 100
185 /* Hash table mapping symbol names to function infos. */
186 struct info_hash_table
*funcinfo_hash_table
;
188 /* Hash table mapping symbol names to variable infos. */
189 struct info_hash_table
*varinfo_hash_table
;
191 /* Head of comp_unit list in the last hash table update. */
192 struct comp_unit
*hash_units_head
;
194 /* Status of info hash. */
195 int info_hash_status
;
196 #define STASH_INFO_HASH_OFF 0
197 #define STASH_INFO_HASH_ON 1
198 #define STASH_INFO_HASH_DISABLED 2
200 /* True if we opened bfd_ptr. */
201 bfd_boolean close_on_cleanup
;
211 /* A minimal decoding of DWARF2 compilation units. We only decode
212 what's needed to get to the line number information. */
216 /* Chain the previously read compilation units. */
217 struct comp_unit
*next_unit
;
219 /* Likewise, chain the compilation unit read after this one.
220 The comp units are stored in reversed reading order. */
221 struct comp_unit
*prev_unit
;
223 /* Keep the bfd convenient (for memory allocation). */
226 /* The lowest and highest addresses contained in this compilation
227 unit as specified in the compilation unit header. */
228 struct arange arange
;
230 /* The DW_AT_name attribute (for error messages). */
233 /* The abbrev hash table. */
234 struct abbrev_info
**abbrevs
;
236 /* DW_AT_language. */
239 /* Note that an error was found by comp_unit_find_nearest_line. */
242 /* The DW_AT_comp_dir attribute. */
245 /* TRUE if there is a line number table associated with this comp. unit. */
248 /* Pointer to the current comp_unit so that we can find a given entry
250 bfd_byte
*info_ptr_unit
;
252 /* The offset into .debug_line of the line number table. */
253 unsigned long line_offset
;
255 /* Pointer to the first child die for the comp unit. */
256 bfd_byte
*first_child_die_ptr
;
258 /* The end of the comp unit. */
261 /* The decoded line number, NULL if not yet decoded. */
262 struct line_info_table
*line_table
;
264 /* A list of the functions found in this comp. unit. */
265 struct funcinfo
*function_table
;
267 /* A table of function information references searchable by address. */
268 struct lookup_funcinfo
*lookup_funcinfo_table
;
270 /* Number of functions in the function_table and sorted_function_table. */
271 bfd_size_type number_of_functions
;
273 /* A list of the variables found in this comp. unit. */
274 struct varinfo
*variable_table
;
276 /* Pointer to dwarf2_debug structure. */
277 struct dwarf2_debug
*stash
;
279 /* DWARF format version for this unit - from unit header. */
282 /* Address size for this unit - from unit header. */
283 unsigned char addr_size
;
285 /* Offset size for this unit - from unit header. */
286 unsigned char offset_size
;
288 /* Base address for this unit - from DW_AT_low_pc attribute of
289 DW_TAG_compile_unit DIE */
290 bfd_vma base_address
;
292 /* TRUE if symbols are cached in hash table for faster lookup by name. */
296 /* This data structure holds the information of an abbrev. */
299 unsigned int number
; /* Number identifying abbrev. */
300 enum dwarf_tag tag
; /* DWARF tag. */
301 int has_children
; /* Boolean. */
302 unsigned int num_attrs
; /* Number of attributes. */
303 struct attr_abbrev
*attrs
; /* An array of attribute descriptions. */
304 struct abbrev_info
*next
; /* Next in chain. */
309 enum dwarf_attribute name
;
310 enum dwarf_form form
;
311 bfd_vma implicit_const
;
314 /* Map of uncompressed DWARF debug section name to compressed one. It
315 is terminated by NULL uncompressed_name. */
317 const struct dwarf_debug_section dwarf_debug_sections
[] =
319 { ".debug_abbrev", ".zdebug_abbrev" },
320 { ".debug_aranges", ".zdebug_aranges" },
321 { ".debug_frame", ".zdebug_frame" },
322 { ".debug_info", ".zdebug_info" },
323 { ".debug_info", ".zdebug_info" },
324 { ".debug_line", ".zdebug_line" },
325 { ".debug_loc", ".zdebug_loc" },
326 { ".debug_macinfo", ".zdebug_macinfo" },
327 { ".debug_macro", ".zdebug_macro" },
328 { ".debug_pubnames", ".zdebug_pubnames" },
329 { ".debug_pubtypes", ".zdebug_pubtypes" },
330 { ".debug_ranges", ".zdebug_ranges" },
331 { ".debug_static_func", ".zdebug_static_func" },
332 { ".debug_static_vars", ".zdebug_static_vars" },
333 { ".debug_str", ".zdebug_str", },
334 { ".debug_str", ".zdebug_str", },
335 { ".debug_line_str", ".zdebug_line_str", },
336 { ".debug_types", ".zdebug_types" },
337 /* GNU DWARF 1 extensions */
338 { ".debug_sfnames", ".zdebug_sfnames" },
339 { ".debug_srcinfo", ".zebug_srcinfo" },
340 /* SGI/MIPS DWARF 2 extensions */
341 { ".debug_funcnames", ".zdebug_funcnames" },
342 { ".debug_typenames", ".zdebug_typenames" },
343 { ".debug_varnames", ".zdebug_varnames" },
344 { ".debug_weaknames", ".zdebug_weaknames" },
348 /* NB/ Numbers in this enum must match up with indicies
349 into the dwarf_debug_sections[] array above. */
350 enum dwarf_debug_section_enum
379 /* A static assertion. */
380 extern int dwarf_debug_section_assert
[ARRAY_SIZE (dwarf_debug_sections
)
381 == debug_max
+ 1 ? 1 : -1];
383 #ifndef ABBREV_HASH_SIZE
384 #define ABBREV_HASH_SIZE 121
386 #ifndef ATTR_ALLOC_CHUNK
387 #define ATTR_ALLOC_CHUNK 4
390 /* Variable and function hash tables. This is used to speed up look-up
391 in lookup_symbol_in_var_table() and lookup_symbol_in_function_table().
392 In order to share code between variable and function infos, we use
393 a list of untyped pointer for all variable/function info associated with
394 a symbol. We waste a bit of memory for list with one node but that
395 simplifies the code. */
397 struct info_list_node
399 struct info_list_node
*next
;
403 /* Info hash entry. */
404 struct info_hash_entry
406 struct bfd_hash_entry root
;
407 struct info_list_node
*head
;
410 struct info_hash_table
412 struct bfd_hash_table base
;
415 /* Function to create a new entry in info hash table. */
417 static struct bfd_hash_entry
*
418 info_hash_table_newfunc (struct bfd_hash_entry
*entry
,
419 struct bfd_hash_table
*table
,
422 struct info_hash_entry
*ret
= (struct info_hash_entry
*) entry
;
424 /* Allocate the structure if it has not already been allocated by a
428 ret
= (struct info_hash_entry
*) bfd_hash_allocate (table
,
434 /* Call the allocation method of the base class. */
435 ret
= ((struct info_hash_entry
*)
436 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
438 /* Initialize the local fields here. */
442 return (struct bfd_hash_entry
*) ret
;
445 /* Function to create a new info hash table. It returns a pointer to the
446 newly created table or NULL if there is any error. We need abfd
447 solely for memory allocation. */
449 static struct info_hash_table
*
450 create_info_hash_table (bfd
*abfd
)
452 struct info_hash_table
*hash_table
;
454 hash_table
= ((struct info_hash_table
*)
455 bfd_alloc (abfd
, sizeof (struct info_hash_table
)));
459 if (!bfd_hash_table_init (&hash_table
->base
, info_hash_table_newfunc
,
460 sizeof (struct info_hash_entry
)))
462 bfd_release (abfd
, hash_table
);
469 /* Insert an info entry into an info hash table. We do not check of
470 duplicate entries. Also, the caller need to guarantee that the
471 right type of info in inserted as info is passed as a void* pointer.
472 This function returns true if there is no error. */
475 insert_info_hash_table (struct info_hash_table
*hash_table
,
480 struct info_hash_entry
*entry
;
481 struct info_list_node
*node
;
483 entry
= (struct info_hash_entry
*) bfd_hash_lookup (&hash_table
->base
,
488 node
= (struct info_list_node
*) bfd_hash_allocate (&hash_table
->base
,
494 node
->next
= entry
->head
;
500 /* Look up an info entry list from an info hash table. Return NULL
503 static struct info_list_node
*
504 lookup_info_hash_table (struct info_hash_table
*hash_table
, const char *key
)
506 struct info_hash_entry
*entry
;
508 entry
= (struct info_hash_entry
*) bfd_hash_lookup (&hash_table
->base
, key
,
510 return entry
? entry
->head
: NULL
;
513 /* Read a section into its appropriate place in the dwarf2_debug
514 struct (indicated by SECTION_BUFFER and SECTION_SIZE). If SYMS is
515 not NULL, use bfd_simple_get_relocated_section_contents to read the
516 section contents, otherwise use bfd_get_section_contents. Fail if
517 the located section does not contain at least OFFSET bytes. */
520 read_section (bfd
* abfd
,
521 const struct dwarf_debug_section
*sec
,
524 bfd_byte
** section_buffer
,
525 bfd_size_type
* section_size
)
528 const char *section_name
= sec
->uncompressed_name
;
529 bfd_byte
*contents
= *section_buffer
;
531 /* The section may have already been read. */
532 if (contents
== NULL
)
534 msec
= bfd_get_section_by_name (abfd
, section_name
);
537 section_name
= sec
->compressed_name
;
538 if (section_name
!= NULL
)
539 msec
= bfd_get_section_by_name (abfd
, section_name
);
543 _bfd_error_handler (_("Dwarf Error: Can't find %s section."),
544 sec
->uncompressed_name
);
545 bfd_set_error (bfd_error_bad_value
);
549 *section_size
= msec
->rawsize
? msec
->rawsize
: msec
->size
;
550 /* Paranoia - alloc one extra so that we can make sure a string
551 section is NUL terminated. */
552 contents
= (bfd_byte
*) bfd_malloc (*section_size
+ 1);
553 if (contents
== NULL
)
556 ? !bfd_simple_get_relocated_section_contents (abfd
, msec
, contents
,
558 : !bfd_get_section_contents (abfd
, msec
, contents
, 0, *section_size
))
563 contents
[*section_size
] = 0;
564 *section_buffer
= contents
;
567 /* It is possible to get a bad value for the offset into the section
568 that the client wants. Validate it here to avoid trouble later. */
569 if (offset
!= 0 && offset
>= *section_size
)
571 /* xgettext: c-format */
572 _bfd_error_handler (_("Dwarf Error: Offset (%" PRIu64
")"
573 " greater than or equal to %s size (%" PRIu64
")."),
574 (uint64_t) offset
, section_name
,
575 (uint64_t) *section_size
);
576 bfd_set_error (bfd_error_bad_value
);
583 /* Read dwarf information from a buffer. */
586 read_1_byte (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_byte
*buf
, bfd_byte
*end
)
590 return bfd_get_8 (abfd
, buf
);
594 read_1_signed_byte (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_byte
*buf
, bfd_byte
*end
)
598 return bfd_get_signed_8 (abfd
, buf
);
602 read_2_bytes (bfd
*abfd
, bfd_byte
*buf
, bfd_byte
*end
)
606 return bfd_get_16 (abfd
, buf
);
610 read_4_bytes (bfd
*abfd
, bfd_byte
*buf
, bfd_byte
*end
)
614 return bfd_get_32 (abfd
, buf
);
618 read_8_bytes (bfd
*abfd
, bfd_byte
*buf
, bfd_byte
*end
)
622 return bfd_get_64 (abfd
, buf
);
626 read_n_bytes (bfd
*abfd ATTRIBUTE_UNUSED
,
629 unsigned int size ATTRIBUTE_UNUSED
)
631 if (buf
+ size
> end
)
636 /* Scans a NUL terminated string starting at BUF, returning a pointer to it.
637 Returns the number of characters in the string, *including* the NUL byte,
638 in BYTES_READ_PTR. This value is set even if the function fails. Bytes
639 at or beyond BUF_END will not be read. Returns NULL if there was a
640 problem, or if the string is empty. */
643 read_string (bfd
* abfd ATTRIBUTE_UNUSED
,
646 unsigned int * bytes_read_ptr
)
652 * bytes_read_ptr
= 0;
658 * bytes_read_ptr
= 1;
662 while (buf
< buf_end
)
665 * bytes_read_ptr
= buf
- str
;
669 * bytes_read_ptr
= buf
- str
;
673 /* Reads an offset from BUF and then locates the string at this offset
674 inside the debug string section. Returns a pointer to the string.
675 Returns the number of bytes read from BUF, *not* the length of the string,
676 in BYTES_READ_PTR. This value is set even if the function fails. Bytes
677 at or beyond BUF_END will not be read from BUF. Returns NULL if there was
678 a problem, or if the string is empty. Does not check for NUL termination
682 read_indirect_string (struct comp_unit
* unit
,
685 unsigned int * bytes_read_ptr
)
688 struct dwarf2_debug
*stash
= unit
->stash
;
691 if (buf
+ unit
->offset_size
> buf_end
)
693 * bytes_read_ptr
= 0;
697 if (unit
->offset_size
== 4)
698 offset
= read_4_bytes (unit
->abfd
, buf
, buf_end
);
700 offset
= read_8_bytes (unit
->abfd
, buf
, buf_end
);
702 *bytes_read_ptr
= unit
->offset_size
;
704 if (! read_section (unit
->abfd
, &stash
->debug_sections
[debug_str
],
706 &stash
->dwarf_str_buffer
, &stash
->dwarf_str_size
))
709 if (offset
>= stash
->dwarf_str_size
)
711 str
= (char *) stash
->dwarf_str_buffer
+ offset
;
717 /* Like read_indirect_string but from .debug_line_str section. */
720 read_indirect_line_string (struct comp_unit
* unit
,
723 unsigned int * bytes_read_ptr
)
726 struct dwarf2_debug
*stash
= unit
->stash
;
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_line_str
],
744 &stash
->dwarf_line_str_buffer
,
745 &stash
->dwarf_line_str_size
))
748 if (offset
>= stash
->dwarf_line_str_size
)
750 str
= (char *) stash
->dwarf_line_str_buffer
+ offset
;
756 /* Like read_indirect_string but uses a .debug_str located in
757 an alternate file pointed to by the .gnu_debugaltlink section.
758 Used to impement DW_FORM_GNU_strp_alt. */
761 read_alt_indirect_string (struct comp_unit
* unit
,
764 unsigned int * bytes_read_ptr
)
767 struct dwarf2_debug
*stash
= unit
->stash
;
770 if (buf
+ unit
->offset_size
> buf_end
)
772 * bytes_read_ptr
= 0;
776 if (unit
->offset_size
== 4)
777 offset
= read_4_bytes (unit
->abfd
, buf
, buf_end
);
779 offset
= read_8_bytes (unit
->abfd
, buf
, buf_end
);
781 *bytes_read_ptr
= unit
->offset_size
;
783 if (stash
->alt_bfd_ptr
== NULL
)
786 char * debug_filename
= bfd_follow_gnu_debugaltlink (unit
->abfd
, DEBUGDIR
);
788 if (debug_filename
== NULL
)
791 if ((debug_bfd
= bfd_openr (debug_filename
, NULL
)) == NULL
792 || ! bfd_check_format (debug_bfd
, bfd_object
))
795 bfd_close (debug_bfd
);
797 /* FIXME: Should we report our failure to follow the debuglink ? */
798 free (debug_filename
);
801 stash
->alt_bfd_ptr
= debug_bfd
;
804 if (! read_section (unit
->stash
->alt_bfd_ptr
,
805 stash
->debug_sections
+ debug_str_alt
,
806 NULL
, /* FIXME: Do we need to load alternate symbols ? */
808 &stash
->alt_dwarf_str_buffer
,
809 &stash
->alt_dwarf_str_size
))
812 if (offset
>= stash
->alt_dwarf_str_size
)
814 str
= (char *) stash
->alt_dwarf_str_buffer
+ offset
;
821 /* Resolve an alternate reference from UNIT at OFFSET.
822 Returns a pointer into the loaded alternate CU upon success
823 or NULL upon failure. */
826 read_alt_indirect_ref (struct comp_unit
* unit
,
829 struct dwarf2_debug
*stash
= unit
->stash
;
831 if (stash
->alt_bfd_ptr
== NULL
)
834 char * debug_filename
= bfd_follow_gnu_debugaltlink (unit
->abfd
, DEBUGDIR
);
836 if (debug_filename
== NULL
)
839 if ((debug_bfd
= bfd_openr (debug_filename
, NULL
)) == NULL
840 || ! bfd_check_format (debug_bfd
, bfd_object
))
843 bfd_close (debug_bfd
);
845 /* FIXME: Should we report our failure to follow the debuglink ? */
846 free (debug_filename
);
849 stash
->alt_bfd_ptr
= debug_bfd
;
852 if (! read_section (unit
->stash
->alt_bfd_ptr
,
853 stash
->debug_sections
+ debug_info_alt
,
854 NULL
, /* FIXME: Do we need to load alternate symbols ? */
856 &stash
->alt_dwarf_info_buffer
,
857 &stash
->alt_dwarf_info_size
))
860 if (offset
>= stash
->alt_dwarf_info_size
)
862 return stash
->alt_dwarf_info_buffer
+ offset
;
866 read_address (struct comp_unit
*unit
, bfd_byte
*buf
, bfd_byte
* buf_end
)
870 if (bfd_get_flavour (unit
->abfd
) == bfd_target_elf_flavour
)
871 signed_vma
= get_elf_backend_data (unit
->abfd
)->sign_extend_vma
;
873 if (buf
+ unit
->addr_size
> buf_end
)
878 switch (unit
->addr_size
)
881 return bfd_get_signed_64 (unit
->abfd
, buf
);
883 return bfd_get_signed_32 (unit
->abfd
, buf
);
885 return bfd_get_signed_16 (unit
->abfd
, buf
);
892 switch (unit
->addr_size
)
895 return bfd_get_64 (unit
->abfd
, buf
);
897 return bfd_get_32 (unit
->abfd
, buf
);
899 return bfd_get_16 (unit
->abfd
, buf
);
906 /* Lookup an abbrev_info structure in the abbrev hash table. */
908 static struct abbrev_info
*
909 lookup_abbrev (unsigned int number
, struct abbrev_info
**abbrevs
)
911 unsigned int hash_number
;
912 struct abbrev_info
*abbrev
;
914 hash_number
= number
% ABBREV_HASH_SIZE
;
915 abbrev
= abbrevs
[hash_number
];
919 if (abbrev
->number
== number
)
922 abbrev
= abbrev
->next
;
928 /* In DWARF version 2, the description of the debugging information is
929 stored in a separate .debug_abbrev section. Before we read any
930 dies from a section we read in all abbreviations and install them
933 static struct abbrev_info
**
934 read_abbrevs (bfd
*abfd
, bfd_uint64_t offset
, struct dwarf2_debug
*stash
)
936 struct abbrev_info
**abbrevs
;
937 bfd_byte
*abbrev_ptr
;
938 bfd_byte
*abbrev_end
;
939 struct abbrev_info
*cur_abbrev
;
940 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
941 unsigned int abbrev_form
, hash_number
;
944 if (! read_section (abfd
, &stash
->debug_sections
[debug_abbrev
],
946 &stash
->dwarf_abbrev_buffer
, &stash
->dwarf_abbrev_size
))
949 if (offset
>= stash
->dwarf_abbrev_size
)
952 amt
= sizeof (struct abbrev_info
*) * ABBREV_HASH_SIZE
;
953 abbrevs
= (struct abbrev_info
**) bfd_zalloc (abfd
, amt
);
957 abbrev_ptr
= stash
->dwarf_abbrev_buffer
+ offset
;
958 abbrev_end
= stash
->dwarf_abbrev_buffer
+ stash
->dwarf_abbrev_size
;
959 abbrev_number
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
, &bytes_read
,
961 abbrev_ptr
+= bytes_read
;
963 /* Loop until we reach an abbrev number of 0. */
964 while (abbrev_number
)
966 amt
= sizeof (struct abbrev_info
);
967 cur_abbrev
= (struct abbrev_info
*) bfd_zalloc (abfd
, amt
);
968 if (cur_abbrev
== NULL
)
971 /* Read in abbrev header. */
972 cur_abbrev
->number
= abbrev_number
;
973 cur_abbrev
->tag
= (enum dwarf_tag
)
974 _bfd_safe_read_leb128 (abfd
, abbrev_ptr
, &bytes_read
,
976 abbrev_ptr
+= bytes_read
;
977 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
, abbrev_end
);
980 /* Now read in declarations. */
983 /* Initialize it just to avoid a GCC false warning. */
984 bfd_vma implicit_const
= -1;
986 abbrev_name
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
, &bytes_read
,
988 abbrev_ptr
+= bytes_read
;
989 abbrev_form
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
, &bytes_read
,
991 abbrev_ptr
+= bytes_read
;
992 if (abbrev_form
== DW_FORM_implicit_const
)
994 implicit_const
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
,
997 abbrev_ptr
+= bytes_read
;
1000 if (abbrev_name
== 0)
1003 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
1005 struct attr_abbrev
*tmp
;
1007 amt
= cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
;
1008 amt
*= sizeof (struct attr_abbrev
);
1009 tmp
= (struct attr_abbrev
*) bfd_realloc (cur_abbrev
->attrs
, amt
);
1014 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
1016 struct abbrev_info
*abbrev
= abbrevs
[i
];
1020 free (abbrev
->attrs
);
1021 abbrev
= abbrev
->next
;
1026 cur_abbrev
->attrs
= tmp
;
1029 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
1030 = (enum dwarf_attribute
) abbrev_name
;
1031 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].form
1032 = (enum dwarf_form
) abbrev_form
;
1033 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].implicit_const
1035 ++cur_abbrev
->num_attrs
;
1038 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
1039 cur_abbrev
->next
= abbrevs
[hash_number
];
1040 abbrevs
[hash_number
] = cur_abbrev
;
1042 /* Get next abbreviation.
1043 Under Irix6 the abbreviations for a compilation unit are not
1044 always properly terminated with an abbrev number of 0.
1045 Exit loop if we encounter an abbreviation which we have
1046 already read (which means we are about to read the abbreviations
1047 for the next compile unit) or if the end of the abbreviation
1048 table is reached. */
1049 if ((unsigned int) (abbrev_ptr
- stash
->dwarf_abbrev_buffer
)
1050 >= stash
->dwarf_abbrev_size
)
1052 abbrev_number
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
,
1053 &bytes_read
, FALSE
, abbrev_end
);
1054 abbrev_ptr
+= bytes_read
;
1055 if (lookup_abbrev (abbrev_number
, abbrevs
) != NULL
)
1062 /* Returns true if the form is one which has a string value. */
1064 static inline bfd_boolean
1065 is_str_attr (enum dwarf_form form
)
1067 return (form
== DW_FORM_string
|| form
== DW_FORM_strp
1068 || form
== DW_FORM_line_strp
|| form
== DW_FORM_GNU_strp_alt
);
1071 /* Read and fill in the value of attribute ATTR as described by FORM.
1072 Read data starting from INFO_PTR, but never at or beyond INFO_PTR_END.
1073 Returns an updated INFO_PTR taking into account the amount of data read. */
1076 read_attribute_value (struct attribute
* attr
,
1078 bfd_vma implicit_const
,
1079 struct comp_unit
* unit
,
1080 bfd_byte
* info_ptr
,
1081 bfd_byte
* info_ptr_end
)
1083 bfd
*abfd
= unit
->abfd
;
1084 unsigned int bytes_read
;
1085 struct dwarf_block
*blk
;
1088 if (info_ptr
>= info_ptr_end
&& form
!= DW_FORM_flag_present
)
1090 _bfd_error_handler (_("Dwarf Error: Info pointer extends beyond end of attributes"));
1091 bfd_set_error (bfd_error_bad_value
);
1095 attr
->form
= (enum dwarf_form
) form
;
1099 case DW_FORM_ref_addr
:
1100 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
1102 if (unit
->version
== 3 || unit
->version
== 4)
1104 if (unit
->offset_size
== 4)
1105 attr
->u
.val
= read_4_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1107 attr
->u
.val
= read_8_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1108 info_ptr
+= unit
->offset_size
;
1113 attr
->u
.val
= read_address (unit
, info_ptr
, info_ptr_end
);
1114 info_ptr
+= unit
->addr_size
;
1116 case DW_FORM_GNU_ref_alt
:
1117 case DW_FORM_sec_offset
:
1118 if (unit
->offset_size
== 4)
1119 attr
->u
.val
= read_4_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1121 attr
->u
.val
= read_8_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1122 info_ptr
+= unit
->offset_size
;
1124 case DW_FORM_block2
:
1125 amt
= sizeof (struct dwarf_block
);
1126 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1129 blk
->size
= read_2_bytes (abfd
, info_ptr
, info_ptr_end
);
1131 blk
->data
= read_n_bytes (abfd
, info_ptr
, info_ptr_end
, blk
->size
);
1132 info_ptr
+= blk
->size
;
1135 case DW_FORM_block4
:
1136 amt
= sizeof (struct dwarf_block
);
1137 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1140 blk
->size
= read_4_bytes (abfd
, info_ptr
, info_ptr_end
);
1142 blk
->data
= read_n_bytes (abfd
, info_ptr
, info_ptr_end
, blk
->size
);
1143 info_ptr
+= blk
->size
;
1147 attr
->u
.val
= read_2_bytes (abfd
, info_ptr
, info_ptr_end
);
1151 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
, info_ptr_end
);
1155 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
, info_ptr_end
);
1158 case DW_FORM_string
:
1159 attr
->u
.str
= read_string (abfd
, info_ptr
, info_ptr_end
, &bytes_read
);
1160 info_ptr
+= bytes_read
;
1163 attr
->u
.str
= read_indirect_string (unit
, info_ptr
, info_ptr_end
, &bytes_read
);
1164 info_ptr
+= bytes_read
;
1166 case DW_FORM_line_strp
:
1167 attr
->u
.str
= read_indirect_line_string (unit
, info_ptr
, info_ptr_end
, &bytes_read
);
1168 info_ptr
+= bytes_read
;
1170 case DW_FORM_GNU_strp_alt
:
1171 attr
->u
.str
= read_alt_indirect_string (unit
, info_ptr
, info_ptr_end
, &bytes_read
);
1172 info_ptr
+= bytes_read
;
1174 case DW_FORM_exprloc
:
1176 amt
= sizeof (struct dwarf_block
);
1177 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1180 blk
->size
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1181 FALSE
, info_ptr_end
);
1182 info_ptr
+= bytes_read
;
1183 blk
->data
= read_n_bytes (abfd
, info_ptr
, info_ptr_end
, blk
->size
);
1184 info_ptr
+= blk
->size
;
1187 case DW_FORM_block1
:
1188 amt
= sizeof (struct dwarf_block
);
1189 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1192 blk
->size
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1194 blk
->data
= read_n_bytes (abfd
, info_ptr
, info_ptr_end
, blk
->size
);
1195 info_ptr
+= blk
->size
;
1199 attr
->u
.val
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1203 attr
->u
.val
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1206 case DW_FORM_flag_present
:
1210 attr
->u
.sval
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1211 TRUE
, info_ptr_end
);
1212 info_ptr
+= bytes_read
;
1215 attr
->u
.val
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1216 FALSE
, info_ptr_end
);
1217 info_ptr
+= bytes_read
;
1220 attr
->u
.val
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1224 attr
->u
.val
= read_2_bytes (abfd
, info_ptr
, info_ptr_end
);
1228 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
, info_ptr_end
);
1232 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
, info_ptr_end
);
1235 case DW_FORM_ref_sig8
:
1236 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
, info_ptr_end
);
1239 case DW_FORM_ref_udata
:
1240 attr
->u
.val
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1241 FALSE
, info_ptr_end
);
1242 info_ptr
+= bytes_read
;
1244 case DW_FORM_indirect
:
1245 form
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1246 FALSE
, info_ptr_end
);
1247 info_ptr
+= bytes_read
;
1248 if (form
== DW_FORM_implicit_const
)
1250 implicit_const
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1251 TRUE
, info_ptr_end
);
1252 info_ptr
+= bytes_read
;
1254 info_ptr
= read_attribute_value (attr
, form
, implicit_const
, unit
,
1255 info_ptr
, info_ptr_end
);
1257 case DW_FORM_implicit_const
:
1258 attr
->form
= DW_FORM_sdata
;
1259 attr
->u
.sval
= implicit_const
;
1262 _bfd_error_handler (_("Dwarf Error: Invalid or unhandled FORM value: %#x."),
1264 bfd_set_error (bfd_error_bad_value
);
1270 /* Read an attribute described by an abbreviated attribute. */
1273 read_attribute (struct attribute
* attr
,
1274 struct attr_abbrev
* abbrev
,
1275 struct comp_unit
* unit
,
1276 bfd_byte
* info_ptr
,
1277 bfd_byte
* info_ptr_end
)
1279 attr
->name
= abbrev
->name
;
1280 info_ptr
= read_attribute_value (attr
, abbrev
->form
, abbrev
->implicit_const
,
1281 unit
, info_ptr
, info_ptr_end
);
1285 /* Return whether DW_AT_name will return the same as DW_AT_linkage_name
1289 non_mangled (int lang
)
1299 case DW_LANG_Cobol74
:
1300 case DW_LANG_Cobol85
:
1301 case DW_LANG_Fortran77
:
1302 case DW_LANG_Pascal83
:
1312 /* Source line information table routines. */
1314 #define FILE_ALLOC_CHUNK 5
1315 #define DIR_ALLOC_CHUNK 5
1319 struct line_info
* prev_line
;
1323 unsigned int column
;
1324 unsigned int discriminator
;
1325 unsigned char op_index
;
1326 unsigned char end_sequence
; /* End of (sequential) code sequence. */
1337 struct line_sequence
1340 struct line_sequence
* prev_sequence
;
1341 struct line_info
* last_line
; /* Largest VMA. */
1342 struct line_info
** line_info_lookup
;
1343 bfd_size_type num_lines
;
1346 struct line_info_table
1349 unsigned int num_files
;
1350 unsigned int num_dirs
;
1351 unsigned int num_sequences
;
1354 struct fileinfo
* files
;
1355 struct line_sequence
* sequences
;
1356 struct line_info
* lcl_head
; /* Local head; used in 'add_line_info'. */
1359 /* Remember some information about each function. If the function is
1360 inlined (DW_TAG_inlined_subroutine) it may have two additional
1361 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
1362 source code location where this function was inlined. */
1366 /* Pointer to previous function in list of all functions. */
1367 struct funcinfo
* prev_func
;
1368 /* Pointer to function one scope higher. */
1369 struct funcinfo
* caller_func
;
1370 /* Source location file name where caller_func inlines this func. */
1372 /* Source location file name. */
1374 /* Source location line number where caller_func inlines this func. */
1376 /* Source location line number. */
1379 bfd_boolean is_linkage
;
1381 struct arange arange
;
1382 /* Where the symbol is defined. */
1386 struct lookup_funcinfo
1388 /* Function information corresponding to this lookup table entry. */
1389 struct funcinfo
* funcinfo
;
1391 /* The lowest address for this specific function. */
1394 /* The highest address of this function before the lookup table is sorted.
1395 The highest address of all prior functions after the lookup table is
1396 sorted, which is used for binary search. */
1402 /* Pointer to previous variable in list of all variables */
1403 struct varinfo
*prev_var
;
1404 /* Source location file name */
1406 /* Source location line number */
1411 /* Where the symbol is defined */
1413 /* Is this a stack variable? */
1414 unsigned int stack
: 1;
1417 /* Return TRUE if NEW_LINE should sort after LINE. */
1419 static inline bfd_boolean
1420 new_line_sorts_after (struct line_info
*new_line
, struct line_info
*line
)
1422 return (new_line
->address
> line
->address
1423 || (new_line
->address
== line
->address
1424 && new_line
->op_index
> line
->op_index
));
1428 /* Adds a new entry to the line_info list in the line_info_table, ensuring
1429 that the list is sorted. Note that the line_info list is sorted from
1430 highest to lowest VMA (with possible duplicates); that is,
1431 line_info->prev_line always accesses an equal or smaller VMA. */
1434 add_line_info (struct line_info_table
*table
,
1436 unsigned char op_index
,
1439 unsigned int column
,
1440 unsigned int discriminator
,
1443 bfd_size_type amt
= sizeof (struct line_info
);
1444 struct line_sequence
* seq
= table
->sequences
;
1445 struct line_info
* info
= (struct line_info
*) bfd_alloc (table
->abfd
, amt
);
1450 /* Set member data of 'info'. */
1451 info
->prev_line
= NULL
;
1452 info
->address
= address
;
1453 info
->op_index
= op_index
;
1455 info
->column
= column
;
1456 info
->discriminator
= discriminator
;
1457 info
->end_sequence
= end_sequence
;
1459 if (filename
&& filename
[0])
1461 info
->filename
= (char *) bfd_alloc (table
->abfd
, strlen (filename
) + 1);
1462 if (info
->filename
== NULL
)
1464 strcpy (info
->filename
, filename
);
1467 info
->filename
= NULL
;
1469 /* Find the correct location for 'info'. Normally we will receive
1470 new line_info data 1) in order and 2) with increasing VMAs.
1471 However some compilers break the rules (cf. decode_line_info) and
1472 so we include some heuristics for quickly finding the correct
1473 location for 'info'. In particular, these heuristics optimize for
1474 the common case in which the VMA sequence that we receive is a
1475 list of locally sorted VMAs such as
1476 p...z a...j (where a < j < p < z)
1478 Note: table->lcl_head is used to head an *actual* or *possible*
1479 sub-sequence within the list (such as a...j) that is not directly
1480 headed by table->last_line
1482 Note: we may receive duplicate entries from 'decode_line_info'. */
1485 && seq
->last_line
->address
== address
1486 && seq
->last_line
->op_index
== op_index
1487 && seq
->last_line
->end_sequence
== end_sequence
)
1489 /* We only keep the last entry with the same address and end
1490 sequence. See PR ld/4986. */
1491 if (table
->lcl_head
== seq
->last_line
)
1492 table
->lcl_head
= info
;
1493 info
->prev_line
= seq
->last_line
->prev_line
;
1494 seq
->last_line
= info
;
1496 else if (!seq
|| seq
->last_line
->end_sequence
)
1498 /* Start a new line sequence. */
1499 amt
= sizeof (struct line_sequence
);
1500 seq
= (struct line_sequence
*) bfd_malloc (amt
);
1503 seq
->low_pc
= address
;
1504 seq
->prev_sequence
= table
->sequences
;
1505 seq
->last_line
= info
;
1506 table
->lcl_head
= info
;
1507 table
->sequences
= seq
;
1508 table
->num_sequences
++;
1510 else if (info
->end_sequence
1511 || new_line_sorts_after (info
, seq
->last_line
))
1513 /* Normal case: add 'info' to the beginning of the current sequence. */
1514 info
->prev_line
= seq
->last_line
;
1515 seq
->last_line
= info
;
1517 /* lcl_head: initialize to head a *possible* sequence at the end. */
1518 if (!table
->lcl_head
)
1519 table
->lcl_head
= info
;
1521 else if (!new_line_sorts_after (info
, table
->lcl_head
)
1522 && (!table
->lcl_head
->prev_line
1523 || new_line_sorts_after (info
, table
->lcl_head
->prev_line
)))
1525 /* Abnormal but easy: lcl_head is the head of 'info'. */
1526 info
->prev_line
= table
->lcl_head
->prev_line
;
1527 table
->lcl_head
->prev_line
= info
;
1531 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head'
1532 are valid heads for 'info'. Reset 'lcl_head'. */
1533 struct line_info
* li2
= seq
->last_line
; /* Always non-NULL. */
1534 struct line_info
* li1
= li2
->prev_line
;
1538 if (!new_line_sorts_after (info
, li2
)
1539 && new_line_sorts_after (info
, li1
))
1542 li2
= li1
; /* always non-NULL */
1543 li1
= li1
->prev_line
;
1545 table
->lcl_head
= li2
;
1546 info
->prev_line
= table
->lcl_head
->prev_line
;
1547 table
->lcl_head
->prev_line
= info
;
1548 if (address
< seq
->low_pc
)
1549 seq
->low_pc
= address
;
1554 /* Extract a fully qualified filename from a line info table.
1555 The returned string has been malloc'ed and it is the caller's
1556 responsibility to free it. */
1559 concat_filename (struct line_info_table
*table
, unsigned int file
)
1563 if (file
- 1 >= table
->num_files
)
1565 /* FILE == 0 means unknown. */
1568 (_("Dwarf Error: mangled line number section (bad file number)."));
1569 return strdup ("<unknown>");
1572 filename
= table
->files
[file
- 1].name
;
1573 if (filename
== NULL
)
1574 return strdup ("<unknown>");
1576 if (!IS_ABSOLUTE_PATH (filename
))
1578 char *dir_name
= NULL
;
1579 char *subdir_name
= NULL
;
1583 if (table
->files
[file
- 1].dir
1584 /* PR 17512: file: 0317e960. */
1585 && table
->files
[file
- 1].dir
<= table
->num_dirs
1586 /* PR 17512: file: 7f3d2e4b. */
1587 && table
->dirs
!= NULL
)
1588 subdir_name
= table
->dirs
[table
->files
[file
- 1].dir
- 1];
1590 if (!subdir_name
|| !IS_ABSOLUTE_PATH (subdir_name
))
1591 dir_name
= table
->comp_dir
;
1595 dir_name
= subdir_name
;
1600 return strdup (filename
);
1602 len
= strlen (dir_name
) + strlen (filename
) + 2;
1606 len
+= strlen (subdir_name
) + 1;
1607 name
= (char *) bfd_malloc (len
);
1609 sprintf (name
, "%s/%s/%s", dir_name
, subdir_name
, filename
);
1613 name
= (char *) bfd_malloc (len
);
1615 sprintf (name
, "%s/%s", dir_name
, filename
);
1621 return strdup (filename
);
1625 arange_add (const struct comp_unit
*unit
, struct arange
*first_arange
,
1626 bfd_vma low_pc
, bfd_vma high_pc
)
1628 struct arange
*arange
;
1630 /* Ignore empty ranges. */
1631 if (low_pc
== high_pc
)
1634 /* If the first arange is empty, use it. */
1635 if (first_arange
->high
== 0)
1637 first_arange
->low
= low_pc
;
1638 first_arange
->high
= high_pc
;
1642 /* Next see if we can cheaply extend an existing range. */
1643 arange
= first_arange
;
1646 if (low_pc
== arange
->high
)
1648 arange
->high
= high_pc
;
1651 if (high_pc
== arange
->low
)
1653 arange
->low
= low_pc
;
1656 arange
= arange
->next
;
1660 /* Need to allocate a new arange and insert it into the arange list.
1661 Order isn't significant, so just insert after the first arange. */
1662 arange
= (struct arange
*) bfd_alloc (unit
->abfd
, sizeof (*arange
));
1665 arange
->low
= low_pc
;
1666 arange
->high
= high_pc
;
1667 arange
->next
= first_arange
->next
;
1668 first_arange
->next
= arange
;
1672 /* Compare function for line sequences. */
1675 compare_sequences (const void* a
, const void* b
)
1677 const struct line_sequence
* seq1
= a
;
1678 const struct line_sequence
* seq2
= b
;
1680 /* Sort by low_pc as the primary key. */
1681 if (seq1
->low_pc
< seq2
->low_pc
)
1683 if (seq1
->low_pc
> seq2
->low_pc
)
1686 /* If low_pc values are equal, sort in reverse order of
1687 high_pc, so that the largest region comes first. */
1688 if (seq1
->last_line
->address
< seq2
->last_line
->address
)
1690 if (seq1
->last_line
->address
> seq2
->last_line
->address
)
1693 if (seq1
->last_line
->op_index
< seq2
->last_line
->op_index
)
1695 if (seq1
->last_line
->op_index
> seq2
->last_line
->op_index
)
1701 /* Construct the line information table for quick lookup. */
1704 build_line_info_table (struct line_info_table
* table
,
1705 struct line_sequence
* seq
)
1708 struct line_info
** line_info_lookup
;
1709 struct line_info
* each_line
;
1710 unsigned int num_lines
;
1711 unsigned int line_index
;
1713 if (seq
->line_info_lookup
!= NULL
)
1716 /* Count the number of line information entries. We could do this while
1717 scanning the debug information, but some entries may be added via
1718 lcl_head without having a sequence handy to increment the number of
1721 for (each_line
= seq
->last_line
; each_line
; each_line
= each_line
->prev_line
)
1727 /* Allocate space for the line information lookup table. */
1728 amt
= sizeof (struct line_info
*) * num_lines
;
1729 line_info_lookup
= (struct line_info
**) bfd_alloc (table
->abfd
, amt
);
1730 if (line_info_lookup
== NULL
)
1733 /* Create the line information lookup table. */
1734 line_index
= num_lines
;
1735 for (each_line
= seq
->last_line
; each_line
; each_line
= each_line
->prev_line
)
1736 line_info_lookup
[--line_index
] = each_line
;
1738 BFD_ASSERT (line_index
== 0);
1740 seq
->num_lines
= num_lines
;
1741 seq
->line_info_lookup
= line_info_lookup
;
1746 /* Sort the line sequences for quick lookup. */
1749 sort_line_sequences (struct line_info_table
* table
)
1752 struct line_sequence
* sequences
;
1753 struct line_sequence
* seq
;
1755 unsigned int num_sequences
= table
->num_sequences
;
1756 bfd_vma last_high_pc
;
1758 if (num_sequences
== 0)
1761 /* Allocate space for an array of sequences. */
1762 amt
= sizeof (struct line_sequence
) * num_sequences
;
1763 sequences
= (struct line_sequence
*) bfd_alloc (table
->abfd
, amt
);
1764 if (sequences
== NULL
)
1767 /* Copy the linked list into the array, freeing the original nodes. */
1768 seq
= table
->sequences
;
1769 for (n
= 0; n
< num_sequences
; n
++)
1771 struct line_sequence
* last_seq
= seq
;
1774 sequences
[n
].low_pc
= seq
->low_pc
;
1775 sequences
[n
].prev_sequence
= NULL
;
1776 sequences
[n
].last_line
= seq
->last_line
;
1777 sequences
[n
].line_info_lookup
= NULL
;
1778 sequences
[n
].num_lines
= 0;
1779 seq
= seq
->prev_sequence
;
1782 BFD_ASSERT (seq
== NULL
);
1784 qsort (sequences
, n
, sizeof (struct line_sequence
), compare_sequences
);
1786 /* Make the list binary-searchable by trimming overlapping entries
1787 and removing nested entries. */
1789 last_high_pc
= sequences
[0].last_line
->address
;
1790 for (n
= 1; n
< table
->num_sequences
; n
++)
1792 if (sequences
[n
].low_pc
< last_high_pc
)
1794 if (sequences
[n
].last_line
->address
<= last_high_pc
)
1795 /* Skip nested entries. */
1798 /* Trim overlapping entries. */
1799 sequences
[n
].low_pc
= last_high_pc
;
1801 last_high_pc
= sequences
[n
].last_line
->address
;
1802 if (n
> num_sequences
)
1804 /* Close up the gap. */
1805 sequences
[num_sequences
].low_pc
= sequences
[n
].low_pc
;
1806 sequences
[num_sequences
].last_line
= sequences
[n
].last_line
;
1811 table
->sequences
= sequences
;
1812 table
->num_sequences
= num_sequences
;
1816 /* Add directory to TABLE. CUR_DIR memory ownership is taken by TABLE. */
1819 line_info_add_include_dir (struct line_info_table
*table
, char *cur_dir
)
1821 if ((table
->num_dirs
% DIR_ALLOC_CHUNK
) == 0)
1826 amt
= table
->num_dirs
+ DIR_ALLOC_CHUNK
;
1827 amt
*= sizeof (char *);
1829 tmp
= (char **) bfd_realloc (table
->dirs
, amt
);
1835 table
->dirs
[table
->num_dirs
++] = cur_dir
;
1840 line_info_add_include_dir_stub (struct line_info_table
*table
, char *cur_dir
,
1841 unsigned int dir ATTRIBUTE_UNUSED
,
1842 unsigned int xtime ATTRIBUTE_UNUSED
,
1843 unsigned int size ATTRIBUTE_UNUSED
)
1845 return line_info_add_include_dir (table
, cur_dir
);
1848 /* Add file to TABLE. CUR_FILE memory ownership is taken by TABLE. */
1851 line_info_add_file_name (struct line_info_table
*table
, char *cur_file
,
1852 unsigned int dir
, unsigned int xtime
,
1855 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
1857 struct fileinfo
*tmp
;
1860 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
1861 amt
*= sizeof (struct fileinfo
);
1863 tmp
= (struct fileinfo
*) bfd_realloc (table
->files
, amt
);
1869 table
->files
[table
->num_files
].name
= cur_file
;
1870 table
->files
[table
->num_files
].dir
= dir
;
1871 table
->files
[table
->num_files
].time
= xtime
;
1872 table
->files
[table
->num_files
].size
= size
;
1877 /* Read directory or file name entry format, starting with byte of
1878 format count entries, ULEB128 pairs of entry formats, ULEB128 of
1879 entries count and the entries themselves in the described entry
1883 read_formatted_entries (struct comp_unit
*unit
, bfd_byte
**bufp
,
1884 bfd_byte
*buf_end
, struct line_info_table
*table
,
1885 bfd_boolean (*callback
) (struct line_info_table
*table
,
1891 bfd
*abfd
= unit
->abfd
;
1892 bfd_byte format_count
, formati
;
1893 bfd_vma data_count
, datai
;
1894 bfd_byte
*buf
= *bufp
;
1895 bfd_byte
*format_header_data
;
1896 unsigned int bytes_read
;
1898 format_count
= read_1_byte (abfd
, buf
, buf_end
);
1900 format_header_data
= buf
;
1901 for (formati
= 0; formati
< format_count
; formati
++)
1903 _bfd_safe_read_leb128 (abfd
, buf
, &bytes_read
, FALSE
, buf_end
);
1905 _bfd_safe_read_leb128 (abfd
, buf
, &bytes_read
, FALSE
, buf_end
);
1909 data_count
= _bfd_safe_read_leb128 (abfd
, buf
, &bytes_read
, FALSE
, buf_end
);
1911 if (format_count
== 0 && data_count
!= 0)
1913 _bfd_error_handler (_("Dwarf Error: Zero format count."));
1914 bfd_set_error (bfd_error_bad_value
);
1918 /* PR 22210. Paranoia check. Don't bother running the loop
1919 if we know that we are going to run out of buffer. */
1920 if (data_count
> (bfd_vma
) (buf_end
- buf
))
1923 (_("Dwarf Error: data count (%" PRIx64
") larger than buffer size."),
1924 (uint64_t) data_count
);
1925 bfd_set_error (bfd_error_bad_value
);
1929 for (datai
= 0; datai
< data_count
; datai
++)
1931 bfd_byte
*format
= format_header_data
;
1934 memset (&fe
, 0, sizeof fe
);
1935 for (formati
= 0; formati
< format_count
; formati
++)
1937 bfd_vma content_type
, form
;
1939 char **stringp
= &string_trash
;
1940 unsigned int uint_trash
, *uintp
= &uint_trash
;
1941 struct attribute attr
;
1943 content_type
= _bfd_safe_read_leb128 (abfd
, format
, &bytes_read
,
1945 format
+= bytes_read
;
1946 switch (content_type
)
1951 case DW_LNCT_directory_index
:
1954 case DW_LNCT_timestamp
:
1964 (_("Dwarf Error: Unknown format content type %" PRIu64
"."),
1965 (uint64_t) content_type
);
1966 bfd_set_error (bfd_error_bad_value
);
1970 form
= _bfd_safe_read_leb128 (abfd
, format
, &bytes_read
, FALSE
,
1972 format
+= bytes_read
;
1974 buf
= read_attribute_value (&attr
, form
, 0, unit
, buf
, buf_end
);
1979 case DW_FORM_string
:
1980 case DW_FORM_line_strp
:
1981 *stringp
= attr
.u
.str
;
1989 *uintp
= attr
.u
.val
;
1994 if (!callback (table
, fe
.name
, fe
.dir
, fe
.time
, fe
.size
))
2002 /* Decode the line number information for UNIT. */
2004 static struct line_info_table
*
2005 decode_line_info (struct comp_unit
*unit
, struct dwarf2_debug
*stash
)
2007 bfd
*abfd
= unit
->abfd
;
2008 struct line_info_table
* table
;
2011 struct line_head lh
;
2012 unsigned int i
, bytes_read
, offset_size
;
2013 char *cur_file
, *cur_dir
;
2014 unsigned char op_code
, extended_op
, adj_opcode
;
2015 unsigned int exop_len
;
2018 if (! read_section (abfd
, &stash
->debug_sections
[debug_line
],
2019 stash
->syms
, unit
->line_offset
,
2020 &stash
->dwarf_line_buffer
, &stash
->dwarf_line_size
))
2023 amt
= sizeof (struct line_info_table
);
2024 table
= (struct line_info_table
*) bfd_alloc (abfd
, amt
);
2028 table
->comp_dir
= unit
->comp_dir
;
2030 table
->num_files
= 0;
2031 table
->files
= NULL
;
2033 table
->num_dirs
= 0;
2036 table
->num_sequences
= 0;
2037 table
->sequences
= NULL
;
2039 table
->lcl_head
= NULL
;
2041 if (stash
->dwarf_line_size
< 16)
2044 (_("Dwarf Error: Line info section is too small (%" PRId64
")"),
2045 (int64_t) stash
->dwarf_line_size
);
2046 bfd_set_error (bfd_error_bad_value
);
2049 line_ptr
= stash
->dwarf_line_buffer
+ unit
->line_offset
;
2050 line_end
= stash
->dwarf_line_buffer
+ stash
->dwarf_line_size
;
2052 /* Read in the prologue. */
2053 lh
.total_length
= read_4_bytes (abfd
, line_ptr
, line_end
);
2056 if (lh
.total_length
== 0xffffffff)
2058 lh
.total_length
= read_8_bytes (abfd
, line_ptr
, line_end
);
2062 else if (lh
.total_length
== 0 && unit
->addr_size
== 8)
2064 /* Handle (non-standard) 64-bit DWARF2 formats. */
2065 lh
.total_length
= read_4_bytes (abfd
, line_ptr
, line_end
);
2070 if (lh
.total_length
> (size_t) (line_end
- line_ptr
))
2073 /* xgettext: c-format */
2074 (_("Dwarf Error: Line info data is bigger (%#" PRIx64
")"
2075 " than the space remaining in the section (%#lx)"),
2076 (uint64_t) lh
.total_length
, (unsigned long) (line_end
- line_ptr
));
2077 bfd_set_error (bfd_error_bad_value
);
2081 line_end
= line_ptr
+ lh
.total_length
;
2083 lh
.version
= read_2_bytes (abfd
, line_ptr
, line_end
);
2084 if (lh
.version
< 2 || lh
.version
> 5)
2087 (_("Dwarf Error: Unhandled .debug_line version %d."), lh
.version
);
2088 bfd_set_error (bfd_error_bad_value
);
2093 if (line_ptr
+ offset_size
+ (lh
.version
>= 5 ? 8 : (lh
.version
>= 4 ? 6 : 5))
2097 (_("Dwarf Error: Ran out of room reading prologue"));
2098 bfd_set_error (bfd_error_bad_value
);
2102 if (lh
.version
>= 5)
2104 unsigned int segment_selector_size
;
2106 /* Skip address size. */
2107 read_1_byte (abfd
, line_ptr
, line_end
);
2110 segment_selector_size
= read_1_byte (abfd
, line_ptr
, line_end
);
2112 if (segment_selector_size
!= 0)
2115 (_("Dwarf Error: Line info unsupported segment selector size %u."),
2116 segment_selector_size
);
2117 bfd_set_error (bfd_error_bad_value
);
2122 if (offset_size
== 4)
2123 lh
.prologue_length
= read_4_bytes (abfd
, line_ptr
, line_end
);
2125 lh
.prologue_length
= read_8_bytes (abfd
, line_ptr
, line_end
);
2126 line_ptr
+= offset_size
;
2128 lh
.minimum_instruction_length
= read_1_byte (abfd
, line_ptr
, line_end
);
2131 if (lh
.version
>= 4)
2133 lh
.maximum_ops_per_insn
= read_1_byte (abfd
, line_ptr
, line_end
);
2137 lh
.maximum_ops_per_insn
= 1;
2139 if (lh
.maximum_ops_per_insn
== 0)
2142 (_("Dwarf Error: Invalid maximum operations per instruction."));
2143 bfd_set_error (bfd_error_bad_value
);
2147 lh
.default_is_stmt
= read_1_byte (abfd
, line_ptr
, line_end
);
2150 lh
.line_base
= read_1_signed_byte (abfd
, line_ptr
, line_end
);
2153 lh
.line_range
= read_1_byte (abfd
, line_ptr
, line_end
);
2156 lh
.opcode_base
= read_1_byte (abfd
, line_ptr
, line_end
);
2159 if (line_ptr
+ (lh
.opcode_base
- 1) >= line_end
)
2161 _bfd_error_handler (_("Dwarf Error: Ran out of room reading opcodes"));
2162 bfd_set_error (bfd_error_bad_value
);
2166 amt
= lh
.opcode_base
* sizeof (unsigned char);
2167 lh
.standard_opcode_lengths
= (unsigned char *) bfd_alloc (abfd
, amt
);
2169 lh
.standard_opcode_lengths
[0] = 1;
2171 for (i
= 1; i
< lh
.opcode_base
; ++i
)
2173 lh
.standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
, line_end
);
2177 if (lh
.version
>= 5)
2179 /* Read directory table. */
2180 if (!read_formatted_entries (unit
, &line_ptr
, line_end
, table
,
2181 line_info_add_include_dir_stub
))
2184 /* Read file name table. */
2185 if (!read_formatted_entries (unit
, &line_ptr
, line_end
, table
,
2186 line_info_add_file_name
))
2191 /* Read directory table. */
2192 while ((cur_dir
= read_string (abfd
, line_ptr
, line_end
, &bytes_read
)) != NULL
)
2194 line_ptr
+= bytes_read
;
2196 if (!line_info_add_include_dir (table
, cur_dir
))
2200 line_ptr
+= bytes_read
;
2202 /* Read file name table. */
2203 while ((cur_file
= read_string (abfd
, line_ptr
, line_end
, &bytes_read
)) != NULL
)
2205 unsigned int dir
, xtime
, size
;
2207 line_ptr
+= bytes_read
;
2209 dir
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
, FALSE
, line_end
);
2210 line_ptr
+= bytes_read
;
2211 xtime
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
, FALSE
, line_end
);
2212 line_ptr
+= bytes_read
;
2213 size
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
, FALSE
, line_end
);
2214 line_ptr
+= bytes_read
;
2216 if (!line_info_add_file_name (table
, cur_file
, dir
, xtime
, size
))
2220 line_ptr
+= bytes_read
;
2223 /* Read the statement sequences until there's nothing left. */
2224 while (line_ptr
< line_end
)
2226 /* State machine registers. */
2227 bfd_vma address
= 0;
2228 unsigned char op_index
= 0;
2229 char * filename
= table
->num_files
? concat_filename (table
, 1) : NULL
;
2230 unsigned int line
= 1;
2231 unsigned int column
= 0;
2232 unsigned int discriminator
= 0;
2233 int is_stmt
= lh
.default_is_stmt
;
2234 int end_sequence
= 0;
2235 unsigned int dir
, xtime
, size
;
2236 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
2237 compilers generate address sequences that are wildly out of
2238 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
2239 for ia64-Linux). Thus, to determine the low and high
2240 address, we must compare on every DW_LNS_copy, etc. */
2241 bfd_vma low_pc
= (bfd_vma
) -1;
2242 bfd_vma high_pc
= 0;
2244 /* Decode the table. */
2245 while (!end_sequence
&& line_ptr
< line_end
)
2247 op_code
= read_1_byte (abfd
, line_ptr
, line_end
);
2250 if (op_code
>= lh
.opcode_base
)
2252 /* Special operand. */
2253 adj_opcode
= op_code
- lh
.opcode_base
;
2254 if (lh
.line_range
== 0)
2256 if (lh
.maximum_ops_per_insn
== 1)
2257 address
+= (adj_opcode
/ lh
.line_range
2258 * lh
.minimum_instruction_length
);
2261 address
+= ((op_index
+ adj_opcode
/ lh
.line_range
)
2262 / lh
.maximum_ops_per_insn
2263 * lh
.minimum_instruction_length
);
2264 op_index
= ((op_index
+ adj_opcode
/ lh
.line_range
)
2265 % lh
.maximum_ops_per_insn
);
2267 line
+= lh
.line_base
+ (adj_opcode
% lh
.line_range
);
2268 /* Append row to matrix using current values. */
2269 if (!add_line_info (table
, address
, op_index
, filename
,
2270 line
, column
, discriminator
, 0))
2273 if (address
< low_pc
)
2275 if (address
> high_pc
)
2278 else switch (op_code
)
2280 case DW_LNS_extended_op
:
2281 exop_len
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2283 line_ptr
+= bytes_read
;
2284 extended_op
= read_1_byte (abfd
, line_ptr
, line_end
);
2287 switch (extended_op
)
2289 case DW_LNE_end_sequence
:
2291 if (!add_line_info (table
, address
, op_index
, filename
, line
,
2292 column
, discriminator
, end_sequence
))
2295 if (address
< low_pc
)
2297 if (address
> high_pc
)
2299 if (!arange_add (unit
, &unit
->arange
, low_pc
, high_pc
))
2302 case DW_LNE_set_address
:
2303 address
= read_address (unit
, line_ptr
, line_end
);
2305 line_ptr
+= unit
->addr_size
;
2307 case DW_LNE_define_file
:
2308 cur_file
= read_string (abfd
, line_ptr
, line_end
, &bytes_read
);
2309 line_ptr
+= bytes_read
;
2310 dir
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2312 line_ptr
+= bytes_read
;
2313 xtime
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2315 line_ptr
+= bytes_read
;
2316 size
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2318 line_ptr
+= bytes_read
;
2319 if (!line_info_add_file_name (table
, cur_file
, dir
,
2323 case DW_LNE_set_discriminator
:
2325 _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2327 line_ptr
+= bytes_read
;
2329 case DW_LNE_HP_source_file_correlation
:
2330 line_ptr
+= exop_len
- 1;
2334 (_("Dwarf Error: mangled line number section."));
2335 bfd_set_error (bfd_error_bad_value
);
2337 if (filename
!= NULL
)
2343 if (!add_line_info (table
, address
, op_index
,
2344 filename
, line
, column
, discriminator
, 0))
2347 if (address
< low_pc
)
2349 if (address
> high_pc
)
2352 case DW_LNS_advance_pc
:
2353 if (lh
.maximum_ops_per_insn
== 1)
2354 address
+= (lh
.minimum_instruction_length
2355 * _bfd_safe_read_leb128 (abfd
, line_ptr
,
2360 bfd_vma adjust
= _bfd_safe_read_leb128 (abfd
, line_ptr
,
2363 address
= ((op_index
+ adjust
) / lh
.maximum_ops_per_insn
2364 * lh
.minimum_instruction_length
);
2365 op_index
= (op_index
+ adjust
) % lh
.maximum_ops_per_insn
;
2367 line_ptr
+= bytes_read
;
2369 case DW_LNS_advance_line
:
2370 line
+= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2372 line_ptr
+= bytes_read
;
2374 case DW_LNS_set_file
:
2378 /* The file and directory tables are 0
2379 based, the references are 1 based. */
2380 file
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2382 line_ptr
+= bytes_read
;
2385 filename
= concat_filename (table
, file
);
2388 case DW_LNS_set_column
:
2389 column
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2391 line_ptr
+= bytes_read
;
2393 case DW_LNS_negate_stmt
:
2394 is_stmt
= (!is_stmt
);
2396 case DW_LNS_set_basic_block
:
2398 case DW_LNS_const_add_pc
:
2399 if (lh
.line_range
== 0)
2401 if (lh
.maximum_ops_per_insn
== 1)
2402 address
+= (lh
.minimum_instruction_length
2403 * ((255 - lh
.opcode_base
) / lh
.line_range
));
2406 bfd_vma adjust
= ((255 - lh
.opcode_base
) / lh
.line_range
);
2407 address
+= (lh
.minimum_instruction_length
2408 * ((op_index
+ adjust
)
2409 / lh
.maximum_ops_per_insn
));
2410 op_index
= (op_index
+ adjust
) % lh
.maximum_ops_per_insn
;
2413 case DW_LNS_fixed_advance_pc
:
2414 address
+= read_2_bytes (abfd
, line_ptr
, line_end
);
2419 /* Unknown standard opcode, ignore it. */
2420 for (i
= 0; i
< lh
.standard_opcode_lengths
[op_code
]; i
++)
2422 (void) _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2424 line_ptr
+= bytes_read
;
2434 if (sort_line_sequences (table
))
2438 while (table
->sequences
!= NULL
)
2440 struct line_sequence
* seq
= table
->sequences
;
2441 table
->sequences
= table
->sequences
->prev_sequence
;
2444 if (table
->files
!= NULL
)
2445 free (table
->files
);
2446 if (table
->dirs
!= NULL
)
2451 /* If ADDR is within TABLE set the output parameters and return the
2452 range of addresses covered by the entry used to fill them out.
2453 Otherwise set * FILENAME_PTR to NULL and return 0.
2454 The parameters FILENAME_PTR, LINENUMBER_PTR and DISCRIMINATOR_PTR
2455 are pointers to the objects to be filled in. */
2458 lookup_address_in_line_info_table (struct line_info_table
*table
,
2460 const char **filename_ptr
,
2461 unsigned int *linenumber_ptr
,
2462 unsigned int *discriminator_ptr
)
2464 struct line_sequence
*seq
= NULL
;
2465 struct line_info
*info
;
2468 /* Binary search the array of sequences. */
2470 high
= table
->num_sequences
;
2473 mid
= (low
+ high
) / 2;
2474 seq
= &table
->sequences
[mid
];
2475 if (addr
< seq
->low_pc
)
2477 else if (addr
>= seq
->last_line
->address
)
2483 /* Check for a valid sequence. */
2484 if (!seq
|| addr
< seq
->low_pc
|| addr
>= seq
->last_line
->address
)
2487 if (!build_line_info_table (table
, seq
))
2490 /* Binary search the array of line information. */
2492 high
= seq
->num_lines
;
2496 mid
= (low
+ high
) / 2;
2497 info
= seq
->line_info_lookup
[mid
];
2498 if (addr
< info
->address
)
2500 else if (addr
>= seq
->line_info_lookup
[mid
+ 1]->address
)
2506 /* Check for a valid line information entry. */
2508 && addr
>= info
->address
2509 && addr
< seq
->line_info_lookup
[mid
+ 1]->address
2510 && !(info
->end_sequence
|| info
== seq
->last_line
))
2512 *filename_ptr
= info
->filename
;
2513 *linenumber_ptr
= info
->line
;
2514 if (discriminator_ptr
)
2515 *discriminator_ptr
= info
->discriminator
;
2516 return seq
->last_line
->address
- seq
->low_pc
;
2520 *filename_ptr
= NULL
;
2524 /* Read in the .debug_ranges section for future reference. */
2527 read_debug_ranges (struct comp_unit
* unit
)
2529 struct dwarf2_debug
* stash
= unit
->stash
;
2531 return read_section (unit
->abfd
, &stash
->debug_sections
[debug_ranges
],
2533 &stash
->dwarf_ranges_buffer
,
2534 &stash
->dwarf_ranges_size
);
2537 /* Function table functions. */
2540 compare_lookup_funcinfos (const void * a
, const void * b
)
2542 const struct lookup_funcinfo
* lookup1
= a
;
2543 const struct lookup_funcinfo
* lookup2
= b
;
2545 if (lookup1
->low_addr
< lookup2
->low_addr
)
2547 if (lookup1
->low_addr
> lookup2
->low_addr
)
2549 if (lookup1
->high_addr
< lookup2
->high_addr
)
2551 if (lookup1
->high_addr
> lookup2
->high_addr
)
2558 build_lookup_funcinfo_table (struct comp_unit
* unit
)
2560 struct lookup_funcinfo
*lookup_funcinfo_table
= unit
->lookup_funcinfo_table
;
2561 unsigned int number_of_functions
= unit
->number_of_functions
;
2562 struct funcinfo
*each
;
2563 struct lookup_funcinfo
*entry
;
2565 struct arange
*range
;
2566 bfd_vma low_addr
, high_addr
;
2568 if (lookup_funcinfo_table
|| number_of_functions
== 0)
2571 /* Create the function info lookup table. */
2572 lookup_funcinfo_table
= (struct lookup_funcinfo
*)
2573 bfd_malloc (number_of_functions
* sizeof (struct lookup_funcinfo
));
2574 if (lookup_funcinfo_table
== NULL
)
2577 /* Populate the function info lookup table. */
2578 func_index
= number_of_functions
;
2579 for (each
= unit
->function_table
; each
; each
= each
->prev_func
)
2581 entry
= &lookup_funcinfo_table
[--func_index
];
2582 entry
->funcinfo
= each
;
2584 /* Calculate the lowest and highest address for this function entry. */
2585 low_addr
= entry
->funcinfo
->arange
.low
;
2586 high_addr
= entry
->funcinfo
->arange
.high
;
2588 for (range
= entry
->funcinfo
->arange
.next
; range
; range
= range
->next
)
2590 if (range
->low
< low_addr
)
2591 low_addr
= range
->low
;
2592 if (range
->high
> high_addr
)
2593 high_addr
= range
->high
;
2596 entry
->low_addr
= low_addr
;
2597 entry
->high_addr
= high_addr
;
2600 BFD_ASSERT (func_index
== 0);
2602 /* Sort the function by address. */
2603 qsort (lookup_funcinfo_table
,
2604 number_of_functions
,
2605 sizeof (struct lookup_funcinfo
),
2606 compare_lookup_funcinfos
);
2608 /* Calculate the high watermark for each function in the lookup table. */
2609 high_addr
= lookup_funcinfo_table
[0].high_addr
;
2610 for (func_index
= 1; func_index
< number_of_functions
; func_index
++)
2612 entry
= &lookup_funcinfo_table
[func_index
];
2613 if (entry
->high_addr
> high_addr
)
2614 high_addr
= entry
->high_addr
;
2616 entry
->high_addr
= high_addr
;
2619 unit
->lookup_funcinfo_table
= lookup_funcinfo_table
;
2623 /* If ADDR is within UNIT's function tables, set FUNCTION_PTR, and return
2624 TRUE. Note that we need to find the function that has the smallest range
2625 that contains ADDR, to handle inlined functions without depending upon
2626 them being ordered in TABLE by increasing range. */
2629 lookup_address_in_function_table (struct comp_unit
*unit
,
2631 struct funcinfo
**function_ptr
)
2633 unsigned int number_of_functions
= unit
->number_of_functions
;
2634 struct lookup_funcinfo
* lookup_funcinfo
= NULL
;
2635 struct funcinfo
* funcinfo
= NULL
;
2636 struct funcinfo
* best_fit
= NULL
;
2637 bfd_vma best_fit_len
= 0;
2638 bfd_size_type low
, high
, mid
, first
;
2639 struct arange
*arange
;
2641 if (number_of_functions
== 0)
2644 if (!build_lookup_funcinfo_table (unit
))
2647 if (unit
->lookup_funcinfo_table
[number_of_functions
- 1].high_addr
< addr
)
2650 /* Find the first function in the lookup table which may contain the
2651 specified address. */
2653 high
= number_of_functions
;
2657 mid
= (low
+ high
) / 2;
2658 lookup_funcinfo
= &unit
->lookup_funcinfo_table
[mid
];
2659 if (addr
< lookup_funcinfo
->low_addr
)
2661 else if (addr
>= lookup_funcinfo
->high_addr
)
2667 /* Find the 'best' match for the address. The prior algorithm defined the
2668 best match as the function with the smallest address range containing
2669 the specified address. This definition should probably be changed to the
2670 innermost inline routine containing the address, but right now we want
2671 to get the same results we did before. */
2672 while (first
< number_of_functions
)
2674 if (addr
< unit
->lookup_funcinfo_table
[first
].low_addr
)
2676 funcinfo
= unit
->lookup_funcinfo_table
[first
].funcinfo
;
2678 for (arange
= &funcinfo
->arange
; arange
; arange
= arange
->next
)
2680 if (addr
< arange
->low
|| addr
>= arange
->high
)
2684 || arange
->high
- arange
->low
< best_fit_len
2685 /* The following comparison is designed to return the same
2686 match as the previous algorithm for routines which have the
2687 same best fit length. */
2688 || (arange
->high
- arange
->low
== best_fit_len
2689 && funcinfo
> best_fit
))
2691 best_fit
= funcinfo
;
2692 best_fit_len
= arange
->high
- arange
->low
;
2702 *function_ptr
= best_fit
;
2706 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
2707 and LINENUMBER_PTR, and return TRUE. */
2710 lookup_symbol_in_function_table (struct comp_unit
*unit
,
2713 const char **filename_ptr
,
2714 unsigned int *linenumber_ptr
)
2716 struct funcinfo
* each_func
;
2717 struct funcinfo
* best_fit
= NULL
;
2718 bfd_vma best_fit_len
= 0;
2719 struct arange
*arange
;
2720 const char *name
= bfd_asymbol_name (sym
);
2721 asection
*sec
= bfd_get_section (sym
);
2723 for (each_func
= unit
->function_table
;
2725 each_func
= each_func
->prev_func
)
2727 for (arange
= &each_func
->arange
;
2729 arange
= arange
->next
)
2731 if ((!each_func
->sec
|| each_func
->sec
== sec
)
2732 && addr
>= arange
->low
2733 && addr
< arange
->high
2735 && strcmp (name
, each_func
->name
) == 0
2737 || arange
->high
- arange
->low
< best_fit_len
))
2739 best_fit
= each_func
;
2740 best_fit_len
= arange
->high
- arange
->low
;
2747 best_fit
->sec
= sec
;
2748 *filename_ptr
= best_fit
->file
;
2749 *linenumber_ptr
= best_fit
->line
;
2756 /* Variable table functions. */
2758 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
2759 LINENUMBER_PTR, and return TRUE. */
2762 lookup_symbol_in_variable_table (struct comp_unit
*unit
,
2765 const char **filename_ptr
,
2766 unsigned int *linenumber_ptr
)
2768 const char *name
= bfd_asymbol_name (sym
);
2769 asection
*sec
= bfd_get_section (sym
);
2770 struct varinfo
* each
;
2772 for (each
= unit
->variable_table
; each
; each
= each
->prev_var
)
2773 if (each
->stack
== 0
2774 && each
->file
!= NULL
2775 && each
->name
!= NULL
2776 && each
->addr
== addr
2777 && (!each
->sec
|| each
->sec
== sec
)
2778 && strcmp (name
, each
->name
) == 0)
2784 *filename_ptr
= each
->file
;
2785 *linenumber_ptr
= each
->line
;
2793 find_abstract_instance (struct comp_unit
* unit
,
2794 bfd_byte
* orig_info_ptr
,
2795 struct attribute
* attr_ptr
,
2796 const char ** pname
,
2797 bfd_boolean
* is_linkage
,
2798 char ** filename_ptr
,
2799 int * linenumber_ptr
)
2801 bfd
*abfd
= unit
->abfd
;
2803 bfd_byte
*info_ptr_end
;
2804 unsigned int abbrev_number
, bytes_read
, i
;
2805 struct abbrev_info
*abbrev
;
2806 bfd_uint64_t die_ref
= attr_ptr
->u
.val
;
2807 struct attribute attr
;
2808 const char *name
= NULL
;
2810 /* DW_FORM_ref_addr can reference an entry in a different CU. It
2811 is an offset from the .debug_info section, not the current CU. */
2812 if (attr_ptr
->form
== DW_FORM_ref_addr
)
2814 /* We only support DW_FORM_ref_addr within the same file, so
2815 any relocations should be resolved already. Check this by
2816 testing for a zero die_ref; There can't be a valid reference
2817 to the header of a .debug_info section.
2818 DW_FORM_ref_addr is an offset relative to .debug_info.
2819 Normally when using the GNU linker this is accomplished by
2820 emitting a symbolic reference to a label, because .debug_info
2821 sections are linked at zero. When there are multiple section
2822 groups containing .debug_info, as there might be in a
2823 relocatable object file, it would be reasonable to assume that
2824 a symbolic reference to a label in any .debug_info section
2825 might be used. Since we lay out multiple .debug_info
2826 sections at non-zero VMAs (see place_sections), and read
2827 them contiguously into stash->info_ptr_memory, that means
2828 the reference is relative to stash->info_ptr_memory. */
2831 info_ptr
= unit
->stash
->info_ptr_memory
;
2832 info_ptr_end
= unit
->stash
->info_ptr_end
;
2833 total
= info_ptr_end
- info_ptr
;
2834 if (!die_ref
|| die_ref
>= total
)
2837 (_("Dwarf Error: Invalid abstract instance DIE ref."));
2838 bfd_set_error (bfd_error_bad_value
);
2841 info_ptr
+= die_ref
;
2843 /* Now find the CU containing this pointer. */
2844 if (info_ptr
>= unit
->info_ptr_unit
&& info_ptr
< unit
->end_ptr
)
2845 info_ptr_end
= unit
->end_ptr
;
2848 /* Check other CUs to see if they contain the abbrev. */
2849 struct comp_unit
* u
;
2851 for (u
= unit
->prev_unit
; u
!= NULL
; u
= u
->prev_unit
)
2852 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
2856 for (u
= unit
->next_unit
; u
!= NULL
; u
= u
->next_unit
)
2857 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
2863 info_ptr_end
= unit
->end_ptr
;
2865 /* else FIXME: What do we do now ? */
2868 else if (attr_ptr
->form
== DW_FORM_GNU_ref_alt
)
2870 info_ptr
= read_alt_indirect_ref (unit
, die_ref
);
2871 if (info_ptr
== NULL
)
2874 (_("Dwarf Error: Unable to read alt ref %" PRIu64
"."),
2875 (uint64_t) die_ref
);
2876 bfd_set_error (bfd_error_bad_value
);
2879 info_ptr_end
= (unit
->stash
->alt_dwarf_info_buffer
2880 + unit
->stash
->alt_dwarf_info_size
);
2882 /* FIXME: Do we need to locate the correct CU, in a similar
2883 fashion to the code in the DW_FORM_ref_addr case above ? */
2887 /* DW_FORM_ref1, DW_FORM_ref2, DW_FORM_ref4, DW_FORM_ref8 or
2888 DW_FORM_ref_udata. These are all references relative to the
2889 start of the current CU. */
2892 info_ptr
= unit
->info_ptr_unit
;
2893 info_ptr_end
= unit
->end_ptr
;
2894 total
= info_ptr_end
- info_ptr
;
2895 if (!die_ref
|| die_ref
>= total
)
2898 (_("Dwarf Error: Invalid abstract instance DIE ref."));
2899 bfd_set_error (bfd_error_bad_value
);
2902 info_ptr
+= die_ref
;
2905 abbrev_number
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
2906 FALSE
, info_ptr_end
);
2907 info_ptr
+= bytes_read
;
2911 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
2915 (_("Dwarf Error: Could not find abbrev number %u."), abbrev_number
);
2916 bfd_set_error (bfd_error_bad_value
);
2921 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
2923 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
,
2924 info_ptr
, info_ptr_end
);
2925 if (info_ptr
== NULL
)
2927 /* It doesn't ever make sense for DW_AT_specification to
2928 refer to the same DIE. Stop simple recursion. */
2929 if (info_ptr
== orig_info_ptr
)
2932 (_("Dwarf Error: Abstract instance recursion detected."));
2933 bfd_set_error (bfd_error_bad_value
);
2939 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2941 if (name
== NULL
&& is_str_attr (attr
.form
))
2944 if (non_mangled (unit
->lang
))
2948 case DW_AT_specification
:
2949 if (!find_abstract_instance (unit
, info_ptr
, &attr
,
2951 filename_ptr
, linenumber_ptr
))
2954 case DW_AT_linkage_name
:
2955 case DW_AT_MIPS_linkage_name
:
2956 /* PR 16949: Corrupt debug info can place
2957 non-string forms into these attributes. */
2958 if (is_str_attr (attr
.form
))
2964 case DW_AT_decl_file
:
2965 *filename_ptr
= concat_filename (unit
->line_table
,
2968 case DW_AT_decl_line
:
2969 *linenumber_ptr
= attr
.u
.val
;
2982 read_rangelist (struct comp_unit
*unit
, struct arange
*arange
,
2983 bfd_uint64_t offset
)
2985 bfd_byte
*ranges_ptr
;
2986 bfd_byte
*ranges_end
;
2987 bfd_vma base_address
= unit
->base_address
;
2989 if (! unit
->stash
->dwarf_ranges_buffer
)
2991 if (! read_debug_ranges (unit
))
2995 ranges_ptr
= unit
->stash
->dwarf_ranges_buffer
+ offset
;
2996 if (ranges_ptr
< unit
->stash
->dwarf_ranges_buffer
)
2998 ranges_end
= unit
->stash
->dwarf_ranges_buffer
+ unit
->stash
->dwarf_ranges_size
;
3005 /* PR 17512: file: 62cada7d. */
3006 if (ranges_ptr
+ 2 * unit
->addr_size
> ranges_end
)
3009 low_pc
= read_address (unit
, ranges_ptr
, ranges_end
);
3010 ranges_ptr
+= unit
->addr_size
;
3011 high_pc
= read_address (unit
, ranges_ptr
, ranges_end
);
3012 ranges_ptr
+= unit
->addr_size
;
3014 if (low_pc
== 0 && high_pc
== 0)
3016 if (low_pc
== -1UL && high_pc
!= -1UL)
3017 base_address
= high_pc
;
3020 if (!arange_add (unit
, arange
,
3021 base_address
+ low_pc
, base_address
+ high_pc
))
3028 /* DWARF2 Compilation unit functions. */
3030 /* Scan over each die in a comp. unit looking for functions to add
3031 to the function table and variables to the variable table. */
3034 scan_unit_for_symbols (struct comp_unit
*unit
)
3036 bfd
*abfd
= unit
->abfd
;
3037 bfd_byte
*info_ptr
= unit
->first_child_die_ptr
;
3038 bfd_byte
*info_ptr_end
= unit
->stash
->info_ptr_end
;
3039 int nesting_level
= 0;
3040 struct nest_funcinfo
{
3041 struct funcinfo
*func
;
3043 int nested_funcs_size
;
3045 /* Maintain a stack of in-scope functions and inlined functions, which we
3046 can use to set the caller_func field. */
3047 nested_funcs_size
= 32;
3048 nested_funcs
= (struct nest_funcinfo
*)
3049 bfd_malloc (nested_funcs_size
* sizeof (*nested_funcs
));
3050 if (nested_funcs
== NULL
)
3052 nested_funcs
[nesting_level
].func
= 0;
3054 while (nesting_level
>= 0)
3056 unsigned int abbrev_number
, bytes_read
, i
;
3057 struct abbrev_info
*abbrev
;
3058 struct attribute attr
;
3059 struct funcinfo
*func
;
3060 struct varinfo
*var
;
3062 bfd_vma high_pc
= 0;
3063 bfd_boolean high_pc_relative
= FALSE
;
3065 /* PR 17512: file: 9f405d9d. */
3066 if (info_ptr
>= info_ptr_end
)
3069 abbrev_number
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
3070 FALSE
, info_ptr_end
);
3071 info_ptr
+= bytes_read
;
3073 if (! abbrev_number
)
3079 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
3082 static unsigned int previous_failed_abbrev
= -1U;
3084 /* Avoid multiple reports of the same missing abbrev. */
3085 if (abbrev_number
!= previous_failed_abbrev
)
3088 (_("Dwarf Error: Could not find abbrev number %u."),
3090 previous_failed_abbrev
= abbrev_number
;
3092 bfd_set_error (bfd_error_bad_value
);
3097 if (abbrev
->tag
== DW_TAG_subprogram
3098 || abbrev
->tag
== DW_TAG_entry_point
3099 || abbrev
->tag
== DW_TAG_inlined_subroutine
)
3101 bfd_size_type amt
= sizeof (struct funcinfo
);
3102 func
= (struct funcinfo
*) bfd_zalloc (abfd
, amt
);
3105 func
->tag
= abbrev
->tag
;
3106 func
->prev_func
= unit
->function_table
;
3107 unit
->function_table
= func
;
3108 unit
->number_of_functions
++;
3109 BFD_ASSERT (!unit
->cached
);
3111 if (func
->tag
== DW_TAG_inlined_subroutine
)
3112 for (i
= nesting_level
; i
-- != 0; )
3113 if (nested_funcs
[i
].func
)
3115 func
->caller_func
= nested_funcs
[i
].func
;
3118 nested_funcs
[nesting_level
].func
= func
;
3123 if (abbrev
->tag
== DW_TAG_variable
)
3125 bfd_size_type amt
= sizeof (struct varinfo
);
3126 var
= (struct varinfo
*) bfd_zalloc (abfd
, amt
);
3129 var
->tag
= abbrev
->tag
;
3131 var
->prev_var
= unit
->variable_table
;
3132 unit
->variable_table
= var
;
3133 /* PR 18205: Missing debug information can cause this
3134 var to be attached to an already cached unit. */
3137 /* No inline function in scope at this nesting level. */
3138 nested_funcs
[nesting_level
].func
= 0;
3141 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3143 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
],
3144 unit
, info_ptr
, info_ptr_end
);
3145 if (info_ptr
== NULL
)
3152 case DW_AT_call_file
:
3153 func
->caller_file
= concat_filename (unit
->line_table
,
3157 case DW_AT_call_line
:
3158 func
->caller_line
= attr
.u
.val
;
3161 case DW_AT_abstract_origin
:
3162 case DW_AT_specification
:
3163 if (!find_abstract_instance (unit
, info_ptr
, &attr
,
3172 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
3174 if (func
->name
== NULL
&& is_str_attr (attr
.form
))
3176 func
->name
= attr
.u
.str
;
3177 if (non_mangled (unit
->lang
))
3178 func
->is_linkage
= TRUE
;
3182 case DW_AT_linkage_name
:
3183 case DW_AT_MIPS_linkage_name
:
3184 /* PR 16949: Corrupt debug info can place
3185 non-string forms into these attributes. */
3186 if (is_str_attr (attr
.form
))
3188 func
->name
= attr
.u
.str
;
3189 func
->is_linkage
= TRUE
;
3194 low_pc
= attr
.u
.val
;
3198 high_pc
= attr
.u
.val
;
3199 high_pc_relative
= attr
.form
!= DW_FORM_addr
;
3203 if (!read_rangelist (unit
, &func
->arange
, attr
.u
.val
))
3207 case DW_AT_decl_file
:
3208 func
->file
= concat_filename (unit
->line_table
,
3212 case DW_AT_decl_line
:
3213 func
->line
= attr
.u
.val
;
3225 if (is_str_attr (attr
.form
))
3226 var
->name
= attr
.u
.str
;
3229 case DW_AT_decl_file
:
3230 var
->file
= concat_filename (unit
->line_table
,
3234 case DW_AT_decl_line
:
3235 var
->line
= attr
.u
.val
;
3238 case DW_AT_external
:
3239 if (attr
.u
.val
!= 0)
3243 case DW_AT_location
:
3247 case DW_FORM_block1
:
3248 case DW_FORM_block2
:
3249 case DW_FORM_block4
:
3250 case DW_FORM_exprloc
:
3251 if (attr
.u
.blk
->data
!= NULL
3252 && *attr
.u
.blk
->data
== DW_OP_addr
)
3256 /* Verify that DW_OP_addr is the only opcode in the
3257 location, in which case the block size will be 1
3258 plus the address size. */
3259 /* ??? For TLS variables, gcc can emit
3260 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
3261 which we don't handle here yet. */
3262 if (attr
.u
.blk
->size
== unit
->addr_size
+ 1U)
3263 var
->addr
= bfd_get (unit
->addr_size
* 8,
3265 attr
.u
.blk
->data
+ 1);
3280 if (high_pc_relative
)
3283 if (func
&& high_pc
!= 0)
3285 if (!arange_add (unit
, &func
->arange
, low_pc
, high_pc
))
3289 if (abbrev
->has_children
)
3293 if (nesting_level
>= nested_funcs_size
)
3295 struct nest_funcinfo
*tmp
;
3297 nested_funcs_size
*= 2;
3298 tmp
= (struct nest_funcinfo
*)
3299 bfd_realloc (nested_funcs
,
3300 nested_funcs_size
* sizeof (*nested_funcs
));
3305 nested_funcs
[nesting_level
].func
= 0;
3309 free (nested_funcs
);
3313 free (nested_funcs
);
3317 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
3318 includes the compilation unit header that proceeds the DIE's, but
3319 does not include the length field that precedes each compilation
3320 unit header. END_PTR points one past the end of this comp unit.
3321 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
3323 This routine does not read the whole compilation unit; only enough
3324 to get to the line number information for the compilation unit. */
3326 static struct comp_unit
*
3327 parse_comp_unit (struct dwarf2_debug
*stash
,
3328 bfd_vma unit_length
,
3329 bfd_byte
*info_ptr_unit
,
3330 unsigned int offset_size
)
3332 struct comp_unit
* unit
;
3333 unsigned int version
;
3334 bfd_uint64_t abbrev_offset
= 0;
3335 /* Initialize it just to avoid a GCC false warning. */
3336 unsigned int addr_size
= -1;
3337 struct abbrev_info
** abbrevs
;
3338 unsigned int abbrev_number
, bytes_read
, i
;
3339 struct abbrev_info
*abbrev
;
3340 struct attribute attr
;
3341 bfd_byte
*info_ptr
= stash
->info_ptr
;
3342 bfd_byte
*end_ptr
= info_ptr
+ unit_length
;
3345 bfd_vma high_pc
= 0;
3346 bfd
*abfd
= stash
->bfd_ptr
;
3347 bfd_boolean high_pc_relative
= FALSE
;
3348 enum dwarf_unit_type unit_type
;
3350 version
= read_2_bytes (abfd
, info_ptr
, end_ptr
);
3352 if (version
< 2 || version
> 5)
3354 /* PR 19872: A version number of 0 probably means that there is padding
3355 at the end of the .debug_info section. Gold puts it there when
3356 performing an incremental link, for example. So do not generate
3357 an error, just return a NULL. */
3361 (_("Dwarf Error: found dwarf version '%u', this reader"
3362 " only handles version 2, 3, 4 and 5 information."), version
);
3363 bfd_set_error (bfd_error_bad_value
);
3369 unit_type
= DW_UT_compile
;
3372 unit_type
= read_1_byte (abfd
, info_ptr
, end_ptr
);
3375 addr_size
= read_1_byte (abfd
, info_ptr
, end_ptr
);
3379 BFD_ASSERT (offset_size
== 4 || offset_size
== 8);
3380 if (offset_size
== 4)
3381 abbrev_offset
= read_4_bytes (abfd
, info_ptr
, end_ptr
);
3383 abbrev_offset
= read_8_bytes (abfd
, info_ptr
, end_ptr
);
3384 info_ptr
+= offset_size
;
3388 addr_size
= read_1_byte (abfd
, info_ptr
, end_ptr
);
3392 if (unit_type
== DW_UT_type
)
3394 /* Skip type signature. */
3397 /* Skip type offset. */
3398 info_ptr
+= offset_size
;
3401 if (addr_size
> sizeof (bfd_vma
))
3404 /* xgettext: c-format */
3405 (_("Dwarf Error: found address size '%u', this reader"
3406 " can not handle sizes greater than '%u'."),
3408 (unsigned int) sizeof (bfd_vma
));
3409 bfd_set_error (bfd_error_bad_value
);
3413 if (addr_size
!= 2 && addr_size
!= 4 && addr_size
!= 8)
3416 ("Dwarf Error: found address size '%u', this reader"
3417 " can only handle address sizes '2', '4' and '8'.", addr_size
);
3418 bfd_set_error (bfd_error_bad_value
);
3422 /* Read the abbrevs for this compilation unit into a table. */
3423 abbrevs
= read_abbrevs (abfd
, abbrev_offset
, stash
);
3427 abbrev_number
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
3429 info_ptr
+= bytes_read
;
3430 if (! abbrev_number
)
3432 /* PR 19872: An abbrev number of 0 probably means that there is padding
3433 at the end of the .debug_abbrev section. Gold puts it there when
3434 performing an incremental link, for example. So do not generate
3435 an error, just return a NULL. */
3439 abbrev
= lookup_abbrev (abbrev_number
, abbrevs
);
3442 _bfd_error_handler (_("Dwarf Error: Could not find abbrev number %u."),
3444 bfd_set_error (bfd_error_bad_value
);
3448 amt
= sizeof (struct comp_unit
);
3449 unit
= (struct comp_unit
*) bfd_zalloc (abfd
, amt
);
3453 unit
->version
= version
;
3454 unit
->addr_size
= addr_size
;
3455 unit
->offset_size
= offset_size
;
3456 unit
->abbrevs
= abbrevs
;
3457 unit
->end_ptr
= end_ptr
;
3458 unit
->stash
= stash
;
3459 unit
->info_ptr_unit
= info_ptr_unit
;
3461 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3463 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
, end_ptr
);
3464 if (info_ptr
== NULL
)
3467 /* Store the data if it is of an attribute we want to keep in a
3468 partial symbol table. */
3471 case DW_AT_stmt_list
:
3473 unit
->line_offset
= attr
.u
.val
;
3477 if (is_str_attr (attr
.form
))
3478 unit
->name
= attr
.u
.str
;
3482 low_pc
= attr
.u
.val
;
3483 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
3484 this is the base address to use when reading location
3485 lists or range lists. */
3486 if (abbrev
->tag
== DW_TAG_compile_unit
)
3487 unit
->base_address
= low_pc
;
3491 high_pc
= attr
.u
.val
;
3492 high_pc_relative
= attr
.form
!= DW_FORM_addr
;
3496 if (!read_rangelist (unit
, &unit
->arange
, attr
.u
.val
))
3500 case DW_AT_comp_dir
:
3502 char *comp_dir
= attr
.u
.str
;
3504 /* PR 17512: file: 1fe726be. */
3505 if (! is_str_attr (attr
.form
))
3508 (_("Dwarf Error: DW_AT_comp_dir attribute encountered with a non-string form."));
3514 /* Irix 6.2 native cc prepends <machine>.: to the compilation
3515 directory, get rid of it. */
3516 char *cp
= strchr (comp_dir
, ':');
3518 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
3521 unit
->comp_dir
= comp_dir
;
3525 case DW_AT_language
:
3526 unit
->lang
= attr
.u
.val
;
3533 if (high_pc_relative
)
3537 if (!arange_add (unit
, &unit
->arange
, low_pc
, high_pc
))
3541 unit
->first_child_die_ptr
= info_ptr
;
3545 /* Return TRUE if UNIT may contain the address given by ADDR. When
3546 there are functions written entirely with inline asm statements, the
3547 range info in the compilation unit header may not be correct. We
3548 need to consult the line info table to see if a compilation unit
3549 really contains the given address. */
3552 comp_unit_contains_address (struct comp_unit
*unit
, bfd_vma addr
)
3554 struct arange
*arange
;
3559 arange
= &unit
->arange
;
3562 if (addr
>= arange
->low
&& addr
< arange
->high
)
3564 arange
= arange
->next
;
3571 /* If UNIT contains ADDR, set the output parameters to the values for
3572 the line containing ADDR. The output parameters, FILENAME_PTR,
3573 FUNCTION_PTR, and LINENUMBER_PTR, are pointers to the objects
3576 Returns the range of addresses covered by the entry that was used
3577 to fill in *LINENUMBER_PTR or 0 if it was not filled in. */
3580 comp_unit_find_nearest_line (struct comp_unit
*unit
,
3582 const char **filename_ptr
,
3583 struct funcinfo
**function_ptr
,
3584 unsigned int *linenumber_ptr
,
3585 unsigned int *discriminator_ptr
,
3586 struct dwarf2_debug
*stash
)
3593 if (! unit
->line_table
)
3595 if (! unit
->stmtlist
)
3601 unit
->line_table
= decode_line_info (unit
, stash
);
3603 if (! unit
->line_table
)
3609 if (unit
->first_child_die_ptr
< unit
->end_ptr
3610 && ! scan_unit_for_symbols (unit
))
3617 *function_ptr
= NULL
;
3618 func_p
= lookup_address_in_function_table (unit
, addr
, function_ptr
);
3619 if (func_p
&& (*function_ptr
)->tag
== DW_TAG_inlined_subroutine
)
3620 stash
->inliner_chain
= *function_ptr
;
3622 return lookup_address_in_line_info_table (unit
->line_table
, addr
,
3628 /* Check to see if line info is already decoded in a comp_unit.
3629 If not, decode it. Returns TRUE if no errors were encountered;
3633 comp_unit_maybe_decode_line_info (struct comp_unit
*unit
,
3634 struct dwarf2_debug
*stash
)
3639 if (! unit
->line_table
)
3641 if (! unit
->stmtlist
)
3647 unit
->line_table
= decode_line_info (unit
, stash
);
3649 if (! unit
->line_table
)
3655 if (unit
->first_child_die_ptr
< unit
->end_ptr
3656 && ! scan_unit_for_symbols (unit
))
3666 /* If UNIT contains SYM at ADDR, set the output parameters to the
3667 values for the line containing SYM. The output parameters,
3668 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
3671 Return TRUE if UNIT contains SYM, and no errors were encountered;
3675 comp_unit_find_line (struct comp_unit
*unit
,
3678 const char **filename_ptr
,
3679 unsigned int *linenumber_ptr
,
3680 struct dwarf2_debug
*stash
)
3682 if (!comp_unit_maybe_decode_line_info (unit
, stash
))
3685 if (sym
->flags
& BSF_FUNCTION
)
3686 return lookup_symbol_in_function_table (unit
, sym
, addr
,
3690 return lookup_symbol_in_variable_table (unit
, sym
, addr
,
3695 static struct funcinfo
*
3696 reverse_funcinfo_list (struct funcinfo
*head
)
3698 struct funcinfo
*rhead
;
3699 struct funcinfo
*temp
;
3701 for (rhead
= NULL
; head
; head
= temp
)
3703 temp
= head
->prev_func
;
3704 head
->prev_func
= rhead
;
3710 static struct varinfo
*
3711 reverse_varinfo_list (struct varinfo
*head
)
3713 struct varinfo
*rhead
;
3714 struct varinfo
*temp
;
3716 for (rhead
= NULL
; head
; head
= temp
)
3718 temp
= head
->prev_var
;
3719 head
->prev_var
= rhead
;
3725 /* Extract all interesting funcinfos and varinfos of a compilation
3726 unit into hash tables for faster lookup. Returns TRUE if no
3727 errors were enountered; FALSE otherwise. */
3730 comp_unit_hash_info (struct dwarf2_debug
*stash
,
3731 struct comp_unit
*unit
,
3732 struct info_hash_table
*funcinfo_hash_table
,
3733 struct info_hash_table
*varinfo_hash_table
)
3735 struct funcinfo
* each_func
;
3736 struct varinfo
* each_var
;
3737 bfd_boolean okay
= TRUE
;
3739 BFD_ASSERT (stash
->info_hash_status
!= STASH_INFO_HASH_DISABLED
);
3741 if (!comp_unit_maybe_decode_line_info (unit
, stash
))
3744 BFD_ASSERT (!unit
->cached
);
3746 /* To preserve the original search order, we went to visit the function
3747 infos in the reversed order of the list. However, making the list
3748 bi-directional use quite a bit of extra memory. So we reverse
3749 the list first, traverse the list in the now reversed order and
3750 finally reverse the list again to get back the original order. */
3751 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
3752 for (each_func
= unit
->function_table
;
3754 each_func
= each_func
->prev_func
)
3756 /* Skip nameless functions. */
3757 if (each_func
->name
)
3758 /* There is no need to copy name string into hash table as
3759 name string is either in the dwarf string buffer or
3760 info in the stash. */
3761 okay
= insert_info_hash_table (funcinfo_hash_table
, each_func
->name
,
3762 (void*) each_func
, FALSE
);
3764 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
3768 /* We do the same for variable infos. */
3769 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
3770 for (each_var
= unit
->variable_table
;
3772 each_var
= each_var
->prev_var
)
3774 /* Skip stack vars and vars with no files or names. */
3775 if (each_var
->stack
== 0
3776 && each_var
->file
!= NULL
3777 && each_var
->name
!= NULL
)
3778 /* There is no need to copy name string into hash table as
3779 name string is either in the dwarf string buffer or
3780 info in the stash. */
3781 okay
= insert_info_hash_table (varinfo_hash_table
, each_var
->name
,
3782 (void*) each_var
, FALSE
);
3785 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
3786 unit
->cached
= TRUE
;
3790 /* Locate a section in a BFD containing debugging info. The search starts
3791 from the section after AFTER_SEC, or from the first section in the BFD if
3792 AFTER_SEC is NULL. The search works by examining the names of the
3793 sections. There are three permissiable names. The first two are given
3794 by DEBUG_SECTIONS[debug_info] (whose standard DWARF2 names are .debug_info
3795 and .zdebug_info). The third is a prefix .gnu.linkonce.wi.
3796 This is a variation on the .debug_info section which has a checksum
3797 describing the contents appended onto the name. This allows the linker to
3798 identify and discard duplicate debugging sections for different
3799 compilation units. */
3800 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
3803 find_debug_info (bfd
*abfd
, const struct dwarf_debug_section
*debug_sections
,
3804 asection
*after_sec
)
3809 if (after_sec
== NULL
)
3811 look
= debug_sections
[debug_info
].uncompressed_name
;
3812 msec
= bfd_get_section_by_name (abfd
, look
);
3816 look
= debug_sections
[debug_info
].compressed_name
;
3819 msec
= bfd_get_section_by_name (abfd
, look
);
3824 for (msec
= abfd
->sections
; msec
!= NULL
; msec
= msec
->next
)
3825 if (CONST_STRNEQ (msec
->name
, GNU_LINKONCE_INFO
))
3831 for (msec
= after_sec
->next
; msec
!= NULL
; msec
= msec
->next
)
3833 look
= debug_sections
[debug_info
].uncompressed_name
;
3834 if (strcmp (msec
->name
, look
) == 0)
3837 look
= debug_sections
[debug_info
].compressed_name
;
3838 if (look
!= NULL
&& strcmp (msec
->name
, look
) == 0)
3841 if (CONST_STRNEQ (msec
->name
, GNU_LINKONCE_INFO
))
3848 /* Transfer VMAs from object file to separate debug file. */
3851 set_debug_vma (bfd
*orig_bfd
, bfd
*debug_bfd
)
3855 for (s
= orig_bfd
->sections
, d
= debug_bfd
->sections
;
3856 s
!= NULL
&& d
!= NULL
;
3857 s
= s
->next
, d
= d
->next
)
3859 if ((d
->flags
& SEC_DEBUGGING
) != 0)
3861 /* ??? Assumes 1-1 correspondence between sections in the
3863 if (strcmp (s
->name
, d
->name
) == 0)
3865 d
->output_section
= s
->output_section
;
3866 d
->output_offset
= s
->output_offset
;
3872 /* Unset vmas for adjusted sections in STASH. */
3875 unset_sections (struct dwarf2_debug
*stash
)
3878 struct adjusted_section
*p
;
3880 i
= stash
->adjusted_section_count
;
3881 p
= stash
->adjusted_sections
;
3882 for (; i
> 0; i
--, p
++)
3883 p
->section
->vma
= 0;
3886 /* Set VMAs for allocated and .debug_info sections in ORIG_BFD, a
3887 relocatable object file. VMAs are normally all zero in relocatable
3888 object files, so if we want to distinguish locations in sections by
3889 address we need to set VMAs so the sections do not overlap. We
3890 also set VMA on .debug_info so that when we have multiple
3891 .debug_info sections (or the linkonce variant) they also do not
3892 overlap. The multiple .debug_info sections make up a single
3893 logical section. ??? We should probably do the same for other
3897 place_sections (bfd
*orig_bfd
, struct dwarf2_debug
*stash
)
3900 struct adjusted_section
*p
;
3902 const char *debug_info_name
;
3904 if (stash
->adjusted_section_count
!= 0)
3906 i
= stash
->adjusted_section_count
;
3907 p
= stash
->adjusted_sections
;
3908 for (; i
> 0; i
--, p
++)
3909 p
->section
->vma
= p
->adj_vma
;
3913 debug_info_name
= stash
->debug_sections
[debug_info
].uncompressed_name
;
3920 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
3924 if ((sect
->output_section
!= NULL
3925 && sect
->output_section
!= sect
3926 && (sect
->flags
& SEC_DEBUGGING
) == 0)
3930 is_debug_info
= (strcmp (sect
->name
, debug_info_name
) == 0
3931 || CONST_STRNEQ (sect
->name
, GNU_LINKONCE_INFO
));
3933 if (!((sect
->flags
& SEC_ALLOC
) != 0 && abfd
== orig_bfd
)
3939 if (abfd
== stash
->bfd_ptr
)
3941 abfd
= stash
->bfd_ptr
;
3945 stash
->adjusted_section_count
= -1;
3948 bfd_vma last_vma
= 0, last_dwarf
= 0;
3949 bfd_size_type amt
= i
* sizeof (struct adjusted_section
);
3951 p
= (struct adjusted_section
*) bfd_malloc (amt
);
3955 stash
->adjusted_sections
= p
;
3956 stash
->adjusted_section_count
= i
;
3963 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
3968 if ((sect
->output_section
!= NULL
3969 && sect
->output_section
!= sect
3970 && (sect
->flags
& SEC_DEBUGGING
) == 0)
3974 is_debug_info
= (strcmp (sect
->name
, debug_info_name
) == 0
3975 || CONST_STRNEQ (sect
->name
, GNU_LINKONCE_INFO
));
3977 if (!((sect
->flags
& SEC_ALLOC
) != 0 && abfd
== orig_bfd
)
3981 sz
= sect
->rawsize
? sect
->rawsize
: sect
->size
;
3985 BFD_ASSERT (sect
->alignment_power
== 0);
3986 sect
->vma
= last_dwarf
;
3991 /* Align the new address to the current section
3993 last_vma
= ((last_vma
3994 + ~(-((bfd_vma
) 1 << sect
->alignment_power
)))
3995 & (-((bfd_vma
) 1 << sect
->alignment_power
)));
3996 sect
->vma
= last_vma
;
4001 p
->adj_vma
= sect
->vma
;
4004 if (abfd
== stash
->bfd_ptr
)
4006 abfd
= stash
->bfd_ptr
;
4010 if (orig_bfd
!= stash
->bfd_ptr
)
4011 set_debug_vma (orig_bfd
, stash
->bfd_ptr
);
4016 /* Look up a funcinfo by name using the given info hash table. If found,
4017 also update the locations pointed to by filename_ptr and linenumber_ptr.
4019 This function returns TRUE if a funcinfo that matches the given symbol
4020 and address is found with any error; otherwise it returns FALSE. */
4023 info_hash_lookup_funcinfo (struct info_hash_table
*hash_table
,
4026 const char **filename_ptr
,
4027 unsigned int *linenumber_ptr
)
4029 struct funcinfo
* each_func
;
4030 struct funcinfo
* best_fit
= NULL
;
4031 bfd_vma best_fit_len
= 0;
4032 struct info_list_node
*node
;
4033 struct arange
*arange
;
4034 const char *name
= bfd_asymbol_name (sym
);
4035 asection
*sec
= bfd_get_section (sym
);
4037 for (node
= lookup_info_hash_table (hash_table
, name
);
4041 each_func
= (struct funcinfo
*) node
->info
;
4042 for (arange
= &each_func
->arange
;
4044 arange
= arange
->next
)
4046 if ((!each_func
->sec
|| each_func
->sec
== sec
)
4047 && addr
>= arange
->low
4048 && addr
< arange
->high
4050 || arange
->high
- arange
->low
< best_fit_len
))
4052 best_fit
= each_func
;
4053 best_fit_len
= arange
->high
- arange
->low
;
4060 best_fit
->sec
= sec
;
4061 *filename_ptr
= best_fit
->file
;
4062 *linenumber_ptr
= best_fit
->line
;
4069 /* Look up a varinfo by name using the given info hash table. If found,
4070 also update the locations pointed to by filename_ptr and linenumber_ptr.
4072 This function returns TRUE if a varinfo that matches the given symbol
4073 and address is found with any error; otherwise it returns FALSE. */
4076 info_hash_lookup_varinfo (struct info_hash_table
*hash_table
,
4079 const char **filename_ptr
,
4080 unsigned int *linenumber_ptr
)
4082 const char *name
= bfd_asymbol_name (sym
);
4083 asection
*sec
= bfd_get_section (sym
);
4084 struct varinfo
* each
;
4085 struct info_list_node
*node
;
4087 for (node
= lookup_info_hash_table (hash_table
, name
);
4091 each
= (struct varinfo
*) node
->info
;
4092 if (each
->addr
== addr
4093 && (!each
->sec
|| each
->sec
== sec
))
4096 *filename_ptr
= each
->file
;
4097 *linenumber_ptr
= each
->line
;
4105 /* Update the funcinfo and varinfo info hash tables if they are
4106 not up to date. Returns TRUE if there is no error; otherwise
4107 returns FALSE and disable the info hash tables. */
4110 stash_maybe_update_info_hash_tables (struct dwarf2_debug
*stash
)
4112 struct comp_unit
*each
;
4114 /* Exit if hash tables are up-to-date. */
4115 if (stash
->all_comp_units
== stash
->hash_units_head
)
4118 if (stash
->hash_units_head
)
4119 each
= stash
->hash_units_head
->prev_unit
;
4121 each
= stash
->last_comp_unit
;
4125 if (!comp_unit_hash_info (stash
, each
, stash
->funcinfo_hash_table
,
4126 stash
->varinfo_hash_table
))
4128 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
4131 each
= each
->prev_unit
;
4134 stash
->hash_units_head
= stash
->all_comp_units
;
4138 /* Check consistency of info hash tables. This is for debugging only. */
4140 static void ATTRIBUTE_UNUSED
4141 stash_verify_info_hash_table (struct dwarf2_debug
*stash
)
4143 struct comp_unit
*each_unit
;
4144 struct funcinfo
*each_func
;
4145 struct varinfo
*each_var
;
4146 struct info_list_node
*node
;
4149 for (each_unit
= stash
->all_comp_units
;
4151 each_unit
= each_unit
->next_unit
)
4153 for (each_func
= each_unit
->function_table
;
4155 each_func
= each_func
->prev_func
)
4157 if (!each_func
->name
)
4159 node
= lookup_info_hash_table (stash
->funcinfo_hash_table
,
4163 while (node
&& !found
)
4165 found
= node
->info
== each_func
;
4171 for (each_var
= each_unit
->variable_table
;
4173 each_var
= each_var
->prev_var
)
4175 if (!each_var
->name
|| !each_var
->file
|| each_var
->stack
)
4177 node
= lookup_info_hash_table (stash
->varinfo_hash_table
,
4181 while (node
&& !found
)
4183 found
= node
->info
== each_var
;
4191 /* Check to see if we want to enable the info hash tables, which consume
4192 quite a bit of memory. Currently we only check the number times
4193 bfd_dwarf2_find_line is called. In the future, we may also want to
4194 take the number of symbols into account. */
4197 stash_maybe_enable_info_hash_tables (bfd
*abfd
, struct dwarf2_debug
*stash
)
4199 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_OFF
);
4201 if (stash
->info_hash_count
++ < STASH_INFO_HASH_TRIGGER
)
4204 /* FIXME: Maybe we should check the reduce_memory_overheads
4205 and optimize fields in the bfd_link_info structure ? */
4207 /* Create hash tables. */
4208 stash
->funcinfo_hash_table
= create_info_hash_table (abfd
);
4209 stash
->varinfo_hash_table
= create_info_hash_table (abfd
);
4210 if (!stash
->funcinfo_hash_table
|| !stash
->varinfo_hash_table
)
4212 /* Turn off info hashes if any allocation above fails. */
4213 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
4216 /* We need a forced update so that the info hash tables will
4217 be created even though there is no compilation unit. That
4218 happens if STASH_INFO_HASH_TRIGGER is 0. */
4219 stash_maybe_update_info_hash_tables (stash
);
4220 stash
->info_hash_status
= STASH_INFO_HASH_ON
;
4223 /* Find the file and line associated with a symbol and address using the
4224 info hash tables of a stash. If there is a match, the function returns
4225 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
4226 otherwise it returns FALSE. */
4229 stash_find_line_fast (struct dwarf2_debug
*stash
,
4232 const char **filename_ptr
,
4233 unsigned int *linenumber_ptr
)
4235 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_ON
);
4237 if (sym
->flags
& BSF_FUNCTION
)
4238 return info_hash_lookup_funcinfo (stash
->funcinfo_hash_table
, sym
, addr
,
4239 filename_ptr
, linenumber_ptr
);
4240 return info_hash_lookup_varinfo (stash
->varinfo_hash_table
, sym
, addr
,
4241 filename_ptr
, linenumber_ptr
);
4244 /* Save current section VMAs. */
4247 save_section_vma (const bfd
*abfd
, struct dwarf2_debug
*stash
)
4252 if (abfd
->section_count
== 0)
4254 stash
->sec_vma
= bfd_malloc (sizeof (*stash
->sec_vma
) * abfd
->section_count
);
4255 if (stash
->sec_vma
== NULL
)
4257 for (i
= 0, s
= abfd
->sections
; i
< abfd
->section_count
; i
++, s
= s
->next
)
4259 if (s
->output_section
!= NULL
)
4260 stash
->sec_vma
[i
] = s
->output_section
->vma
+ s
->output_offset
;
4262 stash
->sec_vma
[i
] = s
->vma
;
4267 /* Compare current section VMAs against those at the time the stash
4268 was created. If find_nearest_line is used in linker warnings or
4269 errors early in the link process, the debug info stash will be
4270 invalid for later calls. This is because we relocate debug info
4271 sections, so the stashed section contents depend on symbol values,
4272 which in turn depend on section VMAs. */
4275 section_vma_same (const bfd
*abfd
, const struct dwarf2_debug
*stash
)
4280 for (i
= 0, s
= abfd
->sections
; i
< abfd
->section_count
; i
++, s
= s
->next
)
4284 if (s
->output_section
!= NULL
)
4285 vma
= s
->output_section
->vma
+ s
->output_offset
;
4288 if (vma
!= stash
->sec_vma
[i
])
4294 /* Read debug information from DEBUG_BFD when DEBUG_BFD is specified.
4295 If DEBUG_BFD is not specified, we read debug information from ABFD
4296 or its gnu_debuglink. The results will be stored in PINFO.
4297 The function returns TRUE iff debug information is ready. */
4300 _bfd_dwarf2_slurp_debug_info (bfd
*abfd
, bfd
*debug_bfd
,
4301 const struct dwarf_debug_section
*debug_sections
,
4304 bfd_boolean do_place
)
4306 bfd_size_type amt
= sizeof (struct dwarf2_debug
);
4307 bfd_size_type total_size
;
4309 struct dwarf2_debug
*stash
= (struct dwarf2_debug
*) *pinfo
;
4313 if (stash
->orig_bfd
== abfd
4314 && section_vma_same (abfd
, stash
))
4316 /* Check that we did previously find some debug information
4317 before attempting to make use of it. */
4318 if (stash
->bfd_ptr
!= NULL
)
4320 if (do_place
&& !place_sections (abfd
, stash
))
4327 _bfd_dwarf2_cleanup_debug_info (abfd
, pinfo
);
4328 memset (stash
, 0, amt
);
4332 stash
= (struct dwarf2_debug
*) bfd_zalloc (abfd
, amt
);
4336 stash
->orig_bfd
= abfd
;
4337 stash
->debug_sections
= debug_sections
;
4338 stash
->syms
= symbols
;
4339 if (!save_section_vma (abfd
, stash
))
4344 if (debug_bfd
== NULL
)
4347 msec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
4348 if (msec
== NULL
&& abfd
== debug_bfd
)
4350 char * debug_filename
;
4352 debug_filename
= bfd_follow_build_id_debuglink (abfd
, DEBUGDIR
);
4353 if (debug_filename
== NULL
)
4354 debug_filename
= bfd_follow_gnu_debuglink (abfd
, DEBUGDIR
);
4356 if (debug_filename
== NULL
)
4357 /* No dwarf2 info, and no gnu_debuglink to follow.
4358 Note that at this point the stash has been allocated, but
4359 contains zeros. This lets future calls to this function
4360 fail more quickly. */
4363 /* Set BFD_DECOMPRESS to decompress debug sections. */
4364 if ((debug_bfd
= bfd_openr (debug_filename
, NULL
)) == NULL
4365 || !(debug_bfd
->flags
|= BFD_DECOMPRESS
,
4366 bfd_check_format (debug_bfd
, bfd_object
))
4367 || (msec
= find_debug_info (debug_bfd
,
4368 debug_sections
, NULL
)) == NULL
4369 || !bfd_generic_link_read_symbols (debug_bfd
))
4372 bfd_close (debug_bfd
);
4373 /* FIXME: Should we report our failure to follow the debuglink ? */
4374 free (debug_filename
);
4378 symbols
= bfd_get_outsymbols (debug_bfd
);
4379 stash
->syms
= symbols
;
4380 stash
->close_on_cleanup
= TRUE
;
4382 stash
->bfd_ptr
= debug_bfd
;
4385 && !place_sections (abfd
, stash
))
4388 /* There can be more than one DWARF2 info section in a BFD these
4389 days. First handle the easy case when there's only one. If
4390 there's more than one, try case two: none of the sections is
4391 compressed. In that case, read them all in and produce one
4392 large stash. We do this in two passes - in the first pass we
4393 just accumulate the section sizes, and in the second pass we
4394 read in the section's contents. (The allows us to avoid
4395 reallocing the data as we add sections to the stash.) If
4396 some or all sections are compressed, then do things the slow
4397 way, with a bunch of reallocs. */
4399 if (! find_debug_info (debug_bfd
, debug_sections
, msec
))
4401 /* Case 1: only one info section. */
4402 total_size
= msec
->size
;
4403 if (! read_section (debug_bfd
, &stash
->debug_sections
[debug_info
],
4405 &stash
->info_ptr_memory
, &total_size
))
4410 /* Case 2: multiple sections. */
4411 for (total_size
= 0;
4413 msec
= find_debug_info (debug_bfd
, debug_sections
, msec
))
4414 total_size
+= msec
->size
;
4416 stash
->info_ptr_memory
= (bfd_byte
*) bfd_malloc (total_size
);
4417 if (stash
->info_ptr_memory
== NULL
)
4421 for (msec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
4423 msec
= find_debug_info (debug_bfd
, debug_sections
, msec
))
4431 if (!(bfd_simple_get_relocated_section_contents
4432 (debug_bfd
, msec
, stash
->info_ptr_memory
+ total_size
,
4440 stash
->info_ptr
= stash
->info_ptr_memory
;
4441 stash
->info_ptr_end
= stash
->info_ptr
+ total_size
;
4442 stash
->sec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
4443 stash
->sec_info_ptr
= stash
->info_ptr
;
4447 /* Scan the debug information in PINFO looking for a DW_TAG_subprogram
4448 abbrev with a DW_AT_low_pc attached to it. Then lookup that same
4449 symbol in SYMBOLS and return the difference between the low_pc and
4450 the symbol's address. Returns 0 if no suitable symbol could be found. */
4453 _bfd_dwarf2_find_symbol_bias (asymbol
** symbols
, void ** pinfo
)
4455 struct dwarf2_debug
*stash
;
4456 struct comp_unit
* unit
;
4458 stash
= (struct dwarf2_debug
*) *pinfo
;
4463 for (unit
= stash
->all_comp_units
; unit
; unit
= unit
->next_unit
)
4465 struct funcinfo
* func
;
4467 if (unit
->function_table
== NULL
)
4469 if (unit
->line_table
== NULL
)
4470 unit
->line_table
= decode_line_info (unit
, stash
);
4471 if (unit
->line_table
!= NULL
)
4472 scan_unit_for_symbols (unit
);
4475 for (func
= unit
->function_table
; func
!= NULL
; func
= func
->prev_func
)
4476 if (func
->name
&& func
->arange
.low
)
4480 /* FIXME: Do we need to scan the aranges looking for the lowest pc value ? */
4482 for (psym
= symbols
; * psym
!= NULL
; psym
++)
4484 asymbol
* sym
= * psym
;
4486 if (sym
->flags
& BSF_FUNCTION
4487 && sym
->section
!= NULL
4488 && strcmp (sym
->name
, func
->name
) == 0)
4489 return ((bfd_signed_vma
) func
->arange
.low
) -
4490 ((bfd_signed_vma
) (sym
->value
+ sym
->section
->vma
));
4498 /* Find the source code location of SYMBOL. If SYMBOL is NULL
4499 then find the nearest source code location corresponding to
4500 the address SECTION + OFFSET.
4501 Returns TRUE if the line is found without error and fills in
4502 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
4503 NULL the FUNCTIONNAME_PTR is also filled in.
4504 SYMBOLS contains the symbol table for ABFD.
4505 DEBUG_SECTIONS contains the name of the dwarf debug sections.
4506 ADDR_SIZE is the number of bytes in the initial .debug_info length
4507 field and in the abbreviation offset, or zero to indicate that the
4508 default value should be used. */
4511 _bfd_dwarf2_find_nearest_line (bfd
*abfd
,
4516 const char **filename_ptr
,
4517 const char **functionname_ptr
,
4518 unsigned int *linenumber_ptr
,
4519 unsigned int *discriminator_ptr
,
4520 const struct dwarf_debug_section
*debug_sections
,
4521 unsigned int addr_size
,
4524 /* Read each compilation unit from the section .debug_info, and check
4525 to see if it contains the address we are searching for. If yes,
4526 lookup the address, and return the line number info. If no, go
4527 on to the next compilation unit.
4529 We keep a list of all the previously read compilation units, and
4530 a pointer to the next un-read compilation unit. Check the
4531 previously read units before reading more. */
4532 struct dwarf2_debug
*stash
;
4533 /* What address are we looking for? */
4535 struct comp_unit
* each
;
4536 struct funcinfo
*function
= NULL
;
4537 bfd_boolean found
= FALSE
;
4538 bfd_boolean do_line
;
4540 *filename_ptr
= NULL
;
4541 if (functionname_ptr
!= NULL
)
4542 *functionname_ptr
= NULL
;
4543 *linenumber_ptr
= 0;
4544 if (discriminator_ptr
)
4545 *discriminator_ptr
= 0;
4547 if (! _bfd_dwarf2_slurp_debug_info (abfd
, NULL
, debug_sections
,
4549 (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0))
4552 stash
= (struct dwarf2_debug
*) *pinfo
;
4554 do_line
= symbol
!= NULL
;
4557 BFD_ASSERT (section
== NULL
&& offset
== 0 && functionname_ptr
== NULL
);
4558 section
= bfd_get_section (symbol
);
4559 addr
= symbol
->value
;
4563 BFD_ASSERT (section
!= NULL
&& functionname_ptr
!= NULL
);
4566 /* If we have no SYMBOL but the section we're looking at is not a
4567 code section, then take a look through the list of symbols to see
4568 if we have a symbol at the address we're looking for. If we do
4569 then use this to look up line information. This will allow us to
4570 give file and line results for data symbols. We exclude code
4571 symbols here, if we look up a function symbol and then look up the
4572 line information we'll actually return the line number for the
4573 opening '{' rather than the function definition line. This is
4574 because looking up by symbol uses the line table, in which the
4575 first line for a function is usually the opening '{', while
4576 looking up the function by section + offset uses the
4577 DW_AT_decl_line from the function DW_TAG_subprogram for the line,
4578 which will be the line of the function name. */
4579 if (symbols
!= NULL
&& (section
->flags
& SEC_CODE
) == 0)
4583 for (tmp
= symbols
; (*tmp
) != NULL
; ++tmp
)
4584 if ((*tmp
)->the_bfd
== abfd
4585 && (*tmp
)->section
== section
4586 && (*tmp
)->value
== offset
4587 && ((*tmp
)->flags
& BSF_SECTION_SYM
) == 0)
4591 /* For local symbols, keep going in the hope we find a
4593 if ((symbol
->flags
& BSF_GLOBAL
) != 0)
4599 if (section
->output_section
)
4600 addr
+= section
->output_section
->vma
+ section
->output_offset
;
4602 addr
+= section
->vma
;
4604 /* A null info_ptr indicates that there is no dwarf2 info
4605 (or that an error occured while setting up the stash). */
4606 if (! stash
->info_ptr
)
4609 stash
->inliner_chain
= NULL
;
4611 /* Check the previously read comp. units first. */
4614 /* The info hash tables use quite a bit of memory. We may not want to
4615 always use them. We use some heuristics to decide if and when to
4617 if (stash
->info_hash_status
== STASH_INFO_HASH_OFF
)
4618 stash_maybe_enable_info_hash_tables (abfd
, stash
);
4620 /* Keep info hash table up to date if they are available. Note that we
4621 may disable the hash tables if there is any error duing update. */
4622 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
4623 stash_maybe_update_info_hash_tables (stash
);
4625 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
4627 found
= stash_find_line_fast (stash
, symbol
, addr
, filename_ptr
,
4634 /* Check the previously read comp. units first. */
4635 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
4636 if ((symbol
->flags
& BSF_FUNCTION
) == 0
4637 || each
->arange
.high
== 0
4638 || comp_unit_contains_address (each
, addr
))
4640 found
= comp_unit_find_line (each
, symbol
, addr
, filename_ptr
,
4641 linenumber_ptr
, stash
);
4649 bfd_vma min_range
= (bfd_vma
) -1;
4650 const char * local_filename
= NULL
;
4651 struct funcinfo
*local_function
= NULL
;
4652 unsigned int local_linenumber
= 0;
4653 unsigned int local_discriminator
= 0;
4655 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
4657 bfd_vma range
= (bfd_vma
) -1;
4659 found
= ((each
->arange
.high
== 0
4660 || comp_unit_contains_address (each
, addr
))
4661 && (range
= comp_unit_find_nearest_line (each
, addr
,
4665 & local_discriminator
,
4669 /* PRs 15935 15994: Bogus debug information may have provided us
4670 with an erroneous match. We attempt to counter this by
4671 selecting the match that has the smallest address range
4672 associated with it. (We are assuming that corrupt debug info
4673 will tend to result in extra large address ranges rather than
4674 extra small ranges).
4676 This does mean that we scan through all of the CUs associated
4677 with the bfd each time this function is called. But this does
4678 have the benefit of producing consistent results every time the
4679 function is called. */
4680 if (range
<= min_range
)
4682 if (filename_ptr
&& local_filename
)
4683 * filename_ptr
= local_filename
;
4685 function
= local_function
;
4686 if (discriminator_ptr
&& local_discriminator
)
4687 * discriminator_ptr
= local_discriminator
;
4688 if (local_linenumber
)
4689 * linenumber_ptr
= local_linenumber
;
4695 if (* linenumber_ptr
)
4702 /* The DWARF2 spec says that the initial length field, and the
4703 offset of the abbreviation table, should both be 4-byte values.
4704 However, some compilers do things differently. */
4707 BFD_ASSERT (addr_size
== 4 || addr_size
== 8);
4709 /* Read each remaining comp. units checking each as they are read. */
4710 while (stash
->info_ptr
< stash
->info_ptr_end
)
4713 unsigned int offset_size
= addr_size
;
4714 bfd_byte
*info_ptr_unit
= stash
->info_ptr
;
4716 length
= read_4_bytes (stash
->bfd_ptr
, stash
->info_ptr
, stash
->info_ptr_end
);
4717 /* A 0xffffff length is the DWARF3 way of indicating
4718 we use 64-bit offsets, instead of 32-bit offsets. */
4719 if (length
== 0xffffffff)
4722 length
= read_8_bytes (stash
->bfd_ptr
, stash
->info_ptr
+ 4, stash
->info_ptr_end
);
4723 stash
->info_ptr
+= 12;
4725 /* A zero length is the IRIX way of indicating 64-bit offsets,
4726 mostly because the 64-bit length will generally fit in 32
4727 bits, and the endianness helps. */
4728 else if (length
== 0)
4731 length
= read_4_bytes (stash
->bfd_ptr
, stash
->info_ptr
+ 4, stash
->info_ptr_end
);
4732 stash
->info_ptr
+= 8;
4734 /* In the absence of the hints above, we assume 32-bit DWARF2
4735 offsets even for targets with 64-bit addresses, because:
4736 a) most of the time these targets will not have generated
4737 more than 2Gb of debug info and so will not need 64-bit
4740 b) if they do use 64-bit offsets but they are not using
4741 the size hints that are tested for above then they are
4742 not conforming to the DWARF3 standard anyway. */
4743 else if (addr_size
== 8)
4746 stash
->info_ptr
+= 4;
4749 stash
->info_ptr
+= 4;
4756 if (stash
->info_ptr
+ length
> stash
->info_ptr_end
)
4759 each
= parse_comp_unit (stash
, length
, info_ptr_unit
,
4762 /* The dwarf information is damaged, don't trust it any
4766 new_ptr
= stash
->info_ptr
+ length
;
4767 /* PR 17512: file: 1500698c. */
4768 if (new_ptr
< stash
->info_ptr
)
4770 /* A corrupt length value - do not trust the info any more. */
4775 stash
->info_ptr
= new_ptr
;
4777 if (stash
->all_comp_units
)
4778 stash
->all_comp_units
->prev_unit
= each
;
4780 stash
->last_comp_unit
= each
;
4782 each
->next_unit
= stash
->all_comp_units
;
4783 stash
->all_comp_units
= each
;
4785 /* DW_AT_low_pc and DW_AT_high_pc are optional for
4786 compilation units. If we don't have them (i.e.,
4787 unit->high == 0), we need to consult the line info table
4788 to see if a compilation unit contains the given
4791 found
= (((symbol
->flags
& BSF_FUNCTION
) == 0
4792 || each
->arange
.high
== 0
4793 || comp_unit_contains_address (each
, addr
))
4794 && comp_unit_find_line (each
, symbol
, addr
,
4799 found
= ((each
->arange
.high
== 0
4800 || comp_unit_contains_address (each
, addr
))
4801 && comp_unit_find_nearest_line (each
, addr
,
4808 if ((bfd_vma
) (stash
->info_ptr
- stash
->sec_info_ptr
)
4809 == stash
->sec
->size
)
4811 stash
->sec
= find_debug_info (stash
->bfd_ptr
, debug_sections
,
4813 stash
->sec_info_ptr
= stash
->info_ptr
;
4824 if (!function
->is_linkage
)
4829 fun
= _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
4830 *filename_ptr
? NULL
: filename_ptr
,
4832 sec_vma
= section
->vma
;
4833 if (section
->output_section
!= NULL
)
4834 sec_vma
= section
->output_section
->vma
+ section
->output_offset
;
4836 && fun
->value
+ sec_vma
== function
->arange
.low
)
4837 function
->name
= *functionname_ptr
;
4838 /* Even if we didn't find a linkage name, say that we have
4839 to stop a repeated search of symbols. */
4840 function
->is_linkage
= TRUE
;
4842 *functionname_ptr
= function
->name
;
4844 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
4845 unset_sections (stash
);
4851 _bfd_dwarf2_find_inliner_info (bfd
*abfd ATTRIBUTE_UNUSED
,
4852 const char **filename_ptr
,
4853 const char **functionname_ptr
,
4854 unsigned int *linenumber_ptr
,
4857 struct dwarf2_debug
*stash
;
4859 stash
= (struct dwarf2_debug
*) *pinfo
;
4862 struct funcinfo
*func
= stash
->inliner_chain
;
4864 if (func
&& func
->caller_func
)
4866 *filename_ptr
= func
->caller_file
;
4867 *functionname_ptr
= func
->caller_func
->name
;
4868 *linenumber_ptr
= func
->caller_line
;
4869 stash
->inliner_chain
= func
->caller_func
;
4878 _bfd_dwarf2_cleanup_debug_info (bfd
*abfd
, void **pinfo
)
4880 struct dwarf2_debug
*stash
= (struct dwarf2_debug
*) *pinfo
;
4881 struct comp_unit
*each
;
4883 if (abfd
== NULL
|| stash
== NULL
)
4886 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
4888 struct abbrev_info
**abbrevs
= each
->abbrevs
;
4889 struct funcinfo
*function_table
= each
->function_table
;
4890 struct varinfo
*variable_table
= each
->variable_table
;
4893 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
4895 struct abbrev_info
*abbrev
= abbrevs
[i
];
4899 free (abbrev
->attrs
);
4900 abbrev
= abbrev
->next
;
4904 if (each
->line_table
)
4906 free (each
->line_table
->dirs
);
4907 free (each
->line_table
->files
);
4910 while (function_table
)
4912 if (function_table
->file
)
4914 free (function_table
->file
);
4915 function_table
->file
= NULL
;
4918 if (function_table
->caller_file
)
4920 free (function_table
->caller_file
);
4921 function_table
->caller_file
= NULL
;
4923 function_table
= function_table
->prev_func
;
4926 if (each
->lookup_funcinfo_table
)
4928 free (each
->lookup_funcinfo_table
);
4929 each
->lookup_funcinfo_table
= NULL
;
4932 while (variable_table
)
4934 if (variable_table
->file
)
4936 free (variable_table
->file
);
4937 variable_table
->file
= NULL
;
4940 variable_table
= variable_table
->prev_var
;
4944 if (stash
->funcinfo_hash_table
)
4945 bfd_hash_table_free (&stash
->funcinfo_hash_table
->base
);
4946 if (stash
->varinfo_hash_table
)
4947 bfd_hash_table_free (&stash
->varinfo_hash_table
->base
);
4948 if (stash
->dwarf_abbrev_buffer
)
4949 free (stash
->dwarf_abbrev_buffer
);
4950 if (stash
->dwarf_line_buffer
)
4951 free (stash
->dwarf_line_buffer
);
4952 if (stash
->dwarf_str_buffer
)
4953 free (stash
->dwarf_str_buffer
);
4954 if (stash
->dwarf_line_str_buffer
)
4955 free (stash
->dwarf_line_str_buffer
);
4956 if (stash
->dwarf_ranges_buffer
)
4957 free (stash
->dwarf_ranges_buffer
);
4958 if (stash
->info_ptr_memory
)
4959 free (stash
->info_ptr_memory
);
4960 if (stash
->close_on_cleanup
)
4961 bfd_close (stash
->bfd_ptr
);
4962 if (stash
->alt_dwarf_str_buffer
)
4963 free (stash
->alt_dwarf_str_buffer
);
4964 if (stash
->alt_dwarf_info_buffer
)
4965 free (stash
->alt_dwarf_info_buffer
);
4967 free (stash
->sec_vma
);
4968 if (stash
->adjusted_sections
)
4969 free (stash
->adjusted_sections
);
4970 if (stash
->alt_bfd_ptr
)
4971 bfd_close (stash
->alt_bfd_ptr
);
4974 /* Find the function to a particular section and offset,
4975 for error reporting. */
4978 _bfd_elf_find_function (bfd
*abfd
,
4982 const char **filename_ptr
,
4983 const char **functionname_ptr
)
4985 struct elf_find_function_cache
4987 asection
*last_section
;
4989 const char *filename
;
4990 bfd_size_type func_size
;
4993 if (symbols
== NULL
)
4996 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
4999 cache
= elf_tdata (abfd
)->elf_find_function_cache
;
5002 cache
= bfd_zalloc (abfd
, sizeof (*cache
));
5003 elf_tdata (abfd
)->elf_find_function_cache
= cache
;
5007 if (cache
->last_section
!= section
5008 || cache
->func
== NULL
5009 || offset
< cache
->func
->value
5010 || offset
>= cache
->func
->value
+ cache
->func_size
)
5015 /* ??? Given multiple file symbols, it is impossible to reliably
5016 choose the right file name for global symbols. File symbols are
5017 local symbols, and thus all file symbols must sort before any
5018 global symbols. The ELF spec may be interpreted to say that a
5019 file symbol must sort before other local symbols, but currently
5020 ld -r doesn't do this. So, for ld -r output, it is possible to
5021 make a better choice of file name for local symbols by ignoring
5022 file symbols appearing after a given local symbol. */
5023 enum { nothing_seen
, symbol_seen
, file_after_symbol_seen
} state
;
5024 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5028 state
= nothing_seen
;
5029 cache
->filename
= NULL
;
5031 cache
->func_size
= 0;
5032 cache
->last_section
= section
;
5034 for (p
= symbols
; *p
!= NULL
; p
++)
5040 if ((sym
->flags
& BSF_FILE
) != 0)
5043 if (state
== symbol_seen
)
5044 state
= file_after_symbol_seen
;
5048 size
= bed
->maybe_function_sym (sym
, section
, &code_off
);
5050 && code_off
<= offset
5051 && (code_off
> low_func
5052 || (code_off
== low_func
5053 && size
> cache
->func_size
)))
5056 cache
->func_size
= size
;
5057 cache
->filename
= NULL
;
5058 low_func
= code_off
;
5060 && ((sym
->flags
& BSF_LOCAL
) != 0
5061 || state
!= file_after_symbol_seen
))
5062 cache
->filename
= bfd_asymbol_name (file
);
5064 if (state
== nothing_seen
)
5065 state
= symbol_seen
;
5069 if (cache
->func
== NULL
)
5073 *filename_ptr
= cache
->filename
;
5074 if (functionname_ptr
)
5075 *functionname_ptr
= bfd_asymbol_name (cache
->func
);