2 Copyright (C) 1994-2017 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. This is used only to free the
130 bfd_byte
*info_ptr_memory
;
132 /* Pointer to the symbol table. */
135 /* Pointer to the .debug_abbrev section loaded into memory. */
136 bfd_byte
*dwarf_abbrev_buffer
;
138 /* Length of the loaded .debug_abbrev section. */
139 bfd_size_type dwarf_abbrev_size
;
141 /* Buffer for decode_line_info. */
142 bfd_byte
*dwarf_line_buffer
;
144 /* Length of the loaded .debug_line section. */
145 bfd_size_type dwarf_line_size
;
147 /* Pointer to the .debug_str section loaded into memory. */
148 bfd_byte
*dwarf_str_buffer
;
150 /* Length of the loaded .debug_str section. */
151 bfd_size_type dwarf_str_size
;
153 /* Pointer to the .debug_ranges section loaded into memory. */
154 bfd_byte
*dwarf_ranges_buffer
;
156 /* Length of the loaded .debug_ranges section. */
157 bfd_size_type dwarf_ranges_size
;
159 /* If the most recent call to bfd_find_nearest_line was given an
160 address in an inlined function, preserve a pointer into the
161 calling chain for subsequent calls to bfd_find_inliner_info to
163 struct funcinfo
*inliner_chain
;
165 /* Section VMAs at the time the stash was built. */
168 /* Number of sections whose VMA we must adjust. */
169 int adjusted_section_count
;
171 /* Array of sections with adjusted VMA. */
172 struct adjusted_section
*adjusted_sections
;
174 /* Number of times find_line is called. This is used in
175 the heuristic for enabling the info hash tables. */
178 #define STASH_INFO_HASH_TRIGGER 100
180 /* Hash table mapping symbol names to function infos. */
181 struct info_hash_table
*funcinfo_hash_table
;
183 /* Hash table mapping symbol names to variable infos. */
184 struct info_hash_table
*varinfo_hash_table
;
186 /* Head of comp_unit list in the last hash table update. */
187 struct comp_unit
*hash_units_head
;
189 /* Status of info hash. */
190 int info_hash_status
;
191 #define STASH_INFO_HASH_OFF 0
192 #define STASH_INFO_HASH_ON 1
193 #define STASH_INFO_HASH_DISABLED 2
195 /* True if we opened bfd_ptr. */
196 bfd_boolean close_on_cleanup
;
206 /* A minimal decoding of DWARF2 compilation units. We only decode
207 what's needed to get to the line number information. */
211 /* Chain the previously read compilation units. */
212 struct comp_unit
*next_unit
;
214 /* Likewise, chain the compilation unit read after this one.
215 The comp units are stored in reversed reading order. */
216 struct comp_unit
*prev_unit
;
218 /* Keep the bfd convenient (for memory allocation). */
221 /* The lowest and highest addresses contained in this compilation
222 unit as specified in the compilation unit header. */
223 struct arange arange
;
225 /* The DW_AT_name attribute (for error messages). */
228 /* The abbrev hash table. */
229 struct abbrev_info
**abbrevs
;
231 /* DW_AT_language. */
234 /* Note that an error was found by comp_unit_find_nearest_line. */
237 /* The DW_AT_comp_dir attribute. */
240 /* TRUE if there is a line number table associated with this comp. unit. */
243 /* Pointer to the current comp_unit so that we can find a given entry
245 bfd_byte
*info_ptr_unit
;
247 /* Pointer to the start of the debug section, for DW_FORM_ref_addr. */
248 bfd_byte
*sec_info_ptr
;
250 /* The offset into .debug_line of the line number table. */
251 unsigned long line_offset
;
253 /* Pointer to the first child die for the comp unit. */
254 bfd_byte
*first_child_die_ptr
;
256 /* The end of the comp unit. */
259 /* The decoded line number, NULL if not yet decoded. */
260 struct line_info_table
*line_table
;
262 /* A list of the functions found in this comp. unit. */
263 struct funcinfo
*function_table
;
265 /* A table of function information references searchable by address. */
266 struct lookup_funcinfo
*lookup_funcinfo_table
;
268 /* Number of functions in the function_table and sorted_function_table. */
269 bfd_size_type number_of_functions
;
271 /* A list of the variables found in this comp. unit. */
272 struct varinfo
*variable_table
;
274 /* Pointer to dwarf2_debug structure. */
275 struct dwarf2_debug
*stash
;
277 /* DWARF format version for this unit - from unit header. */
280 /* Address size for this unit - from unit header. */
281 unsigned char addr_size
;
283 /* Offset size for this unit - from unit header. */
284 unsigned char offset_size
;
286 /* Base address for this unit - from DW_AT_low_pc attribute of
287 DW_TAG_compile_unit DIE */
288 bfd_vma base_address
;
290 /* TRUE if symbols are cached in hash table for faster lookup by name. */
294 /* This data structure holds the information of an abbrev. */
297 unsigned int number
; /* Number identifying abbrev. */
298 enum dwarf_tag tag
; /* DWARF tag. */
299 int has_children
; /* Boolean. */
300 unsigned int num_attrs
; /* Number of attributes. */
301 struct attr_abbrev
*attrs
; /* An array of attribute descriptions. */
302 struct abbrev_info
*next
; /* Next in chain. */
307 enum dwarf_attribute name
;
308 enum dwarf_form form
;
311 /* Map of uncompressed DWARF debug section name to compressed one. It
312 is terminated by NULL uncompressed_name. */
314 const struct dwarf_debug_section dwarf_debug_sections
[] =
316 { ".debug_abbrev", ".zdebug_abbrev" },
317 { ".debug_aranges", ".zdebug_aranges" },
318 { ".debug_frame", ".zdebug_frame" },
319 { ".debug_info", ".zdebug_info" },
320 { ".debug_info", ".zdebug_info" },
321 { ".debug_line", ".zdebug_line" },
322 { ".debug_loc", ".zdebug_loc" },
323 { ".debug_macinfo", ".zdebug_macinfo" },
324 { ".debug_macro", ".zdebug_macro" },
325 { ".debug_pubnames", ".zdebug_pubnames" },
326 { ".debug_pubtypes", ".zdebug_pubtypes" },
327 { ".debug_ranges", ".zdebug_ranges" },
328 { ".debug_static_func", ".zdebug_static_func" },
329 { ".debug_static_vars", ".zdebug_static_vars" },
330 { ".debug_str", ".zdebug_str", },
331 { ".debug_str", ".zdebug_str", },
332 { ".debug_types", ".zdebug_types" },
333 /* GNU DWARF 1 extensions */
334 { ".debug_sfnames", ".zdebug_sfnames" },
335 { ".debug_srcinfo", ".zebug_srcinfo" },
336 /* SGI/MIPS DWARF 2 extensions */
337 { ".debug_funcnames", ".zdebug_funcnames" },
338 { ".debug_typenames", ".zdebug_typenames" },
339 { ".debug_varnames", ".zdebug_varnames" },
340 { ".debug_weaknames", ".zdebug_weaknames" },
344 /* NB/ Numbers in this enum must match up with indicies
345 into the dwarf_debug_sections[] array above. */
346 enum dwarf_debug_section_enum
373 #ifndef ABBREV_HASH_SIZE
374 #define ABBREV_HASH_SIZE 121
376 #ifndef ATTR_ALLOC_CHUNK
377 #define ATTR_ALLOC_CHUNK 4
380 /* Variable and function hash tables. This is used to speed up look-up
381 in lookup_symbol_in_var_table() and lookup_symbol_in_function_table().
382 In order to share code between variable and function infos, we use
383 a list of untyped pointer for all variable/function info associated with
384 a symbol. We waste a bit of memory for list with one node but that
385 simplifies the code. */
387 struct info_list_node
389 struct info_list_node
*next
;
393 /* Info hash entry. */
394 struct info_hash_entry
396 struct bfd_hash_entry root
;
397 struct info_list_node
*head
;
400 struct info_hash_table
402 struct bfd_hash_table base
;
405 /* Function to create a new entry in info hash table. */
407 static struct bfd_hash_entry
*
408 info_hash_table_newfunc (struct bfd_hash_entry
*entry
,
409 struct bfd_hash_table
*table
,
412 struct info_hash_entry
*ret
= (struct info_hash_entry
*) entry
;
414 /* Allocate the structure if it has not already been allocated by a
418 ret
= (struct info_hash_entry
*) bfd_hash_allocate (table
,
424 /* Call the allocation method of the base class. */
425 ret
= ((struct info_hash_entry
*)
426 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
428 /* Initialize the local fields here. */
432 return (struct bfd_hash_entry
*) ret
;
435 /* Function to create a new info hash table. It returns a pointer to the
436 newly created table or NULL if there is any error. We need abfd
437 solely for memory allocation. */
439 static struct info_hash_table
*
440 create_info_hash_table (bfd
*abfd
)
442 struct info_hash_table
*hash_table
;
444 hash_table
= ((struct info_hash_table
*)
445 bfd_alloc (abfd
, sizeof (struct info_hash_table
)));
449 if (!bfd_hash_table_init (&hash_table
->base
, info_hash_table_newfunc
,
450 sizeof (struct info_hash_entry
)))
452 bfd_release (abfd
, hash_table
);
459 /* Insert an info entry into an info hash table. We do not check of
460 duplicate entries. Also, the caller need to guarantee that the
461 right type of info in inserted as info is passed as a void* pointer.
462 This function returns true if there is no error. */
465 insert_info_hash_table (struct info_hash_table
*hash_table
,
470 struct info_hash_entry
*entry
;
471 struct info_list_node
*node
;
473 entry
= (struct info_hash_entry
*) bfd_hash_lookup (&hash_table
->base
,
478 node
= (struct info_list_node
*) bfd_hash_allocate (&hash_table
->base
,
484 node
->next
= entry
->head
;
490 /* Look up an info entry list from an info hash table. Return NULL
493 static struct info_list_node
*
494 lookup_info_hash_table (struct info_hash_table
*hash_table
, const char *key
)
496 struct info_hash_entry
*entry
;
498 entry
= (struct info_hash_entry
*) bfd_hash_lookup (&hash_table
->base
, key
,
500 return entry
? entry
->head
: NULL
;
503 /* Read a section into its appropriate place in the dwarf2_debug
504 struct (indicated by SECTION_BUFFER and SECTION_SIZE). If SYMS is
505 not NULL, use bfd_simple_get_relocated_section_contents to read the
506 section contents, otherwise use bfd_get_section_contents. Fail if
507 the located section does not contain at least OFFSET bytes. */
510 read_section (bfd
* abfd
,
511 const struct dwarf_debug_section
*sec
,
514 bfd_byte
** section_buffer
,
515 bfd_size_type
* section_size
)
518 const char *section_name
= sec
->uncompressed_name
;
520 /* The section may have already been read. */
521 if (*section_buffer
== NULL
)
523 msec
= bfd_get_section_by_name (abfd
, section_name
);
526 section_name
= sec
->compressed_name
;
527 if (section_name
!= NULL
)
528 msec
= bfd_get_section_by_name (abfd
, section_name
);
532 _bfd_error_handler (_("Dwarf Error: Can't find %s section."),
533 sec
->uncompressed_name
);
534 bfd_set_error (bfd_error_bad_value
);
538 *section_size
= msec
->rawsize
? msec
->rawsize
: msec
->size
;
542 = bfd_simple_get_relocated_section_contents (abfd
, msec
, NULL
, syms
);
543 if (! *section_buffer
)
548 *section_buffer
= (bfd_byte
*) bfd_malloc (*section_size
);
549 if (! *section_buffer
)
551 if (! bfd_get_section_contents (abfd
, msec
, *section_buffer
,
557 /* It is possible to get a bad value for the offset into the section
558 that the client wants. Validate it here to avoid trouble later. */
559 if (offset
!= 0 && offset
>= *section_size
)
561 /* xgettext: c-format */
562 _bfd_error_handler (_("Dwarf Error: Offset (%lu)"
563 " greater than or equal to %s size (%lu)."),
564 (long) offset
, section_name
, *section_size
);
565 bfd_set_error (bfd_error_bad_value
);
572 /* Read dwarf information from a buffer. */
575 read_1_byte (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_byte
*buf
, bfd_byte
*end
)
579 return bfd_get_8 (abfd
, buf
);
583 read_1_signed_byte (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_byte
*buf
, bfd_byte
*end
)
587 return bfd_get_signed_8 (abfd
, buf
);
591 read_2_bytes (bfd
*abfd
, bfd_byte
*buf
, bfd_byte
*end
)
595 return bfd_get_16 (abfd
, buf
);
599 read_4_bytes (bfd
*abfd
, bfd_byte
*buf
, bfd_byte
*end
)
603 return bfd_get_32 (abfd
, buf
);
607 read_8_bytes (bfd
*abfd
, bfd_byte
*buf
, bfd_byte
*end
)
611 return bfd_get_64 (abfd
, buf
);
615 read_n_bytes (bfd
*abfd ATTRIBUTE_UNUSED
,
618 unsigned int size ATTRIBUTE_UNUSED
)
620 if (buf
+ size
> end
)
625 /* Scans a NUL terminated string starting at BUF, returning a pointer to it.
626 Returns the number of characters in the string, *including* the NUL byte,
627 in BYTES_READ_PTR. This value is set even if the function fails. Bytes
628 at or beyond BUF_END will not be read. Returns NULL if there was a
629 problem, or if the string is empty. */
632 read_string (bfd
* abfd ATTRIBUTE_UNUSED
,
635 unsigned int * bytes_read_ptr
)
641 * bytes_read_ptr
= 0;
647 * bytes_read_ptr
= 1;
651 while (buf
< buf_end
)
654 * bytes_read_ptr
= buf
- str
;
658 * bytes_read_ptr
= buf
- str
;
662 /* Reads an offset from BUF and then locates the string at this offset
663 inside the debug string section. Returns a pointer to the string.
664 Returns the number of bytes read from BUF, *not* the length of the string,
665 in BYTES_READ_PTR. This value is set even if the function fails. Bytes
666 at or beyond BUF_END will not be read from BUF. Returns NULL if there was
667 a problem, or if the string is empty. Does not check for NUL termination
671 read_indirect_string (struct comp_unit
* unit
,
674 unsigned int * bytes_read_ptr
)
677 struct dwarf2_debug
*stash
= unit
->stash
;
680 if (buf
+ unit
->offset_size
> buf_end
)
682 * bytes_read_ptr
= 0;
686 if (unit
->offset_size
== 4)
687 offset
= read_4_bytes (unit
->abfd
, buf
, buf_end
);
689 offset
= read_8_bytes (unit
->abfd
, buf
, buf_end
);
691 *bytes_read_ptr
= unit
->offset_size
;
693 if (! read_section (unit
->abfd
, &stash
->debug_sections
[debug_str
],
695 &stash
->dwarf_str_buffer
, &stash
->dwarf_str_size
))
698 if (offset
>= stash
->dwarf_str_size
)
700 str
= (char *) stash
->dwarf_str_buffer
+ offset
;
706 /* Like read_indirect_string but uses a .debug_str located in
707 an alternate file pointed to by the .gnu_debugaltlink section.
708 Used to impement DW_FORM_GNU_strp_alt. */
711 read_alt_indirect_string (struct comp_unit
* unit
,
714 unsigned int * bytes_read_ptr
)
717 struct dwarf2_debug
*stash
= unit
->stash
;
720 if (buf
+ unit
->offset_size
> buf_end
)
722 * bytes_read_ptr
= 0;
726 if (unit
->offset_size
== 4)
727 offset
= read_4_bytes (unit
->abfd
, buf
, buf_end
);
729 offset
= read_8_bytes (unit
->abfd
, buf
, buf_end
);
731 *bytes_read_ptr
= unit
->offset_size
;
733 if (stash
->alt_bfd_ptr
== NULL
)
736 char * debug_filename
= bfd_follow_gnu_debugaltlink (unit
->abfd
, DEBUGDIR
);
738 if (debug_filename
== NULL
)
741 if ((debug_bfd
= bfd_openr (debug_filename
, NULL
)) == NULL
742 || ! bfd_check_format (debug_bfd
, bfd_object
))
745 bfd_close (debug_bfd
);
747 /* FIXME: Should we report our failure to follow the debuglink ? */
748 free (debug_filename
);
751 stash
->alt_bfd_ptr
= debug_bfd
;
754 if (! read_section (unit
->stash
->alt_bfd_ptr
,
755 stash
->debug_sections
+ debug_str_alt
,
756 NULL
, /* FIXME: Do we need to load alternate symbols ? */
758 &stash
->alt_dwarf_str_buffer
,
759 &stash
->alt_dwarf_str_size
))
762 if (offset
>= stash
->alt_dwarf_str_size
)
764 str
= (char *) stash
->alt_dwarf_str_buffer
+ offset
;
771 /* Resolve an alternate reference from UNIT at OFFSET.
772 Returns a pointer into the loaded alternate CU upon success
773 or NULL upon failure. */
776 read_alt_indirect_ref (struct comp_unit
* unit
,
779 struct dwarf2_debug
*stash
= unit
->stash
;
781 if (stash
->alt_bfd_ptr
== NULL
)
784 char * debug_filename
= bfd_follow_gnu_debugaltlink (unit
->abfd
, DEBUGDIR
);
786 if (debug_filename
== NULL
)
789 if ((debug_bfd
= bfd_openr (debug_filename
, NULL
)) == NULL
790 || ! bfd_check_format (debug_bfd
, bfd_object
))
793 bfd_close (debug_bfd
);
795 /* FIXME: Should we report our failure to follow the debuglink ? */
796 free (debug_filename
);
799 stash
->alt_bfd_ptr
= debug_bfd
;
802 if (! read_section (unit
->stash
->alt_bfd_ptr
,
803 stash
->debug_sections
+ debug_info_alt
,
804 NULL
, /* FIXME: Do we need to load alternate symbols ? */
806 &stash
->alt_dwarf_info_buffer
,
807 &stash
->alt_dwarf_info_size
))
810 if (offset
>= stash
->alt_dwarf_info_size
)
812 return stash
->alt_dwarf_info_buffer
+ offset
;
816 read_address (struct comp_unit
*unit
, bfd_byte
*buf
, bfd_byte
* buf_end
)
820 if (bfd_get_flavour (unit
->abfd
) == bfd_target_elf_flavour
)
821 signed_vma
= get_elf_backend_data (unit
->abfd
)->sign_extend_vma
;
823 if (buf
+ unit
->addr_size
> buf_end
)
828 switch (unit
->addr_size
)
831 return bfd_get_signed_64 (unit
->abfd
, buf
);
833 return bfd_get_signed_32 (unit
->abfd
, buf
);
835 return bfd_get_signed_16 (unit
->abfd
, buf
);
842 switch (unit
->addr_size
)
845 return bfd_get_64 (unit
->abfd
, buf
);
847 return bfd_get_32 (unit
->abfd
, buf
);
849 return bfd_get_16 (unit
->abfd
, buf
);
856 /* Lookup an abbrev_info structure in the abbrev hash table. */
858 static struct abbrev_info
*
859 lookup_abbrev (unsigned int number
, struct abbrev_info
**abbrevs
)
861 unsigned int hash_number
;
862 struct abbrev_info
*abbrev
;
864 hash_number
= number
% ABBREV_HASH_SIZE
;
865 abbrev
= abbrevs
[hash_number
];
869 if (abbrev
->number
== number
)
872 abbrev
= abbrev
->next
;
878 /* In DWARF version 2, the description of the debugging information is
879 stored in a separate .debug_abbrev section. Before we read any
880 dies from a section we read in all abbreviations and install them
883 static struct abbrev_info
**
884 read_abbrevs (bfd
*abfd
, bfd_uint64_t offset
, struct dwarf2_debug
*stash
)
886 struct abbrev_info
**abbrevs
;
887 bfd_byte
*abbrev_ptr
;
888 bfd_byte
*abbrev_end
;
889 struct abbrev_info
*cur_abbrev
;
890 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
891 unsigned int abbrev_form
, hash_number
;
894 if (! read_section (abfd
, &stash
->debug_sections
[debug_abbrev
],
896 &stash
->dwarf_abbrev_buffer
, &stash
->dwarf_abbrev_size
))
899 if (offset
>= stash
->dwarf_abbrev_size
)
902 amt
= sizeof (struct abbrev_info
*) * ABBREV_HASH_SIZE
;
903 abbrevs
= (struct abbrev_info
**) bfd_zalloc (abfd
, amt
);
907 abbrev_ptr
= stash
->dwarf_abbrev_buffer
+ offset
;
908 abbrev_end
= stash
->dwarf_abbrev_buffer
+ stash
->dwarf_abbrev_size
;
909 abbrev_number
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
, &bytes_read
,
911 abbrev_ptr
+= bytes_read
;
913 /* Loop until we reach an abbrev number of 0. */
914 while (abbrev_number
)
916 amt
= sizeof (struct abbrev_info
);
917 cur_abbrev
= (struct abbrev_info
*) bfd_zalloc (abfd
, amt
);
918 if (cur_abbrev
== NULL
)
921 /* Read in abbrev header. */
922 cur_abbrev
->number
= abbrev_number
;
923 cur_abbrev
->tag
= (enum dwarf_tag
)
924 _bfd_safe_read_leb128 (abfd
, abbrev_ptr
, &bytes_read
,
926 abbrev_ptr
+= bytes_read
;
927 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
, abbrev_end
);
930 /* Now read in declarations. */
931 abbrev_name
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
, &bytes_read
,
933 abbrev_ptr
+= bytes_read
;
934 abbrev_form
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
, &bytes_read
,
936 abbrev_ptr
+= bytes_read
;
940 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
942 struct attr_abbrev
*tmp
;
944 amt
= cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
;
945 amt
*= sizeof (struct attr_abbrev
);
946 tmp
= (struct attr_abbrev
*) bfd_realloc (cur_abbrev
->attrs
, amt
);
951 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
953 struct abbrev_info
*abbrev
= abbrevs
[i
];
957 free (abbrev
->attrs
);
958 abbrev
= abbrev
->next
;
963 cur_abbrev
->attrs
= tmp
;
966 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
967 = (enum dwarf_attribute
) abbrev_name
;
968 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
969 = (enum dwarf_form
) abbrev_form
;
970 abbrev_name
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
, &bytes_read
,
972 abbrev_ptr
+= bytes_read
;
973 abbrev_form
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
, &bytes_read
,
975 abbrev_ptr
+= bytes_read
;
978 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
979 cur_abbrev
->next
= abbrevs
[hash_number
];
980 abbrevs
[hash_number
] = cur_abbrev
;
982 /* Get next abbreviation.
983 Under Irix6 the abbreviations for a compilation unit are not
984 always properly terminated with an abbrev number of 0.
985 Exit loop if we encounter an abbreviation which we have
986 already read (which means we are about to read the abbreviations
987 for the next compile unit) or if the end of the abbreviation
989 if ((unsigned int) (abbrev_ptr
- stash
->dwarf_abbrev_buffer
)
990 >= stash
->dwarf_abbrev_size
)
992 abbrev_number
= _bfd_safe_read_leb128 (abfd
, abbrev_ptr
,
993 &bytes_read
, FALSE
, abbrev_end
);
994 abbrev_ptr
+= bytes_read
;
995 if (lookup_abbrev (abbrev_number
, abbrevs
) != NULL
)
1002 /* Returns true if the form is one which has a string value. */
1004 static inline bfd_boolean
1005 is_str_attr (enum dwarf_form form
)
1007 return form
== DW_FORM_string
|| form
== DW_FORM_strp
|| form
== DW_FORM_GNU_strp_alt
;
1010 /* Read and fill in the value of attribute ATTR as described by FORM.
1011 Read data starting from INFO_PTR, but never at or beyond INFO_PTR_END.
1012 Returns an updated INFO_PTR taking into account the amount of data read. */
1015 read_attribute_value (struct attribute
* attr
,
1017 struct comp_unit
* unit
,
1018 bfd_byte
* info_ptr
,
1019 bfd_byte
* info_ptr_end
)
1021 bfd
*abfd
= unit
->abfd
;
1022 unsigned int bytes_read
;
1023 struct dwarf_block
*blk
;
1026 if (info_ptr
>= info_ptr_end
&& form
!= DW_FORM_flag_present
)
1028 _bfd_error_handler (_("Dwarf Error: Info pointer extends beyond end of attributes"));
1029 bfd_set_error (bfd_error_bad_value
);
1033 attr
->form
= (enum dwarf_form
) form
;
1037 case DW_FORM_ref_addr
:
1038 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
1040 if (unit
->version
== 3 || unit
->version
== 4)
1042 if (unit
->offset_size
== 4)
1043 attr
->u
.val
= read_4_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1045 attr
->u
.val
= read_8_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1046 info_ptr
+= unit
->offset_size
;
1051 attr
->u
.val
= read_address (unit
, info_ptr
, info_ptr_end
);
1052 info_ptr
+= unit
->addr_size
;
1054 case DW_FORM_GNU_ref_alt
:
1055 case DW_FORM_sec_offset
:
1056 if (unit
->offset_size
== 4)
1057 attr
->u
.val
= read_4_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1059 attr
->u
.val
= read_8_bytes (unit
->abfd
, info_ptr
, info_ptr_end
);
1060 info_ptr
+= unit
->offset_size
;
1062 case DW_FORM_block2
:
1063 amt
= sizeof (struct dwarf_block
);
1064 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1067 blk
->size
= read_2_bytes (abfd
, info_ptr
, info_ptr_end
);
1069 blk
->data
= read_n_bytes (abfd
, info_ptr
, info_ptr_end
, blk
->size
);
1070 info_ptr
+= blk
->size
;
1073 case DW_FORM_block4
:
1074 amt
= sizeof (struct dwarf_block
);
1075 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1078 blk
->size
= read_4_bytes (abfd
, info_ptr
, info_ptr_end
);
1080 blk
->data
= read_n_bytes (abfd
, info_ptr
, info_ptr_end
, blk
->size
);
1081 info_ptr
+= blk
->size
;
1085 attr
->u
.val
= read_2_bytes (abfd
, info_ptr
, info_ptr_end
);
1089 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
, info_ptr_end
);
1093 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
, info_ptr_end
);
1096 case DW_FORM_string
:
1097 attr
->u
.str
= read_string (abfd
, info_ptr
, info_ptr_end
, &bytes_read
);
1098 info_ptr
+= bytes_read
;
1101 attr
->u
.str
= read_indirect_string (unit
, info_ptr
, info_ptr_end
, &bytes_read
);
1102 info_ptr
+= bytes_read
;
1104 case DW_FORM_GNU_strp_alt
:
1105 attr
->u
.str
= read_alt_indirect_string (unit
, info_ptr
, info_ptr_end
, &bytes_read
);
1106 info_ptr
+= bytes_read
;
1108 case DW_FORM_exprloc
:
1110 amt
= sizeof (struct dwarf_block
);
1111 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1114 blk
->size
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1115 FALSE
, info_ptr_end
);
1116 info_ptr
+= bytes_read
;
1117 blk
->data
= read_n_bytes (abfd
, info_ptr
, info_ptr_end
, blk
->size
);
1118 info_ptr
+= blk
->size
;
1121 case DW_FORM_block1
:
1122 amt
= sizeof (struct dwarf_block
);
1123 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1126 blk
->size
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1128 blk
->data
= read_n_bytes (abfd
, info_ptr
, info_ptr_end
, blk
->size
);
1129 info_ptr
+= blk
->size
;
1133 attr
->u
.val
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1137 attr
->u
.val
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1140 case DW_FORM_flag_present
:
1144 attr
->u
.sval
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1145 TRUE
, info_ptr_end
);
1146 info_ptr
+= bytes_read
;
1149 attr
->u
.val
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1150 FALSE
, info_ptr_end
);
1151 info_ptr
+= bytes_read
;
1154 attr
->u
.val
= read_1_byte (abfd
, info_ptr
, info_ptr_end
);
1158 attr
->u
.val
= read_2_bytes (abfd
, info_ptr
, info_ptr_end
);
1162 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
, info_ptr_end
);
1166 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
, info_ptr_end
);
1169 case DW_FORM_ref_sig8
:
1170 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
, info_ptr_end
);
1173 case DW_FORM_ref_udata
:
1174 attr
->u
.val
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1175 FALSE
, info_ptr_end
);
1176 info_ptr
+= bytes_read
;
1178 case DW_FORM_indirect
:
1179 form
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
1180 FALSE
, info_ptr_end
);
1181 info_ptr
+= bytes_read
;
1182 info_ptr
= read_attribute_value (attr
, form
, unit
, info_ptr
, info_ptr_end
);
1185 _bfd_error_handler (_("Dwarf Error: Invalid or unhandled FORM value: %#x."),
1187 bfd_set_error (bfd_error_bad_value
);
1193 /* Read an attribute described by an abbreviated attribute. */
1196 read_attribute (struct attribute
* attr
,
1197 struct attr_abbrev
* abbrev
,
1198 struct comp_unit
* unit
,
1199 bfd_byte
* info_ptr
,
1200 bfd_byte
* info_ptr_end
)
1202 attr
->name
= abbrev
->name
;
1203 info_ptr
= read_attribute_value (attr
, abbrev
->form
, unit
, info_ptr
, info_ptr_end
);
1207 /* Return whether DW_AT_name will return the same as DW_AT_linkage_name
1211 non_mangled (int lang
)
1221 case DW_LANG_Cobol74
:
1222 case DW_LANG_Cobol85
:
1223 case DW_LANG_Fortran77
:
1224 case DW_LANG_Pascal83
:
1234 /* Source line information table routines. */
1236 #define FILE_ALLOC_CHUNK 5
1237 #define DIR_ALLOC_CHUNK 5
1241 struct line_info
* prev_line
;
1245 unsigned int column
;
1246 unsigned int discriminator
;
1247 unsigned char op_index
;
1248 unsigned char end_sequence
; /* End of (sequential) code sequence. */
1259 struct line_sequence
1262 struct line_sequence
* prev_sequence
;
1263 struct line_info
* last_line
; /* Largest VMA. */
1264 struct line_info
** line_info_lookup
;
1265 bfd_size_type num_lines
;
1268 struct line_info_table
1271 unsigned int num_files
;
1272 unsigned int num_dirs
;
1273 unsigned int num_sequences
;
1276 struct fileinfo
* files
;
1277 struct line_sequence
* sequences
;
1278 struct line_info
* lcl_head
; /* Local head; used in 'add_line_info'. */
1281 /* Remember some information about each function. If the function is
1282 inlined (DW_TAG_inlined_subroutine) it may have two additional
1283 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
1284 source code location where this function was inlined. */
1288 /* Pointer to previous function in list of all functions. */
1289 struct funcinfo
* prev_func
;
1290 /* Pointer to function one scope higher. */
1291 struct funcinfo
* caller_func
;
1292 /* Source location file name where caller_func inlines this func. */
1294 /* Source location file name. */
1296 /* Source location line number where caller_func inlines this func. */
1298 /* Source location line number. */
1301 bfd_boolean is_linkage
;
1303 struct arange arange
;
1304 /* Where the symbol is defined. */
1308 struct lookup_funcinfo
1310 /* Function information corresponding to this lookup table entry. */
1311 struct funcinfo
* funcinfo
;
1313 /* The lowest address for this specific function. */
1316 /* The highest address of this function before the lookup table is sorted.
1317 The highest address of all prior functions after the lookup table is
1318 sorted, which is used for binary search. */
1324 /* Pointer to previous variable in list of all variables */
1325 struct varinfo
*prev_var
;
1326 /* Source location file name */
1328 /* Source location line number */
1333 /* Where the symbol is defined */
1335 /* Is this a stack variable? */
1336 unsigned int stack
: 1;
1339 /* Return TRUE if NEW_LINE should sort after LINE. */
1341 static inline bfd_boolean
1342 new_line_sorts_after (struct line_info
*new_line
, struct line_info
*line
)
1344 return (new_line
->address
> line
->address
1345 || (new_line
->address
== line
->address
1346 && (new_line
->op_index
> line
->op_index
1347 || (new_line
->op_index
== line
->op_index
1348 && new_line
->end_sequence
< line
->end_sequence
))));
1352 /* Adds a new entry to the line_info list in the line_info_table, ensuring
1353 that the list is sorted. Note that the line_info list is sorted from
1354 highest to lowest VMA (with possible duplicates); that is,
1355 line_info->prev_line always accesses an equal or smaller VMA. */
1358 add_line_info (struct line_info_table
*table
,
1360 unsigned char op_index
,
1363 unsigned int column
,
1364 unsigned int discriminator
,
1367 bfd_size_type amt
= sizeof (struct line_info
);
1368 struct line_sequence
* seq
= table
->sequences
;
1369 struct line_info
* info
= (struct line_info
*) bfd_alloc (table
->abfd
, amt
);
1374 /* Set member data of 'info'. */
1375 info
->prev_line
= NULL
;
1376 info
->address
= address
;
1377 info
->op_index
= op_index
;
1379 info
->column
= column
;
1380 info
->discriminator
= discriminator
;
1381 info
->end_sequence
= end_sequence
;
1383 if (filename
&& filename
[0])
1385 info
->filename
= (char *) bfd_alloc (table
->abfd
, strlen (filename
) + 1);
1386 if (info
->filename
== NULL
)
1388 strcpy (info
->filename
, filename
);
1391 info
->filename
= NULL
;
1393 /* Find the correct location for 'info'. Normally we will receive
1394 new line_info data 1) in order and 2) with increasing VMAs.
1395 However some compilers break the rules (cf. decode_line_info) and
1396 so we include some heuristics for quickly finding the correct
1397 location for 'info'. In particular, these heuristics optimize for
1398 the common case in which the VMA sequence that we receive is a
1399 list of locally sorted VMAs such as
1400 p...z a...j (where a < j < p < z)
1402 Note: table->lcl_head is used to head an *actual* or *possible*
1403 sub-sequence within the list (such as a...j) that is not directly
1404 headed by table->last_line
1406 Note: we may receive duplicate entries from 'decode_line_info'. */
1409 && seq
->last_line
->address
== address
1410 && seq
->last_line
->op_index
== op_index
1411 && seq
->last_line
->end_sequence
== end_sequence
)
1413 /* We only keep the last entry with the same address and end
1414 sequence. See PR ld/4986. */
1415 if (table
->lcl_head
== seq
->last_line
)
1416 table
->lcl_head
= info
;
1417 info
->prev_line
= seq
->last_line
->prev_line
;
1418 seq
->last_line
= info
;
1420 else if (!seq
|| seq
->last_line
->end_sequence
)
1422 /* Start a new line sequence. */
1423 amt
= sizeof (struct line_sequence
);
1424 seq
= (struct line_sequence
*) bfd_malloc (amt
);
1427 seq
->low_pc
= address
;
1428 seq
->prev_sequence
= table
->sequences
;
1429 seq
->last_line
= info
;
1430 table
->lcl_head
= info
;
1431 table
->sequences
= seq
;
1432 table
->num_sequences
++;
1434 else if (new_line_sorts_after (info
, seq
->last_line
))
1436 /* Normal case: add 'info' to the beginning of the current sequence. */
1437 info
->prev_line
= seq
->last_line
;
1438 seq
->last_line
= info
;
1440 /* lcl_head: initialize to head a *possible* sequence at the end. */
1441 if (!table
->lcl_head
)
1442 table
->lcl_head
= info
;
1444 else if (!new_line_sorts_after (info
, table
->lcl_head
)
1445 && (!table
->lcl_head
->prev_line
1446 || new_line_sorts_after (info
, table
->lcl_head
->prev_line
)))
1448 /* Abnormal but easy: lcl_head is the head of 'info'. */
1449 info
->prev_line
= table
->lcl_head
->prev_line
;
1450 table
->lcl_head
->prev_line
= info
;
1454 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head'
1455 are valid heads for 'info'. Reset 'lcl_head'. */
1456 struct line_info
* li2
= seq
->last_line
; /* Always non-NULL. */
1457 struct line_info
* li1
= li2
->prev_line
;
1461 if (!new_line_sorts_after (info
, li2
)
1462 && new_line_sorts_after (info
, li1
))
1465 li2
= li1
; /* always non-NULL */
1466 li1
= li1
->prev_line
;
1468 table
->lcl_head
= li2
;
1469 info
->prev_line
= table
->lcl_head
->prev_line
;
1470 table
->lcl_head
->prev_line
= info
;
1471 if (address
< seq
->low_pc
)
1472 seq
->low_pc
= address
;
1477 /* Extract a fully qualified filename from a line info table.
1478 The returned string has been malloc'ed and it is the caller's
1479 responsibility to free it. */
1482 concat_filename (struct line_info_table
*table
, unsigned int file
)
1486 if (file
- 1 >= table
->num_files
)
1488 /* FILE == 0 means unknown. */
1491 (_("Dwarf Error: mangled line number section (bad file number)."));
1492 return strdup ("<unknown>");
1495 filename
= table
->files
[file
- 1].name
;
1497 if (!IS_ABSOLUTE_PATH (filename
))
1499 char *dir_name
= NULL
;
1500 char *subdir_name
= NULL
;
1504 if (table
->files
[file
- 1].dir
1505 /* PR 17512: file: 0317e960. */
1506 && table
->files
[file
- 1].dir
<= table
->num_dirs
1507 /* PR 17512: file: 7f3d2e4b. */
1508 && table
->dirs
!= NULL
)
1509 subdir_name
= table
->dirs
[table
->files
[file
- 1].dir
- 1];
1511 if (!subdir_name
|| !IS_ABSOLUTE_PATH (subdir_name
))
1512 dir_name
= table
->comp_dir
;
1516 dir_name
= subdir_name
;
1521 return strdup (filename
);
1523 len
= strlen (dir_name
) + strlen (filename
) + 2;
1527 len
+= strlen (subdir_name
) + 1;
1528 name
= (char *) bfd_malloc (len
);
1530 sprintf (name
, "%s/%s/%s", dir_name
, subdir_name
, filename
);
1534 name
= (char *) bfd_malloc (len
);
1536 sprintf (name
, "%s/%s", dir_name
, filename
);
1542 return strdup (filename
);
1546 arange_add (const struct comp_unit
*unit
, struct arange
*first_arange
,
1547 bfd_vma low_pc
, bfd_vma high_pc
)
1549 struct arange
*arange
;
1551 /* Ignore empty ranges. */
1552 if (low_pc
== high_pc
)
1555 /* If the first arange is empty, use it. */
1556 if (first_arange
->high
== 0)
1558 first_arange
->low
= low_pc
;
1559 first_arange
->high
= high_pc
;
1563 /* Next see if we can cheaply extend an existing range. */
1564 arange
= first_arange
;
1567 if (low_pc
== arange
->high
)
1569 arange
->high
= high_pc
;
1572 if (high_pc
== arange
->low
)
1574 arange
->low
= low_pc
;
1577 arange
= arange
->next
;
1581 /* Need to allocate a new arange and insert it into the arange list.
1582 Order isn't significant, so just insert after the first arange. */
1583 arange
= (struct arange
*) bfd_alloc (unit
->abfd
, sizeof (*arange
));
1586 arange
->low
= low_pc
;
1587 arange
->high
= high_pc
;
1588 arange
->next
= first_arange
->next
;
1589 first_arange
->next
= arange
;
1593 /* Compare function for line sequences. */
1596 compare_sequences (const void* a
, const void* b
)
1598 const struct line_sequence
* seq1
= a
;
1599 const struct line_sequence
* seq2
= b
;
1601 /* Sort by low_pc as the primary key. */
1602 if (seq1
->low_pc
< seq2
->low_pc
)
1604 if (seq1
->low_pc
> seq2
->low_pc
)
1607 /* If low_pc values are equal, sort in reverse order of
1608 high_pc, so that the largest region comes first. */
1609 if (seq1
->last_line
->address
< seq2
->last_line
->address
)
1611 if (seq1
->last_line
->address
> seq2
->last_line
->address
)
1614 if (seq1
->last_line
->op_index
< seq2
->last_line
->op_index
)
1616 if (seq1
->last_line
->op_index
> seq2
->last_line
->op_index
)
1622 /* Construct the line information table for quick lookup. */
1625 build_line_info_table (struct line_info_table
* table
,
1626 struct line_sequence
* seq
)
1629 struct line_info
** line_info_lookup
;
1630 struct line_info
* each_line
;
1631 unsigned int num_lines
;
1632 unsigned int line_index
;
1634 if (seq
->line_info_lookup
!= NULL
)
1637 /* Count the number of line information entries. We could do this while
1638 scanning the debug information, but some entries may be added via
1639 lcl_head without having a sequence handy to increment the number of
1642 for (each_line
= seq
->last_line
; each_line
; each_line
= each_line
->prev_line
)
1648 /* Allocate space for the line information lookup table. */
1649 amt
= sizeof (struct line_info
*) * num_lines
;
1650 line_info_lookup
= (struct line_info
**) bfd_alloc (table
->abfd
, amt
);
1651 if (line_info_lookup
== NULL
)
1654 /* Create the line information lookup table. */
1655 line_index
= num_lines
;
1656 for (each_line
= seq
->last_line
; each_line
; each_line
= each_line
->prev_line
)
1657 line_info_lookup
[--line_index
] = each_line
;
1659 BFD_ASSERT (line_index
== 0);
1661 seq
->num_lines
= num_lines
;
1662 seq
->line_info_lookup
= line_info_lookup
;
1667 /* Sort the line sequences for quick lookup. */
1670 sort_line_sequences (struct line_info_table
* table
)
1673 struct line_sequence
* sequences
;
1674 struct line_sequence
* seq
;
1676 unsigned int num_sequences
= table
->num_sequences
;
1677 bfd_vma last_high_pc
;
1679 if (num_sequences
== 0)
1682 /* Allocate space for an array of sequences. */
1683 amt
= sizeof (struct line_sequence
) * num_sequences
;
1684 sequences
= (struct line_sequence
*) bfd_alloc (table
->abfd
, amt
);
1685 if (sequences
== NULL
)
1688 /* Copy the linked list into the array, freeing the original nodes. */
1689 seq
= table
->sequences
;
1690 for (n
= 0; n
< num_sequences
; n
++)
1692 struct line_sequence
* last_seq
= seq
;
1695 sequences
[n
].low_pc
= seq
->low_pc
;
1696 sequences
[n
].prev_sequence
= NULL
;
1697 sequences
[n
].last_line
= seq
->last_line
;
1698 sequences
[n
].line_info_lookup
= NULL
;
1699 sequences
[n
].num_lines
= 0;
1700 seq
= seq
->prev_sequence
;
1703 BFD_ASSERT (seq
== NULL
);
1705 qsort (sequences
, n
, sizeof (struct line_sequence
), compare_sequences
);
1707 /* Make the list binary-searchable by trimming overlapping entries
1708 and removing nested entries. */
1710 last_high_pc
= sequences
[0].last_line
->address
;
1711 for (n
= 1; n
< table
->num_sequences
; n
++)
1713 if (sequences
[n
].low_pc
< last_high_pc
)
1715 if (sequences
[n
].last_line
->address
<= last_high_pc
)
1716 /* Skip nested entries. */
1719 /* Trim overlapping entries. */
1720 sequences
[n
].low_pc
= last_high_pc
;
1722 last_high_pc
= sequences
[n
].last_line
->address
;
1723 if (n
> num_sequences
)
1725 /* Close up the gap. */
1726 sequences
[num_sequences
].low_pc
= sequences
[n
].low_pc
;
1727 sequences
[num_sequences
].last_line
= sequences
[n
].last_line
;
1732 table
->sequences
= sequences
;
1733 table
->num_sequences
= num_sequences
;
1737 /* Decode the line number information for UNIT. */
1739 static struct line_info_table
*
1740 decode_line_info (struct comp_unit
*unit
, struct dwarf2_debug
*stash
)
1742 bfd
*abfd
= unit
->abfd
;
1743 struct line_info_table
* table
;
1746 struct line_head lh
;
1747 unsigned int i
, bytes_read
, offset_size
;
1748 char *cur_file
, *cur_dir
;
1749 unsigned char op_code
, extended_op
, adj_opcode
;
1750 unsigned int exop_len
;
1753 if (! read_section (abfd
, &stash
->debug_sections
[debug_line
],
1754 stash
->syms
, unit
->line_offset
,
1755 &stash
->dwarf_line_buffer
, &stash
->dwarf_line_size
))
1758 amt
= sizeof (struct line_info_table
);
1759 table
= (struct line_info_table
*) bfd_alloc (abfd
, amt
);
1763 table
->comp_dir
= unit
->comp_dir
;
1765 table
->num_files
= 0;
1766 table
->files
= NULL
;
1768 table
->num_dirs
= 0;
1771 table
->num_sequences
= 0;
1772 table
->sequences
= NULL
;
1774 table
->lcl_head
= NULL
;
1776 if (stash
->dwarf_line_size
< 16)
1779 (_("Dwarf Error: Line info section is too small (%ld)"),
1780 (long) stash
->dwarf_line_size
);
1781 bfd_set_error (bfd_error_bad_value
);
1784 line_ptr
= stash
->dwarf_line_buffer
+ unit
->line_offset
;
1785 line_end
= stash
->dwarf_line_buffer
+ stash
->dwarf_line_size
;
1787 /* Read in the prologue. */
1788 lh
.total_length
= read_4_bytes (abfd
, line_ptr
, line_end
);
1791 if (lh
.total_length
== 0xffffffff)
1793 lh
.total_length
= read_8_bytes (abfd
, line_ptr
, line_end
);
1797 else if (lh
.total_length
== 0 && unit
->addr_size
== 8)
1799 /* Handle (non-standard) 64-bit DWARF2 formats. */
1800 lh
.total_length
= read_4_bytes (abfd
, line_ptr
, line_end
);
1805 if (lh
.total_length
> stash
->dwarf_line_size
)
1808 /* xgettext: c-format */
1809 (_("Dwarf Error: Line info data is bigger (0x%lx) than the section (0x%lx)"),
1810 (long) lh
.total_length
, (long) stash
->dwarf_line_size
);
1811 bfd_set_error (bfd_error_bad_value
);
1815 line_end
= line_ptr
+ lh
.total_length
;
1817 lh
.version
= read_2_bytes (abfd
, line_ptr
, line_end
);
1818 if (lh
.version
< 2 || lh
.version
> 4)
1821 (_("Dwarf Error: Unhandled .debug_line version %d."), lh
.version
);
1822 bfd_set_error (bfd_error_bad_value
);
1827 if (line_ptr
+ offset_size
+ (lh
.version
>=4 ? 6 : 5) >= line_end
)
1830 (_("Dwarf Error: Ran out of room reading prologue"));
1831 bfd_set_error (bfd_error_bad_value
);
1835 if (offset_size
== 4)
1836 lh
.prologue_length
= read_4_bytes (abfd
, line_ptr
, line_end
);
1838 lh
.prologue_length
= read_8_bytes (abfd
, line_ptr
, line_end
);
1839 line_ptr
+= offset_size
;
1841 lh
.minimum_instruction_length
= read_1_byte (abfd
, line_ptr
, line_end
);
1844 if (lh
.version
>= 4)
1846 lh
.maximum_ops_per_insn
= read_1_byte (abfd
, line_ptr
, line_end
);
1850 lh
.maximum_ops_per_insn
= 1;
1852 if (lh
.maximum_ops_per_insn
== 0)
1855 (_("Dwarf Error: Invalid maximum operations per instruction."));
1856 bfd_set_error (bfd_error_bad_value
);
1860 lh
.default_is_stmt
= read_1_byte (abfd
, line_ptr
, line_end
);
1863 lh
.line_base
= read_1_signed_byte (abfd
, line_ptr
, line_end
);
1866 lh
.line_range
= read_1_byte (abfd
, line_ptr
, line_end
);
1869 lh
.opcode_base
= read_1_byte (abfd
, line_ptr
, line_end
);
1872 if (line_ptr
+ (lh
.opcode_base
- 1) >= line_end
)
1874 _bfd_error_handler (_("Dwarf Error: Ran out of room reading opcodes"));
1875 bfd_set_error (bfd_error_bad_value
);
1879 amt
= lh
.opcode_base
* sizeof (unsigned char);
1880 lh
.standard_opcode_lengths
= (unsigned char *) bfd_alloc (abfd
, amt
);
1882 lh
.standard_opcode_lengths
[0] = 1;
1884 for (i
= 1; i
< lh
.opcode_base
; ++i
)
1886 lh
.standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
, line_end
);
1890 /* Read directory table. */
1891 while ((cur_dir
= read_string (abfd
, line_ptr
, line_end
, &bytes_read
)) != NULL
)
1893 line_ptr
+= bytes_read
;
1895 if ((table
->num_dirs
% DIR_ALLOC_CHUNK
) == 0)
1899 amt
= table
->num_dirs
+ DIR_ALLOC_CHUNK
;
1900 amt
*= sizeof (char *);
1902 tmp
= (char **) bfd_realloc (table
->dirs
, amt
);
1908 table
->dirs
[table
->num_dirs
++] = cur_dir
;
1911 line_ptr
+= bytes_read
;
1913 /* Read file name table. */
1914 while ((cur_file
= read_string (abfd
, line_ptr
, line_end
, &bytes_read
)) != NULL
)
1916 line_ptr
+= bytes_read
;
1918 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
1920 struct fileinfo
*tmp
;
1922 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
1923 amt
*= sizeof (struct fileinfo
);
1925 tmp
= (struct fileinfo
*) bfd_realloc (table
->files
, amt
);
1931 table
->files
[table
->num_files
].name
= cur_file
;
1932 table
->files
[table
->num_files
].dir
=
1933 _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
, FALSE
, line_end
);
1934 line_ptr
+= bytes_read
;
1935 table
->files
[table
->num_files
].time
1936 = _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
, FALSE
, line_end
);
1937 line_ptr
+= bytes_read
;
1938 table
->files
[table
->num_files
].size
1939 = _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
, FALSE
, line_end
);
1940 line_ptr
+= bytes_read
;
1944 line_ptr
+= bytes_read
;
1946 /* Read the statement sequences until there's nothing left. */
1947 while (line_ptr
< line_end
)
1949 /* State machine registers. */
1950 bfd_vma address
= 0;
1951 unsigned char op_index
= 0;
1952 char * filename
= table
->num_files
? concat_filename (table
, 1) : NULL
;
1953 unsigned int line
= 1;
1954 unsigned int column
= 0;
1955 unsigned int discriminator
= 0;
1956 int is_stmt
= lh
.default_is_stmt
;
1957 int end_sequence
= 0;
1958 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1959 compilers generate address sequences that are wildly out of
1960 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1961 for ia64-Linux). Thus, to determine the low and high
1962 address, we must compare on every DW_LNS_copy, etc. */
1963 bfd_vma low_pc
= (bfd_vma
) -1;
1964 bfd_vma high_pc
= 0;
1966 /* Decode the table. */
1967 while (! end_sequence
)
1969 op_code
= read_1_byte (abfd
, line_ptr
, line_end
);
1972 if (op_code
>= lh
.opcode_base
)
1974 /* Special operand. */
1975 adj_opcode
= op_code
- lh
.opcode_base
;
1976 if (lh
.line_range
== 0)
1978 if (lh
.maximum_ops_per_insn
== 1)
1979 address
+= (adj_opcode
/ lh
.line_range
1980 * lh
.minimum_instruction_length
);
1983 address
+= ((op_index
+ adj_opcode
/ lh
.line_range
)
1984 / lh
.maximum_ops_per_insn
1985 * lh
.minimum_instruction_length
);
1986 op_index
= ((op_index
+ adj_opcode
/ lh
.line_range
)
1987 % lh
.maximum_ops_per_insn
);
1989 line
+= lh
.line_base
+ (adj_opcode
% lh
.line_range
);
1990 /* Append row to matrix using current values. */
1991 if (!add_line_info (table
, address
, op_index
, filename
,
1992 line
, column
, discriminator
, 0))
1995 if (address
< low_pc
)
1997 if (address
> high_pc
)
2000 else switch (op_code
)
2002 case DW_LNS_extended_op
:
2003 exop_len
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2005 line_ptr
+= bytes_read
;
2006 extended_op
= read_1_byte (abfd
, line_ptr
, line_end
);
2009 switch (extended_op
)
2011 case DW_LNE_end_sequence
:
2013 if (!add_line_info (table
, address
, op_index
, filename
, line
,
2014 column
, discriminator
, end_sequence
))
2017 if (address
< low_pc
)
2019 if (address
> high_pc
)
2021 if (!arange_add (unit
, &unit
->arange
, low_pc
, high_pc
))
2024 case DW_LNE_set_address
:
2025 address
= read_address (unit
, line_ptr
, line_end
);
2027 line_ptr
+= unit
->addr_size
;
2029 case DW_LNE_define_file
:
2030 cur_file
= read_string (abfd
, line_ptr
, line_end
, &bytes_read
);
2031 line_ptr
+= bytes_read
;
2032 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
2034 struct fileinfo
*tmp
;
2036 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
2037 amt
*= sizeof (struct fileinfo
);
2038 tmp
= (struct fileinfo
*) bfd_realloc (table
->files
, amt
);
2043 table
->files
[table
->num_files
].name
= cur_file
;
2044 table
->files
[table
->num_files
].dir
=
2045 _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2047 line_ptr
+= bytes_read
;
2048 table
->files
[table
->num_files
].time
=
2049 _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2051 line_ptr
+= bytes_read
;
2052 table
->files
[table
->num_files
].size
=
2053 _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2055 line_ptr
+= bytes_read
;
2058 case DW_LNE_set_discriminator
:
2060 _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2062 line_ptr
+= bytes_read
;
2064 case DW_LNE_HP_source_file_correlation
:
2065 line_ptr
+= exop_len
- 1;
2069 (_("Dwarf Error: mangled line number section."));
2070 bfd_set_error (bfd_error_bad_value
);
2072 if (filename
!= NULL
)
2078 if (!add_line_info (table
, address
, op_index
,
2079 filename
, line
, column
, discriminator
, 0))
2082 if (address
< low_pc
)
2084 if (address
> high_pc
)
2087 case DW_LNS_advance_pc
:
2088 if (lh
.maximum_ops_per_insn
== 1)
2089 address
+= (lh
.minimum_instruction_length
2090 * _bfd_safe_read_leb128 (abfd
, line_ptr
,
2095 bfd_vma adjust
= _bfd_safe_read_leb128 (abfd
, line_ptr
,
2098 address
= ((op_index
+ adjust
) / lh
.maximum_ops_per_insn
2099 * lh
.minimum_instruction_length
);
2100 op_index
= (op_index
+ adjust
) % lh
.maximum_ops_per_insn
;
2102 line_ptr
+= bytes_read
;
2104 case DW_LNS_advance_line
:
2105 line
+= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2107 line_ptr
+= bytes_read
;
2109 case DW_LNS_set_file
:
2113 /* The file and directory tables are 0
2114 based, the references are 1 based. */
2115 file
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2117 line_ptr
+= bytes_read
;
2120 filename
= concat_filename (table
, file
);
2123 case DW_LNS_set_column
:
2124 column
= _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2126 line_ptr
+= bytes_read
;
2128 case DW_LNS_negate_stmt
:
2129 is_stmt
= (!is_stmt
);
2131 case DW_LNS_set_basic_block
:
2133 case DW_LNS_const_add_pc
:
2134 if (lh
.maximum_ops_per_insn
== 1)
2135 address
+= (lh
.minimum_instruction_length
2136 * ((255 - lh
.opcode_base
) / lh
.line_range
));
2139 bfd_vma adjust
= ((255 - lh
.opcode_base
) / lh
.line_range
);
2140 address
+= (lh
.minimum_instruction_length
2141 * ((op_index
+ adjust
)
2142 / lh
.maximum_ops_per_insn
));
2143 op_index
= (op_index
+ adjust
) % lh
.maximum_ops_per_insn
;
2146 case DW_LNS_fixed_advance_pc
:
2147 address
+= read_2_bytes (abfd
, line_ptr
, line_end
);
2152 /* Unknown standard opcode, ignore it. */
2153 for (i
= 0; i
< lh
.standard_opcode_lengths
[op_code
]; i
++)
2155 (void) _bfd_safe_read_leb128 (abfd
, line_ptr
, &bytes_read
,
2157 line_ptr
+= bytes_read
;
2167 if (sort_line_sequences (table
))
2171 if (table
->sequences
!= NULL
)
2172 free (table
->sequences
);
2173 if (table
->files
!= NULL
)
2174 free (table
->files
);
2175 if (table
->dirs
!= NULL
)
2180 /* If ADDR is within TABLE set the output parameters and return the
2181 range of addresses covered by the entry used to fill them out.
2182 Otherwise set * FILENAME_PTR to NULL and return 0.
2183 The parameters FILENAME_PTR, LINENUMBER_PTR and DISCRIMINATOR_PTR
2184 are pointers to the objects to be filled in. */
2187 lookup_address_in_line_info_table (struct line_info_table
*table
,
2189 const char **filename_ptr
,
2190 unsigned int *linenumber_ptr
,
2191 unsigned int *discriminator_ptr
)
2193 struct line_sequence
*seq
= NULL
;
2194 struct line_info
*info
;
2197 /* Binary search the array of sequences. */
2199 high
= table
->num_sequences
;
2202 mid
= (low
+ high
) / 2;
2203 seq
= &table
->sequences
[mid
];
2204 if (addr
< seq
->low_pc
)
2206 else if (addr
>= seq
->last_line
->address
)
2212 /* Check for a valid sequence. */
2213 if (!seq
|| addr
< seq
->low_pc
|| addr
>= seq
->last_line
->address
)
2216 if (!build_line_info_table (table
, seq
))
2219 /* Binary search the array of line information. */
2221 high
= seq
->num_lines
;
2225 mid
= (low
+ high
) / 2;
2226 info
= seq
->line_info_lookup
[mid
];
2227 if (addr
< info
->address
)
2229 else if (addr
>= seq
->line_info_lookup
[mid
+ 1]->address
)
2235 /* Check for a valid line information entry. */
2237 && addr
>= info
->address
2238 && addr
< seq
->line_info_lookup
[mid
+ 1]->address
2239 && !(info
->end_sequence
|| info
== seq
->last_line
))
2241 *filename_ptr
= info
->filename
;
2242 *linenumber_ptr
= info
->line
;
2243 if (discriminator_ptr
)
2244 *discriminator_ptr
= info
->discriminator
;
2245 return seq
->last_line
->address
- seq
->low_pc
;
2249 *filename_ptr
= NULL
;
2253 /* Read in the .debug_ranges section for future reference. */
2256 read_debug_ranges (struct comp_unit
* unit
)
2258 struct dwarf2_debug
* stash
= unit
->stash
;
2260 return read_section (unit
->abfd
, &stash
->debug_sections
[debug_ranges
],
2262 &stash
->dwarf_ranges_buffer
,
2263 &stash
->dwarf_ranges_size
);
2266 /* Function table functions. */
2269 compare_lookup_funcinfos (const void * a
, const void * b
)
2271 const struct lookup_funcinfo
* lookup1
= a
;
2272 const struct lookup_funcinfo
* lookup2
= b
;
2274 if (lookup1
->low_addr
< lookup2
->low_addr
)
2276 if (lookup1
->low_addr
> lookup2
->low_addr
)
2278 if (lookup1
->high_addr
< lookup2
->high_addr
)
2280 if (lookup1
->high_addr
> lookup2
->high_addr
)
2287 build_lookup_funcinfo_table (struct comp_unit
* unit
)
2289 struct lookup_funcinfo
*lookup_funcinfo_table
= unit
->lookup_funcinfo_table
;
2290 unsigned int number_of_functions
= unit
->number_of_functions
;
2291 struct funcinfo
*each
;
2292 struct lookup_funcinfo
*entry
;
2294 struct arange
*range
;
2295 bfd_vma low_addr
, high_addr
;
2297 if (lookup_funcinfo_table
|| number_of_functions
== 0)
2300 /* Create the function info lookup table. */
2301 lookup_funcinfo_table
= (struct lookup_funcinfo
*)
2302 bfd_malloc (number_of_functions
* sizeof (struct lookup_funcinfo
));
2303 if (lookup_funcinfo_table
== NULL
)
2306 /* Populate the function info lookup table. */
2307 func_index
= number_of_functions
;
2308 for (each
= unit
->function_table
; each
; each
= each
->prev_func
)
2310 entry
= &lookup_funcinfo_table
[--func_index
];
2311 entry
->funcinfo
= each
;
2313 /* Calculate the lowest and highest address for this function entry. */
2314 low_addr
= entry
->funcinfo
->arange
.low
;
2315 high_addr
= entry
->funcinfo
->arange
.high
;
2317 for (range
= entry
->funcinfo
->arange
.next
; range
; range
= range
->next
)
2319 if (range
->low
< low_addr
)
2320 low_addr
= range
->low
;
2321 if (range
->high
> high_addr
)
2322 high_addr
= range
->high
;
2325 entry
->low_addr
= low_addr
;
2326 entry
->high_addr
= high_addr
;
2329 BFD_ASSERT (func_index
== 0);
2331 /* Sort the function by address. */
2332 qsort (lookup_funcinfo_table
,
2333 number_of_functions
,
2334 sizeof (struct lookup_funcinfo
),
2335 compare_lookup_funcinfos
);
2337 /* Calculate the high watermark for each function in the lookup table. */
2338 high_addr
= lookup_funcinfo_table
[0].high_addr
;
2339 for (func_index
= 1; func_index
< number_of_functions
; func_index
++)
2341 entry
= &lookup_funcinfo_table
[func_index
];
2342 if (entry
->high_addr
> high_addr
)
2343 high_addr
= entry
->high_addr
;
2345 entry
->high_addr
= high_addr
;
2348 unit
->lookup_funcinfo_table
= lookup_funcinfo_table
;
2352 /* If ADDR is within UNIT's function tables, set FUNCTION_PTR, and return
2353 TRUE. Note that we need to find the function that has the smallest range
2354 that contains ADDR, to handle inlined functions without depending upon
2355 them being ordered in TABLE by increasing range. */
2358 lookup_address_in_function_table (struct comp_unit
*unit
,
2360 struct funcinfo
**function_ptr
)
2362 unsigned int number_of_functions
= unit
->number_of_functions
;
2363 struct lookup_funcinfo
* lookup_funcinfo
= NULL
;
2364 struct funcinfo
* funcinfo
= NULL
;
2365 struct funcinfo
* best_fit
= NULL
;
2366 bfd_vma best_fit_len
= 0;
2367 bfd_size_type low
, high
, mid
, first
;
2368 struct arange
*arange
;
2370 if (number_of_functions
== 0)
2373 if (!build_lookup_funcinfo_table (unit
))
2376 if (unit
->lookup_funcinfo_table
[number_of_functions
- 1].high_addr
< addr
)
2379 /* Find the first function in the lookup table which may contain the
2380 specified address. */
2382 high
= number_of_functions
;
2386 mid
= (low
+ high
) / 2;
2387 lookup_funcinfo
= &unit
->lookup_funcinfo_table
[mid
];
2388 if (addr
< lookup_funcinfo
->low_addr
)
2390 else if (addr
>= lookup_funcinfo
->high_addr
)
2396 /* Find the 'best' match for the address. The prior algorithm defined the
2397 best match as the function with the smallest address range containing
2398 the specified address. This definition should probably be changed to the
2399 innermost inline routine containing the address, but right now we want
2400 to get the same results we did before. */
2401 while (first
< number_of_functions
)
2403 if (addr
< unit
->lookup_funcinfo_table
[first
].low_addr
)
2405 funcinfo
= unit
->lookup_funcinfo_table
[first
].funcinfo
;
2407 for (arange
= &funcinfo
->arange
; arange
; arange
= arange
->next
)
2409 if (addr
< arange
->low
|| addr
>= arange
->high
)
2413 || arange
->high
- arange
->low
< best_fit_len
2414 /* The following comparison is designed to return the same
2415 match as the previous algorithm for routines which have the
2416 same best fit length. */
2417 || (arange
->high
- arange
->low
== best_fit_len
2418 && funcinfo
> best_fit
))
2420 best_fit
= funcinfo
;
2421 best_fit_len
= arange
->high
- arange
->low
;
2431 *function_ptr
= best_fit
;
2435 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
2436 and LINENUMBER_PTR, and return TRUE. */
2439 lookup_symbol_in_function_table (struct comp_unit
*unit
,
2442 const char **filename_ptr
,
2443 unsigned int *linenumber_ptr
)
2445 struct funcinfo
* each_func
;
2446 struct funcinfo
* best_fit
= NULL
;
2447 bfd_vma best_fit_len
= 0;
2448 struct arange
*arange
;
2449 const char *name
= bfd_asymbol_name (sym
);
2450 asection
*sec
= bfd_get_section (sym
);
2452 for (each_func
= unit
->function_table
;
2454 each_func
= each_func
->prev_func
)
2456 for (arange
= &each_func
->arange
;
2458 arange
= arange
->next
)
2460 if ((!each_func
->sec
|| each_func
->sec
== sec
)
2461 && addr
>= arange
->low
2462 && addr
< arange
->high
2464 && strcmp (name
, each_func
->name
) == 0
2466 || arange
->high
- arange
->low
< best_fit_len
))
2468 best_fit
= each_func
;
2469 best_fit_len
= arange
->high
- arange
->low
;
2476 best_fit
->sec
= sec
;
2477 *filename_ptr
= best_fit
->file
;
2478 *linenumber_ptr
= best_fit
->line
;
2485 /* Variable table functions. */
2487 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
2488 LINENUMBER_PTR, and return TRUE. */
2491 lookup_symbol_in_variable_table (struct comp_unit
*unit
,
2494 const char **filename_ptr
,
2495 unsigned int *linenumber_ptr
)
2497 const char *name
= bfd_asymbol_name (sym
);
2498 asection
*sec
= bfd_get_section (sym
);
2499 struct varinfo
* each
;
2501 for (each
= unit
->variable_table
; each
; each
= each
->prev_var
)
2502 if (each
->stack
== 0
2503 && each
->file
!= NULL
2504 && each
->name
!= NULL
2505 && each
->addr
== addr
2506 && (!each
->sec
|| each
->sec
== sec
)
2507 && strcmp (name
, each
->name
) == 0)
2513 *filename_ptr
= each
->file
;
2514 *linenumber_ptr
= each
->line
;
2522 find_abstract_instance_name (struct comp_unit
*unit
,
2523 struct attribute
*attr_ptr
,
2524 bfd_boolean
*is_linkage
)
2526 bfd
*abfd
= unit
->abfd
;
2528 bfd_byte
*info_ptr_end
;
2529 unsigned int abbrev_number
, bytes_read
, i
;
2530 struct abbrev_info
*abbrev
;
2531 bfd_uint64_t die_ref
= attr_ptr
->u
.val
;
2532 struct attribute attr
;
2535 /* DW_FORM_ref_addr can reference an entry in a different CU. It
2536 is an offset from the .debug_info section, not the current CU. */
2537 if (attr_ptr
->form
== DW_FORM_ref_addr
)
2539 /* We only support DW_FORM_ref_addr within the same file, so
2540 any relocations should be resolved already. */
2544 info_ptr
= unit
->sec_info_ptr
+ die_ref
;
2545 info_ptr_end
= unit
->end_ptr
;
2547 /* Now find the CU containing this pointer. */
2548 if (info_ptr
>= unit
->info_ptr_unit
&& info_ptr
< unit
->end_ptr
)
2552 /* Check other CUs to see if they contain the abbrev. */
2553 struct comp_unit
* u
;
2555 for (u
= unit
->prev_unit
; u
!= NULL
; u
= u
->prev_unit
)
2556 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
2560 for (u
= unit
->next_unit
; u
!= NULL
; u
= u
->next_unit
)
2561 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
2566 /* else FIXME: What do we do now ? */
2569 else if (attr_ptr
->form
== DW_FORM_GNU_ref_alt
)
2571 info_ptr
= read_alt_indirect_ref (unit
, die_ref
);
2572 if (info_ptr
== NULL
)
2575 (_("Dwarf Error: Unable to read alt ref %u."), die_ref
);
2576 bfd_set_error (bfd_error_bad_value
);
2579 info_ptr_end
= unit
->stash
->alt_dwarf_info_buffer
+ unit
->stash
->alt_dwarf_info_size
;
2581 /* FIXME: Do we need to locate the correct CU, in a similar
2582 fashion to the code in the DW_FORM_ref_addr case above ? */
2586 info_ptr
= unit
->info_ptr_unit
+ die_ref
;
2587 info_ptr_end
= unit
->end_ptr
;
2590 abbrev_number
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
2591 FALSE
, info_ptr_end
);
2592 info_ptr
+= bytes_read
;
2596 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
2600 (_("Dwarf Error: Could not find abbrev number %u."), abbrev_number
);
2601 bfd_set_error (bfd_error_bad_value
);
2605 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
2607 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
,
2608 info_ptr
, info_ptr_end
);
2609 if (info_ptr
== NULL
)
2614 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2616 if (name
== NULL
&& is_str_attr (attr
.form
))
2619 if (non_mangled (unit
->lang
))
2623 case DW_AT_specification
:
2624 name
= find_abstract_instance_name (unit
, &attr
, is_linkage
);
2626 case DW_AT_linkage_name
:
2627 case DW_AT_MIPS_linkage_name
:
2628 /* PR 16949: Corrupt debug info can place
2629 non-string forms into these attributes. */
2630 if (is_str_attr (attr
.form
))
2646 read_rangelist (struct comp_unit
*unit
, struct arange
*arange
,
2647 bfd_uint64_t offset
)
2649 bfd_byte
*ranges_ptr
;
2650 bfd_byte
*ranges_end
;
2651 bfd_vma base_address
= unit
->base_address
;
2653 if (! unit
->stash
->dwarf_ranges_buffer
)
2655 if (! read_debug_ranges (unit
))
2659 ranges_ptr
= unit
->stash
->dwarf_ranges_buffer
+ offset
;
2660 if (ranges_ptr
< unit
->stash
->dwarf_ranges_buffer
)
2662 ranges_end
= unit
->stash
->dwarf_ranges_buffer
+ unit
->stash
->dwarf_ranges_size
;
2669 /* PR 17512: file: 62cada7d. */
2670 if (ranges_ptr
+ 2 * unit
->addr_size
> ranges_end
)
2673 low_pc
= read_address (unit
, ranges_ptr
, ranges_end
);
2674 ranges_ptr
+= unit
->addr_size
;
2675 high_pc
= read_address (unit
, ranges_ptr
, ranges_end
);
2676 ranges_ptr
+= unit
->addr_size
;
2678 if (low_pc
== 0 && high_pc
== 0)
2680 if (low_pc
== -1UL && high_pc
!= -1UL)
2681 base_address
= high_pc
;
2684 if (!arange_add (unit
, arange
,
2685 base_address
+ low_pc
, base_address
+ high_pc
))
2692 /* DWARF2 Compilation unit functions. */
2694 /* Scan over each die in a comp. unit looking for functions to add
2695 to the function table and variables to the variable table. */
2698 scan_unit_for_symbols (struct comp_unit
*unit
)
2700 bfd
*abfd
= unit
->abfd
;
2701 bfd_byte
*info_ptr
= unit
->first_child_die_ptr
;
2702 bfd_byte
*info_ptr_end
= unit
->stash
->info_ptr_end
;
2703 int nesting_level
= 1;
2704 struct funcinfo
**nested_funcs
;
2705 int nested_funcs_size
;
2707 /* Maintain a stack of in-scope functions and inlined functions, which we
2708 can use to set the caller_func field. */
2709 nested_funcs_size
= 32;
2710 nested_funcs
= (struct funcinfo
**)
2711 bfd_malloc (nested_funcs_size
* sizeof (struct funcinfo
*));
2712 if (nested_funcs
== NULL
)
2714 nested_funcs
[nesting_level
] = 0;
2716 while (nesting_level
)
2718 unsigned int abbrev_number
, bytes_read
, i
;
2719 struct abbrev_info
*abbrev
;
2720 struct attribute attr
;
2721 struct funcinfo
*func
;
2722 struct varinfo
*var
;
2724 bfd_vma high_pc
= 0;
2725 bfd_boolean high_pc_relative
= FALSE
;
2727 /* PR 17512: file: 9f405d9d. */
2728 if (info_ptr
>= info_ptr_end
)
2731 abbrev_number
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
2732 FALSE
, info_ptr_end
);
2733 info_ptr
+= bytes_read
;
2735 if (! abbrev_number
)
2741 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
2744 static unsigned int previous_failed_abbrev
= -1U;
2746 /* Avoid multiple reports of the same missing abbrev. */
2747 if (abbrev_number
!= previous_failed_abbrev
)
2750 (_("Dwarf Error: Could not find abbrev number %u."),
2752 previous_failed_abbrev
= abbrev_number
;
2754 bfd_set_error (bfd_error_bad_value
);
2759 if (abbrev
->tag
== DW_TAG_subprogram
2760 || abbrev
->tag
== DW_TAG_entry_point
2761 || abbrev
->tag
== DW_TAG_inlined_subroutine
)
2763 bfd_size_type amt
= sizeof (struct funcinfo
);
2764 func
= (struct funcinfo
*) bfd_zalloc (abfd
, amt
);
2767 func
->tag
= abbrev
->tag
;
2768 func
->prev_func
= unit
->function_table
;
2769 unit
->function_table
= func
;
2770 unit
->number_of_functions
++;
2771 BFD_ASSERT (!unit
->cached
);
2773 if (func
->tag
== DW_TAG_inlined_subroutine
)
2774 for (i
= nesting_level
- 1; i
>= 1; i
--)
2775 if (nested_funcs
[i
])
2777 func
->caller_func
= nested_funcs
[i
];
2780 nested_funcs
[nesting_level
] = func
;
2785 if (abbrev
->tag
== DW_TAG_variable
)
2787 bfd_size_type amt
= sizeof (struct varinfo
);
2788 var
= (struct varinfo
*) bfd_zalloc (abfd
, amt
);
2791 var
->tag
= abbrev
->tag
;
2793 var
->prev_var
= unit
->variable_table
;
2794 unit
->variable_table
= var
;
2795 /* PR 18205: Missing debug information can cause this
2796 var to be attached to an already cached unit. */
2799 /* No inline function in scope at this nesting level. */
2800 nested_funcs
[nesting_level
] = 0;
2803 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
2805 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
, info_ptr_end
);
2806 if (info_ptr
== NULL
)
2813 case DW_AT_call_file
:
2814 func
->caller_file
= concat_filename (unit
->line_table
,
2818 case DW_AT_call_line
:
2819 func
->caller_line
= attr
.u
.val
;
2822 case DW_AT_abstract_origin
:
2823 case DW_AT_specification
:
2824 func
->name
= find_abstract_instance_name (unit
, &attr
,
2829 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2831 if (func
->name
== NULL
&& is_str_attr (attr
.form
))
2833 func
->name
= attr
.u
.str
;
2834 if (non_mangled (unit
->lang
))
2835 func
->is_linkage
= TRUE
;
2839 case DW_AT_linkage_name
:
2840 case DW_AT_MIPS_linkage_name
:
2841 /* PR 16949: Corrupt debug info can place
2842 non-string forms into these attributes. */
2843 if (is_str_attr (attr
.form
))
2845 func
->name
= attr
.u
.str
;
2846 func
->is_linkage
= TRUE
;
2851 low_pc
= attr
.u
.val
;
2855 high_pc
= attr
.u
.val
;
2856 high_pc_relative
= attr
.form
!= DW_FORM_addr
;
2860 if (!read_rangelist (unit
, &func
->arange
, attr
.u
.val
))
2864 case DW_AT_decl_file
:
2865 func
->file
= concat_filename (unit
->line_table
,
2869 case DW_AT_decl_line
:
2870 func
->line
= attr
.u
.val
;
2882 var
->name
= attr
.u
.str
;
2885 case DW_AT_decl_file
:
2886 var
->file
= concat_filename (unit
->line_table
,
2890 case DW_AT_decl_line
:
2891 var
->line
= attr
.u
.val
;
2894 case DW_AT_external
:
2895 if (attr
.u
.val
!= 0)
2899 case DW_AT_location
:
2903 case DW_FORM_block1
:
2904 case DW_FORM_block2
:
2905 case DW_FORM_block4
:
2906 case DW_FORM_exprloc
:
2907 if (*attr
.u
.blk
->data
== DW_OP_addr
)
2911 /* Verify that DW_OP_addr is the only opcode in the
2912 location, in which case the block size will be 1
2913 plus the address size. */
2914 /* ??? For TLS variables, gcc can emit
2915 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
2916 which we don't handle here yet. */
2917 if (attr
.u
.blk
->size
== unit
->addr_size
+ 1U)
2918 var
->addr
= bfd_get (unit
->addr_size
* 8,
2920 attr
.u
.blk
->data
+ 1);
2935 if (high_pc_relative
)
2938 if (func
&& high_pc
!= 0)
2940 if (!arange_add (unit
, &func
->arange
, low_pc
, high_pc
))
2944 if (abbrev
->has_children
)
2948 if (nesting_level
>= nested_funcs_size
)
2950 struct funcinfo
**tmp
;
2952 nested_funcs_size
*= 2;
2953 tmp
= (struct funcinfo
**)
2954 bfd_realloc (nested_funcs
,
2955 nested_funcs_size
* sizeof (struct funcinfo
*));
2960 nested_funcs
[nesting_level
] = 0;
2964 free (nested_funcs
);
2968 free (nested_funcs
);
2972 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
2973 includes the compilation unit header that proceeds the DIE's, but
2974 does not include the length field that precedes each compilation
2975 unit header. END_PTR points one past the end of this comp unit.
2976 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
2978 This routine does not read the whole compilation unit; only enough
2979 to get to the line number information for the compilation unit. */
2981 static struct comp_unit
*
2982 parse_comp_unit (struct dwarf2_debug
*stash
,
2983 bfd_vma unit_length
,
2984 bfd_byte
*info_ptr_unit
,
2985 unsigned int offset_size
)
2987 struct comp_unit
* unit
;
2988 unsigned int version
;
2989 bfd_uint64_t abbrev_offset
= 0;
2990 unsigned int addr_size
;
2991 struct abbrev_info
** abbrevs
;
2992 unsigned int abbrev_number
, bytes_read
, i
;
2993 struct abbrev_info
*abbrev
;
2994 struct attribute attr
;
2995 bfd_byte
*info_ptr
= stash
->info_ptr
;
2996 bfd_byte
*end_ptr
= info_ptr
+ unit_length
;
2999 bfd_vma high_pc
= 0;
3000 bfd
*abfd
= stash
->bfd_ptr
;
3001 bfd_boolean high_pc_relative
= FALSE
;
3003 version
= read_2_bytes (abfd
, info_ptr
, end_ptr
);
3005 BFD_ASSERT (offset_size
== 4 || offset_size
== 8);
3006 if (offset_size
== 4)
3007 abbrev_offset
= read_4_bytes (abfd
, info_ptr
, end_ptr
);
3009 abbrev_offset
= read_8_bytes (abfd
, info_ptr
, end_ptr
);
3010 info_ptr
+= offset_size
;
3011 addr_size
= read_1_byte (abfd
, info_ptr
, end_ptr
);
3014 if (version
!= 2 && version
!= 3 && version
!= 4)
3016 /* PR 19872: A version number of 0 probably means that there is padding
3017 at the end of the .debug_info section. Gold puts it there when
3018 performing an incremental link, for example. So do not generate
3019 an error, just return a NULL. */
3023 (_("Dwarf Error: found dwarf version '%u', this reader"
3024 " only handles version 2, 3 and 4 information."), version
);
3025 bfd_set_error (bfd_error_bad_value
);
3030 if (addr_size
> sizeof (bfd_vma
))
3033 /* xgettext: c-format */
3034 (_("Dwarf Error: found address size '%u', this reader"
3035 " can not handle sizes greater than '%u'."),
3037 (unsigned int) sizeof (bfd_vma
));
3038 bfd_set_error (bfd_error_bad_value
);
3042 if (addr_size
!= 2 && addr_size
!= 4 && addr_size
!= 8)
3045 ("Dwarf Error: found address size '%u', this reader"
3046 " can only handle address sizes '2', '4' and '8'.", addr_size
);
3047 bfd_set_error (bfd_error_bad_value
);
3051 /* Read the abbrevs for this compilation unit into a table. */
3052 abbrevs
= read_abbrevs (abfd
, abbrev_offset
, stash
);
3056 abbrev_number
= _bfd_safe_read_leb128 (abfd
, info_ptr
, &bytes_read
,
3058 info_ptr
+= bytes_read
;
3059 if (! abbrev_number
)
3061 /* PR 19872: An abbrev number of 0 probably means that there is padding
3062 at the end of the .debug_abbrev section. Gold puts it there when
3063 performing an incremental link, for example. So do not generate
3064 an error, just return a NULL. */
3068 abbrev
= lookup_abbrev (abbrev_number
, abbrevs
);
3071 _bfd_error_handler (_("Dwarf Error: Could not find abbrev number %u."),
3073 bfd_set_error (bfd_error_bad_value
);
3077 amt
= sizeof (struct comp_unit
);
3078 unit
= (struct comp_unit
*) bfd_zalloc (abfd
, amt
);
3082 unit
->version
= version
;
3083 unit
->addr_size
= addr_size
;
3084 unit
->offset_size
= offset_size
;
3085 unit
->abbrevs
= abbrevs
;
3086 unit
->end_ptr
= end_ptr
;
3087 unit
->stash
= stash
;
3088 unit
->info_ptr_unit
= info_ptr_unit
;
3089 unit
->sec_info_ptr
= stash
->sec_info_ptr
;
3091 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3093 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
, end_ptr
);
3094 if (info_ptr
== NULL
)
3097 /* Store the data if it is of an attribute we want to keep in a
3098 partial symbol table. */
3101 case DW_AT_stmt_list
:
3103 unit
->line_offset
= attr
.u
.val
;
3107 unit
->name
= attr
.u
.str
;
3111 low_pc
= attr
.u
.val
;
3112 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
3113 this is the base address to use when reading location
3114 lists or range lists. */
3115 if (abbrev
->tag
== DW_TAG_compile_unit
)
3116 unit
->base_address
= low_pc
;
3120 high_pc
= attr
.u
.val
;
3121 high_pc_relative
= attr
.form
!= DW_FORM_addr
;
3125 if (!read_rangelist (unit
, &unit
->arange
, attr
.u
.val
))
3129 case DW_AT_comp_dir
:
3131 char *comp_dir
= attr
.u
.str
;
3133 /* PR 17512: file: 1fe726be. */
3134 if (! is_str_attr (attr
.form
))
3137 (_("Dwarf Error: DW_AT_comp_dir attribute encountered with a non-string form."));
3143 /* Irix 6.2 native cc prepends <machine>.: to the compilation
3144 directory, get rid of it. */
3145 char *cp
= strchr (comp_dir
, ':');
3147 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
3150 unit
->comp_dir
= comp_dir
;
3154 case DW_AT_language
:
3155 unit
->lang
= attr
.u
.val
;
3162 if (high_pc_relative
)
3166 if (!arange_add (unit
, &unit
->arange
, low_pc
, high_pc
))
3170 unit
->first_child_die_ptr
= info_ptr
;
3174 /* Return TRUE if UNIT may contain the address given by ADDR. When
3175 there are functions written entirely with inline asm statements, the
3176 range info in the compilation unit header may not be correct. We
3177 need to consult the line info table to see if a compilation unit
3178 really contains the given address. */
3181 comp_unit_contains_address (struct comp_unit
*unit
, bfd_vma addr
)
3183 struct arange
*arange
;
3188 arange
= &unit
->arange
;
3191 if (addr
>= arange
->low
&& addr
< arange
->high
)
3193 arange
= arange
->next
;
3200 /* If UNIT contains ADDR, set the output parameters to the values for
3201 the line containing ADDR. The output parameters, FILENAME_PTR,
3202 FUNCTION_PTR, and LINENUMBER_PTR, are pointers to the objects
3205 Returns the range of addresses covered by the entry that was used
3206 to fill in *LINENUMBER_PTR or 0 if it was not filled in. */
3209 comp_unit_find_nearest_line (struct comp_unit
*unit
,
3211 const char **filename_ptr
,
3212 struct funcinfo
**function_ptr
,
3213 unsigned int *linenumber_ptr
,
3214 unsigned int *discriminator_ptr
,
3215 struct dwarf2_debug
*stash
)
3222 if (! unit
->line_table
)
3224 if (! unit
->stmtlist
)
3230 unit
->line_table
= decode_line_info (unit
, stash
);
3232 if (! unit
->line_table
)
3238 if (unit
->first_child_die_ptr
< unit
->end_ptr
3239 && ! scan_unit_for_symbols (unit
))
3246 *function_ptr
= NULL
;
3247 func_p
= lookup_address_in_function_table (unit
, addr
, function_ptr
);
3248 if (func_p
&& (*function_ptr
)->tag
== DW_TAG_inlined_subroutine
)
3249 stash
->inliner_chain
= *function_ptr
;
3251 return lookup_address_in_line_info_table (unit
->line_table
, addr
,
3257 /* Check to see if line info is already decoded in a comp_unit.
3258 If not, decode it. Returns TRUE if no errors were encountered;
3262 comp_unit_maybe_decode_line_info (struct comp_unit
*unit
,
3263 struct dwarf2_debug
*stash
)
3268 if (! unit
->line_table
)
3270 if (! unit
->stmtlist
)
3276 unit
->line_table
= decode_line_info (unit
, stash
);
3278 if (! unit
->line_table
)
3284 if (unit
->first_child_die_ptr
< unit
->end_ptr
3285 && ! scan_unit_for_symbols (unit
))
3295 /* If UNIT contains SYM at ADDR, set the output parameters to the
3296 values for the line containing SYM. The output parameters,
3297 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
3300 Return TRUE if UNIT contains SYM, and no errors were encountered;
3304 comp_unit_find_line (struct comp_unit
*unit
,
3307 const char **filename_ptr
,
3308 unsigned int *linenumber_ptr
,
3309 struct dwarf2_debug
*stash
)
3311 if (!comp_unit_maybe_decode_line_info (unit
, stash
))
3314 if (sym
->flags
& BSF_FUNCTION
)
3315 return lookup_symbol_in_function_table (unit
, sym
, addr
,
3319 return lookup_symbol_in_variable_table (unit
, sym
, addr
,
3324 static struct funcinfo
*
3325 reverse_funcinfo_list (struct funcinfo
*head
)
3327 struct funcinfo
*rhead
;
3328 struct funcinfo
*temp
;
3330 for (rhead
= NULL
; head
; head
= temp
)
3332 temp
= head
->prev_func
;
3333 head
->prev_func
= rhead
;
3339 static struct varinfo
*
3340 reverse_varinfo_list (struct varinfo
*head
)
3342 struct varinfo
*rhead
;
3343 struct varinfo
*temp
;
3345 for (rhead
= NULL
; head
; head
= temp
)
3347 temp
= head
->prev_var
;
3348 head
->prev_var
= rhead
;
3354 /* Extract all interesting funcinfos and varinfos of a compilation
3355 unit into hash tables for faster lookup. Returns TRUE if no
3356 errors were enountered; FALSE otherwise. */
3359 comp_unit_hash_info (struct dwarf2_debug
*stash
,
3360 struct comp_unit
*unit
,
3361 struct info_hash_table
*funcinfo_hash_table
,
3362 struct info_hash_table
*varinfo_hash_table
)
3364 struct funcinfo
* each_func
;
3365 struct varinfo
* each_var
;
3366 bfd_boolean okay
= TRUE
;
3368 BFD_ASSERT (stash
->info_hash_status
!= STASH_INFO_HASH_DISABLED
);
3370 if (!comp_unit_maybe_decode_line_info (unit
, stash
))
3373 BFD_ASSERT (!unit
->cached
);
3375 /* To preserve the original search order, we went to visit the function
3376 infos in the reversed order of the list. However, making the list
3377 bi-directional use quite a bit of extra memory. So we reverse
3378 the list first, traverse the list in the now reversed order and
3379 finally reverse the list again to get back the original order. */
3380 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
3381 for (each_func
= unit
->function_table
;
3383 each_func
= each_func
->prev_func
)
3385 /* Skip nameless functions. */
3386 if (each_func
->name
)
3387 /* There is no need to copy name string into hash table as
3388 name string is either in the dwarf string buffer or
3389 info in the stash. */
3390 okay
= insert_info_hash_table (funcinfo_hash_table
, each_func
->name
,
3391 (void*) each_func
, FALSE
);
3393 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
3397 /* We do the same for variable infos. */
3398 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
3399 for (each_var
= unit
->variable_table
;
3401 each_var
= each_var
->prev_var
)
3403 /* Skip stack vars and vars with no files or names. */
3404 if (each_var
->stack
== 0
3405 && each_var
->file
!= NULL
3406 && each_var
->name
!= NULL
)
3407 /* There is no need to copy name string into hash table as
3408 name string is either in the dwarf string buffer or
3409 info in the stash. */
3410 okay
= insert_info_hash_table (varinfo_hash_table
, each_var
->name
,
3411 (void*) each_var
, FALSE
);
3414 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
3415 unit
->cached
= TRUE
;
3419 /* Locate a section in a BFD containing debugging info. The search starts
3420 from the section after AFTER_SEC, or from the first section in the BFD if
3421 AFTER_SEC is NULL. The search works by examining the names of the
3422 sections. There are three permissiable names. The first two are given
3423 by DEBUG_SECTIONS[debug_info] (whose standard DWARF2 names are .debug_info
3424 and .zdebug_info). The third is a prefix .gnu.linkonce.wi.
3425 This is a variation on the .debug_info section which has a checksum
3426 describing the contents appended onto the name. This allows the linker to
3427 identify and discard duplicate debugging sections for different
3428 compilation units. */
3429 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
3432 find_debug_info (bfd
*abfd
, const struct dwarf_debug_section
*debug_sections
,
3433 asection
*after_sec
)
3438 if (after_sec
== NULL
)
3440 look
= debug_sections
[debug_info
].uncompressed_name
;
3441 msec
= bfd_get_section_by_name (abfd
, look
);
3445 look
= debug_sections
[debug_info
].compressed_name
;
3448 msec
= bfd_get_section_by_name (abfd
, look
);
3453 for (msec
= abfd
->sections
; msec
!= NULL
; msec
= msec
->next
)
3454 if (CONST_STRNEQ (msec
->name
, GNU_LINKONCE_INFO
))
3460 for (msec
= after_sec
->next
; msec
!= NULL
; msec
= msec
->next
)
3462 look
= debug_sections
[debug_info
].uncompressed_name
;
3463 if (strcmp (msec
->name
, look
) == 0)
3466 look
= debug_sections
[debug_info
].compressed_name
;
3467 if (look
!= NULL
&& strcmp (msec
->name
, look
) == 0)
3470 if (CONST_STRNEQ (msec
->name
, GNU_LINKONCE_INFO
))
3477 /* Transfer VMAs from object file to separate debug file. */
3480 set_debug_vma (bfd
*orig_bfd
, bfd
*debug_bfd
)
3484 for (s
= orig_bfd
->sections
, d
= debug_bfd
->sections
;
3485 s
!= NULL
&& d
!= NULL
;
3486 s
= s
->next
, d
= d
->next
)
3488 if ((d
->flags
& SEC_DEBUGGING
) != 0)
3490 /* ??? Assumes 1-1 correspondence between sections in the
3492 if (strcmp (s
->name
, d
->name
) == 0)
3494 d
->output_section
= s
->output_section
;
3495 d
->output_offset
= s
->output_offset
;
3501 /* Unset vmas for adjusted sections in STASH. */
3504 unset_sections (struct dwarf2_debug
*stash
)
3507 struct adjusted_section
*p
;
3509 i
= stash
->adjusted_section_count
;
3510 p
= stash
->adjusted_sections
;
3511 for (; i
> 0; i
--, p
++)
3512 p
->section
->vma
= 0;
3515 /* Set VMAs for allocated and .debug_info sections in ORIG_BFD, a
3516 relocatable object file. VMAs are normally all zero in relocatable
3517 object files, so if we want to distinguish locations in sections by
3518 address we need to set VMAs so the sections do not overlap. We
3519 also set VMA on .debug_info so that when we have multiple
3520 .debug_info sections (or the linkonce variant) they also do not
3521 overlap. The multiple .debug_info sections make up a single
3522 logical section. ??? We should probably do the same for other
3526 place_sections (bfd
*orig_bfd
, struct dwarf2_debug
*stash
)
3529 struct adjusted_section
*p
;
3531 const char *debug_info_name
;
3533 if (stash
->adjusted_section_count
!= 0)
3535 i
= stash
->adjusted_section_count
;
3536 p
= stash
->adjusted_sections
;
3537 for (; i
> 0; i
--, p
++)
3538 p
->section
->vma
= p
->adj_vma
;
3542 debug_info_name
= stash
->debug_sections
[debug_info
].uncompressed_name
;
3549 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
3553 if ((sect
->output_section
!= NULL
3554 && sect
->output_section
!= sect
3555 && (sect
->flags
& SEC_DEBUGGING
) == 0)
3559 is_debug_info
= (strcmp (sect
->name
, debug_info_name
) == 0
3560 || CONST_STRNEQ (sect
->name
, GNU_LINKONCE_INFO
));
3562 if (!((sect
->flags
& SEC_ALLOC
) != 0 && abfd
== orig_bfd
)
3568 if (abfd
== stash
->bfd_ptr
)
3570 abfd
= stash
->bfd_ptr
;
3574 stash
->adjusted_section_count
= -1;
3577 bfd_vma last_vma
= 0, last_dwarf
= 0;
3578 bfd_size_type amt
= i
* sizeof (struct adjusted_section
);
3580 p
= (struct adjusted_section
*) bfd_malloc (amt
);
3584 stash
->adjusted_sections
= p
;
3585 stash
->adjusted_section_count
= i
;
3592 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
3597 if ((sect
->output_section
!= NULL
3598 && sect
->output_section
!= sect
3599 && (sect
->flags
& SEC_DEBUGGING
) == 0)
3603 is_debug_info
= (strcmp (sect
->name
, debug_info_name
) == 0
3604 || CONST_STRNEQ (sect
->name
, GNU_LINKONCE_INFO
));
3606 if (!((sect
->flags
& SEC_ALLOC
) != 0 && abfd
== orig_bfd
)
3610 sz
= sect
->rawsize
? sect
->rawsize
: sect
->size
;
3614 BFD_ASSERT (sect
->alignment_power
== 0);
3615 sect
->vma
= last_dwarf
;
3620 /* Align the new address to the current section
3622 last_vma
= ((last_vma
3623 + ~(-((bfd_vma
) 1 << sect
->alignment_power
)))
3624 & (-((bfd_vma
) 1 << sect
->alignment_power
)));
3625 sect
->vma
= last_vma
;
3630 p
->adj_vma
= sect
->vma
;
3633 if (abfd
== stash
->bfd_ptr
)
3635 abfd
= stash
->bfd_ptr
;
3639 if (orig_bfd
!= stash
->bfd_ptr
)
3640 set_debug_vma (orig_bfd
, stash
->bfd_ptr
);
3645 /* Look up a funcinfo by name using the given info hash table. If found,
3646 also update the locations pointed to by filename_ptr and linenumber_ptr.
3648 This function returns TRUE if a funcinfo that matches the given symbol
3649 and address is found with any error; otherwise it returns FALSE. */
3652 info_hash_lookup_funcinfo (struct info_hash_table
*hash_table
,
3655 const char **filename_ptr
,
3656 unsigned int *linenumber_ptr
)
3658 struct funcinfo
* each_func
;
3659 struct funcinfo
* best_fit
= NULL
;
3660 bfd_vma best_fit_len
= 0;
3661 struct info_list_node
*node
;
3662 struct arange
*arange
;
3663 const char *name
= bfd_asymbol_name (sym
);
3664 asection
*sec
= bfd_get_section (sym
);
3666 for (node
= lookup_info_hash_table (hash_table
, name
);
3670 each_func
= (struct funcinfo
*) node
->info
;
3671 for (arange
= &each_func
->arange
;
3673 arange
= arange
->next
)
3675 if ((!each_func
->sec
|| each_func
->sec
== sec
)
3676 && addr
>= arange
->low
3677 && addr
< arange
->high
3679 || arange
->high
- arange
->low
< best_fit_len
))
3681 best_fit
= each_func
;
3682 best_fit_len
= arange
->high
- arange
->low
;
3689 best_fit
->sec
= sec
;
3690 *filename_ptr
= best_fit
->file
;
3691 *linenumber_ptr
= best_fit
->line
;
3698 /* Look up a varinfo by name using the given info hash table. If found,
3699 also update the locations pointed to by filename_ptr and linenumber_ptr.
3701 This function returns TRUE if a varinfo that matches the given symbol
3702 and address is found with any error; otherwise it returns FALSE. */
3705 info_hash_lookup_varinfo (struct info_hash_table
*hash_table
,
3708 const char **filename_ptr
,
3709 unsigned int *linenumber_ptr
)
3711 const char *name
= bfd_asymbol_name (sym
);
3712 asection
*sec
= bfd_get_section (sym
);
3713 struct varinfo
* each
;
3714 struct info_list_node
*node
;
3716 for (node
= lookup_info_hash_table (hash_table
, name
);
3720 each
= (struct varinfo
*) node
->info
;
3721 if (each
->addr
== addr
3722 && (!each
->sec
|| each
->sec
== sec
))
3725 *filename_ptr
= each
->file
;
3726 *linenumber_ptr
= each
->line
;
3734 /* Update the funcinfo and varinfo info hash tables if they are
3735 not up to date. Returns TRUE if there is no error; otherwise
3736 returns FALSE and disable the info hash tables. */
3739 stash_maybe_update_info_hash_tables (struct dwarf2_debug
*stash
)
3741 struct comp_unit
*each
;
3743 /* Exit if hash tables are up-to-date. */
3744 if (stash
->all_comp_units
== stash
->hash_units_head
)
3747 if (stash
->hash_units_head
)
3748 each
= stash
->hash_units_head
->prev_unit
;
3750 each
= stash
->last_comp_unit
;
3754 if (!comp_unit_hash_info (stash
, each
, stash
->funcinfo_hash_table
,
3755 stash
->varinfo_hash_table
))
3757 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
3760 each
= each
->prev_unit
;
3763 stash
->hash_units_head
= stash
->all_comp_units
;
3767 /* Check consistency of info hash tables. This is for debugging only. */
3769 static void ATTRIBUTE_UNUSED
3770 stash_verify_info_hash_table (struct dwarf2_debug
*stash
)
3772 struct comp_unit
*each_unit
;
3773 struct funcinfo
*each_func
;
3774 struct varinfo
*each_var
;
3775 struct info_list_node
*node
;
3778 for (each_unit
= stash
->all_comp_units
;
3780 each_unit
= each_unit
->next_unit
)
3782 for (each_func
= each_unit
->function_table
;
3784 each_func
= each_func
->prev_func
)
3786 if (!each_func
->name
)
3788 node
= lookup_info_hash_table (stash
->funcinfo_hash_table
,
3792 while (node
&& !found
)
3794 found
= node
->info
== each_func
;
3800 for (each_var
= each_unit
->variable_table
;
3802 each_var
= each_var
->prev_var
)
3804 if (!each_var
->name
|| !each_var
->file
|| each_var
->stack
)
3806 node
= lookup_info_hash_table (stash
->varinfo_hash_table
,
3810 while (node
&& !found
)
3812 found
= node
->info
== each_var
;
3820 /* Check to see if we want to enable the info hash tables, which consume
3821 quite a bit of memory. Currently we only check the number times
3822 bfd_dwarf2_find_line is called. In the future, we may also want to
3823 take the number of symbols into account. */
3826 stash_maybe_enable_info_hash_tables (bfd
*abfd
, struct dwarf2_debug
*stash
)
3828 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_OFF
);
3830 if (stash
->info_hash_count
++ < STASH_INFO_HASH_TRIGGER
)
3833 /* FIXME: Maybe we should check the reduce_memory_overheads
3834 and optimize fields in the bfd_link_info structure ? */
3836 /* Create hash tables. */
3837 stash
->funcinfo_hash_table
= create_info_hash_table (abfd
);
3838 stash
->varinfo_hash_table
= create_info_hash_table (abfd
);
3839 if (!stash
->funcinfo_hash_table
|| !stash
->varinfo_hash_table
)
3841 /* Turn off info hashes if any allocation above fails. */
3842 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
3845 /* We need a forced update so that the info hash tables will
3846 be created even though there is no compilation unit. That
3847 happens if STASH_INFO_HASH_TRIGGER is 0. */
3848 stash_maybe_update_info_hash_tables (stash
);
3849 stash
->info_hash_status
= STASH_INFO_HASH_ON
;
3852 /* Find the file and line associated with a symbol and address using the
3853 info hash tables of a stash. If there is a match, the function returns
3854 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
3855 otherwise it returns FALSE. */
3858 stash_find_line_fast (struct dwarf2_debug
*stash
,
3861 const char **filename_ptr
,
3862 unsigned int *linenumber_ptr
)
3864 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_ON
);
3866 if (sym
->flags
& BSF_FUNCTION
)
3867 return info_hash_lookup_funcinfo (stash
->funcinfo_hash_table
, sym
, addr
,
3868 filename_ptr
, linenumber_ptr
);
3869 return info_hash_lookup_varinfo (stash
->varinfo_hash_table
, sym
, addr
,
3870 filename_ptr
, linenumber_ptr
);
3873 /* Save current section VMAs. */
3876 save_section_vma (const bfd
*abfd
, struct dwarf2_debug
*stash
)
3881 if (abfd
->section_count
== 0)
3883 stash
->sec_vma
= bfd_malloc (sizeof (*stash
->sec_vma
) * abfd
->section_count
);
3884 if (stash
->sec_vma
== NULL
)
3886 for (i
= 0, s
= abfd
->sections
; i
< abfd
->section_count
; i
++, s
= s
->next
)
3888 if (s
->output_section
!= NULL
)
3889 stash
->sec_vma
[i
] = s
->output_section
->vma
+ s
->output_offset
;
3891 stash
->sec_vma
[i
] = s
->vma
;
3896 /* Compare current section VMAs against those at the time the stash
3897 was created. If find_nearest_line is used in linker warnings or
3898 errors early in the link process, the debug info stash will be
3899 invalid for later calls. This is because we relocate debug info
3900 sections, so the stashed section contents depend on symbol values,
3901 which in turn depend on section VMAs. */
3904 section_vma_same (const bfd
*abfd
, const struct dwarf2_debug
*stash
)
3909 for (i
= 0, s
= abfd
->sections
; i
< abfd
->section_count
; i
++, s
= s
->next
)
3913 if (s
->output_section
!= NULL
)
3914 vma
= s
->output_section
->vma
+ s
->output_offset
;
3917 if (vma
!= stash
->sec_vma
[i
])
3923 /* Read debug information from DEBUG_BFD when DEBUG_BFD is specified.
3924 If DEBUG_BFD is not specified, we read debug information from ABFD
3925 or its gnu_debuglink. The results will be stored in PINFO.
3926 The function returns TRUE iff debug information is ready. */
3929 _bfd_dwarf2_slurp_debug_info (bfd
*abfd
, bfd
*debug_bfd
,
3930 const struct dwarf_debug_section
*debug_sections
,
3933 bfd_boolean do_place
)
3935 bfd_size_type amt
= sizeof (struct dwarf2_debug
);
3936 bfd_size_type total_size
;
3938 struct dwarf2_debug
*stash
= (struct dwarf2_debug
*) *pinfo
;
3942 if (stash
->orig_bfd
== abfd
3943 && section_vma_same (abfd
, stash
))
3945 /* Check that we did previously find some debug information
3946 before attempting to make use of it. */
3947 if (stash
->bfd_ptr
!= NULL
)
3949 if (do_place
&& !place_sections (abfd
, stash
))
3956 _bfd_dwarf2_cleanup_debug_info (abfd
, pinfo
);
3957 memset (stash
, 0, amt
);
3961 stash
= (struct dwarf2_debug
*) bfd_zalloc (abfd
, amt
);
3965 stash
->orig_bfd
= abfd
;
3966 stash
->debug_sections
= debug_sections
;
3967 stash
->syms
= symbols
;
3968 if (!save_section_vma (abfd
, stash
))
3973 if (debug_bfd
== NULL
)
3976 msec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
3977 if (msec
== NULL
&& abfd
== debug_bfd
)
3979 char * debug_filename
;
3981 debug_filename
= bfd_follow_build_id_debuglink (abfd
, DEBUGDIR
);
3982 if (debug_filename
== NULL
)
3983 debug_filename
= bfd_follow_gnu_debuglink (abfd
, DEBUGDIR
);
3985 if (debug_filename
== NULL
)
3986 /* No dwarf2 info, and no gnu_debuglink to follow.
3987 Note that at this point the stash has been allocated, but
3988 contains zeros. This lets future calls to this function
3989 fail more quickly. */
3992 /* Set BFD_DECOMPRESS to decompress debug sections. */
3993 if ((debug_bfd
= bfd_openr (debug_filename
, NULL
)) == NULL
3994 || !(debug_bfd
->flags
|= BFD_DECOMPRESS
,
3995 bfd_check_format (debug_bfd
, bfd_object
))
3996 || (msec
= find_debug_info (debug_bfd
,
3997 debug_sections
, NULL
)) == NULL
3998 || !bfd_generic_link_read_symbols (debug_bfd
))
4001 bfd_close (debug_bfd
);
4002 /* FIXME: Should we report our failure to follow the debuglink ? */
4003 free (debug_filename
);
4007 symbols
= bfd_get_outsymbols (debug_bfd
);
4008 stash
->syms
= symbols
;
4009 stash
->close_on_cleanup
= TRUE
;
4011 stash
->bfd_ptr
= debug_bfd
;
4014 && !place_sections (abfd
, stash
))
4017 /* There can be more than one DWARF2 info section in a BFD these
4018 days. First handle the easy case when there's only one. If
4019 there's more than one, try case two: none of the sections is
4020 compressed. In that case, read them all in and produce one
4021 large stash. We do this in two passes - in the first pass we
4022 just accumulate the section sizes, and in the second pass we
4023 read in the section's contents. (The allows us to avoid
4024 reallocing the data as we add sections to the stash.) If
4025 some or all sections are compressed, then do things the slow
4026 way, with a bunch of reallocs. */
4028 if (! find_debug_info (debug_bfd
, debug_sections
, msec
))
4030 /* Case 1: only one info section. */
4031 total_size
= msec
->size
;
4032 if (! read_section (debug_bfd
, &stash
->debug_sections
[debug_info
],
4034 &stash
->info_ptr_memory
, &total_size
))
4039 /* Case 2: multiple sections. */
4040 for (total_size
= 0;
4042 msec
= find_debug_info (debug_bfd
, debug_sections
, msec
))
4043 total_size
+= msec
->size
;
4045 stash
->info_ptr_memory
= (bfd_byte
*) bfd_malloc (total_size
);
4046 if (stash
->info_ptr_memory
== NULL
)
4050 for (msec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
4052 msec
= find_debug_info (debug_bfd
, debug_sections
, msec
))
4060 if (!(bfd_simple_get_relocated_section_contents
4061 (debug_bfd
, msec
, stash
->info_ptr_memory
+ total_size
,
4069 stash
->info_ptr
= stash
->info_ptr_memory
;
4070 stash
->info_ptr_end
= stash
->info_ptr
+ total_size
;
4071 stash
->sec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
4072 stash
->sec_info_ptr
= stash
->info_ptr
;
4076 /* Scan the debug information in PINFO looking for a DW_TAG_subprogram
4077 abbrev with a DW_AT_low_pc attached to it. Then lookup that same
4078 symbol in SYMBOLS and return the difference between the low_pc and
4079 the symbol's address. Returns 0 if no suitable symbol could be found. */
4082 _bfd_dwarf2_find_symbol_bias (asymbol
** symbols
, void ** pinfo
)
4084 struct dwarf2_debug
*stash
;
4085 struct comp_unit
* unit
;
4087 stash
= (struct dwarf2_debug
*) *pinfo
;
4092 for (unit
= stash
->all_comp_units
; unit
; unit
= unit
->next_unit
)
4094 struct funcinfo
* func
;
4096 if (unit
->function_table
== NULL
)
4098 if (unit
->line_table
== NULL
)
4099 unit
->line_table
= decode_line_info (unit
, stash
);
4100 if (unit
->line_table
!= NULL
)
4101 scan_unit_for_symbols (unit
);
4104 for (func
= unit
->function_table
; func
!= NULL
; func
= func
->prev_func
)
4105 if (func
->name
&& func
->arange
.low
)
4109 /* FIXME: Do we need to scan the aranges looking for the lowest pc value ? */
4111 for (psym
= symbols
; * psym
!= NULL
; psym
++)
4113 asymbol
* sym
= * psym
;
4115 if (sym
->flags
& BSF_FUNCTION
4116 && sym
->section
!= NULL
4117 && strcmp (sym
->name
, func
->name
) == 0)
4118 return ((bfd_signed_vma
) func
->arange
.low
) -
4119 ((bfd_signed_vma
) (sym
->value
+ sym
->section
->vma
));
4127 /* Find the source code location of SYMBOL. If SYMBOL is NULL
4128 then find the nearest source code location corresponding to
4129 the address SECTION + OFFSET.
4130 Returns TRUE if the line is found without error and fills in
4131 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
4132 NULL the FUNCTIONNAME_PTR is also filled in.
4133 SYMBOLS contains the symbol table for ABFD.
4134 DEBUG_SECTIONS contains the name of the dwarf debug sections.
4135 ADDR_SIZE is the number of bytes in the initial .debug_info length
4136 field and in the abbreviation offset, or zero to indicate that the
4137 default value should be used. */
4140 _bfd_dwarf2_find_nearest_line (bfd
*abfd
,
4145 const char **filename_ptr
,
4146 const char **functionname_ptr
,
4147 unsigned int *linenumber_ptr
,
4148 unsigned int *discriminator_ptr
,
4149 const struct dwarf_debug_section
*debug_sections
,
4150 unsigned int addr_size
,
4153 /* Read each compilation unit from the section .debug_info, and check
4154 to see if it contains the address we are searching for. If yes,
4155 lookup the address, and return the line number info. If no, go
4156 on to the next compilation unit.
4158 We keep a list of all the previously read compilation units, and
4159 a pointer to the next un-read compilation unit. Check the
4160 previously read units before reading more. */
4161 struct dwarf2_debug
*stash
;
4162 /* What address are we looking for? */
4164 struct comp_unit
* each
;
4165 struct funcinfo
*function
= NULL
;
4166 bfd_boolean found
= FALSE
;
4167 bfd_boolean do_line
;
4169 *filename_ptr
= NULL
;
4170 if (functionname_ptr
!= NULL
)
4171 *functionname_ptr
= NULL
;
4172 *linenumber_ptr
= 0;
4173 if (discriminator_ptr
)
4174 *discriminator_ptr
= 0;
4176 if (! _bfd_dwarf2_slurp_debug_info (abfd
, NULL
, debug_sections
,
4178 (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0))
4181 stash
= (struct dwarf2_debug
*) *pinfo
;
4183 do_line
= symbol
!= NULL
;
4186 BFD_ASSERT (section
== NULL
&& offset
== 0 && functionname_ptr
== NULL
);
4187 section
= bfd_get_section (symbol
);
4188 addr
= symbol
->value
;
4192 BFD_ASSERT (section
!= NULL
&& functionname_ptr
!= NULL
);
4195 /* If we have no SYMBOL but the section we're looking at is not a
4196 code section, then take a look through the list of symbols to see
4197 if we have a symbol at the address we're looking for. If we do
4198 then use this to look up line information. This will allow us to
4199 give file and line results for data symbols. We exclude code
4200 symbols here, if we look up a function symbol and then look up the
4201 line information we'll actually return the line number for the
4202 opening '{' rather than the function definition line. This is
4203 because looking up by symbol uses the line table, in which the
4204 first line for a function is usually the opening '{', while
4205 looking up the function by section + offset uses the
4206 DW_AT_decl_line from the function DW_TAG_subprogram for the line,
4207 which will be the line of the function name. */
4208 if (symbols
!= NULL
&& (section
->flags
& SEC_CODE
) == 0)
4212 for (tmp
= symbols
; (*tmp
) != NULL
; ++tmp
)
4213 if ((*tmp
)->the_bfd
== abfd
4214 && (*tmp
)->section
== section
4215 && (*tmp
)->value
== offset
4216 && ((*tmp
)->flags
& BSF_SECTION_SYM
) == 0)
4220 /* For local symbols, keep going in the hope we find a
4222 if ((symbol
->flags
& BSF_GLOBAL
) != 0)
4228 if (section
->output_section
)
4229 addr
+= section
->output_section
->vma
+ section
->output_offset
;
4231 addr
+= section
->vma
;
4233 /* A null info_ptr indicates that there is no dwarf2 info
4234 (or that an error occured while setting up the stash). */
4235 if (! stash
->info_ptr
)
4238 stash
->inliner_chain
= NULL
;
4240 /* Check the previously read comp. units first. */
4243 /* The info hash tables use quite a bit of memory. We may not want to
4244 always use them. We use some heuristics to decide if and when to
4246 if (stash
->info_hash_status
== STASH_INFO_HASH_OFF
)
4247 stash_maybe_enable_info_hash_tables (abfd
, stash
);
4249 /* Keep info hash table up to date if they are available. Note that we
4250 may disable the hash tables if there is any error duing update. */
4251 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
4252 stash_maybe_update_info_hash_tables (stash
);
4254 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
4256 found
= stash_find_line_fast (stash
, symbol
, addr
, filename_ptr
,
4263 /* Check the previously read comp. units first. */
4264 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
4265 if ((symbol
->flags
& BSF_FUNCTION
) == 0
4266 || each
->arange
.high
== 0
4267 || comp_unit_contains_address (each
, addr
))
4269 found
= comp_unit_find_line (each
, symbol
, addr
, filename_ptr
,
4270 linenumber_ptr
, stash
);
4278 bfd_vma min_range
= (bfd_vma
) -1;
4279 const char * local_filename
= NULL
;
4280 struct funcinfo
*local_function
= NULL
;
4281 unsigned int local_linenumber
= 0;
4282 unsigned int local_discriminator
= 0;
4284 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
4286 bfd_vma range
= (bfd_vma
) -1;
4288 found
= ((each
->arange
.high
== 0
4289 || comp_unit_contains_address (each
, addr
))
4290 && (range
= comp_unit_find_nearest_line (each
, addr
,
4294 & local_discriminator
,
4298 /* PRs 15935 15994: Bogus debug information may have provided us
4299 with an erroneous match. We attempt to counter this by
4300 selecting the match that has the smallest address range
4301 associated with it. (We are assuming that corrupt debug info
4302 will tend to result in extra large address ranges rather than
4303 extra small ranges).
4305 This does mean that we scan through all of the CUs associated
4306 with the bfd each time this function is called. But this does
4307 have the benefit of producing consistent results every time the
4308 function is called. */
4309 if (range
<= min_range
)
4311 if (filename_ptr
&& local_filename
)
4312 * filename_ptr
= local_filename
;
4314 function
= local_function
;
4315 if (discriminator_ptr
&& local_discriminator
)
4316 * discriminator_ptr
= local_discriminator
;
4317 if (local_linenumber
)
4318 * linenumber_ptr
= local_linenumber
;
4324 if (* linenumber_ptr
)
4331 /* The DWARF2 spec says that the initial length field, and the
4332 offset of the abbreviation table, should both be 4-byte values.
4333 However, some compilers do things differently. */
4336 BFD_ASSERT (addr_size
== 4 || addr_size
== 8);
4338 /* Read each remaining comp. units checking each as they are read. */
4339 while (stash
->info_ptr
< stash
->info_ptr_end
)
4342 unsigned int offset_size
= addr_size
;
4343 bfd_byte
*info_ptr_unit
= stash
->info_ptr
;
4345 length
= read_4_bytes (stash
->bfd_ptr
, stash
->info_ptr
, stash
->info_ptr_end
);
4346 /* A 0xffffff length is the DWARF3 way of indicating
4347 we use 64-bit offsets, instead of 32-bit offsets. */
4348 if (length
== 0xffffffff)
4351 length
= read_8_bytes (stash
->bfd_ptr
, stash
->info_ptr
+ 4, stash
->info_ptr_end
);
4352 stash
->info_ptr
+= 12;
4354 /* A zero length is the IRIX way of indicating 64-bit offsets,
4355 mostly because the 64-bit length will generally fit in 32
4356 bits, and the endianness helps. */
4357 else if (length
== 0)
4360 length
= read_4_bytes (stash
->bfd_ptr
, stash
->info_ptr
+ 4, stash
->info_ptr_end
);
4361 stash
->info_ptr
+= 8;
4363 /* In the absence of the hints above, we assume 32-bit DWARF2
4364 offsets even for targets with 64-bit addresses, because:
4365 a) most of the time these targets will not have generated
4366 more than 2Gb of debug info and so will not need 64-bit
4369 b) if they do use 64-bit offsets but they are not using
4370 the size hints that are tested for above then they are
4371 not conforming to the DWARF3 standard anyway. */
4372 else if (addr_size
== 8)
4375 stash
->info_ptr
+= 4;
4378 stash
->info_ptr
+= 4;
4385 if (stash
->info_ptr
+ length
> stash
->info_ptr_end
)
4388 each
= parse_comp_unit (stash
, length
, info_ptr_unit
,
4391 /* The dwarf information is damaged, don't trust it any
4395 new_ptr
= stash
->info_ptr
+ length
;
4396 /* PR 17512: file: 1500698c. */
4397 if (new_ptr
< stash
->info_ptr
)
4399 /* A corrupt length value - do not trust the info any more. */
4404 stash
->info_ptr
= new_ptr
;
4406 if (stash
->all_comp_units
)
4407 stash
->all_comp_units
->prev_unit
= each
;
4409 stash
->last_comp_unit
= each
;
4411 each
->next_unit
= stash
->all_comp_units
;
4412 stash
->all_comp_units
= each
;
4414 /* DW_AT_low_pc and DW_AT_high_pc are optional for
4415 compilation units. If we don't have them (i.e.,
4416 unit->high == 0), we need to consult the line info table
4417 to see if a compilation unit contains the given
4420 found
= (((symbol
->flags
& BSF_FUNCTION
) == 0
4421 || each
->arange
.high
== 0
4422 || comp_unit_contains_address (each
, addr
))
4423 && comp_unit_find_line (each
, symbol
, addr
,
4428 found
= ((each
->arange
.high
== 0
4429 || comp_unit_contains_address (each
, addr
))
4430 && comp_unit_find_nearest_line (each
, addr
,
4437 if ((bfd_vma
) (stash
->info_ptr
- stash
->sec_info_ptr
)
4438 == stash
->sec
->size
)
4440 stash
->sec
= find_debug_info (stash
->bfd_ptr
, debug_sections
,
4442 stash
->sec_info_ptr
= stash
->info_ptr
;
4453 if (!function
->is_linkage
)
4458 fun
= _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
4459 *filename_ptr
? NULL
: filename_ptr
,
4461 sec_vma
= section
->vma
;
4462 if (section
->output_section
!= NULL
)
4463 sec_vma
= section
->output_section
->vma
+ section
->output_offset
;
4465 && fun
->value
+ sec_vma
== function
->arange
.low
)
4466 function
->name
= *functionname_ptr
;
4467 /* Even if we didn't find a linkage name, say that we have
4468 to stop a repeated search of symbols. */
4469 function
->is_linkage
= TRUE
;
4471 *functionname_ptr
= function
->name
;
4473 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
4474 unset_sections (stash
);
4480 _bfd_dwarf2_find_inliner_info (bfd
*abfd ATTRIBUTE_UNUSED
,
4481 const char **filename_ptr
,
4482 const char **functionname_ptr
,
4483 unsigned int *linenumber_ptr
,
4486 struct dwarf2_debug
*stash
;
4488 stash
= (struct dwarf2_debug
*) *pinfo
;
4491 struct funcinfo
*func
= stash
->inliner_chain
;
4493 if (func
&& func
->caller_func
)
4495 *filename_ptr
= func
->caller_file
;
4496 *functionname_ptr
= func
->caller_func
->name
;
4497 *linenumber_ptr
= func
->caller_line
;
4498 stash
->inliner_chain
= func
->caller_func
;
4507 _bfd_dwarf2_cleanup_debug_info (bfd
*abfd
, void **pinfo
)
4509 struct dwarf2_debug
*stash
= (struct dwarf2_debug
*) *pinfo
;
4510 struct comp_unit
*each
;
4512 if (abfd
== NULL
|| stash
== NULL
)
4515 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
4517 struct abbrev_info
**abbrevs
= each
->abbrevs
;
4518 struct funcinfo
*function_table
= each
->function_table
;
4519 struct varinfo
*variable_table
= each
->variable_table
;
4522 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
4524 struct abbrev_info
*abbrev
= abbrevs
[i
];
4528 free (abbrev
->attrs
);
4529 abbrev
= abbrev
->next
;
4533 if (each
->line_table
)
4535 free (each
->line_table
->dirs
);
4536 free (each
->line_table
->files
);
4539 while (function_table
)
4541 if (function_table
->file
)
4543 free (function_table
->file
);
4544 function_table
->file
= NULL
;
4547 if (function_table
->caller_file
)
4549 free (function_table
->caller_file
);
4550 function_table
->caller_file
= NULL
;
4552 function_table
= function_table
->prev_func
;
4555 if (each
->lookup_funcinfo_table
)
4557 free (each
->lookup_funcinfo_table
);
4558 each
->lookup_funcinfo_table
= NULL
;
4561 while (variable_table
)
4563 if (variable_table
->file
)
4565 free (variable_table
->file
);
4566 variable_table
->file
= NULL
;
4569 variable_table
= variable_table
->prev_var
;
4573 if (stash
->dwarf_abbrev_buffer
)
4574 free (stash
->dwarf_abbrev_buffer
);
4575 if (stash
->dwarf_line_buffer
)
4576 free (stash
->dwarf_line_buffer
);
4577 if (stash
->dwarf_str_buffer
)
4578 free (stash
->dwarf_str_buffer
);
4579 if (stash
->dwarf_ranges_buffer
)
4580 free (stash
->dwarf_ranges_buffer
);
4581 if (stash
->info_ptr_memory
)
4582 free (stash
->info_ptr_memory
);
4583 if (stash
->close_on_cleanup
)
4584 bfd_close (stash
->bfd_ptr
);
4585 if (stash
->alt_dwarf_str_buffer
)
4586 free (stash
->alt_dwarf_str_buffer
);
4587 if (stash
->alt_dwarf_info_buffer
)
4588 free (stash
->alt_dwarf_info_buffer
);
4590 free (stash
->sec_vma
);
4591 if (stash
->adjusted_sections
)
4592 free (stash
->adjusted_sections
);
4593 if (stash
->alt_bfd_ptr
)
4594 bfd_close (stash
->alt_bfd_ptr
);
4597 /* Find the function to a particular section and offset,
4598 for error reporting. */
4601 _bfd_elf_find_function (bfd
*abfd
,
4605 const char **filename_ptr
,
4606 const char **functionname_ptr
)
4608 struct elf_find_function_cache
4610 asection
*last_section
;
4612 const char *filename
;
4613 bfd_size_type func_size
;
4616 if (symbols
== NULL
)
4619 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
4622 cache
= elf_tdata (abfd
)->elf_find_function_cache
;
4625 cache
= bfd_zalloc (abfd
, sizeof (*cache
));
4626 elf_tdata (abfd
)->elf_find_function_cache
= cache
;
4630 if (cache
->last_section
!= section
4631 || cache
->func
== NULL
4632 || offset
< cache
->func
->value
4633 || offset
>= cache
->func
->value
+ cache
->func_size
)
4638 /* ??? Given multiple file symbols, it is impossible to reliably
4639 choose the right file name for global symbols. File symbols are
4640 local symbols, and thus all file symbols must sort before any
4641 global symbols. The ELF spec may be interpreted to say that a
4642 file symbol must sort before other local symbols, but currently
4643 ld -r doesn't do this. So, for ld -r output, it is possible to
4644 make a better choice of file name for local symbols by ignoring
4645 file symbols appearing after a given local symbol. */
4646 enum { nothing_seen
, symbol_seen
, file_after_symbol_seen
} state
;
4647 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4651 state
= nothing_seen
;
4652 cache
->filename
= NULL
;
4654 cache
->func_size
= 0;
4655 cache
->last_section
= section
;
4657 for (p
= symbols
; *p
!= NULL
; p
++)
4663 if ((sym
->flags
& BSF_FILE
) != 0)
4666 if (state
== symbol_seen
)
4667 state
= file_after_symbol_seen
;
4671 size
= bed
->maybe_function_sym (sym
, section
, &code_off
);
4673 && code_off
<= offset
4674 && (code_off
> low_func
4675 || (code_off
== low_func
4676 && size
> cache
->func_size
)))
4679 cache
->func_size
= size
;
4680 cache
->filename
= NULL
;
4681 low_func
= code_off
;
4683 && ((sym
->flags
& BSF_LOCAL
) != 0
4684 || state
!= file_after_symbol_seen
))
4685 cache
->filename
= bfd_asymbol_name (file
);
4687 if (state
== nothing_seen
)
4688 state
= symbol_seen
;
4692 if (cache
->func
== NULL
)
4696 *filename_ptr
= cache
->filename
;
4697 if (functionname_ptr
)
4698 *functionname_ptr
= bfd_asymbol_name (cache
->func
);