2 Copyright (C) 1994-2014 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 bfd, section and address of the beginning of the
104 section. The bfd might be different than expected because of
105 gnu_debuglink sections. */
108 bfd_byte
*sec_info_ptr
;
110 /* Support for alternate debug info sections created by the DWZ utility:
111 This includes a pointer to an alternate bfd which contains *extra*,
112 possibly duplicate debug sections, and pointers to the loaded
113 .debug_str and .debug_info sections from this bfd. */
115 bfd_byte
* alt_dwarf_str_buffer
;
116 bfd_size_type alt_dwarf_str_size
;
117 bfd_byte
* alt_dwarf_info_buffer
;
118 bfd_size_type alt_dwarf_info_size
;
120 /* A pointer to the memory block allocated for info_ptr. Neither
121 info_ptr nor sec_info_ptr are guaranteed to stay pointing to the
122 beginning of the malloc block. This is used only to free the
124 bfd_byte
*info_ptr_memory
;
126 /* Pointer to the symbol table. */
129 /* Pointer to the .debug_abbrev section loaded into memory. */
130 bfd_byte
*dwarf_abbrev_buffer
;
132 /* Length of the loaded .debug_abbrev section. */
133 bfd_size_type dwarf_abbrev_size
;
135 /* Buffer for decode_line_info. */
136 bfd_byte
*dwarf_line_buffer
;
138 /* Length of the loaded .debug_line section. */
139 bfd_size_type dwarf_line_size
;
141 /* Pointer to the .debug_str section loaded into memory. */
142 bfd_byte
*dwarf_str_buffer
;
144 /* Length of the loaded .debug_str section. */
145 bfd_size_type dwarf_str_size
;
147 /* Pointer to the .debug_ranges section loaded into memory. */
148 bfd_byte
*dwarf_ranges_buffer
;
150 /* Length of the loaded .debug_ranges section. */
151 bfd_size_type dwarf_ranges_size
;
153 /* If the most recent call to bfd_find_nearest_line was given an
154 address in an inlined function, preserve a pointer into the
155 calling chain for subsequent calls to bfd_find_inliner_info to
157 struct funcinfo
*inliner_chain
;
159 /* Section VMAs at the time the stash was built. */
162 /* Number of sections whose VMA we must adjust. */
163 int adjusted_section_count
;
165 /* Array of sections with adjusted VMA. */
166 struct adjusted_section
*adjusted_sections
;
168 /* Number of times find_line is called. This is used in
169 the heuristic for enabling the info hash tables. */
172 #define STASH_INFO_HASH_TRIGGER 100
174 /* Hash table mapping symbol names to function infos. */
175 struct info_hash_table
*funcinfo_hash_table
;
177 /* Hash table mapping symbol names to variable infos. */
178 struct info_hash_table
*varinfo_hash_table
;
180 /* Head of comp_unit list in the last hash table update. */
181 struct comp_unit
*hash_units_head
;
183 /* Status of info hash. */
184 int info_hash_status
;
185 #define STASH_INFO_HASH_OFF 0
186 #define STASH_INFO_HASH_ON 1
187 #define STASH_INFO_HASH_DISABLED 2
189 /* True if we opened bfd_ptr. */
190 bfd_boolean close_on_cleanup
;
200 /* A minimal decoding of DWARF2 compilation units. We only decode
201 what's needed to get to the line number information. */
205 /* Chain the previously read compilation units. */
206 struct comp_unit
*next_unit
;
208 /* Likewise, chain the compilation unit read after this one.
209 The comp units are stored in reversed reading order. */
210 struct comp_unit
*prev_unit
;
212 /* Keep the bfd convenient (for memory allocation). */
215 /* The lowest and highest addresses contained in this compilation
216 unit as specified in the compilation unit header. */
217 struct arange arange
;
219 /* The DW_AT_name attribute (for error messages). */
222 /* The abbrev hash table. */
223 struct abbrev_info
**abbrevs
;
225 /* Note that an error was found by comp_unit_find_nearest_line. */
228 /* The DW_AT_comp_dir attribute. */
231 /* TRUE if there is a line number table associated with this comp. unit. */
234 /* Pointer to the current comp_unit so that we can find a given entry
236 bfd_byte
*info_ptr_unit
;
238 /* Pointer to the start of the debug section, for DW_FORM_ref_addr. */
239 bfd_byte
*sec_info_ptr
;
241 /* The offset into .debug_line of the line number table. */
242 unsigned long line_offset
;
244 /* Pointer to the first child die for the comp unit. */
245 bfd_byte
*first_child_die_ptr
;
247 /* The end of the comp unit. */
250 /* The decoded line number, NULL if not yet decoded. */
251 struct line_info_table
*line_table
;
253 /* A list of the functions found in this comp. unit. */
254 struct funcinfo
*function_table
;
256 /* A list of the variables found in this comp. unit. */
257 struct varinfo
*variable_table
;
259 /* Pointer to dwarf2_debug structure. */
260 struct dwarf2_debug
*stash
;
262 /* DWARF format version for this unit - from unit header. */
265 /* Address size for this unit - from unit header. */
266 unsigned char addr_size
;
268 /* Offset size for this unit - from unit header. */
269 unsigned char offset_size
;
271 /* Base address for this unit - from DW_AT_low_pc attribute of
272 DW_TAG_compile_unit DIE */
273 bfd_vma base_address
;
275 /* TRUE if symbols are cached in hash table for faster lookup by name. */
279 /* This data structure holds the information of an abbrev. */
282 unsigned int number
; /* Number identifying abbrev. */
283 enum dwarf_tag tag
; /* DWARF tag. */
284 int has_children
; /* Boolean. */
285 unsigned int num_attrs
; /* Number of attributes. */
286 struct attr_abbrev
*attrs
; /* An array of attribute descriptions. */
287 struct abbrev_info
*next
; /* Next in chain. */
292 enum dwarf_attribute name
;
293 enum dwarf_form form
;
296 /* Map of uncompressed DWARF debug section name to compressed one. It
297 is terminated by NULL uncompressed_name. */
299 const struct dwarf_debug_section dwarf_debug_sections
[] =
301 { ".debug_abbrev", ".zdebug_abbrev" },
302 { ".debug_aranges", ".zdebug_aranges" },
303 { ".debug_frame", ".zdebug_frame" },
304 { ".debug_info", ".zdebug_info" },
305 { ".debug_info", ".zdebug_info" },
306 { ".debug_line", ".zdebug_line" },
307 { ".debug_loc", ".zdebug_loc" },
308 { ".debug_macinfo", ".zdebug_macinfo" },
309 { ".debug_macro", ".zdebug_macro" },
310 { ".debug_pubnames", ".zdebug_pubnames" },
311 { ".debug_pubtypes", ".zdebug_pubtypes" },
312 { ".debug_ranges", ".zdebug_ranges" },
313 { ".debug_static_func", ".zdebug_static_func" },
314 { ".debug_static_vars", ".zdebug_static_vars" },
315 { ".debug_str", ".zdebug_str", },
316 { ".debug_str", ".zdebug_str", },
317 { ".debug_types", ".zdebug_types" },
318 /* GNU DWARF 1 extensions */
319 { ".debug_sfnames", ".zdebug_sfnames" },
320 { ".debug_srcinfo", ".zebug_srcinfo" },
321 /* SGI/MIPS DWARF 2 extensions */
322 { ".debug_funcnames", ".zdebug_funcnames" },
323 { ".debug_typenames", ".zdebug_typenames" },
324 { ".debug_varnames", ".zdebug_varnames" },
325 { ".debug_weaknames", ".zdebug_weaknames" },
329 /* NB/ Numbers in this enum must match up with indicies
330 into the dwarf_debug_sections[] array above. */
331 enum dwarf_debug_section_enum
358 #ifndef ABBREV_HASH_SIZE
359 #define ABBREV_HASH_SIZE 121
361 #ifndef ATTR_ALLOC_CHUNK
362 #define ATTR_ALLOC_CHUNK 4
365 /* Variable and function hash tables. This is used to speed up look-up
366 in lookup_symbol_in_var_table() and lookup_symbol_in_function_table().
367 In order to share code between variable and function infos, we use
368 a list of untyped pointer for all variable/function info associated with
369 a symbol. We waste a bit of memory for list with one node but that
370 simplifies the code. */
372 struct info_list_node
374 struct info_list_node
*next
;
378 /* Info hash entry. */
379 struct info_hash_entry
381 struct bfd_hash_entry root
;
382 struct info_list_node
*head
;
385 struct info_hash_table
387 struct bfd_hash_table base
;
390 /* Function to create a new entry in info hash table. */
392 static struct bfd_hash_entry
*
393 info_hash_table_newfunc (struct bfd_hash_entry
*entry
,
394 struct bfd_hash_table
*table
,
397 struct info_hash_entry
*ret
= (struct info_hash_entry
*) entry
;
399 /* Allocate the structure if it has not already been allocated by a
403 ret
= (struct info_hash_entry
*) bfd_hash_allocate (table
,
409 /* Call the allocation method of the base class. */
410 ret
= ((struct info_hash_entry
*)
411 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
413 /* Initialize the local fields here. */
417 return (struct bfd_hash_entry
*) ret
;
420 /* Function to create a new info hash table. It returns a pointer to the
421 newly created table or NULL if there is any error. We need abfd
422 solely for memory allocation. */
424 static struct info_hash_table
*
425 create_info_hash_table (bfd
*abfd
)
427 struct info_hash_table
*hash_table
;
429 hash_table
= ((struct info_hash_table
*)
430 bfd_alloc (abfd
, sizeof (struct info_hash_table
)));
434 if (!bfd_hash_table_init (&hash_table
->base
, info_hash_table_newfunc
,
435 sizeof (struct info_hash_entry
)))
437 bfd_release (abfd
, hash_table
);
444 /* Insert an info entry into an info hash table. We do not check of
445 duplicate entries. Also, the caller need to guarantee that the
446 right type of info in inserted as info is passed as a void* pointer.
447 This function returns true if there is no error. */
450 insert_info_hash_table (struct info_hash_table
*hash_table
,
455 struct info_hash_entry
*entry
;
456 struct info_list_node
*node
;
458 entry
= (struct info_hash_entry
*) bfd_hash_lookup (&hash_table
->base
,
463 node
= (struct info_list_node
*) bfd_hash_allocate (&hash_table
->base
,
469 node
->next
= entry
->head
;
475 /* Look up an info entry list from an info hash table. Return NULL
478 static struct info_list_node
*
479 lookup_info_hash_table (struct info_hash_table
*hash_table
, const char *key
)
481 struct info_hash_entry
*entry
;
483 entry
= (struct info_hash_entry
*) bfd_hash_lookup (&hash_table
->base
, key
,
485 return entry
? entry
->head
: NULL
;
488 /* Read a section into its appropriate place in the dwarf2_debug
489 struct (indicated by SECTION_BUFFER and SECTION_SIZE). If SYMS is
490 not NULL, use bfd_simple_get_relocated_section_contents to read the
491 section contents, otherwise use bfd_get_section_contents. Fail if
492 the located section does not contain at least OFFSET bytes. */
495 read_section (bfd
* abfd
,
496 const struct dwarf_debug_section
*sec
,
499 bfd_byte
** section_buffer
,
500 bfd_size_type
* section_size
)
503 const char *section_name
= sec
->uncompressed_name
;
505 /* The section may have already been read. */
506 if (*section_buffer
== NULL
)
508 msec
= bfd_get_section_by_name (abfd
, section_name
);
511 section_name
= sec
->compressed_name
;
512 if (section_name
!= NULL
)
513 msec
= bfd_get_section_by_name (abfd
, section_name
);
517 (*_bfd_error_handler
) (_("Dwarf Error: Can't find %s section."),
518 sec
->uncompressed_name
);
519 bfd_set_error (bfd_error_bad_value
);
523 *section_size
= msec
->rawsize
? msec
->rawsize
: msec
->size
;
527 = bfd_simple_get_relocated_section_contents (abfd
, msec
, NULL
, syms
);
528 if (! *section_buffer
)
533 *section_buffer
= (bfd_byte
*) bfd_malloc (*section_size
);
534 if (! *section_buffer
)
536 if (! bfd_get_section_contents (abfd
, msec
, *section_buffer
,
542 /* It is possible to get a bad value for the offset into the section
543 that the client wants. Validate it here to avoid trouble later. */
544 if (offset
!= 0 && offset
>= *section_size
)
546 (*_bfd_error_handler
) (_("Dwarf Error: Offset (%lu)"
547 " greater than or equal to %s size (%lu)."),
548 (long) offset
, section_name
, *section_size
);
549 bfd_set_error (bfd_error_bad_value
);
557 The following function up to the END VERBATIM mark are
558 copied directly from dwarf2read.c. */
560 /* Read dwarf information from a buffer. */
563 read_1_byte (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_byte
*buf
)
565 return bfd_get_8 (abfd
, buf
);
569 read_1_signed_byte (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_byte
*buf
)
571 return bfd_get_signed_8 (abfd
, buf
);
575 read_2_bytes (bfd
*abfd
, bfd_byte
*buf
)
577 return bfd_get_16 (abfd
, buf
);
581 read_4_bytes (bfd
*abfd
, bfd_byte
*buf
)
583 return bfd_get_32 (abfd
, buf
);
587 read_8_bytes (bfd
*abfd
, bfd_byte
*buf
)
589 return bfd_get_64 (abfd
, buf
);
593 read_n_bytes (bfd
*abfd ATTRIBUTE_UNUSED
,
595 unsigned int size ATTRIBUTE_UNUSED
)
601 read_string (bfd
*abfd ATTRIBUTE_UNUSED
,
603 unsigned int *bytes_read_ptr
)
605 /* Return a pointer to the embedded string. */
606 char *str
= (char *) buf
;
614 *bytes_read_ptr
= strlen (str
) + 1;
621 read_indirect_string (struct comp_unit
* unit
,
623 unsigned int * bytes_read_ptr
)
626 struct dwarf2_debug
*stash
= unit
->stash
;
629 if (unit
->offset_size
== 4)
630 offset
= read_4_bytes (unit
->abfd
, buf
);
632 offset
= read_8_bytes (unit
->abfd
, buf
);
634 *bytes_read_ptr
= unit
->offset_size
;
636 if (! read_section (unit
->abfd
, &stash
->debug_sections
[debug_str
],
638 &stash
->dwarf_str_buffer
, &stash
->dwarf_str_size
))
641 str
= (char *) stash
->dwarf_str_buffer
+ offset
;
647 /* Like read_indirect_string but uses a .debug_str located in
648 an alternate file pointed to by the .gnu_debugaltlink section.
649 Used to impement DW_FORM_GNU_strp_alt. */
652 read_alt_indirect_string (struct comp_unit
* unit
,
654 unsigned int * bytes_read_ptr
)
657 struct dwarf2_debug
*stash
= unit
->stash
;
660 if (unit
->offset_size
== 4)
661 offset
= read_4_bytes (unit
->abfd
, buf
);
663 offset
= read_8_bytes (unit
->abfd
, buf
);
665 *bytes_read_ptr
= unit
->offset_size
;
667 if (stash
->alt_bfd_ptr
== NULL
)
670 char * debug_filename
= bfd_follow_gnu_debugaltlink (unit
->abfd
, DEBUGDIR
);
672 if (debug_filename
== NULL
)
675 if ((debug_bfd
= bfd_openr (debug_filename
, NULL
)) == NULL
676 || ! bfd_check_format (debug_bfd
, bfd_object
))
679 bfd_close (debug_bfd
);
681 /* FIXME: Should we report our failure to follow the debuglink ? */
682 free (debug_filename
);
685 stash
->alt_bfd_ptr
= debug_bfd
;
688 if (! read_section (unit
->stash
->alt_bfd_ptr
,
689 stash
->debug_sections
+ debug_str_alt
,
690 NULL
, /* FIXME: Do we need to load alternate symbols ? */
692 &stash
->alt_dwarf_str_buffer
,
693 &stash
->alt_dwarf_str_size
))
696 str
= (char *) stash
->alt_dwarf_str_buffer
+ offset
;
703 /* Resolve an alternate reference from UNIT at OFFSET.
704 Returns a pointer into the loaded alternate CU upon success
705 or NULL upon failure. */
708 read_alt_indirect_ref (struct comp_unit
* unit
,
711 struct dwarf2_debug
*stash
= unit
->stash
;
713 if (stash
->alt_bfd_ptr
== NULL
)
716 char * debug_filename
= bfd_follow_gnu_debugaltlink (unit
->abfd
, DEBUGDIR
);
718 if (debug_filename
== NULL
)
721 if ((debug_bfd
= bfd_openr (debug_filename
, NULL
)) == NULL
722 || ! bfd_check_format (debug_bfd
, bfd_object
))
725 bfd_close (debug_bfd
);
727 /* FIXME: Should we report our failure to follow the debuglink ? */
728 free (debug_filename
);
731 stash
->alt_bfd_ptr
= debug_bfd
;
734 if (! read_section (unit
->stash
->alt_bfd_ptr
,
735 stash
->debug_sections
+ debug_info_alt
,
736 NULL
, /* FIXME: Do we need to load alternate symbols ? */
738 &stash
->alt_dwarf_info_buffer
,
739 &stash
->alt_dwarf_info_size
))
742 return stash
->alt_dwarf_info_buffer
+ offset
;
746 read_address (struct comp_unit
*unit
, bfd_byte
*buf
)
748 int signed_vma
= get_elf_backend_data (unit
->abfd
)->sign_extend_vma
;
752 switch (unit
->addr_size
)
755 return bfd_get_signed_64 (unit
->abfd
, buf
);
757 return bfd_get_signed_32 (unit
->abfd
, buf
);
759 return bfd_get_signed_16 (unit
->abfd
, buf
);
766 switch (unit
->addr_size
)
769 return bfd_get_64 (unit
->abfd
, buf
);
771 return bfd_get_32 (unit
->abfd
, buf
);
773 return bfd_get_16 (unit
->abfd
, buf
);
780 /* Lookup an abbrev_info structure in the abbrev hash table. */
782 static struct abbrev_info
*
783 lookup_abbrev (unsigned int number
, struct abbrev_info
**abbrevs
)
785 unsigned int hash_number
;
786 struct abbrev_info
*abbrev
;
788 hash_number
= number
% ABBREV_HASH_SIZE
;
789 abbrev
= abbrevs
[hash_number
];
793 if (abbrev
->number
== number
)
796 abbrev
= abbrev
->next
;
802 /* In DWARF version 2, the description of the debugging information is
803 stored in a separate .debug_abbrev section. Before we read any
804 dies from a section we read in all abbreviations and install them
807 static struct abbrev_info
**
808 read_abbrevs (bfd
*abfd
, bfd_uint64_t offset
, struct dwarf2_debug
*stash
)
810 struct abbrev_info
**abbrevs
;
811 bfd_byte
*abbrev_ptr
;
812 struct abbrev_info
*cur_abbrev
;
813 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
814 unsigned int abbrev_form
, hash_number
;
817 if (! read_section (abfd
, &stash
->debug_sections
[debug_abbrev
],
819 &stash
->dwarf_abbrev_buffer
, &stash
->dwarf_abbrev_size
))
822 amt
= sizeof (struct abbrev_info
*) * ABBREV_HASH_SIZE
;
823 abbrevs
= (struct abbrev_info
**) bfd_zalloc (abfd
, amt
);
827 abbrev_ptr
= stash
->dwarf_abbrev_buffer
+ offset
;
828 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
829 abbrev_ptr
+= bytes_read
;
831 /* Loop until we reach an abbrev number of 0. */
832 while (abbrev_number
)
834 amt
= sizeof (struct abbrev_info
);
835 cur_abbrev
= (struct abbrev_info
*) bfd_zalloc (abfd
, amt
);
836 if (cur_abbrev
== NULL
)
839 /* Read in abbrev header. */
840 cur_abbrev
->number
= abbrev_number
;
841 cur_abbrev
->tag
= (enum dwarf_tag
)
842 read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
843 abbrev_ptr
+= bytes_read
;
844 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
847 /* Now read in declarations. */
848 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
849 abbrev_ptr
+= bytes_read
;
850 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
851 abbrev_ptr
+= bytes_read
;
855 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
857 struct attr_abbrev
*tmp
;
859 amt
= cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
;
860 amt
*= sizeof (struct attr_abbrev
);
861 tmp
= (struct attr_abbrev
*) bfd_realloc (cur_abbrev
->attrs
, amt
);
866 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
868 struct abbrev_info
*abbrev
= abbrevs
[i
];
872 free (abbrev
->attrs
);
873 abbrev
= abbrev
->next
;
878 cur_abbrev
->attrs
= tmp
;
881 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
882 = (enum dwarf_attribute
) abbrev_name
;
883 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
884 = (enum dwarf_form
) abbrev_form
;
885 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
886 abbrev_ptr
+= bytes_read
;
887 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
888 abbrev_ptr
+= bytes_read
;
891 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
892 cur_abbrev
->next
= abbrevs
[hash_number
];
893 abbrevs
[hash_number
] = cur_abbrev
;
895 /* Get next abbreviation.
896 Under Irix6 the abbreviations for a compilation unit are not
897 always properly terminated with an abbrev number of 0.
898 Exit loop if we encounter an abbreviation which we have
899 already read (which means we are about to read the abbreviations
900 for the next compile unit) or if the end of the abbreviation
902 if ((unsigned int) (abbrev_ptr
- stash
->dwarf_abbrev_buffer
)
903 >= stash
->dwarf_abbrev_size
)
905 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
906 abbrev_ptr
+= bytes_read
;
907 if (lookup_abbrev (abbrev_number
,abbrevs
) != NULL
)
914 /* Read an attribute value described by an attribute form. */
917 read_attribute_value (struct attribute
*attr
,
919 struct comp_unit
*unit
,
922 bfd
*abfd
= unit
->abfd
;
923 unsigned int bytes_read
;
924 struct dwarf_block
*blk
;
927 attr
->form
= (enum dwarf_form
) form
;
931 case DW_FORM_ref_addr
:
932 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
934 if (unit
->version
== 3 || unit
->version
== 4)
936 if (unit
->offset_size
== 4)
937 attr
->u
.val
= read_4_bytes (unit
->abfd
, info_ptr
);
939 attr
->u
.val
= read_8_bytes (unit
->abfd
, info_ptr
);
940 info_ptr
+= unit
->offset_size
;
945 attr
->u
.val
= read_address (unit
, info_ptr
);
946 info_ptr
+= unit
->addr_size
;
948 case DW_FORM_GNU_ref_alt
:
949 case DW_FORM_sec_offset
:
950 if (unit
->offset_size
== 4)
951 attr
->u
.val
= read_4_bytes (unit
->abfd
, info_ptr
);
953 attr
->u
.val
= read_8_bytes (unit
->abfd
, info_ptr
);
954 info_ptr
+= unit
->offset_size
;
957 amt
= sizeof (struct dwarf_block
);
958 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
961 blk
->size
= read_2_bytes (abfd
, info_ptr
);
963 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
964 info_ptr
+= blk
->size
;
968 amt
= sizeof (struct dwarf_block
);
969 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
972 blk
->size
= read_4_bytes (abfd
, info_ptr
);
974 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
975 info_ptr
+= blk
->size
;
979 attr
->u
.val
= read_2_bytes (abfd
, info_ptr
);
983 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
);
987 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
);
991 attr
->u
.str
= read_string (abfd
, info_ptr
, &bytes_read
);
992 info_ptr
+= bytes_read
;
995 attr
->u
.str
= read_indirect_string (unit
, info_ptr
, &bytes_read
);
996 info_ptr
+= bytes_read
;
998 case DW_FORM_GNU_strp_alt
:
999 attr
->u
.str
= read_alt_indirect_string (unit
, info_ptr
, &bytes_read
);
1000 info_ptr
+= bytes_read
;
1002 case DW_FORM_exprloc
:
1004 amt
= sizeof (struct dwarf_block
);
1005 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1008 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
1009 info_ptr
+= bytes_read
;
1010 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
1011 info_ptr
+= blk
->size
;
1014 case DW_FORM_block1
:
1015 amt
= sizeof (struct dwarf_block
);
1016 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
1019 blk
->size
= read_1_byte (abfd
, info_ptr
);
1021 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
1022 info_ptr
+= blk
->size
;
1026 attr
->u
.val
= read_1_byte (abfd
, info_ptr
);
1030 attr
->u
.val
= read_1_byte (abfd
, info_ptr
);
1033 case DW_FORM_flag_present
:
1037 attr
->u
.sval
= read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
1038 info_ptr
+= bytes_read
;
1041 attr
->u
.val
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
1042 info_ptr
+= bytes_read
;
1045 attr
->u
.val
= read_1_byte (abfd
, info_ptr
);
1049 attr
->u
.val
= read_2_bytes (abfd
, info_ptr
);
1053 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
);
1057 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
);
1060 case DW_FORM_ref_sig8
:
1061 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
);
1064 case DW_FORM_ref_udata
:
1065 attr
->u
.val
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
1066 info_ptr
+= bytes_read
;
1068 case DW_FORM_indirect
:
1069 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
1070 info_ptr
+= bytes_read
;
1071 info_ptr
= read_attribute_value (attr
, form
, unit
, info_ptr
);
1074 (*_bfd_error_handler
) (_("Dwarf Error: Invalid or unhandled FORM value: %#x."),
1076 bfd_set_error (bfd_error_bad_value
);
1082 /* Read an attribute described by an abbreviated attribute. */
1085 read_attribute (struct attribute
*attr
,
1086 struct attr_abbrev
*abbrev
,
1087 struct comp_unit
*unit
,
1090 attr
->name
= abbrev
->name
;
1091 info_ptr
= read_attribute_value (attr
, abbrev
->form
, unit
, info_ptr
);
1095 /* Source line information table routines. */
1097 #define FILE_ALLOC_CHUNK 5
1098 #define DIR_ALLOC_CHUNK 5
1102 struct line_info
* prev_line
;
1106 unsigned int column
;
1107 unsigned int discriminator
;
1108 unsigned char op_index
;
1109 unsigned char end_sequence
; /* End of (sequential) code sequence. */
1120 struct line_sequence
1123 struct line_sequence
* prev_sequence
;
1124 struct line_info
* last_line
; /* Largest VMA. */
1127 struct line_info_table
1130 unsigned int num_files
;
1131 unsigned int num_dirs
;
1132 unsigned int num_sequences
;
1135 struct fileinfo
* files
;
1136 struct line_sequence
* sequences
;
1137 struct line_info
* lcl_head
; /* Local head; used in 'add_line_info'. */
1140 /* Remember some information about each function. If the function is
1141 inlined (DW_TAG_inlined_subroutine) it may have two additional
1142 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
1143 source code location where this function was inlined. */
1147 /* Pointer to previous function in list of all functions. */
1148 struct funcinfo
*prev_func
;
1149 /* Pointer to function one scope higher. */
1150 struct funcinfo
*caller_func
;
1151 /* Source location file name where caller_func inlines this func. */
1153 /* Source location line number where caller_func inlines this func. */
1155 /* Source location file name. */
1157 /* Source location line number. */
1161 struct arange arange
;
1162 /* Where the symbol is defined. */
1168 /* Pointer to previous variable in list of all variables */
1169 struct varinfo
*prev_var
;
1170 /* Source location file name */
1172 /* Source location line number */
1177 /* Where the symbol is defined */
1179 /* Is this a stack variable? */
1180 unsigned int stack
: 1;
1183 /* Return TRUE if NEW_LINE should sort after LINE. */
1185 static inline bfd_boolean
1186 new_line_sorts_after (struct line_info
*new_line
, struct line_info
*line
)
1188 return (new_line
->address
> line
->address
1189 || (new_line
->address
== line
->address
1190 && (new_line
->op_index
> line
->op_index
1191 || (new_line
->op_index
== line
->op_index
1192 && new_line
->end_sequence
< line
->end_sequence
))));
1196 /* Adds a new entry to the line_info list in the line_info_table, ensuring
1197 that the list is sorted. Note that the line_info list is sorted from
1198 highest to lowest VMA (with possible duplicates); that is,
1199 line_info->prev_line always accesses an equal or smaller VMA. */
1202 add_line_info (struct line_info_table
*table
,
1204 unsigned char op_index
,
1207 unsigned int column
,
1208 unsigned int discriminator
,
1211 bfd_size_type amt
= sizeof (struct line_info
);
1212 struct line_sequence
* seq
= table
->sequences
;
1213 struct line_info
* info
= (struct line_info
*) bfd_alloc (table
->abfd
, amt
);
1218 /* Set member data of 'info'. */
1219 info
->prev_line
= NULL
;
1220 info
->address
= address
;
1221 info
->op_index
= op_index
;
1223 info
->column
= column
;
1224 info
->discriminator
= discriminator
;
1225 info
->end_sequence
= end_sequence
;
1227 if (filename
&& filename
[0])
1229 info
->filename
= (char *) bfd_alloc (table
->abfd
, strlen (filename
) + 1);
1230 if (info
->filename
== NULL
)
1232 strcpy (info
->filename
, filename
);
1235 info
->filename
= NULL
;
1237 /* Find the correct location for 'info'. Normally we will receive
1238 new line_info data 1) in order and 2) with increasing VMAs.
1239 However some compilers break the rules (cf. decode_line_info) and
1240 so we include some heuristics for quickly finding the correct
1241 location for 'info'. In particular, these heuristics optimize for
1242 the common case in which the VMA sequence that we receive is a
1243 list of locally sorted VMAs such as
1244 p...z a...j (where a < j < p < z)
1246 Note: table->lcl_head is used to head an *actual* or *possible*
1247 sub-sequence within the list (such as a...j) that is not directly
1248 headed by table->last_line
1250 Note: we may receive duplicate entries from 'decode_line_info'. */
1253 && seq
->last_line
->address
== address
1254 && seq
->last_line
->op_index
== op_index
1255 && seq
->last_line
->end_sequence
== end_sequence
)
1257 /* We only keep the last entry with the same address and end
1258 sequence. See PR ld/4986. */
1259 if (table
->lcl_head
== seq
->last_line
)
1260 table
->lcl_head
= info
;
1261 info
->prev_line
= seq
->last_line
->prev_line
;
1262 seq
->last_line
= info
;
1264 else if (!seq
|| seq
->last_line
->end_sequence
)
1266 /* Start a new line sequence. */
1267 amt
= sizeof (struct line_sequence
);
1268 seq
= (struct line_sequence
*) bfd_malloc (amt
);
1271 seq
->low_pc
= address
;
1272 seq
->prev_sequence
= table
->sequences
;
1273 seq
->last_line
= info
;
1274 table
->lcl_head
= info
;
1275 table
->sequences
= seq
;
1276 table
->num_sequences
++;
1278 else if (new_line_sorts_after (info
, seq
->last_line
))
1280 /* Normal case: add 'info' to the beginning of the current sequence. */
1281 info
->prev_line
= seq
->last_line
;
1282 seq
->last_line
= info
;
1284 /* lcl_head: initialize to head a *possible* sequence at the end. */
1285 if (!table
->lcl_head
)
1286 table
->lcl_head
= info
;
1288 else if (!new_line_sorts_after (info
, table
->lcl_head
)
1289 && (!table
->lcl_head
->prev_line
1290 || new_line_sorts_after (info
, table
->lcl_head
->prev_line
)))
1292 /* Abnormal but easy: lcl_head is the head of 'info'. */
1293 info
->prev_line
= table
->lcl_head
->prev_line
;
1294 table
->lcl_head
->prev_line
= info
;
1298 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head'
1299 are valid heads for 'info'. Reset 'lcl_head'. */
1300 struct line_info
* li2
= seq
->last_line
; /* Always non-NULL. */
1301 struct line_info
* li1
= li2
->prev_line
;
1305 if (!new_line_sorts_after (info
, li2
)
1306 && new_line_sorts_after (info
, li1
))
1309 li2
= li1
; /* always non-NULL */
1310 li1
= li1
->prev_line
;
1312 table
->lcl_head
= li2
;
1313 info
->prev_line
= table
->lcl_head
->prev_line
;
1314 table
->lcl_head
->prev_line
= info
;
1315 if (address
< seq
->low_pc
)
1316 seq
->low_pc
= address
;
1321 /* Extract a fully qualified filename from a line info table.
1322 The returned string has been malloc'ed and it is the caller's
1323 responsibility to free it. */
1326 concat_filename (struct line_info_table
*table
, unsigned int file
)
1330 if (file
- 1 >= table
->num_files
)
1332 /* FILE == 0 means unknown. */
1334 (*_bfd_error_handler
)
1335 (_("Dwarf Error: mangled line number section (bad file number)."));
1336 return strdup ("<unknown>");
1339 filename
= table
->files
[file
- 1].name
;
1341 if (!IS_ABSOLUTE_PATH (filename
))
1343 char *dir_name
= NULL
;
1344 char *subdir_name
= NULL
;
1348 if (table
->files
[file
- 1].dir
)
1349 subdir_name
= table
->dirs
[table
->files
[file
- 1].dir
- 1];
1351 if (!subdir_name
|| !IS_ABSOLUTE_PATH (subdir_name
))
1352 dir_name
= table
->comp_dir
;
1356 dir_name
= subdir_name
;
1361 return strdup (filename
);
1363 len
= strlen (dir_name
) + strlen (filename
) + 2;
1367 len
+= strlen (subdir_name
) + 1;
1368 name
= (char *) bfd_malloc (len
);
1370 sprintf (name
, "%s/%s/%s", dir_name
, subdir_name
, filename
);
1374 name
= (char *) bfd_malloc (len
);
1376 sprintf (name
, "%s/%s", dir_name
, filename
);
1382 return strdup (filename
);
1386 arange_add (const struct comp_unit
*unit
, struct arange
*first_arange
,
1387 bfd_vma low_pc
, bfd_vma high_pc
)
1389 struct arange
*arange
;
1391 /* Ignore empty ranges. */
1392 if (low_pc
== high_pc
)
1395 /* If the first arange is empty, use it. */
1396 if (first_arange
->high
== 0)
1398 first_arange
->low
= low_pc
;
1399 first_arange
->high
= high_pc
;
1403 /* Next see if we can cheaply extend an existing range. */
1404 arange
= first_arange
;
1407 if (low_pc
== arange
->high
)
1409 arange
->high
= high_pc
;
1412 if (high_pc
== arange
->low
)
1414 arange
->low
= low_pc
;
1417 arange
= arange
->next
;
1421 /* Need to allocate a new arange and insert it into the arange list.
1422 Order isn't significant, so just insert after the first arange. */
1423 arange
= (struct arange
*) bfd_alloc (unit
->abfd
, sizeof (*arange
));
1426 arange
->low
= low_pc
;
1427 arange
->high
= high_pc
;
1428 arange
->next
= first_arange
->next
;
1429 first_arange
->next
= arange
;
1433 /* Compare function for line sequences. */
1436 compare_sequences (const void* a
, const void* b
)
1438 const struct line_sequence
* seq1
= a
;
1439 const struct line_sequence
* seq2
= b
;
1441 /* Sort by low_pc as the primary key. */
1442 if (seq1
->low_pc
< seq2
->low_pc
)
1444 if (seq1
->low_pc
> seq2
->low_pc
)
1447 /* If low_pc values are equal, sort in reverse order of
1448 high_pc, so that the largest region comes first. */
1449 if (seq1
->last_line
->address
< seq2
->last_line
->address
)
1451 if (seq1
->last_line
->address
> seq2
->last_line
->address
)
1454 if (seq1
->last_line
->op_index
< seq2
->last_line
->op_index
)
1456 if (seq1
->last_line
->op_index
> seq2
->last_line
->op_index
)
1462 /* Sort the line sequences for quick lookup. */
1465 sort_line_sequences (struct line_info_table
* table
)
1468 struct line_sequence
* sequences
;
1469 struct line_sequence
* seq
;
1471 unsigned int num_sequences
= table
->num_sequences
;
1472 bfd_vma last_high_pc
;
1474 if (num_sequences
== 0)
1477 /* Allocate space for an array of sequences. */
1478 amt
= sizeof (struct line_sequence
) * num_sequences
;
1479 sequences
= (struct line_sequence
*) bfd_alloc (table
->abfd
, amt
);
1480 if (sequences
== NULL
)
1483 /* Copy the linked list into the array, freeing the original nodes. */
1484 seq
= table
->sequences
;
1485 for (n
= 0; n
< num_sequences
; n
++)
1487 struct line_sequence
* last_seq
= seq
;
1490 sequences
[n
].low_pc
= seq
->low_pc
;
1491 sequences
[n
].prev_sequence
= NULL
;
1492 sequences
[n
].last_line
= seq
->last_line
;
1493 seq
= seq
->prev_sequence
;
1496 BFD_ASSERT (seq
== NULL
);
1498 qsort (sequences
, n
, sizeof (struct line_sequence
), compare_sequences
);
1500 /* Make the list binary-searchable by trimming overlapping entries
1501 and removing nested entries. */
1503 last_high_pc
= sequences
[0].last_line
->address
;
1504 for (n
= 1; n
< table
->num_sequences
; n
++)
1506 if (sequences
[n
].low_pc
< last_high_pc
)
1508 if (sequences
[n
].last_line
->address
<= last_high_pc
)
1509 /* Skip nested entries. */
1512 /* Trim overlapping entries. */
1513 sequences
[n
].low_pc
= last_high_pc
;
1515 last_high_pc
= sequences
[n
].last_line
->address
;
1516 if (n
> num_sequences
)
1518 /* Close up the gap. */
1519 sequences
[num_sequences
].low_pc
= sequences
[n
].low_pc
;
1520 sequences
[num_sequences
].last_line
= sequences
[n
].last_line
;
1525 table
->sequences
= sequences
;
1526 table
->num_sequences
= num_sequences
;
1530 /* Decode the line number information for UNIT. */
1532 static struct line_info_table
*
1533 decode_line_info (struct comp_unit
*unit
, struct dwarf2_debug
*stash
)
1535 bfd
*abfd
= unit
->abfd
;
1536 struct line_info_table
* table
;
1539 struct line_head lh
;
1540 unsigned int i
, bytes_read
, offset_size
;
1541 char *cur_file
, *cur_dir
;
1542 unsigned char op_code
, extended_op
, adj_opcode
;
1543 unsigned int exop_len
;
1546 if (! read_section (abfd
, &stash
->debug_sections
[debug_line
],
1547 stash
->syms
, unit
->line_offset
,
1548 &stash
->dwarf_line_buffer
, &stash
->dwarf_line_size
))
1551 amt
= sizeof (struct line_info_table
);
1552 table
= (struct line_info_table
*) bfd_alloc (abfd
, amt
);
1556 table
->comp_dir
= unit
->comp_dir
;
1558 table
->num_files
= 0;
1559 table
->files
= NULL
;
1561 table
->num_dirs
= 0;
1564 table
->num_sequences
= 0;
1565 table
->sequences
= NULL
;
1567 table
->lcl_head
= NULL
;
1569 line_ptr
= stash
->dwarf_line_buffer
+ unit
->line_offset
;
1571 /* Read in the prologue. */
1572 lh
.total_length
= read_4_bytes (abfd
, line_ptr
);
1575 if (lh
.total_length
== 0xffffffff)
1577 lh
.total_length
= read_8_bytes (abfd
, line_ptr
);
1581 else if (lh
.total_length
== 0 && unit
->addr_size
== 8)
1583 /* Handle (non-standard) 64-bit DWARF2 formats. */
1584 lh
.total_length
= read_4_bytes (abfd
, line_ptr
);
1588 line_end
= line_ptr
+ lh
.total_length
;
1589 lh
.version
= read_2_bytes (abfd
, line_ptr
);
1590 if (lh
.version
< 2 || lh
.version
> 4)
1592 (*_bfd_error_handler
)
1593 (_("Dwarf Error: Unhandled .debug_line version %d."), lh
.version
);
1594 bfd_set_error (bfd_error_bad_value
);
1598 if (offset_size
== 4)
1599 lh
.prologue_length
= read_4_bytes (abfd
, line_ptr
);
1601 lh
.prologue_length
= read_8_bytes (abfd
, line_ptr
);
1602 line_ptr
+= offset_size
;
1603 lh
.minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
1605 if (lh
.version
>= 4)
1607 lh
.maximum_ops_per_insn
= read_1_byte (abfd
, line_ptr
);
1611 lh
.maximum_ops_per_insn
= 1;
1612 if (lh
.maximum_ops_per_insn
== 0)
1614 (*_bfd_error_handler
)
1615 (_("Dwarf Error: Invalid maximum operations per instruction."));
1616 bfd_set_error (bfd_error_bad_value
);
1619 lh
.default_is_stmt
= read_1_byte (abfd
, line_ptr
);
1621 lh
.line_base
= read_1_signed_byte (abfd
, line_ptr
);
1623 lh
.line_range
= read_1_byte (abfd
, line_ptr
);
1625 lh
.opcode_base
= read_1_byte (abfd
, line_ptr
);
1627 amt
= lh
.opcode_base
* sizeof (unsigned char);
1628 lh
.standard_opcode_lengths
= (unsigned char *) bfd_alloc (abfd
, amt
);
1630 lh
.standard_opcode_lengths
[0] = 1;
1632 for (i
= 1; i
< lh
.opcode_base
; ++i
)
1634 lh
.standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
1638 /* Read directory table. */
1639 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
1641 line_ptr
+= bytes_read
;
1643 if ((table
->num_dirs
% DIR_ALLOC_CHUNK
) == 0)
1647 amt
= table
->num_dirs
+ DIR_ALLOC_CHUNK
;
1648 amt
*= sizeof (char *);
1650 tmp
= (char **) bfd_realloc (table
->dirs
, amt
);
1656 table
->dirs
[table
->num_dirs
++] = cur_dir
;
1659 line_ptr
+= bytes_read
;
1661 /* Read file name table. */
1662 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
1664 line_ptr
+= bytes_read
;
1666 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
1668 struct fileinfo
*tmp
;
1670 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
1671 amt
*= sizeof (struct fileinfo
);
1673 tmp
= (struct fileinfo
*) bfd_realloc (table
->files
, amt
);
1679 table
->files
[table
->num_files
].name
= cur_file
;
1680 table
->files
[table
->num_files
].dir
=
1681 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1682 line_ptr
+= bytes_read
;
1683 table
->files
[table
->num_files
].time
=
1684 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1685 line_ptr
+= bytes_read
;
1686 table
->files
[table
->num_files
].size
=
1687 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1688 line_ptr
+= bytes_read
;
1692 line_ptr
+= bytes_read
;
1694 /* Read the statement sequences until there's nothing left. */
1695 while (line_ptr
< line_end
)
1697 /* State machine registers. */
1698 bfd_vma address
= 0;
1699 unsigned char op_index
= 0;
1700 char * filename
= table
->num_files
? concat_filename (table
, 1) : NULL
;
1701 unsigned int line
= 1;
1702 unsigned int column
= 0;
1703 unsigned int discriminator
= 0;
1704 int is_stmt
= lh
.default_is_stmt
;
1705 int end_sequence
= 0;
1706 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1707 compilers generate address sequences that are wildly out of
1708 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1709 for ia64-Linux). Thus, to determine the low and high
1710 address, we must compare on every DW_LNS_copy, etc. */
1711 bfd_vma low_pc
= (bfd_vma
) -1;
1712 bfd_vma high_pc
= 0;
1714 /* Decode the table. */
1715 while (! end_sequence
)
1717 op_code
= read_1_byte (abfd
, line_ptr
);
1720 if (op_code
>= lh
.opcode_base
)
1722 /* Special operand. */
1723 adj_opcode
= op_code
- lh
.opcode_base
;
1724 if (lh
.maximum_ops_per_insn
== 1)
1725 address
+= (adj_opcode
/ lh
.line_range
1726 * lh
.minimum_instruction_length
);
1729 address
+= ((op_index
+ adj_opcode
/ lh
.line_range
)
1730 / lh
.maximum_ops_per_insn
1731 * lh
.minimum_instruction_length
);
1732 op_index
= ((op_index
+ adj_opcode
/ lh
.line_range
)
1733 % lh
.maximum_ops_per_insn
);
1735 line
+= lh
.line_base
+ (adj_opcode
% lh
.line_range
);
1736 /* Append row to matrix using current values. */
1737 if (!add_line_info (table
, address
, op_index
, filename
,
1738 line
, column
, discriminator
, 0))
1741 if (address
< low_pc
)
1743 if (address
> high_pc
)
1746 else switch (op_code
)
1748 case DW_LNS_extended_op
:
1749 exop_len
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1750 line_ptr
+= bytes_read
;
1751 extended_op
= read_1_byte (abfd
, line_ptr
);
1754 switch (extended_op
)
1756 case DW_LNE_end_sequence
:
1758 if (!add_line_info (table
, address
, op_index
, filename
, line
,
1759 column
, discriminator
, end_sequence
))
1762 if (address
< low_pc
)
1764 if (address
> high_pc
)
1766 if (!arange_add (unit
, &unit
->arange
, low_pc
, high_pc
))
1769 case DW_LNE_set_address
:
1770 address
= read_address (unit
, line_ptr
);
1772 line_ptr
+= unit
->addr_size
;
1774 case DW_LNE_define_file
:
1775 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
1776 line_ptr
+= bytes_read
;
1777 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
1779 struct fileinfo
*tmp
;
1781 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
1782 amt
*= sizeof (struct fileinfo
);
1783 tmp
= (struct fileinfo
*) bfd_realloc (table
->files
, amt
);
1788 table
->files
[table
->num_files
].name
= cur_file
;
1789 table
->files
[table
->num_files
].dir
=
1790 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1791 line_ptr
+= bytes_read
;
1792 table
->files
[table
->num_files
].time
=
1793 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1794 line_ptr
+= bytes_read
;
1795 table
->files
[table
->num_files
].size
=
1796 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1797 line_ptr
+= bytes_read
;
1800 case DW_LNE_set_discriminator
:
1802 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1803 line_ptr
+= bytes_read
;
1805 case DW_LNE_HP_source_file_correlation
:
1806 line_ptr
+= exop_len
- 1;
1809 (*_bfd_error_handler
)
1810 (_("Dwarf Error: mangled line number section."));
1811 bfd_set_error (bfd_error_bad_value
);
1813 if (filename
!= NULL
)
1819 if (!add_line_info (table
, address
, op_index
,
1820 filename
, line
, column
, discriminator
, 0))
1823 if (address
< low_pc
)
1825 if (address
> high_pc
)
1828 case DW_LNS_advance_pc
:
1829 if (lh
.maximum_ops_per_insn
== 1)
1830 address
+= (lh
.minimum_instruction_length
1831 * read_unsigned_leb128 (abfd
, line_ptr
,
1835 bfd_vma adjust
= read_unsigned_leb128 (abfd
, line_ptr
,
1837 address
= ((op_index
+ adjust
) / lh
.maximum_ops_per_insn
1838 * lh
.minimum_instruction_length
);
1839 op_index
= (op_index
+ adjust
) % lh
.maximum_ops_per_insn
;
1841 line_ptr
+= bytes_read
;
1843 case DW_LNS_advance_line
:
1844 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
1845 line_ptr
+= bytes_read
;
1847 case DW_LNS_set_file
:
1851 /* The file and directory tables are 0
1852 based, the references are 1 based. */
1853 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1854 line_ptr
+= bytes_read
;
1857 filename
= concat_filename (table
, file
);
1860 case DW_LNS_set_column
:
1861 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1862 line_ptr
+= bytes_read
;
1864 case DW_LNS_negate_stmt
:
1865 is_stmt
= (!is_stmt
);
1867 case DW_LNS_set_basic_block
:
1869 case DW_LNS_const_add_pc
:
1870 if (lh
.maximum_ops_per_insn
== 1)
1871 address
+= (lh
.minimum_instruction_length
1872 * ((255 - lh
.opcode_base
) / lh
.line_range
));
1875 bfd_vma adjust
= ((255 - lh
.opcode_base
) / lh
.line_range
);
1876 address
+= (lh
.minimum_instruction_length
1877 * ((op_index
+ adjust
)
1878 / lh
.maximum_ops_per_insn
));
1879 op_index
= (op_index
+ adjust
) % lh
.maximum_ops_per_insn
;
1882 case DW_LNS_fixed_advance_pc
:
1883 address
+= read_2_bytes (abfd
, line_ptr
);
1888 /* Unknown standard opcode, ignore it. */
1889 for (i
= 0; i
< lh
.standard_opcode_lengths
[op_code
]; i
++)
1891 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1892 line_ptr
+= bytes_read
;
1902 if (sort_line_sequences (table
))
1906 if (table
->sequences
!= NULL
)
1907 free (table
->sequences
);
1908 if (table
->files
!= NULL
)
1909 free (table
->files
);
1910 if (table
->dirs
!= NULL
)
1915 /* If ADDR is within TABLE set the output parameters and return the
1916 range of addresses covered by the entry used to fill them out.
1917 Otherwise set * FILENAME_PTR to NULL and return 0.
1918 The parameters FILENAME_PTR, LINENUMBER_PTR and DISCRIMINATOR_PTR
1919 are pointers to the objects to be filled in. */
1922 lookup_address_in_line_info_table (struct line_info_table
*table
,
1924 const char **filename_ptr
,
1925 unsigned int *linenumber_ptr
,
1926 unsigned int *discriminator_ptr
)
1928 struct line_sequence
*seq
= NULL
;
1929 struct line_info
*each_line
;
1932 /* Binary search the array of sequences. */
1934 high
= table
->num_sequences
;
1937 mid
= (low
+ high
) / 2;
1938 seq
= &table
->sequences
[mid
];
1939 if (addr
< seq
->low_pc
)
1941 else if (addr
>= seq
->last_line
->address
)
1947 if (seq
&& addr
>= seq
->low_pc
&& addr
< seq
->last_line
->address
)
1949 /* Note: seq->last_line should be a descendingly sorted list. */
1950 for (each_line
= seq
->last_line
;
1952 each_line
= each_line
->prev_line
)
1953 if (addr
>= each_line
->address
)
1957 && !(each_line
->end_sequence
|| each_line
== seq
->last_line
))
1959 *filename_ptr
= each_line
->filename
;
1960 *linenumber_ptr
= each_line
->line
;
1961 if (discriminator_ptr
)
1962 *discriminator_ptr
= each_line
->discriminator
;
1963 return seq
->last_line
->address
- seq
->low_pc
;
1967 *filename_ptr
= NULL
;
1971 /* Read in the .debug_ranges section for future reference. */
1974 read_debug_ranges (struct comp_unit
*unit
)
1976 struct dwarf2_debug
*stash
= unit
->stash
;
1977 return read_section (unit
->abfd
, &stash
->debug_sections
[debug_ranges
],
1979 &stash
->dwarf_ranges_buffer
, &stash
->dwarf_ranges_size
);
1982 /* Function table functions. */
1984 /* If ADDR is within UNIT's function tables, set FUNCTIONNAME_PTR, and return
1985 TRUE. Note that we need to find the function that has the smallest range
1986 that contains ADDR, to handle inlined functions without depending upon
1987 them being ordered in TABLE by increasing range. */
1990 lookup_address_in_function_table (struct comp_unit
*unit
,
1992 struct funcinfo
**function_ptr
,
1993 const char **functionname_ptr
)
1995 struct funcinfo
* each_func
;
1996 struct funcinfo
* best_fit
= NULL
;
1997 struct arange
*arange
;
1999 for (each_func
= unit
->function_table
;
2001 each_func
= each_func
->prev_func
)
2003 for (arange
= &each_func
->arange
;
2005 arange
= arange
->next
)
2007 if (addr
>= arange
->low
&& addr
< arange
->high
)
2010 || (arange
->high
- arange
->low
2011 < best_fit
->arange
.high
- best_fit
->arange
.low
))
2012 best_fit
= each_func
;
2019 *functionname_ptr
= best_fit
->name
;
2020 *function_ptr
= best_fit
;
2029 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
2030 and LINENUMBER_PTR, and return TRUE. */
2033 lookup_symbol_in_function_table (struct comp_unit
*unit
,
2036 const char **filename_ptr
,
2037 unsigned int *linenumber_ptr
)
2039 struct funcinfo
* each_func
;
2040 struct funcinfo
* best_fit
= NULL
;
2041 struct arange
*arange
;
2042 const char *name
= bfd_asymbol_name (sym
);
2043 asection
*sec
= bfd_get_section (sym
);
2045 for (each_func
= unit
->function_table
;
2047 each_func
= each_func
->prev_func
)
2049 for (arange
= &each_func
->arange
;
2051 arange
= arange
->next
)
2053 if ((!each_func
->sec
|| each_func
->sec
== sec
)
2054 && addr
>= arange
->low
2055 && addr
< arange
->high
2057 && strcmp (name
, each_func
->name
) == 0
2059 || (arange
->high
- arange
->low
2060 < best_fit
->arange
.high
- best_fit
->arange
.low
)))
2061 best_fit
= each_func
;
2067 best_fit
->sec
= sec
;
2068 *filename_ptr
= best_fit
->file
;
2069 *linenumber_ptr
= best_fit
->line
;
2076 /* Variable table functions. */
2078 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
2079 LINENUMBER_PTR, and return TRUE. */
2082 lookup_symbol_in_variable_table (struct comp_unit
*unit
,
2085 const char **filename_ptr
,
2086 unsigned int *linenumber_ptr
)
2088 const char *name
= bfd_asymbol_name (sym
);
2089 asection
*sec
= bfd_get_section (sym
);
2090 struct varinfo
* each
;
2092 for (each
= unit
->variable_table
; each
; each
= each
->prev_var
)
2093 if (each
->stack
== 0
2094 && each
->file
!= NULL
2095 && each
->name
!= NULL
2096 && each
->addr
== addr
2097 && (!each
->sec
|| each
->sec
== sec
)
2098 && strcmp (name
, each
->name
) == 0)
2104 *filename_ptr
= each
->file
;
2105 *linenumber_ptr
= each
->line
;
2113 find_abstract_instance_name (struct comp_unit
*unit
,
2114 struct attribute
*attr_ptr
)
2116 bfd
*abfd
= unit
->abfd
;
2118 unsigned int abbrev_number
, bytes_read
, i
;
2119 struct abbrev_info
*abbrev
;
2120 bfd_uint64_t die_ref
= attr_ptr
->u
.val
;
2121 struct attribute attr
;
2124 /* DW_FORM_ref_addr can reference an entry in a different CU. It
2125 is an offset from the .debug_info section, not the current CU. */
2126 if (attr_ptr
->form
== DW_FORM_ref_addr
)
2128 /* We only support DW_FORM_ref_addr within the same file, so
2129 any relocations should be resolved already. */
2133 info_ptr
= unit
->sec_info_ptr
+ die_ref
;
2135 /* Now find the CU containing this pointer. */
2136 if (info_ptr
>= unit
->info_ptr_unit
&& info_ptr
< unit
->end_ptr
)
2140 /* Check other CUs to see if they contain the abbrev. */
2141 struct comp_unit
* u
;
2143 for (u
= unit
->prev_unit
; u
!= NULL
; u
= u
->prev_unit
)
2144 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
2148 for (u
= unit
->next_unit
; u
!= NULL
; u
= u
->next_unit
)
2149 if (info_ptr
>= u
->info_ptr_unit
&& info_ptr
< u
->end_ptr
)
2154 /* else FIXME: What do we do now ? */
2157 else if (attr_ptr
->form
== DW_FORM_GNU_ref_alt
)
2159 info_ptr
= read_alt_indirect_ref (unit
, die_ref
);
2160 if (info_ptr
== NULL
)
2162 (*_bfd_error_handler
)
2163 (_("Dwarf Error: Unable to read alt ref %u."), die_ref
);
2164 bfd_set_error (bfd_error_bad_value
);
2167 /* FIXME: Do we need to locate the correct CU, in a similar
2168 fashion to the code in the DW_FORM_ref_addr case above ? */
2171 info_ptr
= unit
->info_ptr_unit
+ die_ref
;
2173 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2174 info_ptr
+= bytes_read
;
2178 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
2181 (*_bfd_error_handler
)
2182 (_("Dwarf Error: Could not find abbrev number %u."), abbrev_number
);
2183 bfd_set_error (bfd_error_bad_value
);
2187 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
2189 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
,
2191 if (info_ptr
== NULL
)
2196 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2201 case DW_AT_specification
:
2202 name
= find_abstract_instance_name (unit
, &attr
);
2204 case DW_AT_linkage_name
:
2205 case DW_AT_MIPS_linkage_name
:
2218 read_rangelist (struct comp_unit
*unit
, struct arange
*arange
,
2219 bfd_uint64_t offset
)
2221 bfd_byte
*ranges_ptr
;
2222 bfd_vma base_address
= unit
->base_address
;
2224 if (! unit
->stash
->dwarf_ranges_buffer
)
2226 if (! read_debug_ranges (unit
))
2229 ranges_ptr
= unit
->stash
->dwarf_ranges_buffer
+ offset
;
2236 low_pc
= read_address (unit
, ranges_ptr
);
2237 ranges_ptr
+= unit
->addr_size
;
2238 high_pc
= read_address (unit
, ranges_ptr
);
2239 ranges_ptr
+= unit
->addr_size
;
2241 if (low_pc
== 0 && high_pc
== 0)
2243 if (low_pc
== -1UL && high_pc
!= -1UL)
2244 base_address
= high_pc
;
2247 if (!arange_add (unit
, arange
,
2248 base_address
+ low_pc
, base_address
+ high_pc
))
2255 /* DWARF2 Compilation unit functions. */
2257 /* Scan over each die in a comp. unit looking for functions to add
2258 to the function table and variables to the variable table. */
2261 scan_unit_for_symbols (struct comp_unit
*unit
)
2263 bfd
*abfd
= unit
->abfd
;
2264 bfd_byte
*info_ptr
= unit
->first_child_die_ptr
;
2265 int nesting_level
= 1;
2266 struct funcinfo
**nested_funcs
;
2267 int nested_funcs_size
;
2269 /* Maintain a stack of in-scope functions and inlined functions, which we
2270 can use to set the caller_func field. */
2271 nested_funcs_size
= 32;
2272 nested_funcs
= (struct funcinfo
**)
2273 bfd_malloc (nested_funcs_size
* sizeof (struct funcinfo
*));
2274 if (nested_funcs
== NULL
)
2276 nested_funcs
[nesting_level
] = 0;
2278 while (nesting_level
)
2280 unsigned int abbrev_number
, bytes_read
, i
;
2281 struct abbrev_info
*abbrev
;
2282 struct attribute attr
;
2283 struct funcinfo
*func
;
2284 struct varinfo
*var
;
2286 bfd_vma high_pc
= 0;
2287 bfd_boolean high_pc_relative
= FALSE
;
2289 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2290 info_ptr
+= bytes_read
;
2292 if (! abbrev_number
)
2298 abbrev
= lookup_abbrev (abbrev_number
,unit
->abbrevs
);
2301 (*_bfd_error_handler
)
2302 (_("Dwarf Error: Could not find abbrev number %u."),
2304 bfd_set_error (bfd_error_bad_value
);
2309 if (abbrev
->tag
== DW_TAG_subprogram
2310 || abbrev
->tag
== DW_TAG_entry_point
2311 || abbrev
->tag
== DW_TAG_inlined_subroutine
)
2313 bfd_size_type amt
= sizeof (struct funcinfo
);
2314 func
= (struct funcinfo
*) bfd_zalloc (abfd
, amt
);
2317 func
->tag
= abbrev
->tag
;
2318 func
->prev_func
= unit
->function_table
;
2319 unit
->function_table
= func
;
2320 BFD_ASSERT (!unit
->cached
);
2322 if (func
->tag
== DW_TAG_inlined_subroutine
)
2323 for (i
= nesting_level
- 1; i
>= 1; i
--)
2324 if (nested_funcs
[i
])
2326 func
->caller_func
= nested_funcs
[i
];
2329 nested_funcs
[nesting_level
] = func
;
2334 if (abbrev
->tag
== DW_TAG_variable
)
2336 bfd_size_type amt
= sizeof (struct varinfo
);
2337 var
= (struct varinfo
*) bfd_zalloc (abfd
, amt
);
2340 var
->tag
= abbrev
->tag
;
2342 var
->prev_var
= unit
->variable_table
;
2343 unit
->variable_table
= var
;
2344 BFD_ASSERT (!unit
->cached
);
2347 /* No inline function in scope at this nesting level. */
2348 nested_funcs
[nesting_level
] = 0;
2351 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
2353 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
);
2354 if (info_ptr
== NULL
)
2361 case DW_AT_call_file
:
2362 func
->caller_file
= concat_filename (unit
->line_table
,
2366 case DW_AT_call_line
:
2367 func
->caller_line
= attr
.u
.val
;
2370 case DW_AT_abstract_origin
:
2371 case DW_AT_specification
:
2372 func
->name
= find_abstract_instance_name (unit
, &attr
);
2376 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2378 if (func
->name
== NULL
)
2379 func
->name
= attr
.u
.str
;
2382 case DW_AT_linkage_name
:
2383 case DW_AT_MIPS_linkage_name
:
2384 func
->name
= attr
.u
.str
;
2388 low_pc
= attr
.u
.val
;
2392 high_pc
= attr
.u
.val
;
2393 high_pc_relative
= attr
.form
!= DW_FORM_addr
;
2397 if (!read_rangelist (unit
, &func
->arange
, attr
.u
.val
))
2401 case DW_AT_decl_file
:
2402 func
->file
= concat_filename (unit
->line_table
,
2406 case DW_AT_decl_line
:
2407 func
->line
= attr
.u
.val
;
2419 var
->name
= attr
.u
.str
;
2422 case DW_AT_decl_file
:
2423 var
->file
= concat_filename (unit
->line_table
,
2427 case DW_AT_decl_line
:
2428 var
->line
= attr
.u
.val
;
2431 case DW_AT_external
:
2432 if (attr
.u
.val
!= 0)
2436 case DW_AT_location
:
2440 case DW_FORM_block1
:
2441 case DW_FORM_block2
:
2442 case DW_FORM_block4
:
2443 case DW_FORM_exprloc
:
2444 if (*attr
.u
.blk
->data
== DW_OP_addr
)
2448 /* Verify that DW_OP_addr is the only opcode in the
2449 location, in which case the block size will be 1
2450 plus the address size. */
2451 /* ??? For TLS variables, gcc can emit
2452 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
2453 which we don't handle here yet. */
2454 if (attr
.u
.blk
->size
== unit
->addr_size
+ 1U)
2455 var
->addr
= bfd_get (unit
->addr_size
* 8,
2457 attr
.u
.blk
->data
+ 1);
2472 if (high_pc_relative
)
2475 if (func
&& high_pc
!= 0)
2477 if (!arange_add (unit
, &func
->arange
, low_pc
, high_pc
))
2481 if (abbrev
->has_children
)
2485 if (nesting_level
>= nested_funcs_size
)
2487 struct funcinfo
**tmp
;
2489 nested_funcs_size
*= 2;
2490 tmp
= (struct funcinfo
**)
2491 bfd_realloc (nested_funcs
,
2492 nested_funcs_size
* sizeof (struct funcinfo
*));
2497 nested_funcs
[nesting_level
] = 0;
2501 free (nested_funcs
);
2505 free (nested_funcs
);
2509 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
2510 includes the compilation unit header that proceeds the DIE's, but
2511 does not include the length field that precedes each compilation
2512 unit header. END_PTR points one past the end of this comp unit.
2513 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
2515 This routine does not read the whole compilation unit; only enough
2516 to get to the line number information for the compilation unit. */
2518 static struct comp_unit
*
2519 parse_comp_unit (struct dwarf2_debug
*stash
,
2520 bfd_vma unit_length
,
2521 bfd_byte
*info_ptr_unit
,
2522 unsigned int offset_size
)
2524 struct comp_unit
* unit
;
2525 unsigned int version
;
2526 bfd_uint64_t abbrev_offset
= 0;
2527 unsigned int addr_size
;
2528 struct abbrev_info
** abbrevs
;
2529 unsigned int abbrev_number
, bytes_read
, i
;
2530 struct abbrev_info
*abbrev
;
2531 struct attribute attr
;
2532 bfd_byte
*info_ptr
= stash
->info_ptr
;
2533 bfd_byte
*end_ptr
= info_ptr
+ unit_length
;
2536 bfd_vma high_pc
= 0;
2537 bfd
*abfd
= stash
->bfd_ptr
;
2538 bfd_boolean high_pc_relative
= FALSE
;
2540 version
= read_2_bytes (abfd
, info_ptr
);
2542 BFD_ASSERT (offset_size
== 4 || offset_size
== 8);
2543 if (offset_size
== 4)
2544 abbrev_offset
= read_4_bytes (abfd
, info_ptr
);
2546 abbrev_offset
= read_8_bytes (abfd
, info_ptr
);
2547 info_ptr
+= offset_size
;
2548 addr_size
= read_1_byte (abfd
, info_ptr
);
2551 if (version
!= 2 && version
!= 3 && version
!= 4)
2553 (*_bfd_error_handler
)
2554 (_("Dwarf Error: found dwarf version '%u', this reader"
2555 " only handles version 2, 3 and 4 information."), version
);
2556 bfd_set_error (bfd_error_bad_value
);
2560 if (addr_size
> sizeof (bfd_vma
))
2562 (*_bfd_error_handler
)
2563 (_("Dwarf Error: found address size '%u', this reader"
2564 " can not handle sizes greater than '%u'."),
2566 (unsigned int) sizeof (bfd_vma
));
2567 bfd_set_error (bfd_error_bad_value
);
2571 if (addr_size
!= 2 && addr_size
!= 4 && addr_size
!= 8)
2573 (*_bfd_error_handler
)
2574 ("Dwarf Error: found address size '%u', this reader"
2575 " can only handle address sizes '2', '4' and '8'.", addr_size
);
2576 bfd_set_error (bfd_error_bad_value
);
2580 /* Read the abbrevs for this compilation unit into a table. */
2581 abbrevs
= read_abbrevs (abfd
, abbrev_offset
, stash
);
2585 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2586 info_ptr
+= bytes_read
;
2587 if (! abbrev_number
)
2589 (*_bfd_error_handler
) (_("Dwarf Error: Bad abbrev number: %u."),
2591 bfd_set_error (bfd_error_bad_value
);
2595 abbrev
= lookup_abbrev (abbrev_number
, abbrevs
);
2598 (*_bfd_error_handler
) (_("Dwarf Error: Could not find abbrev number %u."),
2600 bfd_set_error (bfd_error_bad_value
);
2604 amt
= sizeof (struct comp_unit
);
2605 unit
= (struct comp_unit
*) bfd_zalloc (abfd
, amt
);
2609 unit
->version
= version
;
2610 unit
->addr_size
= addr_size
;
2611 unit
->offset_size
= offset_size
;
2612 unit
->abbrevs
= abbrevs
;
2613 unit
->end_ptr
= end_ptr
;
2614 unit
->stash
= stash
;
2615 unit
->info_ptr_unit
= info_ptr_unit
;
2616 unit
->sec_info_ptr
= stash
->sec_info_ptr
;
2618 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
2620 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
);
2621 if (info_ptr
== NULL
)
2624 /* Store the data if it is of an attribute we want to keep in a
2625 partial symbol table. */
2628 case DW_AT_stmt_list
:
2630 unit
->line_offset
= attr
.u
.val
;
2634 unit
->name
= attr
.u
.str
;
2638 low_pc
= attr
.u
.val
;
2639 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
2640 this is the base address to use when reading location
2641 lists or range lists. */
2642 if (abbrev
->tag
== DW_TAG_compile_unit
)
2643 unit
->base_address
= low_pc
;
2647 high_pc
= attr
.u
.val
;
2648 high_pc_relative
= attr
.form
!= DW_FORM_addr
;
2652 if (!read_rangelist (unit
, &unit
->arange
, attr
.u
.val
))
2656 case DW_AT_comp_dir
:
2658 char *comp_dir
= attr
.u
.str
;
2661 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2662 directory, get rid of it. */
2663 char *cp
= strchr (comp_dir
, ':');
2665 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2668 unit
->comp_dir
= comp_dir
;
2676 if (high_pc_relative
)
2680 if (!arange_add (unit
, &unit
->arange
, low_pc
, high_pc
))
2684 unit
->first_child_die_ptr
= info_ptr
;
2688 /* Return TRUE if UNIT may contain the address given by ADDR. When
2689 there are functions written entirely with inline asm statements, the
2690 range info in the compilation unit header may not be correct. We
2691 need to consult the line info table to see if a compilation unit
2692 really contains the given address. */
2695 comp_unit_contains_address (struct comp_unit
*unit
, bfd_vma addr
)
2697 struct arange
*arange
;
2702 arange
= &unit
->arange
;
2705 if (addr
>= arange
->low
&& addr
< arange
->high
)
2707 arange
= arange
->next
;
2714 /* If UNIT contains ADDR, set the output parameters to the values for
2715 the line containing ADDR. The output parameters, FILENAME_PTR,
2716 FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
2719 Returns the range of addresses covered by the entry that was used
2720 to fill in *LINENUMBER_PTR or 0 if it was not filled in. */
2723 comp_unit_find_nearest_line (struct comp_unit
*unit
,
2725 const char **filename_ptr
,
2726 const char **functionname_ptr
,
2727 unsigned int *linenumber_ptr
,
2728 unsigned int *discriminator_ptr
,
2729 struct dwarf2_debug
*stash
)
2732 struct funcinfo
*function
;
2737 if (! unit
->line_table
)
2739 if (! unit
->stmtlist
)
2745 unit
->line_table
= decode_line_info (unit
, stash
);
2747 if (! unit
->line_table
)
2753 if (unit
->first_child_die_ptr
< unit
->end_ptr
2754 && ! scan_unit_for_symbols (unit
))
2762 func_p
= lookup_address_in_function_table (unit
, addr
,
2763 &function
, functionname_ptr
);
2764 if (func_p
&& (function
->tag
== DW_TAG_inlined_subroutine
))
2765 stash
->inliner_chain
= function
;
2767 return lookup_address_in_line_info_table (unit
->line_table
, addr
,
2773 /* Check to see if line info is already decoded in a comp_unit.
2774 If not, decode it. Returns TRUE if no errors were encountered;
2778 comp_unit_maybe_decode_line_info (struct comp_unit
*unit
,
2779 struct dwarf2_debug
*stash
)
2784 if (! unit
->line_table
)
2786 if (! unit
->stmtlist
)
2792 unit
->line_table
= decode_line_info (unit
, stash
);
2794 if (! unit
->line_table
)
2800 if (unit
->first_child_die_ptr
< unit
->end_ptr
2801 && ! scan_unit_for_symbols (unit
))
2811 /* If UNIT contains SYM at ADDR, set the output parameters to the
2812 values for the line containing SYM. The output parameters,
2813 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
2816 Return TRUE if UNIT contains SYM, and no errors were encountered;
2820 comp_unit_find_line (struct comp_unit
*unit
,
2823 const char **filename_ptr
,
2824 unsigned int *linenumber_ptr
,
2825 struct dwarf2_debug
*stash
)
2827 if (!comp_unit_maybe_decode_line_info (unit
, stash
))
2830 if (sym
->flags
& BSF_FUNCTION
)
2831 return lookup_symbol_in_function_table (unit
, sym
, addr
,
2835 return lookup_symbol_in_variable_table (unit
, sym
, addr
,
2840 static struct funcinfo
*
2841 reverse_funcinfo_list (struct funcinfo
*head
)
2843 struct funcinfo
*rhead
;
2844 struct funcinfo
*temp
;
2846 for (rhead
= NULL
; head
; head
= temp
)
2848 temp
= head
->prev_func
;
2849 head
->prev_func
= rhead
;
2855 static struct varinfo
*
2856 reverse_varinfo_list (struct varinfo
*head
)
2858 struct varinfo
*rhead
;
2859 struct varinfo
*temp
;
2861 for (rhead
= NULL
; head
; head
= temp
)
2863 temp
= head
->prev_var
;
2864 head
->prev_var
= rhead
;
2870 /* Extract all interesting funcinfos and varinfos of a compilation
2871 unit into hash tables for faster lookup. Returns TRUE if no
2872 errors were enountered; FALSE otherwise. */
2875 comp_unit_hash_info (struct dwarf2_debug
*stash
,
2876 struct comp_unit
*unit
,
2877 struct info_hash_table
*funcinfo_hash_table
,
2878 struct info_hash_table
*varinfo_hash_table
)
2880 struct funcinfo
* each_func
;
2881 struct varinfo
* each_var
;
2882 bfd_boolean okay
= TRUE
;
2884 BFD_ASSERT (stash
->info_hash_status
!= STASH_INFO_HASH_DISABLED
);
2886 if (!comp_unit_maybe_decode_line_info (unit
, stash
))
2889 BFD_ASSERT (!unit
->cached
);
2891 /* To preserve the original search order, we went to visit the function
2892 infos in the reversed order of the list. However, making the list
2893 bi-directional use quite a bit of extra memory. So we reverse
2894 the list first, traverse the list in the now reversed order and
2895 finally reverse the list again to get back the original order. */
2896 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
2897 for (each_func
= unit
->function_table
;
2899 each_func
= each_func
->prev_func
)
2901 /* Skip nameless functions. */
2902 if (each_func
->name
)
2903 /* There is no need to copy name string into hash table as
2904 name string is either in the dwarf string buffer or
2905 info in the stash. */
2906 okay
= insert_info_hash_table (funcinfo_hash_table
, each_func
->name
,
2907 (void*) each_func
, FALSE
);
2909 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
2913 /* We do the same for variable infos. */
2914 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
2915 for (each_var
= unit
->variable_table
;
2917 each_var
= each_var
->prev_var
)
2919 /* Skip stack vars and vars with no files or names. */
2920 if (each_var
->stack
== 0
2921 && each_var
->file
!= NULL
2922 && each_var
->name
!= NULL
)
2923 /* There is no need to copy name string into hash table as
2924 name string is either in the dwarf string buffer or
2925 info in the stash. */
2926 okay
= insert_info_hash_table (varinfo_hash_table
, each_var
->name
,
2927 (void*) each_var
, FALSE
);
2930 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
2931 unit
->cached
= TRUE
;
2935 /* Locate a section in a BFD containing debugging info. The search starts
2936 from the section after AFTER_SEC, or from the first section in the BFD if
2937 AFTER_SEC is NULL. The search works by examining the names of the
2938 sections. There are three permissiable names. The first two are given
2939 by DEBUG_SECTIONS[debug_info] (whose standard DWARF2 names are .debug_info
2940 and .zdebug_info). The third is a prefix .gnu.linkonce.wi.
2941 This is a variation on the .debug_info section which has a checksum
2942 describing the contents appended onto the name. This allows the linker to
2943 identify and discard duplicate debugging sections for different
2944 compilation units. */
2945 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
2948 find_debug_info (bfd
*abfd
, const struct dwarf_debug_section
*debug_sections
,
2949 asection
*after_sec
)
2954 if (after_sec
== NULL
)
2956 look
= debug_sections
[debug_info
].uncompressed_name
;
2957 msec
= bfd_get_section_by_name (abfd
, look
);
2961 look
= debug_sections
[debug_info
].compressed_name
;
2964 msec
= bfd_get_section_by_name (abfd
, look
);
2969 for (msec
= abfd
->sections
; msec
!= NULL
; msec
= msec
->next
)
2970 if (CONST_STRNEQ (msec
->name
, GNU_LINKONCE_INFO
))
2976 for (msec
= after_sec
->next
; msec
!= NULL
; msec
= msec
->next
)
2978 look
= debug_sections
[debug_info
].uncompressed_name
;
2979 if (strcmp (msec
->name
, look
) == 0)
2982 look
= debug_sections
[debug_info
].compressed_name
;
2983 if (look
!= NULL
&& strcmp (msec
->name
, look
) == 0)
2986 if (CONST_STRNEQ (msec
->name
, GNU_LINKONCE_INFO
))
2993 /* Transfer VMAs from object file to separate debug file. */
2996 set_debug_vma (bfd
*orig_bfd
, bfd
*debug_bfd
)
3000 for (s
= orig_bfd
->sections
, d
= debug_bfd
->sections
;
3001 s
!= NULL
&& d
!= NULL
;
3002 s
= s
->next
, d
= d
->next
)
3004 if ((d
->flags
& SEC_DEBUGGING
) != 0)
3006 /* ??? Assumes 1-1 correspondence between sections in the
3008 if (strcmp (s
->name
, d
->name
) == 0)
3010 d
->output_section
= s
->output_section
;
3011 d
->output_offset
= s
->output_offset
;
3017 /* Unset vmas for adjusted sections in STASH. */
3020 unset_sections (struct dwarf2_debug
*stash
)
3023 struct adjusted_section
*p
;
3025 i
= stash
->adjusted_section_count
;
3026 p
= stash
->adjusted_sections
;
3027 for (; i
> 0; i
--, p
++)
3028 p
->section
->vma
= 0;
3031 /* Set VMAs for allocated and .debug_info sections in ORIG_BFD, a
3032 relocatable object file. VMAs are normally all zero in relocatable
3033 object files, so if we want to distinguish locations in sections by
3034 address we need to set VMAs so the sections do not overlap. We
3035 also set VMA on .debug_info so that when we have multiple
3036 .debug_info sections (or the linkonce variant) they also do not
3037 overlap. The multiple .debug_info sections make up a single
3038 logical section. ??? We should probably do the same for other
3042 place_sections (bfd
*orig_bfd
, struct dwarf2_debug
*stash
)
3045 struct adjusted_section
*p
;
3047 const char *debug_info_name
;
3049 if (stash
->adjusted_section_count
!= 0)
3051 i
= stash
->adjusted_section_count
;
3052 p
= stash
->adjusted_sections
;
3053 for (; i
> 0; i
--, p
++)
3054 p
->section
->vma
= p
->adj_vma
;
3058 debug_info_name
= stash
->debug_sections
[debug_info
].uncompressed_name
;
3065 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
3069 if ((sect
->output_section
!= NULL
3070 && sect
->output_section
!= sect
3071 && (sect
->flags
& SEC_DEBUGGING
) == 0)
3075 is_debug_info
= (strcmp (sect
->name
, debug_info_name
) == 0
3076 || CONST_STRNEQ (sect
->name
, GNU_LINKONCE_INFO
));
3078 if (!((sect
->flags
& SEC_ALLOC
) != 0 && abfd
== orig_bfd
)
3084 if (abfd
== stash
->bfd_ptr
)
3086 abfd
= stash
->bfd_ptr
;
3090 stash
->adjusted_section_count
= -1;
3093 bfd_vma last_vma
= 0, last_dwarf
= 0;
3094 bfd_size_type amt
= i
* sizeof (struct adjusted_section
);
3096 p
= (struct adjusted_section
*) bfd_malloc (amt
);
3100 stash
->adjusted_sections
= p
;
3101 stash
->adjusted_section_count
= i
;
3108 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
3113 if ((sect
->output_section
!= NULL
3114 && sect
->output_section
!= sect
3115 && (sect
->flags
& SEC_DEBUGGING
) == 0)
3119 is_debug_info
= (strcmp (sect
->name
, debug_info_name
) == 0
3120 || CONST_STRNEQ (sect
->name
, GNU_LINKONCE_INFO
));
3122 if (!((sect
->flags
& SEC_ALLOC
) != 0 && abfd
== orig_bfd
)
3126 sz
= sect
->rawsize
? sect
->rawsize
: sect
->size
;
3130 BFD_ASSERT (sect
->alignment_power
== 0);
3131 sect
->vma
= last_dwarf
;
3136 /* Align the new address to the current section
3138 last_vma
= ((last_vma
3139 + ~((bfd_vma
) -1 << sect
->alignment_power
))
3140 & ((bfd_vma
) -1 << sect
->alignment_power
));
3141 sect
->vma
= last_vma
;
3146 p
->adj_vma
= sect
->vma
;
3149 if (abfd
== stash
->bfd_ptr
)
3151 abfd
= stash
->bfd_ptr
;
3155 if (orig_bfd
!= stash
->bfd_ptr
)
3156 set_debug_vma (orig_bfd
, stash
->bfd_ptr
);
3161 /* Look up a funcinfo by name using the given info hash table. If found,
3162 also update the locations pointed to by filename_ptr and linenumber_ptr.
3164 This function returns TRUE if a funcinfo that matches the given symbol
3165 and address is found with any error; otherwise it returns FALSE. */
3168 info_hash_lookup_funcinfo (struct info_hash_table
*hash_table
,
3171 const char **filename_ptr
,
3172 unsigned int *linenumber_ptr
)
3174 struct funcinfo
* each_func
;
3175 struct funcinfo
* best_fit
= NULL
;
3176 struct info_list_node
*node
;
3177 struct arange
*arange
;
3178 const char *name
= bfd_asymbol_name (sym
);
3179 asection
*sec
= bfd_get_section (sym
);
3181 for (node
= lookup_info_hash_table (hash_table
, name
);
3185 each_func
= (struct funcinfo
*) node
->info
;
3186 for (arange
= &each_func
->arange
;
3188 arange
= arange
->next
)
3190 if ((!each_func
->sec
|| each_func
->sec
== sec
)
3191 && addr
>= arange
->low
3192 && addr
< arange
->high
3194 || (arange
->high
- arange
->low
3195 < best_fit
->arange
.high
- best_fit
->arange
.low
)))
3196 best_fit
= each_func
;
3202 best_fit
->sec
= sec
;
3203 *filename_ptr
= best_fit
->file
;
3204 *linenumber_ptr
= best_fit
->line
;
3211 /* Look up a varinfo by name using the given info hash table. If found,
3212 also update the locations pointed to by filename_ptr and linenumber_ptr.
3214 This function returns TRUE if a varinfo that matches the given symbol
3215 and address is found with any error; otherwise it returns FALSE. */
3218 info_hash_lookup_varinfo (struct info_hash_table
*hash_table
,
3221 const char **filename_ptr
,
3222 unsigned int *linenumber_ptr
)
3224 const char *name
= bfd_asymbol_name (sym
);
3225 asection
*sec
= bfd_get_section (sym
);
3226 struct varinfo
* each
;
3227 struct info_list_node
*node
;
3229 for (node
= lookup_info_hash_table (hash_table
, name
);
3233 each
= (struct varinfo
*) node
->info
;
3234 if (each
->addr
== addr
3235 && (!each
->sec
|| each
->sec
== sec
))
3238 *filename_ptr
= each
->file
;
3239 *linenumber_ptr
= each
->line
;
3247 /* Update the funcinfo and varinfo info hash tables if they are
3248 not up to date. Returns TRUE if there is no error; otherwise
3249 returns FALSE and disable the info hash tables. */
3252 stash_maybe_update_info_hash_tables (struct dwarf2_debug
*stash
)
3254 struct comp_unit
*each
;
3256 /* Exit if hash tables are up-to-date. */
3257 if (stash
->all_comp_units
== stash
->hash_units_head
)
3260 if (stash
->hash_units_head
)
3261 each
= stash
->hash_units_head
->prev_unit
;
3263 each
= stash
->last_comp_unit
;
3267 if (!comp_unit_hash_info (stash
, each
, stash
->funcinfo_hash_table
,
3268 stash
->varinfo_hash_table
))
3270 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
3273 each
= each
->prev_unit
;
3276 stash
->hash_units_head
= stash
->all_comp_units
;
3280 /* Check consistency of info hash tables. This is for debugging only. */
3282 static void ATTRIBUTE_UNUSED
3283 stash_verify_info_hash_table (struct dwarf2_debug
*stash
)
3285 struct comp_unit
*each_unit
;
3286 struct funcinfo
*each_func
;
3287 struct varinfo
*each_var
;
3288 struct info_list_node
*node
;
3291 for (each_unit
= stash
->all_comp_units
;
3293 each_unit
= each_unit
->next_unit
)
3295 for (each_func
= each_unit
->function_table
;
3297 each_func
= each_func
->prev_func
)
3299 if (!each_func
->name
)
3301 node
= lookup_info_hash_table (stash
->funcinfo_hash_table
,
3305 while (node
&& !found
)
3307 found
= node
->info
== each_func
;
3313 for (each_var
= each_unit
->variable_table
;
3315 each_var
= each_var
->prev_var
)
3317 if (!each_var
->name
|| !each_var
->file
|| each_var
->stack
)
3319 node
= lookup_info_hash_table (stash
->varinfo_hash_table
,
3323 while (node
&& !found
)
3325 found
= node
->info
== each_var
;
3333 /* Check to see if we want to enable the info hash tables, which consume
3334 quite a bit of memory. Currently we only check the number times
3335 bfd_dwarf2_find_line is called. In the future, we may also want to
3336 take the number of symbols into account. */
3339 stash_maybe_enable_info_hash_tables (bfd
*abfd
, struct dwarf2_debug
*stash
)
3341 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_OFF
);
3343 if (stash
->info_hash_count
++ < STASH_INFO_HASH_TRIGGER
)
3346 /* FIXME: Maybe we should check the reduce_memory_overheads
3347 and optimize fields in the bfd_link_info structure ? */
3349 /* Create hash tables. */
3350 stash
->funcinfo_hash_table
= create_info_hash_table (abfd
);
3351 stash
->varinfo_hash_table
= create_info_hash_table (abfd
);
3352 if (!stash
->funcinfo_hash_table
|| !stash
->varinfo_hash_table
)
3354 /* Turn off info hashes if any allocation above fails. */
3355 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
3358 /* We need a forced update so that the info hash tables will
3359 be created even though there is no compilation unit. That
3360 happens if STASH_INFO_HASH_TRIGGER is 0. */
3361 stash_maybe_update_info_hash_tables (stash
);
3362 stash
->info_hash_status
= STASH_INFO_HASH_ON
;
3365 /* Find the file and line associated with a symbol and address using the
3366 info hash tables of a stash. If there is a match, the function returns
3367 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
3368 otherwise it returns FALSE. */
3371 stash_find_line_fast (struct dwarf2_debug
*stash
,
3374 const char **filename_ptr
,
3375 unsigned int *linenumber_ptr
)
3377 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_ON
);
3379 if (sym
->flags
& BSF_FUNCTION
)
3380 return info_hash_lookup_funcinfo (stash
->funcinfo_hash_table
, sym
, addr
,
3381 filename_ptr
, linenumber_ptr
);
3382 return info_hash_lookup_varinfo (stash
->varinfo_hash_table
, sym
, addr
,
3383 filename_ptr
, linenumber_ptr
);
3386 /* Save current section VMAs. */
3389 save_section_vma (const bfd
*abfd
, struct dwarf2_debug
*stash
)
3394 if (abfd
->section_count
== 0)
3396 stash
->sec_vma
= bfd_malloc (sizeof (*stash
->sec_vma
) * abfd
->section_count
);
3397 if (stash
->sec_vma
== NULL
)
3399 for (i
= 0, s
= abfd
->sections
; i
< abfd
->section_count
; i
++, s
= s
->next
)
3401 if (s
->output_section
!= NULL
)
3402 stash
->sec_vma
[i
] = s
->output_section
->vma
+ s
->output_offset
;
3404 stash
->sec_vma
[i
] = s
->vma
;
3409 /* Compare current section VMAs against those at the time the stash
3410 was created. If find_nearest_line is used in linker warnings or
3411 errors early in the link process, the debug info stash will be
3412 invalid for later calls. This is because we relocate debug info
3413 sections, so the stashed section contents depend on symbol values,
3414 which in turn depend on section VMAs. */
3417 section_vma_same (const bfd
*abfd
, const struct dwarf2_debug
*stash
)
3422 for (i
= 0, s
= abfd
->sections
; i
< abfd
->section_count
; i
++, s
= s
->next
)
3426 if (s
->output_section
!= NULL
)
3427 vma
= s
->output_section
->vma
+ s
->output_offset
;
3430 if (vma
!= stash
->sec_vma
[i
])
3436 /* Read debug information from DEBUG_BFD when DEBUG_BFD is specified.
3437 If DEBUG_BFD is not specified, we read debug information from ABFD
3438 or its gnu_debuglink. The results will be stored in PINFO.
3439 The function returns TRUE iff debug information is ready. */
3442 _bfd_dwarf2_slurp_debug_info (bfd
*abfd
, bfd
*debug_bfd
,
3443 const struct dwarf_debug_section
*debug_sections
,
3446 bfd_boolean do_place
)
3448 bfd_size_type amt
= sizeof (struct dwarf2_debug
);
3449 bfd_size_type total_size
;
3451 struct dwarf2_debug
*stash
= (struct dwarf2_debug
*) *pinfo
;
3455 if (section_vma_same (abfd
, stash
))
3457 _bfd_dwarf2_cleanup_debug_info (abfd
, pinfo
);
3458 memset (stash
, 0, amt
);
3462 stash
= (struct dwarf2_debug
*) bfd_zalloc (abfd
, amt
);
3466 stash
->debug_sections
= debug_sections
;
3467 stash
->syms
= symbols
;
3468 if (!save_section_vma (abfd
, stash
))
3473 if (debug_bfd
== NULL
)
3476 msec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
3477 if (msec
== NULL
&& abfd
== debug_bfd
)
3479 char * debug_filename
= bfd_follow_gnu_debuglink (abfd
, DEBUGDIR
);
3481 if (debug_filename
== NULL
)
3482 /* No dwarf2 info, and no gnu_debuglink to follow.
3483 Note that at this point the stash has been allocated, but
3484 contains zeros. This lets future calls to this function
3485 fail more quickly. */
3488 if ((debug_bfd
= bfd_openr (debug_filename
, NULL
)) == NULL
3489 || ! bfd_check_format (debug_bfd
, bfd_object
)
3490 || (msec
= find_debug_info (debug_bfd
,
3491 debug_sections
, NULL
)) == NULL
3492 || !bfd_generic_link_read_symbols (debug_bfd
))
3495 bfd_close (debug_bfd
);
3496 /* FIXME: Should we report our failure to follow the debuglink ? */
3497 free (debug_filename
);
3501 symbols
= bfd_get_outsymbols (debug_bfd
);
3502 stash
->syms
= symbols
;
3503 stash
->close_on_cleanup
= TRUE
;
3505 stash
->bfd_ptr
= debug_bfd
;
3508 && !place_sections (abfd
, stash
))
3511 /* There can be more than one DWARF2 info section in a BFD these
3512 days. First handle the easy case when there's only one. If
3513 there's more than one, try case two: none of the sections is
3514 compressed. In that case, read them all in and produce one
3515 large stash. We do this in two passes - in the first pass we
3516 just accumulate the section sizes, and in the second pass we
3517 read in the section's contents. (The allows us to avoid
3518 reallocing the data as we add sections to the stash.) If
3519 some or all sections are compressed, then do things the slow
3520 way, with a bunch of reallocs. */
3522 if (! find_debug_info (debug_bfd
, debug_sections
, msec
))
3524 /* Case 1: only one info section. */
3525 total_size
= msec
->size
;
3526 if (! read_section (debug_bfd
, &stash
->debug_sections
[debug_info
],
3528 &stash
->info_ptr_memory
, &total_size
))
3533 /* Case 2: multiple sections. */
3534 for (total_size
= 0;
3536 msec
= find_debug_info (debug_bfd
, debug_sections
, msec
))
3537 total_size
+= msec
->size
;
3539 stash
->info_ptr_memory
= (bfd_byte
*) bfd_malloc (total_size
);
3540 if (stash
->info_ptr_memory
== NULL
)
3544 for (msec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
3546 msec
= find_debug_info (debug_bfd
, debug_sections
, msec
))
3554 if (!(bfd_simple_get_relocated_section_contents
3555 (debug_bfd
, msec
, stash
->info_ptr_memory
+ total_size
,
3563 stash
->info_ptr
= stash
->info_ptr_memory
;
3564 stash
->info_ptr_end
= stash
->info_ptr
+ total_size
;
3565 stash
->sec
= find_debug_info (debug_bfd
, debug_sections
, NULL
);
3566 stash
->sec_info_ptr
= stash
->info_ptr
;
3570 /* Find the source code location of SYMBOL. If SYMBOL is NULL
3571 then find the nearest source code location corresponding to
3572 the address SECTION + OFFSET.
3573 Returns TRUE if the line is found without error and fills in
3574 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
3575 NULL the FUNCTIONNAME_PTR is also filled in.
3576 SYMBOLS contains the symbol table for ABFD.
3577 DEBUG_SECTIONS contains the name of the dwarf debug sections.
3578 ADDR_SIZE is the number of bytes in the initial .debug_info length
3579 field and in the abbreviation offset, or zero to indicate that the
3580 default value should be used. */
3583 find_line (bfd
*abfd
,
3584 const struct dwarf_debug_section
*debug_sections
,
3589 const char **filename_ptr
,
3590 const char **functionname_ptr
,
3591 unsigned int *linenumber_ptr
,
3592 unsigned int *discriminator_ptr
,
3593 unsigned int addr_size
,
3596 /* Read each compilation unit from the section .debug_info, and check
3597 to see if it contains the address we are searching for. If yes,
3598 lookup the address, and return the line number info. If no, go
3599 on to the next compilation unit.
3601 We keep a list of all the previously read compilation units, and
3602 a pointer to the next un-read compilation unit. Check the
3603 previously read units before reading more. */
3604 struct dwarf2_debug
*stash
;
3605 /* What address are we looking for? */
3607 struct comp_unit
* each
;
3608 bfd_boolean found
= FALSE
;
3609 bfd_boolean do_line
;
3611 *filename_ptr
= NULL
;
3612 if (functionname_ptr
!= NULL
)
3613 *functionname_ptr
= NULL
;
3614 *linenumber_ptr
= 0;
3615 if (discriminator_ptr
)
3616 *discriminator_ptr
= 0;
3618 if (! _bfd_dwarf2_slurp_debug_info (abfd
, NULL
, debug_sections
,
3620 (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0))
3623 stash
= (struct dwarf2_debug
*) *pinfo
;
3625 do_line
= (section
== NULL
3627 && functionname_ptr
== NULL
3631 addr
= symbol
->value
;
3632 section
= bfd_get_section (symbol
);
3634 else if (section
!= NULL
3635 && functionname_ptr
!= NULL
3641 if (section
->output_section
)
3642 addr
+= section
->output_section
->vma
+ section
->output_offset
;
3644 addr
+= section
->vma
;
3646 /* A null info_ptr indicates that there is no dwarf2 info
3647 (or that an error occured while setting up the stash). */
3648 if (! stash
->info_ptr
)
3651 stash
->inliner_chain
= NULL
;
3653 /* Check the previously read comp. units first. */
3656 /* The info hash tables use quite a bit of memory. We may not want to
3657 always use them. We use some heuristics to decide if and when to
3659 if (stash
->info_hash_status
== STASH_INFO_HASH_OFF
)
3660 stash_maybe_enable_info_hash_tables (abfd
, stash
);
3662 /* Keep info hash table up to date if they are available. Note that we
3663 may disable the hash tables if there is any error duing update. */
3664 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
3665 stash_maybe_update_info_hash_tables (stash
);
3667 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
3669 found
= stash_find_line_fast (stash
, symbol
, addr
, filename_ptr
,
3676 /* Check the previously read comp. units first. */
3677 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
3678 if ((symbol
->flags
& BSF_FUNCTION
) == 0
3679 || each
->arange
.high
== 0
3680 || comp_unit_contains_address (each
, addr
))
3682 found
= comp_unit_find_line (each
, symbol
, addr
, filename_ptr
,
3683 linenumber_ptr
, stash
);
3691 bfd_vma min_range
= (bfd_vma
) -1;
3692 const char * local_filename
= NULL
;
3693 const char * local_functionname
= NULL
;
3694 unsigned int local_linenumber
= 0;
3695 unsigned int local_discriminator
= 0;
3697 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
3699 bfd_vma range
= (bfd_vma
) -1;
3701 found
= ((each
->arange
.high
== 0
3702 || comp_unit_contains_address (each
, addr
))
3703 && (range
= comp_unit_find_nearest_line (each
, addr
,
3705 & local_functionname
,
3707 & local_discriminator
,
3711 /* PRs 15935 15994: Bogus debug information may have provided us
3712 with an erroneous match. We attempt to counter this by
3713 selecting the match that has the smallest address range
3714 associated with it. (We are assuming that corrupt debug info
3715 will tend to result in extra large address ranges rather than
3716 extra small ranges).
3718 This does mean that we scan through all of the CUs associated
3719 with the bfd each time this function is called. But this does
3720 have the benefit of producing consistent results every time the
3721 function is called. */
3722 if (range
<= min_range
)
3724 if (filename_ptr
&& local_filename
)
3725 * filename_ptr
= local_filename
;
3726 if (functionname_ptr
&& local_functionname
)
3727 * functionname_ptr
= local_functionname
;
3728 if (discriminator_ptr
&& local_discriminator
)
3729 * discriminator_ptr
= local_discriminator
;
3730 if (local_linenumber
)
3731 * linenumber_ptr
= local_linenumber
;
3737 if (* linenumber_ptr
)
3744 /* The DWARF2 spec says that the initial length field, and the
3745 offset of the abbreviation table, should both be 4-byte values.
3746 However, some compilers do things differently. */
3749 BFD_ASSERT (addr_size
== 4 || addr_size
== 8);
3751 /* Read each remaining comp. units checking each as they are read. */
3752 while (stash
->info_ptr
< stash
->info_ptr_end
)
3755 unsigned int offset_size
= addr_size
;
3756 bfd_byte
*info_ptr_unit
= stash
->info_ptr
;
3758 length
= read_4_bytes (stash
->bfd_ptr
, stash
->info_ptr
);
3759 /* A 0xffffff length is the DWARF3 way of indicating
3760 we use 64-bit offsets, instead of 32-bit offsets. */
3761 if (length
== 0xffffffff)
3764 length
= read_8_bytes (stash
->bfd_ptr
, stash
->info_ptr
+ 4);
3765 stash
->info_ptr
+= 12;
3767 /* A zero length is the IRIX way of indicating 64-bit offsets,
3768 mostly because the 64-bit length will generally fit in 32
3769 bits, and the endianness helps. */
3770 else if (length
== 0)
3773 length
= read_4_bytes (stash
->bfd_ptr
, stash
->info_ptr
+ 4);
3774 stash
->info_ptr
+= 8;
3776 /* In the absence of the hints above, we assume 32-bit DWARF2
3777 offsets even for targets with 64-bit addresses, because:
3778 a) most of the time these targets will not have generated
3779 more than 2Gb of debug info and so will not need 64-bit
3782 b) if they do use 64-bit offsets but they are not using
3783 the size hints that are tested for above then they are
3784 not conforming to the DWARF3 standard anyway. */
3785 else if (addr_size
== 8)
3788 stash
->info_ptr
+= 4;
3791 stash
->info_ptr
+= 4;
3795 each
= parse_comp_unit (stash
, length
, info_ptr_unit
,
3798 /* The dwarf information is damaged, don't trust it any
3801 stash
->info_ptr
+= length
;
3803 if (stash
->all_comp_units
)
3804 stash
->all_comp_units
->prev_unit
= each
;
3806 stash
->last_comp_unit
= each
;
3808 each
->next_unit
= stash
->all_comp_units
;
3809 stash
->all_comp_units
= each
;
3811 /* DW_AT_low_pc and DW_AT_high_pc are optional for
3812 compilation units. If we don't have them (i.e.,
3813 unit->high == 0), we need to consult the line info table
3814 to see if a compilation unit contains the given
3817 found
= (((symbol
->flags
& BSF_FUNCTION
) == 0
3818 || each
->arange
.high
== 0
3819 || comp_unit_contains_address (each
, addr
))
3820 && comp_unit_find_line (each
, symbol
, addr
,
3825 found
= ((each
->arange
.high
== 0
3826 || comp_unit_contains_address (each
, addr
))
3827 && comp_unit_find_nearest_line (each
, addr
,
3834 if ((bfd_vma
) (stash
->info_ptr
- stash
->sec_info_ptr
)
3835 == stash
->sec
->size
)
3837 stash
->sec
= find_debug_info (stash
->bfd_ptr
, debug_sections
,
3839 stash
->sec_info_ptr
= stash
->info_ptr
;
3848 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
3849 unset_sections (stash
);
3854 /* The DWARF2 version of find_nearest_line.
3855 Return TRUE if the line is found without error. */
3858 _bfd_dwarf2_find_nearest_line (bfd
*abfd
,
3859 const struct dwarf_debug_section
*debug_sections
,
3863 const char **filename_ptr
,
3864 const char **functionname_ptr
,
3865 unsigned int *linenumber_ptr
,
3866 unsigned int *discriminator_ptr
,
3867 unsigned int addr_size
,
3870 return find_line (abfd
, debug_sections
, section
, offset
, NULL
, symbols
,
3871 filename_ptr
, functionname_ptr
, linenumber_ptr
,
3872 discriminator_ptr
, addr_size
, pinfo
);
3875 /* The DWARF2 version of find_line.
3876 Return TRUE if the line is found without error. */
3879 _bfd_dwarf2_find_line (bfd
*abfd
,
3882 const char **filename_ptr
,
3883 unsigned int *linenumber_ptr
,
3884 unsigned int *discriminator_ptr
,
3885 unsigned int addr_size
,
3888 return find_line (abfd
, dwarf_debug_sections
, NULL
, 0, symbol
, symbols
,
3889 filename_ptr
, NULL
, linenumber_ptr
, discriminator_ptr
,
3894 _bfd_dwarf2_find_inliner_info (bfd
*abfd ATTRIBUTE_UNUSED
,
3895 const char **filename_ptr
,
3896 const char **functionname_ptr
,
3897 unsigned int *linenumber_ptr
,
3900 struct dwarf2_debug
*stash
;
3902 stash
= (struct dwarf2_debug
*) *pinfo
;
3905 struct funcinfo
*func
= stash
->inliner_chain
;
3907 if (func
&& func
->caller_func
)
3909 *filename_ptr
= func
->caller_file
;
3910 *functionname_ptr
= func
->caller_func
->name
;
3911 *linenumber_ptr
= func
->caller_line
;
3912 stash
->inliner_chain
= func
->caller_func
;
3921 _bfd_dwarf2_cleanup_debug_info (bfd
*abfd
, void **pinfo
)
3923 struct dwarf2_debug
*stash
= (struct dwarf2_debug
*) *pinfo
;
3924 struct comp_unit
*each
;
3926 if (abfd
== NULL
|| stash
== NULL
)
3929 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
3931 struct abbrev_info
**abbrevs
= each
->abbrevs
;
3932 struct funcinfo
*function_table
= each
->function_table
;
3933 struct varinfo
*variable_table
= each
->variable_table
;
3936 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
3938 struct abbrev_info
*abbrev
= abbrevs
[i
];
3942 free (abbrev
->attrs
);
3943 abbrev
= abbrev
->next
;
3947 if (each
->line_table
)
3949 free (each
->line_table
->dirs
);
3950 free (each
->line_table
->files
);
3953 while (function_table
)
3955 if (function_table
->file
)
3957 free (function_table
->file
);
3958 function_table
->file
= NULL
;
3961 if (function_table
->caller_file
)
3963 free (function_table
->caller_file
);
3964 function_table
->caller_file
= NULL
;
3966 function_table
= function_table
->prev_func
;
3969 while (variable_table
)
3971 if (variable_table
->file
)
3973 free (variable_table
->file
);
3974 variable_table
->file
= NULL
;
3977 variable_table
= variable_table
->prev_var
;
3981 if (stash
->dwarf_abbrev_buffer
)
3982 free (stash
->dwarf_abbrev_buffer
);
3983 if (stash
->dwarf_line_buffer
)
3984 free (stash
->dwarf_line_buffer
);
3985 if (stash
->dwarf_str_buffer
)
3986 free (stash
->dwarf_str_buffer
);
3987 if (stash
->dwarf_ranges_buffer
)
3988 free (stash
->dwarf_ranges_buffer
);
3989 if (stash
->info_ptr_memory
)
3990 free (stash
->info_ptr_memory
);
3991 if (stash
->close_on_cleanup
)
3992 bfd_close (stash
->bfd_ptr
);
3993 if (stash
->alt_dwarf_str_buffer
)
3994 free (stash
->alt_dwarf_str_buffer
);
3995 if (stash
->alt_dwarf_info_buffer
)
3996 free (stash
->alt_dwarf_info_buffer
);
3998 free (stash
->sec_vma
);
3999 if (stash
->adjusted_sections
)
4000 free (stash
->adjusted_sections
);
4001 if (stash
->alt_bfd_ptr
)
4002 bfd_close (stash
->alt_bfd_ptr
);