2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005 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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, 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;
70 /* Blocks are a bunch of untyped bytes. */
79 /* A list of all previously read comp_units. */
80 struct comp_unit *all_comp_units;
82 /* The next unread compilation unit within the .debug_info section.
83 Zero indicates that the .debug_info section has not been loaded
87 /* Pointer to the end of the .debug_info section memory buffer. */
88 bfd_byte *info_ptr_end;
90 /* Pointer to the section and address of the beginning of the
93 bfd_byte *sec_info_ptr;
95 /* Pointer to the symbol table. */
98 /* Pointer to the .debug_abbrev section loaded into memory. */
99 bfd_byte *dwarf_abbrev_buffer;
101 /* Length of the loaded .debug_abbrev section. */
102 unsigned long dwarf_abbrev_size;
104 /* Buffer for decode_line_info. */
105 bfd_byte *dwarf_line_buffer;
107 /* Length of the loaded .debug_line section. */
108 unsigned long dwarf_line_size;
110 /* Pointer to the .debug_str section loaded into memory. */
111 bfd_byte *dwarf_str_buffer;
113 /* Length of the loaded .debug_str section. */
114 unsigned long dwarf_str_size;
116 /* Pointer to the .debug_ranges section loaded into memory. */
117 bfd_byte *dwarf_ranges_buffer;
119 /* Length of the loaded .debug_ranges section. */
120 unsigned long dwarf_ranges_size;
122 /* If the most recent call to bfd_find_nearest_line was given an
123 address in an inlined function, preserve a pointer into the
124 calling chain for subsequent calls to bfd_find_inliner_info to
126 struct funcinfo *inliner_chain;
136 /* A minimal decoding of DWARF2 compilation units. We only decode
137 what's needed to get to the line number information. */
141 /* Chain the previously read compilation units. */
142 struct comp_unit *next_unit;
144 /* Keep the bfd convenient (for memory allocation). */
147 /* The lowest and highest addresses contained in this compilation
148 unit as specified in the compilation unit header. */
149 struct arange arange;
151 /* The DW_AT_name attribute (for error messages). */
154 /* The abbrev hash table. */
155 struct abbrev_info **abbrevs;
157 /* Note that an error was found by comp_unit_find_nearest_line. */
160 /* The DW_AT_comp_dir attribute. */
163 /* TRUE if there is a line number table associated with this comp. unit. */
166 /* Pointer to the current comp_unit so that we can find a given entry
168 bfd_byte *info_ptr_unit;
170 /* The offset into .debug_line of the line number table. */
171 unsigned long line_offset;
173 /* Pointer to the first child die for the comp unit. */
174 bfd_byte *first_child_die_ptr;
176 /* The end of the comp unit. */
179 /* The decoded line number, NULL if not yet decoded. */
180 struct line_info_table *line_table;
182 /* A list of the functions found in this comp. unit. */
183 struct funcinfo *function_table;
185 /* A list of the variables found in this comp. unit. */
186 struct varinfo *variable_table;
188 /* Pointer to dwarf2_debug structure. */
189 struct dwarf2_debug *stash;
191 /* Address size for this unit - from unit header. */
192 unsigned char addr_size;
194 /* Offset size for this unit - from unit header. */
195 unsigned char offset_size;
197 /* Base address for this unit - from DW_AT_low_pc attribute of
198 DW_TAG_compile_unit DIE */
199 bfd_vma base_address;
202 /* This data structure holds the information of an abbrev. */
205 unsigned int number; /* Number identifying abbrev. */
206 enum dwarf_tag tag; /* DWARF tag. */
207 int has_children; /* Boolean. */
208 unsigned int num_attrs; /* Number of attributes. */
209 struct attr_abbrev *attrs; /* An array of attribute descriptions. */
210 struct abbrev_info *next; /* Next in chain. */
215 enum dwarf_attribute name;
216 enum dwarf_form form;
219 #ifndef ABBREV_HASH_SIZE
220 #define ABBREV_HASH_SIZE 121
222 #ifndef ATTR_ALLOC_CHUNK
223 #define ATTR_ALLOC_CHUNK 4
227 The following function up to the END VERBATIM mark are
228 copied directly from dwarf2read.c. */
230 /* Read dwarf information from a buffer. */
233 read_1_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf)
235 return bfd_get_8 (abfd, buf);
239 read_1_signed_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf)
241 return bfd_get_signed_8 (abfd, buf);
245 read_2_bytes (bfd *abfd, bfd_byte *buf)
247 return bfd_get_16 (abfd, buf);
251 read_4_bytes (bfd *abfd, bfd_byte *buf)
253 return bfd_get_32 (abfd, buf);
257 read_8_bytes (bfd *abfd, bfd_byte *buf)
259 return bfd_get_64 (abfd, buf);
263 read_n_bytes (bfd *abfd ATTRIBUTE_UNUSED,
265 unsigned int size ATTRIBUTE_UNUSED)
267 /* If the size of a host char is 8 bits, we can return a pointer
268 to the buffer, otherwise we have to copy the data to a buffer
269 allocated on the temporary obstack. */
274 read_string (bfd *abfd ATTRIBUTE_UNUSED,
276 unsigned int *bytes_read_ptr)
278 /* Return a pointer to the embedded string. */
279 char *str = (char *) buf;
286 *bytes_read_ptr = strlen (str) + 1;
291 read_indirect_string (struct comp_unit* unit,
293 unsigned int *bytes_read_ptr)
296 struct dwarf2_debug *stash = unit->stash;
299 if (unit->offset_size == 4)
300 offset = read_4_bytes (unit->abfd, buf);
302 offset = read_8_bytes (unit->abfd, buf);
303 *bytes_read_ptr = unit->offset_size;
305 if (! stash->dwarf_str_buffer)
308 bfd *abfd = unit->abfd;
311 msec = bfd_get_section_by_name (abfd, ".debug_str");
314 (*_bfd_error_handler)
315 (_("Dwarf Error: Can't find .debug_str section."));
316 bfd_set_error (bfd_error_bad_value);
320 sz = msec->rawsize ? msec->rawsize : msec->size;
321 stash->dwarf_str_size = sz;
322 stash->dwarf_str_buffer = bfd_alloc (abfd, sz);
323 if (! stash->dwarf_str_buffer)
326 if (! bfd_get_section_contents (abfd, msec, stash->dwarf_str_buffer,
331 if (offset >= stash->dwarf_str_size)
333 (*_bfd_error_handler) (_("Dwarf Error: DW_FORM_strp offset (%lu) greater than or equal to .debug_str size (%lu)."),
334 (unsigned long) offset, stash->dwarf_str_size);
335 bfd_set_error (bfd_error_bad_value);
339 str = (char *) stash->dwarf_str_buffer + offset;
348 read_address (struct comp_unit *unit, bfd_byte *buf)
350 switch (unit->addr_size)
353 return bfd_get_64 (unit->abfd, buf);
355 return bfd_get_32 (unit->abfd, buf);
357 return bfd_get_16 (unit->abfd, buf);
363 /* Lookup an abbrev_info structure in the abbrev hash table. */
365 static struct abbrev_info *
366 lookup_abbrev (unsigned int number, struct abbrev_info **abbrevs)
368 unsigned int hash_number;
369 struct abbrev_info *abbrev;
371 hash_number = number % ABBREV_HASH_SIZE;
372 abbrev = abbrevs[hash_number];
376 if (abbrev->number == number)
379 abbrev = abbrev->next;
385 /* In DWARF version 2, the description of the debugging information is
386 stored in a separate .debug_abbrev section. Before we read any
387 dies from a section we read in all abbreviations and install them
390 static struct abbrev_info**
391 read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
393 struct abbrev_info **abbrevs;
394 bfd_byte *abbrev_ptr;
395 struct abbrev_info *cur_abbrev;
396 unsigned int abbrev_number, bytes_read, abbrev_name;
397 unsigned int abbrev_form, hash_number;
400 if (! stash->dwarf_abbrev_buffer)
404 msec = bfd_get_section_by_name (abfd, ".debug_abbrev");
407 (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_abbrev section."));
408 bfd_set_error (bfd_error_bad_value);
412 stash->dwarf_abbrev_size = msec->size;
413 stash->dwarf_abbrev_buffer
414 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
416 if (! stash->dwarf_abbrev_buffer)
420 if (offset >= stash->dwarf_abbrev_size)
422 (*_bfd_error_handler) (_("Dwarf Error: Abbrev offset (%lu) greater than or equal to .debug_abbrev size (%lu)."),
423 (unsigned long) offset, stash->dwarf_abbrev_size);
424 bfd_set_error (bfd_error_bad_value);
428 amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
429 abbrevs = bfd_zalloc (abfd, amt);
431 abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
432 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
433 abbrev_ptr += bytes_read;
435 /* Loop until we reach an abbrev number of 0. */
436 while (abbrev_number)
438 amt = sizeof (struct abbrev_info);
439 cur_abbrev = bfd_zalloc (abfd, amt);
441 /* Read in abbrev header. */
442 cur_abbrev->number = abbrev_number;
443 cur_abbrev->tag = (enum dwarf_tag)
444 read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
445 abbrev_ptr += bytes_read;
446 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
449 /* Now read in declarations. */
450 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
451 abbrev_ptr += bytes_read;
452 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
453 abbrev_ptr += bytes_read;
457 if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
459 struct attr_abbrev *tmp;
461 amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
462 amt *= sizeof (struct attr_abbrev);
463 tmp = bfd_realloc (cur_abbrev->attrs, amt);
468 for (i = 0; i < ABBREV_HASH_SIZE; i++)
470 struct abbrev_info *abbrev = abbrevs[i];
474 free (abbrev->attrs);
475 abbrev = abbrev->next;
480 cur_abbrev->attrs = tmp;
483 cur_abbrev->attrs[cur_abbrev->num_attrs].name
484 = (enum dwarf_attribute) abbrev_name;
485 cur_abbrev->attrs[cur_abbrev->num_attrs++].form
486 = (enum dwarf_form) abbrev_form;
487 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
488 abbrev_ptr += bytes_read;
489 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
490 abbrev_ptr += bytes_read;
493 hash_number = abbrev_number % ABBREV_HASH_SIZE;
494 cur_abbrev->next = abbrevs[hash_number];
495 abbrevs[hash_number] = cur_abbrev;
497 /* Get next abbreviation.
498 Under Irix6 the abbreviations for a compilation unit are not
499 always properly terminated with an abbrev number of 0.
500 Exit loop if we encounter an abbreviation which we have
501 already read (which means we are about to read the abbreviations
502 for the next compile unit) or if the end of the abbreviation
504 if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
505 >= stash->dwarf_abbrev_size)
507 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
508 abbrev_ptr += bytes_read;
509 if (lookup_abbrev (abbrev_number,abbrevs) != NULL)
516 /* Read an attribute value described by an attribute form. */
519 read_attribute_value (struct attribute *attr,
521 struct comp_unit *unit,
524 bfd *abfd = unit->abfd;
525 unsigned int bytes_read;
526 struct dwarf_block *blk;
529 attr->form = (enum dwarf_form) form;
534 /* FIXME: DWARF3 draft says DW_FORM_ref_addr is offset_size. */
535 case DW_FORM_ref_addr:
536 attr->u.val = read_address (unit, info_ptr);
537 info_ptr += unit->addr_size;
540 amt = sizeof (struct dwarf_block);
541 blk = bfd_alloc (abfd, amt);
542 blk->size = read_2_bytes (abfd, info_ptr);
544 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
545 info_ptr += blk->size;
549 amt = sizeof (struct dwarf_block);
550 blk = bfd_alloc (abfd, amt);
551 blk->size = read_4_bytes (abfd, info_ptr);
553 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
554 info_ptr += blk->size;
558 attr->u.val = read_2_bytes (abfd, info_ptr);
562 attr->u.val = read_4_bytes (abfd, info_ptr);
566 attr->u.val = read_8_bytes (abfd, info_ptr);
570 attr->u.str = read_string (abfd, info_ptr, &bytes_read);
571 info_ptr += bytes_read;
574 attr->u.str = read_indirect_string (unit, info_ptr, &bytes_read);
575 info_ptr += bytes_read;
578 amt = sizeof (struct dwarf_block);
579 blk = bfd_alloc (abfd, amt);
580 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
581 info_ptr += bytes_read;
582 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
583 info_ptr += blk->size;
587 amt = sizeof (struct dwarf_block);
588 blk = bfd_alloc (abfd, amt);
589 blk->size = read_1_byte (abfd, info_ptr);
591 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
592 info_ptr += blk->size;
596 attr->u.val = read_1_byte (abfd, info_ptr);
600 attr->u.val = read_1_byte (abfd, info_ptr);
604 attr->u.sval = read_signed_leb128 (abfd, info_ptr, &bytes_read);
605 info_ptr += bytes_read;
608 attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
609 info_ptr += bytes_read;
612 attr->u.val = read_1_byte (abfd, info_ptr);
616 attr->u.val = read_2_bytes (abfd, info_ptr);
620 attr->u.val = read_4_bytes (abfd, info_ptr);
624 attr->u.val = read_8_bytes (abfd, info_ptr);
627 case DW_FORM_ref_udata:
628 attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
629 info_ptr += bytes_read;
631 case DW_FORM_indirect:
632 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
633 info_ptr += bytes_read;
634 info_ptr = read_attribute_value (attr, form, unit, info_ptr);
637 (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %u."),
639 bfd_set_error (bfd_error_bad_value);
644 /* Read an attribute described by an abbreviated attribute. */
647 read_attribute (struct attribute *attr,
648 struct attr_abbrev *abbrev,
649 struct comp_unit *unit,
652 attr->name = abbrev->name;
653 info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr);
657 /* Source line information table routines. */
659 #define FILE_ALLOC_CHUNK 5
660 #define DIR_ALLOC_CHUNK 5
664 struct line_info* prev_line;
669 int end_sequence; /* End of (sequential) code sequence. */
680 struct line_info_table
683 unsigned int num_files;
684 unsigned int num_dirs;
687 struct fileinfo* files;
688 struct line_info* last_line; /* largest VMA */
689 struct line_info* lcl_head; /* local head; used in 'add_line_info' */
692 /* Remember some information about each function. If the function is
693 inlined (DW_TAG_inlined_subroutine) it may have two additional
694 attributes, DW_AT_call_file and DW_AT_call_line, which specify the
695 source code location where this function was inlined. */
699 struct funcinfo *prev_func; /* Pointer to previous function in list of all functions */
700 struct funcinfo *caller_func; /* Pointer to function one scope higher */
701 char *caller_file; /* Source location file name where caller_func inlines this func */
702 int caller_line; /* Source location line number where caller_func inlines this func */
703 char *file; /* Source location file name */
704 int line; /* Source location line number */
708 struct arange arange;
709 asection *sec; /* Where the symbol is defined */
714 /* Pointer to previous variable in list of all variables */
715 struct varinfo *prev_var;
716 /* Source location file name */
718 /* Source location line number */
722 /* Where the symbol is defined */
724 /* Is this a stack variable? */
725 unsigned int stack: 1;
728 /* Adds a new entry to the line_info list in the line_info_table, ensuring
729 that the list is sorted. Note that the line_info list is sorted from
730 highest to lowest VMA (with possible duplicates); that is,
731 line_info->prev_line always accesses an equal or smaller VMA. */
734 add_line_info (struct line_info_table *table,
741 bfd_size_type amt = sizeof (struct line_info);
742 struct line_info* info = bfd_alloc (table->abfd, amt);
744 /* Find the correct location for 'info'. Normally we will receive
745 new line_info data 1) in order and 2) with increasing VMAs.
746 However some compilers break the rules (cf. decode_line_info) and
747 so we include some heuristics for quickly finding the correct
748 location for 'info'. In particular, these heuristics optimize for
749 the common case in which the VMA sequence that we receive is a
750 list of locally sorted VMAs such as
751 p...z a...j (where a < j < p < z)
753 Note: table->lcl_head is used to head an *actual* or *possible*
754 sequence within the list (such as a...j) that is not directly
755 headed by table->last_line
757 Note: we may receive duplicate entries from 'decode_line_info'. */
760 if (!table->last_line
761 || address >= table->last_line->address)
763 /* Normal case: add 'info' to the beginning of the list */
764 info->prev_line = table->last_line;
765 table->last_line = info;
767 /* lcl_head: initialize to head a *possible* sequence at the end. */
768 if (!table->lcl_head)
769 table->lcl_head = info;
772 else if (!table->lcl_head->prev_line
773 && table->lcl_head->address > address)
775 /* Abnormal but easy: lcl_head is 1) at the *end* of the line
776 list and 2) the head of 'info'. */
777 info->prev_line = NULL;
778 table->lcl_head->prev_line = info;
781 else if (table->lcl_head->prev_line
782 && table->lcl_head->address > address
783 && address >= table->lcl_head->prev_line->address)
785 /* Abnormal but easy: lcl_head is 1) in the *middle* of the line
786 list and 2) the head of 'info'. */
787 info->prev_line = table->lcl_head->prev_line;
788 table->lcl_head->prev_line = info;
793 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head' are valid
794 heads for 'info'. Reset 'lcl_head' and repeat. */
795 struct line_info* li2 = table->last_line; /* always non-NULL */
796 struct line_info* li1 = li2->prev_line;
800 if (li2->address > address && address >= li1->address)
803 li2 = li1; /* always non-NULL */
804 li1 = li1->prev_line;
806 table->lcl_head = li2;
809 /* Set member data of 'info'. */
810 info->address = address;
812 info->column = column;
813 info->end_sequence = end_sequence;
815 if (filename && filename[0])
817 info->filename = bfd_alloc (table->abfd, strlen (filename) + 1);
819 strcpy (info->filename, filename);
822 info->filename = NULL;
825 /* Extract a fully qualified filename from a line info table.
826 The returned string has been malloc'ed and it is the caller's
827 responsibility to free it. */
830 concat_filename (struct line_info_table *table, unsigned int file)
834 if (file - 1 >= table->num_files)
836 (*_bfd_error_handler)
837 (_("Dwarf Error: mangled line number section (bad file number)."));
838 return strdup ("<unknown>");
841 filename = table->files[file - 1].name;
843 if (! IS_ABSOLUTE_PATH (filename))
845 char *dirname = (table->files[file - 1].dir
846 ? table->dirs[table->files[file - 1].dir - 1]
849 /* Not all tools set DW_AT_comp_dir, so dirname may be unknown.
850 The best we can do is return the filename part. */
853 unsigned int len = strlen (dirname) + strlen (filename) + 2;
856 name = bfd_malloc (len);
858 sprintf (name, "%s/%s", dirname, filename);
863 return strdup (filename);
867 arange_add (bfd *abfd, struct arange *first_arange, bfd_vma low_pc, bfd_vma high_pc)
869 struct arange *arange;
871 /* If the first arange is empty, use it. */
872 if (first_arange->high == 0)
874 first_arange->low = low_pc;
875 first_arange->high = high_pc;
879 /* Next see if we can cheaply extend an existing range. */
880 arange = first_arange;
883 if (low_pc == arange->high)
885 arange->high = high_pc;
888 if (high_pc == arange->low)
890 arange->low = low_pc;
893 arange = arange->next;
897 /* Need to allocate a new arange and insert it into the arange list.
898 Order isn't significant, so just insert after the first arange. */
899 arange = bfd_zalloc (abfd, sizeof (*arange));
900 arange->low = low_pc;
901 arange->high = high_pc;
902 arange->next = first_arange->next;
903 first_arange->next = arange;
906 /* Decode the line number information for UNIT. */
908 static struct line_info_table*
909 decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
911 bfd *abfd = unit->abfd;
912 struct line_info_table* table;
916 unsigned int i, bytes_read, offset_size;
917 char *cur_file, *cur_dir;
918 unsigned char op_code, extended_op, adj_opcode;
921 if (! stash->dwarf_line_buffer)
925 msec = bfd_get_section_by_name (abfd, ".debug_line");
928 (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_line section."));
929 bfd_set_error (bfd_error_bad_value);
933 stash->dwarf_line_size = msec->size;
934 stash->dwarf_line_buffer
935 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
937 if (! stash->dwarf_line_buffer)
941 /* It is possible to get a bad value for the line_offset. Validate
942 it here so that we won't get a segfault below. */
943 if (unit->line_offset >= stash->dwarf_line_size)
945 (*_bfd_error_handler) (_("Dwarf Error: Line offset (%lu) greater than or equal to .debug_line size (%lu)."),
946 unit->line_offset, stash->dwarf_line_size);
947 bfd_set_error (bfd_error_bad_value);
951 amt = sizeof (struct line_info_table);
952 table = bfd_alloc (abfd, amt);
954 table->comp_dir = unit->comp_dir;
956 table->num_files = 0;
963 table->last_line = NULL;
964 table->lcl_head = NULL;
966 line_ptr = stash->dwarf_line_buffer + unit->line_offset;
968 /* Read in the prologue. */
969 lh.total_length = read_4_bytes (abfd, line_ptr);
972 if (lh.total_length == 0xffffffff)
974 lh.total_length = read_8_bytes (abfd, line_ptr);
978 else if (lh.total_length == 0 && unit->addr_size == 8)
980 /* Handle (non-standard) 64-bit DWARF2 formats. */
981 lh.total_length = read_4_bytes (abfd, line_ptr);
985 line_end = line_ptr + lh.total_length;
986 lh.version = read_2_bytes (abfd, line_ptr);
988 if (offset_size == 4)
989 lh.prologue_length = read_4_bytes (abfd, line_ptr);
991 lh.prologue_length = read_8_bytes (abfd, line_ptr);
992 line_ptr += offset_size;
993 lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
995 lh.default_is_stmt = read_1_byte (abfd, line_ptr);
997 lh.line_base = read_1_signed_byte (abfd, line_ptr);
999 lh.line_range = read_1_byte (abfd, line_ptr);
1001 lh.opcode_base = read_1_byte (abfd, line_ptr);
1003 amt = lh.opcode_base * sizeof (unsigned char);
1004 lh.standard_opcode_lengths = bfd_alloc (abfd, amt);
1006 lh.standard_opcode_lengths[0] = 1;
1008 for (i = 1; i < lh.opcode_base; ++i)
1010 lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
1014 /* Read directory table. */
1015 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1017 line_ptr += bytes_read;
1019 if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
1023 amt = table->num_dirs + DIR_ALLOC_CHUNK;
1024 amt *= sizeof (char *);
1026 tmp = bfd_realloc (table->dirs, amt);
1035 table->dirs[table->num_dirs++] = cur_dir;
1038 line_ptr += bytes_read;
1040 /* Read file name table. */
1041 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1043 line_ptr += bytes_read;
1045 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1047 struct fileinfo *tmp;
1049 amt = table->num_files + FILE_ALLOC_CHUNK;
1050 amt *= sizeof (struct fileinfo);
1052 tmp = bfd_realloc (table->files, amt);
1055 free (table->files);
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 = table->num_files ? concat_filename (table, 1) : NULL;
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;
1088 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1089 compilers generate address sequences that are wildly out of
1090 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1091 for ia64-Linux). Thus, to determine the low and high
1092 address, we must compare on every DW_LNS_copy, etc. */
1094 bfd_vma high_pc = 0;
1095 bfd_boolean low_pc_set = FALSE;
1097 /* Decode the table. */
1098 while (! end_sequence)
1100 op_code = read_1_byte (abfd, line_ptr);
1103 if (op_code >= lh.opcode_base)
1105 /* Special operand. */
1106 adj_opcode = op_code - lh.opcode_base;
1107 address += (adj_opcode / lh.line_range)
1108 * lh.minimum_instruction_length;
1109 line += lh.line_base + (adj_opcode % lh.line_range);
1110 /* Append row to matrix using current values. */
1111 add_line_info (table, address, filename, line, column, 0);
1113 if (!low_pc_set || address < low_pc)
1118 if (address > high_pc)
1121 else switch (op_code)
1123 case DW_LNS_extended_op:
1124 /* Ignore length. */
1126 extended_op = read_1_byte (abfd, line_ptr);
1129 switch (extended_op)
1131 case DW_LNE_end_sequence:
1133 add_line_info (table, address, filename, line, column,
1135 if (!low_pc_set || address < low_pc)
1140 if (address > high_pc)
1142 arange_add (unit->abfd, &unit->arange, low_pc, high_pc);
1144 case DW_LNE_set_address:
1145 address = read_address (unit, line_ptr);
1146 line_ptr += unit->addr_size;
1148 case DW_LNE_define_file:
1149 cur_file = read_string (abfd, line_ptr, &bytes_read);
1150 line_ptr += bytes_read;
1151 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1153 struct fileinfo *tmp;
1155 amt = table->num_files + FILE_ALLOC_CHUNK;
1156 amt *= sizeof (struct fileinfo);
1157 tmp = bfd_realloc (table->files, amt);
1160 free (table->files);
1167 table->files[table->num_files].name = cur_file;
1168 table->files[table->num_files].dir =
1169 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1170 line_ptr += bytes_read;
1171 table->files[table->num_files].time =
1172 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1173 line_ptr += bytes_read;
1174 table->files[table->num_files].size =
1175 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1176 line_ptr += bytes_read;
1180 (*_bfd_error_handler) (_("Dwarf Error: mangled line number section."));
1181 bfd_set_error (bfd_error_bad_value);
1183 free (table->files);
1189 add_line_info (table, address, filename, line, column, 0);
1191 if (!low_pc_set || address < low_pc)
1196 if (address > high_pc)
1199 case DW_LNS_advance_pc:
1200 address += lh.minimum_instruction_length
1201 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1202 line_ptr += bytes_read;
1204 case DW_LNS_advance_line:
1205 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
1206 line_ptr += bytes_read;
1208 case DW_LNS_set_file:
1212 /* The file and directory tables are 0
1213 based, the references are 1 based. */
1214 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1215 line_ptr += bytes_read;
1218 filename = concat_filename (table, file);
1221 case DW_LNS_set_column:
1222 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1223 line_ptr += bytes_read;
1225 case DW_LNS_negate_stmt:
1226 is_stmt = (!is_stmt);
1228 case DW_LNS_set_basic_block:
1231 case DW_LNS_const_add_pc:
1232 address += lh.minimum_instruction_length
1233 * ((255 - lh.opcode_base) / lh.line_range);
1235 case DW_LNS_fixed_advance_pc:
1236 address += read_2_bytes (abfd, line_ptr);
1243 /* Unknown standard opcode, ignore it. */
1244 for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
1246 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1247 line_ptr += bytes_read;
1260 /* If ADDR is within TABLE set the output parameters and return TRUE,
1261 otherwise return FALSE. The output parameters, FILENAME_PTR and
1262 LINENUMBER_PTR, are pointers to the objects to be filled in. */
1265 lookup_address_in_line_info_table (struct line_info_table *table,
1267 struct funcinfo *function,
1268 const char **filename_ptr,
1269 unsigned int *linenumber_ptr)
1271 /* Note: table->last_line should be a descendingly sorted list. */
1272 struct line_info* next_line = table->last_line;
1273 struct line_info* each_line = NULL;
1274 *filename_ptr = NULL;
1279 each_line = next_line->prev_line;
1281 /* Check for large addresses */
1282 if (addr > next_line->address)
1283 each_line = NULL; /* ensure we skip over the normal case */
1285 /* Normal case: search the list; save */
1286 while (each_line && next_line)
1288 /* If we have an address match, save this info. This allows us
1289 to return as good as results as possible for strange debugging
1291 bfd_boolean addr_match = FALSE;
1292 if (each_line->address <= addr && addr < next_line->address)
1296 /* If this line appears to span functions, and addr is in the
1297 later function, return the first line of that function instead
1298 of the last line of the earlier one. This check is for GCC
1299 2.95, which emits the first line number for a function late. */
1301 if (function != NULL)
1304 struct arange *arange;
1306 /* Find the lowest address in the function's range list */
1307 lowest_pc = function->arange.low;
1308 for (arange = &function->arange;
1310 arange = arange->next)
1312 if (function->arange.low < lowest_pc)
1313 lowest_pc = function->arange.low;
1315 /* Check for spanning function and set outgoing line info */
1316 if (addr >= lowest_pc
1317 && each_line->address < lowest_pc
1318 && next_line->address > lowest_pc)
1320 *filename_ptr = next_line->filename;
1321 *linenumber_ptr = next_line->line;
1325 *filename_ptr = each_line->filename;
1326 *linenumber_ptr = each_line->line;
1331 *filename_ptr = each_line->filename;
1332 *linenumber_ptr = each_line->line;
1336 if (addr_match && !each_line->end_sequence)
1337 return TRUE; /* we have definitely found what we want */
1339 next_line = each_line;
1340 each_line = each_line->prev_line;
1343 /* At this point each_line is NULL but next_line is not. If we found
1344 a candidate end-of-sequence point in the loop above, we can return
1345 that (compatibility with a bug in the Intel compiler); otherwise,
1346 assuming that we found the containing function for this address in
1347 this compilation unit, return the first line we have a number for
1348 (compatibility with GCC 2.95). */
1349 if (*filename_ptr == NULL && function != NULL)
1351 *filename_ptr = next_line->filename;
1352 *linenumber_ptr = next_line->line;
1359 /* Read in the .debug_ranges section for future reference */
1362 read_debug_ranges (struct comp_unit *unit)
1364 struct dwarf2_debug *stash = unit->stash;
1365 if (! stash->dwarf_ranges_buffer)
1367 bfd *abfd = unit->abfd;
1370 msec = bfd_get_section_by_name (abfd, ".debug_ranges");
1373 (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_ranges section."));
1374 bfd_set_error (bfd_error_bad_value);
1378 stash->dwarf_ranges_size = msec->size;
1379 stash->dwarf_ranges_buffer
1380 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
1382 if (! stash->dwarf_ranges_buffer)
1388 /* Function table functions. */
1390 /* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return TRUE.
1391 Note that we need to find the function that has the smallest
1392 range that contains ADDR, to handle inlined functions without
1393 depending upon them being ordered in TABLE by increasing range. */
1396 lookup_address_in_function_table (struct comp_unit *unit,
1398 struct funcinfo **function_ptr,
1399 const char **functionname_ptr)
1401 struct funcinfo* each_func;
1402 struct funcinfo* best_fit = NULL;
1403 struct arange *arange;
1405 for (each_func = unit->function_table;
1407 each_func = each_func->prev_func)
1409 for (arange = &each_func->arange;
1411 arange = arange->next)
1413 if (addr >= arange->low && addr < arange->high)
1416 ((arange->high - arange->low) < (best_fit->arange.high - best_fit->arange.low)))
1417 best_fit = each_func;
1424 struct funcinfo* curr_func = best_fit;
1426 *functionname_ptr = best_fit->name;
1427 *function_ptr = best_fit;
1429 /* If we found a match and it is a function that was inlined,
1430 traverse the function list looking for the function at the
1431 next higher scope and save a pointer to it for future use.
1432 Note that because of the way the DWARF info is generated, and
1433 the way we build the function list, the first function at the
1434 next higher level is the one we want. */
1436 for (each_func = best_fit -> prev_func;
1437 each_func && (curr_func->tag == DW_TAG_inlined_subroutine);
1438 each_func = each_func->prev_func)
1440 if (each_func->nesting_level < curr_func->nesting_level)
1442 curr_func->caller_func = each_func;
1443 curr_func = each_func;
1454 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
1455 and LINENUMBER_PTR, and return TRUE. */
1458 lookup_symbol_in_function_table (struct comp_unit *unit,
1461 const char **filename_ptr,
1462 unsigned int *linenumber_ptr)
1464 struct funcinfo* each_func;
1465 struct funcinfo* best_fit = NULL;
1466 struct arange *arange;
1467 const char *name = bfd_asymbol_name (sym);
1468 asection *sec = bfd_get_section (sym);
1470 for (each_func = unit->function_table;
1472 each_func = each_func->prev_func)
1474 for (arange = &each_func->arange;
1476 arange = arange->next)
1478 if ((!each_func->sec || each_func->sec == sec)
1479 && addr >= arange->low
1480 && addr < arange->high
1481 && strcmp (name, each_func->name) == 0
1483 || ((arange->high - arange->low)
1484 < (best_fit->arange.high - best_fit->arange.low))))
1485 best_fit = each_func;
1491 best_fit->sec = sec;
1492 *filename_ptr = best_fit->file;
1493 *linenumber_ptr = best_fit->line;
1500 /* Variable table functions. */
1502 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
1503 LINENUMBER_PTR, and return TRUE. */
1506 lookup_symbol_in_variable_table (struct comp_unit *unit,
1508 const char **filename_ptr,
1509 unsigned int *linenumber_ptr)
1511 const char *name = bfd_asymbol_name (sym);
1512 asection *sec = bfd_get_section (sym);
1513 struct varinfo* each;
1515 for (each = unit->variable_table; each; each = each->prev_var)
1516 if (each->stack == 0
1517 && (!each->sec || each->sec == sec)
1518 && strcmp (name, each->name) == 0)
1524 *filename_ptr = each->file;
1525 *linenumber_ptr = each->line;
1533 find_abstract_instance_name (struct comp_unit *unit, bfd_uint64_t die_ref)
1535 bfd *abfd = unit->abfd;
1537 unsigned int abbrev_number, bytes_read, i;
1538 struct abbrev_info *abbrev;
1539 struct attribute attr;
1542 info_ptr = unit->info_ptr_unit + die_ref;
1543 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1544 info_ptr += bytes_read;
1548 abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
1551 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1553 bfd_set_error (bfd_error_bad_value);
1557 for (i = 0; i < abbrev->num_attrs && !name; ++i)
1559 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1565 case DW_AT_specification:
1566 name = find_abstract_instance_name (unit, attr.u.val);
1578 read_rangelist (struct comp_unit *unit, struct arange *arange, bfd_uint64_t offset)
1580 bfd_byte *ranges_ptr;
1581 bfd_vma base_address = unit->base_address;
1583 if (! unit->stash->dwarf_ranges_buffer)
1585 if (! read_debug_ranges (unit))
1588 ranges_ptr = unit->stash->dwarf_ranges_buffer + offset;
1595 if (unit->offset_size == 4)
1597 low_pc = read_4_bytes (unit->abfd, ranges_ptr);
1599 high_pc = read_4_bytes (unit->abfd, ranges_ptr);
1604 low_pc = read_8_bytes (unit->abfd, ranges_ptr);
1606 high_pc = read_8_bytes (unit->abfd, ranges_ptr);
1609 if (low_pc == 0 && high_pc == 0)
1611 if (low_pc == -1UL && high_pc != -1UL)
1612 base_address = high_pc;
1614 arange_add (unit->abfd, arange, base_address + low_pc, base_address + high_pc);
1618 /* DWARF2 Compilation unit functions. */
1620 /* Scan over each die in a comp. unit looking for functions to add
1621 to the function table and variables to the variable table. */
1624 scan_unit_for_symbols (struct comp_unit *unit)
1626 bfd *abfd = unit->abfd;
1627 bfd_byte *info_ptr = unit->first_child_die_ptr;
1628 int nesting_level = 1;
1630 while (nesting_level)
1632 unsigned int abbrev_number, bytes_read, i;
1633 struct abbrev_info *abbrev;
1634 struct attribute attr;
1635 struct funcinfo *func;
1636 struct varinfo *var;
1638 bfd_vma high_pc = 0;
1640 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1641 info_ptr += bytes_read;
1643 if (! abbrev_number)
1649 abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
1652 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1654 bfd_set_error (bfd_error_bad_value);
1659 if (abbrev->tag == DW_TAG_subprogram
1660 || abbrev->tag == DW_TAG_entry_point
1661 || abbrev->tag == DW_TAG_inlined_subroutine)
1663 bfd_size_type amt = sizeof (struct funcinfo);
1664 func = bfd_zalloc (abfd, amt);
1665 func->tag = abbrev->tag;
1666 func->nesting_level = nesting_level;
1667 func->prev_func = unit->function_table;
1668 unit->function_table = func;
1673 if (abbrev->tag == DW_TAG_variable)
1675 bfd_size_type amt = sizeof (struct varinfo);
1676 var = bfd_zalloc (abfd, amt);
1677 var->tag = abbrev->tag;
1679 var->prev_var = unit->variable_table;
1680 unit->variable_table = var;
1684 for (i = 0; i < abbrev->num_attrs; ++i)
1686 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1692 case DW_AT_call_file:
1693 func->caller_file = concat_filename (unit->line_table, attr.u.val);
1696 case DW_AT_call_line:
1697 func->caller_line = attr.u.val;
1700 case DW_AT_abstract_origin:
1701 func->name = find_abstract_instance_name (unit, attr.u.val);
1705 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
1706 if (func->name == NULL)
1707 func->name = attr.u.str;
1710 case DW_AT_MIPS_linkage_name:
1711 func->name = attr.u.str;
1715 low_pc = attr.u.val;
1719 high_pc = attr.u.val;
1723 read_rangelist (unit, &func->arange, attr.u.val);
1726 case DW_AT_decl_file:
1727 func->file = concat_filename (unit->line_table,
1731 case DW_AT_decl_line:
1732 func->line = attr.u.val;
1744 var->name = attr.u.str;
1747 case DW_AT_decl_file:
1748 var->file = concat_filename (unit->line_table,
1752 case DW_AT_decl_line:
1753 var->line = attr.u.val;
1756 case DW_AT_external:
1757 if (attr.u.val != 0)
1761 case DW_AT_location:
1767 case DW_FORM_block1:
1768 case DW_FORM_block2:
1769 case DW_FORM_block4:
1770 if (*attr.u.blk->data == DW_OP_addr)
1786 if (func && high_pc != 0)
1788 arange_add (unit->abfd, &func->arange, low_pc, high_pc);
1791 if (abbrev->has_children)
1798 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
1799 includes the compilation unit header that proceeds the DIE's, but
1800 does not include the length field that precedes each compilation
1801 unit header. END_PTR points one past the end of this comp unit.
1802 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
1804 This routine does not read the whole compilation unit; only enough
1805 to get to the line number information for the compilation unit. */
1807 static struct comp_unit *
1808 parse_comp_unit (bfd *abfd,
1809 struct dwarf2_debug *stash,
1810 bfd_vma unit_length,
1811 bfd_byte *info_ptr_unit,
1812 unsigned int offset_size)
1814 struct comp_unit* unit;
1815 unsigned int version;
1816 bfd_uint64_t abbrev_offset = 0;
1817 unsigned int addr_size;
1818 struct abbrev_info** abbrevs;
1819 unsigned int abbrev_number, bytes_read, i;
1820 struct abbrev_info *abbrev;
1821 struct attribute attr;
1822 bfd_byte *info_ptr = stash->info_ptr;
1823 bfd_byte *end_ptr = info_ptr + unit_length;
1826 bfd_vma high_pc = 0;
1828 version = read_2_bytes (abfd, info_ptr);
1830 BFD_ASSERT (offset_size == 4 || offset_size == 8);
1831 if (offset_size == 4)
1832 abbrev_offset = read_4_bytes (abfd, info_ptr);
1834 abbrev_offset = read_8_bytes (abfd, info_ptr);
1835 info_ptr += offset_size;
1836 addr_size = read_1_byte (abfd, info_ptr);
1841 (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 information."), version);
1842 bfd_set_error (bfd_error_bad_value);
1846 if (addr_size > sizeof (bfd_vma))
1848 (*_bfd_error_handler) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
1850 (unsigned int) sizeof (bfd_vma));
1851 bfd_set_error (bfd_error_bad_value);
1855 if (addr_size != 2 && addr_size != 4 && addr_size != 8)
1857 (*_bfd_error_handler) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size);
1858 bfd_set_error (bfd_error_bad_value);
1862 /* Read the abbrevs for this compilation unit into a table. */
1863 abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
1867 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1868 info_ptr += bytes_read;
1869 if (! abbrev_number)
1871 (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u."),
1873 bfd_set_error (bfd_error_bad_value);
1877 abbrev = lookup_abbrev (abbrev_number, abbrevs);
1880 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1882 bfd_set_error (bfd_error_bad_value);
1886 amt = sizeof (struct comp_unit);
1887 unit = bfd_zalloc (abfd, amt);
1889 unit->addr_size = addr_size;
1890 unit->offset_size = offset_size;
1891 unit->abbrevs = abbrevs;
1892 unit->end_ptr = end_ptr;
1893 unit->stash = stash;
1894 unit->info_ptr_unit = info_ptr_unit;
1896 for (i = 0; i < abbrev->num_attrs; ++i)
1898 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1900 /* Store the data if it is of an attribute we want to keep in a
1901 partial symbol table. */
1904 case DW_AT_stmt_list:
1906 unit->line_offset = attr.u.val;
1910 unit->name = attr.u.str;
1914 low_pc = attr.u.val;
1915 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
1916 this is the base address to use when reading location
1917 lists or range lists. */
1918 unit->base_address = low_pc;
1922 high_pc = attr.u.val;
1926 read_rangelist (unit, &unit->arange, attr.u.val);
1929 case DW_AT_comp_dir:
1931 char *comp_dir = attr.u.str;
1934 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1935 directory, get rid of it. */
1936 char *cp = strchr (comp_dir, ':');
1938 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
1941 unit->comp_dir = comp_dir;
1951 arange_add (unit->abfd, &unit->arange, low_pc, high_pc);
1954 unit->first_child_die_ptr = info_ptr;
1958 /* Return TRUE if UNIT contains the address given by ADDR. */
1961 comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
1963 struct arange *arange;
1968 arange = &unit->arange;
1971 if (addr >= arange->low && addr < arange->high)
1973 arange = arange->next;
1980 /* If UNIT contains ADDR, set the output parameters to the values for
1981 the line containing ADDR. The output parameters, FILENAME_PTR,
1982 FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
1985 Return TRUE if UNIT contains ADDR, and no errors were encountered;
1989 comp_unit_find_nearest_line (struct comp_unit *unit,
1991 const char **filename_ptr,
1992 const char **functionname_ptr,
1993 unsigned int *linenumber_ptr,
1994 struct dwarf2_debug *stash)
1998 struct funcinfo *function;
2003 if (! unit->line_table)
2005 if (! unit->stmtlist)
2011 unit->line_table = decode_line_info (unit, stash);
2013 if (! unit->line_table)
2019 if (unit->first_child_die_ptr < unit->end_ptr
2020 && ! scan_unit_for_symbols (unit))
2028 func_p = lookup_address_in_function_table (unit, addr,
2029 &function, functionname_ptr);
2030 if (func_p && (function->tag == DW_TAG_inlined_subroutine))
2031 stash->inliner_chain = function;
2032 line_p = lookup_address_in_line_info_table (unit->line_table, addr,
2033 function, filename_ptr,
2035 return line_p || func_p;
2038 /* If UNIT contains SYM at ADDR, set the output parameters to the
2039 values for the line containing SYM. The output parameters,
2040 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
2043 Return TRUE if UNIT contains SYM, and no errors were encountered;
2047 comp_unit_find_line (struct comp_unit *unit,
2050 const char **filename_ptr,
2051 unsigned int *linenumber_ptr,
2052 struct dwarf2_debug *stash)
2057 if (! unit->line_table)
2059 if (! unit->stmtlist)
2065 unit->line_table = decode_line_info (unit, stash);
2067 if (! unit->line_table)
2073 if (unit->first_child_die_ptr < unit->end_ptr
2074 && ! scan_unit_for_symbols (unit))
2081 if (sym->flags & BSF_FUNCTION)
2082 return lookup_symbol_in_function_table (unit, sym, addr,
2086 return lookup_symbol_in_variable_table (unit, sym, filename_ptr,
2090 /* Locate a section in a BFD containing debugging info. The search starts
2091 from the section after AFTER_SEC, or from the first section in the BFD if
2092 AFTER_SEC is NULL. The search works by examining the names of the
2093 sections. There are two permissiable names. The first is .debug_info.
2094 This is the standard DWARF2 name. The second is a prefix .gnu.linkonce.wi.
2095 This is a variation on the .debug_info section which has a checksum
2096 describing the contents appended onto the name. This allows the linker to
2097 identify and discard duplicate debugging sections for different
2098 compilation units. */
2099 #define DWARF2_DEBUG_INFO ".debug_info"
2100 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
2103 find_debug_info (bfd *abfd, asection *after_sec)
2108 msec = after_sec->next;
2110 msec = abfd->sections;
2114 if (strcmp (msec->name, DWARF2_DEBUG_INFO) == 0)
2117 if (strncmp (msec->name, GNU_LINKONCE_INFO, strlen (GNU_LINKONCE_INFO)) == 0)
2126 /* The DWARF2 version of find_nearest_line. Return TRUE if the line
2127 is found without error. ADDR_SIZE is the number of bytes in the
2128 initial .debug_info length field and in the abbreviation offset.
2129 You may use zero to indicate that the default value should be
2133 _bfd_dwarf2_find_nearest_line (bfd *abfd,
2137 const char **filename_ptr,
2138 const char **functionname_ptr,
2139 unsigned int *linenumber_ptr,
2140 unsigned int addr_size,
2143 /* Read each compilation unit from the section .debug_info, and check
2144 to see if it contains the address we are searching for. If yes,
2145 lookup the address, and return the line number info. If no, go
2146 on to the next compilation unit.
2148 We keep a list of all the previously read compilation units, and
2149 a pointer to the next un-read compilation unit. Check the
2150 previously read units before reading more. */
2151 struct dwarf2_debug *stash;
2153 /* What address are we looking for? */
2156 struct comp_unit* each;
2160 if (section->output_section)
2161 addr += section->output_section->vma + section->output_offset;
2163 addr += section->vma;
2164 *filename_ptr = NULL;
2165 *functionname_ptr = NULL;
2166 *linenumber_ptr = 0;
2168 /* The DWARF2 spec says that the initial length field, and the
2169 offset of the abbreviation table, should both be 4-byte values.
2170 However, some compilers do things differently. */
2173 BFD_ASSERT (addr_size == 4 || addr_size == 8);
2177 bfd_size_type total_size;
2179 bfd_size_type amt = sizeof (struct dwarf2_debug);
2181 stash = bfd_zalloc (abfd, amt);
2187 msec = find_debug_info (abfd, NULL);
2189 /* No dwarf2 info. Note that at this point the stash
2190 has been allocated, but contains zeros, this lets
2191 future calls to this function fail quicker. */
2194 /* There can be more than one DWARF2 info section in a BFD these days.
2195 Read them all in and produce one large stash. We do this in two
2196 passes - in the first pass we just accumulate the section sizes.
2197 In the second pass we read in the section's contents. The allows
2198 us to avoid reallocing the data as we add sections to the stash. */
2199 for (total_size = 0; msec; msec = find_debug_info (abfd, msec))
2200 total_size += msec->size;
2202 stash->info_ptr = bfd_alloc (abfd, total_size);
2203 if (stash->info_ptr == NULL)
2206 stash->info_ptr_end = stash->info_ptr;
2208 for (msec = find_debug_info (abfd, NULL);
2210 msec = find_debug_info (abfd, msec))
2213 bfd_size_type start;
2219 start = stash->info_ptr_end - stash->info_ptr;
2221 if ((bfd_simple_get_relocated_section_contents
2222 (abfd, msec, stash->info_ptr + start, symbols)) == NULL)
2225 stash->info_ptr_end = stash->info_ptr + start + size;
2228 BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size);
2230 stash->sec = find_debug_info (abfd, NULL);
2231 stash->sec_info_ptr = stash->info_ptr;
2232 stash->syms = symbols;
2235 /* A null info_ptr indicates that there is no dwarf2 info
2236 (or that an error occured while setting up the stash). */
2237 if (! stash->info_ptr)
2240 stash->inliner_chain = NULL;
2242 /* Check the previously read comp. units first. */
2243 for (each = stash->all_comp_units; each; each = each->next_unit)
2244 if (comp_unit_contains_address (each, addr))
2245 return comp_unit_find_nearest_line (each, addr, filename_ptr,
2246 functionname_ptr, linenumber_ptr,
2249 /* Read each remaining comp. units checking each as they are read. */
2250 while (stash->info_ptr < stash->info_ptr_end)
2254 unsigned int offset_size = addr_size;
2255 bfd_byte *info_ptr_unit = stash->info_ptr;
2257 length = read_4_bytes (abfd, stash->info_ptr);
2258 /* A 0xffffff length is the DWARF3 way of indicating we use
2259 64-bit offsets, instead of 32-bit offsets. */
2260 if (length == 0xffffffff)
2263 length = read_8_bytes (abfd, stash->info_ptr + 4);
2264 stash->info_ptr += 12;
2266 /* A zero length is the IRIX way of indicating 64-bit offsets,
2267 mostly because the 64-bit length will generally fit in 32
2268 bits, and the endianness helps. */
2269 else if (length == 0)
2272 length = read_4_bytes (abfd, stash->info_ptr + 4);
2273 stash->info_ptr += 8;
2275 /* In the absence of the hints above, we assume addr_size-sized
2276 offsets, for backward-compatibility with pre-DWARF3 64-bit
2278 else if (addr_size == 8)
2280 length = read_8_bytes (abfd, stash->info_ptr);
2281 stash->info_ptr += 8;
2284 stash->info_ptr += 4;
2288 each = parse_comp_unit (abfd, stash, length, info_ptr_unit,
2290 stash->info_ptr += length;
2292 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
2293 == stash->sec->size)
2295 stash->sec = find_debug_info (abfd, stash->sec);
2296 stash->sec_info_ptr = stash->info_ptr;
2301 each->next_unit = stash->all_comp_units;
2302 stash->all_comp_units = each;
2304 /* DW_AT_low_pc and DW_AT_high_pc are optional for
2305 compilation units. If we don't have them (i.e.,
2306 unit->high == 0), we need to consult the line info
2307 table to see if a compilation unit contains the given
2309 if (each->arange.high > 0)
2311 if (comp_unit_contains_address (each, addr))
2312 return comp_unit_find_nearest_line (each, addr,
2320 found = comp_unit_find_nearest_line (each, addr,
2335 /* The DWARF2 version of find_line. Return TRUE if the line is found
2339 _bfd_dwarf2_find_line (bfd *abfd,
2342 const char **filename_ptr,
2343 unsigned int *linenumber_ptr,
2344 unsigned int addr_size,
2347 /* Read each compilation unit from the section .debug_info, and check
2348 to see if it contains the address we are searching for. If yes,
2349 lookup the address, and return the line number info. If no, go
2350 on to the next compilation unit.
2352 We keep a list of all the previously read compilation units, and
2353 a pointer to the next un-read compilation unit. Check the
2354 previously read units before reading more. */
2355 struct dwarf2_debug *stash;
2357 /* What address are we looking for? */
2360 struct comp_unit* each;
2366 section = bfd_get_section (symbol);
2368 addr = symbol->value;
2369 if (section->output_section)
2370 addr += section->output_section->vma + section->output_offset;
2372 addr += section->vma;
2374 *filename_ptr = NULL;
2376 *filename_ptr = NULL;
2377 *linenumber_ptr = 0;
2381 bfd_size_type total_size;
2383 bfd_size_type amt = sizeof (struct dwarf2_debug);
2385 stash = bfd_zalloc (abfd, amt);
2391 msec = find_debug_info (abfd, NULL);
2393 /* No dwarf2 info. Note that at this point the stash
2394 has been allocated, but contains zeros, this lets
2395 future calls to this function fail quicker. */
2398 /* There can be more than one DWARF2 info section in a BFD these days.
2399 Read them all in and produce one large stash. We do this in two
2400 passes - in the first pass we just accumulate the section sizes.
2401 In the second pass we read in the section's contents. The allows
2402 us to avoid reallocing the data as we add sections to the stash. */
2403 for (total_size = 0; msec; msec = find_debug_info (abfd, msec))
2404 total_size += msec->size;
2406 stash->info_ptr = bfd_alloc (abfd, total_size);
2407 if (stash->info_ptr == NULL)
2410 stash->info_ptr_end = stash->info_ptr;
2412 for (msec = find_debug_info (abfd, NULL);
2414 msec = find_debug_info (abfd, msec))
2417 bfd_size_type start;
2423 start = stash->info_ptr_end - stash->info_ptr;
2425 if ((bfd_simple_get_relocated_section_contents
2426 (abfd, msec, stash->info_ptr + start, symbols)) == NULL)
2429 stash->info_ptr_end = stash->info_ptr + start + size;
2432 BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size);
2434 stash->sec = find_debug_info (abfd, NULL);
2435 stash->sec_info_ptr = stash->info_ptr;
2436 stash->syms = symbols;
2439 /* A null info_ptr indicates that there is no dwarf2 info
2440 (or that an error occured while setting up the stash). */
2441 if (! stash->info_ptr)
2444 stash->inliner_chain = NULL;
2446 /* Check the previously read comp. units first. */
2447 for (each = stash->all_comp_units; each; each = each->next_unit)
2448 if ((symbol->flags & BSF_FUNCTION) == 0
2449 || comp_unit_contains_address (each, addr))
2451 found = comp_unit_find_line (each, symbol, addr, filename_ptr,
2452 linenumber_ptr, stash);
2457 /* The DWARF2 spec says that the initial length field, and the
2458 offset of the abbreviation table, should both be 4-byte values.
2459 However, some compilers do things differently. */
2462 BFD_ASSERT (addr_size == 4 || addr_size == 8);
2464 /* Read each remaining comp. units checking each as they are read. */
2465 while (stash->info_ptr < stash->info_ptr_end)
2468 unsigned int offset_size = addr_size;
2469 bfd_byte *info_ptr_unit = stash->info_ptr;
2471 length = read_4_bytes (abfd, stash->info_ptr);
2472 /* A 0xffffff length is the DWARF3 way of indicating we use
2473 64-bit offsets, instead of 32-bit offsets. */
2474 if (length == 0xffffffff)
2477 length = read_8_bytes (abfd, stash->info_ptr + 4);
2478 stash->info_ptr += 12;
2480 /* A zero length is the IRIX way of indicating 64-bit offsets,
2481 mostly because the 64-bit length will generally fit in 32
2482 bits, and the endianness helps. */
2483 else if (length == 0)
2486 length = read_4_bytes (abfd, stash->info_ptr + 4);
2487 stash->info_ptr += 8;
2489 /* In the absence of the hints above, we assume addr_size-sized
2490 offsets, for backward-compatibility with pre-DWARF3 64-bit
2492 else if (addr_size == 8)
2494 length = read_8_bytes (abfd, stash->info_ptr);
2495 stash->info_ptr += 8;
2498 stash->info_ptr += 4;
2502 each = parse_comp_unit (abfd, stash, length, info_ptr_unit,
2504 stash->info_ptr += length;
2506 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
2507 == stash->sec->size)
2509 stash->sec = find_debug_info (abfd, stash->sec);
2510 stash->sec_info_ptr = stash->info_ptr;
2515 each->next_unit = stash->all_comp_units;
2516 stash->all_comp_units = each;
2518 /* DW_AT_low_pc and DW_AT_high_pc are optional for
2519 compilation units. If we don't have them (i.e.,
2520 unit->high == 0), we need to consult the line info
2521 table to see if a compilation unit contains the given
2523 found = (((symbol->flags & BSF_FUNCTION) == 0
2524 || each->arange.high <= 0
2525 || comp_unit_contains_address (each, addr))
2526 && comp_unit_find_line (each, symbol, addr,
2540 _bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED,
2541 const char **filename_ptr,
2542 const char **functionname_ptr,
2543 unsigned int *linenumber_ptr,
2546 struct dwarf2_debug *stash;
2551 struct funcinfo *func = stash->inliner_chain;
2552 if (func && func->caller_func)
2554 *filename_ptr = func->caller_file;
2555 *functionname_ptr = func->caller_func->name;
2556 *linenumber_ptr = func->caller_line;
2557 stash->inliner_chain = func->caller_func;
2566 _bfd_dwarf2_cleanup_debug_info (bfd *abfd)
2568 struct comp_unit *each;
2569 struct dwarf2_debug *stash;
2571 if (abfd == NULL || elf_tdata (abfd) == NULL)
2574 stash = elf_tdata (abfd)->dwarf2_find_line_info;
2579 for (each = stash->all_comp_units; each; each = each->next_unit)
2581 struct abbrev_info **abbrevs = each->abbrevs;
2584 for (i = 0; i < ABBREV_HASH_SIZE; i++)
2586 struct abbrev_info *abbrev = abbrevs[i];
2590 free (abbrev->attrs);
2591 abbrev = abbrev->next;
2595 if (each->line_table)
2597 free (each->line_table->dirs);
2598 free (each->line_table->files);
2602 free (stash->dwarf_abbrev_buffer);
2603 free (stash->dwarf_line_buffer);
2604 free (stash->dwarf_ranges_buffer);