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 (%llu)"
573 " greater than or equal to %s size (%Lu)."),
574 (long long) offset
, section_name
, *section_size
);
575 bfd_set_error (bfd_error_bad_value
);
582 /* Read dwarf information from a buffer. */
585 read_1_byte (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_byte
*buf
, bfd_byte
*end
)
589 return bfd_get_8 (abfd
, buf
);
593 read_1_signed_byte (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_byte
*buf
, bfd_byte
*end
)
597 return bfd_get_signed_8 (abfd
, buf
);
601 read_2_bytes (bfd
*abfd
, bfd_byte
*buf
, bfd_byte
*end
)
605 return bfd_get_16 (abfd
, buf
);
609 read_4_bytes (bfd
*abfd
, bfd_byte
*buf
, bfd_byte
*end
)
613 return bfd_get_32 (abfd
, buf
);
617 read_8_bytes (bfd
*abfd
, bfd_byte
*buf
, bfd_byte
*end
)
621 return bfd_get_64 (abfd
, buf
);
625 read_n_bytes (bfd
*abfd ATTRIBUTE_UNUSED
,
628 unsigned int size ATTRIBUTE_UNUSED
)
630 if (buf
+ size
> end
)
635 /* Scans a NUL terminated string starting at BUF, returning a pointer to it.
636 Returns the number of characters in the string, *including* the NUL byte,
637 in BYTES_READ_PTR. This value is set even if the function fails. Bytes
638 at or beyond BUF_END will not be read. Returns NULL if there was a
639 problem, or if the string is empty. */
642 read_string (bfd
* abfd ATTRIBUTE_UNUSED
,
645 unsigned int * bytes_read_ptr
)
651 * bytes_read_ptr
= 0;
657 * bytes_read_ptr
= 1;
661 while (buf
< buf_end
)
664 * bytes_read_ptr
= buf
- str
;
668 * bytes_read_ptr
= buf
- str
;
672 /* Reads an offset from BUF and then locates the string at this offset
673 inside the debug string section. Returns a pointer to the string.
674 Returns the number of bytes read from BUF, *not* the length of the string,
675 in BYTES_READ_PTR. This value is set even if the function fails. Bytes
676 at or beyond BUF_END will not be read from BUF. Returns NULL if there was
677 a problem, or if the string is empty. Does not check for NUL termination
681 read_indirect_string (struct comp_unit
* unit
,
684 unsigned int * bytes_read_ptr
)
687 struct dwarf2_debug
*stash
= unit
->stash
;
690 if (buf
+ unit
->offset_size
> buf_end
)
692 * bytes_read_ptr
= 0;
696 if (unit
->offset_size
== 4)
697 offset
= read_4_bytes (unit
->abfd
, buf
, buf_end
);
699 offset
= read_8_bytes (unit
->abfd
, buf
, buf_end
);
701 *bytes_read_ptr
= unit
->offset_size
;
703 if (! read_section (unit
->abfd
, &stash
->debug_sections
[debug_str
],
705 &stash
->dwarf_str_buffer
, &stash
->dwarf_str_size
))
708 if (offset
>= stash
->dwarf_str_size
)
710 str
= (char *) stash
->dwarf_str_buffer
+ offset
;
716 /* Like read_indirect_string but from .debug_line_str section. */
719 read_indirect_line_string (struct comp_unit
* unit
,
722 unsigned int * bytes_read_ptr
)
725 struct dwarf2_debug
*stash
= unit
->stash
;
728 if (buf
+ unit
->offset_size
> buf_end
)
730 * bytes_read_ptr
= 0;
734 if (unit
->offset_size
== 4)
735 offset
= read_4_bytes (unit
->abfd
, buf
, buf_end
);
737 offset
= read_8_bytes (unit
->abfd
, buf
, buf_end
);
739 *bytes_read_ptr
= unit
->offset_size
;
741 if (! read_section (unit
->abfd
, &stash
->debug_sections
[debug_line_str
],
743 &stash
->dwarf_line_str_buffer
,
744 &stash
->dwarf_line_str_size
))
747 if (offset
>= stash
->dwarf_line_str_size
)
749 str
= (char *) stash
->dwarf_line_str_buffer
+ offset
;
755 /* Like read_indirect_string but uses a .debug_str located in
756 an alternate file pointed to by the .gnu_debugaltlink section.
757 Used to impement DW_FORM_GNU_strp_alt. */
760 read_alt_indirect_string (struct comp_unit
* unit
,
763 unsigned int * bytes_read_ptr
)
766 struct dwarf2_debug
*stash
= unit
->stash
;
769 if (buf
+ unit
->offset_size
> buf_end
)
771 * bytes_read_ptr
= 0;
775 if (unit
->offset_size
== 4)
776 offset
= read_4_bytes (unit
->abfd
, buf
, buf_end
);
778 offset
= read_8_bytes (unit
->abfd
, buf
, buf_end
);
780 *bytes_read_ptr
= unit
->offset_size
;
782 if (stash
->alt_bfd_ptr
== NULL
)
785 char * debug_filename
= bfd_follow_gnu_debugaltlink (unit
->abfd
, DEBUGDIR
);
787 if (debug_filename
== NULL
)
790 if ((debug_bfd
= bfd_openr (debug_filename
, NULL
)) == NULL
791 || ! bfd_check_format (debug_bfd
, bfd_object
))
794 bfd_close (debug_bfd
);
796 /* FIXME: Should we report our failure to follow the debuglink ? */
797 free (debug_filename
);
800 stash
->alt_bfd_ptr
= debug_bfd
;
803 if (! read_section (unit
->stash
->alt_bfd_ptr
,
804 stash
->debug_sections
+ debug_str_alt
,
805 NULL
, /* FIXME: Do we need to load alternate symbols ? */
807 &stash
->alt_dwarf_str_buffer
,
808 &stash
->alt_dwarf_str_size
))
811 if (offset
>= stash
->alt_dwarf_str_size
)
813 str
= (char *) stash
->alt_dwarf_str_buffer
+ offset
;
820 /* Resolve an alternate reference from UNIT at OFFSET.
821 Returns a pointer into the loaded alternate CU upon success
822 or NULL upon failure. */
825 read_alt_indirect_ref (struct comp_unit
* unit
,
828 struct dwarf2_debug
*stash
= unit
->stash
;
830 if (stash
->alt_bfd_ptr
== NULL
)
833 char * debug_filename
= bfd_follow_gnu_debugaltlink (unit
->abfd
, DEBUGDIR
);
835 if (debug_filename
== NULL
)
838 if ((debug_bfd
= bfd_openr (debug_filename
, NULL
)) == NULL
839 || ! bfd_check_format (debug_bfd
, bfd_object
))
842 bfd_close (debug_bfd
);
844 /* FIXME: Should we report our failure to follow the debuglink ? */
845 free (debug_filename
);
848 stash
->alt_bfd_ptr
= debug_bfd
;
851 if (! read_section (unit
->stash
->alt_bfd_ptr
,
852 stash
->debug_sections
+ debug_info_alt
,
853 NULL
, /* FIXME: Do we need to load alternate symbols ? */
855 &stash
->alt_dwarf_info_buffer
,
856 &stash
->alt_dwarf_info_size
))
859 if (offset
>= stash
->alt_dwarf_info_size
)
861 return stash
->alt_dwarf_info_buffer
+ offset
;
865 read_address (struct comp_unit
*unit
, bfd_byte
*buf
, bfd_byte
* buf_end
)
869 if (bfd_get_flavour (unit
->abfd
) == bfd_target_elf_flavour
)
870 signed_vma
= get_elf_backend_data (unit
->abfd
)->sign_extend_vma
;
872 if (buf
+ unit
->addr_size
> buf_end
)
877 switch (unit
->addr_size
)
880 return bfd_get_signed_64 (unit
->abfd
, buf
);
882 return bfd_get_signed_32 (unit
->abfd
, buf
);
884 return bfd_get_signed_16 (unit
->abfd
, buf
);
891 switch (unit
->addr_size
)
894 return bfd_get_64 (unit
->abfd
, buf
);
896 return bfd_get_32 (unit
->abfd
, buf
);
898 return bfd_get_16 (unit
->abfd
, buf
);
905 /* Lookup an abbrev_info structure in the abbrev hash table. */
907 static struct abbrev_info
*
908 lookup_abbrev (unsigned int number
, struct abbrev_info
**abbrevs
)
910 unsigned int hash_number
;
911 struct abbrev_info
*abbrev
;
913 hash_number
= number
% ABBREV_HASH_SIZE
;
914 abbrev
= abbrevs
[hash_number
];
918 if (abbrev
->number
== number
)
921 abbrev
= abbrev
->next
;
927 /* In DWARF version 2, the description of the debugging information is
928 stored in a separate .debug_abbrev section. Before we read any
929 dies from a section we read in all abbreviations and install them
932 static struct abbrev_info
**
933 read_abbrevs (bfd
*abfd
, bfd_uint64_t offset
, struct dwarf2_debug
*stash
)
935 struct abbrev_info
**abbrevs
;
936 bfd_byte
*abbrev_ptr
;
937 bfd_byte
*abbrev_end
;
938 struct abbrev_info
*cur_abbrev
;
939 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
940 unsigned int abbrev_form
, hash_number
;
943 if (! read_section (abfd
, &stash
->debug_sections
[debug_abbrev
],
945 &stash
->dwarf_abbrev_buffer
, &stash
->dwarf_abbrev_size
))
948 if (offset
>= stash
->dwarf_abbrev_size
)
951 amt
= sizeof (struct abbrev_info
*) * ABBREV_HASH_SIZE
;
952 abbrevs
= (struct abbrev_info
**) bfd_zalloc (abfd
, amt
);
956 abbrev_ptr
= stash
->dwarf_abbrev_buffer
+ offset
;
957 abbrev_end
= stash
->dwarf_abbrev_buffer
+ stash
->dwarf_abbrev_size
;
958 abbrev_number
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
, &bytes_read
,
960 abbrev_ptr
+= bytes_read
;
962 /* Loop until we reach an abbrev number of 0. */
963 while (abbrev_number
)
965 amt
= sizeof (struct abbrev_info
);
966 cur_abbrev
= (struct abbrev_info
*) bfd_zalloc (abfd
, amt
);
967 if (cur_abbrev
== NULL
)
970 /* Read in abbrev header. */
971 cur_abbrev
->number
= abbrev_number
;
972 cur_abbrev
->tag
= (enum dwarf_tag
)
973 _bfd_safe_read_leb128 (abfd
, abbrev_ptr
, &bytes_read
,
975 abbrev_ptr
+= bytes_read
;
976 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
, abbrev_end
);
979 /* Now read in declarations. */
982 /* Initialize it just to avoid a GCC false warning. */
983 bfd_vma implicit_const
= -1;
985 abbrev_name
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
, &bytes_read
,
987 abbrev_ptr
+= bytes_read
;
988 abbrev_form
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
, &bytes_read
,
990 abbrev_ptr
+= bytes_read
;
991 if (abbrev_form
== DW_FORM_implicit_const
)
993 implicit_const
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
,
996 abbrev_ptr
+= bytes_read
;
999 if (abbrev_name
== 0)
1002 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
1004 struct attr_abbrev
*tmp
;
1006 amt
= cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
;
1007 amt
*= sizeof (struct attr_abbrev
);
1008 tmp
= (struct attr_abbrev
*) bfd_realloc (cur_abbrev
->attrs
, amt
);
1013 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
1015 struct abbrev_info
*abbrev
= abbrevs
[i
];
1019 free (abbrev
->attrs
);
1020 abbrev
= abbrev
->next
;
1025 cur_abbrev
->attrs
= tmp
;
1028 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
1029 = (enum dwarf_attribute
) abbrev_name
;
1030 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].form
1031 = (enum dwarf_form
) abbrev_form
;
1032 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].implicit_const
1034 ++cur_abbrev
->num_attrs
;
1037 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
1038 cur_abbrev
->next
= abbrevs
[hash_number
];
1039 abbrevs
[hash_number
] = cur_abbrev
;
1041 /* Get next abbreviation.
1042 Under Irix6 the abbreviations for a compilation unit are not
1043 always properly terminated with an abbrev number of 0.
1044 Exit loop if we encounter an abbreviation which we have
1045 already read (which means we are about to read the abbreviations
1046 for the next compile unit) or if the end of the abbreviation
1047 table is reached. */
1048 if ((unsigned int) (abbrev_ptr
- stash
->dwarf_abbrev_buffer
)
1049 >= stash
->dwarf_abbrev_size
)
1051 abbrev_number
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
,
1052 &bytes_read
, FALSE
, abbrev_end
);
1053 abbrev_ptr
+= bytes_read
;
1054 if (lookup_abbrev (abbrev_number
, abbrevs
) != NULL
)
1061 /* Returns true if the form is one which has a string value. */
1063 static inline bfd_boolean
1064 is_str_attr (enum dwarf_form form
)
1066 return (form
== DW_FORM_string
|| form
== DW_FORM_strp
1067 || form
== DW_FORM_line_strp
|| form
== DW_FORM_GNU_strp_alt
);
1070 /* Read and fill in the value of attribute ATTR as described by FORM.
1071 Read data starting from INFO_PTR, but never at or beyond INFO_PTR_END.
1072 Returns an updated INFO_PTR taking into account the amount of data read. */
1075 read_attribute_value (struct attribute
* attr
,
1077 bfd_vma implicit_const
,
1078 struct comp_unit
* unit
,
1079 bfd_byte
* info_ptr
,
1080 bfd_byte
* info_ptr_end
)
1082 bfd
*abfd
= unit
->abfd
;
1083 unsigned int bytes_read
;
1084 struct dwarf_block
*blk
;
1087 if (info_ptr
>= info_ptr_end
&& form
!= DW_FORM_flag_present
)
1089 _bfd_error_handler (_("Dwarf Error: Info pointer extends beyond end of attributes"));
1090 bfd_set_error (bfd_error_bad_value
);
1094 attr
->form
= (enum dwarf_form
) form
;
1098 case DW_FORM_ref_addr
:
1099 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
1101 if (unit
->version
== 3 || unit
->version
== 4)
1103 if (unit
->offset_size
== 4)
1104 attr
->u
.val
= read_4_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1106 attr
->u
.val
= read_8_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1107 info_ptr
+= unit
->offset_size
;
1112 attr
->u
.val
= read_address (unit
, info_ptr
, info_ptr_end
);
1113 info_ptr
+= unit
->addr_size
;
1115 case DW_FORM_GNU_ref_alt
:
1116 case DW_FORM_sec_offset
:
1117 if (unit
->offset_size
== 4)
1118 attr
->u
.val
= read_4_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1120 attr
->u
.val
= read_8_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1121 info_ptr
+= unit
->offset_size
;
1123 case DW_FORM_block2
:
1124 amt
= sizeof (struct dwarf_block
);
1125 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1128 blk
->size
= read_2_bytes (abfd
, info_ptr
, info_ptr_end
);
1130 blk
->data
= read_n_bytes (abfd
, info_ptr
, info_ptr_end
, blk
->size
);
1131 info_ptr
+= blk
->size
;
1134 case DW_FORM_block4
:
1135 amt
= sizeof (struct dwarf_block
);
1136 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1139 blk
->size
= read_4_bytes (abfd
, info_ptr
, info_ptr_end
);
1141 blk
->data
= read_n_bytes (abfd
, info_ptr
, info_ptr_end
, blk
->size
);
1142 info_ptr
+= blk
->size
;
1146 attr
->u
.val
= read_2_bytes (abfd
, info_ptr
, info_ptr_end
);
1150 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
, info_ptr_end
);
1154 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
, info_ptr_end
);
1157 case DW_FORM_string
:
1158 attr
->u
.str
= read_string (abfd
, info_ptr
, info_ptr_end
, &bytes_read
);
1159 info_ptr
+= bytes_read
;
1162 attr
->u
.str
= read_indirect_string (unit
, info_ptr
, info_ptr_end
, &bytes_read
);
1163 info_ptr
+= bytes_read
;
1165 case DW_FORM_line_strp
:
1166 attr
->u
.str
= read_indirect_line_string (unit
, info_ptr
, info_ptr_end
, &bytes_read
);
1167 info_ptr
+= bytes_read
;
1169 case DW_FORM_GNU_strp_alt
:
1170 attr
->u
.str
= read_alt_indirect_string (unit
, info_ptr
, info_ptr_end
, &bytes_read
);
1171 info_ptr
+= bytes_read
;
1173 case DW_FORM_exprloc
:
1175 amt
= sizeof (struct dwarf_block
);
1176 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1179 blk
->size
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1180 FALSE
, info_ptr_end
);
1181 info_ptr
+= bytes_read
;
1182 blk
->data
= read_n_bytes (abfd
, info_ptr
, info_ptr_end
, blk
->size
);
1183 info_ptr
+= blk
->size
;
1186 case DW_FORM_block1
:
1187 amt
= sizeof (struct dwarf_block
);
1188 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1191 blk
->size
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1193 blk
->data
= read_n_bytes (abfd
, info_ptr
, info_ptr_end
, blk
->size
);
1194 info_ptr
+= blk
->size
;
1198 attr
->u
.val
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1202 attr
->u
.val
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1205 case DW_FORM_flag_present
:
1209 attr
->u
.sval
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1210 TRUE
, info_ptr_end
);
1211 info_ptr
+= bytes_read
;
1214 attr
->u
.val
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1215 FALSE
, info_ptr_end
);
1216 info_ptr
+= bytes_read
;
1219 attr
->u
.val
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1223 attr
->u
.val
= read_2_bytes (abfd
, info_ptr
, info_ptr_end
);
1227 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
, info_ptr_end
);
1231 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
, info_ptr_end
);
1234 case DW_FORM_ref_sig8
:
1235 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
, info_ptr_end
);
1238 case DW_FORM_ref_udata
:
1239 attr
->u
.val
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1240 FALSE
, info_ptr_end
);
1241 info_ptr
+= bytes_read
;
1243 case DW_FORM_indirect
:
1244 form
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1245 FALSE
, info_ptr_end
);
1246 info_ptr
+= bytes_read
;
1247 if (form
== DW_FORM_implicit_const
)
1249 implicit_const
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1250 TRUE
, info_ptr_end
);
1251 info_ptr
+= bytes_read
;
1253 info_ptr
= read_attribute_value (attr
, form
, implicit_const
, unit
,
1254 info_ptr
, info_ptr_end
);
1256 case DW_FORM_implicit_const
:
1257 attr
->form
= DW_FORM_sdata
;
1258 attr
->u
.sval
= implicit_const
;
1261 _bfd_error_handler (_("Dwarf Error: Invalid or unhandled FORM value: %#x."),
1263 bfd_set_error (bfd_error_bad_value
);
1269 /* Read an attribute described by an abbreviated attribute. */
1272 read_attribute (struct attribute
* attr
,
1273 struct attr_abbrev
* abbrev
,
1274 struct comp_unit
* unit
,
1275 bfd_byte
* info_ptr
,
1276 bfd_byte
* info_ptr_end
)
1278 attr
->name
= abbrev
->name
;
1279 info_ptr
= read_attribute_value (attr
, abbrev
->form
, abbrev
->implicit_const
,
1280 unit
, info_ptr
, info_ptr_end
);
1284 /* Return whether DW_AT_name will return the same as DW_AT_linkage_name
1288 non_mangled (int lang
)
1298 case DW_LANG_Cobol74
:
1299 case DW_LANG_Cobol85
:
1300 case DW_LANG_Fortran77
:
1301 case DW_LANG_Pascal83
:
1311 /* Source line information table routines. */
1313 #define FILE_ALLOC_CHUNK 5
1314 #define DIR_ALLOC_CHUNK 5
1318 struct line_info
* prev_line
;
1322 unsigned int column
;
1323 unsigned int discriminator
;
1324 unsigned char op_index
;
1325 unsigned char end_sequence
; /* End of (sequential) code sequence. */
1336 struct line_sequence
1339 struct line_sequence
* prev_sequence
;
1340 struct line_info
* last_line
; /* Largest VMA. */
1341 struct line_info
** line_info_lookup
;
1342 bfd_size_type num_lines
;
1345 struct line_info_table
1348 unsigned int num_files
;
1349 unsigned int num_dirs
;
1350 unsigned int num_sequences
;
1353 struct fileinfo
* files
;
1354 struct line_sequence
* sequences
;
1355 struct line_info
* lcl_head
; /* Local head; used in 'add_line_info'. */
1358 /* Remember some information about each function. If the function is
1359 inlined (DW_TAG_inlined_subroutine) it may have two additional
1360 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
1361 source code location where this function was inlined. */
1365 /* Pointer to previous function in list of all functions. */
1366 struct funcinfo
* prev_func
;
1367 /* Pointer to function one scope higher. */
1368 struct funcinfo
* caller_func
;
1369 /* Source location file name where caller_func inlines this func. */
1371 /* Source location file name. */
1373 /* Source location line number where caller_func inlines this func. */
1375 /* Source location line number. */
1378 bfd_boolean is_linkage
;
1380 struct arange arange
;
1381 /* Where the symbol is defined. */
1385 struct lookup_funcinfo
1387 /* Function information corresponding to this lookup table entry. */
1388 struct funcinfo
* funcinfo
;
1390 /* The lowest address for this specific function. */
1393 /* The highest address of this function before the lookup table is sorted.
1394 The highest address of all prior functions after the lookup table is
1395 sorted, which is used for binary search. */
1401 /* Pointer to previous variable in list of all variables */
1402 struct varinfo
*prev_var
;
1403 /* Source location file name */
1405 /* Source location line number */
1410 /* Where the symbol is defined */
1412 /* Is this a stack variable? */
1413 unsigned int stack
: 1;
1416 /* Return TRUE if NEW_LINE should sort after LINE. */
1418 static inline bfd_boolean
1419 new_line_sorts_after (struct line_info
*new_line
, struct line_info
*line
)
1421 return (new_line
->address
> line
->address
1422 || (new_line
->address
== line
->address
1423 && new_line
->op_index
> line
->op_index
));
1427 /* Adds a new entry to the line_info list in the line_info_table, ensuring
1428 that the list is sorted. Note that the line_info list is sorted from
1429 highest to lowest VMA (with possible duplicates); that is,
1430 line_info->prev_line always accesses an equal or smaller VMA. */
1433 add_line_info (struct line_info_table
*table
,
1435 unsigned char op_index
,
1438 unsigned int column
,
1439 unsigned int discriminator
,
1442 bfd_size_type amt
= sizeof (struct line_info
);
1443 struct line_sequence
* seq
= table
->sequences
;
1444 struct line_info
* info
= (struct line_info
*) bfd_alloc (table
->abfd
, amt
);
1449 /* Set member data of 'info'. */
1450 info
->prev_line
= NULL
;
1451 info
->address
= address
;
1452 info
->op_index
= op_index
;
1454 info
->column
= column
;
1455 info
->discriminator
= discriminator
;
1456 info
->end_sequence
= end_sequence
;
1458 if (filename
&& filename
[0])
1460 info
->filename
= (char *) bfd_alloc (table
->abfd
, strlen (filename
) + 1);
1461 if (info
->filename
== NULL
)
1463 strcpy (info
->filename
, filename
);
1466 info
->filename
= NULL
;
1468 /* Find the correct location for 'info'. Normally we will receive
1469 new line_info data 1) in order and 2) with increasing VMAs.
1470 However some compilers break the rules (cf. decode_line_info) and
1471 so we include some heuristics for quickly finding the correct
1472 location for 'info'. In particular, these heuristics optimize for
1473 the common case in which the VMA sequence that we receive is a
1474 list of locally sorted VMAs such as
1475 p...z a...j (where a < j < p < z)
1477 Note: table->lcl_head is used to head an *actual* or *possible*
1478 sub-sequence within the list (such as a...j) that is not directly
1479 headed by table->last_line
1481 Note: we may receive duplicate entries from 'decode_line_info'. */
1484 && seq
->last_line
->address
== address
1485 && seq
->last_line
->op_index
== op_index
1486 && seq
->last_line
->end_sequence
== end_sequence
)
1488 /* We only keep the last entry with the same address and end
1489 sequence. See PR ld/4986. */
1490 if (table
->lcl_head
== seq
->last_line
)
1491 table
->lcl_head
= info
;
1492 info
->prev_line
= seq
->last_line
->prev_line
;
1493 seq
->last_line
= info
;
1495 else if (!seq
|| seq
->last_line
->end_sequence
)
1497 /* Start a new line sequence. */
1498 amt
= sizeof (struct line_sequence
);
1499 seq
= (struct line_sequence
*) bfd_malloc (amt
);
1502 seq
->low_pc
= address
;
1503 seq
->prev_sequence
= table
->sequences
;
1504 seq
->last_line
= info
;
1505 table
->lcl_head
= info
;
1506 table
->sequences
= seq
;
1507 table
->num_sequences
++;
1509 else if (info
->end_sequence
1510 || new_line_sorts_after (info
, seq
->last_line
))
1512 /* Normal case: add 'info' to the beginning of the current sequence. */
1513 info
->prev_line
= seq
->last_line
;
1514 seq
->last_line
= info
;
1516 /* lcl_head: initialize to head a *possible* sequence at the end. */
1517 if (!table
->lcl_head
)
1518 table
->lcl_head
= info
;
1520 else if (!new_line_sorts_after (info
, table
->lcl_head
)
1521 && (!table
->lcl_head
->prev_line
1522 || new_line_sorts_after (info
, table
->lcl_head
->prev_line
)))
1524 /* Abnormal but easy: lcl_head is the head of 'info'. */
1525 info
->prev_line
= table
->lcl_head
->prev_line
;
1526 table
->lcl_head
->prev_line
= info
;
1530 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head'
1531 are valid heads for 'info'. Reset 'lcl_head'. */
1532 struct line_info
* li2
= seq
->last_line
; /* Always non-NULL. */
1533 struct line_info
* li1
= li2
->prev_line
;
1537 if (!new_line_sorts_after (info
, li2
)
1538 && new_line_sorts_after (info
, li1
))
1541 li2
= li1
; /* always non-NULL */
1542 li1
= li1
->prev_line
;
1544 table
->lcl_head
= li2
;
1545 info
->prev_line
= table
->lcl_head
->prev_line
;
1546 table
->lcl_head
->prev_line
= info
;
1547 if (address
< seq
->low_pc
)
1548 seq
->low_pc
= address
;
1553 /* Extract a fully qualified filename from a line info table.
1554 The returned string has been malloc'ed and it is the caller's
1555 responsibility to free it. */
1558 concat_filename (struct line_info_table
*table
, unsigned int file
)
1562 if (file
- 1 >= table
->num_files
)
1564 /* FILE == 0 means unknown. */
1567 (_("Dwarf Error: mangled line number section (bad file number)."));
1568 return strdup ("<unknown>");
1571 filename
= table
->files
[file
- 1].name
;
1572 if (filename
== NULL
)
1573 return strdup ("<unknown>");
1575 if (!IS_ABSOLUTE_PATH (filename
))
1577 char *dir_name
= NULL
;
1578 char *subdir_name
= NULL
;
1582 if (table
->files
[file
- 1].dir
1583 /* PR 17512: file: 0317e960. */
1584 && table
->files
[file
- 1].dir
<= table
->num_dirs
1585 /* PR 17512: file: 7f3d2e4b. */
1586 && table
->dirs
!= NULL
)
1587 subdir_name
= table
->dirs
[table
->files
[file
- 1].dir
- 1];
1589 if (!subdir_name
|| !IS_ABSOLUTE_PATH (subdir_name
))
1590 dir_name
= table
->comp_dir
;
1594 dir_name
= subdir_name
;
1599 return strdup (filename
);
1601 len
= strlen (dir_name
) + strlen (filename
) + 2;
1605 len
+= strlen (subdir_name
) + 1;
1606 name
= (char *) bfd_malloc (len
);
1608 sprintf (name
, "%s/%s/%s", dir_name
, subdir_name
, filename
);
1612 name
= (char *) bfd_malloc (len
);
1614 sprintf (name
, "%s/%s", dir_name
, filename
);
1620 return strdup (filename
);
1624 arange_add (const struct comp_unit
*unit
, struct arange
*first_arange
,
1625 bfd_vma low_pc
, bfd_vma high_pc
)
1627 struct arange
*arange
;
1629 /* Ignore empty ranges. */
1630 if (low_pc
== high_pc
)
1633 /* If the first arange is empty, use it. */
1634 if (first_arange
->high
== 0)
1636 first_arange
->low
= low_pc
;
1637 first_arange
->high
= high_pc
;
1641 /* Next see if we can cheaply extend an existing range. */
1642 arange
= first_arange
;
1645 if (low_pc
== arange
->high
)
1647 arange
->high
= high_pc
;
1650 if (high_pc
== arange
->low
)
1652 arange
->low
= low_pc
;
1655 arange
= arange
->next
;
1659 /* Need to allocate a new arange and insert it into the arange list.
1660 Order isn't significant, so just insert after the first arange. */
1661 arange
= (struct arange
*) bfd_alloc (unit
->abfd
, sizeof (*arange
));
1664 arange
->low
= low_pc
;
1665 arange
->high
= high_pc
;
1666 arange
->next
= first_arange
->next
;
1667 first_arange
->next
= arange
;
1671 /* Compare function for line sequences. */
1674 compare_sequences (const void* a
, const void* b
)
1676 const struct line_sequence
* seq1
= a
;
1677 const struct line_sequence
* seq2
= b
;
1679 /* Sort by low_pc as the primary key. */
1680 if (seq1
->low_pc
< seq2
->low_pc
)
1682 if (seq1
->low_pc
> seq2
->low_pc
)
1685 /* If low_pc values are equal, sort in reverse order of
1686 high_pc, so that the largest region comes first. */
1687 if (seq1
->last_line
->address
< seq2
->last_line
->address
)
1689 if (seq1
->last_line
->address
> seq2
->last_line
->address
)
1692 if (seq1
->last_line
->op_index
< seq2
->last_line
->op_index
)
1694 if (seq1
->last_line
->op_index
> seq2
->last_line
->op_index
)
1700 /* Construct the line information table for quick lookup. */
1703 build_line_info_table (struct line_info_table
* table
,
1704 struct line_sequence
* seq
)
1707 struct line_info
** line_info_lookup
;
1708 struct line_info
* each_line
;
1709 unsigned int num_lines
;
1710 unsigned int line_index
;
1712 if (seq
->line_info_lookup
!= NULL
)
1715 /* Count the number of line information entries. We could do this while
1716 scanning the debug information, but some entries may be added via
1717 lcl_head without having a sequence handy to increment the number of
1720 for (each_line
= seq
->last_line
; each_line
; each_line
= each_line
->prev_line
)
1726 /* Allocate space for the line information lookup table. */
1727 amt
= sizeof (struct line_info
*) * num_lines
;
1728 line_info_lookup
= (struct line_info
**) bfd_alloc (table
->abfd
, amt
);
1729 if (line_info_lookup
== NULL
)
1732 /* Create the line information lookup table. */
1733 line_index
= num_lines
;
1734 for (each_line
= seq
->last_line
; each_line
; each_line
= each_line
->prev_line
)
1735 line_info_lookup
[--line_index
] = each_line
;
1737 BFD_ASSERT (line_index
== 0);
1739 seq
->num_lines
= num_lines
;
1740 seq
->line_info_lookup
= line_info_lookup
;
1745 /* Sort the line sequences for quick lookup. */
1748 sort_line_sequences (struct line_info_table
* table
)
1751 struct line_sequence
* sequences
;
1752 struct line_sequence
* seq
;
1754 unsigned int num_sequences
= table
->num_sequences
;
1755 bfd_vma last_high_pc
;
1757 if (num_sequences
== 0)
1760 /* Allocate space for an array of sequences. */
1761 amt
= sizeof (struct line_sequence
) * num_sequences
;
1762 sequences
= (struct line_sequence
*) bfd_alloc (table
->abfd
, amt
);
1763 if (sequences
== NULL
)
1766 /* Copy the linked list into the array, freeing the original nodes. */
1767 seq
= table
->sequences
;
1768 for (n
= 0; n
< num_sequences
; n
++)
1770 struct line_sequence
* last_seq
= seq
;
1773 sequences
[n
].low_pc
= seq
->low_pc
;
1774 sequences
[n
].prev_sequence
= NULL
;
1775 sequences
[n
].last_line
= seq
->last_line
;
1776 sequences
[n
].line_info_lookup
= NULL
;
1777 sequences
[n
].num_lines
= 0;
1778 seq
= seq
->prev_sequence
;
1781 BFD_ASSERT (seq
== NULL
);
1783 qsort (sequences
, n
, sizeof (struct line_sequence
), compare_sequences
);
1785 /* Make the list binary-searchable by trimming overlapping entries
1786 and removing nested entries. */
1788 last_high_pc
= sequences
[0].last_line
->address
;
1789 for (n
= 1; n
< table
->num_sequences
; n
++)
1791 if (sequences
[n
].low_pc
< last_high_pc
)
1793 if (sequences
[n
].last_line
->address
<= last_high_pc
)
1794 /* Skip nested entries. */
1797 /* Trim overlapping entries. */
1798 sequences
[n
].low_pc
= last_high_pc
;
1800 last_high_pc
= sequences
[n
].last_line
->address
;
1801 if (n
> num_sequences
)
1803 /* Close up the gap. */
1804 sequences
[num_sequences
].low_pc
= sequences
[n
].low_pc
;
1805 sequences
[num_sequences
].last_line
= sequences
[n
].last_line
;
1810 table
->sequences
= sequences
;
1811 table
->num_sequences
= num_sequences
;
1815 /* Add directory to TABLE. CUR_DIR memory ownership is taken by TABLE. */
1818 line_info_add_include_dir (struct line_info_table
*table
, char *cur_dir
)
1820 if ((table
->num_dirs
% DIR_ALLOC_CHUNK
) == 0)
1825 amt
= table
->num_dirs
+ DIR_ALLOC_CHUNK
;
1826 amt
*= sizeof (char *);
1828 tmp
= (char **) bfd_realloc (table
->dirs
, amt
);
1834 table
->dirs
[table
->num_dirs
++] = cur_dir
;
1839 line_info_add_include_dir_stub (struct line_info_table
*table
, char *cur_dir
,
1840 unsigned int dir ATTRIBUTE_UNUSED
,
1841 unsigned int xtime ATTRIBUTE_UNUSED
,
1842 unsigned int size ATTRIBUTE_UNUSED
)
1844 return line_info_add_include_dir (table
, cur_dir
);
1847 /* Add file to TABLE. CUR_FILE memory ownership is taken by TABLE. */
1850 line_info_add_file_name (struct line_info_table
*table
, char *cur_file
,
1851 unsigned int dir
, unsigned int xtime
,
1854 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
1856 struct fileinfo
*tmp
;
1859 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
1860 amt
*= sizeof (struct fileinfo
);
1862 tmp
= (struct fileinfo
*) bfd_realloc (table
->files
, amt
);
1868 table
->files
[table
->num_files
].name
= cur_file
;
1869 table
->files
[table
->num_files
].dir
= dir
;
1870 table
->files
[table
->num_files
].time
= xtime
;
1871 table
->files
[table
->num_files
].size
= size
;
1876 /* Read directory or file name entry format, starting with byte of
1877 format count entries, ULEB128 pairs of entry formats, ULEB128 of
1878 entries count and the entries themselves in the described entry
1882 read_formatted_entries (struct comp_unit
*unit
, bfd_byte
**bufp
,
1883 bfd_byte
*buf_end
, struct line_info_table
*table
,
1884 bfd_boolean (*callback
) (struct line_info_table
*table
,
1890 bfd
*abfd
= unit
->abfd
;
1891 bfd_byte format_count
, formati
;
1892 bfd_vma data_count
, datai
;
1893 bfd_byte
*buf
= *bufp
;
1894 bfd_byte
*format_header_data
;
1895 unsigned int bytes_read
;
1897 format_count
= read_1_byte (abfd
, buf
, buf_end
);
1899 format_header_data
= buf
;
1900 for (formati
= 0; formati
< format_count
; formati
++)
1902 _bfd_safe_read_leb128 (abfd
, buf
, &bytes_read
, FALSE
, buf_end
);
1904 _bfd_safe_read_leb128 (abfd
, buf
, &bytes_read
, FALSE
, buf_end
);
1908 data_count
= _bfd_safe_read_leb128 (abfd
, buf
, &bytes_read
, FALSE
, buf_end
);
1910 if (format_count
== 0 && data_count
!= 0)
1912 _bfd_error_handler (_("Dwarf Error: Zero format count."));
1913 bfd_set_error (bfd_error_bad_value
);
1917 /* PR 22210. Paranoia check. Don't bother running the loop
1918 if we know that we are going to run out of buffer. */
1919 if (data_count
> (bfd_vma
) (buf_end
- buf
))
1921 _bfd_error_handler (_("Dwarf Error: data count (%Lx) larger than buffer size."),
1923 bfd_set_error (bfd_error_bad_value
);
1927 for (datai
= 0; datai
< data_count
; datai
++)
1929 bfd_byte
*format
= format_header_data
;
1932 memset (&fe
, 0, sizeof fe
);
1933 for (formati
= 0; formati
< format_count
; formati
++)
1935 bfd_vma content_type
, form
;
1937 char **stringp
= &string_trash
;
1938 unsigned int uint_trash
, *uintp
= &uint_trash
;
1939 struct attribute attr
;
1941 content_type
= _bfd_safe_read_leb128 (abfd
, format
, &bytes_read
,
1943 format
+= bytes_read
;
1944 switch (content_type
)
1949 case DW_LNCT_directory_index
:
1952 case DW_LNCT_timestamp
:
1962 (_("Dwarf Error: Unknown format content type %Lu."),
1964 bfd_set_error (bfd_error_bad_value
);
1968 form
= _bfd_safe_read_leb128 (abfd
, format
, &bytes_read
, FALSE
,
1970 format
+= bytes_read
;
1972 buf
= read_attribute_value (&attr
, form
, 0, unit
, buf
, buf_end
);
1977 case DW_FORM_string
:
1978 case DW_FORM_line_strp
:
1979 *stringp
= attr
.u
.str
;
1987 *uintp
= attr
.u
.val
;
1992 if (!callback (table
, fe
.name
, fe
.dir
, fe
.time
, fe
.size
))
2000 /* Decode the line number information for UNIT. */
2002 static struct line_info_table
*
2003 decode_line_info (struct comp_unit
*unit
, struct dwarf2_debug
*stash
)
2005 bfd
*abfd
= unit
->abfd
;
2006 struct line_info_table
* table
;
2009 struct line_head lh
;
2010 unsigned int i
, bytes_read
, offset_size
;
2011 char *cur_file
, *cur_dir
;
2012 unsigned char op_code
, extended_op
, adj_opcode
;
2013 unsigned int exop_len
;
2016 if (! read_section (abfd
, &stash
->debug_sections
[debug_line
],
2017 stash
->syms
, unit
->line_offset
,
2018 &stash
->dwarf_line_buffer
, &stash
->dwarf_line_size
))
2021 amt
= sizeof (struct line_info_table
);
2022 table
= (struct line_info_table
*) bfd_alloc (abfd
, amt
);
2026 table
->comp_dir
= unit
->comp_dir
;
2028 table
->num_files
= 0;
2029 table
->files
= NULL
;
2031 table
->num_dirs
= 0;
2034 table
->num_sequences
= 0;
2035 table
->sequences
= NULL
;
2037 table
->lcl_head
= NULL
;
2039 if (stash
->dwarf_line_size
< 16)
2042 (_("Dwarf Error: Line info section is too small (%Ld)"),
2043 stash
->dwarf_line_size
);
2044 bfd_set_error (bfd_error_bad_value
);
2047 line_ptr
= stash
->dwarf_line_buffer
+ unit
->line_offset
;
2048 line_end
= stash
->dwarf_line_buffer
+ stash
->dwarf_line_size
;
2050 /* Read in the prologue. */
2051 lh
.total_length
= read_4_bytes (abfd
, line_ptr
, line_end
);
2054 if (lh
.total_length
== 0xffffffff)
2056 lh
.total_length
= read_8_bytes (abfd
, line_ptr
, line_end
);
2060 else if (lh
.total_length
== 0 && unit
->addr_size
== 8)
2062 /* Handle (non-standard) 64-bit DWARF2 formats. */
2063 lh
.total_length
= read_4_bytes (abfd
, line_ptr
, line_end
);
2068 if (lh
.total_length
> (size_t) (line_end
- line_ptr
))
2071 /* xgettext: c-format */
2072 (_("Dwarf Error: Line info data is bigger (%#Lx)"
2073 " than the space remaining in the section (%#lx)"),
2074 lh
.total_length
, (unsigned long) (line_end
- line_ptr
));
2075 bfd_set_error (bfd_error_bad_value
);
2079 line_end
= line_ptr
+ lh
.total_length
;
2081 lh
.version
= read_2_bytes (abfd
, line_ptr
, line_end
);
2082 if (lh
.version
< 2 || lh
.version
> 5)
2085 (_("Dwarf Error: Unhandled .debug_line version %d."), lh
.version
);
2086 bfd_set_error (bfd_error_bad_value
);
2091 if (line_ptr
+ offset_size
+ (lh
.version
>= 5 ? 8 : (lh
.version
>= 4 ? 6 : 5))
2095 (_("Dwarf Error: Ran out of room reading prologue"));
2096 bfd_set_error (bfd_error_bad_value
);
2100 if (lh
.version
>= 5)
2102 unsigned int segment_selector_size
;
2104 /* Skip address size. */
2105 read_1_byte (abfd
, line_ptr
, line_end
);
2108 segment_selector_size
= read_1_byte (abfd
, line_ptr
, line_end
);
2110 if (segment_selector_size
!= 0)
2113 (_("Dwarf Error: Line info unsupported segment selector size %u."),
2114 segment_selector_size
);
2115 bfd_set_error (bfd_error_bad_value
);
2120 if (offset_size
== 4)
2121 lh
.prologue_length
= read_4_bytes (abfd
, line_ptr
, line_end
);
2123 lh
.prologue_length
= read_8_bytes (abfd
, line_ptr
, line_end
);
2124 line_ptr
+= offset_size
;
2126 lh
.minimum_instruction_length
= read_1_byte (abfd
, line_ptr
, line_end
);
2129 if (lh
.version
>= 4)
2131 lh
.maximum_ops_per_insn
= read_1_byte (abfd
, line_ptr
, line_end
);
2135 lh
.maximum_ops_per_insn
= 1;
2137 if (lh
.maximum_ops_per_insn
== 0)
2140 (_("Dwarf Error: Invalid maximum operations per instruction."));
2141 bfd_set_error (bfd_error_bad_value
);
2145 lh
.default_is_stmt
= read_1_byte (abfd
, line_ptr
, line_end
);
2148 lh
.line_base
= read_1_signed_byte (abfd
, line_ptr
, line_end
);
2151 lh
.line_range
= read_1_byte (abfd
, line_ptr
, line_end
);
2154 lh
.opcode_base
= read_1_byte (abfd
, line_ptr
, line_end
);
2157 if (line_ptr
+ (lh
.opcode_base
- 1) >= line_end
)
2159 _bfd_error_handler (_("Dwarf Error: Ran out of room reading opcodes"));
2160 bfd_set_error (bfd_error_bad_value
);
2164 amt
= lh
.opcode_base
* sizeof (unsigned char);
2165 lh
.standard_opcode_lengths
= (unsigned char *) bfd_alloc (abfd
, amt
);
2167 lh
.standard_opcode_lengths
[0] = 1;
2169 for (i
= 1; i
< lh
.opcode_base
; ++i
)
2171 lh
.standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
, line_end
);
2175 if (lh
.version
>= 5)
2177 /* Read directory table. */
2178 if (!read_formatted_entries (unit
, &line_ptr
, line_end
, table
,
2179 line_info_add_include_dir_stub
))
2182 /* Read file name table. */
2183 if (!read_formatted_entries (unit
, &line_ptr
, line_end
, table
,
2184 line_info_add_file_name
))
2189 /* Read directory table. */
2190 while ((cur_dir
= read_string (abfd
, line_ptr
, line_end
, &bytes_read
)) != NULL
)
2192 line_ptr
+= bytes_read
;
2194 if (!line_info_add_include_dir (table
, cur_dir
))
2198 line_ptr
+= bytes_read
;
2200 /* Read file name table. */
2201 while ((cur_file
= read_string (abfd
, line_ptr
, line_end
, &bytes_read
)) != NULL
)
2203 unsigned int dir
, xtime
, size
;
2205 line_ptr
+= bytes_read
;
2207 dir
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
, FALSE
, line_end
);
2208 line_ptr
+= bytes_read
;
2209 xtime
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
, FALSE
, line_end
);
2210 line_ptr
+= bytes_read
;
2211 size
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
, FALSE
, line_end
);
2212 line_ptr
+= bytes_read
;
2214 if (!line_info_add_file_name (table
, cur_file
, dir
, xtime
, size
))
2218 line_ptr
+= bytes_read
;
2221 /* Read the statement sequences until there's nothing left. */
2222 while (line_ptr
< line_end
)
2224 /* State machine registers. */
2225 bfd_vma address
= 0;
2226 unsigned char op_index
= 0;
2227 char * filename
= table
->num_files
? concat_filename (table
, 1) : NULL
;
2228 unsigned int line
= 1;
2229 unsigned int column
= 0;
2230 unsigned int discriminator
= 0;
2231 int is_stmt
= lh
.default_is_stmt
;
2232 int end_sequence
= 0;
2233 unsigned int dir
, xtime
, size
;
2234 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
2235 compilers generate address sequences that are wildly out of
2236 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
2237 for ia64-Linux). Thus, to determine the low and high
2238 address, we must compare on every DW_LNS_copy, etc. */
2239 bfd_vma low_pc
= (bfd_vma
) -1;
2240 bfd_vma high_pc
= 0;
2242 /* Decode the table. */
2243 while (!end_sequence
&& line_ptr
< line_end
)
2245 op_code
= read_1_byte (abfd
, line_ptr
, line_end
);
2248 if (op_code
>= lh
.opcode_base
)
2250 /* Special operand. */
2251 adj_opcode
= op_code
- lh
.opcode_base
;
2252 if (lh
.line_range
== 0)
2254 if (lh
.maximum_ops_per_insn
== 1)
2255 address
+= (adj_opcode
/ lh
.line_range
2256 * lh
.minimum_instruction_length
);
2259 address
+= ((op_index
+ adj_opcode
/ lh
.line_range
)
2260 / lh
.maximum_ops_per_insn
2261 * lh
.minimum_instruction_length
);
2262 op_index
= ((op_index
+ adj_opcode
/ lh
.line_range
)
2263 % lh
.maximum_ops_per_insn
);
2265 line
+= lh
.line_base
+ (adj_opcode
% lh
.line_range
);
2266 /* Append row to matrix using current values. */
2267 if (!add_line_info (table
, address
, op_index
, filename
,
2268 line
, column
, discriminator
, 0))
2271 if (address
< low_pc
)
2273 if (address
> high_pc
)
2276 else switch (op_code
)
2278 case DW_LNS_extended_op
:
2279 exop_len
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2281 line_ptr
+= bytes_read
;
2282 extended_op
= read_1_byte (abfd
, line_ptr
, line_end
);
2285 switch (extended_op
)
2287 case DW_LNE_end_sequence
:
2289 if (!add_line_info (table
, address
, op_index
, filename
, line
,
2290 column
, discriminator
, end_sequence
))
2293 if (address
< low_pc
)
2295 if (address
> high_pc
)
2297 if (!arange_add (unit
, &unit
->arange
, low_pc
, high_pc
))
2300 case DW_LNE_set_address
:
2301 address
= read_address (unit
, line_ptr
, line_end
);
2303 line_ptr
+= unit
->addr_size
;
2305 case DW_LNE_define_file
:
2306 cur_file
= read_string (abfd
, line_ptr
, line_end
, &bytes_read
);
2307 line_ptr
+= bytes_read
;
2308 dir
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2310 line_ptr
+= bytes_read
;
2311 xtime
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2313 line_ptr
+= bytes_read
;
2314 size
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2316 line_ptr
+= bytes_read
;
2317 if (!line_info_add_file_name (table
, cur_file
, dir
,
2321 case DW_LNE_set_discriminator
:
2323 _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2325 line_ptr
+= bytes_read
;
2327 case DW_LNE_HP_source_file_correlation
:
2328 line_ptr
+= exop_len
- 1;
2332 (_("Dwarf Error: mangled line number section."));
2333 bfd_set_error (bfd_error_bad_value
);
2335 if (filename
!= NULL
)
2341 if (!add_line_info (table
, address
, op_index
,
2342 filename
, line
, column
, discriminator
, 0))
2345 if (address
< low_pc
)
2347 if (address
> high_pc
)
2350 case DW_LNS_advance_pc
:
2351 if (lh
.maximum_ops_per_insn
== 1)
2352 address
+= (lh
.minimum_instruction_length
2353 * _bfd_safe_read_leb128 (abfd
, line_ptr
,
2358 bfd_vma adjust
= _bfd_safe_read_leb128 (abfd
, line_ptr
,
2361 address
= ((op_index
+ adjust
) / lh
.maximum_ops_per_insn
2362 * lh
.minimum_instruction_length
);
2363 op_index
= (op_index
+ adjust
) % lh
.maximum_ops_per_insn
;
2365 line_ptr
+= bytes_read
;
2367 case DW_LNS_advance_line
:
2368 line
+= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2370 line_ptr
+= bytes_read
;
2372 case DW_LNS_set_file
:
2376 /* The file and directory tables are 0
2377 based, the references are 1 based. */
2378 file
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2380 line_ptr
+= bytes_read
;
2383 filename
= concat_filename (table
, file
);
2386 case DW_LNS_set_column
:
2387 column
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2389 line_ptr
+= bytes_read
;
2391 case DW_LNS_negate_stmt
:
2392 is_stmt
= (!is_stmt
);
2394 case DW_LNS_set_basic_block
:
2396 case DW_LNS_const_add_pc
:
2397 if (lh
.line_range
== 0)
2399 if (lh
.maximum_ops_per_insn
== 1)
2400 address
+= (lh
.minimum_instruction_length
2401 * ((255 - lh
.opcode_base
) / lh
.line_range
));
2404 bfd_vma adjust
= ((255 - lh
.opcode_base
) / lh
.line_range
);
2405 address
+= (lh
.minimum_instruction_length
2406 * ((op_index
+ adjust
)
2407 / lh
.maximum_ops_per_insn
));
2408 op_index
= (op_index
+ adjust
) % lh
.maximum_ops_per_insn
;
2411 case DW_LNS_fixed_advance_pc
:
2412 address
+= read_2_bytes (abfd
, line_ptr
, line_end
);
2417 /* Unknown standard opcode, ignore it. */
2418 for (i
= 0; i
< lh
.standard_opcode_lengths
[op_code
]; i
++)
2420 (void) _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2422 line_ptr
+= bytes_read
;
2432 if (sort_line_sequences (table
))
2436 while (table
->sequences
!= NULL
)
2438 struct line_sequence
* seq
= table
->sequences
;
2439 table
->sequences
= table
->sequences
->prev_sequence
;
2442 if (table
->files
!= NULL
)
2443 free (table
->files
);
2444 if (table
->dirs
!= NULL
)
2449 /* If ADDR is within TABLE set the output parameters and return the
2450 range of addresses covered by the entry used to fill them out.
2451 Otherwise set * FILENAME_PTR to NULL and return 0.
2452 The parameters FILENAME_PTR, LINENUMBER_PTR and DISCRIMINATOR_PTR
2453 are pointers to the objects to be filled in. */
2456 lookup_address_in_line_info_table (struct line_info_table
*table
,
2458 const char **filename_ptr
,
2459 unsigned int *linenumber_ptr
,
2460 unsigned int *discriminator_ptr
)
2462 struct line_sequence
*seq
= NULL
;
2463 struct line_info
*info
;
2466 /* Binary search the array of sequences. */
2468 high
= table
->num_sequences
;
2471 mid
= (low
+ high
) / 2;
2472 seq
= &table
->sequences
[mid
];
2473 if (addr
< seq
->low_pc
)
2475 else if (addr
>= seq
->last_line
->address
)
2481 /* Check for a valid sequence. */
2482 if (!seq
|| addr
< seq
->low_pc
|| addr
>= seq
->last_line
->address
)
2485 if (!build_line_info_table (table
, seq
))
2488 /* Binary search the array of line information. */
2490 high
= seq
->num_lines
;
2494 mid
= (low
+ high
) / 2;
2495 info
= seq
->line_info_lookup
[mid
];
2496 if (addr
< info
->address
)
2498 else if (addr
>= seq
->line_info_lookup
[mid
+ 1]->address
)
2504 /* Check for a valid line information entry. */
2506 && addr
>= info
->address
2507 && addr
< seq
->line_info_lookup
[mid
+ 1]->address
2508 && !(info
->end_sequence
|| info
== seq
->last_line
))
2510 *filename_ptr
= info
->filename
;
2511 *linenumber_ptr
= info
->line
;
2512 if (discriminator_ptr
)
2513 *discriminator_ptr
= info
->discriminator
;
2514 return seq
->last_line
->address
- seq
->low_pc
;
2518 *filename_ptr
= NULL
;
2522 /* Read in the .debug_ranges section for future reference. */
2525 read_debug_ranges (struct comp_unit
* unit
)
2527 struct dwarf2_debug
* stash
= unit
->stash
;
2529 return read_section (unit
->abfd
, &stash
->debug_sections
[debug_ranges
],
2531 &stash
->dwarf_ranges_buffer
,
2532 &stash
->dwarf_ranges_size
);
2535 /* Function table functions. */
2538 compare_lookup_funcinfos (const void * a
, const void * b
)
2540 const struct lookup_funcinfo
* lookup1
= a
;
2541 const struct lookup_funcinfo
* lookup2
= b
;
2543 if (lookup1
->low_addr
< lookup2
->low_addr
)
2545 if (lookup1
->low_addr
> lookup2
->low_addr
)
2547 if (lookup1
->high_addr
< lookup2
->high_addr
)
2549 if (lookup1
->high_addr
> lookup2
->high_addr
)
2556 build_lookup_funcinfo_table (struct comp_unit
* unit
)
2558 struct lookup_funcinfo
*lookup_funcinfo_table
= unit
->lookup_funcinfo_table
;
2559 unsigned int number_of_functions
= unit
->number_of_functions
;
2560 struct funcinfo
*each
;
2561 struct lookup_funcinfo
*entry
;
2563 struct arange
*range
;
2564 bfd_vma low_addr
, high_addr
;
2566 if (lookup_funcinfo_table
|| number_of_functions
== 0)
2569 /* Create the function info lookup table. */
2570 lookup_funcinfo_table
= (struct lookup_funcinfo
*)
2571 bfd_malloc (number_of_functions
* sizeof (struct lookup_funcinfo
));
2572 if (lookup_funcinfo_table
== NULL
)
2575 /* Populate the function info lookup table. */
2576 func_index
= number_of_functions
;
2577 for (each
= unit
->function_table
; each
; each
= each
->prev_func
)
2579 entry
= &lookup_funcinfo_table
[--func_index
];
2580 entry
->funcinfo
= each
;
2582 /* Calculate the lowest and highest address for this function entry. */
2583 low_addr
= entry
->funcinfo
->arange
.low
;
2584 high_addr
= entry
->funcinfo
->arange
.high
;
2586 for (range
= entry
->funcinfo
->arange
.next
; range
; range
= range
->next
)
2588 if (range
->low
< low_addr
)
2589 low_addr
= range
->low
;
2590 if (range
->high
> high_addr
)
2591 high_addr
= range
->high
;
2594 entry
->low_addr
= low_addr
;
2595 entry
->high_addr
= high_addr
;
2598 BFD_ASSERT (func_index
== 0);
2600 /* Sort the function by address. */
2601 qsort (lookup_funcinfo_table
,
2602 number_of_functions
,
2603 sizeof (struct lookup_funcinfo
),
2604 compare_lookup_funcinfos
);
2606 /* Calculate the high watermark for each function in the lookup table. */
2607 high_addr
= lookup_funcinfo_table
[0].high_addr
;
2608 for (func_index
= 1; func_index
< number_of_functions
; func_index
++)
2610 entry
= &lookup_funcinfo_table
[func_index
];
2611 if (entry
->high_addr
> high_addr
)
2612 high_addr
= entry
->high_addr
;
2614 entry
->high_addr
= high_addr
;
2617 unit
->lookup_funcinfo_table
= lookup_funcinfo_table
;
2621 /* If ADDR is within UNIT's function tables, set FUNCTION_PTR, and return
2622 TRUE. Note that we need to find the function that has the smallest range
2623 that contains ADDR, to handle inlined functions without depending upon
2624 them being ordered in TABLE by increasing range. */
2627 lookup_address_in_function_table (struct comp_unit
*unit
,
2629 struct funcinfo
**function_ptr
)
2631 unsigned int number_of_functions
= unit
->number_of_functions
;
2632 struct lookup_funcinfo
* lookup_funcinfo
= NULL
;
2633 struct funcinfo
* funcinfo
= NULL
;
2634 struct funcinfo
* best_fit
= NULL
;
2635 bfd_vma best_fit_len
= 0;
2636 bfd_size_type low
, high
, mid
, first
;
2637 struct arange
*arange
;
2639 if (number_of_functions
== 0)
2642 if (!build_lookup_funcinfo_table (unit
))
2645 if (unit
->lookup_funcinfo_table
[number_of_functions
- 1].high_addr
< addr
)
2648 /* Find the first function in the lookup table which may contain the
2649 specified address. */
2651 high
= number_of_functions
;
2655 mid
= (low
+ high
) / 2;
2656 lookup_funcinfo
= &unit
->lookup_funcinfo_table
[mid
];
2657 if (addr
< lookup_funcinfo
->low_addr
)
2659 else if (addr
>= lookup_funcinfo
->high_addr
)
2665 /* Find the 'best' match for the address. The prior algorithm defined the
2666 best match as the function with the smallest address range containing
2667 the specified address. This definition should probably be changed to the
2668 innermost inline routine containing the address, but right now we want
2669 to get the same results we did before. */
2670 while (first
< number_of_functions
)
2672 if (addr
< unit
->lookup_funcinfo_table
[first
].low_addr
)
2674 funcinfo
= unit
->lookup_funcinfo_table
[first
].funcinfo
;
2676 for (arange
= &funcinfo
->arange
; arange
; arange
= arange
->next
)
2678 if (addr
< arange
->low
|| addr
>= arange
->high
)
2682 || arange
->high
- arange
->low
< best_fit_len
2683 /* The following comparison is designed to return the same
2684 match as the previous algorithm for routines which have the
2685 same best fit length. */
2686 || (arange
->high
- arange
->low
== best_fit_len
2687 && funcinfo
> best_fit
))
2689 best_fit
= funcinfo
;
2690 best_fit_len
= arange
->high
- arange
->low
;
2700 *function_ptr
= best_fit
;
2704 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
2705 and LINENUMBER_PTR, and return TRUE. */
2708 lookup_symbol_in_function_table (struct comp_unit
*unit
,
2711 const char **filename_ptr
,
2712 unsigned int *linenumber_ptr
)
2714 struct funcinfo
* each_func
;
2715 struct funcinfo
* best_fit
= NULL
;
2716 bfd_vma best_fit_len
= 0;
2717 struct arange
*arange
;
2718 const char *name
= bfd_asymbol_name (sym
);
2719 asection
*sec
= bfd_get_section (sym
);
2721 for (each_func
= unit
->function_table
;
2723 each_func
= each_func
->prev_func
)
2725 for (arange
= &each_func
->arange
;
2727 arange
= arange
->next
)
2729 if ((!each_func
->sec
|| each_func
->sec
== sec
)
2730 && addr
>= arange
->low
2731 && addr
< arange
->high
2733 && strcmp (name
, each_func
->name
) == 0
2735 || arange
->high
- arange
->low
< best_fit_len
))
2737 best_fit
= each_func
;
2738 best_fit_len
= arange
->high
- arange
->low
;
2745 best_fit
->sec
= sec
;
2746 *filename_ptr
= best_fit
->file
;
2747 *linenumber_ptr
= best_fit
->line
;
2754 /* Variable table functions. */
2756 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
2757 LINENUMBER_PTR, and return TRUE. */
2760 lookup_symbol_in_variable_table (struct comp_unit
*unit
,
2763 const char **filename_ptr
,
2764 unsigned int *linenumber_ptr
)
2766 const char *name
= bfd_asymbol_name (sym
);
2767 asection
*sec
= bfd_get_section (sym
);
2768 struct varinfo
* each
;
2770 for (each
= unit
->variable_table
; each
; each
= each
->prev_var
)
2771 if (each
->stack
== 0
2772 && each
->file
!= NULL
2773 && each
->name
!= NULL
2774 && each
->addr
== addr
2775 && (!each
->sec
|| each
->sec
== sec
)
2776 && strcmp (name
, each
->name
) == 0)
2782 *filename_ptr
= each
->file
;
2783 *linenumber_ptr
= each
->line
;
2791 find_abstract_instance (struct comp_unit
* unit
,
2792 bfd_byte
* orig_info_ptr
,
2793 struct attribute
* attr_ptr
,
2794 const char ** pname
,
2795 bfd_boolean
* is_linkage
,
2796 char ** filename_ptr
,
2797 int * linenumber_ptr
)
2799 bfd
*abfd
= unit
->abfd
;
2801 bfd_byte
*info_ptr_end
;
2802 unsigned int abbrev_number
, bytes_read
, i
;
2803 struct abbrev_info
*abbrev
;
2804 bfd_uint64_t die_ref
= attr_ptr
->u
.val
;
2805 struct attribute attr
;
2806 const char *name
= NULL
;
2808 /* DW_FORM_ref_addr can reference an entry in a different CU. It
2809 is an offset from the .debug_info section, not the current CU. */
2810 if (attr_ptr
->form
== DW_FORM_ref_addr
)
2812 /* We only support DW_FORM_ref_addr within the same file, so
2813 any relocations should be resolved already. Check this by
2814 testing for a zero die_ref; There can't be a valid reference
2815 to the header of a .debug_info section.
2816 DW_FORM_ref_addr is an offset relative to .debug_info.
2817 Normally when using the GNU linker this is accomplished by
2818 emitting a symbolic reference to a label, because .debug_info
2819 sections are linked at zero. When there are multiple section
2820 groups containing .debug_info, as there might be in a
2821 relocatable object file, it would be reasonable to assume that
2822 a symbolic reference to a label in any .debug_info section
2823 might be used. Since we lay out multiple .debug_info
2824 sections at non-zero VMAs (see place_sections), and read
2825 them contiguously into stash->info_ptr_memory, that means
2826 the reference is relative to stash->info_ptr_memory. */
2829 info_ptr
= unit
->stash
->info_ptr_memory
;
2830 info_ptr_end
= unit
->stash
->info_ptr_end
;
2831 total
= info_ptr_end
- info_ptr
;
2832 if (!die_ref
|| die_ref
>= total
)
2835 (_("Dwarf Error: Invalid abstract instance DIE ref."));
2836 bfd_set_error (bfd_error_bad_value
);
2839 info_ptr
+= die_ref
;
2841 /* Now find the CU containing this pointer. */
2842 if (info_ptr
>= unit
->info_ptr_unit
&& info_ptr
< unit
->end_ptr
)
2843 info_ptr_end
= unit
->end_ptr
;
2846 /* Check other CUs to see if they contain the abbrev. */
2847 struct comp_unit
* u
;
2849 for (u
= unit
->prev_unit
; u
!= NULL
; u
= u
->prev_unit
)
2850 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
2854 for (u
= unit
->next_unit
; u
!= NULL
; u
= u
->next_unit
)
2855 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
2861 info_ptr_end
= unit
->end_ptr
;
2863 /* else FIXME: What do we do now ? */
2866 else if (attr_ptr
->form
== DW_FORM_GNU_ref_alt
)
2868 info_ptr
= read_alt_indirect_ref (unit
, die_ref
);
2869 if (info_ptr
== NULL
)
2872 (_("Dwarf Error: Unable to read alt ref %llu."),
2873 (long long) die_ref
);
2874 bfd_set_error (bfd_error_bad_value
);
2877 info_ptr_end
= (unit
->stash
->alt_dwarf_info_buffer
2878 + unit
->stash
->alt_dwarf_info_size
);
2880 /* FIXME: Do we need to locate the correct CU, in a similar
2881 fashion to the code in the DW_FORM_ref_addr case above ? */
2885 /* DW_FORM_ref1, DW_FORM_ref2, DW_FORM_ref4, DW_FORM_ref8 or
2886 DW_FORM_ref_udata. These are all references relative to the
2887 start of the current CU. */
2890 info_ptr
= unit
->info_ptr_unit
;
2891 info_ptr_end
= unit
->end_ptr
;
2892 total
= info_ptr_end
- info_ptr
;
2893 if (!die_ref
|| die_ref
>= total
)
2896 (_("Dwarf Error: Invalid abstract instance DIE ref."));
2897 bfd_set_error (bfd_error_bad_value
);
2900 info_ptr
+= die_ref
;
2903 abbrev_number
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
2904 FALSE
, info_ptr_end
);
2905 info_ptr
+= bytes_read
;
2909 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
2913 (_("Dwarf Error: Could not find abbrev number %u."), abbrev_number
);
2914 bfd_set_error (bfd_error_bad_value
);
2919 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
2921 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
,
2922 info_ptr
, info_ptr_end
);
2923 if (info_ptr
== NULL
)
2925 /* It doesn't ever make sense for DW_AT_specification to
2926 refer to the same DIE. Stop simple recursion. */
2927 if (info_ptr
== orig_info_ptr
)
2930 (_("Dwarf Error: Abstract instance recursion detected."));
2931 bfd_set_error (bfd_error_bad_value
);
2937 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2939 if (name
== NULL
&& is_str_attr (attr
.form
))
2942 if (non_mangled (unit
->lang
))
2946 case DW_AT_specification
:
2947 if (!find_abstract_instance (unit
, info_ptr
, &attr
,
2949 filename_ptr
, linenumber_ptr
))
2952 case DW_AT_linkage_name
:
2953 case DW_AT_MIPS_linkage_name
:
2954 /* PR 16949: Corrupt debug info can place
2955 non-string forms into these attributes. */
2956 if (is_str_attr (attr
.form
))
2962 case DW_AT_decl_file
:
2963 *filename_ptr
= concat_filename (unit
->line_table
,
2966 case DW_AT_decl_line
:
2967 *linenumber_ptr
= attr
.u
.val
;
2980 read_rangelist (struct comp_unit
*unit
, struct arange
*arange
,
2981 bfd_uint64_t offset
)
2983 bfd_byte
*ranges_ptr
;
2984 bfd_byte
*ranges_end
;
2985 bfd_vma base_address
= unit
->base_address
;
2987 if (! unit
->stash
->dwarf_ranges_buffer
)
2989 if (! read_debug_ranges (unit
))
2993 ranges_ptr
= unit
->stash
->dwarf_ranges_buffer
+ offset
;
2994 if (ranges_ptr
< unit
->stash
->dwarf_ranges_buffer
)
2996 ranges_end
= unit
->stash
->dwarf_ranges_buffer
+ unit
->stash
->dwarf_ranges_size
;
3003 /* PR 17512: file: 62cada7d. */
3004 if (ranges_ptr
+ 2 * unit
->addr_size
> ranges_end
)
3007 low_pc
= read_address (unit
, ranges_ptr
, ranges_end
);
3008 ranges_ptr
+= unit
->addr_size
;
3009 high_pc
= read_address (unit
, ranges_ptr
, ranges_end
);
3010 ranges_ptr
+= unit
->addr_size
;
3012 if (low_pc
== 0 && high_pc
== 0)
3014 if (low_pc
== -1UL && high_pc
!= -1UL)
3015 base_address
= high_pc
;
3018 if (!arange_add (unit
, arange
,
3019 base_address
+ low_pc
, base_address
+ high_pc
))
3026 /* DWARF2 Compilation unit functions. */
3028 /* Scan over each die in a comp. unit looking for functions to add
3029 to the function table and variables to the variable table. */
3032 scan_unit_for_symbols (struct comp_unit
*unit
)
3034 bfd
*abfd
= unit
->abfd
;
3035 bfd_byte
*info_ptr
= unit
->first_child_die_ptr
;
3036 bfd_byte
*info_ptr_end
= unit
->stash
->info_ptr_end
;
3037 int nesting_level
= 0;
3038 struct nest_funcinfo
{
3039 struct funcinfo
*func
;
3041 int nested_funcs_size
;
3043 /* Maintain a stack of in-scope functions and inlined functions, which we
3044 can use to set the caller_func field. */
3045 nested_funcs_size
= 32;
3046 nested_funcs
= (struct nest_funcinfo
*)
3047 bfd_malloc (nested_funcs_size
* sizeof (*nested_funcs
));
3048 if (nested_funcs
== NULL
)
3050 nested_funcs
[nesting_level
].func
= 0;
3052 while (nesting_level
>= 0)
3054 unsigned int abbrev_number
, bytes_read
, i
;
3055 struct abbrev_info
*abbrev
;
3056 struct attribute attr
;
3057 struct funcinfo
*func
;
3058 struct varinfo
*var
;
3060 bfd_vma high_pc
= 0;
3061 bfd_boolean high_pc_relative
= FALSE
;
3063 /* PR 17512: file: 9f405d9d. */
3064 if (info_ptr
>= info_ptr_end
)
3067 abbrev_number
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
3068 FALSE
, info_ptr_end
);
3069 info_ptr
+= bytes_read
;
3071 if (! abbrev_number
)
3077 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
3080 static unsigned int previous_failed_abbrev
= -1U;
3082 /* Avoid multiple reports of the same missing abbrev. */
3083 if (abbrev_number
!= previous_failed_abbrev
)
3086 (_("Dwarf Error: Could not find abbrev number %u."),
3088 previous_failed_abbrev
= abbrev_number
;
3090 bfd_set_error (bfd_error_bad_value
);
3095 if (abbrev
->tag
== DW_TAG_subprogram
3096 || abbrev
->tag
== DW_TAG_entry_point
3097 || abbrev
->tag
== DW_TAG_inlined_subroutine
)
3099 bfd_size_type amt
= sizeof (struct funcinfo
);
3100 func
= (struct funcinfo
*) bfd_zalloc (abfd
, amt
);
3103 func
->tag
= abbrev
->tag
;
3104 func
->prev_func
= unit
->function_table
;
3105 unit
->function_table
= func
;
3106 unit
->number_of_functions
++;
3107 BFD_ASSERT (!unit
->cached
);
3109 if (func
->tag
== DW_TAG_inlined_subroutine
)
3110 for (i
= nesting_level
; i
-- != 0; )
3111 if (nested_funcs
[i
].func
)
3113 func
->caller_func
= nested_funcs
[i
].func
;
3116 nested_funcs
[nesting_level
].func
= func
;
3121 if (abbrev
->tag
== DW_TAG_variable
)
3123 bfd_size_type amt
= sizeof (struct varinfo
);
3124 var
= (struct varinfo
*) bfd_zalloc (abfd
, amt
);
3127 var
->tag
= abbrev
->tag
;
3129 var
->prev_var
= unit
->variable_table
;
3130 unit
->variable_table
= var
;
3131 /* PR 18205: Missing debug information can cause this
3132 var to be attached to an already cached unit. */
3135 /* No inline function in scope at this nesting level. */
3136 nested_funcs
[nesting_level
].func
= 0;
3139 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3141 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
],
3142 unit
, info_ptr
, info_ptr_end
);
3143 if (info_ptr
== NULL
)
3150 case DW_AT_call_file
:
3151 func
->caller_file
= concat_filename (unit
->line_table
,
3155 case DW_AT_call_line
:
3156 func
->caller_line
= attr
.u
.val
;
3159 case DW_AT_abstract_origin
:
3160 case DW_AT_specification
:
3161 if (!find_abstract_instance (unit
, info_ptr
, &attr
,
3170 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
3172 if (func
->name
== NULL
&& is_str_attr (attr
.form
))
3174 func
->name
= attr
.u
.str
;
3175 if (non_mangled (unit
->lang
))
3176 func
->is_linkage
= TRUE
;
3180 case DW_AT_linkage_name
:
3181 case DW_AT_MIPS_linkage_name
:
3182 /* PR 16949: Corrupt debug info can place
3183 non-string forms into these attributes. */
3184 if (is_str_attr (attr
.form
))
3186 func
->name
= attr
.u
.str
;
3187 func
->is_linkage
= TRUE
;
3192 low_pc
= attr
.u
.val
;
3196 high_pc
= attr
.u
.val
;
3197 high_pc_relative
= attr
.form
!= DW_FORM_addr
;
3201 if (!read_rangelist (unit
, &func
->arange
, attr
.u
.val
))
3205 case DW_AT_decl_file
:
3206 func
->file
= concat_filename (unit
->line_table
,
3210 case DW_AT_decl_line
:
3211 func
->line
= attr
.u
.val
;
3223 if (is_str_attr (attr
.form
))
3224 var
->name
= attr
.u
.str
;
3227 case DW_AT_decl_file
:
3228 var
->file
= concat_filename (unit
->line_table
,
3232 case DW_AT_decl_line
:
3233 var
->line
= attr
.u
.val
;
3236 case DW_AT_external
:
3237 if (attr
.u
.val
!= 0)
3241 case DW_AT_location
:
3245 case DW_FORM_block1
:
3246 case DW_FORM_block2
:
3247 case DW_FORM_block4
:
3248 case DW_FORM_exprloc
:
3249 if (attr
.u
.blk
->data
!= NULL
3250 && *attr
.u
.blk
->data
== DW_OP_addr
)
3254 /* Verify that DW_OP_addr is the only opcode in the
3255 location, in which case the block size will be 1
3256 plus the address size. */
3257 /* ??? For TLS variables, gcc can emit
3258 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
3259 which we don't handle here yet. */
3260 if (attr
.u
.blk
->size
== unit
->addr_size
+ 1U)
3261 var
->addr
= bfd_get (unit
->addr_size
* 8,
3263 attr
.u
.blk
->data
+ 1);
3278 if (high_pc_relative
)
3281 if (func
&& high_pc
!= 0)
3283 if (!arange_add (unit
, &func
->arange
, low_pc
, high_pc
))
3287 if (abbrev
->has_children
)
3291 if (nesting_level
>= nested_funcs_size
)
3293 struct nest_funcinfo
*tmp
;
3295 nested_funcs_size
*= 2;
3296 tmp
= (struct nest_funcinfo
*)
3297 bfd_realloc (nested_funcs
,
3298 nested_funcs_size
* sizeof (*nested_funcs
));
3303 nested_funcs
[nesting_level
].func
= 0;
3307 free (nested_funcs
);
3311 free (nested_funcs
);
3315 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
3316 includes the compilation unit header that proceeds the DIE's, but
3317 does not include the length field that precedes each compilation
3318 unit header. END_PTR points one past the end of this comp unit.
3319 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
3321 This routine does not read the whole compilation unit; only enough
3322 to get to the line number information for the compilation unit. */
3324 static struct comp_unit
*
3325 parse_comp_unit (struct dwarf2_debug
*stash
,
3326 bfd_vma unit_length
,
3327 bfd_byte
*info_ptr_unit
,
3328 unsigned int offset_size
)
3330 struct comp_unit
* unit
;
3331 unsigned int version
;
3332 bfd_uint64_t abbrev_offset
= 0;
3333 /* Initialize it just to avoid a GCC false warning. */
3334 unsigned int addr_size
= -1;
3335 struct abbrev_info
** abbrevs
;
3336 unsigned int abbrev_number
, bytes_read
, i
;
3337 struct abbrev_info
*abbrev
;
3338 struct attribute attr
;
3339 bfd_byte
*info_ptr
= stash
->info_ptr
;
3340 bfd_byte
*end_ptr
= info_ptr
+ unit_length
;
3343 bfd_vma high_pc
= 0;
3344 bfd
*abfd
= stash
->bfd_ptr
;
3345 bfd_boolean high_pc_relative
= FALSE
;
3346 enum dwarf_unit_type unit_type
;
3348 version
= read_2_bytes (abfd
, info_ptr
, end_ptr
);
3350 if (version
< 2 || version
> 5)
3352 /* PR 19872: A version number of 0 probably means that there is padding
3353 at the end of the .debug_info section. Gold puts it there when
3354 performing an incremental link, for example. So do not generate
3355 an error, just return a NULL. */
3359 (_("Dwarf Error: found dwarf version '%u', this reader"
3360 " only handles version 2, 3, 4 and 5 information."), version
);
3361 bfd_set_error (bfd_error_bad_value
);
3367 unit_type
= DW_UT_compile
;
3370 unit_type
= read_1_byte (abfd
, info_ptr
, end_ptr
);
3373 addr_size
= read_1_byte (abfd
, info_ptr
, end_ptr
);
3377 BFD_ASSERT (offset_size
== 4 || offset_size
== 8);
3378 if (offset_size
== 4)
3379 abbrev_offset
= read_4_bytes (abfd
, info_ptr
, end_ptr
);
3381 abbrev_offset
= read_8_bytes (abfd
, info_ptr
, end_ptr
);
3382 info_ptr
+= offset_size
;
3386 addr_size
= read_1_byte (abfd
, info_ptr
, end_ptr
);
3390 if (unit_type
== DW_UT_type
)
3392 /* Skip type signature. */
3395 /* Skip type offset. */
3396 info_ptr
+= offset_size
;
3399 if (addr_size
> sizeof (bfd_vma
))
3402 /* xgettext: c-format */
3403 (_("Dwarf Error: found address size '%u', this reader"
3404 " can not handle sizes greater than '%u'."),
3406 (unsigned int) sizeof (bfd_vma
));
3407 bfd_set_error (bfd_error_bad_value
);
3411 if (addr_size
!= 2 && addr_size
!= 4 && addr_size
!= 8)
3414 ("Dwarf Error: found address size '%u', this reader"
3415 " can only handle address sizes '2', '4' and '8'.", addr_size
);
3416 bfd_set_error (bfd_error_bad_value
);
3420 /* Read the abbrevs for this compilation unit into a table. */
3421 abbrevs
= read_abbrevs (abfd
, abbrev_offset
, stash
);
3425 abbrev_number
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
3427 info_ptr
+= bytes_read
;
3428 if (! abbrev_number
)
3430 /* PR 19872: An abbrev number of 0 probably means that there is padding
3431 at the end of the .debug_abbrev section. Gold puts it there when
3432 performing an incremental link, for example. So do not generate
3433 an error, just return a NULL. */
3437 abbrev
= lookup_abbrev (abbrev_number
, abbrevs
);
3440 _bfd_error_handler (_("Dwarf Error: Could not find abbrev number %u."),
3442 bfd_set_error (bfd_error_bad_value
);
3446 amt
= sizeof (struct comp_unit
);
3447 unit
= (struct comp_unit
*) bfd_zalloc (abfd
, amt
);
3451 unit
->version
= version
;
3452 unit
->addr_size
= addr_size
;
3453 unit
->offset_size
= offset_size
;
3454 unit
->abbrevs
= abbrevs
;
3455 unit
->end_ptr
= end_ptr
;
3456 unit
->stash
= stash
;
3457 unit
->info_ptr_unit
= info_ptr_unit
;
3459 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3461 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
, end_ptr
);
3462 if (info_ptr
== NULL
)
3465 /* Store the data if it is of an attribute we want to keep in a
3466 partial symbol table. */
3469 case DW_AT_stmt_list
:
3471 unit
->line_offset
= attr
.u
.val
;
3475 if (is_str_attr (attr
.form
))
3476 unit
->name
= attr
.u
.str
;
3480 low_pc
= attr
.u
.val
;
3481 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
3482 this is the base address to use when reading location
3483 lists or range lists. */
3484 if (abbrev
->tag
== DW_TAG_compile_unit
)
3485 unit
->base_address
= low_pc
;
3489 high_pc
= attr
.u
.val
;
3490 high_pc_relative
= attr
.form
!= DW_FORM_addr
;
3494 if (!read_rangelist (unit
, &unit
->arange
, attr
.u
.val
))
3498 case DW_AT_comp_dir
:
3500 char *comp_dir
= attr
.u
.str
;
3502 /* PR 17512: file: 1fe726be. */
3503 if (! is_str_attr (attr
.form
))
3506 (_("Dwarf Error: DW_AT_comp_dir attribute encountered with a non-string form."));
3512 /* Irix 6.2 native cc prepends <machine>.: to the compilation
3513 directory, get rid of it. */
3514 char *cp
= strchr (comp_dir
, ':');
3516 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
3519 unit
->comp_dir
= comp_dir
;
3523 case DW_AT_language
:
3524 unit
->lang
= attr
.u
.val
;
3531 if (high_pc_relative
)
3535 if (!arange_add (unit
, &unit
->arange
, low_pc
, high_pc
))
3539 unit
->first_child_die_ptr
= info_ptr
;
3543 /* Return TRUE if UNIT may contain the address given by ADDR. When
3544 there are functions written entirely with inline asm statements, the
3545 range info in the compilation unit header may not be correct. We
3546 need to consult the line info table to see if a compilation unit
3547 really contains the given address. */
3550 comp_unit_contains_address (struct comp_unit
*unit
, bfd_vma addr
)
3552 struct arange
*arange
;
3557 arange
= &unit
->arange
;
3560 if (addr
>= arange
->low
&& addr
< arange
->high
)
3562 arange
= arange
->next
;
3569 /* If UNIT contains ADDR, set the output parameters to the values for
3570 the line containing ADDR. The output parameters, FILENAME_PTR,
3571 FUNCTION_PTR, and LINENUMBER_PTR, are pointers to the objects
3574 Returns the range of addresses covered by the entry that was used
3575 to fill in *LINENUMBER_PTR or 0 if it was not filled in. */
3578 comp_unit_find_nearest_line (struct comp_unit
*unit
,
3580 const char **filename_ptr
,
3581 struct funcinfo
**function_ptr
,
3582 unsigned int *linenumber_ptr
,
3583 unsigned int *discriminator_ptr
,
3584 struct dwarf2_debug
*stash
)
3591 if (! unit
->line_table
)
3593 if (! unit
->stmtlist
)
3599 unit
->line_table
= decode_line_info (unit
, stash
);
3601 if (! unit
->line_table
)
3607 if (unit
->first_child_die_ptr
< unit
->end_ptr
3608 && ! scan_unit_for_symbols (unit
))
3615 *function_ptr
= NULL
;
3616 func_p
= lookup_address_in_function_table (unit
, addr
, function_ptr
);
3617 if (func_p
&& (*function_ptr
)->tag
== DW_TAG_inlined_subroutine
)
3618 stash
->inliner_chain
= *function_ptr
;
3620 return lookup_address_in_line_info_table (unit
->line_table
, addr
,
3626 /* Check to see if line info is already decoded in a comp_unit.
3627 If not, decode it. Returns TRUE if no errors were encountered;
3631 comp_unit_maybe_decode_line_info (struct comp_unit
*unit
,
3632 struct dwarf2_debug
*stash
)
3637 if (! unit
->line_table
)
3639 if (! unit
->stmtlist
)
3645 unit
->line_table
= decode_line_info (unit
, stash
);
3647 if (! unit
->line_table
)
3653 if (unit
->first_child_die_ptr
< unit
->end_ptr
3654 && ! scan_unit_for_symbols (unit
))
3664 /* If UNIT contains SYM at ADDR, set the output parameters to the
3665 values for the line containing SYM. The output parameters,
3666 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
3669 Return TRUE if UNIT contains SYM, and no errors were encountered;
3673 comp_unit_find_line (struct comp_unit
*unit
,
3676 const char **filename_ptr
,
3677 unsigned int *linenumber_ptr
,
3678 struct dwarf2_debug
*stash
)
3680 if (!comp_unit_maybe_decode_line_info (unit
, stash
))
3683 if (sym
->flags
& BSF_FUNCTION
)
3684 return lookup_symbol_in_function_table (unit
, sym
, addr
,
3688 return lookup_symbol_in_variable_table (unit
, sym
, addr
,
3693 static struct funcinfo
*
3694 reverse_funcinfo_list (struct funcinfo
*head
)
3696 struct funcinfo
*rhead
;
3697 struct funcinfo
*temp
;
3699 for (rhead
= NULL
; head
; head
= temp
)
3701 temp
= head
->prev_func
;
3702 head
->prev_func
= rhead
;
3708 static struct varinfo
*
3709 reverse_varinfo_list (struct varinfo
*head
)
3711 struct varinfo
*rhead
;
3712 struct varinfo
*temp
;
3714 for (rhead
= NULL
; head
; head
= temp
)
3716 temp
= head
->prev_var
;
3717 head
->prev_var
= rhead
;
3723 /* Extract all interesting funcinfos and varinfos of a compilation
3724 unit into hash tables for faster lookup. Returns TRUE if no
3725 errors were enountered; FALSE otherwise. */
3728 comp_unit_hash_info (struct dwarf2_debug
*stash
,
3729 struct comp_unit
*unit
,
3730 struct info_hash_table
*funcinfo_hash_table
,
3731 struct info_hash_table
*varinfo_hash_table
)
3733 struct funcinfo
* each_func
;
3734 struct varinfo
* each_var
;
3735 bfd_boolean okay
= TRUE
;
3737 BFD_ASSERT (stash
->info_hash_status
!= STASH_INFO_HASH_DISABLED
);
3739 if (!comp_unit_maybe_decode_line_info (unit
, stash
))
3742 BFD_ASSERT (!unit
->cached
);
3744 /* To preserve the original search order, we went to visit the function
3745 infos in the reversed order of the list. However, making the list
3746 bi-directional use quite a bit of extra memory. So we reverse
3747 the list first, traverse the list in the now reversed order and
3748 finally reverse the list again to get back the original order. */
3749 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
3750 for (each_func
= unit
->function_table
;
3752 each_func
= each_func
->prev_func
)
3754 /* Skip nameless functions. */
3755 if (each_func
->name
)
3756 /* There is no need to copy name string into hash table as
3757 name string is either in the dwarf string buffer or
3758 info in the stash. */
3759 okay
= insert_info_hash_table (funcinfo_hash_table
, each_func
->name
,
3760 (void*) each_func
, FALSE
);
3762 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
3766 /* We do the same for variable infos. */
3767 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
3768 for (each_var
= unit
->variable_table
;
3770 each_var
= each_var
->prev_var
)
3772 /* Skip stack vars and vars with no files or names. */
3773 if (each_var
->stack
== 0
3774 && each_var
->file
!= NULL
3775 && each_var
->name
!= NULL
)
3776 /* There is no need to copy name string into hash table as
3777 name string is either in the dwarf string buffer or
3778 info in the stash. */
3779 okay
= insert_info_hash_table (varinfo_hash_table
, each_var
->name
,
3780 (void*) each_var
, FALSE
);
3783 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
3784 unit
->cached
= TRUE
;
3788 /* Locate a section in a BFD containing debugging info. The search starts
3789 from the section after AFTER_SEC, or from the first section in the BFD if
3790 AFTER_SEC is NULL. The search works by examining the names of the
3791 sections. There are three permissiable names. The first two are given
3792 by DEBUG_SECTIONS[debug_info] (whose standard DWARF2 names are .debug_info
3793 and .zdebug_info). The third is a prefix .gnu.linkonce.wi.
3794 This is a variation on the .debug_info section which has a checksum
3795 describing the contents appended onto the name. This allows the linker to
3796 identify and discard duplicate debugging sections for different
3797 compilation units. */
3798 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
3801 find_debug_info (bfd
*abfd
, const struct dwarf_debug_section
*debug_sections
,
3802 asection
*after_sec
)
3807 if (after_sec
== NULL
)
3809 look
= debug_sections
[debug_info
].uncompressed_name
;
3810 msec
= bfd_get_section_by_name (abfd
, look
);
3814 look
= debug_sections
[debug_info
].compressed_name
;
3817 msec
= bfd_get_section_by_name (abfd
, look
);
3822 for (msec
= abfd
->sections
; msec
!= NULL
; msec
= msec
->next
)
3823 if (CONST_STRNEQ (msec
->name
, GNU_LINKONCE_INFO
))
3829 for (msec
= after_sec
->next
; msec
!= NULL
; msec
= msec
->next
)
3831 look
= debug_sections
[debug_info
].uncompressed_name
;
3832 if (strcmp (msec
->name
, look
) == 0)
3835 look
= debug_sections
[debug_info
].compressed_name
;
3836 if (look
!= NULL
&& strcmp (msec
->name
, look
) == 0)
3839 if (CONST_STRNEQ (msec
->name
, GNU_LINKONCE_INFO
))
3846 /* Transfer VMAs from object file to separate debug file. */
3849 set_debug_vma (bfd
*orig_bfd
, bfd
*debug_bfd
)
3853 for (s
= orig_bfd
->sections
, d
= debug_bfd
->sections
;
3854 s
!= NULL
&& d
!= NULL
;
3855 s
= s
->next
, d
= d
->next
)
3857 if ((d
->flags
& SEC_DEBUGGING
) != 0)
3859 /* ??? Assumes 1-1 correspondence between sections in the
3861 if (strcmp (s
->name
, d
->name
) == 0)
3863 d
->output_section
= s
->output_section
;
3864 d
->output_offset
= s
->output_offset
;
3870 /* Unset vmas for adjusted sections in STASH. */
3873 unset_sections (struct dwarf2_debug
*stash
)
3876 struct adjusted_section
*p
;
3878 i
= stash
->adjusted_section_count
;
3879 p
= stash
->adjusted_sections
;
3880 for (; i
> 0; i
--, p
++)
3881 p
->section
->vma
= 0;
3884 /* Set VMAs for allocated and .debug_info sections in ORIG_BFD, a
3885 relocatable object file. VMAs are normally all zero in relocatable
3886 object files, so if we want to distinguish locations in sections by
3887 address we need to set VMAs so the sections do not overlap. We
3888 also set VMA on .debug_info so that when we have multiple
3889 .debug_info sections (or the linkonce variant) they also do not
3890 overlap. The multiple .debug_info sections make up a single
3891 logical section. ??? We should probably do the same for other
3895 place_sections (bfd
*orig_bfd
, struct dwarf2_debug
*stash
)
3898 struct adjusted_section
*p
;
3900 const char *debug_info_name
;
3902 if (stash
->adjusted_section_count
!= 0)
3904 i
= stash
->adjusted_section_count
;
3905 p
= stash
->adjusted_sections
;
3906 for (; i
> 0; i
--, p
++)
3907 p
->section
->vma
= p
->adj_vma
;
3911 debug_info_name
= stash
->debug_sections
[debug_info
].uncompressed_name
;
3918 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
3922 if ((sect
->output_section
!= NULL
3923 && sect
->output_section
!= sect
3924 && (sect
->flags
& SEC_DEBUGGING
) == 0)
3928 is_debug_info
= (strcmp (sect
->name
, debug_info_name
) == 0
3929 || CONST_STRNEQ (sect
->name
, GNU_LINKONCE_INFO
));
3931 if (!((sect
->flags
& SEC_ALLOC
) != 0 && abfd
== orig_bfd
)
3937 if (abfd
== stash
->bfd_ptr
)
3939 abfd
= stash
->bfd_ptr
;
3943 stash
->adjusted_section_count
= -1;
3946 bfd_vma last_vma
= 0, last_dwarf
= 0;
3947 bfd_size_type amt
= i
* sizeof (struct adjusted_section
);
3949 p
= (struct adjusted_section
*) bfd_malloc (amt
);
3953 stash
->adjusted_sections
= p
;
3954 stash
->adjusted_section_count
= i
;
3961 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
3966 if ((sect
->output_section
!= NULL
3967 && sect
->output_section
!= sect
3968 && (sect
->flags
& SEC_DEBUGGING
) == 0)
3972 is_debug_info
= (strcmp (sect
->name
, debug_info_name
) == 0
3973 || CONST_STRNEQ (sect
->name
, GNU_LINKONCE_INFO
));
3975 if (!((sect
->flags
& SEC_ALLOC
) != 0 && abfd
== orig_bfd
)
3979 sz
= sect
->rawsize
? sect
->rawsize
: sect
->size
;
3983 BFD_ASSERT (sect
->alignment_power
== 0);
3984 sect
->vma
= last_dwarf
;
3989 /* Align the new address to the current section
3991 last_vma
= ((last_vma
3992 + ~(-((bfd_vma
) 1 << sect
->alignment_power
)))
3993 & (-((bfd_vma
) 1 << sect
->alignment_power
)));
3994 sect
->vma
= last_vma
;
3999 p
->adj_vma
= sect
->vma
;
4002 if (abfd
== stash
->bfd_ptr
)
4004 abfd
= stash
->bfd_ptr
;
4008 if (orig_bfd
!= stash
->bfd_ptr
)
4009 set_debug_vma (orig_bfd
, stash
->bfd_ptr
);
4014 /* Look up a funcinfo by name using the given info hash table. If found,
4015 also update the locations pointed to by filename_ptr and linenumber_ptr.
4017 This function returns TRUE if a funcinfo that matches the given symbol
4018 and address is found with any error; otherwise it returns FALSE. */
4021 info_hash_lookup_funcinfo (struct info_hash_table
*hash_table
,
4024 const char **filename_ptr
,
4025 unsigned int *linenumber_ptr
)
4027 struct funcinfo
* each_func
;
4028 struct funcinfo
* best_fit
= NULL
;
4029 bfd_vma best_fit_len
= 0;
4030 struct info_list_node
*node
;
4031 struct arange
*arange
;
4032 const char *name
= bfd_asymbol_name (sym
);
4033 asection
*sec
= bfd_get_section (sym
);
4035 for (node
= lookup_info_hash_table (hash_table
, name
);
4039 each_func
= (struct funcinfo
*) node
->info
;
4040 for (arange
= &each_func
->arange
;
4042 arange
= arange
->next
)
4044 if ((!each_func
->sec
|| each_func
->sec
== sec
)
4045 && addr
>= arange
->low
4046 && addr
< arange
->high
4048 || arange
->high
- arange
->low
< best_fit_len
))
4050 best_fit
= each_func
;
4051 best_fit_len
= arange
->high
- arange
->low
;
4058 best_fit
->sec
= sec
;
4059 *filename_ptr
= best_fit
->file
;
4060 *linenumber_ptr
= best_fit
->line
;
4067 /* Look up a varinfo by name using the given info hash table. If found,
4068 also update the locations pointed to by filename_ptr and linenumber_ptr.
4070 This function returns TRUE if a varinfo that matches the given symbol
4071 and address is found with any error; otherwise it returns FALSE. */
4074 info_hash_lookup_varinfo (struct info_hash_table
*hash_table
,
4077 const char **filename_ptr
,
4078 unsigned int *linenumber_ptr
)
4080 const char *name
= bfd_asymbol_name (sym
);
4081 asection
*sec
= bfd_get_section (sym
);
4082 struct varinfo
* each
;
4083 struct info_list_node
*node
;
4085 for (node
= lookup_info_hash_table (hash_table
, name
);
4089 each
= (struct varinfo
*) node
->info
;
4090 if (each
->addr
== addr
4091 && (!each
->sec
|| each
->sec
== sec
))
4094 *filename_ptr
= each
->file
;
4095 *linenumber_ptr
= each
->line
;
4103 /* Update the funcinfo and varinfo info hash tables if they are
4104 not up to date. Returns TRUE if there is no error; otherwise
4105 returns FALSE and disable the info hash tables. */
4108 stash_maybe_update_info_hash_tables (struct dwarf2_debug
*stash
)
4110 struct comp_unit
*each
;
4112 /* Exit if hash tables are up-to-date. */
4113 if (stash
->all_comp_units
== stash
->hash_units_head
)
4116 if (stash
->hash_units_head
)
4117 each
= stash
->hash_units_head
->prev_unit
;
4119 each
= stash
->last_comp_unit
;
4123 if (!comp_unit_hash_info (stash
, each
, stash
->funcinfo_hash_table
,
4124 stash
->varinfo_hash_table
))
4126 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
4129 each
= each
->prev_unit
;
4132 stash
->hash_units_head
= stash
->all_comp_units
;
4136 /* Check consistency of info hash tables. This is for debugging only. */
4138 static void ATTRIBUTE_UNUSED
4139 stash_verify_info_hash_table (struct dwarf2_debug
*stash
)
4141 struct comp_unit
*each_unit
;
4142 struct funcinfo
*each_func
;
4143 struct varinfo
*each_var
;
4144 struct info_list_node
*node
;
4147 for (each_unit
= stash
->all_comp_units
;
4149 each_unit
= each_unit
->next_unit
)
4151 for (each_func
= each_unit
->function_table
;
4153 each_func
= each_func
->prev_func
)
4155 if (!each_func
->name
)
4157 node
= lookup_info_hash_table (stash
->funcinfo_hash_table
,
4161 while (node
&& !found
)
4163 found
= node
->info
== each_func
;
4169 for (each_var
= each_unit
->variable_table
;
4171 each_var
= each_var
->prev_var
)
4173 if (!each_var
->name
|| !each_var
->file
|| each_var
->stack
)
4175 node
= lookup_info_hash_table (stash
->varinfo_hash_table
,
4179 while (node
&& !found
)
4181 found
= node
->info
== each_var
;
4189 /* Check to see if we want to enable the info hash tables, which consume
4190 quite a bit of memory. Currently we only check the number times
4191 bfd_dwarf2_find_line is called. In the future, we may also want to
4192 take the number of symbols into account. */
4195 stash_maybe_enable_info_hash_tables (bfd
*abfd
, struct dwarf2_debug
*stash
)
4197 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_OFF
);
4199 if (stash
->info_hash_count
++ < STASH_INFO_HASH_TRIGGER
)
4202 /* FIXME: Maybe we should check the reduce_memory_overheads
4203 and optimize fields in the bfd_link_info structure ? */
4205 /* Create hash tables. */
4206 stash
->funcinfo_hash_table
= create_info_hash_table (abfd
);
4207 stash
->varinfo_hash_table
= create_info_hash_table (abfd
);
4208 if (!stash
->funcinfo_hash_table
|| !stash
->varinfo_hash_table
)
4210 /* Turn off info hashes if any allocation above fails. */
4211 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
4214 /* We need a forced update so that the info hash tables will
4215 be created even though there is no compilation unit. That
4216 happens if STASH_INFO_HASH_TRIGGER is 0. */
4217 stash_maybe_update_info_hash_tables (stash
);
4218 stash
->info_hash_status
= STASH_INFO_HASH_ON
;
4221 /* Find the file and line associated with a symbol and address using the
4222 info hash tables of a stash. If there is a match, the function returns
4223 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
4224 otherwise it returns FALSE. */
4227 stash_find_line_fast (struct dwarf2_debug
*stash
,
4230 const char **filename_ptr
,
4231 unsigned int *linenumber_ptr
)
4233 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_ON
);
4235 if (sym
->flags
& BSF_FUNCTION
)
4236 return info_hash_lookup_funcinfo (stash
->funcinfo_hash_table
, sym
, addr
,
4237 filename_ptr
, linenumber_ptr
);
4238 return info_hash_lookup_varinfo (stash
->varinfo_hash_table
, sym
, addr
,
4239 filename_ptr
, linenumber_ptr
);
4242 /* Save current section VMAs. */
4245 save_section_vma (const bfd
*abfd
, struct dwarf2_debug
*stash
)
4250 if (abfd
->section_count
== 0)
4252 stash
->sec_vma
= bfd_malloc (sizeof (*stash
->sec_vma
) * abfd
->section_count
);
4253 if (stash
->sec_vma
== NULL
)
4255 for (i
= 0, s
= abfd
->sections
; i
< abfd
->section_count
; i
++, s
= s
->next
)
4257 if (s
->output_section
!= NULL
)
4258 stash
->sec_vma
[i
] = s
->output_section
->vma
+ s
->output_offset
;
4260 stash
->sec_vma
[i
] = s
->vma
;
4265 /* Compare current section VMAs against those at the time the stash
4266 was created. If find_nearest_line is used in linker warnings or
4267 errors early in the link process, the debug info stash will be
4268 invalid for later calls. This is because we relocate debug info
4269 sections, so the stashed section contents depend on symbol values,
4270 which in turn depend on section VMAs. */
4273 section_vma_same (const bfd
*abfd
, const struct dwarf2_debug
*stash
)
4278 for (i
= 0, s
= abfd
->sections
; i
< abfd
->section_count
; i
++, s
= s
->next
)
4282 if (s
->output_section
!= NULL
)
4283 vma
= s
->output_section
->vma
+ s
->output_offset
;
4286 if (vma
!= stash
->sec_vma
[i
])
4292 /* Read debug information from DEBUG_BFD when DEBUG_BFD is specified.
4293 If DEBUG_BFD is not specified, we read debug information from ABFD
4294 or its gnu_debuglink. The results will be stored in PINFO.
4295 The function returns TRUE iff debug information is ready. */
4298 _bfd_dwarf2_slurp_debug_info (bfd
*abfd
, bfd
*debug_bfd
,
4299 const struct dwarf_debug_section
*debug_sections
,
4302 bfd_boolean do_place
)
4304 bfd_size_type amt
= sizeof (struct dwarf2_debug
);
4305 bfd_size_type total_size
;
4307 struct dwarf2_debug
*stash
= (struct dwarf2_debug
*) *pinfo
;
4311 if (stash
->orig_bfd
== abfd
4312 && section_vma_same (abfd
, stash
))
4314 /* Check that we did previously find some debug information
4315 before attempting to make use of it. */
4316 if (stash
->bfd_ptr
!= NULL
)
4318 if (do_place
&& !place_sections (abfd
, stash
))
4325 _bfd_dwarf2_cleanup_debug_info (abfd
, pinfo
);
4326 memset (stash
, 0, amt
);
4330 stash
= (struct dwarf2_debug
*) bfd_zalloc (abfd
, amt
);
4334 stash
->orig_bfd
= abfd
;
4335 stash
->debug_sections
= debug_sections
;
4336 stash
->syms
= symbols
;
4337 if (!save_section_vma (abfd
, stash
))
4342 if (debug_bfd
== NULL
)
4345 msec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
4346 if (msec
== NULL
&& abfd
== debug_bfd
)
4348 char * debug_filename
;
4350 debug_filename
= bfd_follow_build_id_debuglink (abfd
, DEBUGDIR
);
4351 if (debug_filename
== NULL
)
4352 debug_filename
= bfd_follow_gnu_debuglink (abfd
, DEBUGDIR
);
4354 if (debug_filename
== NULL
)
4355 /* No dwarf2 info, and no gnu_debuglink to follow.
4356 Note that at this point the stash has been allocated, but
4357 contains zeros. This lets future calls to this function
4358 fail more quickly. */
4361 /* Set BFD_DECOMPRESS to decompress debug sections. */
4362 if ((debug_bfd
= bfd_openr (debug_filename
, NULL
)) == NULL
4363 || !(debug_bfd
->flags
|= BFD_DECOMPRESS
,
4364 bfd_check_format (debug_bfd
, bfd_object
))
4365 || (msec
= find_debug_info (debug_bfd
,
4366 debug_sections
, NULL
)) == NULL
4367 || !bfd_generic_link_read_symbols (debug_bfd
))
4370 bfd_close (debug_bfd
);
4371 /* FIXME: Should we report our failure to follow the debuglink ? */
4372 free (debug_filename
);
4376 symbols
= bfd_get_outsymbols (debug_bfd
);
4377 stash
->syms
= symbols
;
4378 stash
->close_on_cleanup
= TRUE
;
4380 stash
->bfd_ptr
= debug_bfd
;
4383 && !place_sections (abfd
, stash
))
4386 /* There can be more than one DWARF2 info section in a BFD these
4387 days. First handle the easy case when there's only one. If
4388 there's more than one, try case two: none of the sections is
4389 compressed. In that case, read them all in and produce one
4390 large stash. We do this in two passes - in the first pass we
4391 just accumulate the section sizes, and in the second pass we
4392 read in the section's contents. (The allows us to avoid
4393 reallocing the data as we add sections to the stash.) If
4394 some or all sections are compressed, then do things the slow
4395 way, with a bunch of reallocs. */
4397 if (! find_debug_info (debug_bfd
, debug_sections
, msec
))
4399 /* Case 1: only one info section. */
4400 total_size
= msec
->size
;
4401 if (! read_section (debug_bfd
, &stash
->debug_sections
[debug_info
],
4403 &stash
->info_ptr_memory
, &total_size
))
4408 /* Case 2: multiple sections. */
4409 for (total_size
= 0;
4411 msec
= find_debug_info (debug_bfd
, debug_sections
, msec
))
4412 total_size
+= msec
->size
;
4414 stash
->info_ptr_memory
= (bfd_byte
*) bfd_malloc (total_size
);
4415 if (stash
->info_ptr_memory
== NULL
)
4419 for (msec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
4421 msec
= find_debug_info (debug_bfd
, debug_sections
, msec
))
4429 if (!(bfd_simple_get_relocated_section_contents
4430 (debug_bfd
, msec
, stash
->info_ptr_memory
+ total_size
,
4438 stash
->info_ptr
= stash
->info_ptr_memory
;
4439 stash
->info_ptr_end
= stash
->info_ptr
+ total_size
;
4440 stash
->sec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
4441 stash
->sec_info_ptr
= stash
->info_ptr
;
4445 /* Scan the debug information in PINFO looking for a DW_TAG_subprogram
4446 abbrev with a DW_AT_low_pc attached to it. Then lookup that same
4447 symbol in SYMBOLS and return the difference between the low_pc and
4448 the symbol's address. Returns 0 if no suitable symbol could be found. */
4451 _bfd_dwarf2_find_symbol_bias (asymbol
** symbols
, void ** pinfo
)
4453 struct dwarf2_debug
*stash
;
4454 struct comp_unit
* unit
;
4456 stash
= (struct dwarf2_debug
*) *pinfo
;
4461 for (unit
= stash
->all_comp_units
; unit
; unit
= unit
->next_unit
)
4463 struct funcinfo
* func
;
4465 if (unit
->function_table
== NULL
)
4467 if (unit
->line_table
== NULL
)
4468 unit
->line_table
= decode_line_info (unit
, stash
);
4469 if (unit
->line_table
!= NULL
)
4470 scan_unit_for_symbols (unit
);
4473 for (func
= unit
->function_table
; func
!= NULL
; func
= func
->prev_func
)
4474 if (func
->name
&& func
->arange
.low
)
4478 /* FIXME: Do we need to scan the aranges looking for the lowest pc value ? */
4480 for (psym
= symbols
; * psym
!= NULL
; psym
++)
4482 asymbol
* sym
= * psym
;
4484 if (sym
->flags
& BSF_FUNCTION
4485 && sym
->section
!= NULL
4486 && strcmp (sym
->name
, func
->name
) == 0)
4487 return ((bfd_signed_vma
) func
->arange
.low
) -
4488 ((bfd_signed_vma
) (sym
->value
+ sym
->section
->vma
));
4496 /* Find the source code location of SYMBOL. If SYMBOL is NULL
4497 then find the nearest source code location corresponding to
4498 the address SECTION + OFFSET.
4499 Returns TRUE if the line is found without error and fills in
4500 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
4501 NULL the FUNCTIONNAME_PTR is also filled in.
4502 SYMBOLS contains the symbol table for ABFD.
4503 DEBUG_SECTIONS contains the name of the dwarf debug sections.
4504 ADDR_SIZE is the number of bytes in the initial .debug_info length
4505 field and in the abbreviation offset, or zero to indicate that the
4506 default value should be used. */
4509 _bfd_dwarf2_find_nearest_line (bfd
*abfd
,
4514 const char **filename_ptr
,
4515 const char **functionname_ptr
,
4516 unsigned int *linenumber_ptr
,
4517 unsigned int *discriminator_ptr
,
4518 const struct dwarf_debug_section
*debug_sections
,
4519 unsigned int addr_size
,
4522 /* Read each compilation unit from the section .debug_info, and check
4523 to see if it contains the address we are searching for. If yes,
4524 lookup the address, and return the line number info. If no, go
4525 on to the next compilation unit.
4527 We keep a list of all the previously read compilation units, and
4528 a pointer to the next un-read compilation unit. Check the
4529 previously read units before reading more. */
4530 struct dwarf2_debug
*stash
;
4531 /* What address are we looking for? */
4533 struct comp_unit
* each
;
4534 struct funcinfo
*function
= NULL
;
4535 bfd_boolean found
= FALSE
;
4536 bfd_boolean do_line
;
4538 *filename_ptr
= NULL
;
4539 if (functionname_ptr
!= NULL
)
4540 *functionname_ptr
= NULL
;
4541 *linenumber_ptr
= 0;
4542 if (discriminator_ptr
)
4543 *discriminator_ptr
= 0;
4545 if (! _bfd_dwarf2_slurp_debug_info (abfd
, NULL
, debug_sections
,
4547 (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0))
4550 stash
= (struct dwarf2_debug
*) *pinfo
;
4552 do_line
= symbol
!= NULL
;
4555 BFD_ASSERT (section
== NULL
&& offset
== 0 && functionname_ptr
== NULL
);
4556 section
= bfd_get_section (symbol
);
4557 addr
= symbol
->value
;
4561 BFD_ASSERT (section
!= NULL
&& functionname_ptr
!= NULL
);
4564 /* If we have no SYMBOL but the section we're looking at is not a
4565 code section, then take a look through the list of symbols to see
4566 if we have a symbol at the address we're looking for. If we do
4567 then use this to look up line information. This will allow us to
4568 give file and line results for data symbols. We exclude code
4569 symbols here, if we look up a function symbol and then look up the
4570 line information we'll actually return the line number for the
4571 opening '{' rather than the function definition line. This is
4572 because looking up by symbol uses the line table, in which the
4573 first line for a function is usually the opening '{', while
4574 looking up the function by section + offset uses the
4575 DW_AT_decl_line from the function DW_TAG_subprogram for the line,
4576 which will be the line of the function name. */
4577 if (symbols
!= NULL
&& (section
->flags
& SEC_CODE
) == 0)
4581 for (tmp
= symbols
; (*tmp
) != NULL
; ++tmp
)
4582 if ((*tmp
)->the_bfd
== abfd
4583 && (*tmp
)->section
== section
4584 && (*tmp
)->value
== offset
4585 && ((*tmp
)->flags
& BSF_SECTION_SYM
) == 0)
4589 /* For local symbols, keep going in the hope we find a
4591 if ((symbol
->flags
& BSF_GLOBAL
) != 0)
4597 if (section
->output_section
)
4598 addr
+= section
->output_section
->vma
+ section
->output_offset
;
4600 addr
+= section
->vma
;
4602 /* A null info_ptr indicates that there is no dwarf2 info
4603 (or that an error occured while setting up the stash). */
4604 if (! stash
->info_ptr
)
4607 stash
->inliner_chain
= NULL
;
4609 /* Check the previously read comp. units first. */
4612 /* The info hash tables use quite a bit of memory. We may not want to
4613 always use them. We use some heuristics to decide if and when to
4615 if (stash
->info_hash_status
== STASH_INFO_HASH_OFF
)
4616 stash_maybe_enable_info_hash_tables (abfd
, stash
);
4618 /* Keep info hash table up to date if they are available. Note that we
4619 may disable the hash tables if there is any error duing update. */
4620 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
4621 stash_maybe_update_info_hash_tables (stash
);
4623 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
4625 found
= stash_find_line_fast (stash
, symbol
, addr
, filename_ptr
,
4632 /* Check the previously read comp. units first. */
4633 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
4634 if ((symbol
->flags
& BSF_FUNCTION
) == 0
4635 || each
->arange
.high
== 0
4636 || comp_unit_contains_address (each
, addr
))
4638 found
= comp_unit_find_line (each
, symbol
, addr
, filename_ptr
,
4639 linenumber_ptr
, stash
);
4647 bfd_vma min_range
= (bfd_vma
) -1;
4648 const char * local_filename
= NULL
;
4649 struct funcinfo
*local_function
= NULL
;
4650 unsigned int local_linenumber
= 0;
4651 unsigned int local_discriminator
= 0;
4653 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
4655 bfd_vma range
= (bfd_vma
) -1;
4657 found
= ((each
->arange
.high
== 0
4658 || comp_unit_contains_address (each
, addr
))
4659 && (range
= comp_unit_find_nearest_line (each
, addr
,
4663 & local_discriminator
,
4667 /* PRs 15935 15994: Bogus debug information may have provided us
4668 with an erroneous match. We attempt to counter this by
4669 selecting the match that has the smallest address range
4670 associated with it. (We are assuming that corrupt debug info
4671 will tend to result in extra large address ranges rather than
4672 extra small ranges).
4674 This does mean that we scan through all of the CUs associated
4675 with the bfd each time this function is called. But this does
4676 have the benefit of producing consistent results every time the
4677 function is called. */
4678 if (range
<= min_range
)
4680 if (filename_ptr
&& local_filename
)
4681 * filename_ptr
= local_filename
;
4683 function
= local_function
;
4684 if (discriminator_ptr
&& local_discriminator
)
4685 * discriminator_ptr
= local_discriminator
;
4686 if (local_linenumber
)
4687 * linenumber_ptr
= local_linenumber
;
4693 if (* linenumber_ptr
)
4700 /* The DWARF2 spec says that the initial length field, and the
4701 offset of the abbreviation table, should both be 4-byte values.
4702 However, some compilers do things differently. */
4705 BFD_ASSERT (addr_size
== 4 || addr_size
== 8);
4707 /* Read each remaining comp. units checking each as they are read. */
4708 while (stash
->info_ptr
< stash
->info_ptr_end
)
4711 unsigned int offset_size
= addr_size
;
4712 bfd_byte
*info_ptr_unit
= stash
->info_ptr
;
4714 length
= read_4_bytes (stash
->bfd_ptr
, stash
->info_ptr
, stash
->info_ptr_end
);
4715 /* A 0xffffff length is the DWARF3 way of indicating
4716 we use 64-bit offsets, instead of 32-bit offsets. */
4717 if (length
== 0xffffffff)
4720 length
= read_8_bytes (stash
->bfd_ptr
, stash
->info_ptr
+ 4, stash
->info_ptr_end
);
4721 stash
->info_ptr
+= 12;
4723 /* A zero length is the IRIX way of indicating 64-bit offsets,
4724 mostly because the 64-bit length will generally fit in 32
4725 bits, and the endianness helps. */
4726 else if (length
== 0)
4729 length
= read_4_bytes (stash
->bfd_ptr
, stash
->info_ptr
+ 4, stash
->info_ptr_end
);
4730 stash
->info_ptr
+= 8;
4732 /* In the absence of the hints above, we assume 32-bit DWARF2
4733 offsets even for targets with 64-bit addresses, because:
4734 a) most of the time these targets will not have generated
4735 more than 2Gb of debug info and so will not need 64-bit
4738 b) if they do use 64-bit offsets but they are not using
4739 the size hints that are tested for above then they are
4740 not conforming to the DWARF3 standard anyway. */
4741 else if (addr_size
== 8)
4744 stash
->info_ptr
+= 4;
4747 stash
->info_ptr
+= 4;
4754 if (stash
->info_ptr
+ length
> stash
->info_ptr_end
)
4757 each
= parse_comp_unit (stash
, length
, info_ptr_unit
,
4760 /* The dwarf information is damaged, don't trust it any
4764 new_ptr
= stash
->info_ptr
+ length
;
4765 /* PR 17512: file: 1500698c. */
4766 if (new_ptr
< stash
->info_ptr
)
4768 /* A corrupt length value - do not trust the info any more. */
4773 stash
->info_ptr
= new_ptr
;
4775 if (stash
->all_comp_units
)
4776 stash
->all_comp_units
->prev_unit
= each
;
4778 stash
->last_comp_unit
= each
;
4780 each
->next_unit
= stash
->all_comp_units
;
4781 stash
->all_comp_units
= each
;
4783 /* DW_AT_low_pc and DW_AT_high_pc are optional for
4784 compilation units. If we don't have them (i.e.,
4785 unit->high == 0), we need to consult the line info table
4786 to see if a compilation unit contains the given
4789 found
= (((symbol
->flags
& BSF_FUNCTION
) == 0
4790 || each
->arange
.high
== 0
4791 || comp_unit_contains_address (each
, addr
))
4792 && comp_unit_find_line (each
, symbol
, addr
,
4797 found
= ((each
->arange
.high
== 0
4798 || comp_unit_contains_address (each
, addr
))
4799 && comp_unit_find_nearest_line (each
, addr
,
4806 if ((bfd_vma
) (stash
->info_ptr
- stash
->sec_info_ptr
)
4807 == stash
->sec
->size
)
4809 stash
->sec
= find_debug_info (stash
->bfd_ptr
, debug_sections
,
4811 stash
->sec_info_ptr
= stash
->info_ptr
;
4822 if (!function
->is_linkage
)
4827 fun
= _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
4828 *filename_ptr
? NULL
: filename_ptr
,
4830 sec_vma
= section
->vma
;
4831 if (section
->output_section
!= NULL
)
4832 sec_vma
= section
->output_section
->vma
+ section
->output_offset
;
4834 && fun
->value
+ sec_vma
== function
->arange
.low
)
4835 function
->name
= *functionname_ptr
;
4836 /* Even if we didn't find a linkage name, say that we have
4837 to stop a repeated search of symbols. */
4838 function
->is_linkage
= TRUE
;
4840 *functionname_ptr
= function
->name
;
4842 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
4843 unset_sections (stash
);
4849 _bfd_dwarf2_find_inliner_info (bfd
*abfd ATTRIBUTE_UNUSED
,
4850 const char **filename_ptr
,
4851 const char **functionname_ptr
,
4852 unsigned int *linenumber_ptr
,
4855 struct dwarf2_debug
*stash
;
4857 stash
= (struct dwarf2_debug
*) *pinfo
;
4860 struct funcinfo
*func
= stash
->inliner_chain
;
4862 if (func
&& func
->caller_func
)
4864 *filename_ptr
= func
->caller_file
;
4865 *functionname_ptr
= func
->caller_func
->name
;
4866 *linenumber_ptr
= func
->caller_line
;
4867 stash
->inliner_chain
= func
->caller_func
;
4876 _bfd_dwarf2_cleanup_debug_info (bfd
*abfd
, void **pinfo
)
4878 struct dwarf2_debug
*stash
= (struct dwarf2_debug
*) *pinfo
;
4879 struct comp_unit
*each
;
4881 if (abfd
== NULL
|| stash
== NULL
)
4884 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
4886 struct abbrev_info
**abbrevs
= each
->abbrevs
;
4887 struct funcinfo
*function_table
= each
->function_table
;
4888 struct varinfo
*variable_table
= each
->variable_table
;
4891 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
4893 struct abbrev_info
*abbrev
= abbrevs
[i
];
4897 free (abbrev
->attrs
);
4898 abbrev
= abbrev
->next
;
4902 if (each
->line_table
)
4904 free (each
->line_table
->dirs
);
4905 free (each
->line_table
->files
);
4908 while (function_table
)
4910 if (function_table
->file
)
4912 free (function_table
->file
);
4913 function_table
->file
= NULL
;
4916 if (function_table
->caller_file
)
4918 free (function_table
->caller_file
);
4919 function_table
->caller_file
= NULL
;
4921 function_table
= function_table
->prev_func
;
4924 if (each
->lookup_funcinfo_table
)
4926 free (each
->lookup_funcinfo_table
);
4927 each
->lookup_funcinfo_table
= NULL
;
4930 while (variable_table
)
4932 if (variable_table
->file
)
4934 free (variable_table
->file
);
4935 variable_table
->file
= NULL
;
4938 variable_table
= variable_table
->prev_var
;
4942 if (stash
->funcinfo_hash_table
)
4943 bfd_hash_table_free (&stash
->funcinfo_hash_table
->base
);
4944 if (stash
->varinfo_hash_table
)
4945 bfd_hash_table_free (&stash
->varinfo_hash_table
->base
);
4946 if (stash
->dwarf_abbrev_buffer
)
4947 free (stash
->dwarf_abbrev_buffer
);
4948 if (stash
->dwarf_line_buffer
)
4949 free (stash
->dwarf_line_buffer
);
4950 if (stash
->dwarf_str_buffer
)
4951 free (stash
->dwarf_str_buffer
);
4952 if (stash
->dwarf_line_str_buffer
)
4953 free (stash
->dwarf_line_str_buffer
);
4954 if (stash
->dwarf_ranges_buffer
)
4955 free (stash
->dwarf_ranges_buffer
);
4956 if (stash
->info_ptr_memory
)
4957 free (stash
->info_ptr_memory
);
4958 if (stash
->close_on_cleanup
)
4959 bfd_close (stash
->bfd_ptr
);
4960 if (stash
->alt_dwarf_str_buffer
)
4961 free (stash
->alt_dwarf_str_buffer
);
4962 if (stash
->alt_dwarf_info_buffer
)
4963 free (stash
->alt_dwarf_info_buffer
);
4965 free (stash
->sec_vma
);
4966 if (stash
->adjusted_sections
)
4967 free (stash
->adjusted_sections
);
4968 if (stash
->alt_bfd_ptr
)
4969 bfd_close (stash
->alt_bfd_ptr
);
4972 /* Find the function to a particular section and offset,
4973 for error reporting. */
4976 _bfd_elf_find_function (bfd
*abfd
,
4980 const char **filename_ptr
,
4981 const char **functionname_ptr
)
4983 struct elf_find_function_cache
4985 asection
*last_section
;
4987 const char *filename
;
4988 bfd_size_type func_size
;
4991 if (symbols
== NULL
)
4994 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
4997 cache
= elf_tdata (abfd
)->elf_find_function_cache
;
5000 cache
= bfd_zalloc (abfd
, sizeof (*cache
));
5001 elf_tdata (abfd
)->elf_find_function_cache
= cache
;
5005 if (cache
->last_section
!= section
5006 || cache
->func
== NULL
5007 || offset
< cache
->func
->value
5008 || offset
>= cache
->func
->value
+ cache
->func_size
)
5013 /* ??? Given multiple file symbols, it is impossible to reliably
5014 choose the right file name for global symbols. File symbols are
5015 local symbols, and thus all file symbols must sort before any
5016 global symbols. The ELF spec may be interpreted to say that a
5017 file symbol must sort before other local symbols, but currently
5018 ld -r doesn't do this. So, for ld -r output, it is possible to
5019 make a better choice of file name for local symbols by ignoring
5020 file symbols appearing after a given local symbol. */
5021 enum { nothing_seen
, symbol_seen
, file_after_symbol_seen
} state
;
5022 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5026 state
= nothing_seen
;
5027 cache
->filename
= NULL
;
5029 cache
->func_size
= 0;
5030 cache
->last_section
= section
;
5032 for (p
= symbols
; *p
!= NULL
; p
++)
5038 if ((sym
->flags
& BSF_FILE
) != 0)
5041 if (state
== symbol_seen
)
5042 state
= file_after_symbol_seen
;
5046 size
= bed
->maybe_function_sym (sym
, section
, &code_off
);
5048 && code_off
<= offset
5049 && (code_off
> low_func
5050 || (code_off
== low_func
5051 && size
> cache
->func_size
)))
5054 cache
->func_size
= size
;
5055 cache
->filename
= NULL
;
5056 low_func
= code_off
;
5058 && ((sym
->flags
& BSF_LOCAL
) != 0
5059 || state
!= file_after_symbol_seen
))
5060 cache
->filename
= bfd_asymbol_name (file
);
5062 if (state
== nothing_seen
)
5063 state
= symbol_seen
;
5067 if (cache
->func
== NULL
)
5071 *filename_ptr
= cache
->filename
;
5072 if (functionname_ptr
)
5073 *functionname_ptr
= bfd_asymbol_name (cache
->func
);