2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
3 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
34 #include "libiberty.h"
37 #include "elf/dwarf2.h"
39 /* The data in the .debug_line statement prologue looks like this. */
44 unsigned short version
;
45 bfd_vma prologue_length
;
46 unsigned char minimum_instruction_length
;
47 unsigned char default_is_stmt
;
49 unsigned char line_range
;
50 unsigned char opcode_base
;
51 unsigned char *standard_opcode_lengths
;
54 /* Attributes have a name and a value. */
58 enum dwarf_attribute name
;
63 struct dwarf_block
*blk
;
71 /* Get at parts of an attribute structure. */
73 #define DW_STRING(attr) ((attr)->u.str)
74 #define DW_UNSND(attr) ((attr)->u.unsnd)
75 #define DW_BLOCK(attr) ((attr)->u.blk)
76 #define DW_SND(attr) ((attr)->u.snd)
77 #define DW_ADDR(attr) ((attr)->u.addr)
79 /* Blocks are a bunch of untyped bytes. */
88 /* A list of all previously read comp_units. */
89 struct comp_unit
* all_comp_units
;
91 /* The next unread compilation unit within the .debug_info section.
92 Zero indicates that the .debug_info section has not been loaded
96 /* Pointer to the end of the .debug_info section memory buffer. */
99 /* Pointer to the section and address of the beginning of the
104 /* Pointer to the symbol table. */
107 /* Pointer to the .debug_abbrev section loaded into memory. */
108 char* dwarf_abbrev_buffer
;
110 /* Length of the loaded .debug_abbrev section. */
111 unsigned long dwarf_abbrev_size
;
113 /* Buffer for decode_line_info. */
114 char *dwarf_line_buffer
;
116 /* Length of the loaded .debug_line section. */
117 unsigned long dwarf_line_size
;
119 /* Pointer to the .debug_str section loaded into memory. */
120 char* dwarf_str_buffer
;
122 /* Length of the loaded .debug_str section. */
123 unsigned long dwarf_str_size
;
133 /* A minimal decoding of DWARF2 compilation units. We only decode
134 what's needed to get to the line number information. */
138 /* Chain the previously read compilation units. */
139 struct comp_unit
* next_unit
;
141 /* Keep the bdf convenient (for memory allocation). */
144 /* The lowest and higest addresses contained in this compilation
145 unit as specified in the compilation unit header. */
146 struct arange arange
;
148 /* The DW_AT_name attribute (for error messages). */
151 /* The abbrev hash table. */
152 struct abbrev_info
** abbrevs
;
154 /* Note that an error was found by comp_unit_find_nearest_line. */
157 /* The DW_AT_comp_dir attribute. */
160 /* True if there is a line number table associated with this comp. unit. */
163 /* The offset into .debug_line of the line number table. */
164 unsigned long line_offset
;
166 /* Pointer to the first child die for the comp unit. */
167 char *first_child_die_ptr
;
169 /* The end of the comp unit. */
172 /* The decoded line number, NULL if not yet decoded. */
173 struct line_info_table
* line_table
;
175 /* A list of the functions found in this comp. unit. */
176 struct funcinfo
* function_table
;
178 /* Pointer to dwarf2_debug structure. */
179 struct dwarf2_debug
*stash
;
181 /* Address size for this unit - from unit header. */
182 unsigned char addr_size
;
184 /* Offset size for this unit - from unit header. */
185 unsigned char offset_size
;
188 /* This data structure holds the information of an abbrev. */
191 unsigned int number
; /* Number identifying abbrev. */
192 enum dwarf_tag tag
; /* DWARF tag. */
193 int has_children
; /* Boolean. */
194 unsigned int num_attrs
; /* Number of attributes. */
195 struct attr_abbrev
*attrs
; /* An array of attribute descriptions. */
196 struct abbrev_info
*next
; /* Next in chain. */
201 enum dwarf_attribute name
;
202 enum dwarf_form form
;
205 #ifndef ABBREV_HASH_SIZE
206 #define ABBREV_HASH_SIZE 121
208 #ifndef ATTR_ALLOC_CHUNK
209 #define ATTR_ALLOC_CHUNK 4
212 static unsigned int read_1_byte
PARAMS ((bfd
*, char *));
213 static int read_1_signed_byte
PARAMS ((bfd
*, char *));
214 static unsigned int read_2_bytes
PARAMS ((bfd
*, char *));
215 static unsigned int read_4_bytes
PARAMS ((bfd
*, char *));
216 static bfd_vma read_8_bytes
PARAMS ((bfd
*, char *));
217 static char *read_n_bytes
PARAMS ((bfd
*, char *, unsigned int));
218 static char *read_string
PARAMS ((bfd
*, char *, unsigned int *));
219 static char *read_indirect_string
PARAMS ((struct comp_unit
*, char *, unsigned int *));
220 static unsigned int read_unsigned_leb128
221 PARAMS ((bfd
*, char *, unsigned int *));
222 static int read_signed_leb128
223 PARAMS ((bfd
*, char *, unsigned int *));
224 static bfd_vma read_address
PARAMS ((struct comp_unit
*, char *));
225 static struct abbrev_info
*lookup_abbrev
226 PARAMS ((unsigned int, struct abbrev_info
**));
227 static struct abbrev_info
**read_abbrevs
228 PARAMS ((bfd
*, bfd_vma
, struct dwarf2_debug
*));
229 static char *read_attribute
230 PARAMS ((struct attribute
*, struct attr_abbrev
*,
231 struct comp_unit
*, char *));
232 static char *read_attribute_value
233 PARAMS ((struct attribute
*, unsigned,
234 struct comp_unit
*, char *));
235 static void add_line_info
236 PARAMS ((struct line_info_table
*, bfd_vma
, char *,
237 unsigned int, unsigned int, int));
238 static char *concat_filename
PARAMS ((struct line_info_table
*, unsigned int));
239 static void arange_add
PARAMS ((struct comp_unit
*, bfd_vma
, bfd_vma
));
240 static struct line_info_table
*decode_line_info
241 PARAMS ((struct comp_unit
*, struct dwarf2_debug
*));
242 static boolean lookup_address_in_line_info_table
243 PARAMS ((struct line_info_table
*, bfd_vma
, struct funcinfo
*,
244 const char **, unsigned int *));
245 static boolean lookup_address_in_function_table
246 PARAMS ((struct funcinfo
*, bfd_vma
, struct funcinfo
**, const char **));
247 static boolean scan_unit_for_functions
PARAMS ((struct comp_unit
*));
248 static bfd_vma find_rela_addend
249 PARAMS ((bfd
*, asection
*, bfd_size_type
, asymbol
**));
250 static struct comp_unit
*parse_comp_unit
251 PARAMS ((bfd
*, struct dwarf2_debug
*, bfd_vma
, unsigned int));
252 static boolean comp_unit_contains_address
253 PARAMS ((struct comp_unit
*, bfd_vma
));
254 static boolean comp_unit_find_nearest_line
255 PARAMS ((struct comp_unit
*, bfd_vma
, const char **, const char **,
256 unsigned int *, struct dwarf2_debug
*));
257 static asection
*find_debug_info
PARAMS ((bfd
*, asection
*));
260 The following function up to the END VERBATIM mark are
261 copied directly from dwarf2read.c. */
263 /* Read dwarf information from a buffer. */
266 read_1_byte (abfd
, buf
)
267 bfd
*abfd ATTRIBUTE_UNUSED
;
270 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
274 read_1_signed_byte (abfd
, buf
)
275 bfd
*abfd ATTRIBUTE_UNUSED
;
278 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
282 read_2_bytes (abfd
, buf
)
286 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
289 #if 0 /* This is not used. */
292 read_2_signed_bytes (abfd
, buf
)
296 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
302 read_4_bytes (abfd
, buf
)
306 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
309 #if 0 /* This is not used. */
312 read_4_signed_bytes (abfd
, buf
)
316 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
322 read_8_bytes (abfd
, buf
)
326 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
330 read_n_bytes (abfd
, buf
, size
)
331 bfd
*abfd ATTRIBUTE_UNUSED
;
333 unsigned int size ATTRIBUTE_UNUSED
;
335 /* If the size of a host char is 8 bits, we can return a pointer
336 to the buffer, otherwise we have to copy the data to a buffer
337 allocated on the temporary obstack. */
342 read_string (abfd
, buf
, bytes_read_ptr
)
343 bfd
*abfd ATTRIBUTE_UNUSED
;
345 unsigned int *bytes_read_ptr
;
347 /* Return a pointer to the embedded string. */
354 *bytes_read_ptr
= strlen (buf
) + 1;
359 read_indirect_string (unit
, buf
, bytes_read_ptr
)
360 struct comp_unit
* unit
;
362 unsigned int *bytes_read_ptr
;
365 struct dwarf2_debug
*stash
= unit
->stash
;
367 if (unit
->offset_size
== 4)
368 offset
= read_4_bytes (unit
->abfd
, buf
);
370 offset
= read_8_bytes (unit
->abfd
, buf
);
371 *bytes_read_ptr
= unit
->offset_size
;
373 if (! stash
->dwarf_str_buffer
)
376 bfd
*abfd
= unit
->abfd
;
378 msec
= bfd_get_section_by_name (abfd
, ".debug_str");
381 (*_bfd_error_handler
)
382 (_("Dwarf Error: Can't find .debug_str section."));
383 bfd_set_error (bfd_error_bad_value
);
387 stash
->dwarf_str_size
= msec
->_raw_size
;
388 stash
->dwarf_str_buffer
= (char*) bfd_alloc (abfd
, msec
->_raw_size
);
389 if (! stash
->dwarf_abbrev_buffer
)
392 if (! bfd_get_section_contents (abfd
, msec
, stash
->dwarf_str_buffer
,
393 (bfd_vma
) 0, msec
->_raw_size
))
397 if (offset
>= stash
->dwarf_str_size
)
399 (*_bfd_error_handler
) (_("Dwarf Error: DW_FORM_strp offset (%lu) greater than or equal to .debug_str size (%lu)."),
400 (unsigned long) offset
, stash
->dwarf_str_size
);
401 bfd_set_error (bfd_error_bad_value
);
405 buf
= stash
->dwarf_str_buffer
+ offset
;
412 read_unsigned_leb128 (abfd
, buf
, bytes_read_ptr
)
413 bfd
*abfd ATTRIBUTE_UNUSED
;
415 unsigned int *bytes_read_ptr
;
418 unsigned int num_read
;
428 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
431 result
|= ((byte
& 0x7f) << shift
);
436 * bytes_read_ptr
= num_read
;
442 read_signed_leb128 (abfd
, buf
, bytes_read_ptr
)
443 bfd
*abfd ATTRIBUTE_UNUSED
;
445 unsigned int * bytes_read_ptr
;
458 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
461 result
|= ((byte
& 0x7f) << shift
);
466 if ((shift
< 32) && (byte
& 0x40))
467 result
|= -(1 << shift
);
469 * bytes_read_ptr
= num_read
;
477 read_address (unit
, buf
)
478 struct comp_unit
* unit
;
481 switch (unit
->addr_size
)
484 return bfd_get_64 (unit
->abfd
, (bfd_byte
*) buf
);
486 return bfd_get_32 (unit
->abfd
, (bfd_byte
*) buf
);
488 return bfd_get_16 (unit
->abfd
, (bfd_byte
*) buf
);
494 /* Lookup an abbrev_info structure in the abbrev hash table. */
496 static struct abbrev_info
*
497 lookup_abbrev (number
,abbrevs
)
499 struct abbrev_info
**abbrevs
;
501 unsigned int hash_number
;
502 struct abbrev_info
*abbrev
;
504 hash_number
= number
% ABBREV_HASH_SIZE
;
505 abbrev
= abbrevs
[hash_number
];
509 if (abbrev
->number
== number
)
512 abbrev
= abbrev
->next
;
518 /* In DWARF version 2, the description of the debugging information is
519 stored in a separate .debug_abbrev section. Before we read any
520 dies from a section we read in all abbreviations and install them
523 static struct abbrev_info
**
524 read_abbrevs (abfd
, offset
, stash
)
527 struct dwarf2_debug
*stash
;
529 struct abbrev_info
**abbrevs
;
531 struct abbrev_info
*cur_abbrev
;
532 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
533 unsigned int abbrev_form
, hash_number
;
536 if (! stash
->dwarf_abbrev_buffer
)
540 msec
= bfd_get_section_by_name (abfd
, ".debug_abbrev");
543 (*_bfd_error_handler
) (_("Dwarf Error: Can't find .debug_abbrev section."));
544 bfd_set_error (bfd_error_bad_value
);
548 stash
->dwarf_abbrev_size
= msec
->_raw_size
;
549 stash
->dwarf_abbrev_buffer
= (char*) bfd_alloc (abfd
, msec
->_raw_size
);
550 if (! stash
->dwarf_abbrev_buffer
)
553 if (! bfd_get_section_contents (abfd
, msec
, stash
->dwarf_abbrev_buffer
,
554 (bfd_vma
) 0, msec
->_raw_size
))
558 if (offset
>= stash
->dwarf_abbrev_size
)
560 (*_bfd_error_handler
) (_("Dwarf Error: Abbrev offset (%lu) greater than or equal to .debug_abbrev size (%lu)."),
561 (unsigned long) offset
, stash
->dwarf_abbrev_size
);
562 bfd_set_error (bfd_error_bad_value
);
566 amt
= sizeof (struct abbrev_info
*) * ABBREV_HASH_SIZE
;
567 abbrevs
= (struct abbrev_info
**) bfd_zalloc (abfd
, amt
);
569 abbrev_ptr
= stash
->dwarf_abbrev_buffer
+ offset
;
570 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
571 abbrev_ptr
+= bytes_read
;
573 /* Loop until we reach an abbrev number of 0. */
574 while (abbrev_number
)
576 amt
= sizeof (struct abbrev_info
);
577 cur_abbrev
= (struct abbrev_info
*) bfd_zalloc (abfd
, amt
);
579 /* Read in abbrev header. */
580 cur_abbrev
->number
= abbrev_number
;
581 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
582 abbrev_ptr
+= bytes_read
;
583 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
586 /* Now read in declarations. */
587 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
588 abbrev_ptr
+= bytes_read
;
589 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
590 abbrev_ptr
+= bytes_read
;
594 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
596 amt
= cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
;
597 amt
*= sizeof (struct attr_abbrev
);
598 cur_abbrev
->attrs
= ((struct attr_abbrev
*)
599 bfd_realloc (cur_abbrev
->attrs
, amt
));
600 if (! cur_abbrev
->attrs
)
604 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
605 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
606 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
607 abbrev_ptr
+= bytes_read
;
608 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
609 abbrev_ptr
+= bytes_read
;
612 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
613 cur_abbrev
->next
= abbrevs
[hash_number
];
614 abbrevs
[hash_number
] = cur_abbrev
;
616 /* Get next abbreviation.
617 Under Irix6 the abbreviations for a compilation unit are not
618 always properly terminated with an abbrev number of 0.
619 Exit loop if we encounter an abbreviation which we have
620 already read (which means we are about to read the abbreviations
621 for the next compile unit) or if the end of the abbreviation
623 if ((unsigned int) (abbrev_ptr
- stash
->dwarf_abbrev_buffer
)
624 >= stash
->dwarf_abbrev_size
)
626 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
627 abbrev_ptr
+= bytes_read
;
628 if (lookup_abbrev (abbrev_number
,abbrevs
) != NULL
)
635 /* Read an attribute value described by an attribute form. */
638 read_attribute_value (attr
, form
, unit
, info_ptr
)
639 struct attribute
*attr
;
641 struct comp_unit
*unit
;
644 bfd
*abfd
= unit
->abfd
;
645 unsigned int bytes_read
;
646 struct dwarf_block
*blk
;
654 /* FIXME: DWARF3 draft sais DW_FORM_ref_addr is offset_size. */
655 case DW_FORM_ref_addr
:
656 DW_ADDR (attr
) = read_address (unit
, info_ptr
);
657 info_ptr
+= unit
->addr_size
;
660 amt
= sizeof (struct dwarf_block
);
661 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
662 blk
->size
= read_2_bytes (abfd
, info_ptr
);
664 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
665 info_ptr
+= blk
->size
;
666 DW_BLOCK (attr
) = blk
;
669 amt
= sizeof (struct dwarf_block
);
670 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
671 blk
->size
= read_4_bytes (abfd
, info_ptr
);
673 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
674 info_ptr
+= blk
->size
;
675 DW_BLOCK (attr
) = blk
;
678 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
682 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
686 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
690 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
691 info_ptr
+= bytes_read
;
694 DW_STRING (attr
) = read_indirect_string (unit
, info_ptr
, &bytes_read
);
695 info_ptr
+= bytes_read
;
698 amt
= sizeof (struct dwarf_block
);
699 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
700 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
701 info_ptr
+= bytes_read
;
702 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
703 info_ptr
+= blk
->size
;
704 DW_BLOCK (attr
) = blk
;
707 amt
= sizeof (struct dwarf_block
);
708 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
709 blk
->size
= read_1_byte (abfd
, info_ptr
);
711 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
712 info_ptr
+= blk
->size
;
713 DW_BLOCK (attr
) = blk
;
716 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
720 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
724 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
725 info_ptr
+= bytes_read
;
728 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
729 info_ptr
+= bytes_read
;
732 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
736 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
740 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
744 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
747 case DW_FORM_ref_udata
:
748 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
749 info_ptr
+= bytes_read
;
751 case DW_FORM_indirect
:
752 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
753 info_ptr
+= bytes_read
;
754 info_ptr
= read_attribute_value (attr
, form
, unit
, info_ptr
);
757 (*_bfd_error_handler
) (_("Dwarf Error: Invalid or unhandled FORM value: %u."),
759 bfd_set_error (bfd_error_bad_value
);
764 /* Read an attribute described by an abbreviated attribute. */
767 read_attribute (attr
, abbrev
, unit
, info_ptr
)
768 struct attribute
*attr
;
769 struct attr_abbrev
*abbrev
;
770 struct comp_unit
*unit
;
773 attr
->name
= abbrev
->name
;
774 info_ptr
= read_attribute_value (attr
, abbrev
->form
, unit
, info_ptr
);
778 /* Source line information table routines. */
780 #define FILE_ALLOC_CHUNK 5
781 #define DIR_ALLOC_CHUNK 5
785 struct line_info
* prev_line
;
790 int end_sequence
; /* End of (sequential) code sequence. */
801 struct line_info_table
804 unsigned int num_files
;
805 unsigned int num_dirs
;
808 struct fileinfo
* files
;
809 struct line_info
* last_line
;
814 struct funcinfo
*prev_func
;
821 add_line_info (table
, address
, filename
, line
, column
, end_sequence
)
822 struct line_info_table
* table
;
829 bfd_size_type amt
= sizeof (struct line_info
);
830 struct line_info
* info
= (struct line_info
*) bfd_alloc (table
->abfd
, amt
);
832 info
->prev_line
= table
->last_line
;
833 table
->last_line
= info
;
835 info
->address
= address
;
836 info
->filename
= filename
;
838 info
->column
= column
;
839 info
->end_sequence
= end_sequence
;
843 concat_filename (table
, file
)
844 struct line_info_table
* table
;
849 if (file
- 1 >= table
->num_files
)
851 (*_bfd_error_handler
)
852 (_("Dwarf Error: mangled line number section (bad file number)."));
856 filename
= table
->files
[file
- 1].name
;
857 if (IS_ABSOLUTE_PATH(filename
))
862 char* dirname
= (table
->files
[file
- 1].dir
863 ? table
->dirs
[table
->files
[file
- 1].dir
- 1]
865 return (char*) concat (dirname
, "/", filename
, NULL
);
870 arange_add (unit
, low_pc
, high_pc
)
871 struct comp_unit
*unit
;
875 struct arange
*arange
;
877 /* First see if we can cheaply extend an existing range. */
878 arange
= &unit
->arange
;
882 if (low_pc
== arange
->high
)
884 arange
->high
= high_pc
;
887 if (high_pc
== arange
->low
)
889 arange
->low
= low_pc
;
892 arange
= arange
->next
;
896 if (unit
->arange
.high
== 0)
898 /* This is the first address range: store it in unit->arange. */
899 unit
->arange
.next
= 0;
900 unit
->arange
.low
= low_pc
;
901 unit
->arange
.high
= high_pc
;
905 /* Need to allocate a new arange and insert it into the arange list. */
906 arange
= bfd_zalloc (unit
->abfd
, (bfd_size_type
) sizeof (*arange
));
907 arange
->low
= low_pc
;
908 arange
->high
= high_pc
;
910 arange
->next
= unit
->arange
.next
;
911 unit
->arange
.next
= arange
;
914 /* Decode the line number information for UNIT. */
916 static struct line_info_table
*
917 decode_line_info (unit
, stash
)
918 struct comp_unit
*unit
;
919 struct dwarf2_debug
*stash
;
921 bfd
*abfd
= unit
->abfd
;
922 struct line_info_table
* table
;
926 unsigned int i
, bytes_read
, offset_size
;
927 char *cur_file
, *cur_dir
;
928 unsigned char op_code
, extended_op
, adj_opcode
;
931 if (! stash
->dwarf_line_buffer
)
935 msec
= bfd_get_section_by_name (abfd
, ".debug_line");
938 (*_bfd_error_handler
) (_("Dwarf Error: Can't find .debug_line section."));
939 bfd_set_error (bfd_error_bad_value
);
943 stash
->dwarf_line_size
= msec
->_raw_size
;
944 stash
->dwarf_line_buffer
= (char *) bfd_alloc (abfd
, msec
->_raw_size
);
945 if (! stash
->dwarf_line_buffer
)
948 if (! bfd_get_section_contents (abfd
, msec
, stash
->dwarf_line_buffer
,
949 (bfd_vma
) 0, msec
->_raw_size
))
952 /* FIXME: We ought to apply the relocs against this section before
956 /* Since we are using un-relocated data, it is possible to get a bad value
957 for the line_offset. Validate it here so that we won't get a segfault
959 if (unit
->line_offset
>= stash
->dwarf_line_size
)
961 (*_bfd_error_handler
) (_("Dwarf Error: Line offset (%lu) greater than or equal to .debug_line size (%lu)."),
962 unit
->line_offset
, stash
->dwarf_line_size
);
963 bfd_set_error (bfd_error_bad_value
);
967 amt
= sizeof (struct line_info_table
);
968 table
= (struct line_info_table
*) bfd_alloc (abfd
, amt
);
970 table
->comp_dir
= unit
->comp_dir
;
972 table
->num_files
= 0;
979 table
->last_line
= NULL
;
981 line_ptr
= stash
->dwarf_line_buffer
+ unit
->line_offset
;
983 /* Read in the prologue. */
984 lh
.total_length
= read_4_bytes (abfd
, line_ptr
);
987 if (lh
.total_length
== 0xffffffff)
989 lh
.total_length
= read_8_bytes (abfd
, line_ptr
);
993 else if (lh
.total_length
== 0 && unit
->addr_size
== 8)
995 /* Handle (non-standard) 64-bit DWARF2 formats. */
996 lh
.total_length
= read_4_bytes (abfd
, line_ptr
);
1000 line_end
= line_ptr
+ lh
.total_length
;
1001 lh
.version
= read_2_bytes (abfd
, line_ptr
);
1003 if (offset_size
== 4)
1004 lh
.prologue_length
= read_4_bytes (abfd
, line_ptr
);
1006 lh
.prologue_length
= read_8_bytes (abfd
, line_ptr
);
1007 line_ptr
+= offset_size
;
1008 lh
.minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
1010 lh
.default_is_stmt
= read_1_byte (abfd
, line_ptr
);
1012 lh
.line_base
= read_1_signed_byte (abfd
, line_ptr
);
1014 lh
.line_range
= read_1_byte (abfd
, line_ptr
);
1016 lh
.opcode_base
= read_1_byte (abfd
, line_ptr
);
1018 amt
= lh
.opcode_base
* sizeof (unsigned char);
1019 lh
.standard_opcode_lengths
= (unsigned char *) bfd_alloc (abfd
, amt
);
1021 lh
.standard_opcode_lengths
[0] = 1;
1023 for (i
= 1; i
< lh
.opcode_base
; ++i
)
1025 lh
.standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
1029 /* Read directory table. */
1030 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
1032 line_ptr
+= bytes_read
;
1034 if ((table
->num_dirs
% DIR_ALLOC_CHUNK
) == 0)
1036 amt
= table
->num_dirs
+ DIR_ALLOC_CHUNK
;
1037 amt
*= sizeof (char *);
1038 table
->dirs
= (char **) bfd_realloc (table
->dirs
, amt
);
1043 table
->dirs
[table
->num_dirs
++] = cur_dir
;
1046 line_ptr
+= bytes_read
;
1048 /* Read file name table. */
1049 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
1051 line_ptr
+= bytes_read
;
1053 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
1055 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
1056 amt
*= sizeof (struct fileinfo
);
1057 table
->files
= (struct fileinfo
*) bfd_realloc (table
->files
, amt
);
1062 table
->files
[table
->num_files
].name
= cur_file
;
1063 table
->files
[table
->num_files
].dir
=
1064 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1065 line_ptr
+= bytes_read
;
1066 table
->files
[table
->num_files
].time
=
1067 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1068 line_ptr
+= bytes_read
;
1069 table
->files
[table
->num_files
].size
=
1070 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1071 line_ptr
+= bytes_read
;
1075 line_ptr
+= bytes_read
;
1077 /* Read the statement sequences until there's nothing left. */
1078 while (line_ptr
< line_end
)
1080 /* State machine registers. */
1081 bfd_vma address
= 0;
1082 char* filename
= concat_filename (table
, 1);
1083 unsigned int line
= 1;
1084 unsigned int column
= 0;
1085 int is_stmt
= lh
.default_is_stmt
;
1086 int basic_block
= 0;
1087 int end_sequence
= 0, need_low_pc
= 1;
1090 /* Decode the table. */
1091 while (! end_sequence
)
1093 op_code
= read_1_byte (abfd
, line_ptr
);
1096 if (op_code
>= lh
.opcode_base
)
1097 { /* Special operand. */
1098 adj_opcode
= op_code
- lh
.opcode_base
;
1099 address
+= (adj_opcode
/ lh
.line_range
)
1100 * lh
.minimum_instruction_length
;
1101 line
+= lh
.line_base
+ (adj_opcode
% lh
.line_range
);
1102 /* Append row to matrix using current values. */
1103 add_line_info (table
, address
, filename
, line
, column
, 0);
1111 else switch (op_code
)
1113 case DW_LNS_extended_op
:
1114 line_ptr
+= 1; /* Ignore length. */
1115 extended_op
= read_1_byte (abfd
, line_ptr
);
1117 switch (extended_op
)
1119 case DW_LNE_end_sequence
:
1121 add_line_info (table
, address
, filename
, line
, column
,
1128 arange_add (unit
, low_pc
, address
);
1130 case DW_LNE_set_address
:
1131 address
= read_address (unit
, line_ptr
);
1132 line_ptr
+= unit
->addr_size
;
1134 case DW_LNE_define_file
:
1135 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
1136 line_ptr
+= bytes_read
;
1137 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
1139 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
1140 amt
*= sizeof (struct fileinfo
);
1142 (struct fileinfo
*) bfd_realloc (table
->files
, amt
);
1146 table
->files
[table
->num_files
].name
= cur_file
;
1147 table
->files
[table
->num_files
].dir
=
1148 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1149 line_ptr
+= bytes_read
;
1150 table
->files
[table
->num_files
].time
=
1151 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1152 line_ptr
+= bytes_read
;
1153 table
->files
[table
->num_files
].size
=
1154 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1155 line_ptr
+= bytes_read
;
1159 (*_bfd_error_handler
) (_("Dwarf Error: mangled line number section."));
1160 bfd_set_error (bfd_error_bad_value
);
1165 add_line_info (table
, address
, filename
, line
, column
, 0);
1173 case DW_LNS_advance_pc
:
1174 address
+= lh
.minimum_instruction_length
1175 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1176 line_ptr
+= bytes_read
;
1178 case DW_LNS_advance_line
:
1179 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
1180 line_ptr
+= bytes_read
;
1182 case DW_LNS_set_file
:
1186 /* The file and directory tables are 0 based, the references
1188 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1189 line_ptr
+= bytes_read
;
1190 filename
= concat_filename (table
, file
);
1193 case DW_LNS_set_column
:
1194 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1195 line_ptr
+= bytes_read
;
1197 case DW_LNS_negate_stmt
:
1198 is_stmt
= (!is_stmt
);
1200 case DW_LNS_set_basic_block
:
1203 case DW_LNS_const_add_pc
:
1204 address
+= lh
.minimum_instruction_length
1205 * ((255 - lh
.opcode_base
) / lh
.line_range
);
1207 case DW_LNS_fixed_advance_pc
:
1208 address
+= read_2_bytes (abfd
, line_ptr
);
1212 { /* Unknown standard opcode, ignore it. */
1214 for (i
= 0; i
< lh
.standard_opcode_lengths
[op_code
]; i
++)
1216 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1217 line_ptr
+= bytes_read
;
1227 /* If ADDR is within TABLE set the output parameters and return true,
1228 otherwise return false. The output parameters, FILENAME_PTR and
1229 LINENUMBER_PTR, are pointers to the objects to be filled in. */
1232 lookup_address_in_line_info_table (table
,
1237 struct line_info_table
* table
;
1239 struct funcinfo
*function
;
1240 const char **filename_ptr
;
1241 unsigned int *linenumber_ptr
;
1243 struct line_info
* next_line
= table
->last_line
;
1244 struct line_info
* each_line
;
1249 each_line
= next_line
->prev_line
;
1251 while (each_line
&& next_line
)
1253 if (!each_line
->end_sequence
1254 && addr
>= each_line
->address
&& addr
< next_line
->address
)
1256 /* If this line appears to span functions, and addr is in the
1257 later function, return the first line of that function instead
1258 of the last line of the earlier one. This check is for GCC
1259 2.95, which emits the first line number for a function late. */
1260 if (function
!= NULL
1261 && each_line
->address
< function
->low
1262 && next_line
->address
> function
->low
)
1264 *filename_ptr
= next_line
->filename
;
1265 *linenumber_ptr
= next_line
->line
;
1269 *filename_ptr
= each_line
->filename
;
1270 *linenumber_ptr
= each_line
->line
;
1274 next_line
= each_line
;
1275 each_line
= each_line
->prev_line
;
1278 /* At this point each_line is NULL but next_line is not. If we found the
1279 containing function in this compilation unit, return the first line we
1280 have a number for. This is also for compatibility with GCC 2.95. */
1281 if (function
!= NULL
)
1283 *filename_ptr
= next_line
->filename
;
1284 *linenumber_ptr
= next_line
->line
;
1291 /* Function table functions. */
1293 /* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return true. */
1296 lookup_address_in_function_table (table
,
1300 struct funcinfo
* table
;
1302 struct funcinfo
** function_ptr
;
1303 const char **functionname_ptr
;
1305 struct funcinfo
* each_func
;
1307 for (each_func
= table
;
1309 each_func
= each_func
->prev_func
)
1311 if (addr
>= each_func
->low
&& addr
< each_func
->high
)
1313 *functionname_ptr
= each_func
->name
;
1314 *function_ptr
= each_func
;
1322 /* DWARF2 Compilation unit functions. */
1324 /* Scan over each die in a comp. unit looking for functions to add
1325 to the function table. */
1328 scan_unit_for_functions (unit
)
1329 struct comp_unit
*unit
;
1331 bfd
*abfd
= unit
->abfd
;
1332 char *info_ptr
= unit
->first_child_die_ptr
;
1333 int nesting_level
= 1;
1335 while (nesting_level
)
1337 unsigned int abbrev_number
, bytes_read
, i
;
1338 struct abbrev_info
*abbrev
;
1339 struct attribute attr
;
1340 struct funcinfo
*func
;
1343 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
1344 info_ptr
+= bytes_read
;
1346 if (! abbrev_number
)
1352 abbrev
= lookup_abbrev (abbrev_number
,unit
->abbrevs
);
1355 (*_bfd_error_handler
) (_("Dwarf Error: Could not find abbrev number %u."),
1357 bfd_set_error (bfd_error_bad_value
);
1361 if (abbrev
->tag
== DW_TAG_subprogram
)
1363 bfd_size_type amt
= sizeof (struct funcinfo
);
1364 func
= (struct funcinfo
*) bfd_zalloc (abfd
, amt
);
1365 func
->prev_func
= unit
->function_table
;
1366 unit
->function_table
= func
;
1371 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
1373 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
);
1381 name
= DW_STRING (&attr
);
1383 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
1384 if (func
->name
== NULL
)
1385 func
->name
= DW_STRING (&attr
);
1388 case DW_AT_MIPS_linkage_name
:
1389 func
->name
= DW_STRING (&attr
);
1393 func
->low
= DW_ADDR (&attr
);
1397 func
->high
= DW_ADDR (&attr
);
1409 name
= DW_STRING (&attr
);
1418 if (abbrev
->has_children
)
1425 /* Look for a RELA relocation to be applied on OFFSET of section SEC,
1426 and return the addend if such a relocation is found. Since this is
1427 only used to find relocations referring to the .debug_abbrev
1428 section, we make sure the relocation refers to this section, but
1429 this is not strictly necessary, and it can probably be safely
1430 removed if needed. However, it is important to note that this
1431 function only returns the addend, it doesn't serve the purpose of
1432 applying a generic relocation.
1434 If no suitable relocation is found, or if it is not a real RELA
1435 relocation, this function returns 0. */
1438 find_rela_addend (abfd
, sec
, offset
, syms
)
1441 bfd_size_type offset
;
1444 long reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
1445 arelent
**relocs
= NULL
;
1446 long reloc_count
, relc
;
1448 if (reloc_size
<= 0)
1451 relocs
= (arelent
**) bfd_malloc ((bfd_size_type
) reloc_size
);
1455 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, syms
);
1457 if (reloc_count
<= 0)
1463 for (relc
= 0; relc
< reloc_count
; relc
++)
1464 if (relocs
[relc
]->address
== offset
1465 && (*relocs
[relc
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
1466 && strcmp ((*relocs
[relc
]->sym_ptr_ptr
)->name
,
1467 ".debug_abbrev") == 0)
1469 bfd_vma addend
= (relocs
[relc
]->howto
->partial_inplace
1470 ? 0 : relocs
[relc
]->addend
);
1479 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
1480 includes the compilation unit header that proceeds the DIE's, but
1481 does not include the length field that preceeds each compilation
1482 unit header. END_PTR points one past the end of this comp unit.
1483 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
1485 This routine does not read the whole compilation unit; only enough
1486 to get to the line number information for the compilation unit. */
1488 static struct comp_unit
*
1489 parse_comp_unit (abfd
, stash
, unit_length
, offset_size
)
1491 struct dwarf2_debug
*stash
;
1492 bfd_vma unit_length
;
1493 unsigned int offset_size
;
1495 struct comp_unit
* unit
;
1496 unsigned int version
;
1497 bfd_vma abbrev_offset
= 0;
1498 unsigned int addr_size
;
1499 struct abbrev_info
** abbrevs
;
1500 unsigned int abbrev_number
, bytes_read
, i
;
1501 struct abbrev_info
*abbrev
;
1502 struct attribute attr
;
1503 char *info_ptr
= stash
->info_ptr
;
1504 char *end_ptr
= info_ptr
+ unit_length
;
1508 version
= read_2_bytes (abfd
, info_ptr
);
1510 BFD_ASSERT (offset_size
== 4 || offset_size
== 8);
1511 if (offset_size
== 4)
1512 abbrev_offset
= read_4_bytes (abfd
, info_ptr
);
1514 abbrev_offset
= read_8_bytes (abfd
, info_ptr
);
1515 /* The abbrev offset is generally a relocation pointing to
1516 .debug_abbrev+offset. On RELA targets, we have to find the
1517 relocation and extract the addend to obtain the actual
1518 abbrev_offset, so do it here. */
1519 off
= info_ptr
- stash
->sec_info_ptr
;
1520 abbrev_offset
+= find_rela_addend (abfd
, stash
->sec
, off
, stash
->syms
);
1521 info_ptr
+= offset_size
;
1522 addr_size
= read_1_byte (abfd
, info_ptr
);
1527 (*_bfd_error_handler
) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 information."), version
);
1528 bfd_set_error (bfd_error_bad_value
);
1532 if (addr_size
> sizeof (bfd_vma
))
1534 (*_bfd_error_handler
) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
1536 (unsigned int) sizeof (bfd_vma
));
1537 bfd_set_error (bfd_error_bad_value
);
1541 if (addr_size
!= 2 && addr_size
!= 4 && addr_size
!= 8)
1543 (*_bfd_error_handler
) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size
);
1544 bfd_set_error (bfd_error_bad_value
);
1548 /* Read the abbrevs for this compilation unit into a table. */
1549 abbrevs
= read_abbrevs (abfd
, abbrev_offset
, stash
);
1553 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
1554 info_ptr
+= bytes_read
;
1555 if (! abbrev_number
)
1557 (*_bfd_error_handler
) (_("Dwarf Error: Bad abbrev number: %u."),
1559 bfd_set_error (bfd_error_bad_value
);
1563 abbrev
= lookup_abbrev (abbrev_number
, abbrevs
);
1566 (*_bfd_error_handler
) (_("Dwarf Error: Could not find abbrev number %u."),
1568 bfd_set_error (bfd_error_bad_value
);
1572 amt
= sizeof (struct comp_unit
);
1573 unit
= (struct comp_unit
*) bfd_zalloc (abfd
, amt
);
1575 unit
->addr_size
= addr_size
;
1576 unit
->offset_size
= offset_size
;
1577 unit
->abbrevs
= abbrevs
;
1578 unit
->end_ptr
= end_ptr
;
1579 unit
->stash
= stash
;
1581 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
1583 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
);
1585 /* Store the data if it is of an attribute we want to keep in a
1586 partial symbol table. */
1589 case DW_AT_stmt_list
:
1591 unit
->line_offset
= DW_UNSND (&attr
);
1595 unit
->name
= DW_STRING (&attr
);
1599 unit
->arange
.low
= DW_ADDR (&attr
);
1603 unit
->arange
.high
= DW_ADDR (&attr
);
1606 case DW_AT_comp_dir
:
1608 char* comp_dir
= DW_STRING (&attr
);
1611 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1612 directory, get rid of it. */
1613 char *cp
= (char*) strchr (comp_dir
, ':');
1615 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
1618 unit
->comp_dir
= comp_dir
;
1627 unit
->first_child_die_ptr
= info_ptr
;
1631 /* Return true if UNIT contains the address given by ADDR. */
1634 comp_unit_contains_address (unit
, addr
)
1635 struct comp_unit
* unit
;
1638 struct arange
*arange
;
1643 arange
= &unit
->arange
;
1646 if (addr
>= arange
->low
&& addr
< arange
->high
)
1648 arange
= arange
->next
;
1655 /* If UNIT contains ADDR, set the output parameters to the values for
1656 the line containing ADDR. The output parameters, FILENAME_PTR,
1657 FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
1660 Return true of UNIT contains ADDR, and no errors were encountered;
1664 comp_unit_find_nearest_line (unit
, addr
,
1665 filename_ptr
, functionname_ptr
, linenumber_ptr
,
1667 struct comp_unit
* unit
;
1669 const char **filename_ptr
;
1670 const char **functionname_ptr
;
1671 unsigned int *linenumber_ptr
;
1672 struct dwarf2_debug
*stash
;
1676 struct funcinfo
*function
;
1681 if (! unit
->line_table
)
1683 if (! unit
->stmtlist
)
1689 unit
->line_table
= decode_line_info (unit
, stash
);
1691 if (! unit
->line_table
)
1697 if (unit
->first_child_die_ptr
< unit
->end_ptr
1698 && ! scan_unit_for_functions (unit
))
1706 func_p
= lookup_address_in_function_table (unit
->function_table
,
1710 line_p
= lookup_address_in_line_info_table (unit
->line_table
,
1715 return line_p
|| func_p
;
1718 /* Locate a section in a BFD containing debugging info. The search starts from the
1719 section after AFTER_SEC, or from the first section in the BFD if AFTER_SEC is
1720 NULL. The search works by examining the names of the sections. There are two
1721 permissiable names. The first is .debug_info. This is the standard DWARF2 name.
1722 The second is a prefix .gnu.linkonce.wi. This is a variation on the .debug_info
1723 section which has a checksum describing the contents appended onto the name. This
1724 allows the linker to identify and discard duplicate debugging sections for
1725 different compilation units. */
1726 #define DWARF2_DEBUG_INFO ".debug_info"
1727 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
1730 find_debug_info (abfd
, after_sec
)
1732 asection
* after_sec
;
1737 msec
= after_sec
->next
;
1739 msec
= abfd
->sections
;
1743 if (strcmp (msec
->name
, DWARF2_DEBUG_INFO
) == 0)
1746 if (strncmp (msec
->name
, GNU_LINKONCE_INFO
, strlen (GNU_LINKONCE_INFO
)) == 0)
1755 /* The DWARF2 version of find_nearest line. Return true if the line
1756 is found without error. ADDR_SIZE is the number of bytes in the
1757 initial .debug_info length field and in the abbreviation offset.
1758 You may use zero to indicate that the default value should be
1762 _bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
1763 filename_ptr
, functionname_ptr
,
1770 const char **filename_ptr
;
1771 const char **functionname_ptr
;
1772 unsigned int *linenumber_ptr
;
1773 unsigned int addr_size
;
1776 /* Read each compilation unit from the section .debug_info, and check
1777 to see if it contains the address we are searching for. If yes,
1778 lookup the address, and return the line number info. If no, go
1779 on to the next compilation unit.
1781 We keep a list of all the previously read compilation units, and
1782 a pointer to the next un-read compilation unit. Check the
1783 previously read units before reading more. */
1784 struct dwarf2_debug
*stash
= (struct dwarf2_debug
*) *pinfo
;
1786 /* What address are we looking for? */
1787 bfd_vma addr
= offset
+ section
->vma
;
1789 struct comp_unit
* each
;
1791 *filename_ptr
= NULL
;
1792 *functionname_ptr
= NULL
;
1793 *linenumber_ptr
= 0;
1795 /* The DWARF2 spec says that the initial length field, and the
1796 offset of the abbreviation table, should both be 4-byte values.
1797 However, some compilers do things differently. */
1800 BFD_ASSERT (addr_size
== 4 || addr_size
== 8);
1804 bfd_size_type total_size
;
1806 bfd_size_type amt
= sizeof (struct dwarf2_debug
);
1808 stash
= (struct dwarf2_debug
*) bfd_zalloc (abfd
, amt
);
1812 *pinfo
= (PTR
) stash
;
1814 msec
= find_debug_info (abfd
, NULL
);
1816 /* No dwarf2 info. Note that at this point the stash
1817 has been allocated, but contains zeros, this lets
1818 future calls to this function fail quicker. */
1821 /* There can be more than one DWARF2 info section in a BFD these days.
1822 Read them all in and produce one large stash. We do this in two
1823 passes - in the first pass we just accumulate the section sizes.
1824 In the second pass we read in the section's contents. The allows
1825 us to avoid reallocing the data as we add sections to the stash. */
1826 for (total_size
= 0; msec
; msec
= find_debug_info (abfd
, msec
))
1827 total_size
+= msec
->_raw_size
;
1829 stash
->info_ptr
= (char *) bfd_alloc (abfd
, total_size
);
1830 if (stash
->info_ptr
== NULL
)
1833 stash
->info_ptr_end
= stash
->info_ptr
;
1835 for (msec
= find_debug_info (abfd
, NULL
);
1837 msec
= find_debug_info (abfd
, msec
))
1840 bfd_size_type start
;
1842 size
= msec
->_raw_size
;
1846 start
= stash
->info_ptr_end
- stash
->info_ptr
;
1848 if (! bfd_get_section_contents (abfd
, msec
, stash
->info_ptr
+ start
,
1852 stash
->info_ptr_end
= stash
->info_ptr
+ start
+ size
;
1855 BFD_ASSERT (stash
->info_ptr_end
== stash
->info_ptr
+ total_size
);
1857 stash
->sec
= find_debug_info (abfd
, NULL
);
1858 stash
->sec_info_ptr
= stash
->info_ptr
;
1859 stash
->syms
= symbols
;
1862 /* FIXME: There is a problem with the contents of the
1863 .debug_info section. The 'low' and 'high' addresses of the
1864 comp_units are computed by relocs against symbols in the
1865 .text segment. We need these addresses in order to determine
1866 the nearest line number, and so we have to resolve the
1867 relocs. There is a similar problem when the .debug_line
1868 section is processed as well (e.g., there may be relocs
1869 against the operand of the DW_LNE_set_address operator).
1871 Unfortunately getting hold of the reloc information is hard...
1873 For now, this means that disassembling object files (as
1874 opposed to fully executables) does not always work as well as
1877 /* A null info_ptr indicates that there is no dwarf2 info
1878 (or that an error occured while setting up the stash). */
1879 if (! stash
->info_ptr
)
1882 /* Check the previously read comp. units first. */
1883 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
1884 if (comp_unit_contains_address (each
, addr
))
1885 return comp_unit_find_nearest_line (each
, addr
, filename_ptr
,
1886 functionname_ptr
, linenumber_ptr
,
1889 /* Read each remaining comp. units checking each as they are read. */
1890 while (stash
->info_ptr
< stash
->info_ptr_end
)
1894 unsigned int offset_size
= addr_size
;
1898 length
= read_4_bytes (abfd
, stash
->info_ptr
);
1899 if (length
== 0xffffffff)
1902 length
= read_8_bytes (abfd
, stash
->info_ptr
+ 4);
1903 stash
->info_ptr
+= 8;
1907 length
= read_8_bytes (abfd
, stash
->info_ptr
);
1908 stash
->info_ptr
+= addr_size
;
1912 each
= parse_comp_unit (abfd
, stash
, length
, offset_size
);
1913 stash
->info_ptr
+= length
;
1915 if ((bfd_vma
) (stash
->info_ptr
- stash
->sec_info_ptr
)
1916 == stash
->sec
->_raw_size
)
1918 stash
->sec
= find_debug_info (abfd
, stash
->sec
);
1919 stash
->sec_info_ptr
= stash
->info_ptr
;
1924 each
->next_unit
= stash
->all_comp_units
;
1925 stash
->all_comp_units
= each
;
1927 /* DW_AT_low_pc and DW_AT_high_pc are optional for
1928 compilation units. If we don't have them (i.e.,
1929 unit->high == 0), we need to consult the line info
1930 table to see if a compilation unit contains the given
1932 if (each
->arange
.high
> 0)
1934 if (comp_unit_contains_address (each
, addr
))
1935 return comp_unit_find_nearest_line (each
, addr
,
1943 found
= comp_unit_find_nearest_line (each
, addr
,