2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
5 Adapted from gdb/dwarf2read.c by Gavin Koch of Cygnus Solutions
8 From the dwarf2read.c header:
9 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
10 Inc. with support from Florida State University (under contract
11 with the Ada Joint Program Office), and Silicon Graphics, Inc.
12 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
13 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
14 support in dwarfread.c
16 This file is part of BFD.
18 This program is free software; you can redistribute it and/or modify
19 it under the terms of the GNU General Public License as published by
20 the Free Software Foundation; either version 3 of the License, or (at
21 your option) any later version.
23 This program is distributed in the hope that it will be useful, but
24 WITHOUT ANY WARRANTY; without even the implied warranty of
25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
26 General Public License for more details.
28 You should have received a copy of the GNU General Public License
29 along with this program; if not, write to the Free Software
30 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
31 MA 02110-1301, USA. */
35 #include "libiberty.h"
40 /* The data in the .debug_line statement prologue looks like this. */
45 unsigned short version
;
46 bfd_vma prologue_length
;
47 unsigned char minimum_instruction_length
;
48 unsigned char maximum_ops_per_insn
;
49 unsigned char default_is_stmt
;
51 unsigned char line_range
;
52 unsigned char opcode_base
;
53 unsigned char *standard_opcode_lengths
;
56 /* Attributes have a name and a value. */
60 enum dwarf_attribute name
;
65 struct dwarf_block
*blk
;
72 /* Blocks are a bunch of untyped bytes. */
79 struct adjusted_section
87 /* A list of all previously read comp_units. */
88 struct comp_unit
*all_comp_units
;
90 /* Last comp unit in list above. */
91 struct comp_unit
*last_comp_unit
;
93 /* The next unread compilation unit within the .debug_info section.
94 Zero indicates that the .debug_info section has not been loaded
98 /* Pointer to the end of the .debug_info section memory buffer. */
99 bfd_byte
*info_ptr_end
;
101 /* Pointer to the bfd, section and address of the beginning of the
102 section. The bfd might be different than expected because of
103 gnu_debuglink sections. */
106 bfd_byte
*sec_info_ptr
;
108 /* A pointer to the memory block allocated for info_ptr. Neither
109 info_ptr nor sec_info_ptr are guaranteed to stay pointing to the
110 beginning of the malloc block. This is used only to free the
112 bfd_byte
*info_ptr_memory
;
114 /* Pointer to the symbol table. */
117 /* Pointer to the .debug_abbrev section loaded into memory. */
118 bfd_byte
*dwarf_abbrev_buffer
;
120 /* Length of the loaded .debug_abbrev section. */
121 bfd_size_type dwarf_abbrev_size
;
123 /* Buffer for decode_line_info. */
124 bfd_byte
*dwarf_line_buffer
;
126 /* Length of the loaded .debug_line section. */
127 bfd_size_type dwarf_line_size
;
129 /* Pointer to the .debug_str section loaded into memory. */
130 bfd_byte
*dwarf_str_buffer
;
132 /* Length of the loaded .debug_str section. */
133 bfd_size_type dwarf_str_size
;
135 /* Pointer to the .debug_ranges section loaded into memory. */
136 bfd_byte
*dwarf_ranges_buffer
;
138 /* Length of the loaded .debug_ranges section. */
139 bfd_size_type dwarf_ranges_size
;
141 /* If the most recent call to bfd_find_nearest_line was given an
142 address in an inlined function, preserve a pointer into the
143 calling chain for subsequent calls to bfd_find_inliner_info to
145 struct funcinfo
*inliner_chain
;
147 /* Number of sections whose VMA we must adjust. */
148 unsigned int adjusted_section_count
;
150 /* Array of sections with adjusted VMA. */
151 struct adjusted_section
*adjusted_sections
;
153 /* Number of times find_line is called. This is used in
154 the heuristic for enabling the info hash tables. */
157 #define STASH_INFO_HASH_TRIGGER 100
159 /* Hash table mapping symbol names to function infos. */
160 struct info_hash_table
*funcinfo_hash_table
;
162 /* Hash table mapping symbol names to variable infos. */
163 struct info_hash_table
*varinfo_hash_table
;
165 /* Head of comp_unit list in the last hash table update. */
166 struct comp_unit
*hash_units_head
;
168 /* Status of info hash. */
169 int info_hash_status
;
170 #define STASH_INFO_HASH_OFF 0
171 #define STASH_INFO_HASH_ON 1
172 #define STASH_INFO_HASH_DISABLED 2
182 /* A minimal decoding of DWARF2 compilation units. We only decode
183 what's needed to get to the line number information. */
187 /* Chain the previously read compilation units. */
188 struct comp_unit
*next_unit
;
190 /* Likewise, chain the compilation unit read after this one.
191 The comp units are stored in reversed reading order. */
192 struct comp_unit
*prev_unit
;
194 /* Keep the bfd convenient (for memory allocation). */
197 /* The lowest and highest addresses contained in this compilation
198 unit as specified in the compilation unit header. */
199 struct arange arange
;
201 /* The DW_AT_name attribute (for error messages). */
204 /* The abbrev hash table. */
205 struct abbrev_info
**abbrevs
;
207 /* Note that an error was found by comp_unit_find_nearest_line. */
210 /* The DW_AT_comp_dir attribute. */
213 /* TRUE if there is a line number table associated with this comp. unit. */
216 /* Pointer to the current comp_unit so that we can find a given entry
218 bfd_byte
*info_ptr_unit
;
220 /* Pointer to the start of the debug section, for DW_FORM_ref_addr. */
221 bfd_byte
*sec_info_ptr
;
223 /* The offset into .debug_line of the line number table. */
224 unsigned long line_offset
;
226 /* Pointer to the first child die for the comp unit. */
227 bfd_byte
*first_child_die_ptr
;
229 /* The end of the comp unit. */
232 /* The decoded line number, NULL if not yet decoded. */
233 struct line_info_table
*line_table
;
235 /* A list of the functions found in this comp. unit. */
236 struct funcinfo
*function_table
;
238 /* A list of the variables found in this comp. unit. */
239 struct varinfo
*variable_table
;
241 /* Pointer to dwarf2_debug structure. */
242 struct dwarf2_debug
*stash
;
244 /* DWARF format version for this unit - from unit header. */
247 /* Address size for this unit - from unit header. */
248 unsigned char addr_size
;
250 /* Offset size for this unit - from unit header. */
251 unsigned char offset_size
;
253 /* Base address for this unit - from DW_AT_low_pc attribute of
254 DW_TAG_compile_unit DIE */
255 bfd_vma base_address
;
257 /* TRUE if symbols are cached in hash table for faster lookup by name. */
261 /* This data structure holds the information of an abbrev. */
264 unsigned int number
; /* Number identifying abbrev. */
265 enum dwarf_tag tag
; /* DWARF tag. */
266 int has_children
; /* Boolean. */
267 unsigned int num_attrs
; /* Number of attributes. */
268 struct attr_abbrev
*attrs
; /* An array of attribute descriptions. */
269 struct abbrev_info
*next
; /* Next in chain. */
274 enum dwarf_attribute name
;
275 enum dwarf_form form
;
278 #ifndef ABBREV_HASH_SIZE
279 #define ABBREV_HASH_SIZE 121
281 #ifndef ATTR_ALLOC_CHUNK
282 #define ATTR_ALLOC_CHUNK 4
285 /* Variable and function hash tables. This is used to speed up look-up
286 in lookup_symbol_in_var_table() and lookup_symbol_in_function_table().
287 In order to share code between variable and function infos, we use
288 a list of untyped pointer for all variable/function info associated with
289 a symbol. We waste a bit of memory for list with one node but that
290 simplifies the code. */
292 struct info_list_node
294 struct info_list_node
*next
;
298 /* Info hash entry. */
299 struct info_hash_entry
301 struct bfd_hash_entry root
;
302 struct info_list_node
*head
;
305 struct info_hash_table
307 struct bfd_hash_table base
;
310 /* Function to create a new entry in info hash table. */
312 static struct bfd_hash_entry
*
313 info_hash_table_newfunc (struct bfd_hash_entry
*entry
,
314 struct bfd_hash_table
*table
,
317 struct info_hash_entry
*ret
= (struct info_hash_entry
*) entry
;
319 /* Allocate the structure if it has not already been allocated by a
323 ret
= (struct info_hash_entry
*) bfd_hash_allocate (table
,
329 /* Call the allocation method of the base class. */
330 ret
= ((struct info_hash_entry
*)
331 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
333 /* Initialize the local fields here. */
337 return (struct bfd_hash_entry
*) ret
;
340 /* Function to create a new info hash table. It returns a pointer to the
341 newly created table or NULL if there is any error. We need abfd
342 solely for memory allocation. */
344 static struct info_hash_table
*
345 create_info_hash_table (bfd
*abfd
)
347 struct info_hash_table
*hash_table
;
349 hash_table
= (struct info_hash_table
*)
350 bfd_alloc (abfd
, sizeof (struct info_hash_table
));
354 if (!bfd_hash_table_init (&hash_table
->base
, info_hash_table_newfunc
,
355 sizeof (struct info_hash_entry
)))
357 bfd_release (abfd
, hash_table
);
364 /* Insert an info entry into an info hash table. We do not check of
365 duplicate entries. Also, the caller need to guarantee that the
366 right type of info in inserted as info is passed as a void* pointer.
367 This function returns true if there is no error. */
370 insert_info_hash_table (struct info_hash_table
*hash_table
,
375 struct info_hash_entry
*entry
;
376 struct info_list_node
*node
;
378 entry
= (struct info_hash_entry
*) bfd_hash_lookup (&hash_table
->base
,
383 node
= (struct info_list_node
*) bfd_hash_allocate (&hash_table
->base
,
389 node
->next
= entry
->head
;
395 /* Look up an info entry list from an info hash table. Return NULL
398 static struct info_list_node
*
399 lookup_info_hash_table (struct info_hash_table
*hash_table
, const char *key
)
401 struct info_hash_entry
*entry
;
403 entry
= (struct info_hash_entry
*) bfd_hash_lookup (&hash_table
->base
, key
,
405 return entry
? entry
->head
: NULL
;
408 /* Read a section, uncompress it if necessary, and relocate it. */
411 read_and_uncompress_section (bfd
* abfd
,
413 bfd_boolean section_is_compressed
,
415 bfd_byte
** section_buffer
,
416 bfd_size_type
* section_size
)
418 /* Get the unrelocated contents of the section. */
419 *section_buffer
= (bfd_byte
*) bfd_malloc (*section_size
);
420 if (! *section_buffer
)
422 if (! bfd_get_section_contents (abfd
, msec
, *section_buffer
,
426 if (section_is_compressed
)
428 if (! bfd_uncompress_section_contents (section_buffer
, section_size
))
430 (*_bfd_error_handler
) (_("Dwarf Error: unable to decompress %s section."),
431 bfd_get_section_name (abfd
, msec
));
432 bfd_set_error (bfd_error_bad_value
);
439 /* We want to relocate the data we've already read (and
440 decompressed), so we store a pointer to the data in
441 the bfd_section, and tell it that the contents are
442 already in memory. */
443 BFD_ASSERT (msec
->contents
== NULL
&& (msec
->flags
& SEC_IN_MEMORY
) == 0);
444 msec
->contents
= *section_buffer
;
445 msec
->flags
|= SEC_IN_MEMORY
;
446 msec
->size
= *section_size
;
448 = bfd_simple_get_relocated_section_contents (abfd
, msec
, NULL
, syms
);
449 if (! *section_buffer
)
456 /* Read a section into its appropriate place in the dwarf2_debug
457 struct (indicated by SECTION_BUFFER and SECTION_SIZE). If SYMS is
458 not NULL, use bfd_simple_get_relocated_section_contents to read the
459 section contents, otherwise use bfd_get_section_contents. Fail if
460 the located section does not contain at least OFFSET bytes. */
463 read_section (bfd
* abfd
,
464 const char * section_name
,
465 const char * compressed_section_name
,
468 bfd_byte
** section_buffer
,
469 bfd_size_type
* section_size
)
472 bfd_boolean section_is_compressed
= FALSE
;
474 /* read_section is a noop if the section has already been read. */
475 if (!*section_buffer
)
477 msec
= bfd_get_section_by_name (abfd
, section_name
);
478 if (! msec
&& compressed_section_name
)
480 msec
= bfd_get_section_by_name (abfd
, compressed_section_name
);
481 section_is_compressed
= TRUE
;
485 (*_bfd_error_handler
) (_("Dwarf Error: Can't find %s section."), section_name
);
486 bfd_set_error (bfd_error_bad_value
);
490 *section_size
= msec
->rawsize
? msec
->rawsize
: msec
->size
;
492 if (! read_and_uncompress_section (abfd
, msec
, section_is_compressed
,
493 syms
, section_buffer
, section_size
))
497 /* It is possible to get a bad value for the offset into the section
498 that the client wants. Validate it here to avoid trouble later. */
499 if (offset
!= 0 && offset
>= *section_size
)
501 (*_bfd_error_handler
) (_("Dwarf Error: Offset (%lu) greater than or equal to %s size (%lu)."),
502 (long) offset
, section_name
, *section_size
);
503 bfd_set_error (bfd_error_bad_value
);
511 The following function up to the END VERBATIM mark are
512 copied directly from dwarf2read.c. */
514 /* Read dwarf information from a buffer. */
517 read_1_byte (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_byte
*buf
)
519 return bfd_get_8 (abfd
, buf
);
523 read_1_signed_byte (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_byte
*buf
)
525 return bfd_get_signed_8 (abfd
, buf
);
529 read_2_bytes (bfd
*abfd
, bfd_byte
*buf
)
531 return bfd_get_16 (abfd
, buf
);
535 read_4_bytes (bfd
*abfd
, bfd_byte
*buf
)
537 return bfd_get_32 (abfd
, buf
);
541 read_8_bytes (bfd
*abfd
, bfd_byte
*buf
)
543 return bfd_get_64 (abfd
, buf
);
547 read_n_bytes (bfd
*abfd ATTRIBUTE_UNUSED
,
549 unsigned int size ATTRIBUTE_UNUSED
)
555 read_string (bfd
*abfd ATTRIBUTE_UNUSED
,
557 unsigned int *bytes_read_ptr
)
559 /* Return a pointer to the embedded string. */
560 char *str
= (char *) buf
;
568 *bytes_read_ptr
= strlen (str
) + 1;
575 read_indirect_string (struct comp_unit
* unit
,
577 unsigned int * bytes_read_ptr
)
580 struct dwarf2_debug
*stash
= unit
->stash
;
583 if (unit
->offset_size
== 4)
584 offset
= read_4_bytes (unit
->abfd
, buf
);
586 offset
= read_8_bytes (unit
->abfd
, buf
);
588 *bytes_read_ptr
= unit
->offset_size
;
590 if (! read_section (unit
->abfd
, ".debug_str", ".zdebug_str",
592 &stash
->dwarf_str_buffer
, &stash
->dwarf_str_size
))
595 str
= (char *) stash
->dwarf_str_buffer
+ offset
;
602 read_address (struct comp_unit
*unit
, bfd_byte
*buf
)
604 int signed_vma
= get_elf_backend_data (unit
->abfd
)->sign_extend_vma
;
608 switch (unit
->addr_size
)
611 return bfd_get_signed_64 (unit
->abfd
, buf
);
613 return bfd_get_signed_32 (unit
->abfd
, buf
);
615 return bfd_get_signed_16 (unit
->abfd
, buf
);
622 switch (unit
->addr_size
)
625 return bfd_get_64 (unit
->abfd
, buf
);
627 return bfd_get_32 (unit
->abfd
, buf
);
629 return bfd_get_16 (unit
->abfd
, buf
);
636 /* Lookup an abbrev_info structure in the abbrev hash table. */
638 static struct abbrev_info
*
639 lookup_abbrev (unsigned int number
, struct abbrev_info
**abbrevs
)
641 unsigned int hash_number
;
642 struct abbrev_info
*abbrev
;
644 hash_number
= number
% ABBREV_HASH_SIZE
;
645 abbrev
= abbrevs
[hash_number
];
649 if (abbrev
->number
== number
)
652 abbrev
= abbrev
->next
;
658 /* In DWARF version 2, the description of the debugging information is
659 stored in a separate .debug_abbrev section. Before we read any
660 dies from a section we read in all abbreviations and install them
663 static struct abbrev_info
**
664 read_abbrevs (bfd
*abfd
, bfd_uint64_t offset
, struct dwarf2_debug
*stash
)
666 struct abbrev_info
**abbrevs
;
667 bfd_byte
*abbrev_ptr
;
668 struct abbrev_info
*cur_abbrev
;
669 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
670 unsigned int abbrev_form
, hash_number
;
673 if (! read_section (abfd
, ".debug_abbrev", ".zdebug_abbrev",
675 &stash
->dwarf_abbrev_buffer
, &stash
->dwarf_abbrev_size
))
678 amt
= sizeof (struct abbrev_info
*) * ABBREV_HASH_SIZE
;
679 abbrevs
= (struct abbrev_info
**) bfd_zalloc (abfd
, amt
);
683 abbrev_ptr
= stash
->dwarf_abbrev_buffer
+ offset
;
684 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
685 abbrev_ptr
+= bytes_read
;
687 /* Loop until we reach an abbrev number of 0. */
688 while (abbrev_number
)
690 amt
= sizeof (struct abbrev_info
);
691 cur_abbrev
= (struct abbrev_info
*) bfd_zalloc (abfd
, amt
);
692 if (cur_abbrev
== NULL
)
695 /* Read in abbrev header. */
696 cur_abbrev
->number
= abbrev_number
;
697 cur_abbrev
->tag
= (enum dwarf_tag
)
698 read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
699 abbrev_ptr
+= bytes_read
;
700 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
703 /* Now read in declarations. */
704 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
705 abbrev_ptr
+= bytes_read
;
706 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
707 abbrev_ptr
+= bytes_read
;
711 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
713 struct attr_abbrev
*tmp
;
715 amt
= cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
;
716 amt
*= sizeof (struct attr_abbrev
);
717 tmp
= (struct attr_abbrev
*) bfd_realloc (cur_abbrev
->attrs
, amt
);
722 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
724 struct abbrev_info
*abbrev
= abbrevs
[i
];
728 free (abbrev
->attrs
);
729 abbrev
= abbrev
->next
;
734 cur_abbrev
->attrs
= tmp
;
737 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
738 = (enum dwarf_attribute
) abbrev_name
;
739 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
740 = (enum dwarf_form
) abbrev_form
;
741 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
742 abbrev_ptr
+= bytes_read
;
743 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
744 abbrev_ptr
+= bytes_read
;
747 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
748 cur_abbrev
->next
= abbrevs
[hash_number
];
749 abbrevs
[hash_number
] = cur_abbrev
;
751 /* Get next abbreviation.
752 Under Irix6 the abbreviations for a compilation unit are not
753 always properly terminated with an abbrev number of 0.
754 Exit loop if we encounter an abbreviation which we have
755 already read (which means we are about to read the abbreviations
756 for the next compile unit) or if the end of the abbreviation
758 if ((unsigned int) (abbrev_ptr
- stash
->dwarf_abbrev_buffer
)
759 >= stash
->dwarf_abbrev_size
)
761 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
762 abbrev_ptr
+= bytes_read
;
763 if (lookup_abbrev (abbrev_number
,abbrevs
) != NULL
)
770 /* Read an attribute value described by an attribute form. */
773 read_attribute_value (struct attribute
*attr
,
775 struct comp_unit
*unit
,
778 bfd
*abfd
= unit
->abfd
;
779 unsigned int bytes_read
;
780 struct dwarf_block
*blk
;
783 attr
->form
= (enum dwarf_form
) form
;
787 case DW_FORM_ref_addr
:
788 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
790 if (unit
->version
== 3 || unit
->version
== 4)
792 if (unit
->offset_size
== 4)
793 attr
->u
.val
= read_4_bytes (unit
->abfd
, info_ptr
);
795 attr
->u
.val
= read_8_bytes (unit
->abfd
, info_ptr
);
796 info_ptr
+= unit
->offset_size
;
801 attr
->u
.val
= read_address (unit
, info_ptr
);
802 info_ptr
+= unit
->addr_size
;
804 case DW_FORM_sec_offset
:
805 if (unit
->offset_size
== 4)
806 attr
->u
.val
= read_4_bytes (unit
->abfd
, info_ptr
);
808 attr
->u
.val
= read_8_bytes (unit
->abfd
, info_ptr
);
809 info_ptr
+= unit
->offset_size
;
812 amt
= sizeof (struct dwarf_block
);
813 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
816 blk
->size
= read_2_bytes (abfd
, info_ptr
);
818 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
819 info_ptr
+= blk
->size
;
823 amt
= sizeof (struct dwarf_block
);
824 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
827 blk
->size
= read_4_bytes (abfd
, info_ptr
);
829 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
830 info_ptr
+= blk
->size
;
834 attr
->u
.val
= read_2_bytes (abfd
, info_ptr
);
838 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
);
842 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
);
846 attr
->u
.str
= read_string (abfd
, info_ptr
, &bytes_read
);
847 info_ptr
+= bytes_read
;
850 attr
->u
.str
= read_indirect_string (unit
, info_ptr
, &bytes_read
);
851 info_ptr
+= bytes_read
;
853 case DW_FORM_exprloc
:
855 amt
= sizeof (struct dwarf_block
);
856 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
859 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
860 info_ptr
+= bytes_read
;
861 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
862 info_ptr
+= blk
->size
;
866 amt
= sizeof (struct dwarf_block
);
867 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
870 blk
->size
= read_1_byte (abfd
, info_ptr
);
872 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
873 info_ptr
+= blk
->size
;
877 attr
->u
.val
= read_1_byte (abfd
, info_ptr
);
881 attr
->u
.val
= read_1_byte (abfd
, info_ptr
);
884 case DW_FORM_flag_present
:
888 attr
->u
.sval
= read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
889 info_ptr
+= bytes_read
;
892 attr
->u
.val
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
893 info_ptr
+= bytes_read
;
896 attr
->u
.val
= read_1_byte (abfd
, info_ptr
);
900 attr
->u
.val
= read_2_bytes (abfd
, info_ptr
);
904 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
);
908 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
);
911 case DW_FORM_ref_sig8
:
912 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
);
915 case DW_FORM_ref_udata
:
916 attr
->u
.val
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
917 info_ptr
+= bytes_read
;
919 case DW_FORM_indirect
:
920 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
921 info_ptr
+= bytes_read
;
922 info_ptr
= read_attribute_value (attr
, form
, unit
, info_ptr
);
925 (*_bfd_error_handler
) (_("Dwarf Error: Invalid or unhandled FORM value: %u."),
927 bfd_set_error (bfd_error_bad_value
);
933 /* Read an attribute described by an abbreviated attribute. */
936 read_attribute (struct attribute
*attr
,
937 struct attr_abbrev
*abbrev
,
938 struct comp_unit
*unit
,
941 attr
->name
= abbrev
->name
;
942 info_ptr
= read_attribute_value (attr
, abbrev
->form
, unit
, info_ptr
);
946 /* Source line information table routines. */
948 #define FILE_ALLOC_CHUNK 5
949 #define DIR_ALLOC_CHUNK 5
953 struct line_info
* prev_line
;
958 unsigned char op_index
;
959 unsigned char end_sequence
; /* End of (sequential) code sequence. */
973 struct line_sequence
* prev_sequence
;
974 struct line_info
* last_line
; /* Largest VMA. */
977 struct line_info_table
980 unsigned int num_files
;
981 unsigned int num_dirs
;
982 unsigned int num_sequences
;
985 struct fileinfo
* files
;
986 struct line_sequence
* sequences
;
987 struct line_info
* lcl_head
; /* Local head; used in 'add_line_info'. */
990 /* Remember some information about each function. If the function is
991 inlined (DW_TAG_inlined_subroutine) it may have two additional
992 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
993 source code location where this function was inlined. */
997 struct funcinfo
*prev_func
; /* Pointer to previous function in list of all functions */
998 struct funcinfo
*caller_func
; /* Pointer to function one scope higher */
999 char *caller_file
; /* Source location file name where caller_func inlines this func */
1000 int caller_line
; /* Source location line number where caller_func inlines this func */
1001 char *file
; /* Source location file name */
1002 int line
; /* Source location line number */
1005 struct arange arange
;
1006 asection
*sec
; /* Where the symbol is defined */
1011 /* Pointer to previous variable in list of all variables */
1012 struct varinfo
*prev_var
;
1013 /* Source location file name */
1015 /* Source location line number */
1020 /* Where the symbol is defined */
1022 /* Is this a stack variable? */
1023 unsigned int stack
: 1;
1026 /* Return TRUE if NEW_LINE should sort after LINE. */
1028 static inline bfd_boolean
1029 new_line_sorts_after (struct line_info
*new_line
, struct line_info
*line
)
1031 return (new_line
->address
> line
->address
1032 || (new_line
->address
== line
->address
1033 && (new_line
->op_index
> line
->op_index
1034 || (new_line
->op_index
== line
->op_index
1035 && new_line
->end_sequence
< line
->end_sequence
))));
1039 /* Adds a new entry to the line_info list in the line_info_table, ensuring
1040 that the list is sorted. Note that the line_info list is sorted from
1041 highest to lowest VMA (with possible duplicates); that is,
1042 line_info->prev_line always accesses an equal or smaller VMA. */
1045 add_line_info (struct line_info_table
*table
,
1047 unsigned char op_index
,
1050 unsigned int column
,
1053 bfd_size_type amt
= sizeof (struct line_info
);
1054 struct line_sequence
* seq
= table
->sequences
;
1055 struct line_info
* info
= (struct line_info
*) bfd_alloc (table
->abfd
, amt
);
1060 /* Set member data of 'info'. */
1061 info
->address
= address
;
1062 info
->op_index
= op_index
;
1064 info
->column
= column
;
1065 info
->end_sequence
= end_sequence
;
1067 if (filename
&& filename
[0])
1069 info
->filename
= (char *) bfd_alloc (table
->abfd
, strlen (filename
) + 1);
1070 if (info
->filename
== NULL
)
1072 strcpy (info
->filename
, filename
);
1075 info
->filename
= NULL
;
1077 /* Find the correct location for 'info'. Normally we will receive
1078 new line_info data 1) in order and 2) with increasing VMAs.
1079 However some compilers break the rules (cf. decode_line_info) and
1080 so we include some heuristics for quickly finding the correct
1081 location for 'info'. In particular, these heuristics optimize for
1082 the common case in which the VMA sequence that we receive is a
1083 list of locally sorted VMAs such as
1084 p...z a...j (where a < j < p < z)
1086 Note: table->lcl_head is used to head an *actual* or *possible*
1087 sub-sequence within the list (such as a...j) that is not directly
1088 headed by table->last_line
1090 Note: we may receive duplicate entries from 'decode_line_info'. */
1093 && seq
->last_line
->address
== address
1094 && seq
->last_line
->op_index
== op_index
1095 && seq
->last_line
->end_sequence
== end_sequence
)
1097 /* We only keep the last entry with the same address and end
1098 sequence. See PR ld/4986. */
1099 if (table
->lcl_head
== seq
->last_line
)
1100 table
->lcl_head
= info
;
1101 info
->prev_line
= seq
->last_line
->prev_line
;
1102 seq
->last_line
= info
;
1104 else if (!seq
|| seq
->last_line
->end_sequence
)
1106 /* Start a new line sequence. */
1107 amt
= sizeof (struct line_sequence
);
1108 seq
= (struct line_sequence
*) bfd_malloc (amt
);
1111 seq
->low_pc
= address
;
1112 seq
->prev_sequence
= table
->sequences
;
1113 seq
->last_line
= info
;
1114 table
->lcl_head
= info
;
1115 table
->sequences
= seq
;
1116 table
->num_sequences
++;
1118 else if (new_line_sorts_after (info
, seq
->last_line
))
1120 /* Normal case: add 'info' to the beginning of the current sequence. */
1121 info
->prev_line
= seq
->last_line
;
1122 seq
->last_line
= info
;
1124 /* lcl_head: initialize to head a *possible* sequence at the end. */
1125 if (!table
->lcl_head
)
1126 table
->lcl_head
= info
;
1128 else if (!new_line_sorts_after (info
, table
->lcl_head
)
1129 && (!table
->lcl_head
->prev_line
1130 || new_line_sorts_after (info
, table
->lcl_head
->prev_line
)))
1132 /* Abnormal but easy: lcl_head is the head of 'info'. */
1133 info
->prev_line
= table
->lcl_head
->prev_line
;
1134 table
->lcl_head
->prev_line
= info
;
1138 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head'
1139 are valid heads for 'info'. Reset 'lcl_head'. */
1140 struct line_info
* li2
= seq
->last_line
; /* Always non-NULL. */
1141 struct line_info
* li1
= li2
->prev_line
;
1145 if (!new_line_sorts_after (info
, li2
)
1146 && new_line_sorts_after (info
, li1
))
1149 li2
= li1
; /* always non-NULL */
1150 li1
= li1
->prev_line
;
1152 table
->lcl_head
= li2
;
1153 info
->prev_line
= table
->lcl_head
->prev_line
;
1154 table
->lcl_head
->prev_line
= info
;
1155 if (address
< seq
->low_pc
)
1156 seq
->low_pc
= address
;
1161 /* Extract a fully qualified filename from a line info table.
1162 The returned string has been malloc'ed and it is the caller's
1163 responsibility to free it. */
1166 concat_filename (struct line_info_table
*table
, unsigned int file
)
1170 if (file
- 1 >= table
->num_files
)
1172 /* FILE == 0 means unknown. */
1174 (*_bfd_error_handler
)
1175 (_("Dwarf Error: mangled line number section (bad file number)."));
1176 return strdup ("<unknown>");
1179 filename
= table
->files
[file
- 1].name
;
1181 if (!IS_ABSOLUTE_PATH (filename
))
1183 char *dir_name
= NULL
;
1184 char *subdir_name
= NULL
;
1188 if (table
->files
[file
- 1].dir
)
1189 subdir_name
= table
->dirs
[table
->files
[file
- 1].dir
- 1];
1191 if (!subdir_name
|| !IS_ABSOLUTE_PATH (subdir_name
))
1192 dir_name
= table
->comp_dir
;
1196 dir_name
= subdir_name
;
1201 return strdup (filename
);
1203 len
= strlen (dir_name
) + strlen (filename
) + 2;
1207 len
+= strlen (subdir_name
) + 1;
1208 name
= (char *) bfd_malloc (len
);
1210 sprintf (name
, "%s/%s/%s", dir_name
, subdir_name
, filename
);
1214 name
= (char *) bfd_malloc (len
);
1216 sprintf (name
, "%s/%s", dir_name
, filename
);
1222 return strdup (filename
);
1226 arange_add (bfd
*abfd
, struct arange
*first_arange
,
1227 bfd_vma low_pc
, bfd_vma high_pc
)
1229 struct arange
*arange
;
1231 /* If the first arange is empty, use it. */
1232 if (first_arange
->high
== 0)
1234 first_arange
->low
= low_pc
;
1235 first_arange
->high
= high_pc
;
1239 /* Next see if we can cheaply extend an existing range. */
1240 arange
= first_arange
;
1243 if (low_pc
== arange
->high
)
1245 arange
->high
= high_pc
;
1248 if (high_pc
== arange
->low
)
1250 arange
->low
= low_pc
;
1253 arange
= arange
->next
;
1257 /* Need to allocate a new arange and insert it into the arange list.
1258 Order isn't significant, so just insert after the first arange. */
1259 arange
= (struct arange
*) bfd_zalloc (abfd
, sizeof (*arange
));
1262 arange
->low
= low_pc
;
1263 arange
->high
= high_pc
;
1264 arange
->next
= first_arange
->next
;
1265 first_arange
->next
= arange
;
1269 /* Compare function for line sequences. */
1272 compare_sequences (const void* a
, const void* b
)
1274 const struct line_sequence
* seq1
= a
;
1275 const struct line_sequence
* seq2
= b
;
1277 /* Sort by low_pc as the primary key. */
1278 if (seq1
->low_pc
< seq2
->low_pc
)
1280 if (seq1
->low_pc
> seq2
->low_pc
)
1283 /* If low_pc values are equal, sort in reverse order of
1284 high_pc, so that the largest region comes first. */
1285 if (seq1
->last_line
->address
< seq2
->last_line
->address
)
1287 if (seq1
->last_line
->address
> seq2
->last_line
->address
)
1290 if (seq1
->last_line
->op_index
< seq2
->last_line
->op_index
)
1292 if (seq1
->last_line
->op_index
> seq2
->last_line
->op_index
)
1298 /* Sort the line sequences for quick lookup. */
1301 sort_line_sequences (struct line_info_table
* table
)
1304 struct line_sequence
* sequences
;
1305 struct line_sequence
* seq
;
1307 unsigned int num_sequences
= table
->num_sequences
;
1308 bfd_vma last_high_pc
;
1310 if (num_sequences
== 0)
1313 /* Allocate space for an array of sequences. */
1314 amt
= sizeof (struct line_sequence
) * num_sequences
;
1315 sequences
= (struct line_sequence
*) bfd_alloc (table
->abfd
, amt
);
1316 if (sequences
== NULL
)
1319 /* Copy the linked list into the array, freeing the original nodes. */
1320 seq
= table
->sequences
;
1321 for (n
= 0; n
< num_sequences
; n
++)
1323 struct line_sequence
* last_seq
= seq
;
1326 sequences
[n
].low_pc
= seq
->low_pc
;
1327 sequences
[n
].prev_sequence
= NULL
;
1328 sequences
[n
].last_line
= seq
->last_line
;
1329 seq
= seq
->prev_sequence
;
1332 BFD_ASSERT (seq
== NULL
);
1334 qsort (sequences
, n
, sizeof (struct line_sequence
), compare_sequences
);
1336 /* Make the list binary-searchable by trimming overlapping entries
1337 and removing nested entries. */
1339 last_high_pc
= sequences
[0].last_line
->address
;
1340 for (n
= 1; n
< table
->num_sequences
; n
++)
1342 if (sequences
[n
].low_pc
< last_high_pc
)
1344 if (sequences
[n
].last_line
->address
<= last_high_pc
)
1345 /* Skip nested entries. */
1348 /* Trim overlapping entries. */
1349 sequences
[n
].low_pc
= last_high_pc
;
1351 last_high_pc
= sequences
[n
].last_line
->address
;
1352 if (n
> num_sequences
)
1354 /* Close up the gap. */
1355 sequences
[num_sequences
].low_pc
= sequences
[n
].low_pc
;
1356 sequences
[num_sequences
].last_line
= sequences
[n
].last_line
;
1361 table
->sequences
= sequences
;
1362 table
->num_sequences
= num_sequences
;
1366 /* Decode the line number information for UNIT. */
1368 static struct line_info_table
*
1369 decode_line_info (struct comp_unit
*unit
, struct dwarf2_debug
*stash
)
1371 bfd
*abfd
= unit
->abfd
;
1372 struct line_info_table
* table
;
1375 struct line_head lh
;
1376 unsigned int i
, bytes_read
, offset_size
;
1377 char *cur_file
, *cur_dir
;
1378 unsigned char op_code
, extended_op
, adj_opcode
;
1381 if (! read_section (abfd
, ".debug_line", ".zdebug_line",
1382 stash
->syms
, unit
->line_offset
,
1383 &stash
->dwarf_line_buffer
, &stash
->dwarf_line_size
))
1386 amt
= sizeof (struct line_info_table
);
1387 table
= (struct line_info_table
*) bfd_alloc (abfd
, amt
);
1391 table
->comp_dir
= unit
->comp_dir
;
1393 table
->num_files
= 0;
1394 table
->files
= NULL
;
1396 table
->num_dirs
= 0;
1399 table
->num_sequences
= 0;
1400 table
->sequences
= NULL
;
1402 table
->lcl_head
= NULL
;
1404 line_ptr
= stash
->dwarf_line_buffer
+ unit
->line_offset
;
1406 /* Read in the prologue. */
1407 lh
.total_length
= read_4_bytes (abfd
, line_ptr
);
1410 if (lh
.total_length
== 0xffffffff)
1412 lh
.total_length
= read_8_bytes (abfd
, line_ptr
);
1416 else if (lh
.total_length
== 0 && unit
->addr_size
== 8)
1418 /* Handle (non-standard) 64-bit DWARF2 formats. */
1419 lh
.total_length
= read_4_bytes (abfd
, line_ptr
);
1423 line_end
= line_ptr
+ lh
.total_length
;
1424 lh
.version
= read_2_bytes (abfd
, line_ptr
);
1425 if (lh
.version
< 2 || lh
.version
> 4)
1427 (*_bfd_error_handler
)
1428 (_("Dwarf Error: Unhandled .debug_line version %d."), lh
.version
);
1429 bfd_set_error (bfd_error_bad_value
);
1433 if (offset_size
== 4)
1434 lh
.prologue_length
= read_4_bytes (abfd
, line_ptr
);
1436 lh
.prologue_length
= read_8_bytes (abfd
, line_ptr
);
1437 line_ptr
+= offset_size
;
1438 lh
.minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
1440 if (lh
.version
>= 4)
1442 lh
.maximum_ops_per_insn
= read_1_byte (abfd
, line_ptr
);
1446 lh
.maximum_ops_per_insn
= 1;
1447 if (lh
.maximum_ops_per_insn
== 0)
1449 (*_bfd_error_handler
)
1450 (_("Dwarf Error: Invalid maximum operations per instruction."));
1451 bfd_set_error (bfd_error_bad_value
);
1454 lh
.default_is_stmt
= read_1_byte (abfd
, line_ptr
);
1456 lh
.line_base
= read_1_signed_byte (abfd
, line_ptr
);
1458 lh
.line_range
= read_1_byte (abfd
, line_ptr
);
1460 lh
.opcode_base
= read_1_byte (abfd
, line_ptr
);
1462 amt
= lh
.opcode_base
* sizeof (unsigned char);
1463 lh
.standard_opcode_lengths
= (unsigned char *) bfd_alloc (abfd
, amt
);
1465 lh
.standard_opcode_lengths
[0] = 1;
1467 for (i
= 1; i
< lh
.opcode_base
; ++i
)
1469 lh
.standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
1473 /* Read directory table. */
1474 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
1476 line_ptr
+= bytes_read
;
1478 if ((table
->num_dirs
% DIR_ALLOC_CHUNK
) == 0)
1482 amt
= table
->num_dirs
+ DIR_ALLOC_CHUNK
;
1483 amt
*= sizeof (char *);
1485 tmp
= (char **) bfd_realloc (table
->dirs
, amt
);
1491 table
->dirs
[table
->num_dirs
++] = cur_dir
;
1494 line_ptr
+= bytes_read
;
1496 /* Read file name table. */
1497 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
1499 line_ptr
+= bytes_read
;
1501 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
1503 struct fileinfo
*tmp
;
1505 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
1506 amt
*= sizeof (struct fileinfo
);
1508 tmp
= (struct fileinfo
*) bfd_realloc (table
->files
, amt
);
1514 table
->files
[table
->num_files
].name
= cur_file
;
1515 table
->files
[table
->num_files
].dir
=
1516 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1517 line_ptr
+= bytes_read
;
1518 table
->files
[table
->num_files
].time
=
1519 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1520 line_ptr
+= bytes_read
;
1521 table
->files
[table
->num_files
].size
=
1522 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1523 line_ptr
+= bytes_read
;
1527 line_ptr
+= bytes_read
;
1529 /* Read the statement sequences until there's nothing left. */
1530 while (line_ptr
< line_end
)
1532 /* State machine registers. */
1533 bfd_vma address
= 0;
1534 unsigned char op_index
= 0;
1535 char * filename
= table
->num_files
? concat_filename (table
, 1) : NULL
;
1536 unsigned int line
= 1;
1537 unsigned int column
= 0;
1538 int is_stmt
= lh
.default_is_stmt
;
1539 int end_sequence
= 0;
1540 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1541 compilers generate address sequences that are wildly out of
1542 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1543 for ia64-Linux). Thus, to determine the low and high
1544 address, we must compare on every DW_LNS_copy, etc. */
1545 bfd_vma low_pc
= (bfd_vma
) -1;
1546 bfd_vma high_pc
= 0;
1548 /* Decode the table. */
1549 while (! end_sequence
)
1551 op_code
= read_1_byte (abfd
, line_ptr
);
1554 if (op_code
>= lh
.opcode_base
)
1556 /* Special operand. */
1557 adj_opcode
= op_code
- lh
.opcode_base
;
1558 if (lh
.maximum_ops_per_insn
== 1)
1559 address
+= (adj_opcode
/ lh
.line_range
)
1560 * lh
.minimum_instruction_length
;
1563 address
+= ((op_index
+ (adj_opcode
/ lh
.line_range
))
1564 / lh
.maximum_ops_per_insn
)
1565 * lh
.minimum_instruction_length
;
1566 op_index
= (op_index
+ (adj_opcode
/ lh
.line_range
))
1567 % lh
.maximum_ops_per_insn
;
1569 line
+= lh
.line_base
+ (adj_opcode
% lh
.line_range
);
1570 /* Append row to matrix using current values. */
1571 if (!add_line_info (table
, address
, op_index
, filename
,
1574 if (address
< low_pc
)
1576 if (address
> high_pc
)
1579 else switch (op_code
)
1581 case DW_LNS_extended_op
:
1582 /* Ignore length. */
1584 extended_op
= read_1_byte (abfd
, line_ptr
);
1587 switch (extended_op
)
1589 case DW_LNE_end_sequence
:
1591 if (!add_line_info (table
, address
, op_index
, filename
,
1592 line
, column
, end_sequence
))
1594 if (address
< low_pc
)
1596 if (address
> high_pc
)
1598 if (!arange_add (unit
->abfd
, &unit
->arange
, low_pc
, high_pc
))
1601 case DW_LNE_set_address
:
1602 address
= read_address (unit
, line_ptr
);
1604 line_ptr
+= unit
->addr_size
;
1606 case DW_LNE_define_file
:
1607 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
1608 line_ptr
+= bytes_read
;
1609 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
1611 struct fileinfo
*tmp
;
1613 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
1614 amt
*= sizeof (struct fileinfo
);
1615 tmp
= (struct fileinfo
*) bfd_realloc (table
->files
, amt
);
1620 table
->files
[table
->num_files
].name
= cur_file
;
1621 table
->files
[table
->num_files
].dir
=
1622 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1623 line_ptr
+= bytes_read
;
1624 table
->files
[table
->num_files
].time
=
1625 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1626 line_ptr
+= bytes_read
;
1627 table
->files
[table
->num_files
].size
=
1628 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1629 line_ptr
+= bytes_read
;
1632 case DW_LNE_set_discriminator
:
1633 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1634 line_ptr
+= bytes_read
;
1637 (*_bfd_error_handler
) (_("Dwarf Error: mangled line number section."));
1638 bfd_set_error (bfd_error_bad_value
);
1640 if (filename
!= NULL
)
1646 if (!add_line_info (table
, address
, op_index
,
1647 filename
, line
, column
, 0))
1649 if (address
< low_pc
)
1651 if (address
> high_pc
)
1654 case DW_LNS_advance_pc
:
1655 if (lh
.maximum_ops_per_insn
== 1)
1656 address
+= lh
.minimum_instruction_length
1657 * read_unsigned_leb128 (abfd
, line_ptr
,
1661 bfd_vma adjust
= read_unsigned_leb128 (abfd
, line_ptr
,
1663 address
= ((op_index
+ adjust
) / lh
.maximum_ops_per_insn
)
1664 * lh
.minimum_instruction_length
;
1665 op_index
= (op_index
+ adjust
) % lh
.maximum_ops_per_insn
;
1667 line_ptr
+= bytes_read
;
1669 case DW_LNS_advance_line
:
1670 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
1671 line_ptr
+= bytes_read
;
1673 case DW_LNS_set_file
:
1677 /* The file and directory tables are 0
1678 based, the references are 1 based. */
1679 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1680 line_ptr
+= bytes_read
;
1683 filename
= concat_filename (table
, file
);
1686 case DW_LNS_set_column
:
1687 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1688 line_ptr
+= bytes_read
;
1690 case DW_LNS_negate_stmt
:
1691 is_stmt
= (!is_stmt
);
1693 case DW_LNS_set_basic_block
:
1695 case DW_LNS_const_add_pc
:
1696 if (lh
.maximum_ops_per_insn
== 1)
1697 address
+= lh
.minimum_instruction_length
1698 * ((255 - lh
.opcode_base
) / lh
.line_range
);
1701 bfd_vma adjust
= ((255 - lh
.opcode_base
) / lh
.line_range
);
1702 address
+= lh
.minimum_instruction_length
1703 * ((op_index
+ adjust
) / lh
.maximum_ops_per_insn
);
1704 op_index
= (op_index
+ adjust
) % lh
.maximum_ops_per_insn
;
1707 case DW_LNS_fixed_advance_pc
:
1708 address
+= read_2_bytes (abfd
, line_ptr
);
1713 /* Unknown standard opcode, ignore it. */
1714 for (i
= 0; i
< lh
.standard_opcode_lengths
[op_code
]; i
++)
1716 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1717 line_ptr
+= bytes_read
;
1727 if (sort_line_sequences (table
))
1731 if (table
->sequences
!= NULL
)
1732 free (table
->sequences
);
1733 if (table
->files
!= NULL
)
1734 free (table
->files
);
1735 if (table
->dirs
!= NULL
)
1740 /* If ADDR is within TABLE set the output parameters and return TRUE,
1741 otherwise return FALSE. The output parameters, FILENAME_PTR and
1742 LINENUMBER_PTR, are pointers to the objects to be filled in. */
1745 lookup_address_in_line_info_table (struct line_info_table
*table
,
1747 const char **filename_ptr
,
1748 unsigned int *linenumber_ptr
)
1750 struct line_sequence
*seq
= NULL
;
1751 struct line_info
*each_line
;
1754 /* Binary search the array of sequences. */
1756 high
= table
->num_sequences
;
1759 mid
= (low
+ high
) / 2;
1760 seq
= &table
->sequences
[mid
];
1761 if (addr
< seq
->low_pc
)
1763 else if (addr
>= seq
->last_line
->address
)
1769 if (seq
&& addr
>= seq
->low_pc
&& addr
< seq
->last_line
->address
)
1771 /* Note: seq->last_line should be a descendingly sorted list. */
1772 for (each_line
= seq
->last_line
;
1774 each_line
= each_line
->prev_line
)
1775 if (addr
>= each_line
->address
)
1779 && !(each_line
->end_sequence
|| each_line
== seq
->last_line
))
1781 *filename_ptr
= each_line
->filename
;
1782 *linenumber_ptr
= each_line
->line
;
1787 *filename_ptr
= NULL
;
1791 /* Read in the .debug_ranges section for future reference. */
1794 read_debug_ranges (struct comp_unit
*unit
)
1796 struct dwarf2_debug
*stash
= unit
->stash
;
1797 return read_section (unit
->abfd
, ".debug_ranges", ".zdebug_ranges",
1799 &stash
->dwarf_ranges_buffer
, &stash
->dwarf_ranges_size
);
1802 /* Function table functions. */
1804 /* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return TRUE.
1805 Note that we need to find the function that has the smallest
1806 range that contains ADDR, to handle inlined functions without
1807 depending upon them being ordered in TABLE by increasing range. */
1810 lookup_address_in_function_table (struct comp_unit
*unit
,
1812 struct funcinfo
**function_ptr
,
1813 const char **functionname_ptr
)
1815 struct funcinfo
* each_func
;
1816 struct funcinfo
* best_fit
= NULL
;
1817 struct arange
*arange
;
1819 for (each_func
= unit
->function_table
;
1821 each_func
= each_func
->prev_func
)
1823 for (arange
= &each_func
->arange
;
1825 arange
= arange
->next
)
1827 if (addr
>= arange
->low
&& addr
< arange
->high
)
1830 ((arange
->high
- arange
->low
) < (best_fit
->arange
.high
- best_fit
->arange
.low
)))
1831 best_fit
= each_func
;
1838 *functionname_ptr
= best_fit
->name
;
1839 *function_ptr
= best_fit
;
1848 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
1849 and LINENUMBER_PTR, and return TRUE. */
1852 lookup_symbol_in_function_table (struct comp_unit
*unit
,
1855 const char **filename_ptr
,
1856 unsigned int *linenumber_ptr
)
1858 struct funcinfo
* each_func
;
1859 struct funcinfo
* best_fit
= NULL
;
1860 struct arange
*arange
;
1861 const char *name
= bfd_asymbol_name (sym
);
1862 asection
*sec
= bfd_get_section (sym
);
1864 for (each_func
= unit
->function_table
;
1866 each_func
= each_func
->prev_func
)
1868 for (arange
= &each_func
->arange
;
1870 arange
= arange
->next
)
1872 if ((!each_func
->sec
|| each_func
->sec
== sec
)
1873 && addr
>= arange
->low
1874 && addr
< arange
->high
1876 && strcmp (name
, each_func
->name
) == 0
1878 || ((arange
->high
- arange
->low
)
1879 < (best_fit
->arange
.high
- best_fit
->arange
.low
))))
1880 best_fit
= each_func
;
1886 best_fit
->sec
= sec
;
1887 *filename_ptr
= best_fit
->file
;
1888 *linenumber_ptr
= best_fit
->line
;
1895 /* Variable table functions. */
1897 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
1898 LINENUMBER_PTR, and return TRUE. */
1901 lookup_symbol_in_variable_table (struct comp_unit
*unit
,
1904 const char **filename_ptr
,
1905 unsigned int *linenumber_ptr
)
1907 const char *name
= bfd_asymbol_name (sym
);
1908 asection
*sec
= bfd_get_section (sym
);
1909 struct varinfo
* each
;
1911 for (each
= unit
->variable_table
; each
; each
= each
->prev_var
)
1912 if (each
->stack
== 0
1913 && each
->file
!= NULL
1914 && each
->name
!= NULL
1915 && each
->addr
== addr
1916 && (!each
->sec
|| each
->sec
== sec
)
1917 && strcmp (name
, each
->name
) == 0)
1923 *filename_ptr
= each
->file
;
1924 *linenumber_ptr
= each
->line
;
1932 find_abstract_instance_name (struct comp_unit
*unit
,
1933 struct attribute
*attr_ptr
)
1935 bfd
*abfd
= unit
->abfd
;
1937 unsigned int abbrev_number
, bytes_read
, i
;
1938 struct abbrev_info
*abbrev
;
1939 bfd_uint64_t die_ref
= attr_ptr
->u
.val
;
1940 struct attribute attr
;
1943 /* DW_FORM_ref_addr can reference an entry in a different CU. It
1944 is an offset from the .debug_info section, not the current CU. */
1945 if (attr_ptr
->form
== DW_FORM_ref_addr
)
1947 /* We only support DW_FORM_ref_addr within the same file, so
1948 any relocations should be resolved already. */
1952 info_ptr
= unit
->sec_info_ptr
+ die_ref
;
1955 info_ptr
= unit
->info_ptr_unit
+ die_ref
;
1956 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
1957 info_ptr
+= bytes_read
;
1961 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
1964 (*_bfd_error_handler
) (_("Dwarf Error: Could not find abbrev number %u."),
1966 bfd_set_error (bfd_error_bad_value
);
1970 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
1972 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
,
1974 if (info_ptr
== NULL
)
1979 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
1984 case DW_AT_specification
:
1985 name
= find_abstract_instance_name (unit
, &attr
);
1987 case DW_AT_linkage_name
:
1988 case DW_AT_MIPS_linkage_name
:
2001 read_rangelist (struct comp_unit
*unit
, struct arange
*arange
,
2002 bfd_uint64_t offset
)
2004 bfd_byte
*ranges_ptr
;
2005 bfd_vma base_address
= unit
->base_address
;
2007 if (! unit
->stash
->dwarf_ranges_buffer
)
2009 if (! read_debug_ranges (unit
))
2012 ranges_ptr
= unit
->stash
->dwarf_ranges_buffer
+ offset
;
2019 low_pc
= read_address (unit
, ranges_ptr
);
2020 ranges_ptr
+= unit
->addr_size
;
2021 high_pc
= read_address (unit
, ranges_ptr
);
2022 ranges_ptr
+= unit
->addr_size
;
2024 if (low_pc
== 0 && high_pc
== 0)
2026 if (low_pc
== -1UL && high_pc
!= -1UL)
2027 base_address
= high_pc
;
2030 if (!arange_add (unit
->abfd
, arange
,
2031 base_address
+ low_pc
, base_address
+ high_pc
))
2038 /* DWARF2 Compilation unit functions. */
2040 /* Scan over each die in a comp. unit looking for functions to add
2041 to the function table and variables to the variable table. */
2044 scan_unit_for_symbols (struct comp_unit
*unit
)
2046 bfd
*abfd
= unit
->abfd
;
2047 bfd_byte
*info_ptr
= unit
->first_child_die_ptr
;
2048 int nesting_level
= 1;
2049 struct funcinfo
**nested_funcs
;
2050 int nested_funcs_size
;
2052 /* Maintain a stack of in-scope functions and inlined functions, which we
2053 can use to set the caller_func field. */
2054 nested_funcs_size
= 32;
2055 nested_funcs
= (struct funcinfo
**)
2056 bfd_malloc (nested_funcs_size
* sizeof (struct funcinfo
*));
2057 if (nested_funcs
== NULL
)
2059 nested_funcs
[nesting_level
] = 0;
2061 while (nesting_level
)
2063 unsigned int abbrev_number
, bytes_read
, i
;
2064 struct abbrev_info
*abbrev
;
2065 struct attribute attr
;
2066 struct funcinfo
*func
;
2067 struct varinfo
*var
;
2069 bfd_vma high_pc
= 0;
2071 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2072 info_ptr
+= bytes_read
;
2074 if (! abbrev_number
)
2080 abbrev
= lookup_abbrev (abbrev_number
,unit
->abbrevs
);
2083 (*_bfd_error_handler
)
2084 (_("Dwarf Error: Could not find abbrev number %u."),
2086 bfd_set_error (bfd_error_bad_value
);
2091 if (abbrev
->tag
== DW_TAG_subprogram
2092 || abbrev
->tag
== DW_TAG_entry_point
2093 || abbrev
->tag
== DW_TAG_inlined_subroutine
)
2095 bfd_size_type amt
= sizeof (struct funcinfo
);
2096 func
= (struct funcinfo
*) bfd_zalloc (abfd
, amt
);
2099 func
->tag
= abbrev
->tag
;
2100 func
->prev_func
= unit
->function_table
;
2101 unit
->function_table
= func
;
2102 BFD_ASSERT (!unit
->cached
);
2104 if (func
->tag
== DW_TAG_inlined_subroutine
)
2105 for (i
= nesting_level
- 1; i
>= 1; i
--)
2106 if (nested_funcs
[i
])
2108 func
->caller_func
= nested_funcs
[i
];
2111 nested_funcs
[nesting_level
] = func
;
2116 if (abbrev
->tag
== DW_TAG_variable
)
2118 bfd_size_type amt
= sizeof (struct varinfo
);
2119 var
= (struct varinfo
*) bfd_zalloc (abfd
, amt
);
2122 var
->tag
= abbrev
->tag
;
2124 var
->prev_var
= unit
->variable_table
;
2125 unit
->variable_table
= var
;
2126 BFD_ASSERT (!unit
->cached
);
2129 /* No inline function in scope at this nesting level. */
2130 nested_funcs
[nesting_level
] = 0;
2133 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
2135 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
);
2136 if (info_ptr
== NULL
)
2143 case DW_AT_call_file
:
2144 func
->caller_file
= concat_filename (unit
->line_table
,
2148 case DW_AT_call_line
:
2149 func
->caller_line
= attr
.u
.val
;
2152 case DW_AT_abstract_origin
:
2153 func
->name
= find_abstract_instance_name (unit
, &attr
);
2157 /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name
2159 if (func
->name
== NULL
)
2160 func
->name
= attr
.u
.str
;
2163 case DW_AT_linkage_name
:
2164 case DW_AT_MIPS_linkage_name
:
2165 func
->name
= attr
.u
.str
;
2169 low_pc
= attr
.u
.val
;
2173 high_pc
= attr
.u
.val
;
2177 if (!read_rangelist (unit
, &func
->arange
, attr
.u
.val
))
2181 case DW_AT_decl_file
:
2182 func
->file
= concat_filename (unit
->line_table
,
2186 case DW_AT_decl_line
:
2187 func
->line
= attr
.u
.val
;
2199 var
->name
= attr
.u
.str
;
2202 case DW_AT_decl_file
:
2203 var
->file
= concat_filename (unit
->line_table
,
2207 case DW_AT_decl_line
:
2208 var
->line
= attr
.u
.val
;
2211 case DW_AT_external
:
2212 if (attr
.u
.val
!= 0)
2216 case DW_AT_location
:
2220 case DW_FORM_block1
:
2221 case DW_FORM_block2
:
2222 case DW_FORM_block4
:
2223 case DW_FORM_exprloc
:
2224 if (*attr
.u
.blk
->data
== DW_OP_addr
)
2228 /* Verify that DW_OP_addr is the only opcode in the
2229 location, in which case the block size will be 1
2230 plus the address size. */
2231 /* ??? For TLS variables, gcc can emit
2232 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
2233 which we don't handle here yet. */
2234 if (attr
.u
.blk
->size
== unit
->addr_size
+ 1U)
2235 var
->addr
= bfd_get (unit
->addr_size
* 8,
2237 attr
.u
.blk
->data
+ 1);
2252 if (func
&& high_pc
!= 0)
2254 if (!arange_add (unit
->abfd
, &func
->arange
, low_pc
, high_pc
))
2258 if (abbrev
->has_children
)
2262 if (nesting_level
>= nested_funcs_size
)
2264 struct funcinfo
**tmp
;
2266 nested_funcs_size
*= 2;
2267 tmp
= (struct funcinfo
**)
2268 bfd_realloc (nested_funcs
,
2269 (nested_funcs_size
* sizeof (struct funcinfo
*)));
2274 nested_funcs
[nesting_level
] = 0;
2278 free (nested_funcs
);
2282 free (nested_funcs
);
2286 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
2287 includes the compilation unit header that proceeds the DIE's, but
2288 does not include the length field that precedes each compilation
2289 unit header. END_PTR points one past the end of this comp unit.
2290 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
2292 This routine does not read the whole compilation unit; only enough
2293 to get to the line number information for the compilation unit. */
2295 static struct comp_unit
*
2296 parse_comp_unit (struct dwarf2_debug
*stash
,
2297 bfd_vma unit_length
,
2298 bfd_byte
*info_ptr_unit
,
2299 unsigned int offset_size
)
2301 struct comp_unit
* unit
;
2302 unsigned int version
;
2303 bfd_uint64_t abbrev_offset
= 0;
2304 unsigned int addr_size
;
2305 struct abbrev_info
** abbrevs
;
2306 unsigned int abbrev_number
, bytes_read
, i
;
2307 struct abbrev_info
*abbrev
;
2308 struct attribute attr
;
2309 bfd_byte
*info_ptr
= stash
->info_ptr
;
2310 bfd_byte
*end_ptr
= info_ptr
+ unit_length
;
2313 bfd_vma high_pc
= 0;
2314 bfd
*abfd
= stash
->bfd_ptr
;
2316 version
= read_2_bytes (abfd
, info_ptr
);
2318 BFD_ASSERT (offset_size
== 4 || offset_size
== 8);
2319 if (offset_size
== 4)
2320 abbrev_offset
= read_4_bytes (abfd
, info_ptr
);
2322 abbrev_offset
= read_8_bytes (abfd
, info_ptr
);
2323 info_ptr
+= offset_size
;
2324 addr_size
= read_1_byte (abfd
, info_ptr
);
2327 if (version
!= 2 && version
!= 3 && version
!= 4)
2329 (*_bfd_error_handler
) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2, 3 and 4 information."), version
);
2330 bfd_set_error (bfd_error_bad_value
);
2334 if (addr_size
> sizeof (bfd_vma
))
2336 (*_bfd_error_handler
) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
2338 (unsigned int) sizeof (bfd_vma
));
2339 bfd_set_error (bfd_error_bad_value
);
2343 if (addr_size
!= 2 && addr_size
!= 4 && addr_size
!= 8)
2345 (*_bfd_error_handler
) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size
);
2346 bfd_set_error (bfd_error_bad_value
);
2350 /* Read the abbrevs for this compilation unit into a table. */
2351 abbrevs
= read_abbrevs (abfd
, abbrev_offset
, stash
);
2355 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2356 info_ptr
+= bytes_read
;
2357 if (! abbrev_number
)
2359 (*_bfd_error_handler
) (_("Dwarf Error: Bad abbrev number: %u."),
2361 bfd_set_error (bfd_error_bad_value
);
2365 abbrev
= lookup_abbrev (abbrev_number
, abbrevs
);
2368 (*_bfd_error_handler
) (_("Dwarf Error: Could not find abbrev number %u."),
2370 bfd_set_error (bfd_error_bad_value
);
2374 amt
= sizeof (struct comp_unit
);
2375 unit
= (struct comp_unit
*) bfd_zalloc (abfd
, amt
);
2379 unit
->version
= version
;
2380 unit
->addr_size
= addr_size
;
2381 unit
->offset_size
= offset_size
;
2382 unit
->abbrevs
= abbrevs
;
2383 unit
->end_ptr
= end_ptr
;
2384 unit
->stash
= stash
;
2385 unit
->info_ptr_unit
= info_ptr_unit
;
2386 unit
->sec_info_ptr
= stash
->sec_info_ptr
;
2388 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
2390 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
);
2391 if (info_ptr
== NULL
)
2394 /* Store the data if it is of an attribute we want to keep in a
2395 partial symbol table. */
2398 case DW_AT_stmt_list
:
2400 unit
->line_offset
= attr
.u
.val
;
2404 unit
->name
= attr
.u
.str
;
2408 low_pc
= attr
.u
.val
;
2409 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
2410 this is the base address to use when reading location
2411 lists or range lists. */
2412 unit
->base_address
= low_pc
;
2416 high_pc
= attr
.u
.val
;
2420 if (!read_rangelist (unit
, &unit
->arange
, attr
.u
.val
))
2424 case DW_AT_comp_dir
:
2426 char *comp_dir
= attr
.u
.str
;
2429 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2430 directory, get rid of it. */
2431 char *cp
= strchr (comp_dir
, ':');
2433 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2436 unit
->comp_dir
= comp_dir
;
2446 if (!arange_add (unit
->abfd
, &unit
->arange
, low_pc
, high_pc
))
2450 unit
->first_child_die_ptr
= info_ptr
;
2454 /* Return TRUE if UNIT may contain the address given by ADDR. When
2455 there are functions written entirely with inline asm statements, the
2456 range info in the compilation unit header may not be correct. We
2457 need to consult the line info table to see if a compilation unit
2458 really contains the given address. */
2461 comp_unit_contains_address (struct comp_unit
*unit
, bfd_vma addr
)
2463 struct arange
*arange
;
2468 arange
= &unit
->arange
;
2471 if (addr
>= arange
->low
&& addr
< arange
->high
)
2473 arange
= arange
->next
;
2480 /* If UNIT contains ADDR, set the output parameters to the values for
2481 the line containing ADDR. The output parameters, FILENAME_PTR,
2482 FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
2485 Return TRUE if UNIT contains ADDR, and no errors were encountered;
2489 comp_unit_find_nearest_line (struct comp_unit
*unit
,
2491 const char **filename_ptr
,
2492 const char **functionname_ptr
,
2493 unsigned int *linenumber_ptr
,
2494 struct dwarf2_debug
*stash
)
2498 struct funcinfo
*function
;
2503 if (! unit
->line_table
)
2505 if (! unit
->stmtlist
)
2511 unit
->line_table
= decode_line_info (unit
, stash
);
2513 if (! unit
->line_table
)
2519 if (unit
->first_child_die_ptr
< unit
->end_ptr
2520 && ! scan_unit_for_symbols (unit
))
2528 func_p
= lookup_address_in_function_table (unit
, addr
,
2529 &function
, functionname_ptr
);
2530 if (func_p
&& (function
->tag
== DW_TAG_inlined_subroutine
))
2531 stash
->inliner_chain
= function
;
2532 line_p
= lookup_address_in_line_info_table (unit
->line_table
, addr
,
2535 return line_p
|| func_p
;
2538 /* Check to see if line info is already decoded in a comp_unit.
2539 If not, decode it. Returns TRUE if no errors were encountered;
2543 comp_unit_maybe_decode_line_info (struct comp_unit
*unit
,
2544 struct dwarf2_debug
*stash
)
2549 if (! unit
->line_table
)
2551 if (! unit
->stmtlist
)
2557 unit
->line_table
= decode_line_info (unit
, stash
);
2559 if (! unit
->line_table
)
2565 if (unit
->first_child_die_ptr
< unit
->end_ptr
2566 && ! scan_unit_for_symbols (unit
))
2576 /* If UNIT contains SYM at ADDR, set the output parameters to the
2577 values for the line containing SYM. The output parameters,
2578 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
2581 Return TRUE if UNIT contains SYM, and no errors were encountered;
2585 comp_unit_find_line (struct comp_unit
*unit
,
2588 const char **filename_ptr
,
2589 unsigned int *linenumber_ptr
,
2590 struct dwarf2_debug
*stash
)
2592 if (!comp_unit_maybe_decode_line_info (unit
, stash
))
2595 if (sym
->flags
& BSF_FUNCTION
)
2596 return lookup_symbol_in_function_table (unit
, sym
, addr
,
2600 return lookup_symbol_in_variable_table (unit
, sym
, addr
,
2605 static struct funcinfo
*
2606 reverse_funcinfo_list (struct funcinfo
*head
)
2608 struct funcinfo
*rhead
;
2609 struct funcinfo
*temp
;
2611 for (rhead
= NULL
; head
; head
= temp
)
2613 temp
= head
->prev_func
;
2614 head
->prev_func
= rhead
;
2620 static struct varinfo
*
2621 reverse_varinfo_list (struct varinfo
*head
)
2623 struct varinfo
*rhead
;
2624 struct varinfo
*temp
;
2626 for (rhead
= NULL
; head
; head
= temp
)
2628 temp
= head
->prev_var
;
2629 head
->prev_var
= rhead
;
2635 /* Extract all interesting funcinfos and varinfos of a compilation
2636 unit into hash tables for faster lookup. Returns TRUE if no
2637 errors were enountered; FALSE otherwise. */
2640 comp_unit_hash_info (struct dwarf2_debug
*stash
,
2641 struct comp_unit
*unit
,
2642 struct info_hash_table
*funcinfo_hash_table
,
2643 struct info_hash_table
*varinfo_hash_table
)
2645 struct funcinfo
* each_func
;
2646 struct varinfo
* each_var
;
2647 bfd_boolean okay
= TRUE
;
2649 BFD_ASSERT (stash
->info_hash_status
!= STASH_INFO_HASH_DISABLED
);
2651 if (!comp_unit_maybe_decode_line_info (unit
, stash
))
2654 BFD_ASSERT (!unit
->cached
);
2656 /* To preserve the original search order, we went to visit the function
2657 infos in the reversed order of the list. However, making the list
2658 bi-directional use quite a bit of extra memory. So we reverse
2659 the list first, traverse the list in the now reversed order and
2660 finally reverse the list again to get back the original order. */
2661 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
2662 for (each_func
= unit
->function_table
;
2664 each_func
= each_func
->prev_func
)
2666 /* Skip nameless functions. */
2667 if (each_func
->name
)
2668 /* There is no need to copy name string into hash table as
2669 name string is either in the dwarf string buffer or
2670 info in the stash. */
2671 okay
= insert_info_hash_table (funcinfo_hash_table
, each_func
->name
,
2672 (void*) each_func
, FALSE
);
2674 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
2678 /* We do the same for variable infos. */
2679 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
2680 for (each_var
= unit
->variable_table
;
2682 each_var
= each_var
->prev_var
)
2684 /* Skip stack vars and vars with no files or names. */
2685 if (each_var
->stack
== 0
2686 && each_var
->file
!= NULL
2687 && each_var
->name
!= NULL
)
2688 /* There is no need to copy name string into hash table as
2689 name string is either in the dwarf string buffer or
2690 info in the stash. */
2691 okay
= insert_info_hash_table (varinfo_hash_table
, each_var
->name
,
2692 (void*) each_var
, FALSE
);
2695 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
2696 unit
->cached
= TRUE
;
2700 /* Locate a section in a BFD containing debugging info. The search starts
2701 from the section after AFTER_SEC, or from the first section in the BFD if
2702 AFTER_SEC is NULL. The search works by examining the names of the
2703 sections. There are two permissiable names. The first is .debug_info.
2704 This is the standard DWARF2 name. The second is a prefix .gnu.linkonce.wi.
2705 This is a variation on the .debug_info section which has a checksum
2706 describing the contents appended onto the name. This allows the linker to
2707 identify and discard duplicate debugging sections for different
2708 compilation units. */
2709 #define DWARF2_DEBUG_INFO ".debug_info"
2710 #define DWARF2_COMPRESSED_DEBUG_INFO ".zdebug_info"
2711 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
2714 find_debug_info (bfd
*abfd
, asection
*after_sec
)
2718 msec
= after_sec
!= NULL
? after_sec
->next
: abfd
->sections
;
2722 if (strcmp (msec
->name
, DWARF2_DEBUG_INFO
) == 0)
2725 if (strcmp (msec
->name
, DWARF2_COMPRESSED_DEBUG_INFO
) == 0)
2728 if (CONST_STRNEQ (msec
->name
, GNU_LINKONCE_INFO
))
2737 /* Unset vmas for adjusted sections in STASH. */
2740 unset_sections (struct dwarf2_debug
*stash
)
2743 struct adjusted_section
*p
;
2745 i
= stash
->adjusted_section_count
;
2746 p
= stash
->adjusted_sections
;
2747 for (; i
> 0; i
--, p
++)
2748 p
->section
->vma
= 0;
2751 /* Set unique VMAs for loadable and DWARF sections in ABFD and save
2752 VMAs in STASH for unset_sections. */
2755 place_sections (bfd
*abfd
, struct dwarf2_debug
*stash
)
2757 struct adjusted_section
*p
;
2760 if (stash
->adjusted_section_count
!= 0)
2762 i
= stash
->adjusted_section_count
;
2763 p
= stash
->adjusted_sections
;
2764 for (; i
> 0; i
--, p
++)
2765 p
->section
->vma
= p
->adj_vma
;
2770 bfd_vma last_vma
= 0, last_dwarf
= 0;
2774 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
2782 /* We need to adjust the VMAs of any .debug_info sections.
2783 Skip compressed ones, since no relocations could target
2784 them - they should not appear in object files anyway. */
2785 if (strcmp (sect
->name
, DWARF2_DEBUG_INFO
) == 0)
2787 else if (CONST_STRNEQ (sect
->name
, GNU_LINKONCE_INFO
))
2792 if (!is_debug_info
&& (sect
->flags
& SEC_LOAD
) == 0)
2795 sz
= sect
->rawsize
? sect
->rawsize
: sect
->size
;
2802 amt
= i
* sizeof (struct adjusted_section
);
2803 p
= (struct adjusted_section
*) bfd_zalloc (abfd
, amt
);
2807 stash
->adjusted_sections
= p
;
2808 stash
->adjusted_section_count
= i
;
2810 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
2818 /* We need to adjust the VMAs of any .debug_info sections.
2819 Skip compressed ones, since no relocations could target
2820 them - they should not appear in object files anyway. */
2821 if (strcmp (sect
->name
, DWARF2_DEBUG_INFO
) == 0)
2823 else if (CONST_STRNEQ (sect
->name
, GNU_LINKONCE_INFO
))
2828 if (!is_debug_info
&& (sect
->flags
& SEC_LOAD
) == 0)
2831 sz
= sect
->rawsize
? sect
->rawsize
: sect
->size
;
2838 BFD_ASSERT (sect
->alignment_power
== 0);
2839 sect
->vma
= last_dwarf
;
2842 else if (last_vma
!= 0)
2844 /* Align the new address to the current section
2846 last_vma
= ((last_vma
2847 + ~((bfd_vma
) -1 << sect
->alignment_power
))
2848 & ((bfd_vma
) -1 << sect
->alignment_power
));
2849 sect
->vma
= last_vma
;
2850 last_vma
+= sect
->vma
+ sz
;
2853 last_vma
+= sect
->vma
+ sz
;
2855 p
->adj_vma
= sect
->vma
;
2864 /* Look up a funcinfo by name using the given info hash table. If found,
2865 also update the locations pointed to by filename_ptr and linenumber_ptr.
2867 This function returns TRUE if a funcinfo that matches the given symbol
2868 and address is found with any error; otherwise it returns FALSE. */
2871 info_hash_lookup_funcinfo (struct info_hash_table
*hash_table
,
2874 const char **filename_ptr
,
2875 unsigned int *linenumber_ptr
)
2877 struct funcinfo
* each_func
;
2878 struct funcinfo
* best_fit
= NULL
;
2879 struct info_list_node
*node
;
2880 struct arange
*arange
;
2881 const char *name
= bfd_asymbol_name (sym
);
2882 asection
*sec
= bfd_get_section (sym
);
2884 for (node
= lookup_info_hash_table (hash_table
, name
);
2888 each_func
= (struct funcinfo
*) node
->info
;
2889 for (arange
= &each_func
->arange
;
2891 arange
= arange
->next
)
2893 if ((!each_func
->sec
|| each_func
->sec
== sec
)
2894 && addr
>= arange
->low
2895 && addr
< arange
->high
2897 || ((arange
->high
- arange
->low
)
2898 < (best_fit
->arange
.high
- best_fit
->arange
.low
))))
2899 best_fit
= each_func
;
2905 best_fit
->sec
= sec
;
2906 *filename_ptr
= best_fit
->file
;
2907 *linenumber_ptr
= best_fit
->line
;
2914 /* Look up a varinfo by name using the given info hash table. If found,
2915 also update the locations pointed to by filename_ptr and linenumber_ptr.
2917 This function returns TRUE if a varinfo that matches the given symbol
2918 and address is found with any error; otherwise it returns FALSE. */
2921 info_hash_lookup_varinfo (struct info_hash_table
*hash_table
,
2924 const char **filename_ptr
,
2925 unsigned int *linenumber_ptr
)
2927 const char *name
= bfd_asymbol_name (sym
);
2928 asection
*sec
= bfd_get_section (sym
);
2929 struct varinfo
* each
;
2930 struct info_list_node
*node
;
2932 for (node
= lookup_info_hash_table (hash_table
, name
);
2936 each
= (struct varinfo
*) node
->info
;
2937 if (each
->addr
== addr
2938 && (!each
->sec
|| each
->sec
== sec
))
2941 *filename_ptr
= each
->file
;
2942 *linenumber_ptr
= each
->line
;
2950 /* Update the funcinfo and varinfo info hash tables if they are
2951 not up to date. Returns TRUE if there is no error; otherwise
2952 returns FALSE and disable the info hash tables. */
2955 stash_maybe_update_info_hash_tables (struct dwarf2_debug
*stash
)
2957 struct comp_unit
*each
;
2959 /* Exit if hash tables are up-to-date. */
2960 if (stash
->all_comp_units
== stash
->hash_units_head
)
2963 if (stash
->hash_units_head
)
2964 each
= stash
->hash_units_head
->prev_unit
;
2966 each
= stash
->last_comp_unit
;
2970 if (!comp_unit_hash_info (stash
, each
, stash
->funcinfo_hash_table
,
2971 stash
->varinfo_hash_table
))
2973 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
2976 each
= each
->prev_unit
;
2979 stash
->hash_units_head
= stash
->all_comp_units
;
2983 /* Check consistency of info hash tables. This is for debugging only. */
2985 static void ATTRIBUTE_UNUSED
2986 stash_verify_info_hash_table (struct dwarf2_debug
*stash
)
2988 struct comp_unit
*each_unit
;
2989 struct funcinfo
*each_func
;
2990 struct varinfo
*each_var
;
2991 struct info_list_node
*node
;
2994 for (each_unit
= stash
->all_comp_units
;
2996 each_unit
= each_unit
->next_unit
)
2998 for (each_func
= each_unit
->function_table
;
3000 each_func
= each_func
->prev_func
)
3002 if (!each_func
->name
)
3004 node
= lookup_info_hash_table (stash
->funcinfo_hash_table
,
3008 while (node
&& !found
)
3010 found
= node
->info
== each_func
;
3016 for (each_var
= each_unit
->variable_table
;
3018 each_var
= each_var
->prev_var
)
3020 if (!each_var
->name
|| !each_var
->file
|| each_var
->stack
)
3022 node
= lookup_info_hash_table (stash
->varinfo_hash_table
,
3026 while (node
&& !found
)
3028 found
= node
->info
== each_var
;
3036 /* Check to see if we want to enable the info hash tables, which consume
3037 quite a bit of memory. Currently we only check the number times
3038 bfd_dwarf2_find_line is called. In the future, we may also want to
3039 take the number of symbols into account. */
3042 stash_maybe_enable_info_hash_tables (bfd
*abfd
, struct dwarf2_debug
*stash
)
3044 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_OFF
);
3046 if (stash
->info_hash_count
++ < STASH_INFO_HASH_TRIGGER
)
3049 /* FIXME: Maybe we should check the reduce_memory_overheads
3050 and optimize fields in the bfd_link_info structure ? */
3052 /* Create hash tables. */
3053 stash
->funcinfo_hash_table
= create_info_hash_table (abfd
);
3054 stash
->varinfo_hash_table
= create_info_hash_table (abfd
);
3055 if (!stash
->funcinfo_hash_table
|| !stash
->varinfo_hash_table
)
3057 /* Turn off info hashes if any allocation above fails. */
3058 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
3061 /* We need a forced update so that the info hash tables will
3062 be created even though there is no compilation unit. That
3063 happens if STASH_INFO_HASH_TRIGGER is 0. */
3064 stash_maybe_update_info_hash_tables (stash
);
3065 stash
->info_hash_status
= STASH_INFO_HASH_ON
;
3068 /* Find the file and line associated with a symbol and address using the
3069 info hash tables of a stash. If there is a match, the function returns
3070 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
3071 otherwise it returns FALSE. */
3074 stash_find_line_fast (struct dwarf2_debug
*stash
,
3077 const char **filename_ptr
,
3078 unsigned int *linenumber_ptr
)
3080 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_ON
);
3082 if (sym
->flags
& BSF_FUNCTION
)
3083 return info_hash_lookup_funcinfo (stash
->funcinfo_hash_table
, sym
, addr
,
3084 filename_ptr
, linenumber_ptr
);
3085 return info_hash_lookup_varinfo (stash
->varinfo_hash_table
, sym
, addr
,
3086 filename_ptr
, linenumber_ptr
);
3089 /* Find the source code location of SYMBOL. If SYMBOL is NULL
3090 then find the nearest source code location corresponding to
3091 the address SECTION + OFFSET.
3092 Returns TRUE if the line is found without error and fills in
3093 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
3094 NULL the FUNCTIONNAME_PTR is also filled in.
3095 SYMBOLS contains the symbol table for ABFD.
3096 ADDR_SIZE is the number of bytes in the initial .debug_info length
3097 field and in the abbreviation offset, or zero to indicate that the
3098 default value should be used. */
3101 find_line (bfd
*abfd
,
3106 const char **filename_ptr
,
3107 const char **functionname_ptr
,
3108 unsigned int *linenumber_ptr
,
3109 unsigned int addr_size
,
3112 /* Read each compilation unit from the section .debug_info, and check
3113 to see if it contains the address we are searching for. If yes,
3114 lookup the address, and return the line number info. If no, go
3115 on to the next compilation unit.
3117 We keep a list of all the previously read compilation units, and
3118 a pointer to the next un-read compilation unit. Check the
3119 previously read units before reading more. */
3120 struct dwarf2_debug
*stash
;
3121 /* What address are we looking for? */
3123 struct comp_unit
* each
;
3124 bfd_vma found
= FALSE
;
3125 bfd_boolean do_line
;
3127 stash
= (struct dwarf2_debug
*) *pinfo
;
3131 bfd_size_type amt
= sizeof (struct dwarf2_debug
);
3133 stash
= (struct dwarf2_debug
*) bfd_zalloc (abfd
, amt
);
3138 /* In a relocatable file, 2 functions may have the same address.
3139 We change the section vma so that they won't overlap. */
3140 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
3142 if (! place_sections (abfd
, stash
))
3146 do_line
= (section
== NULL
3148 && functionname_ptr
== NULL
3152 addr
= symbol
->value
;
3153 section
= bfd_get_section (symbol
);
3155 else if (section
!= NULL
3156 && functionname_ptr
!= NULL
3162 if (section
->output_section
)
3163 addr
+= section
->output_section
->vma
+ section
->output_offset
;
3165 addr
+= section
->vma
;
3166 *filename_ptr
= NULL
;
3168 *functionname_ptr
= NULL
;
3169 *linenumber_ptr
= 0;
3174 bfd_size_type total_size
;
3179 msec
= find_debug_info (abfd
, NULL
);
3182 char * debug_filename
= bfd_follow_gnu_debuglink (abfd
, DEBUGDIR
);
3184 if (debug_filename
== NULL
)
3185 /* No dwarf2 info, and no gnu_debuglink to follow.
3186 Note that at this point the stash has been allocated, but
3187 contains zeros. This lets future calls to this function
3188 fail more quickly. */
3191 if ((debug_bfd
= bfd_openr (debug_filename
, NULL
)) == NULL
3192 || ! bfd_check_format (debug_bfd
, bfd_object
)
3193 || (msec
= find_debug_info (debug_bfd
, NULL
)) == NULL
)
3196 bfd_close (debug_bfd
);
3197 /* FIXME: Should we report our failure to follow the debuglink ? */
3198 free (debug_filename
);
3205 /* There can be more than one DWARF2 info section in a BFD these
3206 days. First handle the easy case when there's only one. If
3207 there's more than one, try case two: none of the sections is
3208 compressed. In that case, read them all in and produce one
3209 large stash. We do this in two passes - in the first pass we
3210 just accumulate the section sizes, and in the second pass we
3211 read in the section's contents. (The allows us to avoid
3212 reallocing the data as we add sections to the stash.) If
3213 some or all sections are compressed, then do things the slow
3214 way, with a bunch of reallocs. */
3216 if (! find_debug_info (debug_bfd
, msec
))
3218 /* Case 1: only one info section. */
3219 total_size
= msec
->size
;
3220 if (! read_section (debug_bfd
, ".debug_info", ".zdebug_info",
3222 &stash
->info_ptr_memory
, &total_size
))
3227 int all_uncompressed
= 1;
3228 for (total_size
= 0; msec
; msec
= find_debug_info (debug_bfd
, msec
))
3230 total_size
+= msec
->size
;
3231 if (strcmp (msec
->name
, DWARF2_COMPRESSED_DEBUG_INFO
) == 0)
3232 all_uncompressed
= 0;
3234 if (all_uncompressed
)
3236 /* Case 2: multiple sections, but none is compressed. */
3237 stash
->info_ptr_memory
= (bfd_byte
*) bfd_malloc (total_size
);
3238 if (stash
->info_ptr_memory
== NULL
)
3242 for (msec
= find_debug_info (debug_bfd
, NULL
);
3244 msec
= find_debug_info (debug_bfd
, msec
))
3252 if (!(bfd_simple_get_relocated_section_contents
3253 (debug_bfd
, msec
, stash
->info_ptr_memory
+ total_size
,
3262 /* Case 3: multiple sections, some or all compressed. */
3263 stash
->info_ptr_memory
= NULL
;
3265 for (msec
= find_debug_info (debug_bfd
, NULL
);
3267 msec
= find_debug_info (debug_bfd
, msec
))
3269 bfd_size_type size
= msec
->size
;
3270 bfd_byte
*buffer
, *tmp
;
3271 bfd_boolean is_compressed
=
3272 strcmp (msec
->name
, DWARF2_COMPRESSED_DEBUG_INFO
) == 0;
3277 if (! read_and_uncompress_section (debug_bfd
, msec
,
3278 is_compressed
, symbols
,
3282 tmp
= (bfd_byte
*) bfd_realloc (stash
->info_ptr_memory
,
3289 stash
->info_ptr_memory
= tmp
;
3290 memcpy (stash
->info_ptr_memory
+ total_size
, buffer
, size
);
3297 stash
->info_ptr
= stash
->info_ptr_memory
;
3298 stash
->info_ptr_end
= stash
->info_ptr
+ total_size
;
3299 stash
->sec
= find_debug_info (debug_bfd
, NULL
);
3300 stash
->sec_info_ptr
= stash
->info_ptr
;
3301 stash
->syms
= symbols
;
3302 stash
->bfd_ptr
= debug_bfd
;
3305 /* A null info_ptr indicates that there is no dwarf2 info
3306 (or that an error occured while setting up the stash). */
3307 if (! stash
->info_ptr
)
3310 stash
->inliner_chain
= NULL
;
3312 /* Check the previously read comp. units first. */
3315 /* The info hash tables use quite a bit of memory. We may not want to
3316 always use them. We use some heuristics to decide if and when to
3318 if (stash
->info_hash_status
== STASH_INFO_HASH_OFF
)
3319 stash_maybe_enable_info_hash_tables (abfd
, stash
);
3321 /* Keep info hash table up to date if they are available. Note that we
3322 may disable the hash tables if there is any error duing update. */
3323 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
3324 stash_maybe_update_info_hash_tables (stash
);
3326 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
3328 found
= stash_find_line_fast (stash
, symbol
, addr
, filename_ptr
,
3335 /* Check the previously read comp. units first. */
3336 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
3337 if ((symbol
->flags
& BSF_FUNCTION
) == 0
3338 || comp_unit_contains_address (each
, addr
))
3340 found
= comp_unit_find_line (each
, symbol
, addr
, filename_ptr
,
3341 linenumber_ptr
, stash
);
3349 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
3351 found
= (comp_unit_contains_address (each
, addr
)
3352 && comp_unit_find_nearest_line (each
, addr
,
3362 /* The DWARF2 spec says that the initial length field, and the
3363 offset of the abbreviation table, should both be 4-byte values.
3364 However, some compilers do things differently. */
3367 BFD_ASSERT (addr_size
== 4 || addr_size
== 8);
3369 /* Read each remaining comp. units checking each as they are read. */
3370 while (stash
->info_ptr
< stash
->info_ptr_end
)
3373 unsigned int offset_size
= addr_size
;
3374 bfd_byte
*info_ptr_unit
= stash
->info_ptr
;
3376 length
= read_4_bytes (stash
->bfd_ptr
, stash
->info_ptr
);
3377 /* A 0xffffff length is the DWARF3 way of indicating
3378 we use 64-bit offsets, instead of 32-bit offsets. */
3379 if (length
== 0xffffffff)
3382 length
= read_8_bytes (stash
->bfd_ptr
, stash
->info_ptr
+ 4);
3383 stash
->info_ptr
+= 12;
3385 /* A zero length is the IRIX way of indicating 64-bit offsets,
3386 mostly because the 64-bit length will generally fit in 32
3387 bits, and the endianness helps. */
3388 else if (length
== 0)
3391 length
= read_4_bytes (stash
->bfd_ptr
, stash
->info_ptr
+ 4);
3392 stash
->info_ptr
+= 8;
3394 /* In the absence of the hints above, we assume 32-bit DWARF2
3395 offsets even for targets with 64-bit addresses, because:
3396 a) most of the time these targets will not have generated
3397 more than 2Gb of debug info and so will not need 64-bit
3400 b) if they do use 64-bit offsets but they are not using
3401 the size hints that are tested for above then they are
3402 not conforming to the DWARF3 standard anyway. */
3403 else if (addr_size
== 8)
3406 stash
->info_ptr
+= 4;
3409 stash
->info_ptr
+= 4;
3413 each
= parse_comp_unit (stash
, length
, info_ptr_unit
,
3416 /* The dwarf information is damaged, don't trust it any
3419 stash
->info_ptr
+= length
;
3421 if (stash
->all_comp_units
)
3422 stash
->all_comp_units
->prev_unit
= each
;
3424 stash
->last_comp_unit
= each
;
3426 each
->next_unit
= stash
->all_comp_units
;
3427 stash
->all_comp_units
= each
;
3429 /* DW_AT_low_pc and DW_AT_high_pc are optional for
3430 compilation units. If we don't have them (i.e.,
3431 unit->high == 0), we need to consult the line info table
3432 to see if a compilation unit contains the given
3435 found
= (((symbol
->flags
& BSF_FUNCTION
) == 0
3436 || each
->arange
.high
== 0
3437 || comp_unit_contains_address (each
, addr
))
3438 && comp_unit_find_line (each
, symbol
, addr
,
3443 found
= ((each
->arange
.high
== 0
3444 || comp_unit_contains_address (each
, addr
))
3445 && comp_unit_find_nearest_line (each
, addr
,
3451 if ((bfd_vma
) (stash
->info_ptr
- stash
->sec_info_ptr
)
3452 == stash
->sec
->size
)
3454 stash
->sec
= find_debug_info (stash
->bfd_ptr
, stash
->sec
);
3455 stash
->sec_info_ptr
= stash
->info_ptr
;
3464 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
3465 unset_sections (stash
);
3470 /* The DWARF2 version of find_nearest_line.
3471 Return TRUE if the line is found without error. */
3474 _bfd_dwarf2_find_nearest_line (bfd
*abfd
,
3478 const char **filename_ptr
,
3479 const char **functionname_ptr
,
3480 unsigned int *linenumber_ptr
,
3481 unsigned int addr_size
,
3484 return find_line (abfd
, section
, offset
, NULL
, symbols
, filename_ptr
,
3485 functionname_ptr
, linenumber_ptr
, addr_size
,
3489 /* The DWARF2 version of find_line.
3490 Return TRUE if the line is found without error. */
3493 _bfd_dwarf2_find_line (bfd
*abfd
,
3496 const char **filename_ptr
,
3497 unsigned int *linenumber_ptr
,
3498 unsigned int addr_size
,
3501 return find_line (abfd
, NULL
, 0, symbol
, symbols
, filename_ptr
,
3502 NULL
, linenumber_ptr
, addr_size
,
3507 _bfd_dwarf2_find_inliner_info (bfd
*abfd ATTRIBUTE_UNUSED
,
3508 const char **filename_ptr
,
3509 const char **functionname_ptr
,
3510 unsigned int *linenumber_ptr
,
3513 struct dwarf2_debug
*stash
;
3515 stash
= (struct dwarf2_debug
*) *pinfo
;
3518 struct funcinfo
*func
= stash
->inliner_chain
;
3520 if (func
&& func
->caller_func
)
3522 *filename_ptr
= func
->caller_file
;
3523 *functionname_ptr
= func
->caller_func
->name
;
3524 *linenumber_ptr
= func
->caller_line
;
3525 stash
->inliner_chain
= func
->caller_func
;
3534 _bfd_dwarf2_cleanup_debug_info (bfd
*abfd
)
3536 struct comp_unit
*each
;
3537 struct dwarf2_debug
*stash
;
3539 if (abfd
== NULL
|| elf_tdata (abfd
) == NULL
)
3542 stash
= (struct dwarf2_debug
*) elf_tdata (abfd
)->dwarf2_find_line_info
;
3547 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
3549 struct abbrev_info
**abbrevs
= each
->abbrevs
;
3550 struct funcinfo
*function_table
= each
->function_table
;
3551 struct varinfo
*variable_table
= each
->variable_table
;
3554 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
3556 struct abbrev_info
*abbrev
= abbrevs
[i
];
3560 free (abbrev
->attrs
);
3561 abbrev
= abbrev
->next
;
3565 if (each
->line_table
)
3567 free (each
->line_table
->dirs
);
3568 free (each
->line_table
->files
);
3571 while (function_table
)
3573 if (function_table
->file
)
3575 free (function_table
->file
);
3576 function_table
->file
= NULL
;
3579 if (function_table
->caller_file
)
3581 free (function_table
->caller_file
);
3582 function_table
->caller_file
= NULL
;
3584 function_table
= function_table
->prev_func
;
3587 while (variable_table
)
3589 if (variable_table
->file
)
3591 free (variable_table
->file
);
3592 variable_table
->file
= NULL
;
3595 variable_table
= variable_table
->prev_var
;
3599 if (stash
->dwarf_abbrev_buffer
)
3600 free (stash
->dwarf_abbrev_buffer
);
3601 if (stash
->dwarf_line_buffer
)
3602 free (stash
->dwarf_line_buffer
);
3603 if (stash
->dwarf_str_buffer
)
3604 free (stash
->dwarf_str_buffer
);
3605 if (stash
->dwarf_ranges_buffer
)
3606 free (stash
->dwarf_ranges_buffer
);
3607 if (stash
->info_ptr_memory
)
3608 free (stash
->info_ptr_memory
);