2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008, 2009 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 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 /* The next unread compilation unit within the .debug_info section.
93 Zero indicates that the .debug_info section has not been loaded
97 /* Pointer to the end of the .debug_info section memory buffer. */
98 bfd_byte
*info_ptr_end
;
100 /* Pointer to the bfd, section and address of the beginning of the
101 section. The bfd might be different than expected because of
102 gnu_debuglink sections. */
105 bfd_byte
*sec_info_ptr
;
107 /* A pointer to the memory block allocated for info_ptr. Neither
108 info_ptr nor sec_info_ptr are guaranteed to stay pointing to the
109 beginning of the malloc block. This is used only to free the
111 bfd_byte
*info_ptr_memory
;
113 /* Pointer to the symbol table. */
116 /* Pointer to the .debug_abbrev section loaded into memory. */
117 bfd_byte
*dwarf_abbrev_buffer
;
119 /* Length of the loaded .debug_abbrev section. */
120 bfd_size_type dwarf_abbrev_size
;
122 /* Buffer for decode_line_info. */
123 bfd_byte
*dwarf_line_buffer
;
125 /* Length of the loaded .debug_line section. */
126 bfd_size_type dwarf_line_size
;
128 /* Pointer to the .debug_str section loaded into memory. */
129 bfd_byte
*dwarf_str_buffer
;
131 /* Length of the loaded .debug_str section. */
132 bfd_size_type dwarf_str_size
;
134 /* Pointer to the .debug_ranges section loaded into memory. */
135 bfd_byte
*dwarf_ranges_buffer
;
137 /* Length of the loaded .debug_ranges section. */
138 bfd_size_type dwarf_ranges_size
;
140 /* If the most recent call to bfd_find_nearest_line was given an
141 address in an inlined function, preserve a pointer into the
142 calling chain for subsequent calls to bfd_find_inliner_info to
144 struct funcinfo
*inliner_chain
;
146 /* Number of sections whose VMA we must adjust. */
147 unsigned int adjusted_section_count
;
149 /* Array of sections with adjusted VMA. */
150 struct adjusted_section
*adjusted_sections
;
152 /* Number of times find_line is called. This is used in
153 the heuristic for enabling the info hash tables. */
156 #define STASH_INFO_HASH_TRIGGER 100
158 /* Hash table mapping symbol names to function infos. */
159 struct info_hash_table
*funcinfo_hash_table
;
161 /* Hash table mapping symbol names to variable infos. */
162 struct info_hash_table
*varinfo_hash_table
;
164 /* Head of comp_unit list in the last hash table update. */
165 struct comp_unit
*hash_units_head
;
167 /* Status of info hash. */
168 int info_hash_status
;
169 #define STASH_INFO_HASH_OFF 0
170 #define STASH_INFO_HASH_ON 1
171 #define STASH_INFO_HASH_DISABLED 2
181 /* A minimal decoding of DWARF2 compilation units. We only decode
182 what's needed to get to the line number information. */
186 /* Chain the previously read compilation units. */
187 struct comp_unit
*next_unit
;
189 /* Likewise, chain the compilation unit read after this one.
190 The comp units are stored in reversed reading order. */
191 struct comp_unit
*prev_unit
;
193 /* Keep the bfd convenient (for memory allocation). */
196 /* The lowest and highest addresses contained in this compilation
197 unit as specified in the compilation unit header. */
198 struct arange arange
;
200 /* The DW_AT_name attribute (for error messages). */
203 /* The abbrev hash table. */
204 struct abbrev_info
**abbrevs
;
206 /* Note that an error was found by comp_unit_find_nearest_line. */
209 /* The DW_AT_comp_dir attribute. */
212 /* TRUE if there is a line number table associated with this comp. unit. */
215 /* Pointer to the current comp_unit so that we can find a given entry
217 bfd_byte
*info_ptr_unit
;
219 /* The offset into .debug_line of the line number table. */
220 unsigned long line_offset
;
222 /* Pointer to the first child die for the comp unit. */
223 bfd_byte
*first_child_die_ptr
;
225 /* The end of the comp unit. */
228 /* The decoded line number, NULL if not yet decoded. */
229 struct line_info_table
*line_table
;
231 /* A list of the functions found in this comp. unit. */
232 struct funcinfo
*function_table
;
234 /* A list of the variables found in this comp. unit. */
235 struct varinfo
*variable_table
;
237 /* Pointer to dwarf2_debug structure. */
238 struct dwarf2_debug
*stash
;
240 /* DWARF format version for this unit - from unit header. */
243 /* Address size for this unit - from unit header. */
244 unsigned char addr_size
;
246 /* Offset size for this unit - from unit header. */
247 unsigned char offset_size
;
249 /* Base address for this unit - from DW_AT_low_pc attribute of
250 DW_TAG_compile_unit DIE */
251 bfd_vma base_address
;
253 /* TRUE if symbols are cached in hash table for faster lookup by name. */
257 /* This data structure holds the information of an abbrev. */
260 unsigned int number
; /* Number identifying abbrev. */
261 enum dwarf_tag tag
; /* DWARF tag. */
262 int has_children
; /* Boolean. */
263 unsigned int num_attrs
; /* Number of attributes. */
264 struct attr_abbrev
*attrs
; /* An array of attribute descriptions. */
265 struct abbrev_info
*next
; /* Next in chain. */
270 enum dwarf_attribute name
;
271 enum dwarf_form form
;
274 #ifndef ABBREV_HASH_SIZE
275 #define ABBREV_HASH_SIZE 121
277 #ifndef ATTR_ALLOC_CHUNK
278 #define ATTR_ALLOC_CHUNK 4
281 /* Variable and function hash tables. This is used to speed up look-up
282 in lookup_symbol_in_var_table() and lookup_symbol_in_function_table().
283 In order to share code between variable and function infos, we use
284 a list of untyped pointer for all variable/function info associated with
285 a symbol. We waste a bit of memory for list with one node but that
286 simplifies the code. */
288 struct info_list_node
290 struct info_list_node
*next
;
294 /* Info hash entry. */
295 struct info_hash_entry
297 struct bfd_hash_entry root
;
298 struct info_list_node
*head
;
301 struct info_hash_table
303 struct bfd_hash_table base
;
306 /* Function to create a new entry in info hash table. */
308 static struct bfd_hash_entry
*
309 info_hash_table_newfunc (struct bfd_hash_entry
*entry
,
310 struct bfd_hash_table
*table
,
313 struct info_hash_entry
*ret
= (struct info_hash_entry
*) entry
;
315 /* Allocate the structure if it has not already been allocated by a
319 ret
= bfd_hash_allocate (table
, sizeof (* ret
));
324 /* Call the allocation method of the base class. */
325 ret
= ((struct info_hash_entry
*)
326 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
328 /* Initialize the local fields here. */
332 return (struct bfd_hash_entry
*) ret
;
335 /* Function to create a new info hash table. It returns a pointer to the
336 newly created table or NULL if there is any error. We need abfd
337 solely for memory allocation. */
339 static struct info_hash_table
*
340 create_info_hash_table (bfd
*abfd
)
342 struct info_hash_table
*hash_table
;
344 hash_table
= bfd_alloc (abfd
, sizeof (struct info_hash_table
));
348 if (!bfd_hash_table_init (&hash_table
->base
, info_hash_table_newfunc
,
349 sizeof (struct info_hash_entry
)))
351 bfd_release (abfd
, hash_table
);
358 /* Insert an info entry into an info hash table. We do not check of
359 duplicate entries. Also, the caller need to guarantee that the
360 right type of info in inserted as info is passed as a void* pointer.
361 This function returns true if there is no error. */
364 insert_info_hash_table (struct info_hash_table
*hash_table
,
369 struct info_hash_entry
*entry
;
370 struct info_list_node
*node
;
372 entry
= (struct info_hash_entry
*) bfd_hash_lookup (&hash_table
->base
,
377 node
= bfd_hash_allocate (&hash_table
->base
, sizeof (*node
));
382 node
->next
= entry
->head
;
388 /* Look up an info entry list from an info hash table. Return NULL
391 static struct info_list_node
*
392 lookup_info_hash_table (struct info_hash_table
*hash_table
, const char *key
)
394 struct info_hash_entry
*entry
;
396 entry
= (struct info_hash_entry
*) bfd_hash_lookup (&hash_table
->base
, key
,
398 return entry
? entry
->head
: NULL
;
401 /* Read a section into its appropriate place in the dwarf2_debug
402 struct (indicated by SECTION_BUFFER and SECTION_SIZE). If SYMS is
403 not NULL, use bfd_simple_get_relocated_section_contents to read the
404 section contents, otherwise use bfd_get_section_contents. Fail if
405 the located section does not contain at least OFFSET bytes. */
408 read_section (bfd
* abfd
,
409 const char * section_name
,
410 const char * compressed_section_name
,
413 bfd_byte
** section_buffer
,
414 bfd_size_type
* section_size
)
417 bfd_boolean section_is_compressed
= FALSE
;
419 /* read_section is a noop if the section has already been read. */
420 if (!*section_buffer
)
422 msec
= bfd_get_section_by_name (abfd
, section_name
);
423 if (! msec
&& compressed_section_name
)
425 msec
= bfd_get_section_by_name (abfd
, compressed_section_name
);
426 section_is_compressed
= TRUE
;
430 (*_bfd_error_handler
) (_("Dwarf Error: Can't find %s section."), section_name
);
431 bfd_set_error (bfd_error_bad_value
);
435 *section_size
= msec
->rawsize
? msec
->rawsize
: msec
->size
;
439 = bfd_simple_get_relocated_section_contents (abfd
, msec
, NULL
, syms
);
440 if (! *section_buffer
)
445 *section_buffer
= bfd_malloc (*section_size
);
446 if (! *section_buffer
)
448 if (! bfd_get_section_contents (abfd
, msec
, *section_buffer
,
453 if (section_is_compressed
)
455 if (! bfd_uncompress_section_contents (section_buffer
, section_size
))
457 (*_bfd_error_handler
) (_("Dwarf Error: unable to decompress %s section."), compressed_section_name
);
458 bfd_set_error (bfd_error_bad_value
);
464 /* It is possible to get a bad value for the offset into the section
465 that the client wants. Validate it here to avoid trouble later. */
466 if (offset
!= 0 && offset
>= *section_size
)
468 (*_bfd_error_handler
) (_("Dwarf Error: Offset (%lu) greater than or equal to %s size (%lu)."),
469 (long) offset
, section_name
, *section_size
);
470 bfd_set_error (bfd_error_bad_value
);
478 The following function up to the END VERBATIM mark are
479 copied directly from dwarf2read.c. */
481 /* Read dwarf information from a buffer. */
484 read_1_byte (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_byte
*buf
)
486 return bfd_get_8 (abfd
, buf
);
490 read_1_signed_byte (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_byte
*buf
)
492 return bfd_get_signed_8 (abfd
, buf
);
496 read_2_bytes (bfd
*abfd
, bfd_byte
*buf
)
498 return bfd_get_16 (abfd
, buf
);
502 read_4_bytes (bfd
*abfd
, bfd_byte
*buf
)
504 return bfd_get_32 (abfd
, buf
);
508 read_8_bytes (bfd
*abfd
, bfd_byte
*buf
)
510 return bfd_get_64 (abfd
, buf
);
514 read_n_bytes (bfd
*abfd ATTRIBUTE_UNUSED
,
516 unsigned int size ATTRIBUTE_UNUSED
)
522 read_string (bfd
*abfd ATTRIBUTE_UNUSED
,
524 unsigned int *bytes_read_ptr
)
526 /* Return a pointer to the embedded string. */
527 char *str
= (char *) buf
;
535 *bytes_read_ptr
= strlen (str
) + 1;
542 read_indirect_string (struct comp_unit
* unit
,
544 unsigned int * bytes_read_ptr
)
547 struct dwarf2_debug
*stash
= unit
->stash
;
550 if (unit
->offset_size
== 4)
551 offset
= read_4_bytes (unit
->abfd
, buf
);
553 offset
= read_8_bytes (unit
->abfd
, buf
);
555 *bytes_read_ptr
= unit
->offset_size
;
557 if (! read_section (unit
->abfd
, ".debug_str", ".zdebug_str",
559 &stash
->dwarf_str_buffer
, &stash
->dwarf_str_size
))
562 str
= (char *) stash
->dwarf_str_buffer
+ offset
;
569 read_address (struct comp_unit
*unit
, bfd_byte
*buf
)
571 int signed_vma
= get_elf_backend_data (unit
->abfd
)->sign_extend_vma
;
575 switch (unit
->addr_size
)
578 return bfd_get_signed_64 (unit
->abfd
, buf
);
580 return bfd_get_signed_32 (unit
->abfd
, buf
);
582 return bfd_get_signed_16 (unit
->abfd
, buf
);
589 switch (unit
->addr_size
)
592 return bfd_get_64 (unit
->abfd
, buf
);
594 return bfd_get_32 (unit
->abfd
, buf
);
596 return bfd_get_16 (unit
->abfd
, buf
);
603 /* Lookup an abbrev_info structure in the abbrev hash table. */
605 static struct abbrev_info
*
606 lookup_abbrev (unsigned int number
, struct abbrev_info
**abbrevs
)
608 unsigned int hash_number
;
609 struct abbrev_info
*abbrev
;
611 hash_number
= number
% ABBREV_HASH_SIZE
;
612 abbrev
= abbrevs
[hash_number
];
616 if (abbrev
->number
== number
)
619 abbrev
= abbrev
->next
;
625 /* In DWARF version 2, the description of the debugging information is
626 stored in a separate .debug_abbrev section. Before we read any
627 dies from a section we read in all abbreviations and install them
630 static struct abbrev_info
**
631 read_abbrevs (bfd
*abfd
, bfd_uint64_t offset
, struct dwarf2_debug
*stash
)
633 struct abbrev_info
**abbrevs
;
634 bfd_byte
*abbrev_ptr
;
635 struct abbrev_info
*cur_abbrev
;
636 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
637 unsigned int abbrev_form
, hash_number
;
640 if (! read_section (abfd
, ".debug_abbrev", ".zdebug_abbrev",
642 &stash
->dwarf_abbrev_buffer
, &stash
->dwarf_abbrev_size
))
645 amt
= sizeof (struct abbrev_info
*) * ABBREV_HASH_SIZE
;
646 abbrevs
= bfd_zalloc (abfd
, amt
);
648 abbrev_ptr
= stash
->dwarf_abbrev_buffer
+ offset
;
649 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
650 abbrev_ptr
+= bytes_read
;
652 /* Loop until we reach an abbrev number of 0. */
653 while (abbrev_number
)
655 amt
= sizeof (struct abbrev_info
);
656 cur_abbrev
= bfd_zalloc (abfd
, amt
);
658 /* Read in abbrev header. */
659 cur_abbrev
->number
= abbrev_number
;
660 cur_abbrev
->tag
= (enum dwarf_tag
)
661 read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
662 abbrev_ptr
+= bytes_read
;
663 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
666 /* Now read in declarations. */
667 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
668 abbrev_ptr
+= bytes_read
;
669 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
670 abbrev_ptr
+= bytes_read
;
674 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
676 struct attr_abbrev
*tmp
;
678 amt
= cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
;
679 amt
*= sizeof (struct attr_abbrev
);
680 tmp
= bfd_realloc (cur_abbrev
->attrs
, amt
);
685 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
687 struct abbrev_info
*abbrev
= abbrevs
[i
];
691 free (abbrev
->attrs
);
692 abbrev
= abbrev
->next
;
697 cur_abbrev
->attrs
= tmp
;
700 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
701 = (enum dwarf_attribute
) abbrev_name
;
702 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
703 = (enum dwarf_form
) abbrev_form
;
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
;
710 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
711 cur_abbrev
->next
= abbrevs
[hash_number
];
712 abbrevs
[hash_number
] = cur_abbrev
;
714 /* Get next abbreviation.
715 Under Irix6 the abbreviations for a compilation unit are not
716 always properly terminated with an abbrev number of 0.
717 Exit loop if we encounter an abbreviation which we have
718 already read (which means we are about to read the abbreviations
719 for the next compile unit) or if the end of the abbreviation
721 if ((unsigned int) (abbrev_ptr
- stash
->dwarf_abbrev_buffer
)
722 >= stash
->dwarf_abbrev_size
)
724 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
725 abbrev_ptr
+= bytes_read
;
726 if (lookup_abbrev (abbrev_number
,abbrevs
) != NULL
)
733 /* Read an attribute value described by an attribute form. */
736 read_attribute_value (struct attribute
*attr
,
738 struct comp_unit
*unit
,
741 bfd
*abfd
= unit
->abfd
;
742 unsigned int bytes_read
;
743 struct dwarf_block
*blk
;
746 attr
->form
= (enum dwarf_form
) form
;
750 case DW_FORM_ref_addr
:
751 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
753 if (unit
->version
== 3)
755 if (unit
->offset_size
== 4)
756 attr
->u
.val
= read_4_bytes (unit
->abfd
, info_ptr
);
758 attr
->u
.val
= read_8_bytes (unit
->abfd
, info_ptr
);
759 info_ptr
+= unit
->offset_size
;
764 attr
->u
.val
= read_address (unit
, info_ptr
);
765 info_ptr
+= unit
->addr_size
;
768 amt
= sizeof (struct dwarf_block
);
769 blk
= bfd_alloc (abfd
, amt
);
770 blk
->size
= read_2_bytes (abfd
, info_ptr
);
772 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
773 info_ptr
+= blk
->size
;
777 amt
= sizeof (struct dwarf_block
);
778 blk
= bfd_alloc (abfd
, amt
);
779 blk
->size
= read_4_bytes (abfd
, info_ptr
);
781 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
782 info_ptr
+= blk
->size
;
786 attr
->u
.val
= read_2_bytes (abfd
, info_ptr
);
790 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
);
794 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
);
798 attr
->u
.str
= read_string (abfd
, info_ptr
, &bytes_read
);
799 info_ptr
+= bytes_read
;
802 attr
->u
.str
= read_indirect_string (unit
, info_ptr
, &bytes_read
);
803 info_ptr
+= bytes_read
;
806 amt
= sizeof (struct dwarf_block
);
807 blk
= bfd_alloc (abfd
, amt
);
808 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
809 info_ptr
+= bytes_read
;
810 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
811 info_ptr
+= blk
->size
;
815 amt
= sizeof (struct dwarf_block
);
816 blk
= bfd_alloc (abfd
, amt
);
817 blk
->size
= read_1_byte (abfd
, info_ptr
);
819 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
820 info_ptr
+= blk
->size
;
824 attr
->u
.val
= read_1_byte (abfd
, info_ptr
);
828 attr
->u
.val
= read_1_byte (abfd
, info_ptr
);
832 attr
->u
.sval
= read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
833 info_ptr
+= bytes_read
;
836 attr
->u
.val
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
837 info_ptr
+= bytes_read
;
840 attr
->u
.val
= read_1_byte (abfd
, info_ptr
);
844 attr
->u
.val
= read_2_bytes (abfd
, info_ptr
);
848 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
);
852 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
);
855 case DW_FORM_ref_udata
:
856 attr
->u
.val
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
857 info_ptr
+= bytes_read
;
859 case DW_FORM_indirect
:
860 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
861 info_ptr
+= bytes_read
;
862 info_ptr
= read_attribute_value (attr
, form
, unit
, info_ptr
);
865 (*_bfd_error_handler
) (_("Dwarf Error: Invalid or unhandled FORM value: %u."),
867 bfd_set_error (bfd_error_bad_value
);
872 /* Read an attribute described by an abbreviated attribute. */
875 read_attribute (struct attribute
*attr
,
876 struct attr_abbrev
*abbrev
,
877 struct comp_unit
*unit
,
880 attr
->name
= abbrev
->name
;
881 info_ptr
= read_attribute_value (attr
, abbrev
->form
, unit
, info_ptr
);
885 /* Source line information table routines. */
887 #define FILE_ALLOC_CHUNK 5
888 #define DIR_ALLOC_CHUNK 5
892 struct line_info
* prev_line
;
897 int end_sequence
; /* End of (sequential) code sequence. */
908 struct line_info_table
911 unsigned int num_files
;
912 unsigned int num_dirs
;
915 struct fileinfo
* files
;
916 struct line_info
* last_line
; /* largest VMA */
917 struct line_info
* lcl_head
; /* local head; used in 'add_line_info' */
920 /* Remember some information about each function. If the function is
921 inlined (DW_TAG_inlined_subroutine) it may have two additional
922 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
923 source code location where this function was inlined. */
927 struct funcinfo
*prev_func
; /* Pointer to previous function in list of all functions */
928 struct funcinfo
*caller_func
; /* Pointer to function one scope higher */
929 char *caller_file
; /* Source location file name where caller_func inlines this func */
930 int caller_line
; /* Source location line number where caller_func inlines this func */
931 char *file
; /* Source location file name */
932 int line
; /* Source location line number */
935 struct arange arange
;
936 asection
*sec
; /* Where the symbol is defined */
941 /* Pointer to previous variable in list of all variables */
942 struct varinfo
*prev_var
;
943 /* Source location file name */
945 /* Source location line number */
950 /* Where the symbol is defined */
952 /* Is this a stack variable? */
953 unsigned int stack
: 1;
956 /* Return TRUE if NEW_LINE should sort after LINE. */
958 static inline bfd_boolean
959 new_line_sorts_after (struct line_info
*new_line
, struct line_info
*line
)
961 return (new_line
->address
> line
->address
962 || (new_line
->address
== line
->address
963 && new_line
->end_sequence
< line
->end_sequence
));
967 /* Adds a new entry to the line_info list in the line_info_table, ensuring
968 that the list is sorted. Note that the line_info list is sorted from
969 highest to lowest VMA (with possible duplicates); that is,
970 line_info->prev_line always accesses an equal or smaller VMA. */
973 add_line_info (struct line_info_table
*table
,
980 bfd_size_type amt
= sizeof (struct line_info
);
981 struct line_info
* info
= bfd_alloc (table
->abfd
, amt
);
983 /* Set member data of 'info'. */
984 info
->address
= address
;
986 info
->column
= column
;
987 info
->end_sequence
= end_sequence
;
989 if (filename
&& filename
[0])
991 info
->filename
= bfd_alloc (table
->abfd
, strlen (filename
) + 1);
993 strcpy (info
->filename
, filename
);
996 info
->filename
= NULL
;
998 /* Find the correct location for 'info'. Normally we will receive
999 new line_info data 1) in order and 2) with increasing VMAs.
1000 However some compilers break the rules (cf. decode_line_info) and
1001 so we include some heuristics for quickly finding the correct
1002 location for 'info'. In particular, these heuristics optimize for
1003 the common case in which the VMA sequence that we receive is a
1004 list of locally sorted VMAs such as
1005 p...z a...j (where a < j < p < z)
1007 Note: table->lcl_head is used to head an *actual* or *possible*
1008 sequence within the list (such as a...j) that is not directly
1009 headed by table->last_line
1011 Note: we may receive duplicate entries from 'decode_line_info'. */
1013 if (table
->last_line
1014 && table
->last_line
->address
== address
1015 && table
->last_line
->end_sequence
== end_sequence
)
1017 /* We only keep the last entry with the same address and end
1018 sequence. See PR ld/4986. */
1019 if (table
->lcl_head
== table
->last_line
)
1020 table
->lcl_head
= info
;
1021 info
->prev_line
= table
->last_line
->prev_line
;
1022 table
->last_line
= info
;
1024 else if (!table
->last_line
1025 || new_line_sorts_after (info
, table
->last_line
))
1027 /* Normal case: add 'info' to the beginning of the list */
1028 info
->prev_line
= table
->last_line
;
1029 table
->last_line
= info
;
1031 /* lcl_head: initialize to head a *possible* sequence at the end. */
1032 if (!table
->lcl_head
)
1033 table
->lcl_head
= info
;
1035 else if (!new_line_sorts_after (info
, table
->lcl_head
)
1036 && (!table
->lcl_head
->prev_line
1037 || new_line_sorts_after (info
, table
->lcl_head
->prev_line
)))
1039 /* Abnormal but easy: lcl_head is the head of 'info'. */
1040 info
->prev_line
= table
->lcl_head
->prev_line
;
1041 table
->lcl_head
->prev_line
= info
;
1045 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head' are valid
1046 heads for 'info'. Reset 'lcl_head'. */
1047 struct line_info
* li2
= table
->last_line
; /* always non-NULL */
1048 struct line_info
* li1
= li2
->prev_line
;
1052 if (!new_line_sorts_after (info
, li2
)
1053 && new_line_sorts_after (info
, li1
))
1056 li2
= li1
; /* always non-NULL */
1057 li1
= li1
->prev_line
;
1059 table
->lcl_head
= li2
;
1060 info
->prev_line
= table
->lcl_head
->prev_line
;
1061 table
->lcl_head
->prev_line
= info
;
1065 /* Extract a fully qualified filename from a line info table.
1066 The returned string has been malloc'ed and it is the caller's
1067 responsibility to free it. */
1070 concat_filename (struct line_info_table
*table
, unsigned int file
)
1074 if (file
- 1 >= table
->num_files
)
1076 /* FILE == 0 means unknown. */
1078 (*_bfd_error_handler
)
1079 (_("Dwarf Error: mangled line number section (bad file number)."));
1080 return strdup ("<unknown>");
1083 filename
= table
->files
[file
- 1].name
;
1085 if (!IS_ABSOLUTE_PATH (filename
))
1087 char *dirname
= NULL
;
1088 char *subdirname
= NULL
;
1092 if (table
->files
[file
- 1].dir
)
1093 subdirname
= table
->dirs
[table
->files
[file
- 1].dir
- 1];
1095 if (!subdirname
|| !IS_ABSOLUTE_PATH (subdirname
))
1096 dirname
= table
->comp_dir
;
1100 dirname
= subdirname
;
1105 return strdup (filename
);
1107 len
= strlen (dirname
) + strlen (filename
) + 2;
1111 len
+= strlen (subdirname
) + 1;
1112 name
= bfd_malloc (len
);
1114 sprintf (name
, "%s/%s/%s", dirname
, subdirname
, filename
);
1118 name
= bfd_malloc (len
);
1120 sprintf (name
, "%s/%s", dirname
, filename
);
1126 return strdup (filename
);
1130 arange_add (bfd
*abfd
, struct arange
*first_arange
, bfd_vma low_pc
, bfd_vma high_pc
)
1132 struct arange
*arange
;
1134 /* If the first arange is empty, use it. */
1135 if (first_arange
->high
== 0)
1137 first_arange
->low
= low_pc
;
1138 first_arange
->high
= high_pc
;
1142 /* Next see if we can cheaply extend an existing range. */
1143 arange
= first_arange
;
1146 if (low_pc
== arange
->high
)
1148 arange
->high
= high_pc
;
1151 if (high_pc
== arange
->low
)
1153 arange
->low
= low_pc
;
1156 arange
= arange
->next
;
1160 /* Need to allocate a new arange and insert it into the arange list.
1161 Order isn't significant, so just insert after the first arange. */
1162 arange
= bfd_zalloc (abfd
, sizeof (*arange
));
1163 arange
->low
= low_pc
;
1164 arange
->high
= high_pc
;
1165 arange
->next
= first_arange
->next
;
1166 first_arange
->next
= arange
;
1169 /* Decode the line number information for UNIT. */
1171 static struct line_info_table
*
1172 decode_line_info (struct comp_unit
*unit
, struct dwarf2_debug
*stash
)
1174 bfd
*abfd
= unit
->abfd
;
1175 struct line_info_table
* table
;
1178 struct line_head lh
;
1179 unsigned int i
, bytes_read
, offset_size
;
1180 char *cur_file
, *cur_dir
;
1181 unsigned char op_code
, extended_op
, adj_opcode
;
1184 if (! read_section (abfd
, ".debug_line", ".zdebug_line",
1185 stash
->syms
, unit
->line_offset
,
1186 &stash
->dwarf_line_buffer
, &stash
->dwarf_line_size
))
1189 amt
= sizeof (struct line_info_table
);
1190 table
= bfd_alloc (abfd
, amt
);
1192 table
->comp_dir
= unit
->comp_dir
;
1194 table
->num_files
= 0;
1195 table
->files
= NULL
;
1197 table
->num_dirs
= 0;
1200 table
->files
= NULL
;
1201 table
->last_line
= NULL
;
1202 table
->lcl_head
= NULL
;
1204 line_ptr
= stash
->dwarf_line_buffer
+ unit
->line_offset
;
1206 /* Read in the prologue. */
1207 lh
.total_length
= read_4_bytes (abfd
, line_ptr
);
1210 if (lh
.total_length
== 0xffffffff)
1212 lh
.total_length
= read_8_bytes (abfd
, line_ptr
);
1216 else if (lh
.total_length
== 0 && unit
->addr_size
== 8)
1218 /* Handle (non-standard) 64-bit DWARF2 formats. */
1219 lh
.total_length
= read_4_bytes (abfd
, line_ptr
);
1223 line_end
= line_ptr
+ lh
.total_length
;
1224 lh
.version
= read_2_bytes (abfd
, line_ptr
);
1226 if (offset_size
== 4)
1227 lh
.prologue_length
= read_4_bytes (abfd
, line_ptr
);
1229 lh
.prologue_length
= read_8_bytes (abfd
, line_ptr
);
1230 line_ptr
+= offset_size
;
1231 lh
.minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
1233 lh
.default_is_stmt
= read_1_byte (abfd
, line_ptr
);
1235 lh
.line_base
= read_1_signed_byte (abfd
, line_ptr
);
1237 lh
.line_range
= read_1_byte (abfd
, line_ptr
);
1239 lh
.opcode_base
= read_1_byte (abfd
, line_ptr
);
1241 amt
= lh
.opcode_base
* sizeof (unsigned char);
1242 lh
.standard_opcode_lengths
= bfd_alloc (abfd
, amt
);
1244 lh
.standard_opcode_lengths
[0] = 1;
1246 for (i
= 1; i
< lh
.opcode_base
; ++i
)
1248 lh
.standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
1252 /* Read directory table. */
1253 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
1255 line_ptr
+= bytes_read
;
1257 if ((table
->num_dirs
% DIR_ALLOC_CHUNK
) == 0)
1261 amt
= table
->num_dirs
+ DIR_ALLOC_CHUNK
;
1262 amt
*= sizeof (char *);
1264 tmp
= bfd_realloc (table
->dirs
, amt
);
1273 table
->dirs
[table
->num_dirs
++] = cur_dir
;
1276 line_ptr
+= bytes_read
;
1278 /* Read file name table. */
1279 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
1281 line_ptr
+= bytes_read
;
1283 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
1285 struct fileinfo
*tmp
;
1287 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
1288 amt
*= sizeof (struct fileinfo
);
1290 tmp
= bfd_realloc (table
->files
, amt
);
1293 free (table
->files
);
1300 table
->files
[table
->num_files
].name
= cur_file
;
1301 table
->files
[table
->num_files
].dir
=
1302 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1303 line_ptr
+= bytes_read
;
1304 table
->files
[table
->num_files
].time
=
1305 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1306 line_ptr
+= bytes_read
;
1307 table
->files
[table
->num_files
].size
=
1308 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1309 line_ptr
+= bytes_read
;
1313 line_ptr
+= bytes_read
;
1315 /* Read the statement sequences until there's nothing left. */
1316 while (line_ptr
< line_end
)
1318 /* State machine registers. */
1319 bfd_vma address
= 0;
1320 char * filename
= table
->num_files
? concat_filename (table
, 1) : NULL
;
1321 unsigned int line
= 1;
1322 unsigned int column
= 0;
1323 int is_stmt
= lh
.default_is_stmt
;
1324 int end_sequence
= 0;
1325 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1326 compilers generate address sequences that are wildly out of
1327 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1328 for ia64-Linux). Thus, to determine the low and high
1329 address, we must compare on every DW_LNS_copy, etc. */
1330 bfd_vma low_pc
= (bfd_vma
) -1;
1331 bfd_vma high_pc
= 0;
1333 /* Decode the table. */
1334 while (! end_sequence
)
1336 op_code
= read_1_byte (abfd
, line_ptr
);
1339 if (op_code
>= lh
.opcode_base
)
1341 /* Special operand. */
1342 adj_opcode
= op_code
- lh
.opcode_base
;
1343 address
+= (adj_opcode
/ lh
.line_range
)
1344 * lh
.minimum_instruction_length
;
1345 line
+= lh
.line_base
+ (adj_opcode
% lh
.line_range
);
1346 /* Append row to matrix using current values. */
1347 add_line_info (table
, address
, filename
, line
, column
, 0);
1348 if (address
< low_pc
)
1350 if (address
> high_pc
)
1353 else switch (op_code
)
1355 case DW_LNS_extended_op
:
1356 /* Ignore length. */
1358 extended_op
= read_1_byte (abfd
, line_ptr
);
1361 switch (extended_op
)
1363 case DW_LNE_end_sequence
:
1365 add_line_info (table
, address
, filename
, line
, column
,
1367 if (address
< low_pc
)
1369 if (address
> high_pc
)
1371 arange_add (unit
->abfd
, &unit
->arange
, low_pc
, high_pc
);
1373 case DW_LNE_set_address
:
1374 address
= read_address (unit
, line_ptr
);
1375 line_ptr
+= unit
->addr_size
;
1377 case DW_LNE_define_file
:
1378 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
1379 line_ptr
+= bytes_read
;
1380 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
1382 struct fileinfo
*tmp
;
1384 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
1385 amt
*= sizeof (struct fileinfo
);
1386 tmp
= bfd_realloc (table
->files
, amt
);
1389 free (table
->files
);
1396 table
->files
[table
->num_files
].name
= cur_file
;
1397 table
->files
[table
->num_files
].dir
=
1398 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1399 line_ptr
+= bytes_read
;
1400 table
->files
[table
->num_files
].time
=
1401 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1402 line_ptr
+= bytes_read
;
1403 table
->files
[table
->num_files
].size
=
1404 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1405 line_ptr
+= bytes_read
;
1408 case DW_LNE_set_discriminator
:
1409 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1410 line_ptr
+= bytes_read
;
1413 (*_bfd_error_handler
) (_("Dwarf Error: mangled line number section."));
1414 bfd_set_error (bfd_error_bad_value
);
1416 free (table
->files
);
1422 add_line_info (table
, address
, filename
, line
, column
, 0);
1423 if (address
< low_pc
)
1425 if (address
> high_pc
)
1428 case DW_LNS_advance_pc
:
1429 address
+= lh
.minimum_instruction_length
1430 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1431 line_ptr
+= bytes_read
;
1433 case DW_LNS_advance_line
:
1434 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
1435 line_ptr
+= bytes_read
;
1437 case DW_LNS_set_file
:
1441 /* The file and directory tables are 0
1442 based, the references are 1 based. */
1443 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1444 line_ptr
+= bytes_read
;
1447 filename
= concat_filename (table
, file
);
1450 case DW_LNS_set_column
:
1451 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1452 line_ptr
+= bytes_read
;
1454 case DW_LNS_negate_stmt
:
1455 is_stmt
= (!is_stmt
);
1457 case DW_LNS_set_basic_block
:
1459 case DW_LNS_const_add_pc
:
1460 address
+= lh
.minimum_instruction_length
1461 * ((255 - lh
.opcode_base
) / lh
.line_range
);
1463 case DW_LNS_fixed_advance_pc
:
1464 address
+= read_2_bytes (abfd
, line_ptr
);
1471 /* Unknown standard opcode, ignore it. */
1472 for (i
= 0; i
< lh
.standard_opcode_lengths
[op_code
]; i
++)
1474 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1475 line_ptr
+= bytes_read
;
1488 /* If ADDR is within TABLE set the output parameters and return TRUE,
1489 otherwise return FALSE. The output parameters, FILENAME_PTR and
1490 LINENUMBER_PTR, are pointers to the objects to be filled in. */
1493 lookup_address_in_line_info_table (struct line_info_table
*table
,
1495 struct funcinfo
*function
,
1496 const char **filename_ptr
,
1497 unsigned int *linenumber_ptr
)
1499 /* Note: table->last_line should be a descendingly sorted list. */
1500 struct line_info
* next_line
= table
->last_line
;
1501 struct line_info
* each_line
= NULL
;
1502 *filename_ptr
= NULL
;
1507 each_line
= next_line
->prev_line
;
1509 /* Check for large addresses */
1510 if (addr
> next_line
->address
)
1511 each_line
= NULL
; /* ensure we skip over the normal case */
1513 /* Normal case: search the list; save */
1514 while (each_line
&& next_line
)
1516 /* If we have an address match, save this info. This allows us
1517 to return as good as results as possible for strange debugging
1519 bfd_boolean addr_match
= FALSE
;
1520 if (each_line
->address
<= addr
&& addr
< next_line
->address
)
1524 /* If this line appears to span functions, and addr is in the
1525 later function, return the first line of that function instead
1526 of the last line of the earlier one. This check is for GCC
1527 2.95, which emits the first line number for a function late. */
1529 if (function
!= NULL
)
1532 struct arange
*arange
;
1534 /* Find the lowest address in the function's range list */
1535 lowest_pc
= function
->arange
.low
;
1536 for (arange
= &function
->arange
;
1538 arange
= arange
->next
)
1540 if (function
->arange
.low
< lowest_pc
)
1541 lowest_pc
= function
->arange
.low
;
1543 /* Check for spanning function and set outgoing line info */
1544 if (addr
>= lowest_pc
1545 && each_line
->address
< lowest_pc
1546 && next_line
->address
> lowest_pc
)
1548 *filename_ptr
= next_line
->filename
;
1549 *linenumber_ptr
= next_line
->line
;
1553 *filename_ptr
= each_line
->filename
;
1554 *linenumber_ptr
= each_line
->line
;
1559 *filename_ptr
= each_line
->filename
;
1560 *linenumber_ptr
= each_line
->line
;
1564 if (addr_match
&& !each_line
->end_sequence
)
1565 return TRUE
; /* we have definitely found what we want */
1567 next_line
= each_line
;
1568 each_line
= each_line
->prev_line
;
1571 /* At this point each_line is NULL but next_line is not. If we found
1572 a candidate end-of-sequence point in the loop above, we can return
1573 that (compatibility with a bug in the Intel compiler); otherwise,
1574 assuming that we found the containing function for this address in
1575 this compilation unit, return the first line we have a number for
1576 (compatibility with GCC 2.95). */
1577 if (*filename_ptr
== NULL
&& function
!= NULL
)
1579 *filename_ptr
= next_line
->filename
;
1580 *linenumber_ptr
= next_line
->line
;
1587 /* Read in the .debug_ranges section for future reference */
1590 read_debug_ranges (struct comp_unit
*unit
)
1592 struct dwarf2_debug
*stash
= unit
->stash
;
1593 return read_section (unit
->abfd
, ".debug_ranges", ".zdebug_ranges",
1595 &stash
->dwarf_ranges_buffer
, &stash
->dwarf_ranges_size
);
1598 /* Function table functions. */
1600 /* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return TRUE.
1601 Note that we need to find the function that has the smallest
1602 range that contains ADDR, to handle inlined functions without
1603 depending upon them being ordered in TABLE by increasing range. */
1606 lookup_address_in_function_table (struct comp_unit
*unit
,
1608 struct funcinfo
**function_ptr
,
1609 const char **functionname_ptr
)
1611 struct funcinfo
* each_func
;
1612 struct funcinfo
* best_fit
= NULL
;
1613 struct arange
*arange
;
1615 for (each_func
= unit
->function_table
;
1617 each_func
= each_func
->prev_func
)
1619 for (arange
= &each_func
->arange
;
1621 arange
= arange
->next
)
1623 if (addr
>= arange
->low
&& addr
< arange
->high
)
1626 ((arange
->high
- arange
->low
) < (best_fit
->arange
.high
- best_fit
->arange
.low
)))
1627 best_fit
= each_func
;
1634 *functionname_ptr
= best_fit
->name
;
1635 *function_ptr
= best_fit
;
1644 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
1645 and LINENUMBER_PTR, and return TRUE. */
1648 lookup_symbol_in_function_table (struct comp_unit
*unit
,
1651 const char **filename_ptr
,
1652 unsigned int *linenumber_ptr
)
1654 struct funcinfo
* each_func
;
1655 struct funcinfo
* best_fit
= NULL
;
1656 struct arange
*arange
;
1657 const char *name
= bfd_asymbol_name (sym
);
1658 asection
*sec
= bfd_get_section (sym
);
1660 for (each_func
= unit
->function_table
;
1662 each_func
= each_func
->prev_func
)
1664 for (arange
= &each_func
->arange
;
1666 arange
= arange
->next
)
1668 if ((!each_func
->sec
|| each_func
->sec
== sec
)
1669 && addr
>= arange
->low
1670 && addr
< arange
->high
1672 && strcmp (name
, each_func
->name
) == 0
1674 || ((arange
->high
- arange
->low
)
1675 < (best_fit
->arange
.high
- best_fit
->arange
.low
))))
1676 best_fit
= each_func
;
1682 best_fit
->sec
= sec
;
1683 *filename_ptr
= best_fit
->file
;
1684 *linenumber_ptr
= best_fit
->line
;
1691 /* Variable table functions. */
1693 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
1694 LINENUMBER_PTR, and return TRUE. */
1697 lookup_symbol_in_variable_table (struct comp_unit
*unit
,
1700 const char **filename_ptr
,
1701 unsigned int *linenumber_ptr
)
1703 const char *name
= bfd_asymbol_name (sym
);
1704 asection
*sec
= bfd_get_section (sym
);
1705 struct varinfo
* each
;
1707 for (each
= unit
->variable_table
; each
; each
= each
->prev_var
)
1708 if (each
->stack
== 0
1709 && each
->file
!= NULL
1710 && each
->name
!= NULL
1711 && each
->addr
== addr
1712 && (!each
->sec
|| each
->sec
== sec
)
1713 && strcmp (name
, each
->name
) == 0)
1719 *filename_ptr
= each
->file
;
1720 *linenumber_ptr
= each
->line
;
1728 find_abstract_instance_name (struct comp_unit
*unit
,
1729 struct attribute
*attr_ptr
)
1731 bfd
*abfd
= unit
->abfd
;
1733 unsigned int abbrev_number
, bytes_read
, i
;
1734 struct abbrev_info
*abbrev
;
1735 bfd_uint64_t die_ref
= attr_ptr
->u
.val
;
1736 struct attribute attr
;
1739 /* DW_FORM_ref_addr can reference an entry in a different CU. It
1740 is an offset from the .debug_info section, not the current CU. */
1741 if (attr_ptr
->form
== DW_FORM_ref_addr
)
1743 /* We only support DW_FORM_ref_addr within the same file, so
1744 any relocations should be resolved already. */
1748 info_ptr
= unit
->stash
->sec_info_ptr
+ die_ref
;
1751 info_ptr
= unit
->info_ptr_unit
+ die_ref
;
1752 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
1753 info_ptr
+= bytes_read
;
1757 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
1760 (*_bfd_error_handler
) (_("Dwarf Error: Could not find abbrev number %u."),
1762 bfd_set_error (bfd_error_bad_value
);
1766 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
1768 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
);
1772 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
1776 case DW_AT_specification
:
1777 name
= find_abstract_instance_name (unit
, &attr
);
1779 case DW_AT_MIPS_linkage_name
:
1792 read_rangelist (struct comp_unit
*unit
, struct arange
*arange
, bfd_uint64_t offset
)
1794 bfd_byte
*ranges_ptr
;
1795 bfd_vma base_address
= unit
->base_address
;
1797 if (! unit
->stash
->dwarf_ranges_buffer
)
1799 if (! read_debug_ranges (unit
))
1802 ranges_ptr
= unit
->stash
->dwarf_ranges_buffer
+ offset
;
1809 low_pc
= read_address (unit
, ranges_ptr
);
1810 ranges_ptr
+= unit
->addr_size
;
1811 high_pc
= read_address (unit
, ranges_ptr
);
1812 ranges_ptr
+= unit
->addr_size
;
1814 if (low_pc
== 0 && high_pc
== 0)
1816 if (low_pc
== -1UL && high_pc
!= -1UL)
1817 base_address
= high_pc
;
1819 arange_add (unit
->abfd
, arange
, base_address
+ low_pc
, base_address
+ high_pc
);
1823 /* DWARF2 Compilation unit functions. */
1825 /* Scan over each die in a comp. unit looking for functions to add
1826 to the function table and variables to the variable table. */
1829 scan_unit_for_symbols (struct comp_unit
*unit
)
1831 bfd
*abfd
= unit
->abfd
;
1832 bfd_byte
*info_ptr
= unit
->first_child_die_ptr
;
1833 int nesting_level
= 1;
1834 struct funcinfo
**nested_funcs
;
1835 int nested_funcs_size
;
1837 /* Maintain a stack of in-scope functions and inlined functions, which we
1838 can use to set the caller_func field. */
1839 nested_funcs_size
= 32;
1840 nested_funcs
= bfd_malloc (nested_funcs_size
* sizeof (struct funcinfo
*));
1841 if (nested_funcs
== NULL
)
1843 nested_funcs
[nesting_level
] = 0;
1845 while (nesting_level
)
1847 unsigned int abbrev_number
, bytes_read
, i
;
1848 struct abbrev_info
*abbrev
;
1849 struct attribute attr
;
1850 struct funcinfo
*func
;
1851 struct varinfo
*var
;
1853 bfd_vma high_pc
= 0;
1855 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
1856 info_ptr
+= bytes_read
;
1858 if (! abbrev_number
)
1864 abbrev
= lookup_abbrev (abbrev_number
,unit
->abbrevs
);
1867 (*_bfd_error_handler
) (_("Dwarf Error: Could not find abbrev number %u."),
1869 bfd_set_error (bfd_error_bad_value
);
1870 free (nested_funcs
);
1875 if (abbrev
->tag
== DW_TAG_subprogram
1876 || abbrev
->tag
== DW_TAG_entry_point
1877 || abbrev
->tag
== DW_TAG_inlined_subroutine
)
1879 bfd_size_type amt
= sizeof (struct funcinfo
);
1880 func
= bfd_zalloc (abfd
, amt
);
1881 func
->tag
= abbrev
->tag
;
1882 func
->prev_func
= unit
->function_table
;
1883 unit
->function_table
= func
;
1884 BFD_ASSERT (!unit
->cached
);
1886 if (func
->tag
== DW_TAG_inlined_subroutine
)
1887 for (i
= nesting_level
- 1; i
>= 1; i
--)
1888 if (nested_funcs
[i
])
1890 func
->caller_func
= nested_funcs
[i
];
1893 nested_funcs
[nesting_level
] = func
;
1898 if (abbrev
->tag
== DW_TAG_variable
)
1900 bfd_size_type amt
= sizeof (struct varinfo
);
1901 var
= bfd_zalloc (abfd
, amt
);
1902 var
->tag
= abbrev
->tag
;
1904 var
->prev_var
= unit
->variable_table
;
1905 unit
->variable_table
= var
;
1906 BFD_ASSERT (!unit
->cached
);
1909 /* No inline function in scope at this nesting level. */
1910 nested_funcs
[nesting_level
] = 0;
1913 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
1915 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
);
1921 case DW_AT_call_file
:
1922 func
->caller_file
= concat_filename (unit
->line_table
, attr
.u
.val
);
1925 case DW_AT_call_line
:
1926 func
->caller_line
= attr
.u
.val
;
1929 case DW_AT_abstract_origin
:
1930 func
->name
= find_abstract_instance_name (unit
, &attr
);
1934 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
1935 if (func
->name
== NULL
)
1936 func
->name
= attr
.u
.str
;
1939 case DW_AT_MIPS_linkage_name
:
1940 func
->name
= attr
.u
.str
;
1944 low_pc
= attr
.u
.val
;
1948 high_pc
= attr
.u
.val
;
1952 read_rangelist (unit
, &func
->arange
, attr
.u
.val
);
1955 case DW_AT_decl_file
:
1956 func
->file
= concat_filename (unit
->line_table
,
1960 case DW_AT_decl_line
:
1961 func
->line
= attr
.u
.val
;
1973 var
->name
= attr
.u
.str
;
1976 case DW_AT_decl_file
:
1977 var
->file
= concat_filename (unit
->line_table
,
1981 case DW_AT_decl_line
:
1982 var
->line
= attr
.u
.val
;
1985 case DW_AT_external
:
1986 if (attr
.u
.val
!= 0)
1990 case DW_AT_location
:
1994 case DW_FORM_block1
:
1995 case DW_FORM_block2
:
1996 case DW_FORM_block4
:
1997 if (*attr
.u
.blk
->data
== DW_OP_addr
)
2001 /* Verify that DW_OP_addr is the only opcode in the
2002 location, in which case the block size will be 1
2003 plus the address size. */
2004 /* ??? For TLS variables, gcc can emit
2005 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
2006 which we don't handle here yet. */
2007 if (attr
.u
.blk
->size
== unit
->addr_size
+ 1U)
2008 var
->addr
= bfd_get (unit
->addr_size
* 8,
2010 attr
.u
.blk
->data
+ 1);
2025 if (func
&& high_pc
!= 0)
2027 arange_add (unit
->abfd
, &func
->arange
, low_pc
, high_pc
);
2030 if (abbrev
->has_children
)
2034 if (nesting_level
>= nested_funcs_size
)
2036 struct funcinfo
**tmp
;
2038 nested_funcs_size
*= 2;
2039 tmp
= bfd_realloc (nested_funcs
,
2041 * sizeof (struct funcinfo
*)));
2044 free (nested_funcs
);
2049 nested_funcs
[nesting_level
] = 0;
2053 free (nested_funcs
);
2057 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
2058 includes the compilation unit header that proceeds the DIE's, but
2059 does not include the length field that precedes each compilation
2060 unit header. END_PTR points one past the end of this comp unit.
2061 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
2063 This routine does not read the whole compilation unit; only enough
2064 to get to the line number information for the compilation unit. */
2066 static struct comp_unit
*
2067 parse_comp_unit (struct dwarf2_debug
*stash
,
2068 bfd_vma unit_length
,
2069 bfd_byte
*info_ptr_unit
,
2070 unsigned int offset_size
)
2072 struct comp_unit
* unit
;
2073 unsigned int version
;
2074 bfd_uint64_t abbrev_offset
= 0;
2075 unsigned int addr_size
;
2076 struct abbrev_info
** abbrevs
;
2077 unsigned int abbrev_number
, bytes_read
, i
;
2078 struct abbrev_info
*abbrev
;
2079 struct attribute attr
;
2080 bfd_byte
*info_ptr
= stash
->info_ptr
;
2081 bfd_byte
*end_ptr
= info_ptr
+ unit_length
;
2084 bfd_vma high_pc
= 0;
2085 bfd
*abfd
= stash
->bfd
;
2087 version
= read_2_bytes (abfd
, info_ptr
);
2089 BFD_ASSERT (offset_size
== 4 || offset_size
== 8);
2090 if (offset_size
== 4)
2091 abbrev_offset
= read_4_bytes (abfd
, info_ptr
);
2093 abbrev_offset
= read_8_bytes (abfd
, info_ptr
);
2094 info_ptr
+= offset_size
;
2095 addr_size
= read_1_byte (abfd
, info_ptr
);
2098 if (version
!= 2 && version
!= 3)
2100 (*_bfd_error_handler
) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 and 3 information."), version
);
2101 bfd_set_error (bfd_error_bad_value
);
2105 if (addr_size
> sizeof (bfd_vma
))
2107 (*_bfd_error_handler
) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
2109 (unsigned int) sizeof (bfd_vma
));
2110 bfd_set_error (bfd_error_bad_value
);
2114 if (addr_size
!= 2 && addr_size
!= 4 && addr_size
!= 8)
2116 (*_bfd_error_handler
) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size
);
2117 bfd_set_error (bfd_error_bad_value
);
2121 /* Read the abbrevs for this compilation unit into a table. */
2122 abbrevs
= read_abbrevs (abfd
, abbrev_offset
, stash
);
2126 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2127 info_ptr
+= bytes_read
;
2128 if (! abbrev_number
)
2130 (*_bfd_error_handler
) (_("Dwarf Error: Bad abbrev number: %u."),
2132 bfd_set_error (bfd_error_bad_value
);
2136 abbrev
= lookup_abbrev (abbrev_number
, abbrevs
);
2139 (*_bfd_error_handler
) (_("Dwarf Error: Could not find abbrev number %u."),
2141 bfd_set_error (bfd_error_bad_value
);
2145 amt
= sizeof (struct comp_unit
);
2146 unit
= bfd_zalloc (abfd
, amt
);
2148 unit
->version
= version
;
2149 unit
->addr_size
= addr_size
;
2150 unit
->offset_size
= offset_size
;
2151 unit
->abbrevs
= abbrevs
;
2152 unit
->end_ptr
= end_ptr
;
2153 unit
->stash
= stash
;
2154 unit
->info_ptr_unit
= info_ptr_unit
;
2156 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
2158 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
);
2160 /* Store the data if it is of an attribute we want to keep in a
2161 partial symbol table. */
2164 case DW_AT_stmt_list
:
2166 unit
->line_offset
= attr
.u
.val
;
2170 unit
->name
= attr
.u
.str
;
2174 low_pc
= attr
.u
.val
;
2175 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
2176 this is the base address to use when reading location
2177 lists or range lists. */
2178 unit
->base_address
= low_pc
;
2182 high_pc
= attr
.u
.val
;
2186 read_rangelist (unit
, &unit
->arange
, attr
.u
.val
);
2189 case DW_AT_comp_dir
:
2191 char *comp_dir
= attr
.u
.str
;
2194 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2195 directory, get rid of it. */
2196 char *cp
= strchr (comp_dir
, ':');
2198 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2201 unit
->comp_dir
= comp_dir
;
2211 arange_add (unit
->abfd
, &unit
->arange
, low_pc
, high_pc
);
2214 unit
->first_child_die_ptr
= info_ptr
;
2218 /* Return TRUE if UNIT may contain the address given by ADDR. When
2219 there are functions written entirely with inline asm statements, the
2220 range info in the compilation unit header may not be correct. We
2221 need to consult the line info table to see if a compilation unit
2222 really contains the given address. */
2225 comp_unit_contains_address (struct comp_unit
*unit
, bfd_vma addr
)
2227 struct arange
*arange
;
2232 arange
= &unit
->arange
;
2235 if (addr
>= arange
->low
&& addr
< arange
->high
)
2237 arange
= arange
->next
;
2244 /* If UNIT contains ADDR, set the output parameters to the values for
2245 the line containing ADDR. The output parameters, FILENAME_PTR,
2246 FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
2249 Return TRUE if UNIT contains ADDR, and no errors were encountered;
2253 comp_unit_find_nearest_line (struct comp_unit
*unit
,
2255 const char **filename_ptr
,
2256 const char **functionname_ptr
,
2257 unsigned int *linenumber_ptr
,
2258 struct dwarf2_debug
*stash
)
2262 struct funcinfo
*function
;
2267 if (! unit
->line_table
)
2269 if (! unit
->stmtlist
)
2275 unit
->line_table
= decode_line_info (unit
, stash
);
2277 if (! unit
->line_table
)
2283 if (unit
->first_child_die_ptr
< unit
->end_ptr
2284 && ! scan_unit_for_symbols (unit
))
2292 func_p
= lookup_address_in_function_table (unit
, addr
,
2293 &function
, functionname_ptr
);
2294 if (func_p
&& (function
->tag
== DW_TAG_inlined_subroutine
))
2295 stash
->inliner_chain
= function
;
2296 line_p
= lookup_address_in_line_info_table (unit
->line_table
, addr
,
2297 function
, filename_ptr
,
2299 return line_p
|| func_p
;
2302 /* Check to see if line info is already decoded in a comp_unit.
2303 If not, decode it. Returns TRUE if no errors were encountered;
2307 comp_unit_maybe_decode_line_info (struct comp_unit
*unit
,
2308 struct dwarf2_debug
*stash
)
2313 if (! unit
->line_table
)
2315 if (! unit
->stmtlist
)
2321 unit
->line_table
= decode_line_info (unit
, stash
);
2323 if (! unit
->line_table
)
2329 if (unit
->first_child_die_ptr
< unit
->end_ptr
2330 && ! scan_unit_for_symbols (unit
))
2340 /* If UNIT contains SYM at ADDR, set the output parameters to the
2341 values for the line containing SYM. The output parameters,
2342 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
2345 Return TRUE if UNIT contains SYM, and no errors were encountered;
2349 comp_unit_find_line (struct comp_unit
*unit
,
2352 const char **filename_ptr
,
2353 unsigned int *linenumber_ptr
,
2354 struct dwarf2_debug
*stash
)
2356 if (!comp_unit_maybe_decode_line_info (unit
, stash
))
2359 if (sym
->flags
& BSF_FUNCTION
)
2360 return lookup_symbol_in_function_table (unit
, sym
, addr
,
2364 return lookup_symbol_in_variable_table (unit
, sym
, addr
,
2369 static struct funcinfo
*
2370 reverse_funcinfo_list (struct funcinfo
*head
)
2372 struct funcinfo
*rhead
;
2373 struct funcinfo
*temp
;
2375 for (rhead
= NULL
; head
; head
= temp
)
2377 temp
= head
->prev_func
;
2378 head
->prev_func
= rhead
;
2384 static struct varinfo
*
2385 reverse_varinfo_list (struct varinfo
*head
)
2387 struct varinfo
*rhead
;
2388 struct varinfo
*temp
;
2390 for (rhead
= NULL
; head
; head
= temp
)
2392 temp
= head
->prev_var
;
2393 head
->prev_var
= rhead
;
2399 /* Extract all interesting funcinfos and varinfos of a compilation
2400 unit into hash tables for faster lookup. Returns TRUE if no
2401 errors were enountered; FALSE otherwise. */
2404 comp_unit_hash_info (struct dwarf2_debug
*stash
,
2405 struct comp_unit
*unit
,
2406 struct info_hash_table
*funcinfo_hash_table
,
2407 struct info_hash_table
*varinfo_hash_table
)
2409 struct funcinfo
* each_func
;
2410 struct varinfo
* each_var
;
2411 bfd_boolean okay
= TRUE
;
2413 BFD_ASSERT (stash
->info_hash_status
!= STASH_INFO_HASH_DISABLED
);
2415 if (!comp_unit_maybe_decode_line_info (unit
, stash
))
2418 BFD_ASSERT (!unit
->cached
);
2420 /* To preserve the original search order, we went to visit the function
2421 infos in the reversed order of the list. However, making the list
2422 bi-directional use quite a bit of extra memory. So we reverse
2423 the list first, traverse the list in the now reversed order and
2424 finally reverse the list again to get back the original order. */
2425 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
2426 for (each_func
= unit
->function_table
;
2428 each_func
= each_func
->prev_func
)
2430 /* Skip nameless functions. */
2431 if (each_func
->name
)
2432 /* There is no need to copy name string into hash table as
2433 name string is either in the dwarf string buffer or
2434 info in the stash. */
2435 okay
= insert_info_hash_table (funcinfo_hash_table
, each_func
->name
,
2436 (void*) each_func
, FALSE
);
2438 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
2442 /* We do the same for variable infos. */
2443 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
2444 for (each_var
= unit
->variable_table
;
2446 each_var
= each_var
->prev_var
)
2448 /* Skip stack vars and vars with no files or names. */
2449 if (each_var
->stack
== 0
2450 && each_var
->file
!= NULL
2451 && each_var
->name
!= NULL
)
2452 /* There is no need to copy name string into hash table as
2453 name string is either in the dwarf string buffer or
2454 info in the stash. */
2455 okay
= insert_info_hash_table (varinfo_hash_table
, each_var
->name
,
2456 (void*) each_var
, FALSE
);
2459 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
2460 unit
->cached
= TRUE
;
2464 /* Locate a section in a BFD containing debugging info. The search starts
2465 from the section after AFTER_SEC, or from the first section in the BFD if
2466 AFTER_SEC is NULL. The search works by examining the names of the
2467 sections. There are two permissiable names. The first is .debug_info.
2468 This is the standard DWARF2 name. The second is a prefix .gnu.linkonce.wi.
2469 This is a variation on the .debug_info section which has a checksum
2470 describing the contents appended onto the name. This allows the linker to
2471 identify and discard duplicate debugging sections for different
2472 compilation units. */
2473 #define DWARF2_DEBUG_INFO ".debug_info"
2474 #define DWARF2_COMPRESSED_DEBUG_INFO ".zdebug_info"
2475 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
2478 find_debug_info (bfd
*abfd
, asection
*after_sec
)
2482 msec
= after_sec
!= NULL
? after_sec
->next
: abfd
->sections
;
2486 if (strcmp (msec
->name
, DWARF2_DEBUG_INFO
) == 0)
2489 if (strcmp (msec
->name
, DWARF2_COMPRESSED_DEBUG_INFO
) == 0)
2492 if (CONST_STRNEQ (msec
->name
, GNU_LINKONCE_INFO
))
2501 /* Unset vmas for adjusted sections in STASH. */
2504 unset_sections (struct dwarf2_debug
*stash
)
2507 struct adjusted_section
*p
;
2509 i
= stash
->adjusted_section_count
;
2510 p
= stash
->adjusted_sections
;
2511 for (; i
> 0; i
--, p
++)
2512 p
->section
->vma
= 0;
2515 /* Set unique VMAs for loadable and DWARF sections in ABFD and save
2516 VMAs in STASH for unset_sections. */
2519 place_sections (bfd
*abfd
, struct dwarf2_debug
*stash
)
2521 struct adjusted_section
*p
;
2524 if (stash
->adjusted_section_count
!= 0)
2526 i
= stash
->adjusted_section_count
;
2527 p
= stash
->adjusted_sections
;
2528 for (; i
> 0; i
--, p
++)
2529 p
->section
->vma
= p
->adj_vma
;
2534 bfd_vma last_vma
= 0, last_dwarf
= 0;
2536 struct adjusted_section
*p
;
2539 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
2547 /* We need to adjust the VMAs of any .debug_info sections.
2548 Skip compressed ones, since no relocations could target
2549 them - they should not appear in object files anyway. */
2550 if (strcmp (sect
->name
, DWARF2_DEBUG_INFO
) == 0)
2552 else if (CONST_STRNEQ (sect
->name
, GNU_LINKONCE_INFO
))
2557 if (!is_debug_info
&& (sect
->flags
& SEC_LOAD
) == 0)
2560 sz
= sect
->rawsize
? sect
->rawsize
: sect
->size
;
2567 amt
= i
* sizeof (struct adjusted_section
);
2568 p
= (struct adjusted_section
*) bfd_zalloc (abfd
, amt
);
2572 stash
->adjusted_sections
= p
;
2573 stash
->adjusted_section_count
= i
;
2575 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
2583 /* We need to adjust the VMAs of any .debug_info sections.
2584 Skip compressed ones, since no relocations could target
2585 them - they should not appear in object files anyway. */
2586 if (strcmp (sect
->name
, DWARF2_DEBUG_INFO
) == 0)
2588 else if (CONST_STRNEQ (sect
->name
, GNU_LINKONCE_INFO
))
2593 if (!is_debug_info
&& (sect
->flags
& SEC_LOAD
) == 0)
2596 sz
= sect
->rawsize
? sect
->rawsize
: sect
->size
;
2603 BFD_ASSERT (sect
->alignment_power
== 0);
2604 sect
->vma
= last_dwarf
;
2607 else if (last_vma
!= 0)
2609 /* Align the new address to the current section
2611 last_vma
= ((last_vma
2612 + ~((bfd_vma
) -1 << sect
->alignment_power
))
2613 & ((bfd_vma
) -1 << sect
->alignment_power
));
2614 sect
->vma
= last_vma
;
2615 last_vma
+= sect
->vma
+ sz
;
2618 last_vma
+= sect
->vma
+ sz
;
2620 p
->adj_vma
= sect
->vma
;
2629 /* Look up a funcinfo by name using the given info hash table. If found,
2630 also update the locations pointed to by filename_ptr and linenumber_ptr.
2632 This function returns TRUE if a funcinfo that matches the given symbol
2633 and address is found with any error; otherwise it returns FALSE. */
2636 info_hash_lookup_funcinfo (struct info_hash_table
*hash_table
,
2639 const char **filename_ptr
,
2640 unsigned int *linenumber_ptr
)
2642 struct funcinfo
* each_func
;
2643 struct funcinfo
* best_fit
= NULL
;
2644 struct info_list_node
*node
;
2645 struct arange
*arange
;
2646 const char *name
= bfd_asymbol_name (sym
);
2647 asection
*sec
= bfd_get_section (sym
);
2649 for (node
= lookup_info_hash_table (hash_table
, name
);
2653 each_func
= node
->info
;
2654 for (arange
= &each_func
->arange
;
2656 arange
= arange
->next
)
2658 if ((!each_func
->sec
|| each_func
->sec
== sec
)
2659 && addr
>= arange
->low
2660 && addr
< arange
->high
2662 || ((arange
->high
- arange
->low
)
2663 < (best_fit
->arange
.high
- best_fit
->arange
.low
))))
2664 best_fit
= each_func
;
2670 best_fit
->sec
= sec
;
2671 *filename_ptr
= best_fit
->file
;
2672 *linenumber_ptr
= best_fit
->line
;
2679 /* Look up a varinfo by name using the given info hash table. If found,
2680 also update the locations pointed to by filename_ptr and linenumber_ptr.
2682 This function returns TRUE if a varinfo that matches the given symbol
2683 and address is found with any error; otherwise it returns FALSE. */
2686 info_hash_lookup_varinfo (struct info_hash_table
*hash_table
,
2689 const char **filename_ptr
,
2690 unsigned int *linenumber_ptr
)
2692 const char *name
= bfd_asymbol_name (sym
);
2693 asection
*sec
= bfd_get_section (sym
);
2694 struct varinfo
* each
;
2695 struct info_list_node
*node
;
2697 for (node
= lookup_info_hash_table (hash_table
, name
);
2702 if (each
->addr
== addr
2703 && (!each
->sec
|| each
->sec
== sec
))
2706 *filename_ptr
= each
->file
;
2707 *linenumber_ptr
= each
->line
;
2715 /* Update the funcinfo and varinfo info hash tables if they are
2716 not up to date. Returns TRUE if there is no error; otherwise
2717 returns FALSE and disable the info hash tables. */
2720 stash_maybe_update_info_hash_tables (struct dwarf2_debug
*stash
)
2722 struct comp_unit
*each
;
2724 /* Exit if hash tables are up-to-date. */
2725 if (stash
->all_comp_units
== stash
->hash_units_head
)
2728 if (stash
->hash_units_head
)
2729 each
= stash
->hash_units_head
->prev_unit
;
2731 each
= stash
->last_comp_unit
;
2735 if (!comp_unit_hash_info (stash
, each
, stash
->funcinfo_hash_table
,
2736 stash
->varinfo_hash_table
))
2738 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
2741 each
= each
->prev_unit
;
2744 stash
->hash_units_head
= stash
->all_comp_units
;
2748 /* Check consistency of info hash tables. This is for debugging only. */
2750 static void ATTRIBUTE_UNUSED
2751 stash_verify_info_hash_table (struct dwarf2_debug
*stash
)
2753 struct comp_unit
*each_unit
;
2754 struct funcinfo
*each_func
;
2755 struct varinfo
*each_var
;
2756 struct info_list_node
*node
;
2759 for (each_unit
= stash
->all_comp_units
;
2761 each_unit
= each_unit
->next_unit
)
2763 for (each_func
= each_unit
->function_table
;
2765 each_func
= each_func
->prev_func
)
2767 if (!each_func
->name
)
2769 node
= lookup_info_hash_table (stash
->funcinfo_hash_table
,
2773 while (node
&& !found
)
2775 found
= node
->info
== each_func
;
2781 for (each_var
= each_unit
->variable_table
;
2783 each_var
= each_var
->prev_var
)
2785 if (!each_var
->name
|| !each_var
->file
|| each_var
->stack
)
2787 node
= lookup_info_hash_table (stash
->varinfo_hash_table
,
2791 while (node
&& !found
)
2793 found
= node
->info
== each_var
;
2801 /* Check to see if we want to enable the info hash tables, which consume
2802 quite a bit of memory. Currently we only check the number times
2803 bfd_dwarf2_find_line is called. In the future, we may also want to
2804 take the number of symbols into account. */
2807 stash_maybe_enable_info_hash_tables (bfd
*abfd
, struct dwarf2_debug
*stash
)
2809 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_OFF
);
2811 if (stash
->info_hash_count
++ < STASH_INFO_HASH_TRIGGER
)
2814 /* FIXME: Maybe we should check the reduce_memory_overheads
2815 and optimize fields in the bfd_link_info structure ? */
2817 /* Create hash tables. */
2818 stash
->funcinfo_hash_table
= create_info_hash_table (abfd
);
2819 stash
->varinfo_hash_table
= create_info_hash_table (abfd
);
2820 if (!stash
->funcinfo_hash_table
|| !stash
->varinfo_hash_table
)
2822 /* Turn off info hashes if any allocation above fails. */
2823 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
2826 /* We need a forced update so that the info hash tables will
2827 be created even though there is no compilation unit. That
2828 happens if STASH_INFO_HASH_TRIGGER is 0. */
2829 stash_maybe_update_info_hash_tables (stash
);
2830 stash
->info_hash_status
= STASH_INFO_HASH_ON
;
2833 /* Find the file and line associated with a symbol and address using the
2834 info hash tables of a stash. If there is a match, the function returns
2835 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
2836 otherwise it returns FALSE. */
2839 stash_find_line_fast (struct dwarf2_debug
*stash
,
2842 const char **filename_ptr
,
2843 unsigned int *linenumber_ptr
)
2845 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_ON
);
2847 if (sym
->flags
& BSF_FUNCTION
)
2848 return info_hash_lookup_funcinfo (stash
->funcinfo_hash_table
, sym
, addr
,
2849 filename_ptr
, linenumber_ptr
);
2850 return info_hash_lookup_varinfo (stash
->varinfo_hash_table
, sym
, addr
,
2851 filename_ptr
, linenumber_ptr
);
2854 /* Find the source code location of SYMBOL. If SYMBOL is NULL
2855 then find the nearest source code location corresponding to
2856 the address SECTION + OFFSET.
2857 Returns TRUE if the line is found without error and fills in
2858 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
2859 NULL the FUNCTIONNAME_PTR is also filled in.
2860 SYMBOLS contains the symbol table for ABFD.
2861 ADDR_SIZE is the number of bytes in the initial .debug_info length
2862 field and in the abbreviation offset, or zero to indicate that the
2863 default value should be used. */
2866 find_line (bfd
*abfd
,
2871 const char **filename_ptr
,
2872 const char **functionname_ptr
,
2873 unsigned int *linenumber_ptr
,
2874 unsigned int addr_size
,
2877 /* Read each compilation unit from the section .debug_info, and check
2878 to see if it contains the address we are searching for. If yes,
2879 lookup the address, and return the line number info. If no, go
2880 on to the next compilation unit.
2882 We keep a list of all the previously read compilation units, and
2883 a pointer to the next un-read compilation unit. Check the
2884 previously read units before reading more. */
2885 struct dwarf2_debug
*stash
;
2886 /* What address are we looking for? */
2888 struct comp_unit
* each
;
2889 bfd_vma found
= FALSE
;
2890 bfd_boolean do_line
;
2896 bfd_size_type amt
= sizeof (struct dwarf2_debug
);
2898 stash
= bfd_zalloc (abfd
, amt
);
2903 /* In a relocatable file, 2 functions may have the same address.
2904 We change the section vma so that they won't overlap. */
2905 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2907 if (! place_sections (abfd
, stash
))
2911 do_line
= (section
== NULL
2913 && functionname_ptr
== NULL
2917 addr
= symbol
->value
;
2918 section
= bfd_get_section (symbol
);
2920 else if (section
!= NULL
2921 && functionname_ptr
!= NULL
2927 if (section
->output_section
)
2928 addr
+= section
->output_section
->vma
+ section
->output_offset
;
2930 addr
+= section
->vma
;
2931 *filename_ptr
= NULL
;
2933 *functionname_ptr
= NULL
;
2934 *linenumber_ptr
= 0;
2939 bfd_size_type total_size
;
2944 msec
= find_debug_info (abfd
, NULL
);
2947 char * debug_filename
= bfd_follow_gnu_debuglink (abfd
, DEBUGDIR
);
2949 if (debug_filename
== NULL
)
2950 /* No dwarf2 info, and no gnu_debuglink to follow.
2951 Note that at this point the stash has been allocated, but
2952 contains zeros. This lets future calls to this function
2953 fail more quickly. */
2956 if ((debug_bfd
= bfd_openr (debug_filename
, NULL
)) == NULL
2957 || ! bfd_check_format (debug_bfd
, bfd_object
)
2958 || (msec
= find_debug_info (debug_bfd
, NULL
)) == NULL
)
2961 bfd_close (debug_bfd
);
2962 /* FIXME: Should we report our failure to follow the debuglink ? */
2963 free (debug_filename
);
2970 /* There can be more than one DWARF2 info section in a BFD these
2971 days. First handle the easy case when there's only one. If
2972 there's more than one, try case two: none of the sections is
2973 compressed. In that case, read them all in and produce one
2974 large stash. We do this in two passes - in the first pass we
2975 just accumulate the section sizes, and in the second pass we
2976 read in the section's contents. (The allows us to avoid
2977 reallocing the data as we add sections to the stash.) If
2978 some or all sections are compressed, then do things the slow
2979 way, with a bunch of reallocs. */
2981 if (! find_debug_info (debug_bfd
, msec
))
2983 /* Case 1: only one info section. */
2984 total_size
= msec
->size
;
2985 if (! read_section (debug_bfd
, ".debug_info", ".zdebug_info",
2987 &stash
->info_ptr_memory
, &total_size
))
2992 int all_uncompressed
= 1;
2993 for (total_size
= 0; msec
; msec
= find_debug_info (debug_bfd
, msec
))
2995 total_size
+= msec
->size
;
2996 if (strcmp (msec
->name
, DWARF2_COMPRESSED_DEBUG_INFO
) == 0)
2997 all_uncompressed
= 0;
2999 if (all_uncompressed
)
3001 /* Case 2: multiple sections, but none is compressed. */
3002 stash
->info_ptr_memory
= bfd_malloc (total_size
);
3003 if (stash
->info_ptr_memory
== NULL
)
3007 for (msec
= find_debug_info (debug_bfd
, NULL
);
3009 msec
= find_debug_info (debug_bfd
, msec
))
3017 if (!(bfd_simple_get_relocated_section_contents
3018 (debug_bfd
, msec
, stash
->info_ptr_memory
+ total_size
,
3027 /* Case 3: multiple sections, some or all compressed. */
3028 stash
->info_ptr_memory
= NULL
;
3030 for (msec
= find_debug_info (debug_bfd
, NULL
);
3032 msec
= find_debug_info (debug_bfd
, msec
))
3034 bfd_size_type size
= msec
->size
;
3040 buffer
= (bfd_simple_get_relocated_section_contents
3041 (debug_bfd
, msec
, NULL
, symbols
));
3045 if (strcmp (msec
->name
, DWARF2_COMPRESSED_DEBUG_INFO
) == 0)
3047 if (! bfd_uncompress_section_contents (&buffer
, &size
))
3053 stash
->info_ptr_memory
= bfd_realloc (stash
->info_ptr_memory
,
3055 memcpy (stash
->info_ptr_memory
+ total_size
, buffer
, size
);
3062 stash
->info_ptr
= stash
->info_ptr_memory
;
3063 stash
->info_ptr_end
= stash
->info_ptr
+ total_size
;
3064 stash
->sec
= find_debug_info (debug_bfd
, NULL
);
3065 stash
->sec_info_ptr
= stash
->info_ptr
;
3066 stash
->syms
= symbols
;
3067 stash
->bfd
= debug_bfd
;
3070 /* A null info_ptr indicates that there is no dwarf2 info
3071 (or that an error occured while setting up the stash). */
3072 if (! stash
->info_ptr
)
3075 stash
->inliner_chain
= NULL
;
3077 /* Check the previously read comp. units first. */
3080 /* The info hash tables use quite a bit of memory. We may not want to
3081 always use them. We use some heuristics to decide if and when to
3083 if (stash
->info_hash_status
== STASH_INFO_HASH_OFF
)
3084 stash_maybe_enable_info_hash_tables (abfd
, stash
);
3086 /* Keep info hash table up to date if they are available. Note that we
3087 may disable the hash tables if there is any error duing update. */
3088 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
3089 stash_maybe_update_info_hash_tables (stash
);
3091 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
3093 found
= stash_find_line_fast (stash
, symbol
, addr
, filename_ptr
,
3100 /* Check the previously read comp. units first. */
3101 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
3102 if ((symbol
->flags
& BSF_FUNCTION
) == 0
3103 || comp_unit_contains_address (each
, addr
))
3105 found
= comp_unit_find_line (each
, symbol
, addr
, filename_ptr
,
3106 linenumber_ptr
, stash
);
3114 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
3116 found
= (comp_unit_contains_address (each
, addr
)
3117 && comp_unit_find_nearest_line (each
, addr
,
3127 /* The DWARF2 spec says that the initial length field, and the
3128 offset of the abbreviation table, should both be 4-byte values.
3129 However, some compilers do things differently. */
3132 BFD_ASSERT (addr_size
== 4 || addr_size
== 8);
3134 /* Read each remaining comp. units checking each as they are read. */
3135 while (stash
->info_ptr
< stash
->info_ptr_end
)
3138 unsigned int offset_size
= addr_size
;
3139 bfd_byte
*info_ptr_unit
= stash
->info_ptr
;
3141 length
= read_4_bytes (stash
->bfd
, stash
->info_ptr
);
3142 /* A 0xffffff length is the DWARF3 way of indicating
3143 we use 64-bit offsets, instead of 32-bit offsets. */
3144 if (length
== 0xffffffff)
3147 length
= read_8_bytes (stash
->bfd
, stash
->info_ptr
+ 4);
3148 stash
->info_ptr
+= 12;
3150 /* A zero length is the IRIX way of indicating 64-bit offsets,
3151 mostly because the 64-bit length will generally fit in 32
3152 bits, and the endianness helps. */
3153 else if (length
== 0)
3156 length
= read_4_bytes (stash
->bfd
, stash
->info_ptr
+ 4);
3157 stash
->info_ptr
+= 8;
3159 /* In the absence of the hints above, we assume 32-bit DWARF2
3160 offsets even for targets with 64-bit addresses, because:
3161 a) most of the time these targets will not have generated
3162 more than 2Gb of debug info and so will not need 64-bit
3165 b) if they do use 64-bit offsets but they are not using
3166 the size hints that are tested for above then they are
3167 not conforming to the DWARF3 standard anyway. */
3168 else if (addr_size
== 8)
3171 stash
->info_ptr
+= 4;
3174 stash
->info_ptr
+= 4;
3178 each
= parse_comp_unit (stash
, length
, info_ptr_unit
,
3181 /* The dwarf information is damaged, don't trust it any
3184 stash
->info_ptr
+= length
;
3186 if (stash
->all_comp_units
)
3187 stash
->all_comp_units
->prev_unit
= each
;
3189 stash
->last_comp_unit
= each
;
3191 each
->next_unit
= stash
->all_comp_units
;
3192 stash
->all_comp_units
= each
;
3194 /* DW_AT_low_pc and DW_AT_high_pc are optional for
3195 compilation units. If we don't have them (i.e.,
3196 unit->high == 0), we need to consult the line info table
3197 to see if a compilation unit contains the given
3200 found
= (((symbol
->flags
& BSF_FUNCTION
) == 0
3201 || each
->arange
.high
== 0
3202 || comp_unit_contains_address (each
, addr
))
3203 && comp_unit_find_line (each
, symbol
, addr
,
3208 found
= ((each
->arange
.high
== 0
3209 || comp_unit_contains_address (each
, addr
))
3210 && comp_unit_find_nearest_line (each
, addr
,
3216 if ((bfd_vma
) (stash
->info_ptr
- stash
->sec_info_ptr
)
3217 == stash
->sec
->size
)
3219 stash
->sec
= find_debug_info (stash
->bfd
, stash
->sec
);
3220 stash
->sec_info_ptr
= stash
->info_ptr
;
3229 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
3230 unset_sections (stash
);
3235 /* The DWARF2 version of find_nearest_line.
3236 Return TRUE if the line is found without error. */
3239 _bfd_dwarf2_find_nearest_line (bfd
*abfd
,
3243 const char **filename_ptr
,
3244 const char **functionname_ptr
,
3245 unsigned int *linenumber_ptr
,
3246 unsigned int addr_size
,
3249 return find_line (abfd
, section
, offset
, NULL
, symbols
, filename_ptr
,
3250 functionname_ptr
, linenumber_ptr
, addr_size
,
3254 /* The DWARF2 version of find_line.
3255 Return TRUE if the line is found without error. */
3258 _bfd_dwarf2_find_line (bfd
*abfd
,
3261 const char **filename_ptr
,
3262 unsigned int *linenumber_ptr
,
3263 unsigned int addr_size
,
3266 return find_line (abfd
, NULL
, 0, symbol
, symbols
, filename_ptr
,
3267 NULL
, linenumber_ptr
, addr_size
,
3272 _bfd_dwarf2_find_inliner_info (bfd
*abfd ATTRIBUTE_UNUSED
,
3273 const char **filename_ptr
,
3274 const char **functionname_ptr
,
3275 unsigned int *linenumber_ptr
,
3278 struct dwarf2_debug
*stash
;
3283 struct funcinfo
*func
= stash
->inliner_chain
;
3285 if (func
&& func
->caller_func
)
3287 *filename_ptr
= func
->caller_file
;
3288 *functionname_ptr
= func
->caller_func
->name
;
3289 *linenumber_ptr
= func
->caller_line
;
3290 stash
->inliner_chain
= func
->caller_func
;
3299 _bfd_dwarf2_cleanup_debug_info (bfd
*abfd
)
3301 struct comp_unit
*each
;
3302 struct dwarf2_debug
*stash
;
3304 if (abfd
== NULL
|| elf_tdata (abfd
) == NULL
)
3307 stash
= elf_tdata (abfd
)->dwarf2_find_line_info
;
3312 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
3314 struct abbrev_info
**abbrevs
= each
->abbrevs
;
3315 struct funcinfo
*function_table
= each
->function_table
;
3316 struct varinfo
*variable_table
= each
->variable_table
;
3319 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
3321 struct abbrev_info
*abbrev
= abbrevs
[i
];
3325 free (abbrev
->attrs
);
3326 abbrev
= abbrev
->next
;
3330 if (each
->line_table
)
3332 free (each
->line_table
->dirs
);
3333 free (each
->line_table
->files
);
3336 while (function_table
)
3338 if (function_table
->file
)
3340 free (function_table
->file
);
3341 function_table
->file
= NULL
;
3344 if (function_table
->caller_file
)
3346 free (function_table
->caller_file
);
3347 function_table
->caller_file
= NULL
;
3349 function_table
= function_table
->prev_func
;
3352 while (variable_table
)
3354 if (variable_table
->file
)
3356 free (variable_table
->file
);
3357 variable_table
->file
= NULL
;
3360 variable_table
= variable_table
->prev_var
;
3364 if (stash
->dwarf_abbrev_buffer
)
3365 free (stash
->dwarf_abbrev_buffer
);
3366 if (stash
->dwarf_line_buffer
)
3367 free (stash
->dwarf_line_buffer
);
3368 if (stash
->dwarf_str_buffer
)
3369 free (stash
->dwarf_str_buffer
);
3370 if (stash
->dwarf_ranges_buffer
)
3371 free (stash
->dwarf_ranges_buffer
);
3372 if (stash
->info_ptr_memory
)
3373 free (stash
->info_ptr_memory
);