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
= (struct info_hash_entry
*) bfd_hash_allocate (table
,
325 /* Call the allocation method of the base class. */
326 ret
= ((struct info_hash_entry
*)
327 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
329 /* Initialize the local fields here. */
333 return (struct bfd_hash_entry
*) ret
;
336 /* Function to create a new info hash table. It returns a pointer to the
337 newly created table or NULL if there is any error. We need abfd
338 solely for memory allocation. */
340 static struct info_hash_table
*
341 create_info_hash_table (bfd
*abfd
)
343 struct info_hash_table
*hash_table
;
345 hash_table
= (struct info_hash_table
*)
346 bfd_alloc (abfd
, sizeof (struct info_hash_table
));
350 if (!bfd_hash_table_init (&hash_table
->base
, info_hash_table_newfunc
,
351 sizeof (struct info_hash_entry
)))
353 bfd_release (abfd
, hash_table
);
360 /* Insert an info entry into an info hash table. We do not check of
361 duplicate entries. Also, the caller need to guarantee that the
362 right type of info in inserted as info is passed as a void* pointer.
363 This function returns true if there is no error. */
366 insert_info_hash_table (struct info_hash_table
*hash_table
,
371 struct info_hash_entry
*entry
;
372 struct info_list_node
*node
;
374 entry
= (struct info_hash_entry
*) bfd_hash_lookup (&hash_table
->base
,
379 node
= (struct info_list_node
*) bfd_hash_allocate (&hash_table
->base
,
385 node
->next
= entry
->head
;
391 /* Look up an info entry list from an info hash table. Return NULL
394 static struct info_list_node
*
395 lookup_info_hash_table (struct info_hash_table
*hash_table
, const char *key
)
397 struct info_hash_entry
*entry
;
399 entry
= (struct info_hash_entry
*) bfd_hash_lookup (&hash_table
->base
, key
,
401 return entry
? entry
->head
: NULL
;
404 /* Read a section into its appropriate place in the dwarf2_debug
405 struct (indicated by SECTION_BUFFER and SECTION_SIZE). If SYMS is
406 not NULL, use bfd_simple_get_relocated_section_contents to read the
407 section contents, otherwise use bfd_get_section_contents. Fail if
408 the located section does not contain at least OFFSET bytes. */
411 read_section (bfd
* abfd
,
412 const char * section_name
,
413 const char * compressed_section_name
,
416 bfd_byte
** section_buffer
,
417 bfd_size_type
* section_size
)
420 bfd_boolean section_is_compressed
= FALSE
;
422 /* read_section is a noop if the section has already been read. */
423 if (!*section_buffer
)
425 msec
= bfd_get_section_by_name (abfd
, section_name
);
426 if (! msec
&& compressed_section_name
)
428 msec
= bfd_get_section_by_name (abfd
, compressed_section_name
);
429 section_is_compressed
= TRUE
;
433 (*_bfd_error_handler
) (_("Dwarf Error: Can't find %s section."), section_name
);
434 bfd_set_error (bfd_error_bad_value
);
438 *section_size
= msec
->rawsize
? msec
->rawsize
: msec
->size
;
442 = bfd_simple_get_relocated_section_contents (abfd
, msec
, NULL
, syms
);
443 if (! *section_buffer
)
448 *section_buffer
= (bfd_byte
*) bfd_malloc (*section_size
);
449 if (! *section_buffer
)
451 if (! bfd_get_section_contents (abfd
, msec
, *section_buffer
,
456 if (section_is_compressed
)
458 if (! bfd_uncompress_section_contents (section_buffer
, section_size
))
460 (*_bfd_error_handler
) (_("Dwarf Error: unable to decompress %s section."), compressed_section_name
);
461 bfd_set_error (bfd_error_bad_value
);
467 /* It is possible to get a bad value for the offset into the section
468 that the client wants. Validate it here to avoid trouble later. */
469 if (offset
!= 0 && offset
>= *section_size
)
471 (*_bfd_error_handler
) (_("Dwarf Error: Offset (%lu) greater than or equal to %s size (%lu)."),
472 (long) offset
, section_name
, *section_size
);
473 bfd_set_error (bfd_error_bad_value
);
481 The following function up to the END VERBATIM mark are
482 copied directly from dwarf2read.c. */
484 /* Read dwarf information from a buffer. */
487 read_1_byte (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_byte
*buf
)
489 return bfd_get_8 (abfd
, buf
);
493 read_1_signed_byte (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_byte
*buf
)
495 return bfd_get_signed_8 (abfd
, buf
);
499 read_2_bytes (bfd
*abfd
, bfd_byte
*buf
)
501 return bfd_get_16 (abfd
, buf
);
505 read_4_bytes (bfd
*abfd
, bfd_byte
*buf
)
507 return bfd_get_32 (abfd
, buf
);
511 read_8_bytes (bfd
*abfd
, bfd_byte
*buf
)
513 return bfd_get_64 (abfd
, buf
);
517 read_n_bytes (bfd
*abfd ATTRIBUTE_UNUSED
,
519 unsigned int size ATTRIBUTE_UNUSED
)
525 read_string (bfd
*abfd ATTRIBUTE_UNUSED
,
527 unsigned int *bytes_read_ptr
)
529 /* Return a pointer to the embedded string. */
530 char *str
= (char *) buf
;
538 *bytes_read_ptr
= strlen (str
) + 1;
545 read_indirect_string (struct comp_unit
* unit
,
547 unsigned int * bytes_read_ptr
)
550 struct dwarf2_debug
*stash
= unit
->stash
;
553 if (unit
->offset_size
== 4)
554 offset
= read_4_bytes (unit
->abfd
, buf
);
556 offset
= read_8_bytes (unit
->abfd
, buf
);
558 *bytes_read_ptr
= unit
->offset_size
;
560 if (! read_section (unit
->abfd
, ".debug_str", ".zdebug_str",
562 &stash
->dwarf_str_buffer
, &stash
->dwarf_str_size
))
565 str
= (char *) stash
->dwarf_str_buffer
+ offset
;
572 read_address (struct comp_unit
*unit
, bfd_byte
*buf
)
574 int signed_vma
= get_elf_backend_data (unit
->abfd
)->sign_extend_vma
;
578 switch (unit
->addr_size
)
581 return bfd_get_signed_64 (unit
->abfd
, buf
);
583 return bfd_get_signed_32 (unit
->abfd
, buf
);
585 return bfd_get_signed_16 (unit
->abfd
, buf
);
592 switch (unit
->addr_size
)
595 return bfd_get_64 (unit
->abfd
, buf
);
597 return bfd_get_32 (unit
->abfd
, buf
);
599 return bfd_get_16 (unit
->abfd
, buf
);
606 /* Lookup an abbrev_info structure in the abbrev hash table. */
608 static struct abbrev_info
*
609 lookup_abbrev (unsigned int number
, struct abbrev_info
**abbrevs
)
611 unsigned int hash_number
;
612 struct abbrev_info
*abbrev
;
614 hash_number
= number
% ABBREV_HASH_SIZE
;
615 abbrev
= abbrevs
[hash_number
];
619 if (abbrev
->number
== number
)
622 abbrev
= abbrev
->next
;
628 /* In DWARF version 2, the description of the debugging information is
629 stored in a separate .debug_abbrev section. Before we read any
630 dies from a section we read in all abbreviations and install them
633 static struct abbrev_info
**
634 read_abbrevs (bfd
*abfd
, bfd_uint64_t offset
, struct dwarf2_debug
*stash
)
636 struct abbrev_info
**abbrevs
;
637 bfd_byte
*abbrev_ptr
;
638 struct abbrev_info
*cur_abbrev
;
639 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
640 unsigned int abbrev_form
, hash_number
;
643 if (! read_section (abfd
, ".debug_abbrev", ".zdebug_abbrev",
645 &stash
->dwarf_abbrev_buffer
, &stash
->dwarf_abbrev_size
))
648 amt
= sizeof (struct abbrev_info
*) * ABBREV_HASH_SIZE
;
649 abbrevs
= (struct abbrev_info
**) bfd_zalloc (abfd
, amt
);
651 abbrev_ptr
= stash
->dwarf_abbrev_buffer
+ offset
;
652 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
653 abbrev_ptr
+= bytes_read
;
655 /* Loop until we reach an abbrev number of 0. */
656 while (abbrev_number
)
658 amt
= sizeof (struct abbrev_info
);
659 cur_abbrev
= (struct abbrev_info
*) bfd_zalloc (abfd
, amt
);
661 /* Read in abbrev header. */
662 cur_abbrev
->number
= abbrev_number
;
663 cur_abbrev
->tag
= (enum dwarf_tag
)
664 read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
665 abbrev_ptr
+= bytes_read
;
666 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
669 /* Now read in declarations. */
670 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
671 abbrev_ptr
+= bytes_read
;
672 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
673 abbrev_ptr
+= bytes_read
;
677 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
679 struct attr_abbrev
*tmp
;
681 amt
= cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
;
682 amt
*= sizeof (struct attr_abbrev
);
683 tmp
= (struct attr_abbrev
*) bfd_realloc (cur_abbrev
->attrs
, amt
);
688 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
690 struct abbrev_info
*abbrev
= abbrevs
[i
];
694 free (abbrev
->attrs
);
695 abbrev
= abbrev
->next
;
700 cur_abbrev
->attrs
= tmp
;
703 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
704 = (enum dwarf_attribute
) abbrev_name
;
705 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
706 = (enum dwarf_form
) abbrev_form
;
707 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
708 abbrev_ptr
+= bytes_read
;
709 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
710 abbrev_ptr
+= bytes_read
;
713 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
714 cur_abbrev
->next
= abbrevs
[hash_number
];
715 abbrevs
[hash_number
] = cur_abbrev
;
717 /* Get next abbreviation.
718 Under Irix6 the abbreviations for a compilation unit are not
719 always properly terminated with an abbrev number of 0.
720 Exit loop if we encounter an abbreviation which we have
721 already read (which means we are about to read the abbreviations
722 for the next compile unit) or if the end of the abbreviation
724 if ((unsigned int) (abbrev_ptr
- stash
->dwarf_abbrev_buffer
)
725 >= stash
->dwarf_abbrev_size
)
727 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
728 abbrev_ptr
+= bytes_read
;
729 if (lookup_abbrev (abbrev_number
,abbrevs
) != NULL
)
736 /* Read an attribute value described by an attribute form. */
739 read_attribute_value (struct attribute
*attr
,
741 struct comp_unit
*unit
,
744 bfd
*abfd
= unit
->abfd
;
745 unsigned int bytes_read
;
746 struct dwarf_block
*blk
;
749 attr
->form
= (enum dwarf_form
) form
;
753 case DW_FORM_ref_addr
:
754 /* DW_FORM_ref_addr is an address in DWARF2, and an offset in
756 if (unit
->version
== 3)
758 if (unit
->offset_size
== 4)
759 attr
->u
.val
= read_4_bytes (unit
->abfd
, info_ptr
);
761 attr
->u
.val
= read_8_bytes (unit
->abfd
, info_ptr
);
762 info_ptr
+= unit
->offset_size
;
767 attr
->u
.val
= read_address (unit
, info_ptr
);
768 info_ptr
+= unit
->addr_size
;
771 amt
= sizeof (struct dwarf_block
);
772 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
773 blk
->size
= read_2_bytes (abfd
, info_ptr
);
775 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
776 info_ptr
+= blk
->size
;
780 amt
= sizeof (struct dwarf_block
);
781 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
782 blk
->size
= read_4_bytes (abfd
, info_ptr
);
784 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
785 info_ptr
+= blk
->size
;
789 attr
->u
.val
= read_2_bytes (abfd
, info_ptr
);
793 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
);
797 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
);
801 attr
->u
.str
= read_string (abfd
, info_ptr
, &bytes_read
);
802 info_ptr
+= bytes_read
;
805 attr
->u
.str
= read_indirect_string (unit
, info_ptr
, &bytes_read
);
806 info_ptr
+= bytes_read
;
809 amt
= sizeof (struct dwarf_block
);
810 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
811 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
812 info_ptr
+= bytes_read
;
813 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
814 info_ptr
+= blk
->size
;
818 amt
= sizeof (struct dwarf_block
);
819 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
820 blk
->size
= read_1_byte (abfd
, info_ptr
);
822 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
823 info_ptr
+= blk
->size
;
827 attr
->u
.val
= read_1_byte (abfd
, info_ptr
);
831 attr
->u
.val
= read_1_byte (abfd
, info_ptr
);
835 attr
->u
.sval
= read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
836 info_ptr
+= bytes_read
;
839 attr
->u
.val
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
840 info_ptr
+= bytes_read
;
843 attr
->u
.val
= read_1_byte (abfd
, info_ptr
);
847 attr
->u
.val
= read_2_bytes (abfd
, info_ptr
);
851 attr
->u
.val
= read_4_bytes (abfd
, info_ptr
);
855 attr
->u
.val
= read_8_bytes (abfd
, info_ptr
);
858 case DW_FORM_ref_udata
:
859 attr
->u
.val
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
860 info_ptr
+= bytes_read
;
862 case DW_FORM_indirect
:
863 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
864 info_ptr
+= bytes_read
;
865 info_ptr
= read_attribute_value (attr
, form
, unit
, info_ptr
);
868 (*_bfd_error_handler
) (_("Dwarf Error: Invalid or unhandled FORM value: %u."),
870 bfd_set_error (bfd_error_bad_value
);
875 /* Read an attribute described by an abbreviated attribute. */
878 read_attribute (struct attribute
*attr
,
879 struct attr_abbrev
*abbrev
,
880 struct comp_unit
*unit
,
883 attr
->name
= abbrev
->name
;
884 info_ptr
= read_attribute_value (attr
, abbrev
->form
, unit
, info_ptr
);
888 /* Source line information table routines. */
890 #define FILE_ALLOC_CHUNK 5
891 #define DIR_ALLOC_CHUNK 5
895 struct line_info
* prev_line
;
900 int end_sequence
; /* End of (sequential) code sequence. */
914 struct line_sequence
* prev_sequence
;
915 struct line_info
* last_line
; /* Largest VMA. */
918 struct line_info_table
921 unsigned int num_files
;
922 unsigned int num_dirs
;
923 unsigned int num_sequences
;
926 struct fileinfo
* files
;
927 struct line_sequence
* sequences
;
928 struct line_info
* lcl_head
; /* Local head; used in 'add_line_info'. */
931 /* Remember some information about each function. If the function is
932 inlined (DW_TAG_inlined_subroutine) it may have two additional
933 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
934 source code location where this function was inlined. */
938 struct funcinfo
*prev_func
; /* Pointer to previous function in list of all functions */
939 struct funcinfo
*caller_func
; /* Pointer to function one scope higher */
940 char *caller_file
; /* Source location file name where caller_func inlines this func */
941 int caller_line
; /* Source location line number where caller_func inlines this func */
942 char *file
; /* Source location file name */
943 int line
; /* Source location line number */
946 struct arange arange
;
947 asection
*sec
; /* Where the symbol is defined */
952 /* Pointer to previous variable in list of all variables */
953 struct varinfo
*prev_var
;
954 /* Source location file name */
956 /* Source location line number */
961 /* Where the symbol is defined */
963 /* Is this a stack variable? */
964 unsigned int stack
: 1;
967 /* Return TRUE if NEW_LINE should sort after LINE. */
969 static inline bfd_boolean
970 new_line_sorts_after (struct line_info
*new_line
, struct line_info
*line
)
972 return (new_line
->address
> line
->address
973 || (new_line
->address
== line
->address
974 && new_line
->end_sequence
< line
->end_sequence
));
978 /* Adds a new entry to the line_info list in the line_info_table, ensuring
979 that the list is sorted. Note that the line_info list is sorted from
980 highest to lowest VMA (with possible duplicates); that is,
981 line_info->prev_line always accesses an equal or smaller VMA. */
984 add_line_info (struct line_info_table
*table
,
991 bfd_size_type amt
= sizeof (struct line_info
);
992 struct line_sequence
* seq
= table
->sequences
;
993 struct line_info
* info
= (struct line_info
*) bfd_alloc (table
->abfd
, amt
);
995 /* Set member data of 'info'. */
996 info
->address
= address
;
998 info
->column
= column
;
999 info
->end_sequence
= end_sequence
;
1001 if (filename
&& filename
[0])
1003 info
->filename
= (char *) bfd_alloc (table
->abfd
, strlen (filename
) + 1);
1005 strcpy (info
->filename
, filename
);
1008 info
->filename
= NULL
;
1010 /* Find the correct location for 'info'. Normally we will receive
1011 new line_info data 1) in order and 2) with increasing VMAs.
1012 However some compilers break the rules (cf. decode_line_info) and
1013 so we include some heuristics for quickly finding the correct
1014 location for 'info'. In particular, these heuristics optimize for
1015 the common case in which the VMA sequence that we receive is a
1016 list of locally sorted VMAs such as
1017 p...z a...j (where a < j < p < z)
1019 Note: table->lcl_head is used to head an *actual* or *possible*
1020 sub-sequence within the list (such as a...j) that is not directly
1021 headed by table->last_line
1023 Note: we may receive duplicate entries from 'decode_line_info'. */
1026 && seq
->last_line
->address
== address
1027 && seq
->last_line
->end_sequence
== end_sequence
)
1029 /* We only keep the last entry with the same address and end
1030 sequence. See PR ld/4986. */
1031 if (table
->lcl_head
== seq
->last_line
)
1032 table
->lcl_head
= info
;
1033 info
->prev_line
= seq
->last_line
->prev_line
;
1034 seq
->last_line
= info
;
1036 else if (!seq
|| seq
->last_line
->end_sequence
)
1038 /* Start a new line sequence. */
1039 amt
= sizeof (struct line_sequence
);
1040 seq
= (struct line_sequence
*) bfd_malloc (amt
);
1041 seq
->low_pc
= address
;
1042 seq
->prev_sequence
= table
->sequences
;
1043 seq
->last_line
= info
;
1044 table
->lcl_head
= info
;
1045 table
->sequences
= seq
;
1046 table
->num_sequences
++;
1048 else if (new_line_sorts_after (info
, seq
->last_line
))
1050 /* Normal case: add 'info' to the beginning of the current sequence. */
1051 info
->prev_line
= seq
->last_line
;
1052 seq
->last_line
= info
;
1054 /* lcl_head: initialize to head a *possible* sequence at the end. */
1055 if (!table
->lcl_head
)
1056 table
->lcl_head
= info
;
1058 else if (!new_line_sorts_after (info
, table
->lcl_head
)
1059 && (!table
->lcl_head
->prev_line
1060 || new_line_sorts_after (info
, table
->lcl_head
->prev_line
)))
1062 /* Abnormal but easy: lcl_head is the head of 'info'. */
1063 info
->prev_line
= table
->lcl_head
->prev_line
;
1064 table
->lcl_head
->prev_line
= info
;
1068 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head'
1069 are valid heads for 'info'. Reset 'lcl_head'. */
1070 struct line_info
* li2
= seq
->last_line
; /* Always non-NULL. */
1071 struct line_info
* li1
= li2
->prev_line
;
1075 if (!new_line_sorts_after (info
, li2
)
1076 && new_line_sorts_after (info
, li1
))
1079 li2
= li1
; /* always non-NULL */
1080 li1
= li1
->prev_line
;
1082 table
->lcl_head
= li2
;
1083 info
->prev_line
= table
->lcl_head
->prev_line
;
1084 table
->lcl_head
->prev_line
= info
;
1085 if (address
< seq
->low_pc
)
1086 seq
->low_pc
= address
;
1090 /* Extract a fully qualified filename from a line info table.
1091 The returned string has been malloc'ed and it is the caller's
1092 responsibility to free it. */
1095 concat_filename (struct line_info_table
*table
, unsigned int file
)
1099 if (file
- 1 >= table
->num_files
)
1101 /* FILE == 0 means unknown. */
1103 (*_bfd_error_handler
)
1104 (_("Dwarf Error: mangled line number section (bad file number)."));
1105 return strdup ("<unknown>");
1108 filename
= table
->files
[file
- 1].name
;
1110 if (!IS_ABSOLUTE_PATH (filename
))
1112 char *dir_name
= NULL
;
1113 char *subdir_name
= NULL
;
1117 if (table
->files
[file
- 1].dir
)
1118 subdir_name
= table
->dirs
[table
->files
[file
- 1].dir
- 1];
1120 if (!subdir_name
|| !IS_ABSOLUTE_PATH (subdir_name
))
1121 dir_name
= table
->comp_dir
;
1125 dir_name
= subdir_name
;
1130 return strdup (filename
);
1132 len
= strlen (dir_name
) + strlen (filename
) + 2;
1136 len
+= strlen (subdir_name
) + 1;
1137 name
= (char *) bfd_malloc (len
);
1139 sprintf (name
, "%s/%s/%s", dir_name
, subdir_name
, filename
);
1143 name
= (char *) bfd_malloc (len
);
1145 sprintf (name
, "%s/%s", dir_name
, filename
);
1151 return strdup (filename
);
1155 arange_add (bfd
*abfd
, struct arange
*first_arange
, bfd_vma low_pc
, bfd_vma high_pc
)
1157 struct arange
*arange
;
1159 /* If the first arange is empty, use it. */
1160 if (first_arange
->high
== 0)
1162 first_arange
->low
= low_pc
;
1163 first_arange
->high
= high_pc
;
1167 /* Next see if we can cheaply extend an existing range. */
1168 arange
= first_arange
;
1171 if (low_pc
== arange
->high
)
1173 arange
->high
= high_pc
;
1176 if (high_pc
== arange
->low
)
1178 arange
->low
= low_pc
;
1181 arange
= arange
->next
;
1185 /* Need to allocate a new arange and insert it into the arange list.
1186 Order isn't significant, so just insert after the first arange. */
1187 arange
= (struct arange
*) bfd_zalloc (abfd
, sizeof (*arange
));
1188 arange
->low
= low_pc
;
1189 arange
->high
= high_pc
;
1190 arange
->next
= first_arange
->next
;
1191 first_arange
->next
= arange
;
1194 /* Compare function for line sequences. */
1197 compare_sequences (const void* a
, const void* b
)
1199 const struct line_sequence
* seq1
= a
;
1200 const struct line_sequence
* seq2
= b
;
1202 /* Sort by low_pc as the primary key. */
1203 if (seq1
->low_pc
< seq2
->low_pc
)
1205 if (seq1
->low_pc
> seq2
->low_pc
)
1208 /* If low_pc values are equal, sort in reverse order of
1209 high_pc, so that the largest region comes first. */
1210 if (seq1
->last_line
->address
< seq2
->last_line
->address
)
1212 if (seq1
->last_line
->address
> seq2
->last_line
->address
)
1218 /* Sort the line sequences for quick lookup. */
1221 sort_line_sequences (struct line_info_table
* table
)
1224 struct line_sequence
* sequences
;
1225 struct line_sequence
* seq
;
1227 unsigned int num_sequences
= table
->num_sequences
;
1228 bfd_vma last_high_pc
;
1230 if (num_sequences
== 0)
1233 /* Allocate space for an array of sequences. */
1234 amt
= sizeof (struct line_sequence
) * num_sequences
;
1235 sequences
= (struct line_sequence
*) bfd_alloc (table
->abfd
, amt
);
1237 /* Copy the linked list into the array, freeing the original nodes. */
1238 seq
= table
->sequences
;
1239 for (n
= 0; n
< num_sequences
; n
++)
1241 struct line_sequence
* last_seq
= seq
;
1244 sequences
[n
].low_pc
= seq
->low_pc
;
1245 sequences
[n
].prev_sequence
= NULL
;
1246 sequences
[n
].last_line
= seq
->last_line
;
1247 seq
= seq
->prev_sequence
;
1250 BFD_ASSERT (seq
== NULL
);
1252 qsort (sequences
, n
, sizeof (struct line_sequence
), compare_sequences
);
1254 /* Make the list binary-searchable by trimming overlapping entries
1255 and removing nested entries. */
1257 last_high_pc
= sequences
[0].last_line
->address
;
1258 for (n
= 1; n
< table
->num_sequences
; n
++)
1260 if (sequences
[n
].low_pc
< last_high_pc
)
1262 if (sequences
[n
].last_line
->address
<= last_high_pc
)
1263 /* Skip nested entries. */
1266 /* Trim overlapping entries. */
1267 sequences
[n
].low_pc
= last_high_pc
;
1269 last_high_pc
= sequences
[n
].last_line
->address
;
1270 if (n
> num_sequences
)
1272 /* Close up the gap. */
1273 sequences
[num_sequences
].low_pc
= sequences
[n
].low_pc
;
1274 sequences
[num_sequences
].last_line
= sequences
[n
].last_line
;
1279 table
->sequences
= sequences
;
1280 table
->num_sequences
= num_sequences
;
1283 /* Decode the line number information for UNIT. */
1285 static struct line_info_table
*
1286 decode_line_info (struct comp_unit
*unit
, struct dwarf2_debug
*stash
)
1288 bfd
*abfd
= unit
->abfd
;
1289 struct line_info_table
* table
;
1292 struct line_head lh
;
1293 unsigned int i
, bytes_read
, offset_size
;
1294 char *cur_file
, *cur_dir
;
1295 unsigned char op_code
, extended_op
, adj_opcode
;
1298 if (! read_section (abfd
, ".debug_line", ".zdebug_line",
1299 stash
->syms
, unit
->line_offset
,
1300 &stash
->dwarf_line_buffer
, &stash
->dwarf_line_size
))
1303 amt
= sizeof (struct line_info_table
);
1304 table
= (struct line_info_table
*) bfd_alloc (abfd
, amt
);
1306 table
->comp_dir
= unit
->comp_dir
;
1308 table
->num_files
= 0;
1309 table
->files
= NULL
;
1311 table
->num_dirs
= 0;
1314 table
->num_sequences
= 0;
1315 table
->sequences
= NULL
;
1317 table
->lcl_head
= NULL
;
1319 line_ptr
= stash
->dwarf_line_buffer
+ unit
->line_offset
;
1321 /* Read in the prologue. */
1322 lh
.total_length
= read_4_bytes (abfd
, line_ptr
);
1325 if (lh
.total_length
== 0xffffffff)
1327 lh
.total_length
= read_8_bytes (abfd
, line_ptr
);
1331 else if (lh
.total_length
== 0 && unit
->addr_size
== 8)
1333 /* Handle (non-standard) 64-bit DWARF2 formats. */
1334 lh
.total_length
= read_4_bytes (abfd
, line_ptr
);
1338 line_end
= line_ptr
+ lh
.total_length
;
1339 lh
.version
= read_2_bytes (abfd
, line_ptr
);
1341 if (offset_size
== 4)
1342 lh
.prologue_length
= read_4_bytes (abfd
, line_ptr
);
1344 lh
.prologue_length
= read_8_bytes (abfd
, line_ptr
);
1345 line_ptr
+= offset_size
;
1346 lh
.minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
1348 lh
.default_is_stmt
= read_1_byte (abfd
, line_ptr
);
1350 lh
.line_base
= read_1_signed_byte (abfd
, line_ptr
);
1352 lh
.line_range
= read_1_byte (abfd
, line_ptr
);
1354 lh
.opcode_base
= read_1_byte (abfd
, line_ptr
);
1356 amt
= lh
.opcode_base
* sizeof (unsigned char);
1357 lh
.standard_opcode_lengths
= (unsigned char *) bfd_alloc (abfd
, amt
);
1359 lh
.standard_opcode_lengths
[0] = 1;
1361 for (i
= 1; i
< lh
.opcode_base
; ++i
)
1363 lh
.standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
1367 /* Read directory table. */
1368 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
1370 line_ptr
+= bytes_read
;
1372 if ((table
->num_dirs
% DIR_ALLOC_CHUNK
) == 0)
1376 amt
= table
->num_dirs
+ DIR_ALLOC_CHUNK
;
1377 amt
*= sizeof (char *);
1379 tmp
= (char **) bfd_realloc (table
->dirs
, amt
);
1388 table
->dirs
[table
->num_dirs
++] = cur_dir
;
1391 line_ptr
+= bytes_read
;
1393 /* Read file name table. */
1394 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
1396 line_ptr
+= bytes_read
;
1398 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
1400 struct fileinfo
*tmp
;
1402 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
1403 amt
*= sizeof (struct fileinfo
);
1405 tmp
= (struct fileinfo
*) bfd_realloc (table
->files
, amt
);
1408 free (table
->files
);
1415 table
->files
[table
->num_files
].name
= cur_file
;
1416 table
->files
[table
->num_files
].dir
=
1417 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1418 line_ptr
+= bytes_read
;
1419 table
->files
[table
->num_files
].time
=
1420 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1421 line_ptr
+= bytes_read
;
1422 table
->files
[table
->num_files
].size
=
1423 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1424 line_ptr
+= bytes_read
;
1428 line_ptr
+= bytes_read
;
1430 /* Read the statement sequences until there's nothing left. */
1431 while (line_ptr
< line_end
)
1433 /* State machine registers. */
1434 bfd_vma address
= 0;
1435 char * filename
= table
->num_files
? concat_filename (table
, 1) : NULL
;
1436 unsigned int line
= 1;
1437 unsigned int column
= 0;
1438 int is_stmt
= lh
.default_is_stmt
;
1439 int end_sequence
= 0;
1440 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1441 compilers generate address sequences that are wildly out of
1442 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1443 for ia64-Linux). Thus, to determine the low and high
1444 address, we must compare on every DW_LNS_copy, etc. */
1445 bfd_vma low_pc
= (bfd_vma
) -1;
1446 bfd_vma high_pc
= 0;
1448 /* Decode the table. */
1449 while (! end_sequence
)
1451 op_code
= read_1_byte (abfd
, line_ptr
);
1454 if (op_code
>= lh
.opcode_base
)
1456 /* Special operand. */
1457 adj_opcode
= op_code
- lh
.opcode_base
;
1458 address
+= (adj_opcode
/ lh
.line_range
)
1459 * lh
.minimum_instruction_length
;
1460 line
+= lh
.line_base
+ (adj_opcode
% lh
.line_range
);
1461 /* Append row to matrix using current values. */
1462 add_line_info (table
, address
, filename
, line
, column
, 0);
1463 if (address
< low_pc
)
1465 if (address
> high_pc
)
1468 else switch (op_code
)
1470 case DW_LNS_extended_op
:
1471 /* Ignore length. */
1473 extended_op
= read_1_byte (abfd
, line_ptr
);
1476 switch (extended_op
)
1478 case DW_LNE_end_sequence
:
1480 add_line_info (table
, address
, filename
, line
, column
,
1482 if (address
< low_pc
)
1484 if (address
> high_pc
)
1486 arange_add (unit
->abfd
, &unit
->arange
, low_pc
, high_pc
);
1488 case DW_LNE_set_address
:
1489 address
= read_address (unit
, line_ptr
);
1490 line_ptr
+= unit
->addr_size
;
1492 case DW_LNE_define_file
:
1493 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
1494 line_ptr
+= bytes_read
;
1495 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
1497 struct fileinfo
*tmp
;
1499 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
1500 amt
*= sizeof (struct fileinfo
);
1501 tmp
= (struct fileinfo
*) bfd_realloc (table
->files
, amt
);
1504 free (table
->files
);
1511 table
->files
[table
->num_files
].name
= cur_file
;
1512 table
->files
[table
->num_files
].dir
=
1513 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1514 line_ptr
+= bytes_read
;
1515 table
->files
[table
->num_files
].time
=
1516 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1517 line_ptr
+= bytes_read
;
1518 table
->files
[table
->num_files
].size
=
1519 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1520 line_ptr
+= bytes_read
;
1523 case DW_LNE_set_discriminator
:
1524 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1525 line_ptr
+= bytes_read
;
1528 (*_bfd_error_handler
) (_("Dwarf Error: mangled line number section."));
1529 bfd_set_error (bfd_error_bad_value
);
1531 free (table
->files
);
1537 add_line_info (table
, address
, filename
, line
, column
, 0);
1538 if (address
< low_pc
)
1540 if (address
> high_pc
)
1543 case DW_LNS_advance_pc
:
1544 address
+= lh
.minimum_instruction_length
1545 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1546 line_ptr
+= bytes_read
;
1548 case DW_LNS_advance_line
:
1549 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
1550 line_ptr
+= bytes_read
;
1552 case DW_LNS_set_file
:
1556 /* The file and directory tables are 0
1557 based, the references are 1 based. */
1558 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1559 line_ptr
+= bytes_read
;
1562 filename
= concat_filename (table
, file
);
1565 case DW_LNS_set_column
:
1566 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1567 line_ptr
+= bytes_read
;
1569 case DW_LNS_negate_stmt
:
1570 is_stmt
= (!is_stmt
);
1572 case DW_LNS_set_basic_block
:
1574 case DW_LNS_const_add_pc
:
1575 address
+= lh
.minimum_instruction_length
1576 * ((255 - lh
.opcode_base
) / lh
.line_range
);
1578 case DW_LNS_fixed_advance_pc
:
1579 address
+= read_2_bytes (abfd
, line_ptr
);
1583 /* Unknown standard opcode, ignore it. */
1584 for (i
= 0; i
< lh
.standard_opcode_lengths
[op_code
]; i
++)
1586 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1587 line_ptr
+= bytes_read
;
1597 sort_line_sequences (table
);
1602 /* If ADDR is within TABLE set the output parameters and return TRUE,
1603 otherwise return FALSE. The output parameters, FILENAME_PTR and
1604 LINENUMBER_PTR, are pointers to the objects to be filled in. */
1607 lookup_address_in_line_info_table (struct line_info_table
*table
,
1609 const char **filename_ptr
,
1610 unsigned int *linenumber_ptr
)
1612 struct line_sequence
*seq
= NULL
;
1613 struct line_info
*each_line
;
1616 /* Binary search the array of sequences. */
1618 high
= table
->num_sequences
;
1621 mid
= (low
+ high
) / 2;
1622 seq
= &table
->sequences
[mid
];
1623 if (addr
< seq
->low_pc
)
1625 else if (addr
>= seq
->last_line
->address
)
1631 if (seq
&& addr
>= seq
->low_pc
&& addr
< seq
->last_line
->address
)
1633 /* Note: seq->last_line should be a descendingly sorted list. */
1634 for (each_line
= seq
->last_line
;
1636 each_line
= each_line
->prev_line
)
1637 if (addr
>= each_line
->address
)
1641 && !(each_line
->end_sequence
|| each_line
== seq
->last_line
))
1643 *filename_ptr
= each_line
->filename
;
1644 *linenumber_ptr
= each_line
->line
;
1649 *filename_ptr
= NULL
;
1653 /* Read in the .debug_ranges section for future reference. */
1656 read_debug_ranges (struct comp_unit
*unit
)
1658 struct dwarf2_debug
*stash
= unit
->stash
;
1659 return read_section (unit
->abfd
, ".debug_ranges", ".zdebug_ranges",
1661 &stash
->dwarf_ranges_buffer
, &stash
->dwarf_ranges_size
);
1664 /* Function table functions. */
1666 /* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return TRUE.
1667 Note that we need to find the function that has the smallest
1668 range that contains ADDR, to handle inlined functions without
1669 depending upon them being ordered in TABLE by increasing range. */
1672 lookup_address_in_function_table (struct comp_unit
*unit
,
1674 struct funcinfo
**function_ptr
,
1675 const char **functionname_ptr
)
1677 struct funcinfo
* each_func
;
1678 struct funcinfo
* best_fit
= NULL
;
1679 struct arange
*arange
;
1681 for (each_func
= unit
->function_table
;
1683 each_func
= each_func
->prev_func
)
1685 for (arange
= &each_func
->arange
;
1687 arange
= arange
->next
)
1689 if (addr
>= arange
->low
&& addr
< arange
->high
)
1692 ((arange
->high
- arange
->low
) < (best_fit
->arange
.high
- best_fit
->arange
.low
)))
1693 best_fit
= each_func
;
1700 *functionname_ptr
= best_fit
->name
;
1701 *function_ptr
= best_fit
;
1710 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
1711 and LINENUMBER_PTR, and return TRUE. */
1714 lookup_symbol_in_function_table (struct comp_unit
*unit
,
1717 const char **filename_ptr
,
1718 unsigned int *linenumber_ptr
)
1720 struct funcinfo
* each_func
;
1721 struct funcinfo
* best_fit
= NULL
;
1722 struct arange
*arange
;
1723 const char *name
= bfd_asymbol_name (sym
);
1724 asection
*sec
= bfd_get_section (sym
);
1726 for (each_func
= unit
->function_table
;
1728 each_func
= each_func
->prev_func
)
1730 for (arange
= &each_func
->arange
;
1732 arange
= arange
->next
)
1734 if ((!each_func
->sec
|| each_func
->sec
== sec
)
1735 && addr
>= arange
->low
1736 && addr
< arange
->high
1738 && strcmp (name
, each_func
->name
) == 0
1740 || ((arange
->high
- arange
->low
)
1741 < (best_fit
->arange
.high
- best_fit
->arange
.low
))))
1742 best_fit
= each_func
;
1748 best_fit
->sec
= sec
;
1749 *filename_ptr
= best_fit
->file
;
1750 *linenumber_ptr
= best_fit
->line
;
1757 /* Variable table functions. */
1759 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
1760 LINENUMBER_PTR, and return TRUE. */
1763 lookup_symbol_in_variable_table (struct comp_unit
*unit
,
1766 const char **filename_ptr
,
1767 unsigned int *linenumber_ptr
)
1769 const char *name
= bfd_asymbol_name (sym
);
1770 asection
*sec
= bfd_get_section (sym
);
1771 struct varinfo
* each
;
1773 for (each
= unit
->variable_table
; each
; each
= each
->prev_var
)
1774 if (each
->stack
== 0
1775 && each
->file
!= NULL
1776 && each
->name
!= NULL
1777 && each
->addr
== addr
1778 && (!each
->sec
|| each
->sec
== sec
)
1779 && strcmp (name
, each
->name
) == 0)
1785 *filename_ptr
= each
->file
;
1786 *linenumber_ptr
= each
->line
;
1794 find_abstract_instance_name (struct comp_unit
*unit
,
1795 struct attribute
*attr_ptr
)
1797 bfd
*abfd
= unit
->abfd
;
1799 unsigned int abbrev_number
, bytes_read
, i
;
1800 struct abbrev_info
*abbrev
;
1801 bfd_uint64_t die_ref
= attr_ptr
->u
.val
;
1802 struct attribute attr
;
1805 /* DW_FORM_ref_addr can reference an entry in a different CU. It
1806 is an offset from the .debug_info section, not the current CU. */
1807 if (attr_ptr
->form
== DW_FORM_ref_addr
)
1809 /* We only support DW_FORM_ref_addr within the same file, so
1810 any relocations should be resolved already. */
1814 info_ptr
= unit
->stash
->sec_info_ptr
+ die_ref
;
1817 info_ptr
= unit
->info_ptr_unit
+ die_ref
;
1818 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
1819 info_ptr
+= bytes_read
;
1823 abbrev
= lookup_abbrev (abbrev_number
, unit
->abbrevs
);
1826 (*_bfd_error_handler
) (_("Dwarf Error: Could not find abbrev number %u."),
1828 bfd_set_error (bfd_error_bad_value
);
1832 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
1834 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
);
1838 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
1842 case DW_AT_specification
:
1843 name
= find_abstract_instance_name (unit
, &attr
);
1845 case DW_AT_MIPS_linkage_name
:
1858 read_rangelist (struct comp_unit
*unit
, struct arange
*arange
, bfd_uint64_t offset
)
1860 bfd_byte
*ranges_ptr
;
1861 bfd_vma base_address
= unit
->base_address
;
1863 if (! unit
->stash
->dwarf_ranges_buffer
)
1865 if (! read_debug_ranges (unit
))
1868 ranges_ptr
= unit
->stash
->dwarf_ranges_buffer
+ offset
;
1875 low_pc
= read_address (unit
, ranges_ptr
);
1876 ranges_ptr
+= unit
->addr_size
;
1877 high_pc
= read_address (unit
, ranges_ptr
);
1878 ranges_ptr
+= unit
->addr_size
;
1880 if (low_pc
== 0 && high_pc
== 0)
1882 if (low_pc
== -1UL && high_pc
!= -1UL)
1883 base_address
= high_pc
;
1885 arange_add (unit
->abfd
, arange
, base_address
+ low_pc
, base_address
+ high_pc
);
1889 /* DWARF2 Compilation unit functions. */
1891 /* Scan over each die in a comp. unit looking for functions to add
1892 to the function table and variables to the variable table. */
1895 scan_unit_for_symbols (struct comp_unit
*unit
)
1897 bfd
*abfd
= unit
->abfd
;
1898 bfd_byte
*info_ptr
= unit
->first_child_die_ptr
;
1899 int nesting_level
= 1;
1900 struct funcinfo
**nested_funcs
;
1901 int nested_funcs_size
;
1903 /* Maintain a stack of in-scope functions and inlined functions, which we
1904 can use to set the caller_func field. */
1905 nested_funcs_size
= 32;
1906 nested_funcs
= (struct funcinfo
**)
1907 bfd_malloc (nested_funcs_size
* sizeof (struct funcinfo
*));
1908 if (nested_funcs
== NULL
)
1910 nested_funcs
[nesting_level
] = 0;
1912 while (nesting_level
)
1914 unsigned int abbrev_number
, bytes_read
, i
;
1915 struct abbrev_info
*abbrev
;
1916 struct attribute attr
;
1917 struct funcinfo
*func
;
1918 struct varinfo
*var
;
1920 bfd_vma high_pc
= 0;
1922 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
1923 info_ptr
+= bytes_read
;
1925 if (! abbrev_number
)
1931 abbrev
= lookup_abbrev (abbrev_number
,unit
->abbrevs
);
1934 (*_bfd_error_handler
) (_("Dwarf Error: Could not find abbrev number %u."),
1936 bfd_set_error (bfd_error_bad_value
);
1937 free (nested_funcs
);
1942 if (abbrev
->tag
== DW_TAG_subprogram
1943 || abbrev
->tag
== DW_TAG_entry_point
1944 || abbrev
->tag
== DW_TAG_inlined_subroutine
)
1946 bfd_size_type amt
= sizeof (struct funcinfo
);
1947 func
= (struct funcinfo
*) bfd_zalloc (abfd
, amt
);
1948 func
->tag
= abbrev
->tag
;
1949 func
->prev_func
= unit
->function_table
;
1950 unit
->function_table
= func
;
1951 BFD_ASSERT (!unit
->cached
);
1953 if (func
->tag
== DW_TAG_inlined_subroutine
)
1954 for (i
= nesting_level
- 1; i
>= 1; i
--)
1955 if (nested_funcs
[i
])
1957 func
->caller_func
= nested_funcs
[i
];
1960 nested_funcs
[nesting_level
] = func
;
1965 if (abbrev
->tag
== DW_TAG_variable
)
1967 bfd_size_type amt
= sizeof (struct varinfo
);
1968 var
= (struct varinfo
*) bfd_zalloc (abfd
, amt
);
1969 var
->tag
= abbrev
->tag
;
1971 var
->prev_var
= unit
->variable_table
;
1972 unit
->variable_table
= var
;
1973 BFD_ASSERT (!unit
->cached
);
1976 /* No inline function in scope at this nesting level. */
1977 nested_funcs
[nesting_level
] = 0;
1980 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
1982 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
);
1988 case DW_AT_call_file
:
1989 func
->caller_file
= concat_filename (unit
->line_table
, attr
.u
.val
);
1992 case DW_AT_call_line
:
1993 func
->caller_line
= attr
.u
.val
;
1996 case DW_AT_abstract_origin
:
1997 func
->name
= find_abstract_instance_name (unit
, &attr
);
2001 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
2002 if (func
->name
== NULL
)
2003 func
->name
= attr
.u
.str
;
2006 case DW_AT_MIPS_linkage_name
:
2007 func
->name
= attr
.u
.str
;
2011 low_pc
= attr
.u
.val
;
2015 high_pc
= attr
.u
.val
;
2019 read_rangelist (unit
, &func
->arange
, attr
.u
.val
);
2022 case DW_AT_decl_file
:
2023 func
->file
= concat_filename (unit
->line_table
,
2027 case DW_AT_decl_line
:
2028 func
->line
= attr
.u
.val
;
2040 var
->name
= attr
.u
.str
;
2043 case DW_AT_decl_file
:
2044 var
->file
= concat_filename (unit
->line_table
,
2048 case DW_AT_decl_line
:
2049 var
->line
= attr
.u
.val
;
2052 case DW_AT_external
:
2053 if (attr
.u
.val
!= 0)
2057 case DW_AT_location
:
2061 case DW_FORM_block1
:
2062 case DW_FORM_block2
:
2063 case DW_FORM_block4
:
2064 if (*attr
.u
.blk
->data
== DW_OP_addr
)
2068 /* Verify that DW_OP_addr is the only opcode in the
2069 location, in which case the block size will be 1
2070 plus the address size. */
2071 /* ??? For TLS variables, gcc can emit
2072 DW_OP_addr <addr> DW_OP_GNU_push_tls_address
2073 which we don't handle here yet. */
2074 if (attr
.u
.blk
->size
== unit
->addr_size
+ 1U)
2075 var
->addr
= bfd_get (unit
->addr_size
* 8,
2077 attr
.u
.blk
->data
+ 1);
2092 if (func
&& high_pc
!= 0)
2094 arange_add (unit
->abfd
, &func
->arange
, low_pc
, high_pc
);
2097 if (abbrev
->has_children
)
2101 if (nesting_level
>= nested_funcs_size
)
2103 struct funcinfo
**tmp
;
2105 nested_funcs_size
*= 2;
2106 tmp
= (struct funcinfo
**)
2107 bfd_realloc (nested_funcs
,
2108 (nested_funcs_size
* sizeof (struct funcinfo
*)));
2111 free (nested_funcs
);
2116 nested_funcs
[nesting_level
] = 0;
2120 free (nested_funcs
);
2124 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
2125 includes the compilation unit header that proceeds the DIE's, but
2126 does not include the length field that precedes each compilation
2127 unit header. END_PTR points one past the end of this comp unit.
2128 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
2130 This routine does not read the whole compilation unit; only enough
2131 to get to the line number information for the compilation unit. */
2133 static struct comp_unit
*
2134 parse_comp_unit (struct dwarf2_debug
*stash
,
2135 bfd_vma unit_length
,
2136 bfd_byte
*info_ptr_unit
,
2137 unsigned int offset_size
)
2139 struct comp_unit
* unit
;
2140 unsigned int version
;
2141 bfd_uint64_t abbrev_offset
= 0;
2142 unsigned int addr_size
;
2143 struct abbrev_info
** abbrevs
;
2144 unsigned int abbrev_number
, bytes_read
, i
;
2145 struct abbrev_info
*abbrev
;
2146 struct attribute attr
;
2147 bfd_byte
*info_ptr
= stash
->info_ptr
;
2148 bfd_byte
*end_ptr
= info_ptr
+ unit_length
;
2151 bfd_vma high_pc
= 0;
2152 bfd
*abfd
= stash
->bfd_ptr
;
2154 version
= read_2_bytes (abfd
, info_ptr
);
2156 BFD_ASSERT (offset_size
== 4 || offset_size
== 8);
2157 if (offset_size
== 4)
2158 abbrev_offset
= read_4_bytes (abfd
, info_ptr
);
2160 abbrev_offset
= read_8_bytes (abfd
, info_ptr
);
2161 info_ptr
+= offset_size
;
2162 addr_size
= read_1_byte (abfd
, info_ptr
);
2165 if (version
!= 2 && version
!= 3)
2167 (*_bfd_error_handler
) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 and 3 information."), version
);
2168 bfd_set_error (bfd_error_bad_value
);
2172 if (addr_size
> sizeof (bfd_vma
))
2174 (*_bfd_error_handler
) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
2176 (unsigned int) sizeof (bfd_vma
));
2177 bfd_set_error (bfd_error_bad_value
);
2181 if (addr_size
!= 2 && addr_size
!= 4 && addr_size
!= 8)
2183 (*_bfd_error_handler
) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size
);
2184 bfd_set_error (bfd_error_bad_value
);
2188 /* Read the abbrevs for this compilation unit into a table. */
2189 abbrevs
= read_abbrevs (abfd
, abbrev_offset
, stash
);
2193 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2194 info_ptr
+= bytes_read
;
2195 if (! abbrev_number
)
2197 (*_bfd_error_handler
) (_("Dwarf Error: Bad abbrev number: %u."),
2199 bfd_set_error (bfd_error_bad_value
);
2203 abbrev
= lookup_abbrev (abbrev_number
, abbrevs
);
2206 (*_bfd_error_handler
) (_("Dwarf Error: Could not find abbrev number %u."),
2208 bfd_set_error (bfd_error_bad_value
);
2212 amt
= sizeof (struct comp_unit
);
2213 unit
= (struct comp_unit
*) bfd_zalloc (abfd
, amt
);
2215 unit
->version
= version
;
2216 unit
->addr_size
= addr_size
;
2217 unit
->offset_size
= offset_size
;
2218 unit
->abbrevs
= abbrevs
;
2219 unit
->end_ptr
= end_ptr
;
2220 unit
->stash
= stash
;
2221 unit
->info_ptr_unit
= info_ptr_unit
;
2223 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
2225 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
);
2227 /* Store the data if it is of an attribute we want to keep in a
2228 partial symbol table. */
2231 case DW_AT_stmt_list
:
2233 unit
->line_offset
= attr
.u
.val
;
2237 unit
->name
= attr
.u
.str
;
2241 low_pc
= attr
.u
.val
;
2242 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
2243 this is the base address to use when reading location
2244 lists or range lists. */
2245 unit
->base_address
= low_pc
;
2249 high_pc
= attr
.u
.val
;
2253 read_rangelist (unit
, &unit
->arange
, attr
.u
.val
);
2256 case DW_AT_comp_dir
:
2258 char *comp_dir
= attr
.u
.str
;
2261 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2262 directory, get rid of it. */
2263 char *cp
= strchr (comp_dir
, ':');
2265 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2268 unit
->comp_dir
= comp_dir
;
2278 arange_add (unit
->abfd
, &unit
->arange
, low_pc
, high_pc
);
2281 unit
->first_child_die_ptr
= info_ptr
;
2285 /* Return TRUE if UNIT may contain the address given by ADDR. When
2286 there are functions written entirely with inline asm statements, the
2287 range info in the compilation unit header may not be correct. We
2288 need to consult the line info table to see if a compilation unit
2289 really contains the given address. */
2292 comp_unit_contains_address (struct comp_unit
*unit
, bfd_vma addr
)
2294 struct arange
*arange
;
2299 arange
= &unit
->arange
;
2302 if (addr
>= arange
->low
&& addr
< arange
->high
)
2304 arange
= arange
->next
;
2311 /* If UNIT contains ADDR, set the output parameters to the values for
2312 the line containing ADDR. The output parameters, FILENAME_PTR,
2313 FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
2316 Return TRUE if UNIT contains ADDR, and no errors were encountered;
2320 comp_unit_find_nearest_line (struct comp_unit
*unit
,
2322 const char **filename_ptr
,
2323 const char **functionname_ptr
,
2324 unsigned int *linenumber_ptr
,
2325 struct dwarf2_debug
*stash
)
2329 struct funcinfo
*function
;
2334 if (! unit
->line_table
)
2336 if (! unit
->stmtlist
)
2342 unit
->line_table
= decode_line_info (unit
, stash
);
2344 if (! unit
->line_table
)
2350 if (unit
->first_child_die_ptr
< unit
->end_ptr
2351 && ! scan_unit_for_symbols (unit
))
2359 func_p
= lookup_address_in_function_table (unit
, addr
,
2360 &function
, functionname_ptr
);
2361 if (func_p
&& (function
->tag
== DW_TAG_inlined_subroutine
))
2362 stash
->inliner_chain
= function
;
2363 line_p
= lookup_address_in_line_info_table (unit
->line_table
, addr
,
2366 return line_p
|| func_p
;
2369 /* Check to see if line info is already decoded in a comp_unit.
2370 If not, decode it. Returns TRUE if no errors were encountered;
2374 comp_unit_maybe_decode_line_info (struct comp_unit
*unit
,
2375 struct dwarf2_debug
*stash
)
2380 if (! unit
->line_table
)
2382 if (! unit
->stmtlist
)
2388 unit
->line_table
= decode_line_info (unit
, stash
);
2390 if (! unit
->line_table
)
2396 if (unit
->first_child_die_ptr
< unit
->end_ptr
2397 && ! scan_unit_for_symbols (unit
))
2407 /* If UNIT contains SYM at ADDR, set the output parameters to the
2408 values for the line containing SYM. The output parameters,
2409 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
2412 Return TRUE if UNIT contains SYM, and no errors were encountered;
2416 comp_unit_find_line (struct comp_unit
*unit
,
2419 const char **filename_ptr
,
2420 unsigned int *linenumber_ptr
,
2421 struct dwarf2_debug
*stash
)
2423 if (!comp_unit_maybe_decode_line_info (unit
, stash
))
2426 if (sym
->flags
& BSF_FUNCTION
)
2427 return lookup_symbol_in_function_table (unit
, sym
, addr
,
2431 return lookup_symbol_in_variable_table (unit
, sym
, addr
,
2436 static struct funcinfo
*
2437 reverse_funcinfo_list (struct funcinfo
*head
)
2439 struct funcinfo
*rhead
;
2440 struct funcinfo
*temp
;
2442 for (rhead
= NULL
; head
; head
= temp
)
2444 temp
= head
->prev_func
;
2445 head
->prev_func
= rhead
;
2451 static struct varinfo
*
2452 reverse_varinfo_list (struct varinfo
*head
)
2454 struct varinfo
*rhead
;
2455 struct varinfo
*temp
;
2457 for (rhead
= NULL
; head
; head
= temp
)
2459 temp
= head
->prev_var
;
2460 head
->prev_var
= rhead
;
2466 /* Extract all interesting funcinfos and varinfos of a compilation
2467 unit into hash tables for faster lookup. Returns TRUE if no
2468 errors were enountered; FALSE otherwise. */
2471 comp_unit_hash_info (struct dwarf2_debug
*stash
,
2472 struct comp_unit
*unit
,
2473 struct info_hash_table
*funcinfo_hash_table
,
2474 struct info_hash_table
*varinfo_hash_table
)
2476 struct funcinfo
* each_func
;
2477 struct varinfo
* each_var
;
2478 bfd_boolean okay
= TRUE
;
2480 BFD_ASSERT (stash
->info_hash_status
!= STASH_INFO_HASH_DISABLED
);
2482 if (!comp_unit_maybe_decode_line_info (unit
, stash
))
2485 BFD_ASSERT (!unit
->cached
);
2487 /* To preserve the original search order, we went to visit the function
2488 infos in the reversed order of the list. However, making the list
2489 bi-directional use quite a bit of extra memory. So we reverse
2490 the list first, traverse the list in the now reversed order and
2491 finally reverse the list again to get back the original order. */
2492 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
2493 for (each_func
= unit
->function_table
;
2495 each_func
= each_func
->prev_func
)
2497 /* Skip nameless functions. */
2498 if (each_func
->name
)
2499 /* There is no need to copy name string into hash table as
2500 name string is either in the dwarf string buffer or
2501 info in the stash. */
2502 okay
= insert_info_hash_table (funcinfo_hash_table
, each_func
->name
,
2503 (void*) each_func
, FALSE
);
2505 unit
->function_table
= reverse_funcinfo_list (unit
->function_table
);
2509 /* We do the same for variable infos. */
2510 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
2511 for (each_var
= unit
->variable_table
;
2513 each_var
= each_var
->prev_var
)
2515 /* Skip stack vars and vars with no files or names. */
2516 if (each_var
->stack
== 0
2517 && each_var
->file
!= NULL
2518 && each_var
->name
!= NULL
)
2519 /* There is no need to copy name string into hash table as
2520 name string is either in the dwarf string buffer or
2521 info in the stash. */
2522 okay
= insert_info_hash_table (varinfo_hash_table
, each_var
->name
,
2523 (void*) each_var
, FALSE
);
2526 unit
->variable_table
= reverse_varinfo_list (unit
->variable_table
);
2527 unit
->cached
= TRUE
;
2531 /* Locate a section in a BFD containing debugging info. The search starts
2532 from the section after AFTER_SEC, or from the first section in the BFD if
2533 AFTER_SEC is NULL. The search works by examining the names of the
2534 sections. There are two permissiable names. The first is .debug_info.
2535 This is the standard DWARF2 name. The second is a prefix .gnu.linkonce.wi.
2536 This is a variation on the .debug_info section which has a checksum
2537 describing the contents appended onto the name. This allows the linker to
2538 identify and discard duplicate debugging sections for different
2539 compilation units. */
2540 #define DWARF2_DEBUG_INFO ".debug_info"
2541 #define DWARF2_COMPRESSED_DEBUG_INFO ".zdebug_info"
2542 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
2545 find_debug_info (bfd
*abfd
, asection
*after_sec
)
2549 msec
= after_sec
!= NULL
? after_sec
->next
: abfd
->sections
;
2553 if (strcmp (msec
->name
, DWARF2_DEBUG_INFO
) == 0)
2556 if (strcmp (msec
->name
, DWARF2_COMPRESSED_DEBUG_INFO
) == 0)
2559 if (CONST_STRNEQ (msec
->name
, GNU_LINKONCE_INFO
))
2568 /* Unset vmas for adjusted sections in STASH. */
2571 unset_sections (struct dwarf2_debug
*stash
)
2574 struct adjusted_section
*p
;
2576 i
= stash
->adjusted_section_count
;
2577 p
= stash
->adjusted_sections
;
2578 for (; i
> 0; i
--, p
++)
2579 p
->section
->vma
= 0;
2582 /* Set unique VMAs for loadable and DWARF sections in ABFD and save
2583 VMAs in STASH for unset_sections. */
2586 place_sections (bfd
*abfd
, struct dwarf2_debug
*stash
)
2588 struct adjusted_section
*p
;
2591 if (stash
->adjusted_section_count
!= 0)
2593 i
= stash
->adjusted_section_count
;
2594 p
= stash
->adjusted_sections
;
2595 for (; i
> 0; i
--, p
++)
2596 p
->section
->vma
= p
->adj_vma
;
2601 bfd_vma last_vma
= 0, last_dwarf
= 0;
2605 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
2613 /* We need to adjust the VMAs of any .debug_info sections.
2614 Skip compressed ones, since no relocations could target
2615 them - they should not appear in object files anyway. */
2616 if (strcmp (sect
->name
, DWARF2_DEBUG_INFO
) == 0)
2618 else if (CONST_STRNEQ (sect
->name
, GNU_LINKONCE_INFO
))
2623 if (!is_debug_info
&& (sect
->flags
& SEC_LOAD
) == 0)
2626 sz
= sect
->rawsize
? sect
->rawsize
: sect
->size
;
2633 amt
= i
* sizeof (struct adjusted_section
);
2634 p
= (struct adjusted_section
*) bfd_zalloc (abfd
, amt
);
2638 stash
->adjusted_sections
= p
;
2639 stash
->adjusted_section_count
= i
;
2641 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
2649 /* We need to adjust the VMAs of any .debug_info sections.
2650 Skip compressed ones, since no relocations could target
2651 them - they should not appear in object files anyway. */
2652 if (strcmp (sect
->name
, DWARF2_DEBUG_INFO
) == 0)
2654 else if (CONST_STRNEQ (sect
->name
, GNU_LINKONCE_INFO
))
2659 if (!is_debug_info
&& (sect
->flags
& SEC_LOAD
) == 0)
2662 sz
= sect
->rawsize
? sect
->rawsize
: sect
->size
;
2669 BFD_ASSERT (sect
->alignment_power
== 0);
2670 sect
->vma
= last_dwarf
;
2673 else if (last_vma
!= 0)
2675 /* Align the new address to the current section
2677 last_vma
= ((last_vma
2678 + ~((bfd_vma
) -1 << sect
->alignment_power
))
2679 & ((bfd_vma
) -1 << sect
->alignment_power
));
2680 sect
->vma
= last_vma
;
2681 last_vma
+= sect
->vma
+ sz
;
2684 last_vma
+= sect
->vma
+ sz
;
2686 p
->adj_vma
= sect
->vma
;
2695 /* Look up a funcinfo by name using the given info hash table. If found,
2696 also update the locations pointed to by filename_ptr and linenumber_ptr.
2698 This function returns TRUE if a funcinfo that matches the given symbol
2699 and address is found with any error; otherwise it returns FALSE. */
2702 info_hash_lookup_funcinfo (struct info_hash_table
*hash_table
,
2705 const char **filename_ptr
,
2706 unsigned int *linenumber_ptr
)
2708 struct funcinfo
* each_func
;
2709 struct funcinfo
* best_fit
= NULL
;
2710 struct info_list_node
*node
;
2711 struct arange
*arange
;
2712 const char *name
= bfd_asymbol_name (sym
);
2713 asection
*sec
= bfd_get_section (sym
);
2715 for (node
= lookup_info_hash_table (hash_table
, name
);
2719 each_func
= (struct funcinfo
*) node
->info
;
2720 for (arange
= &each_func
->arange
;
2722 arange
= arange
->next
)
2724 if ((!each_func
->sec
|| each_func
->sec
== sec
)
2725 && addr
>= arange
->low
2726 && addr
< arange
->high
2728 || ((arange
->high
- arange
->low
)
2729 < (best_fit
->arange
.high
- best_fit
->arange
.low
))))
2730 best_fit
= each_func
;
2736 best_fit
->sec
= sec
;
2737 *filename_ptr
= best_fit
->file
;
2738 *linenumber_ptr
= best_fit
->line
;
2745 /* Look up a varinfo by name using the given info hash table. If found,
2746 also update the locations pointed to by filename_ptr and linenumber_ptr.
2748 This function returns TRUE if a varinfo that matches the given symbol
2749 and address is found with any error; otherwise it returns FALSE. */
2752 info_hash_lookup_varinfo (struct info_hash_table
*hash_table
,
2755 const char **filename_ptr
,
2756 unsigned int *linenumber_ptr
)
2758 const char *name
= bfd_asymbol_name (sym
);
2759 asection
*sec
= bfd_get_section (sym
);
2760 struct varinfo
* each
;
2761 struct info_list_node
*node
;
2763 for (node
= lookup_info_hash_table (hash_table
, name
);
2767 each
= (struct varinfo
*) node
->info
;
2768 if (each
->addr
== addr
2769 && (!each
->sec
|| each
->sec
== sec
))
2772 *filename_ptr
= each
->file
;
2773 *linenumber_ptr
= each
->line
;
2781 /* Update the funcinfo and varinfo info hash tables if they are
2782 not up to date. Returns TRUE if there is no error; otherwise
2783 returns FALSE and disable the info hash tables. */
2786 stash_maybe_update_info_hash_tables (struct dwarf2_debug
*stash
)
2788 struct comp_unit
*each
;
2790 /* Exit if hash tables are up-to-date. */
2791 if (stash
->all_comp_units
== stash
->hash_units_head
)
2794 if (stash
->hash_units_head
)
2795 each
= stash
->hash_units_head
->prev_unit
;
2797 each
= stash
->last_comp_unit
;
2801 if (!comp_unit_hash_info (stash
, each
, stash
->funcinfo_hash_table
,
2802 stash
->varinfo_hash_table
))
2804 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
2807 each
= each
->prev_unit
;
2810 stash
->hash_units_head
= stash
->all_comp_units
;
2814 /* Check consistency of info hash tables. This is for debugging only. */
2816 static void ATTRIBUTE_UNUSED
2817 stash_verify_info_hash_table (struct dwarf2_debug
*stash
)
2819 struct comp_unit
*each_unit
;
2820 struct funcinfo
*each_func
;
2821 struct varinfo
*each_var
;
2822 struct info_list_node
*node
;
2825 for (each_unit
= stash
->all_comp_units
;
2827 each_unit
= each_unit
->next_unit
)
2829 for (each_func
= each_unit
->function_table
;
2831 each_func
= each_func
->prev_func
)
2833 if (!each_func
->name
)
2835 node
= lookup_info_hash_table (stash
->funcinfo_hash_table
,
2839 while (node
&& !found
)
2841 found
= node
->info
== each_func
;
2847 for (each_var
= each_unit
->variable_table
;
2849 each_var
= each_var
->prev_var
)
2851 if (!each_var
->name
|| !each_var
->file
|| each_var
->stack
)
2853 node
= lookup_info_hash_table (stash
->varinfo_hash_table
,
2857 while (node
&& !found
)
2859 found
= node
->info
== each_var
;
2867 /* Check to see if we want to enable the info hash tables, which consume
2868 quite a bit of memory. Currently we only check the number times
2869 bfd_dwarf2_find_line is called. In the future, we may also want to
2870 take the number of symbols into account. */
2873 stash_maybe_enable_info_hash_tables (bfd
*abfd
, struct dwarf2_debug
*stash
)
2875 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_OFF
);
2877 if (stash
->info_hash_count
++ < STASH_INFO_HASH_TRIGGER
)
2880 /* FIXME: Maybe we should check the reduce_memory_overheads
2881 and optimize fields in the bfd_link_info structure ? */
2883 /* Create hash tables. */
2884 stash
->funcinfo_hash_table
= create_info_hash_table (abfd
);
2885 stash
->varinfo_hash_table
= create_info_hash_table (abfd
);
2886 if (!stash
->funcinfo_hash_table
|| !stash
->varinfo_hash_table
)
2888 /* Turn off info hashes if any allocation above fails. */
2889 stash
->info_hash_status
= STASH_INFO_HASH_DISABLED
;
2892 /* We need a forced update so that the info hash tables will
2893 be created even though there is no compilation unit. That
2894 happens if STASH_INFO_HASH_TRIGGER is 0. */
2895 stash_maybe_update_info_hash_tables (stash
);
2896 stash
->info_hash_status
= STASH_INFO_HASH_ON
;
2899 /* Find the file and line associated with a symbol and address using the
2900 info hash tables of a stash. If there is a match, the function returns
2901 TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
2902 otherwise it returns FALSE. */
2905 stash_find_line_fast (struct dwarf2_debug
*stash
,
2908 const char **filename_ptr
,
2909 unsigned int *linenumber_ptr
)
2911 BFD_ASSERT (stash
->info_hash_status
== STASH_INFO_HASH_ON
);
2913 if (sym
->flags
& BSF_FUNCTION
)
2914 return info_hash_lookup_funcinfo (stash
->funcinfo_hash_table
, sym
, addr
,
2915 filename_ptr
, linenumber_ptr
);
2916 return info_hash_lookup_varinfo (stash
->varinfo_hash_table
, sym
, addr
,
2917 filename_ptr
, linenumber_ptr
);
2920 /* Find the source code location of SYMBOL. If SYMBOL is NULL
2921 then find the nearest source code location corresponding to
2922 the address SECTION + OFFSET.
2923 Returns TRUE if the line is found without error and fills in
2924 FILENAME_PTR and LINENUMBER_PTR. In the case where SYMBOL was
2925 NULL the FUNCTIONNAME_PTR is also filled in.
2926 SYMBOLS contains the symbol table for ABFD.
2927 ADDR_SIZE is the number of bytes in the initial .debug_info length
2928 field and in the abbreviation offset, or zero to indicate that the
2929 default value should be used. */
2932 find_line (bfd
*abfd
,
2937 const char **filename_ptr
,
2938 const char **functionname_ptr
,
2939 unsigned int *linenumber_ptr
,
2940 unsigned int addr_size
,
2943 /* Read each compilation unit from the section .debug_info, and check
2944 to see if it contains the address we are searching for. If yes,
2945 lookup the address, and return the line number info. If no, go
2946 on to the next compilation unit.
2948 We keep a list of all the previously read compilation units, and
2949 a pointer to the next un-read compilation unit. Check the
2950 previously read units before reading more. */
2951 struct dwarf2_debug
*stash
;
2952 /* What address are we looking for? */
2954 struct comp_unit
* each
;
2955 bfd_vma found
= FALSE
;
2956 bfd_boolean do_line
;
2958 stash
= (struct dwarf2_debug
*) *pinfo
;
2962 bfd_size_type amt
= sizeof (struct dwarf2_debug
);
2964 stash
= (struct dwarf2_debug
*) bfd_zalloc (abfd
, amt
);
2969 /* In a relocatable file, 2 functions may have the same address.
2970 We change the section vma so that they won't overlap. */
2971 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2973 if (! place_sections (abfd
, stash
))
2977 do_line
= (section
== NULL
2979 && functionname_ptr
== NULL
2983 addr
= symbol
->value
;
2984 section
= bfd_get_section (symbol
);
2986 else if (section
!= NULL
2987 && functionname_ptr
!= NULL
2993 if (section
->output_section
)
2994 addr
+= section
->output_section
->vma
+ section
->output_offset
;
2996 addr
+= section
->vma
;
2997 *filename_ptr
= NULL
;
2999 *functionname_ptr
= NULL
;
3000 *linenumber_ptr
= 0;
3005 bfd_size_type total_size
;
3010 msec
= find_debug_info (abfd
, NULL
);
3013 char * debug_filename
= bfd_follow_gnu_debuglink (abfd
, DEBUGDIR
);
3015 if (debug_filename
== NULL
)
3016 /* No dwarf2 info, and no gnu_debuglink to follow.
3017 Note that at this point the stash has been allocated, but
3018 contains zeros. This lets future calls to this function
3019 fail more quickly. */
3022 if ((debug_bfd
= bfd_openr (debug_filename
, NULL
)) == NULL
3023 || ! bfd_check_format (debug_bfd
, bfd_object
)
3024 || (msec
= find_debug_info (debug_bfd
, NULL
)) == NULL
)
3027 bfd_close (debug_bfd
);
3028 /* FIXME: Should we report our failure to follow the debuglink ? */
3029 free (debug_filename
);
3036 /* There can be more than one DWARF2 info section in a BFD these
3037 days. First handle the easy case when there's only one. If
3038 there's more than one, try case two: none of the sections is
3039 compressed. In that case, read them all in and produce one
3040 large stash. We do this in two passes - in the first pass we
3041 just accumulate the section sizes, and in the second pass we
3042 read in the section's contents. (The allows us to avoid
3043 reallocing the data as we add sections to the stash.) If
3044 some or all sections are compressed, then do things the slow
3045 way, with a bunch of reallocs. */
3047 if (! find_debug_info (debug_bfd
, msec
))
3049 /* Case 1: only one info section. */
3050 total_size
= msec
->size
;
3051 if (! read_section (debug_bfd
, ".debug_info", ".zdebug_info",
3053 &stash
->info_ptr_memory
, &total_size
))
3058 int all_uncompressed
= 1;
3059 for (total_size
= 0; msec
; msec
= find_debug_info (debug_bfd
, msec
))
3061 total_size
+= msec
->size
;
3062 if (strcmp (msec
->name
, DWARF2_COMPRESSED_DEBUG_INFO
) == 0)
3063 all_uncompressed
= 0;
3065 if (all_uncompressed
)
3067 /* Case 2: multiple sections, but none is compressed. */
3068 stash
->info_ptr_memory
= (bfd_byte
*) bfd_malloc (total_size
);
3069 if (stash
->info_ptr_memory
== NULL
)
3073 for (msec
= find_debug_info (debug_bfd
, NULL
);
3075 msec
= find_debug_info (debug_bfd
, msec
))
3083 if (!(bfd_simple_get_relocated_section_contents
3084 (debug_bfd
, msec
, stash
->info_ptr_memory
+ total_size
,
3093 /* Case 3: multiple sections, some or all compressed. */
3094 stash
->info_ptr_memory
= NULL
;
3096 for (msec
= find_debug_info (debug_bfd
, NULL
);
3098 msec
= find_debug_info (debug_bfd
, msec
))
3100 bfd_size_type size
= msec
->size
;
3106 buffer
= (bfd_simple_get_relocated_section_contents
3107 (debug_bfd
, msec
, NULL
, symbols
));
3111 if (strcmp (msec
->name
, DWARF2_COMPRESSED_DEBUG_INFO
) == 0)
3113 if (! bfd_uncompress_section_contents (&buffer
, &size
))
3119 stash
->info_ptr_memory
= (bfd_byte
*)
3120 bfd_realloc (stash
->info_ptr_memory
, total_size
+ size
);
3121 memcpy (stash
->info_ptr_memory
+ total_size
, buffer
, size
);
3128 stash
->info_ptr
= stash
->info_ptr_memory
;
3129 stash
->info_ptr_end
= stash
->info_ptr
+ total_size
;
3130 stash
->sec
= find_debug_info (debug_bfd
, NULL
);
3131 stash
->sec_info_ptr
= stash
->info_ptr
;
3132 stash
->syms
= symbols
;
3133 stash
->bfd_ptr
= debug_bfd
;
3136 /* A null info_ptr indicates that there is no dwarf2 info
3137 (or that an error occured while setting up the stash). */
3138 if (! stash
->info_ptr
)
3141 stash
->inliner_chain
= NULL
;
3143 /* Check the previously read comp. units first. */
3146 /* The info hash tables use quite a bit of memory. We may not want to
3147 always use them. We use some heuristics to decide if and when to
3149 if (stash
->info_hash_status
== STASH_INFO_HASH_OFF
)
3150 stash_maybe_enable_info_hash_tables (abfd
, stash
);
3152 /* Keep info hash table up to date if they are available. Note that we
3153 may disable the hash tables if there is any error duing update. */
3154 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
3155 stash_maybe_update_info_hash_tables (stash
);
3157 if (stash
->info_hash_status
== STASH_INFO_HASH_ON
)
3159 found
= stash_find_line_fast (stash
, symbol
, addr
, filename_ptr
,
3166 /* Check the previously read comp. units first. */
3167 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
3168 if ((symbol
->flags
& BSF_FUNCTION
) == 0
3169 || comp_unit_contains_address (each
, addr
))
3171 found
= comp_unit_find_line (each
, symbol
, addr
, filename_ptr
,
3172 linenumber_ptr
, stash
);
3180 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
3182 found
= (comp_unit_contains_address (each
, addr
)
3183 && comp_unit_find_nearest_line (each
, addr
,
3193 /* The DWARF2 spec says that the initial length field, and the
3194 offset of the abbreviation table, should both be 4-byte values.
3195 However, some compilers do things differently. */
3198 BFD_ASSERT (addr_size
== 4 || addr_size
== 8);
3200 /* Read each remaining comp. units checking each as they are read. */
3201 while (stash
->info_ptr
< stash
->info_ptr_end
)
3204 unsigned int offset_size
= addr_size
;
3205 bfd_byte
*info_ptr_unit
= stash
->info_ptr
;
3207 length
= read_4_bytes (stash
->bfd_ptr
, stash
->info_ptr
);
3208 /* A 0xffffff length is the DWARF3 way of indicating
3209 we use 64-bit offsets, instead of 32-bit offsets. */
3210 if (length
== 0xffffffff)
3213 length
= read_8_bytes (stash
->bfd_ptr
, stash
->info_ptr
+ 4);
3214 stash
->info_ptr
+= 12;
3216 /* A zero length is the IRIX way of indicating 64-bit offsets,
3217 mostly because the 64-bit length will generally fit in 32
3218 bits, and the endianness helps. */
3219 else if (length
== 0)
3222 length
= read_4_bytes (stash
->bfd_ptr
, stash
->info_ptr
+ 4);
3223 stash
->info_ptr
+= 8;
3225 /* In the absence of the hints above, we assume 32-bit DWARF2
3226 offsets even for targets with 64-bit addresses, because:
3227 a) most of the time these targets will not have generated
3228 more than 2Gb of debug info and so will not need 64-bit
3231 b) if they do use 64-bit offsets but they are not using
3232 the size hints that are tested for above then they are
3233 not conforming to the DWARF3 standard anyway. */
3234 else if (addr_size
== 8)
3237 stash
->info_ptr
+= 4;
3240 stash
->info_ptr
+= 4;
3244 each
= parse_comp_unit (stash
, length
, info_ptr_unit
,
3247 /* The dwarf information is damaged, don't trust it any
3250 stash
->info_ptr
+= length
;
3252 if (stash
->all_comp_units
)
3253 stash
->all_comp_units
->prev_unit
= each
;
3255 stash
->last_comp_unit
= each
;
3257 each
->next_unit
= stash
->all_comp_units
;
3258 stash
->all_comp_units
= each
;
3260 /* DW_AT_low_pc and DW_AT_high_pc are optional for
3261 compilation units. If we don't have them (i.e.,
3262 unit->high == 0), we need to consult the line info table
3263 to see if a compilation unit contains the given
3266 found
= (((symbol
->flags
& BSF_FUNCTION
) == 0
3267 || each
->arange
.high
== 0
3268 || comp_unit_contains_address (each
, addr
))
3269 && comp_unit_find_line (each
, symbol
, addr
,
3274 found
= ((each
->arange
.high
== 0
3275 || comp_unit_contains_address (each
, addr
))
3276 && comp_unit_find_nearest_line (each
, addr
,
3282 if ((bfd_vma
) (stash
->info_ptr
- stash
->sec_info_ptr
)
3283 == stash
->sec
->size
)
3285 stash
->sec
= find_debug_info (stash
->bfd_ptr
, stash
->sec
);
3286 stash
->sec_info_ptr
= stash
->info_ptr
;
3295 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
3296 unset_sections (stash
);
3301 /* The DWARF2 version of find_nearest_line.
3302 Return TRUE if the line is found without error. */
3305 _bfd_dwarf2_find_nearest_line (bfd
*abfd
,
3309 const char **filename_ptr
,
3310 const char **functionname_ptr
,
3311 unsigned int *linenumber_ptr
,
3312 unsigned int addr_size
,
3315 return find_line (abfd
, section
, offset
, NULL
, symbols
, filename_ptr
,
3316 functionname_ptr
, linenumber_ptr
, addr_size
,
3320 /* The DWARF2 version of find_line.
3321 Return TRUE if the line is found without error. */
3324 _bfd_dwarf2_find_line (bfd
*abfd
,
3327 const char **filename_ptr
,
3328 unsigned int *linenumber_ptr
,
3329 unsigned int addr_size
,
3332 return find_line (abfd
, NULL
, 0, symbol
, symbols
, filename_ptr
,
3333 NULL
, linenumber_ptr
, addr_size
,
3338 _bfd_dwarf2_find_inliner_info (bfd
*abfd ATTRIBUTE_UNUSED
,
3339 const char **filename_ptr
,
3340 const char **functionname_ptr
,
3341 unsigned int *linenumber_ptr
,
3344 struct dwarf2_debug
*stash
;
3346 stash
= (struct dwarf2_debug
*) *pinfo
;
3349 struct funcinfo
*func
= stash
->inliner_chain
;
3351 if (func
&& func
->caller_func
)
3353 *filename_ptr
= func
->caller_file
;
3354 *functionname_ptr
= func
->caller_func
->name
;
3355 *linenumber_ptr
= func
->caller_line
;
3356 stash
->inliner_chain
= func
->caller_func
;
3365 _bfd_dwarf2_cleanup_debug_info (bfd
*abfd
)
3367 struct comp_unit
*each
;
3368 struct dwarf2_debug
*stash
;
3370 if (abfd
== NULL
|| elf_tdata (abfd
) == NULL
)
3373 stash
= (struct dwarf2_debug
*) elf_tdata (abfd
)->dwarf2_find_line_info
;
3378 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
3380 struct abbrev_info
**abbrevs
= each
->abbrevs
;
3381 struct funcinfo
*function_table
= each
->function_table
;
3382 struct varinfo
*variable_table
= each
->variable_table
;
3385 for (i
= 0; i
< ABBREV_HASH_SIZE
; i
++)
3387 struct abbrev_info
*abbrev
= abbrevs
[i
];
3391 free (abbrev
->attrs
);
3392 abbrev
= abbrev
->next
;
3396 if (each
->line_table
)
3398 free (each
->line_table
->dirs
);
3399 free (each
->line_table
->files
);
3402 while (function_table
)
3404 if (function_table
->file
)
3406 free (function_table
->file
);
3407 function_table
->file
= NULL
;
3410 if (function_table
->caller_file
)
3412 free (function_table
->caller_file
);
3413 function_table
->caller_file
= NULL
;
3415 function_table
= function_table
->prev_func
;
3418 while (variable_table
)
3420 if (variable_table
->file
)
3422 free (variable_table
->file
);
3423 variable_table
->file
= NULL
;
3426 variable_table
= variable_table
->prev_var
;
3430 if (stash
->dwarf_abbrev_buffer
)
3431 free (stash
->dwarf_abbrev_buffer
);
3432 if (stash
->dwarf_line_buffer
)
3433 free (stash
->dwarf_line_buffer
);
3434 if (stash
->dwarf_str_buffer
)
3435 free (stash
->dwarf_str_buffer
);
3436 if (stash
->dwarf_ranges_buffer
)
3437 free (stash
->dwarf_ranges_buffer
);
3438 if (stash
->info_ptr_memory
)
3439 free (stash
->info_ptr_memory
);