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 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 /* Pointer to the start of the debug section, for DW_FORM_ref_addr. */
220 bfd_byte
*sec_info_ptr
;
222 /* The offset into .debug_line of the line number table. */
223 unsigned long line_offset
;
225 /* Pointer to the first child die for the comp unit. */
226 bfd_byte
*first_child_die_ptr
;
228 /* The end of the comp unit. */
231 /* The decoded line number, NULL if not yet decoded. */
232 struct line_info_table
*line_table
;
234 /* A list of the functions found in this comp. unit. */
235 struct funcinfo
*function_table
;
237 /* A list of the variables found in this comp. unit. */
238 struct varinfo
*variable_table
;
240 /* Pointer to dwarf2_debug structure. */
241 struct dwarf2_debug
*stash
;
243 /* DWARF format version for this unit - from unit header. */
246 /* Address size for this unit - from unit header. */
247 unsigned char addr_size
;
249 /* Offset size for this unit - from unit header. */
250 unsigned char offset_size
;
252 /* Base address for this unit - from DW_AT_low_pc attribute of
253 DW_TAG_compile_unit DIE */
254 bfd_vma base_address
;
256 /* TRUE if symbols are cached in hash table for faster lookup by name. */
260 /* This data structure holds the information of an abbrev. */
263 unsigned int number
; /* Number identifying abbrev. */
264 enum dwarf_tag tag
; /* DWARF tag. */
265 int has_children
; /* Boolean. */
266 unsigned int num_attrs
; /* Number of attributes. */
267 struct attr_abbrev
*attrs
; /* An array of attribute descriptions. */
268 struct abbrev_info
*next
; /* Next in chain. */
273 enum dwarf_attribute name
;
274 enum dwarf_form form
;
277 #ifndef ABBREV_HASH_SIZE
278 #define ABBREV_HASH_SIZE 121
280 #ifndef ATTR_ALLOC_CHUNK
281 #define ATTR_ALLOC_CHUNK 4
284 /* Variable and function hash tables. This is used to speed up look-up
285 in lookup_symbol_in_var_table() and lookup_symbol_in_function_table().
286 In order to share code between variable and function infos, we use
287 a list of untyped pointer for all variable/function info associated with
288 a symbol. We waste a bit of memory for list with one node but that
289 simplifies the code. */
291 struct info_list_node
293 struct info_list_node
*next
;
297 /* Info hash entry. */
298 struct info_hash_entry
300 struct bfd_hash_entry root
;
301 struct info_list_node
*head
;
304 struct info_hash_table
306 struct bfd_hash_table base
;
309 /* Function to create a new entry in info hash table. */
311 static struct bfd_hash_entry
*
312 info_hash_table_newfunc (struct bfd_hash_entry
*entry
,
313 struct bfd_hash_table
*table
,
316 struct info_hash_entry
*ret
= (struct info_hash_entry
*) entry
;
318 /* Allocate the structure if it has not already been allocated by a
322 ret
= (struct info_hash_entry
*) bfd_hash_allocate (table
,
328 /* Call the allocation method of the base class. */
329 ret
= ((struct info_hash_entry
*)
330 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
332 /* Initialize the local fields here. */
336 return (struct bfd_hash_entry
*) ret
;
339 /* Function to create a new info hash table. It returns a pointer to the
340 newly created table or NULL if there is any error. We need abfd
341 solely for memory allocation. */
343 static struct info_hash_table
*
344 create_info_hash_table (bfd
*abfd
)
346 struct info_hash_table
*hash_table
;
348 hash_table
= (struct info_hash_table
*)
349 bfd_alloc (abfd
, sizeof (struct info_hash_table
));
353 if (!bfd_hash_table_init (&hash_table
->base
, info_hash_table_newfunc
,
354 sizeof (struct info_hash_entry
)))
356 bfd_release (abfd
, hash_table
);
363 /* Insert an info entry into an info hash table. We do not check of
364 duplicate entries. Also, the caller need to guarantee that the
365 right type of info in inserted as info is passed as a void* pointer.
366 This function returns true if there is no error. */
369 insert_info_hash_table (struct info_hash_table
*hash_table
,
374 struct info_hash_entry
*entry
;
375 struct info_list_node
*node
;
377 entry
= (struct info_hash_entry
*) bfd_hash_lookup (&hash_table
->base
,
382 node
= (struct info_list_node
*) bfd_hash_allocate (&hash_table
->base
,
388 node
->next
= entry
->head
;
394 /* Look up an info entry list from an info hash table. Return NULL
397 static struct info_list_node
*
398 lookup_info_hash_table (struct info_hash_table
*hash_table
, const char *key
)
400 struct info_hash_entry
*entry
;
402 entry
= (struct info_hash_entry
*) bfd_hash_lookup (&hash_table
->base
, key
,
404 return entry
? entry
->head
: NULL
;
407 /* Read a section into its appropriate place in the dwarf2_debug
408 struct (indicated by SECTION_BUFFER and SECTION_SIZE). If SYMS is
409 not NULL, use bfd_simple_get_relocated_section_contents to read the
410 section contents, otherwise use bfd_get_section_contents. Fail if
411 the located section does not contain at least OFFSET bytes. */
414 read_section (bfd
* abfd
,
415 const char * section_name
,
416 const char * compressed_section_name
,
419 bfd_byte
** section_buffer
,
420 bfd_size_type
* section_size
)
423 bfd_boolean section_is_compressed
= FALSE
;
425 /* read_section is a noop if the section has already been read. */
426 if (!*section_buffer
)
428 msec
= bfd_get_section_by_name (abfd
, section_name
);
429 if (! msec
&& compressed_section_name
)
431 msec
= bfd_get_section_by_name (abfd
, compressed_section_name
);
432 section_is_compressed
= TRUE
;
436 (*_bfd_error_handler
) (_("Dwarf Error: Can't find %s section."), section_name
);
437 bfd_set_error (bfd_error_bad_value
);
441 *section_size
= msec
->rawsize
? msec
->rawsize
: msec
->size
;
445 = bfd_simple_get_relocated_section_contents (abfd
, msec
, NULL
, syms
);
446 if (! *section_buffer
)
451 *section_buffer
= (bfd_byte
*) bfd_malloc (*section_size
);
452 if (! *section_buffer
)
454 if (! bfd_get_section_contents (abfd
, msec
, *section_buffer
,
459 if (section_is_compressed
)
461 if (! bfd_uncompress_section_contents (section_buffer
, section_size
))
463 (*_bfd_error_handler
) (_("Dwarf Error: unable to decompress %s section."), compressed_section_name
);
464 bfd_set_error (bfd_error_bad_value
);
470 /* It is possible to get a bad value for the offset into the section
471 that the client wants. Validate it here to avoid trouble later. */
472 if (offset
!= 0 && offset
>= *section_size
)
474 (*_bfd_error_handler
) (_("Dwarf Error: Offset (%lu) greater than or equal to %s size (%lu)."),
475 (long) offset
, section_name
, *section_size
);
476 bfd_set_error (bfd_error_bad_value
);
484 The following function up to the END VERBATIM mark are
485 copied directly from dwarf2read.c. */
487 /* Read dwarf information from a buffer. */
490 read_1_byte (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_byte
*buf
)
492 return bfd_get_8 (abfd
, buf
);
496 read_1_signed_byte (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_byte
*buf
)
498 return bfd_get_signed_8 (abfd
, buf
);
502 read_2_bytes (bfd
*abfd
, bfd_byte
*buf
)
504 return bfd_get_16 (abfd
, buf
);
508 read_4_bytes (bfd
*abfd
, bfd_byte
*buf
)
510 return bfd_get_32 (abfd
, buf
);
514 read_8_bytes (bfd
*abfd
, bfd_byte
*buf
)
516 return bfd_get_64 (abfd
, buf
);
520 read_n_bytes (bfd
*abfd ATTRIBUTE_UNUSED
,
522 unsigned int size ATTRIBUTE_UNUSED
)
528 read_string (bfd
*abfd ATTRIBUTE_UNUSED
,
530 unsigned int *bytes_read_ptr
)
532 /* Return a pointer to the embedded string. */
533 char *str
= (char *) buf
;
541 *bytes_read_ptr
= strlen (str
) + 1;
548 read_indirect_string (struct comp_unit
* unit
,
550 unsigned int * bytes_read_ptr
)
553 struct dwarf2_debug
*stash
= unit
->stash
;
556 if (unit
->offset_size
== 4)
557 offset
= read_4_bytes (unit
->abfd
, buf
);
559 offset
= read_8_bytes (unit
->abfd
, buf
);
561 *bytes_read_ptr
= unit
->offset_size
;
563 if (! read_section (unit
->abfd
, ".debug_str", ".zdebug_str",
565 &stash
->dwarf_str_buffer
, &stash
->dwarf_str_size
))
568 str
= (char *) stash
->dwarf_str_buffer
+ offset
;
575 read_address (struct comp_unit
*unit
, bfd_byte
*buf
)
577 int signed_vma
= get_elf_backend_data (unit
->abfd
)->sign_extend_vma
;
581 switch (unit
->addr_size
)
584 return bfd_get_signed_64 (unit
->abfd
, buf
);
586 return bfd_get_signed_32 (unit
->abfd
, buf
);
588 return bfd_get_signed_16 (unit
->abfd
, buf
);
595 switch (unit
->addr_size
)
598 return bfd_get_64 (unit
->abfd
, buf
);
600 return bfd_get_32 (unit
->abfd
, buf
);
602 return bfd_get_16 (unit
->abfd
, buf
);
609 /* Lookup an abbrev_info structure in the abbrev hash table. */
611 static struct abbrev_info
*
612 lookup_abbrev (unsigned int number
, struct abbrev_info
**abbrevs
)
614 unsigned int hash_number
;
615 struct abbrev_info
*abbrev
;
617 hash_number
= number
% ABBREV_HASH_SIZE
;
618 abbrev
= abbrevs
[hash_number
];
622 if (abbrev
->number
== number
)
625 abbrev
= abbrev
->next
;
631 /* In DWARF version 2, the description of the debugging information is
632 stored in a separate .debug_abbrev section. Before we read any
633 dies from a section we read in all abbreviations and install them
636 static struct abbrev_info
**
637 read_abbrevs (bfd
*abfd
, bfd_uint64_t offset
, struct dwarf2_debug
*stash
)
639 struct abbrev_info
**abbrevs
;
640 bfd_byte
*abbrev_ptr
;
641 struct abbrev_info
*cur_abbrev
;
642 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
643 unsigned int abbrev_form
, hash_number
;
646 if (! read_section (abfd
, ".debug_abbrev", ".zdebug_abbrev",
648 &stash
->dwarf_abbrev_buffer
, &stash
->dwarf_abbrev_size
))
651 amt
= sizeof (struct abbrev_info
*) * ABBREV_HASH_SIZE
;
652 abbrevs
= (struct abbrev_info
**) bfd_zalloc (abfd
, amt
);
654 abbrev_ptr
= stash
->dwarf_abbrev_buffer
+ offset
;
655 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
656 abbrev_ptr
+= bytes_read
;
658 /* Loop until we reach an abbrev number of 0. */
659 while (abbrev_number
)
661 amt
= sizeof (struct abbrev_info
);
662 cur_abbrev
= (struct abbrev_info
*) bfd_zalloc (abfd
, amt
);
664 /* Read in abbrev header. */
665 cur_abbrev
->number
= abbrev_number
;
666 cur_abbrev
->tag
= (enum dwarf_tag
)
667 read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
668 abbrev_ptr
+= bytes_read
;
669 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
672 /* Now read in declarations. */
673 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
674 abbrev_ptr
+= bytes_read
;
675 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
676 abbrev_ptr
+= bytes_read
;
680 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
682 struct attr_abbrev
*tmp
;
684 amt
= cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
;
685 amt
*= sizeof (struct attr_abbrev
);
686 tmp
= (struct attr_abbrev
*) bfd_realloc (cur_abbrev
->attrs
, amt
);
691 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
693 struct abbrev_info
*abbrev
= abbrevs
[i
];
697 free (abbrev
->attrs
);
698 abbrev
= abbrev
->next
;
703 cur_abbrev
->attrs
= tmp
;
706 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
707 = (enum dwarf_attribute
) abbrev_name
;
708 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
709 = (enum dwarf_form
) abbrev_form
;
710 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
711 abbrev_ptr
+= bytes_read
;
712 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
713 abbrev_ptr
+= bytes_read
;
716 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
717 cur_abbrev
->next
= abbrevs
[hash_number
];
718 abbrevs
[hash_number
] = cur_abbrev
;
720 /* Get next abbreviation.
721 Under Irix6 the abbreviations for a compilation unit are not
722 always properly terminated with an abbrev number of 0.
723 Exit loop if we encounter an abbreviation which we have
724 already read (which means we are about to read the abbreviations
725 for the next compile unit) or if the end of the abbreviation
727 if ((unsigned int) (abbrev_ptr
- stash
->dwarf_abbrev_buffer
)
728 >= stash
->dwarf_abbrev_size
)
730 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
731 abbrev_ptr
+= bytes_read
;
732 if (lookup_abbrev (abbrev_number
,abbrevs
) != NULL
)
739 /* Read an attribute value described by an attribute form. */
742 read_attribute_value (struct attribute
*attr
,
744 struct comp_unit
*unit
,
747 bfd
*abfd
= unit
->abfd
;
748 unsigned int bytes_read
;
749 struct dwarf_block
*blk
;
752 attr
->form
= (enum dwarf_form
) form
;
756 case DW_FORM_ref_addr
:
757 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
759 if (unit
->version
== 3)
761 if (unit
->offset_size
== 4)
762 attr
->u
.val
= read_4_bytes (unit
->abfd
, info_ptr
);
764 attr
->u
.val
= read_8_bytes (unit
->abfd
, info_ptr
);
765 info_ptr
+= unit
->offset_size
;
770 attr
->u
.val
= read_address (unit
, info_ptr
);
771 info_ptr
+= unit
->addr_size
;
774 amt
= sizeof (struct dwarf_block
);
775 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
776 blk
->size
= read_2_bytes (abfd
, info_ptr
);
778 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
779 info_ptr
+= blk
->size
;
783 amt
= sizeof (struct dwarf_block
);
784 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
785 blk
->size
= read_4_bytes (abfd
, info_ptr
);
787 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
788 info_ptr
+= blk
->size
;
792 attr
->u
.val
= read_2_bytes (abfd
, info_ptr
);
796 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
);
800 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
);
804 attr
->u
.str
= read_string (abfd
, info_ptr
, &bytes_read
);
805 info_ptr
+= bytes_read
;
808 attr
->u
.str
= read_indirect_string (unit
, info_ptr
, &bytes_read
);
809 info_ptr
+= bytes_read
;
812 amt
= sizeof (struct dwarf_block
);
813 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
814 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
815 info_ptr
+= bytes_read
;
816 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
817 info_ptr
+= blk
->size
;
821 amt
= sizeof (struct dwarf_block
);
822 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
823 blk
->size
= read_1_byte (abfd
, info_ptr
);
825 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
826 info_ptr
+= blk
->size
;
830 attr
->u
.val
= read_1_byte (abfd
, info_ptr
);
834 attr
->u
.val
= read_1_byte (abfd
, info_ptr
);
838 attr
->u
.sval
= read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
839 info_ptr
+= bytes_read
;
842 attr
->u
.val
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
843 info_ptr
+= bytes_read
;
846 attr
->u
.val
= read_1_byte (abfd
, info_ptr
);
850 attr
->u
.val
= read_2_bytes (abfd
, info_ptr
);
854 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
);
858 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
);
861 case DW_FORM_ref_udata
:
862 attr
->u
.val
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
863 info_ptr
+= bytes_read
;
865 case DW_FORM_indirect
:
866 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
867 info_ptr
+= bytes_read
;
868 info_ptr
= read_attribute_value (attr
, form
, unit
, info_ptr
);
871 (*_bfd_error_handler
) (_("Dwarf Error: Invalid or unhandled FORM value: %u."),
873 bfd_set_error (bfd_error_bad_value
);
878 /* Read an attribute described by an abbreviated attribute. */
881 read_attribute (struct attribute
*attr
,
882 struct attr_abbrev
*abbrev
,
883 struct comp_unit
*unit
,
886 attr
->name
= abbrev
->name
;
887 info_ptr
= read_attribute_value (attr
, abbrev
->form
, unit
, info_ptr
);
891 /* Source line information table routines. */
893 #define FILE_ALLOC_CHUNK 5
894 #define DIR_ALLOC_CHUNK 5
898 struct line_info
* prev_line
;
903 int end_sequence
; /* End of (sequential) code sequence. */
917 struct line_sequence
* prev_sequence
;
918 struct line_info
* last_line
; /* Largest VMA. */
921 struct line_info_table
924 unsigned int num_files
;
925 unsigned int num_dirs
;
926 unsigned int num_sequences
;
929 struct fileinfo
* files
;
930 struct line_sequence
* sequences
;
931 struct line_info
* lcl_head
; /* Local head; used in 'add_line_info'. */
934 /* Remember some information about each function. If the function is
935 inlined (DW_TAG_inlined_subroutine) it may have two additional
936 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
937 source code location where this function was inlined. */
941 struct funcinfo
*prev_func
; /* Pointer to previous function in list of all functions */
942 struct funcinfo
*caller_func
; /* Pointer to function one scope higher */
943 char *caller_file
; /* Source location file name where caller_func inlines this func */
944 int caller_line
; /* Source location line number where caller_func inlines this func */
945 char *file
; /* Source location file name */
946 int line
; /* Source location line number */
949 struct arange arange
;
950 asection
*sec
; /* Where the symbol is defined */
955 /* Pointer to previous variable in list of all variables */
956 struct varinfo
*prev_var
;
957 /* Source location file name */
959 /* Source location line number */
964 /* Where the symbol is defined */
966 /* Is this a stack variable? */
967 unsigned int stack
: 1;
970 /* Return TRUE if NEW_LINE should sort after LINE. */
972 static inline bfd_boolean
973 new_line_sorts_after (struct line_info
*new_line
, struct line_info
*line
)
975 return (new_line
->address
> line
->address
976 || (new_line
->address
== line
->address
977 && new_line
->end_sequence
< line
->end_sequence
));
981 /* Adds a new entry to the line_info list in the line_info_table, ensuring
982 that the list is sorted. Note that the line_info list is sorted from
983 highest to lowest VMA (with possible duplicates); that is,
984 line_info->prev_line always accesses an equal or smaller VMA. */
987 add_line_info (struct line_info_table
*table
,
994 bfd_size_type amt
= sizeof (struct line_info
);
995 struct line_sequence
* seq
= table
->sequences
;
996 struct line_info
* info
= (struct line_info
*) bfd_alloc (table
->abfd
, amt
);
998 /* Set member data of 'info'. */
999 info
->address
= address
;
1001 info
->column
= column
;
1002 info
->end_sequence
= end_sequence
;
1004 if (filename
&& filename
[0])
1006 info
->filename
= (char *) bfd_alloc (table
->abfd
, strlen (filename
) + 1);
1008 strcpy (info
->filename
, filename
);
1011 info
->filename
= NULL
;
1013 /* Find the correct location for 'info'. Normally we will receive
1014 new line_info data 1) in order and 2) with increasing VMAs.
1015 However some compilers break the rules (cf. decode_line_info) and
1016 so we include some heuristics for quickly finding the correct
1017 location for 'info'. In particular, these heuristics optimize for
1018 the common case in which the VMA sequence that we receive is a
1019 list of locally sorted VMAs such as
1020 p...z a...j (where a < j < p < z)
1022 Note: table->lcl_head is used to head an *actual* or *possible*
1023 sub-sequence within the list (such as a...j) that is not directly
1024 headed by table->last_line
1026 Note: we may receive duplicate entries from 'decode_line_info'. */
1029 && seq
->last_line
->address
== address
1030 && seq
->last_line
->end_sequence
== end_sequence
)
1032 /* We only keep the last entry with the same address and end
1033 sequence. See PR ld/4986. */
1034 if (table
->lcl_head
== seq
->last_line
)
1035 table
->lcl_head
= info
;
1036 info
->prev_line
= seq
->last_line
->prev_line
;
1037 seq
->last_line
= info
;
1039 else if (!seq
|| seq
->last_line
->end_sequence
)
1041 /* Start a new line sequence. */
1042 amt
= sizeof (struct line_sequence
);
1043 seq
= (struct line_sequence
*) bfd_malloc (amt
);
1044 seq
->low_pc
= address
;
1045 seq
->prev_sequence
= table
->sequences
;
1046 seq
->last_line
= info
;
1047 table
->lcl_head
= info
;
1048 table
->sequences
= seq
;
1049 table
->num_sequences
++;
1051 else if (new_line_sorts_after (info
, seq
->last_line
))
1053 /* Normal case: add 'info' to the beginning of the current sequence. */
1054 info
->prev_line
= seq
->last_line
;
1055 seq
->last_line
= info
;
1057 /* lcl_head: initialize to head a *possible* sequence at the end. */
1058 if (!table
->lcl_head
)
1059 table
->lcl_head
= info
;
1061 else if (!new_line_sorts_after (info
, table
->lcl_head
)
1062 && (!table
->lcl_head
->prev_line
1063 || new_line_sorts_after (info
, table
->lcl_head
->prev_line
)))
1065 /* Abnormal but easy: lcl_head is the head of 'info'. */
1066 info
->prev_line
= table
->lcl_head
->prev_line
;
1067 table
->lcl_head
->prev_line
= info
;
1071 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head'
1072 are valid heads for 'info'. Reset 'lcl_head'. */
1073 struct line_info
* li2
= seq
->last_line
; /* Always non-NULL. */
1074 struct line_info
* li1
= li2
->prev_line
;
1078 if (!new_line_sorts_after (info
, li2
)
1079 && new_line_sorts_after (info
, li1
))
1082 li2
= li1
; /* always non-NULL */
1083 li1
= li1
->prev_line
;
1085 table
->lcl_head
= li2
;
1086 info
->prev_line
= table
->lcl_head
->prev_line
;
1087 table
->lcl_head
->prev_line
= info
;
1088 if (address
< seq
->low_pc
)
1089 seq
->low_pc
= address
;
1093 /* Extract a fully qualified filename from a line info table.
1094 The returned string has been malloc'ed and it is the caller's
1095 responsibility to free it. */
1098 concat_filename (struct line_info_table
*table
, unsigned int file
)
1102 if (file
- 1 >= table
->num_files
)
1104 /* FILE == 0 means unknown. */
1106 (*_bfd_error_handler
)
1107 (_("Dwarf Error: mangled line number section (bad file number)."));
1108 return strdup ("<unknown>");
1111 filename
= table
->files
[file
- 1].name
;
1113 if (!IS_ABSOLUTE_PATH (filename
))
1115 char *dir_name
= NULL
;
1116 char *subdir_name
= NULL
;
1120 if (table
->files
[file
- 1].dir
)
1121 subdir_name
= table
->dirs
[table
->files
[file
- 1].dir
- 1];
1123 if (!subdir_name
|| !IS_ABSOLUTE_PATH (subdir_name
))
1124 dir_name
= table
->comp_dir
;
1128 dir_name
= subdir_name
;
1133 return strdup (filename
);
1135 len
= strlen (dir_name
) + strlen (filename
) + 2;
1139 len
+= strlen (subdir_name
) + 1;
1140 name
= (char *) bfd_malloc (len
);
1142 sprintf (name
, "%s/%s/%s", dir_name
, subdir_name
, filename
);
1146 name
= (char *) bfd_malloc (len
);
1148 sprintf (name
, "%s/%s", dir_name
, filename
);
1154 return strdup (filename
);
1158 arange_add (bfd
*abfd
, struct arange
*first_arange
, bfd_vma low_pc
, bfd_vma high_pc
)
1160 struct arange
*arange
;
1162 /* If the first arange is empty, use it. */
1163 if (first_arange
->high
== 0)
1165 first_arange
->low
= low_pc
;
1166 first_arange
->high
= high_pc
;
1170 /* Next see if we can cheaply extend an existing range. */
1171 arange
= first_arange
;
1174 if (low_pc
== arange
->high
)
1176 arange
->high
= high_pc
;
1179 if (high_pc
== arange
->low
)
1181 arange
->low
= low_pc
;
1184 arange
= arange
->next
;
1188 /* Need to allocate a new arange and insert it into the arange list.
1189 Order isn't significant, so just insert after the first arange. */
1190 arange
= (struct arange
*) bfd_zalloc (abfd
, sizeof (*arange
));
1191 arange
->low
= low_pc
;
1192 arange
->high
= high_pc
;
1193 arange
->next
= first_arange
->next
;
1194 first_arange
->next
= arange
;
1197 /* Compare function for line sequences. */
1200 compare_sequences (const void* a
, const void* b
)
1202 const struct line_sequence
* seq1
= a
;
1203 const struct line_sequence
* seq2
= b
;
1205 /* Sort by low_pc as the primary key. */
1206 if (seq1
->low_pc
< seq2
->low_pc
)
1208 if (seq1
->low_pc
> seq2
->low_pc
)
1211 /* If low_pc values are equal, sort in reverse order of
1212 high_pc, so that the largest region comes first. */
1213 if (seq1
->last_line
->address
< seq2
->last_line
->address
)
1215 if (seq1
->last_line
->address
> seq2
->last_line
->address
)
1221 /* Sort the line sequences for quick lookup. */
1224 sort_line_sequences (struct line_info_table
* table
)
1227 struct line_sequence
* sequences
;
1228 struct line_sequence
* seq
;
1230 unsigned int num_sequences
= table
->num_sequences
;
1231 bfd_vma last_high_pc
;
1233 if (num_sequences
== 0)
1236 /* Allocate space for an array of sequences. */
1237 amt
= sizeof (struct line_sequence
) * num_sequences
;
1238 sequences
= (struct line_sequence
*) bfd_alloc (table
->abfd
, amt
);
1240 /* Copy the linked list into the array, freeing the original nodes. */
1241 seq
= table
->sequences
;
1242 for (n
= 0; n
< num_sequences
; n
++)
1244 struct line_sequence
* last_seq
= seq
;
1247 sequences
[n
].low_pc
= seq
->low_pc
;
1248 sequences
[n
].prev_sequence
= NULL
;
1249 sequences
[n
].last_line
= seq
->last_line
;
1250 seq
= seq
->prev_sequence
;
1253 BFD_ASSERT (seq
== NULL
);
1255 qsort (sequences
, n
, sizeof (struct line_sequence
), compare_sequences
);
1257 /* Make the list binary-searchable by trimming overlapping entries
1258 and removing nested entries. */
1260 last_high_pc
= sequences
[0].last_line
->address
;
1261 for (n
= 1; n
< table
->num_sequences
; n
++)
1263 if (sequences
[n
].low_pc
< last_high_pc
)
1265 if (sequences
[n
].last_line
->address
<= last_high_pc
)
1266 /* Skip nested entries. */
1269 /* Trim overlapping entries. */
1270 sequences
[n
].low_pc
= last_high_pc
;
1272 last_high_pc
= sequences
[n
].last_line
->address
;
1273 if (n
> num_sequences
)
1275 /* Close up the gap. */
1276 sequences
[num_sequences
].low_pc
= sequences
[n
].low_pc
;
1277 sequences
[num_sequences
].last_line
= sequences
[n
].last_line
;
1282 table
->sequences
= sequences
;
1283 table
->num_sequences
= num_sequences
;
1286 /* Decode the line number information for UNIT. */
1288 static struct line_info_table
*
1289 decode_line_info (struct comp_unit
*unit
, struct dwarf2_debug
*stash
)
1291 bfd
*abfd
= unit
->abfd
;
1292 struct line_info_table
* table
;
1295 struct line_head lh
;
1296 unsigned int i
, bytes_read
, offset_size
;
1297 char *cur_file
, *cur_dir
;
1298 unsigned char op_code
, extended_op
, adj_opcode
;
1301 if (! read_section (abfd
, ".debug_line", ".zdebug_line",
1302 stash
->syms
, unit
->line_offset
,
1303 &stash
->dwarf_line_buffer
, &stash
->dwarf_line_size
))
1306 amt
= sizeof (struct line_info_table
);
1307 table
= (struct line_info_table
*) bfd_alloc (abfd
, amt
);
1309 table
->comp_dir
= unit
->comp_dir
;
1311 table
->num_files
= 0;
1312 table
->files
= NULL
;
1314 table
->num_dirs
= 0;
1317 table
->num_sequences
= 0;
1318 table
->sequences
= NULL
;
1320 table
->lcl_head
= NULL
;
1322 line_ptr
= stash
->dwarf_line_buffer
+ unit
->line_offset
;
1324 /* Read in the prologue. */
1325 lh
.total_length
= read_4_bytes (abfd
, line_ptr
);
1328 if (lh
.total_length
== 0xffffffff)
1330 lh
.total_length
= read_8_bytes (abfd
, line_ptr
);
1334 else if (lh
.total_length
== 0 && unit
->addr_size
== 8)
1336 /* Handle (non-standard) 64-bit DWARF2 formats. */
1337 lh
.total_length
= read_4_bytes (abfd
, line_ptr
);
1341 line_end
= line_ptr
+ lh
.total_length
;
1342 lh
.version
= read_2_bytes (abfd
, line_ptr
);
1344 if (offset_size
== 4)
1345 lh
.prologue_length
= read_4_bytes (abfd
, line_ptr
);
1347 lh
.prologue_length
= read_8_bytes (abfd
, line_ptr
);
1348 line_ptr
+= offset_size
;
1349 lh
.minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
1351 lh
.default_is_stmt
= read_1_byte (abfd
, line_ptr
);
1353 lh
.line_base
= read_1_signed_byte (abfd
, line_ptr
);
1355 lh
.line_range
= read_1_byte (abfd
, line_ptr
);
1357 lh
.opcode_base
= read_1_byte (abfd
, line_ptr
);
1359 amt
= lh
.opcode_base
* sizeof (unsigned char);
1360 lh
.standard_opcode_lengths
= (unsigned char *) bfd_alloc (abfd
, amt
);
1362 lh
.standard_opcode_lengths
[0] = 1;
1364 for (i
= 1; i
< lh
.opcode_base
; ++i
)
1366 lh
.standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
1370 /* Read directory table. */
1371 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
1373 line_ptr
+= bytes_read
;
1375 if ((table
->num_dirs
% DIR_ALLOC_CHUNK
) == 0)
1379 amt
= table
->num_dirs
+ DIR_ALLOC_CHUNK
;
1380 amt
*= sizeof (char *);
1382 tmp
= (char **) bfd_realloc (table
->dirs
, amt
);
1391 table
->dirs
[table
->num_dirs
++] = cur_dir
;
1394 line_ptr
+= bytes_read
;
1396 /* Read file name table. */
1397 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
1399 line_ptr
+= bytes_read
;
1401 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
1403 struct fileinfo
*tmp
;
1405 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
1406 amt
*= sizeof (struct fileinfo
);
1408 tmp
= (struct fileinfo
*) bfd_realloc (table
->files
, amt
);
1411 free (table
->files
);
1418 table
->files
[table
->num_files
].name
= cur_file
;
1419 table
->files
[table
->num_files
].dir
=
1420 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1421 line_ptr
+= bytes_read
;
1422 table
->files
[table
->num_files
].time
=
1423 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1424 line_ptr
+= bytes_read
;
1425 table
->files
[table
->num_files
].size
=
1426 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1427 line_ptr
+= bytes_read
;
1431 line_ptr
+= bytes_read
;
1433 /* Read the statement sequences until there's nothing left. */
1434 while (line_ptr
< line_end
)
1436 /* State machine registers. */
1437 bfd_vma address
= 0;
1438 char * filename
= table
->num_files
? concat_filename (table
, 1) : NULL
;
1439 unsigned int line
= 1;
1440 unsigned int column
= 0;
1441 int is_stmt
= lh
.default_is_stmt
;
1442 int end_sequence
= 0;
1443 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1444 compilers generate address sequences that are wildly out of
1445 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1446 for ia64-Linux). Thus, to determine the low and high
1447 address, we must compare on every DW_LNS_copy, etc. */
1448 bfd_vma low_pc
= (bfd_vma
) -1;
1449 bfd_vma high_pc
= 0;
1451 /* Decode the table. */
1452 while (! end_sequence
)
1454 op_code
= read_1_byte (abfd
, line_ptr
);
1457 if (op_code
>= lh
.opcode_base
)
1459 /* Special operand. */
1460 adj_opcode
= op_code
- lh
.opcode_base
;
1461 address
+= (adj_opcode
/ lh
.line_range
)
1462 * lh
.minimum_instruction_length
;
1463 line
+= lh
.line_base
+ (adj_opcode
% lh
.line_range
);
1464 /* Append row to matrix using current values. */
1465 add_line_info (table
, address
, filename
, line
, column
, 0);
1466 if (address
< low_pc
)
1468 if (address
> high_pc
)
1471 else switch (op_code
)
1473 case DW_LNS_extended_op
:
1474 /* Ignore length. */
1476 extended_op
= read_1_byte (abfd
, line_ptr
);
1479 switch (extended_op
)
1481 case DW_LNE_end_sequence
:
1483 add_line_info (table
, address
, filename
, line
, column
,
1485 if (address
< low_pc
)
1487 if (address
> high_pc
)
1489 arange_add (unit
->abfd
, &unit
->arange
, low_pc
, high_pc
);
1491 case DW_LNE_set_address
:
1492 address
= read_address (unit
, line_ptr
);
1493 line_ptr
+= unit
->addr_size
;
1495 case DW_LNE_define_file
:
1496 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
1497 line_ptr
+= bytes_read
;
1498 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
1500 struct fileinfo
*tmp
;
1502 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
1503 amt
*= sizeof (struct fileinfo
);
1504 tmp
= (struct fileinfo
*) bfd_realloc (table
->files
, amt
);
1507 free (table
->files
);
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
;
1526 case DW_LNE_set_discriminator
:
1527 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1528 line_ptr
+= bytes_read
;
1531 (*_bfd_error_handler
) (_("Dwarf Error: mangled line number section."));
1532 bfd_set_error (bfd_error_bad_value
);
1534 free (table
->files
);
1540 add_line_info (table
, address
, filename
, line
, column
, 0);
1541 if (address
< low_pc
)
1543 if (address
> high_pc
)
1546 case DW_LNS_advance_pc
:
1547 address
+= lh
.minimum_instruction_length
1548 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1549 line_ptr
+= bytes_read
;
1551 case DW_LNS_advance_line
:
1552 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
1553 line_ptr
+= bytes_read
;
1555 case DW_LNS_set_file
:
1559 /* The file and directory tables are 0
1560 based, the references are 1 based. */
1561 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1562 line_ptr
+= bytes_read
;
1565 filename
= concat_filename (table
, file
);
1568 case DW_LNS_set_column
:
1569 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1570 line_ptr
+= bytes_read
;
1572 case DW_LNS_negate_stmt
:
1573 is_stmt
= (!is_stmt
);
1575 case DW_LNS_set_basic_block
:
1577 case DW_LNS_const_add_pc
:
1578 address
+= lh
.minimum_instruction_length
1579 * ((255 - lh
.opcode_base
) / lh
.line_range
);
1581 case DW_LNS_fixed_advance_pc
:
1582 address
+= read_2_bytes (abfd
, line_ptr
);
1586 /* Unknown standard opcode, ignore it. */
1587 for (i
= 0; i
< lh
.standard_opcode_lengths
[op_code
]; i
++)
1589 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1590 line_ptr
+= bytes_read
;
1600 sort_line_sequences (table
);
1605 /* If ADDR is within TABLE set the output parameters and return TRUE,
1606 otherwise return FALSE. The output parameters, FILENAME_PTR and
1607 LINENUMBER_PTR, are pointers to the objects to be filled in. */
1610 lookup_address_in_line_info_table (struct line_info_table
*table
,
1612 const char **filename_ptr
,
1613 unsigned int *linenumber_ptr
)
1615 struct line_sequence
*seq
= NULL
;
1616 struct line_info
*each_line
;
1619 /* Binary search the array of sequences. */
1621 high
= table
->num_sequences
;
1624 mid
= (low
+ high
) / 2;
1625 seq
= &table
->sequences
[mid
];
1626 if (addr
< seq
->low_pc
)
1628 else if (addr
>= seq
->last_line
->address
)
1634 if (seq
&& addr
>= seq
->low_pc
&& addr
< seq
->last_line
->address
)
1636 /* Note: seq->last_line should be a descendingly sorted list. */
1637 for (each_line
= seq
->last_line
;
1639 each_line
= each_line
->prev_line
)
1640 if (addr
>= each_line
->address
)
1644 && !(each_line
->end_sequence
|| each_line
== seq
->last_line
))
1646 *filename_ptr
= each_line
->filename
;
1647 *linenumber_ptr
= each_line
->line
;
1652 *filename_ptr
= NULL
;
1656 /* Read in the .debug_ranges section for future reference. */
1659 read_debug_ranges (struct comp_unit
*unit
)
1661 struct dwarf2_debug
*stash
= unit
->stash
;
1662 return read_section (unit
->abfd
, ".debug_ranges", ".zdebug_ranges",
1664 &stash
->dwarf_ranges_buffer
, &stash
->dwarf_ranges_size
);
1667 /* Function table functions. */
1669 /* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return TRUE.
1670 Note that we need to find the function that has the smallest
1671 range that contains ADDR, to handle inlined functions without
1672 depending upon them being ordered in TABLE by increasing range. */
1675 lookup_address_in_function_table (struct comp_unit
*unit
,
1677 struct funcinfo
**function_ptr
,
1678 const char **functionname_ptr
)
1680 struct funcinfo
* each_func
;
1681 struct funcinfo
* best_fit
= NULL
;
1682 struct arange
*arange
;
1684 for (each_func
= unit
->function_table
;
1686 each_func
= each_func
->prev_func
)
1688 for (arange
= &each_func
->arange
;
1690 arange
= arange
->next
)
1692 if (addr
>= arange
->low
&& addr
< arange
->high
)
1695 ((arange
->high
- arange
->low
) < (best_fit
->arange
.high
- best_fit
->arange
.low
)))
1696 best_fit
= each_func
;
1703 *functionname_ptr
= best_fit
->name
;
1704 *function_ptr
= best_fit
;
1713 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
1714 and LINENUMBER_PTR, and return TRUE. */
1717 lookup_symbol_in_function_table (struct comp_unit
*unit
,
1720 const char **filename_ptr
,
1721 unsigned int *linenumber_ptr
)
1723 struct funcinfo
* each_func
;
1724 struct funcinfo
* best_fit
= NULL
;
1725 struct arange
*arange
;
1726 const char *name
= bfd_asymbol_name (sym
);
1727 asection
*sec
= bfd_get_section (sym
);
1729 for (each_func
= unit
->function_table
;
1731 each_func
= each_func
->prev_func
)
1733 for (arange
= &each_func
->arange
;
1735 arange
= arange
->next
)
1737 if ((!each_func
->sec
|| each_func
->sec
== sec
)
1738 && addr
>= arange
->low
1739 && addr
< arange
->high
1741 && strcmp (name
, each_func
->name
) == 0
1743 || ((arange
->high
- arange
->low
)
1744 < (best_fit
->arange
.high
- best_fit
->arange
.low
))))
1745 best_fit
= each_func
;
1751 best_fit
->sec
= sec
;
1752 *filename_ptr
= best_fit
->file
;
1753 *linenumber_ptr
= best_fit
->line
;
1760 /* Variable table functions. */
1762 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
1763 LINENUMBER_PTR, and return TRUE. */
1766 lookup_symbol_in_variable_table (struct comp_unit
*unit
,
1769 const char **filename_ptr
,
1770 unsigned int *linenumber_ptr
)
1772 const char *name
= bfd_asymbol_name (sym
);
1773 asection
*sec
= bfd_get_section (sym
);
1774 struct varinfo
* each
;
1776 for (each
= unit
->variable_table
; each
; each
= each
->prev_var
)
1777 if (each
->stack
== 0
1778 && each
->file
!= NULL
1779 && each
->name
!= NULL
1780 && each
->addr
== addr
1781 && (!each
->sec
|| each
->sec
== sec
)
1782 && strcmp (name
, each
->name
) == 0)
1788 *filename_ptr
= each
->file
;
1789 *linenumber_ptr
= each
->line
;
1797 find_abstract_instance_name (struct comp_unit
*unit
,
1798 struct attribute
*attr_ptr
)
1800 bfd
*abfd
= unit
->abfd
;
1802 unsigned int abbrev_number
, bytes_read
, i
;
1803 struct abbrev_info
*abbrev
;
1804 bfd_uint64_t die_ref
= attr_ptr
->u
.val
;
1805 struct attribute attr
;
1808 /* DW_FORM_ref_addr can reference an entry in a different CU. It
1809 is an offset from the .debug_info section, not the current CU. */
1810 if (attr_ptr
->form
== DW_FORM_ref_addr
)
1812 /* We only support DW_FORM_ref_addr within the same file, so
1813 any relocations should be resolved already. */
1817 info_ptr
= unit
->sec_info_ptr
+ die_ref
;
1820 info_ptr
= unit
->info_ptr_unit
+ die_ref
;
1821 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
1822 info_ptr
+= bytes_read
;
1826 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
1829 (*_bfd_error_handler
) (_("Dwarf Error: Could not find abbrev number %u."),
1831 bfd_set_error (bfd_error_bad_value
);
1835 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
1837 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
);
1841 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
1845 case DW_AT_specification
:
1846 name
= find_abstract_instance_name (unit
, &attr
);
1848 case DW_AT_MIPS_linkage_name
:
1861 read_rangelist (struct comp_unit
*unit
, struct arange
*arange
, bfd_uint64_t offset
)
1863 bfd_byte
*ranges_ptr
;
1864 bfd_vma base_address
= unit
->base_address
;
1866 if (! unit
->stash
->dwarf_ranges_buffer
)
1868 if (! read_debug_ranges (unit
))
1871 ranges_ptr
= unit
->stash
->dwarf_ranges_buffer
+ offset
;
1878 low_pc
= read_address (unit
, ranges_ptr
);
1879 ranges_ptr
+= unit
->addr_size
;
1880 high_pc
= read_address (unit
, ranges_ptr
);
1881 ranges_ptr
+= unit
->addr_size
;
1883 if (low_pc
== 0 && high_pc
== 0)
1885 if (low_pc
== -1UL && high_pc
!= -1UL)
1886 base_address
= high_pc
;
1888 arange_add (unit
->abfd
, arange
, base_address
+ low_pc
, base_address
+ high_pc
);
1892 /* DWARF2 Compilation unit functions. */
1894 /* Scan over each die in a comp. unit looking for functions to add
1895 to the function table and variables to the variable table. */
1898 scan_unit_for_symbols (struct comp_unit
*unit
)
1900 bfd
*abfd
= unit
->abfd
;
1901 bfd_byte
*info_ptr
= unit
->first_child_die_ptr
;
1902 int nesting_level
= 1;
1903 struct funcinfo
**nested_funcs
;
1904 int nested_funcs_size
;
1906 /* Maintain a stack of in-scope functions and inlined functions, which we
1907 can use to set the caller_func field. */
1908 nested_funcs_size
= 32;
1909 nested_funcs
= (struct funcinfo
**)
1910 bfd_malloc (nested_funcs_size
* sizeof (struct funcinfo
*));
1911 if (nested_funcs
== NULL
)
1913 nested_funcs
[nesting_level
] = 0;
1915 while (nesting_level
)
1917 unsigned int abbrev_number
, bytes_read
, i
;
1918 struct abbrev_info
*abbrev
;
1919 struct attribute attr
;
1920 struct funcinfo
*func
;
1921 struct varinfo
*var
;
1923 bfd_vma high_pc
= 0;
1925 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
1926 info_ptr
+= bytes_read
;
1928 if (! abbrev_number
)
1934 abbrev
= lookup_abbrev (abbrev_number
,unit
->abbrevs
);
1937 (*_bfd_error_handler
) (_("Dwarf Error: Could not find abbrev number %u."),
1939 bfd_set_error (bfd_error_bad_value
);
1940 free (nested_funcs
);
1945 if (abbrev
->tag
== DW_TAG_subprogram
1946 || abbrev
->tag
== DW_TAG_entry_point
1947 || abbrev
->tag
== DW_TAG_inlined_subroutine
)
1949 bfd_size_type amt
= sizeof (struct funcinfo
);
1950 func
= (struct funcinfo
*) bfd_zalloc (abfd
, amt
);
1951 func
->tag
= abbrev
->tag
;
1952 func
->prev_func
= unit
->function_table
;
1953 unit
->function_table
= func
;
1954 BFD_ASSERT (!unit
->cached
);
1956 if (func
->tag
== DW_TAG_inlined_subroutine
)
1957 for (i
= nesting_level
- 1; i
>= 1; i
--)
1958 if (nested_funcs
[i
])
1960 func
->caller_func
= nested_funcs
[i
];
1963 nested_funcs
[nesting_level
] = func
;
1968 if (abbrev
->tag
== DW_TAG_variable
)
1970 bfd_size_type amt
= sizeof (struct varinfo
);
1971 var
= (struct varinfo
*) bfd_zalloc (abfd
, amt
);
1972 var
->tag
= abbrev
->tag
;
1974 var
->prev_var
= unit
->variable_table
;
1975 unit
->variable_table
= var
;
1976 BFD_ASSERT (!unit
->cached
);
1979 /* No inline function in scope at this nesting level. */
1980 nested_funcs
[nesting_level
] = 0;
1983 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
1985 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
);
1991 case DW_AT_call_file
:
1992 func
->caller_file
= concat_filename (unit
->line_table
, attr
.u
.val
);
1995 case DW_AT_call_line
:
1996 func
->caller_line
= attr
.u
.val
;
1999 case DW_AT_abstract_origin
:
2000 func
->name
= find_abstract_instance_name (unit
, &attr
);
2004 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
2005 if (func
->name
== NULL
)
2006 func
->name
= attr
.u
.str
;
2009 case DW_AT_MIPS_linkage_name
:
2010 func
->name
= attr
.u
.str
;
2014 low_pc
= attr
.u
.val
;
2018 high_pc
= attr
.u
.val
;
2022 read_rangelist (unit
, &func
->arange
, attr
.u
.val
);
2025 case DW_AT_decl_file
:
2026 func
->file
= concat_filename (unit
->line_table
,
2030 case DW_AT_decl_line
:
2031 func
->line
= attr
.u
.val
;
2043 var
->name
= attr
.u
.str
;
2046 case DW_AT_decl_file
:
2047 var
->file
= concat_filename (unit
->line_table
,
2051 case DW_AT_decl_line
:
2052 var
->line
= attr
.u
.val
;
2055 case DW_AT_external
:
2056 if (attr
.u
.val
!= 0)
2060 case DW_AT_location
:
2064 case DW_FORM_block1
:
2065 case DW_FORM_block2
:
2066 case DW_FORM_block4
:
2067 if (*attr
.u
.blk
->data
== DW_OP_addr
)
2071 /* Verify that DW_OP_addr is the only opcode in the
2072 location, in which case the block size will be 1
2073 plus the address size. */
2074 /* ??? For TLS variables, gcc can emit
2075 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
2076 which we don't handle here yet. */
2077 if (attr
.u
.blk
->size
== unit
->addr_size
+ 1U)
2078 var
->addr
= bfd_get (unit
->addr_size
* 8,
2080 attr
.u
.blk
->data
+ 1);
2095 if (func
&& high_pc
!= 0)
2097 arange_add (unit
->abfd
, &func
->arange
, low_pc
, high_pc
);
2100 if (abbrev
->has_children
)
2104 if (nesting_level
>= nested_funcs_size
)
2106 struct funcinfo
**tmp
;
2108 nested_funcs_size
*= 2;
2109 tmp
= (struct funcinfo
**)
2110 bfd_realloc (nested_funcs
,
2111 (nested_funcs_size
* sizeof (struct funcinfo
*)));
2114 free (nested_funcs
);
2119 nested_funcs
[nesting_level
] = 0;
2123 free (nested_funcs
);
2127 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
2128 includes the compilation unit header that proceeds the DIE's, but
2129 does not include the length field that precedes each compilation
2130 unit header. END_PTR points one past the end of this comp unit.
2131 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
2133 This routine does not read the whole compilation unit; only enough
2134 to get to the line number information for the compilation unit. */
2136 static struct comp_unit
*
2137 parse_comp_unit (struct dwarf2_debug
*stash
,
2138 bfd_vma unit_length
,
2139 bfd_byte
*info_ptr_unit
,
2140 unsigned int offset_size
)
2142 struct comp_unit
* unit
;
2143 unsigned int version
;
2144 bfd_uint64_t abbrev_offset
= 0;
2145 unsigned int addr_size
;
2146 struct abbrev_info
** abbrevs
;
2147 unsigned int abbrev_number
, bytes_read
, i
;
2148 struct abbrev_info
*abbrev
;
2149 struct attribute attr
;
2150 bfd_byte
*info_ptr
= stash
->info_ptr
;
2151 bfd_byte
*end_ptr
= info_ptr
+ unit_length
;
2154 bfd_vma high_pc
= 0;
2155 bfd
*abfd
= stash
->bfd_ptr
;
2157 version
= read_2_bytes (abfd
, info_ptr
);
2159 BFD_ASSERT (offset_size
== 4 || offset_size
== 8);
2160 if (offset_size
== 4)
2161 abbrev_offset
= read_4_bytes (abfd
, info_ptr
);
2163 abbrev_offset
= read_8_bytes (abfd
, info_ptr
);
2164 info_ptr
+= offset_size
;
2165 addr_size
= read_1_byte (abfd
, info_ptr
);
2168 if (version
!= 2 && version
!= 3)
2170 (*_bfd_error_handler
) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 and 3 information."), version
);
2171 bfd_set_error (bfd_error_bad_value
);
2175 if (addr_size
> sizeof (bfd_vma
))
2177 (*_bfd_error_handler
) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
2179 (unsigned int) sizeof (bfd_vma
));
2180 bfd_set_error (bfd_error_bad_value
);
2184 if (addr_size
!= 2 && addr_size
!= 4 && addr_size
!= 8)
2186 (*_bfd_error_handler
) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size
);
2187 bfd_set_error (bfd_error_bad_value
);
2191 /* Read the abbrevs for this compilation unit into a table. */
2192 abbrevs
= read_abbrevs (abfd
, abbrev_offset
, stash
);
2196 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2197 info_ptr
+= bytes_read
;
2198 if (! abbrev_number
)
2200 (*_bfd_error_handler
) (_("Dwarf Error: Bad abbrev number: %u."),
2202 bfd_set_error (bfd_error_bad_value
);
2206 abbrev
= lookup_abbrev (abbrev_number
, abbrevs
);
2209 (*_bfd_error_handler
) (_("Dwarf Error: Could not find abbrev number %u."),
2211 bfd_set_error (bfd_error_bad_value
);
2215 amt
= sizeof (struct comp_unit
);
2216 unit
= (struct comp_unit
*) bfd_zalloc (abfd
, amt
);
2218 unit
->version
= version
;
2219 unit
->addr_size
= addr_size
;
2220 unit
->offset_size
= offset_size
;
2221 unit
->abbrevs
= abbrevs
;
2222 unit
->end_ptr
= end_ptr
;
2223 unit
->stash
= stash
;
2224 unit
->info_ptr_unit
= info_ptr_unit
;
2225 unit
->sec_info_ptr
= stash
->sec_info_ptr
;
2227 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
2229 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
);
2231 /* Store the data if it is of an attribute we want to keep in a
2232 partial symbol table. */
2235 case DW_AT_stmt_list
:
2237 unit
->line_offset
= attr
.u
.val
;
2241 unit
->name
= attr
.u
.str
;
2245 low_pc
= attr
.u
.val
;
2246 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
2247 this is the base address to use when reading location
2248 lists or range lists. */
2249 unit
->base_address
= low_pc
;
2253 high_pc
= attr
.u
.val
;
2257 read_rangelist (unit
, &unit
->arange
, attr
.u
.val
);
2260 case DW_AT_comp_dir
:
2262 char *comp_dir
= attr
.u
.str
;
2265 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2266 directory, get rid of it. */
2267 char *cp
= strchr (comp_dir
, ':');
2269 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2272 unit
->comp_dir
= comp_dir
;
2282 arange_add (unit
->abfd
, &unit
->arange
, low_pc
, high_pc
);
2285 unit
->first_child_die_ptr
= info_ptr
;
2289 /* Return TRUE if UNIT may contain the address given by ADDR. When
2290 there are functions written entirely with inline asm statements, the
2291 range info in the compilation unit header may not be correct. We
2292 need to consult the line info table to see if a compilation unit
2293 really contains the given address. */
2296 comp_unit_contains_address (struct comp_unit
*unit
, bfd_vma addr
)
2298 struct arange
*arange
;
2303 arange
= &unit
->arange
;
2306 if (addr
>= arange
->low
&& addr
< arange
->high
)
2308 arange
= arange
->next
;
2315 /* If UNIT contains ADDR, set the output parameters to the values for
2316 the line containing ADDR. The output parameters, FILENAME_PTR,
2317 FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
2320 Return TRUE if UNIT contains ADDR, and no errors were encountered;
2324 comp_unit_find_nearest_line (struct comp_unit
*unit
,
2326 const char **filename_ptr
,
2327 const char **functionname_ptr
,
2328 unsigned int *linenumber_ptr
,
2329 struct dwarf2_debug
*stash
)
2333 struct funcinfo
*function
;
2338 if (! unit
->line_table
)
2340 if (! unit
->stmtlist
)
2346 unit
->line_table
= decode_line_info (unit
, stash
);
2348 if (! unit
->line_table
)
2354 if (unit
->first_child_die_ptr
< unit
->end_ptr
2355 && ! scan_unit_for_symbols (unit
))
2363 func_p
= lookup_address_in_function_table (unit
, addr
,
2364 &function
, functionname_ptr
);
2365 if (func_p
&& (function
->tag
== DW_TAG_inlined_subroutine
))
2366 stash
->inliner_chain
= function
;
2367 line_p
= lookup_address_in_line_info_table (unit
->line_table
, addr
,
2370 return line_p
|| func_p
;
2373 /* Check to see if line info is already decoded in a comp_unit.
2374 If not, decode it. Returns TRUE if no errors were encountered;
2378 comp_unit_maybe_decode_line_info (struct comp_unit
*unit
,
2379 struct dwarf2_debug
*stash
)
2384 if (! unit
->line_table
)
2386 if (! unit
->stmtlist
)
2392 unit
->line_table
= decode_line_info (unit
, stash
);
2394 if (! unit
->line_table
)
2400 if (unit
->first_child_die_ptr
< unit
->end_ptr
2401 && ! scan_unit_for_symbols (unit
))
2411 /* If UNIT contains SYM at ADDR, set the output parameters to the
2412 values for the line containing SYM. The output parameters,
2413 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
2416 Return TRUE if UNIT contains SYM, and no errors were encountered;
2420 comp_unit_find_line (struct comp_unit
*unit
,
2423 const char **filename_ptr
,
2424 unsigned int *linenumber_ptr
,
2425 struct dwarf2_debug
*stash
)
2427 if (!comp_unit_maybe_decode_line_info (unit
, stash
))
2430 if (sym
->flags
& BSF_FUNCTION
)
2431 return lookup_symbol_in_function_table (unit
, sym
, addr
,
2435 return lookup_symbol_in_variable_table (unit
, sym
, addr
,
2440 static struct funcinfo
*
2441 reverse_funcinfo_list (struct funcinfo
*head
)
2443 struct funcinfo
*rhead
;
2444 struct funcinfo
*temp
;
2446 for (rhead
= NULL
; head
; head
= temp
)
2448 temp
= head
->prev_func
;
2449 head
->prev_func
= rhead
;
2455 static struct varinfo
*
2456 reverse_varinfo_list (struct varinfo
*head
)
2458 struct varinfo
*rhead
;
2459 struct varinfo
*temp
;
2461 for (rhead
= NULL
; head
; head
= temp
)
2463 temp
= head
->prev_var
;
2464 head
->prev_var
= rhead
;
2470 /* Extract all interesting funcinfos and varinfos of a compilation
2471 unit into hash tables for faster lookup. Returns TRUE if no
2472 errors were enountered; FALSE otherwise. */
2475 comp_unit_hash_info (struct dwarf2_debug
*stash
,
2476 struct comp_unit
*unit
,
2477 struct info_hash_table
*funcinfo_hash_table
,
2478 struct info_hash_table
*varinfo_hash_table
)
2480 struct funcinfo
* each_func
;
2481 struct varinfo
* each_var
;
2482 bfd_boolean okay
= TRUE
;
2484 BFD_ASSERT (stash
->info_hash_status
!= STASH_INFO_HASH_DISABLED
);
2486 if (!comp_unit_maybe_decode_line_info (unit
, stash
))
2489 BFD_ASSERT (!unit
->cached
);
2491 /* To preserve the original search order, we went to visit the function
2492 infos in the reversed order of the list. However, making the list
2493 bi-directional use quite a bit of extra memory. So we reverse
2494 the list first, traverse the list in the now reversed order and
2495 finally reverse the list again to get back the original order. */
2496 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
2497 for (each_func
= unit
->function_table
;
2499 each_func
= each_func
->prev_func
)
2501 /* Skip nameless functions. */
2502 if (each_func
->name
)
2503 /* There is no need to copy name string into hash table as
2504 name string is either in the dwarf string buffer or
2505 info in the stash. */
2506 okay
= insert_info_hash_table (funcinfo_hash_table
, each_func
->name
,
2507 (void*) each_func
, FALSE
);
2509 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
2513 /* We do the same for variable infos. */
2514 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
2515 for (each_var
= unit
->variable_table
;
2517 each_var
= each_var
->prev_var
)
2519 /* Skip stack vars and vars with no files or names. */
2520 if (each_var
->stack
== 0
2521 && each_var
->file
!= NULL
2522 && each_var
->name
!= NULL
)
2523 /* There is no need to copy name string into hash table as
2524 name string is either in the dwarf string buffer or
2525 info in the stash. */
2526 okay
= insert_info_hash_table (varinfo_hash_table
, each_var
->name
,
2527 (void*) each_var
, FALSE
);
2530 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
2531 unit
->cached
= TRUE
;
2535 /* Locate a section in a BFD containing debugging info. The search starts
2536 from the section after AFTER_SEC, or from the first section in the BFD if
2537 AFTER_SEC is NULL. The search works by examining the names of the
2538 sections. There are two permissiable names. The first is .debug_info.
2539 This is the standard DWARF2 name. The second is a prefix .gnu.linkonce.wi.
2540 This is a variation on the .debug_info section which has a checksum
2541 describing the contents appended onto the name. This allows the linker to
2542 identify and discard duplicate debugging sections for different
2543 compilation units. */
2544 #define DWARF2_DEBUG_INFO ".debug_info"
2545 #define DWARF2_COMPRESSED_DEBUG_INFO ".zdebug_info"
2546 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
2549 find_debug_info (bfd
*abfd
, asection
*after_sec
)
2553 msec
= after_sec
!= NULL
? after_sec
->next
: abfd
->sections
;
2557 if (strcmp (msec
->name
, DWARF2_DEBUG_INFO
) == 0)
2560 if (strcmp (msec
->name
, DWARF2_COMPRESSED_DEBUG_INFO
) == 0)
2563 if (CONST_STRNEQ (msec
->name
, GNU_LINKONCE_INFO
))
2572 /* Unset vmas for adjusted sections in STASH. */
2575 unset_sections (struct dwarf2_debug
*stash
)
2578 struct adjusted_section
*p
;
2580 i
= stash
->adjusted_section_count
;
2581 p
= stash
->adjusted_sections
;
2582 for (; i
> 0; i
--, p
++)
2583 p
->section
->vma
= 0;
2586 /* Set unique VMAs for loadable and DWARF sections in ABFD and save
2587 VMAs in STASH for unset_sections. */
2590 place_sections (bfd
*abfd
, struct dwarf2_debug
*stash
)
2592 struct adjusted_section
*p
;
2595 if (stash
->adjusted_section_count
!= 0)
2597 i
= stash
->adjusted_section_count
;
2598 p
= stash
->adjusted_sections
;
2599 for (; i
> 0; i
--, p
++)
2600 p
->section
->vma
= p
->adj_vma
;
2605 bfd_vma last_vma
= 0, last_dwarf
= 0;
2609 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
2617 /* We need to adjust the VMAs of any .debug_info sections.
2618 Skip compressed ones, since no relocations could target
2619 them - they should not appear in object files anyway. */
2620 if (strcmp (sect
->name
, DWARF2_DEBUG_INFO
) == 0)
2622 else if (CONST_STRNEQ (sect
->name
, GNU_LINKONCE_INFO
))
2627 if (!is_debug_info
&& (sect
->flags
& SEC_LOAD
) == 0)
2630 sz
= sect
->rawsize
? sect
->rawsize
: sect
->size
;
2637 amt
= i
* sizeof (struct adjusted_section
);
2638 p
= (struct adjusted_section
*) bfd_zalloc (abfd
, amt
);
2642 stash
->adjusted_sections
= p
;
2643 stash
->adjusted_section_count
= i
;
2645 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
2653 /* We need to adjust the VMAs of any .debug_info sections.
2654 Skip compressed ones, since no relocations could target
2655 them - they should not appear in object files anyway. */
2656 if (strcmp (sect
->name
, DWARF2_DEBUG_INFO
) == 0)
2658 else if (CONST_STRNEQ (sect
->name
, GNU_LINKONCE_INFO
))
2663 if (!is_debug_info
&& (sect
->flags
& SEC_LOAD
) == 0)
2666 sz
= sect
->rawsize
? sect
->rawsize
: sect
->size
;
2673 BFD_ASSERT (sect
->alignment_power
== 0);
2674 sect
->vma
= last_dwarf
;
2677 else if (last_vma
!= 0)
2679 /* Align the new address to the current section
2681 last_vma
= ((last_vma
2682 + ~((bfd_vma
) -1 << sect
->alignment_power
))
2683 & ((bfd_vma
) -1 << sect
->alignment_power
));
2684 sect
->vma
= last_vma
;
2685 last_vma
+= sect
->vma
+ sz
;
2688 last_vma
+= sect
->vma
+ sz
;
2690 p
->adj_vma
= sect
->vma
;
2699 /* Look up a funcinfo by name using the given info hash table. If found,
2700 also update the locations pointed to by filename_ptr and linenumber_ptr.
2702 This function returns TRUE if a funcinfo that matches the given symbol
2703 and address is found with any error; otherwise it returns FALSE. */
2706 info_hash_lookup_funcinfo (struct info_hash_table
*hash_table
,
2709 const char **filename_ptr
,
2710 unsigned int *linenumber_ptr
)
2712 struct funcinfo
* each_func
;
2713 struct funcinfo
* best_fit
= NULL
;
2714 struct info_list_node
*node
;
2715 struct arange
*arange
;
2716 const char *name
= bfd_asymbol_name (sym
);
2717 asection
*sec
= bfd_get_section (sym
);
2719 for (node
= lookup_info_hash_table (hash_table
, name
);
2723 each_func
= (struct funcinfo
*) node
->info
;
2724 for (arange
= &each_func
->arange
;
2726 arange
= arange
->next
)
2728 if ((!each_func
->sec
|| each_func
->sec
== sec
)
2729 && addr
>= arange
->low
2730 && addr
< arange
->high
2732 || ((arange
->high
- arange
->low
)
2733 < (best_fit
->arange
.high
- best_fit
->arange
.low
))))
2734 best_fit
= each_func
;
2740 best_fit
->sec
= sec
;
2741 *filename_ptr
= best_fit
->file
;
2742 *linenumber_ptr
= best_fit
->line
;
2749 /* Look up a varinfo by name using the given info hash table. If found,
2750 also update the locations pointed to by filename_ptr and linenumber_ptr.
2752 This function returns TRUE if a varinfo that matches the given symbol
2753 and address is found with any error; otherwise it returns FALSE. */
2756 info_hash_lookup_varinfo (struct info_hash_table
*hash_table
,
2759 const char **filename_ptr
,
2760 unsigned int *linenumber_ptr
)
2762 const char *name
= bfd_asymbol_name (sym
);
2763 asection
*sec
= bfd_get_section (sym
);
2764 struct varinfo
* each
;
2765 struct info_list_node
*node
;
2767 for (node
= lookup_info_hash_table (hash_table
, name
);
2771 each
= (struct varinfo
*) node
->info
;
2772 if (each
->addr
== addr
2773 && (!each
->sec
|| each
->sec
== sec
))
2776 *filename_ptr
= each
->file
;
2777 *linenumber_ptr
= each
->line
;
2785 /* Update the funcinfo and varinfo info hash tables if they are
2786 not up to date. Returns TRUE if there is no error; otherwise
2787 returns FALSE and disable the info hash tables. */
2790 stash_maybe_update_info_hash_tables (struct dwarf2_debug
*stash
)
2792 struct comp_unit
*each
;
2794 /* Exit if hash tables are up-to-date. */
2795 if (stash
->all_comp_units
== stash
->hash_units_head
)
2798 if (stash
->hash_units_head
)
2799 each
= stash
->hash_units_head
->prev_unit
;
2801 each
= stash
->last_comp_unit
;
2805 if (!comp_unit_hash_info (stash
, each
, stash
->funcinfo_hash_table
,
2806 stash
->varinfo_hash_table
))
2808 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
2811 each
= each
->prev_unit
;
2814 stash
->hash_units_head
= stash
->all_comp_units
;
2818 /* Check consistency of info hash tables. This is for debugging only. */
2820 static void ATTRIBUTE_UNUSED
2821 stash_verify_info_hash_table (struct dwarf2_debug
*stash
)
2823 struct comp_unit
*each_unit
;
2824 struct funcinfo
*each_func
;
2825 struct varinfo
*each_var
;
2826 struct info_list_node
*node
;
2829 for (each_unit
= stash
->all_comp_units
;
2831 each_unit
= each_unit
->next_unit
)
2833 for (each_func
= each_unit
->function_table
;
2835 each_func
= each_func
->prev_func
)
2837 if (!each_func
->name
)
2839 node
= lookup_info_hash_table (stash
->funcinfo_hash_table
,
2843 while (node
&& !found
)
2845 found
= node
->info
== each_func
;
2851 for (each_var
= each_unit
->variable_table
;
2853 each_var
= each_var
->prev_var
)
2855 if (!each_var
->name
|| !each_var
->file
|| each_var
->stack
)
2857 node
= lookup_info_hash_table (stash
->varinfo_hash_table
,
2861 while (node
&& !found
)
2863 found
= node
->info
== each_var
;
2871 /* Check to see if we want to enable the info hash tables, which consume
2872 quite a bit of memory. Currently we only check the number times
2873 bfd_dwarf2_find_line is called. In the future, we may also want to
2874 take the number of symbols into account. */
2877 stash_maybe_enable_info_hash_tables (bfd
*abfd
, struct dwarf2_debug
*stash
)
2879 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_OFF
);
2881 if (stash
->info_hash_count
++ < STASH_INFO_HASH_TRIGGER
)
2884 /* FIXME: Maybe we should check the reduce_memory_overheads
2885 and optimize fields in the bfd_link_info structure ? */
2887 /* Create hash tables. */
2888 stash
->funcinfo_hash_table
= create_info_hash_table (abfd
);
2889 stash
->varinfo_hash_table
= create_info_hash_table (abfd
);
2890 if (!stash
->funcinfo_hash_table
|| !stash
->varinfo_hash_table
)
2892 /* Turn off info hashes if any allocation above fails. */
2893 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
2896 /* We need a forced update so that the info hash tables will
2897 be created even though there is no compilation unit. That
2898 happens if STASH_INFO_HASH_TRIGGER is 0. */
2899 stash_maybe_update_info_hash_tables (stash
);
2900 stash
->info_hash_status
= STASH_INFO_HASH_ON
;
2903 /* Find the file and line associated with a symbol and address using the
2904 info hash tables of a stash. If there is a match, the function returns
2905 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
2906 otherwise it returns FALSE. */
2909 stash_find_line_fast (struct dwarf2_debug
*stash
,
2912 const char **filename_ptr
,
2913 unsigned int *linenumber_ptr
)
2915 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_ON
);
2917 if (sym
->flags
& BSF_FUNCTION
)
2918 return info_hash_lookup_funcinfo (stash
->funcinfo_hash_table
, sym
, addr
,
2919 filename_ptr
, linenumber_ptr
);
2920 return info_hash_lookup_varinfo (stash
->varinfo_hash_table
, sym
, addr
,
2921 filename_ptr
, linenumber_ptr
);
2924 /* Find the source code location of SYMBOL. If SYMBOL is NULL
2925 then find the nearest source code location corresponding to
2926 the address SECTION + OFFSET.
2927 Returns TRUE if the line is found without error and fills in
2928 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
2929 NULL the FUNCTIONNAME_PTR is also filled in.
2930 SYMBOLS contains the symbol table for ABFD.
2931 ADDR_SIZE is the number of bytes in the initial .debug_info length
2932 field and in the abbreviation offset, or zero to indicate that the
2933 default value should be used. */
2936 find_line (bfd
*abfd
,
2941 const char **filename_ptr
,
2942 const char **functionname_ptr
,
2943 unsigned int *linenumber_ptr
,
2944 unsigned int addr_size
,
2947 /* Read each compilation unit from the section .debug_info, and check
2948 to see if it contains the address we are searching for. If yes,
2949 lookup the address, and return the line number info. If no, go
2950 on to the next compilation unit.
2952 We keep a list of all the previously read compilation units, and
2953 a pointer to the next un-read compilation unit. Check the
2954 previously read units before reading more. */
2955 struct dwarf2_debug
*stash
;
2956 /* What address are we looking for? */
2958 struct comp_unit
* each
;
2959 bfd_vma found
= FALSE
;
2960 bfd_boolean do_line
;
2962 stash
= (struct dwarf2_debug
*) *pinfo
;
2966 bfd_size_type amt
= sizeof (struct dwarf2_debug
);
2968 stash
= (struct dwarf2_debug
*) bfd_zalloc (abfd
, amt
);
2973 /* In a relocatable file, 2 functions may have the same address.
2974 We change the section vma so that they won't overlap. */
2975 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2977 if (! place_sections (abfd
, stash
))
2981 do_line
= (section
== NULL
2983 && functionname_ptr
== NULL
2987 addr
= symbol
->value
;
2988 section
= bfd_get_section (symbol
);
2990 else if (section
!= NULL
2991 && functionname_ptr
!= NULL
2997 if (section
->output_section
)
2998 addr
+= section
->output_section
->vma
+ section
->output_offset
;
3000 addr
+= section
->vma
;
3001 *filename_ptr
= NULL
;
3003 *functionname_ptr
= NULL
;
3004 *linenumber_ptr
= 0;
3009 bfd_size_type total_size
;
3014 msec
= find_debug_info (abfd
, NULL
);
3017 char * debug_filename
= bfd_follow_gnu_debuglink (abfd
, DEBUGDIR
);
3019 if (debug_filename
== NULL
)
3020 /* No dwarf2 info, and no gnu_debuglink to follow.
3021 Note that at this point the stash has been allocated, but
3022 contains zeros. This lets future calls to this function
3023 fail more quickly. */
3026 if ((debug_bfd
= bfd_openr (debug_filename
, NULL
)) == NULL
3027 || ! bfd_check_format (debug_bfd
, bfd_object
)
3028 || (msec
= find_debug_info (debug_bfd
, NULL
)) == NULL
)
3031 bfd_close (debug_bfd
);
3032 /* FIXME: Should we report our failure to follow the debuglink ? */
3033 free (debug_filename
);
3040 /* There can be more than one DWARF2 info section in a BFD these
3041 days. First handle the easy case when there's only one. If
3042 there's more than one, try case two: none of the sections is
3043 compressed. In that case, read them all in and produce one
3044 large stash. We do this in two passes - in the first pass we
3045 just accumulate the section sizes, and in the second pass we
3046 read in the section's contents. (The allows us to avoid
3047 reallocing the data as we add sections to the stash.) If
3048 some or all sections are compressed, then do things the slow
3049 way, with a bunch of reallocs. */
3051 if (! find_debug_info (debug_bfd
, msec
))
3053 /* Case 1: only one info section. */
3054 total_size
= msec
->size
;
3055 if (! read_section (debug_bfd
, ".debug_info", ".zdebug_info",
3057 &stash
->info_ptr_memory
, &total_size
))
3062 int all_uncompressed
= 1;
3063 for (total_size
= 0; msec
; msec
= find_debug_info (debug_bfd
, msec
))
3065 total_size
+= msec
->size
;
3066 if (strcmp (msec
->name
, DWARF2_COMPRESSED_DEBUG_INFO
) == 0)
3067 all_uncompressed
= 0;
3069 if (all_uncompressed
)
3071 /* Case 2: multiple sections, but none is compressed. */
3072 stash
->info_ptr_memory
= (bfd_byte
*) bfd_malloc (total_size
);
3073 if (stash
->info_ptr_memory
== NULL
)
3077 for (msec
= find_debug_info (debug_bfd
, NULL
);
3079 msec
= find_debug_info (debug_bfd
, msec
))
3087 if (!(bfd_simple_get_relocated_section_contents
3088 (debug_bfd
, msec
, stash
->info_ptr_memory
+ total_size
,
3097 /* Case 3: multiple sections, some or all compressed. */
3098 stash
->info_ptr_memory
= NULL
;
3100 for (msec
= find_debug_info (debug_bfd
, NULL
);
3102 msec
= find_debug_info (debug_bfd
, msec
))
3104 bfd_size_type size
= msec
->size
;
3110 buffer
= (bfd_simple_get_relocated_section_contents
3111 (debug_bfd
, msec
, NULL
, symbols
));
3115 if (strcmp (msec
->name
, DWARF2_COMPRESSED_DEBUG_INFO
) == 0)
3117 if (! bfd_uncompress_section_contents (&buffer
, &size
))
3123 stash
->info_ptr_memory
= (bfd_byte
*)
3124 bfd_realloc (stash
->info_ptr_memory
, total_size
+ size
);
3125 memcpy (stash
->info_ptr_memory
+ total_size
, buffer
, size
);
3132 stash
->info_ptr
= stash
->info_ptr_memory
;
3133 stash
->info_ptr_end
= stash
->info_ptr
+ total_size
;
3134 stash
->sec
= find_debug_info (debug_bfd
, NULL
);
3135 stash
->sec_info_ptr
= stash
->info_ptr
;
3136 stash
->syms
= symbols
;
3137 stash
->bfd_ptr
= debug_bfd
;
3140 /* A null info_ptr indicates that there is no dwarf2 info
3141 (or that an error occured while setting up the stash). */
3142 if (! stash
->info_ptr
)
3145 stash
->inliner_chain
= NULL
;
3147 /* Check the previously read comp. units first. */
3150 /* The info hash tables use quite a bit of memory. We may not want to
3151 always use them. We use some heuristics to decide if and when to
3153 if (stash
->info_hash_status
== STASH_INFO_HASH_OFF
)
3154 stash_maybe_enable_info_hash_tables (abfd
, stash
);
3156 /* Keep info hash table up to date if they are available. Note that we
3157 may disable the hash tables if there is any error duing update. */
3158 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
3159 stash_maybe_update_info_hash_tables (stash
);
3161 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
3163 found
= stash_find_line_fast (stash
, symbol
, addr
, filename_ptr
,
3170 /* Check the previously read comp. units first. */
3171 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
3172 if ((symbol
->flags
& BSF_FUNCTION
) == 0
3173 || comp_unit_contains_address (each
, addr
))
3175 found
= comp_unit_find_line (each
, symbol
, addr
, filename_ptr
,
3176 linenumber_ptr
, stash
);
3184 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
3186 found
= (comp_unit_contains_address (each
, addr
)
3187 && comp_unit_find_nearest_line (each
, addr
,
3197 /* The DWARF2 spec says that the initial length field, and the
3198 offset of the abbreviation table, should both be 4-byte values.
3199 However, some compilers do things differently. */
3202 BFD_ASSERT (addr_size
== 4 || addr_size
== 8);
3204 /* Read each remaining comp. units checking each as they are read. */
3205 while (stash
->info_ptr
< stash
->info_ptr_end
)
3208 unsigned int offset_size
= addr_size
;
3209 bfd_byte
*info_ptr_unit
= stash
->info_ptr
;
3211 length
= read_4_bytes (stash
->bfd_ptr
, stash
->info_ptr
);
3212 /* A 0xffffff length is the DWARF3 way of indicating
3213 we use 64-bit offsets, instead of 32-bit offsets. */
3214 if (length
== 0xffffffff)
3217 length
= read_8_bytes (stash
->bfd_ptr
, stash
->info_ptr
+ 4);
3218 stash
->info_ptr
+= 12;
3220 /* A zero length is the IRIX way of indicating 64-bit offsets,
3221 mostly because the 64-bit length will generally fit in 32
3222 bits, and the endianness helps. */
3223 else if (length
== 0)
3226 length
= read_4_bytes (stash
->bfd_ptr
, stash
->info_ptr
+ 4);
3227 stash
->info_ptr
+= 8;
3229 /* In the absence of the hints above, we assume 32-bit DWARF2
3230 offsets even for targets with 64-bit addresses, because:
3231 a) most of the time these targets will not have generated
3232 more than 2Gb of debug info and so will not need 64-bit
3235 b) if they do use 64-bit offsets but they are not using
3236 the size hints that are tested for above then they are
3237 not conforming to the DWARF3 standard anyway. */
3238 else if (addr_size
== 8)
3241 stash
->info_ptr
+= 4;
3244 stash
->info_ptr
+= 4;
3248 each
= parse_comp_unit (stash
, length
, info_ptr_unit
,
3251 /* The dwarf information is damaged, don't trust it any
3254 stash
->info_ptr
+= length
;
3256 if (stash
->all_comp_units
)
3257 stash
->all_comp_units
->prev_unit
= each
;
3259 stash
->last_comp_unit
= each
;
3261 each
->next_unit
= stash
->all_comp_units
;
3262 stash
->all_comp_units
= each
;
3264 /* DW_AT_low_pc and DW_AT_high_pc are optional for
3265 compilation units. If we don't have them (i.e.,
3266 unit->high == 0), we need to consult the line info table
3267 to see if a compilation unit contains the given
3270 found
= (((symbol
->flags
& BSF_FUNCTION
) == 0
3271 || each
->arange
.high
== 0
3272 || comp_unit_contains_address (each
, addr
))
3273 && comp_unit_find_line (each
, symbol
, addr
,
3278 found
= ((each
->arange
.high
== 0
3279 || comp_unit_contains_address (each
, addr
))
3280 && comp_unit_find_nearest_line (each
, addr
,
3286 if ((bfd_vma
) (stash
->info_ptr
- stash
->sec_info_ptr
)
3287 == stash
->sec
->size
)
3289 stash
->sec
= find_debug_info (stash
->bfd_ptr
, stash
->sec
);
3290 stash
->sec_info_ptr
= stash
->info_ptr
;
3299 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
3300 unset_sections (stash
);
3305 /* The DWARF2 version of find_nearest_line.
3306 Return TRUE if the line is found without error. */
3309 _bfd_dwarf2_find_nearest_line (bfd
*abfd
,
3313 const char **filename_ptr
,
3314 const char **functionname_ptr
,
3315 unsigned int *linenumber_ptr
,
3316 unsigned int addr_size
,
3319 return find_line (abfd
, section
, offset
, NULL
, symbols
, filename_ptr
,
3320 functionname_ptr
, linenumber_ptr
, addr_size
,
3324 /* The DWARF2 version of find_line.
3325 Return TRUE if the line is found without error. */
3328 _bfd_dwarf2_find_line (bfd
*abfd
,
3331 const char **filename_ptr
,
3332 unsigned int *linenumber_ptr
,
3333 unsigned int addr_size
,
3336 return find_line (abfd
, NULL
, 0, symbol
, symbols
, filename_ptr
,
3337 NULL
, linenumber_ptr
, addr_size
,
3342 _bfd_dwarf2_find_inliner_info (bfd
*abfd ATTRIBUTE_UNUSED
,
3343 const char **filename_ptr
,
3344 const char **functionname_ptr
,
3345 unsigned int *linenumber_ptr
,
3348 struct dwarf2_debug
*stash
;
3350 stash
= (struct dwarf2_debug
*) *pinfo
;
3353 struct funcinfo
*func
= stash
->inliner_chain
;
3355 if (func
&& func
->caller_func
)
3357 *filename_ptr
= func
->caller_file
;
3358 *functionname_ptr
= func
->caller_func
->name
;
3359 *linenumber_ptr
= func
->caller_line
;
3360 stash
->inliner_chain
= func
->caller_func
;
3369 _bfd_dwarf2_cleanup_debug_info (bfd
*abfd
)
3371 struct comp_unit
*each
;
3372 struct dwarf2_debug
*stash
;
3374 if (abfd
== NULL
|| elf_tdata (abfd
) == NULL
)
3377 stash
= (struct dwarf2_debug
*) elf_tdata (abfd
)->dwarf2_find_line_info
;
3382 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
3384 struct abbrev_info
**abbrevs
= each
->abbrevs
;
3385 struct funcinfo
*function_table
= each
->function_table
;
3386 struct varinfo
*variable_table
= each
->variable_table
;
3389 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
3391 struct abbrev_info
*abbrev
= abbrevs
[i
];
3395 free (abbrev
->attrs
);
3396 abbrev
= abbrev
->next
;
3400 if (each
->line_table
)
3402 free (each
->line_table
->dirs
);
3403 free (each
->line_table
->files
);
3406 while (function_table
)
3408 if (function_table
->file
)
3410 free (function_table
->file
);
3411 function_table
->file
= NULL
;
3414 if (function_table
->caller_file
)
3416 free (function_table
->caller_file
);
3417 function_table
->caller_file
= NULL
;
3419 function_table
= function_table
->prev_func
;
3422 while (variable_table
)
3424 if (variable_table
->file
)
3426 free (variable_table
->file
);
3427 variable_table
->file
= NULL
;
3430 variable_table
= variable_table
->prev_var
;
3434 if (stash
->dwarf_abbrev_buffer
)
3435 free (stash
->dwarf_abbrev_buffer
);
3436 if (stash
->dwarf_line_buffer
)
3437 free (stash
->dwarf_line_buffer
);
3438 if (stash
->dwarf_str_buffer
)
3439 free (stash
->dwarf_str_buffer
);
3440 if (stash
->dwarf_ranges_buffer
)
3441 free (stash
->dwarf_ranges_buffer
);
3442 if (stash
->info_ptr_memory
)
3443 free (stash
->info_ptr_memory
);