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 */
723 /* Where the symbol is defined */
725 /* Is this a stack variable? */
726 unsigned int stack: 1;
729 /* Adds a new entry to the line_info list in the line_info_table, ensuring
730 that the list is sorted. Note that the line_info list is sorted from
731 highest to lowest VMA (with possible duplicates); that is,
732 line_info->prev_line always accesses an equal or smaller VMA. */
735 add_line_info (struct line_info_table *table,
742 bfd_size_type amt = sizeof (struct line_info);
743 struct line_info* info = bfd_alloc (table->abfd, amt);
745 /* Find the correct location for 'info'. Normally we will receive
746 new line_info data 1) in order and 2) with increasing VMAs.
747 However some compilers break the rules (cf. decode_line_info) and
748 so we include some heuristics for quickly finding the correct
749 location for 'info'. In particular, these heuristics optimize for
750 the common case in which the VMA sequence that we receive is a
751 list of locally sorted VMAs such as
752 p...z a...j (where a < j < p < z)
754 Note: table->lcl_head is used to head an *actual* or *possible*
755 sequence within the list (such as a...j) that is not directly
756 headed by table->last_line
758 Note: we may receive duplicate entries from 'decode_line_info'. */
761 if (!table->last_line
762 || address >= table->last_line->address)
764 /* Normal case: add 'info' to the beginning of the list */
765 info->prev_line = table->last_line;
766 table->last_line = info;
768 /* lcl_head: initialize to head a *possible* sequence at the end. */
769 if (!table->lcl_head)
770 table->lcl_head = info;
773 else if (!table->lcl_head->prev_line
774 && table->lcl_head->address > address)
776 /* Abnormal but easy: lcl_head is 1) at the *end* of the line
777 list and 2) the head of 'info'. */
778 info->prev_line = NULL;
779 table->lcl_head->prev_line = info;
782 else if (table->lcl_head->prev_line
783 && table->lcl_head->address > address
784 && address >= table->lcl_head->prev_line->address)
786 /* Abnormal but easy: lcl_head is 1) in the *middle* of the line
787 list and 2) the head of 'info'. */
788 info->prev_line = table->lcl_head->prev_line;
789 table->lcl_head->prev_line = info;
794 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head' are valid
795 heads for 'info'. Reset 'lcl_head' and repeat. */
796 struct line_info* li2 = table->last_line; /* always non-NULL */
797 struct line_info* li1 = li2->prev_line;
801 if (li2->address > address && address >= li1->address)
804 li2 = li1; /* always non-NULL */
805 li1 = li1->prev_line;
807 table->lcl_head = li2;
810 /* Set member data of 'info'. */
811 info->address = address;
813 info->column = column;
814 info->end_sequence = end_sequence;
816 if (filename && filename[0])
818 info->filename = bfd_alloc (table->abfd, strlen (filename) + 1);
820 strcpy (info->filename, filename);
823 info->filename = NULL;
826 /* Extract a fully qualified filename from a line info table.
827 The returned string has been malloc'ed and it is the caller's
828 responsibility to free it. */
831 concat_filename (struct line_info_table *table, unsigned int file)
835 if (file - 1 >= table->num_files)
837 (*_bfd_error_handler)
838 (_("Dwarf Error: mangled line number section (bad file number)."));
839 return strdup ("<unknown>");
842 filename = table->files[file - 1].name;
844 if (! IS_ABSOLUTE_PATH (filename))
846 char *dirname = (table->files[file - 1].dir
847 ? table->dirs[table->files[file - 1].dir - 1]
850 /* Not all tools set DW_AT_comp_dir, so dirname may be unknown.
851 The best we can do is return the filename part. */
854 unsigned int len = strlen (dirname) + strlen (filename) + 2;
857 name = bfd_malloc (len);
859 sprintf (name, "%s/%s", dirname, filename);
864 return strdup (filename);
868 arange_add (bfd *abfd, struct arange *first_arange, bfd_vma low_pc, bfd_vma high_pc)
870 struct arange *arange;
872 /* If the first arange is empty, use it. */
873 if (first_arange->high == 0)
875 first_arange->low = low_pc;
876 first_arange->high = high_pc;
880 /* Next see if we can cheaply extend an existing range. */
881 arange = first_arange;
884 if (low_pc == arange->high)
886 arange->high = high_pc;
889 if (high_pc == arange->low)
891 arange->low = low_pc;
894 arange = arange->next;
898 /* Need to allocate a new arange and insert it into the arange list.
899 Order isn't significant, so just insert after the first arange. */
900 arange = bfd_zalloc (abfd, sizeof (*arange));
901 arange->low = low_pc;
902 arange->high = high_pc;
903 arange->next = first_arange->next;
904 first_arange->next = arange;
907 /* Decode the line number information for UNIT. */
909 static struct line_info_table*
910 decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
912 bfd *abfd = unit->abfd;
913 struct line_info_table* table;
917 unsigned int i, bytes_read, offset_size;
918 char *cur_file, *cur_dir;
919 unsigned char op_code, extended_op, adj_opcode;
922 if (! stash->dwarf_line_buffer)
926 msec = bfd_get_section_by_name (abfd, ".debug_line");
929 (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_line section."));
930 bfd_set_error (bfd_error_bad_value);
934 stash->dwarf_line_size = msec->size;
935 stash->dwarf_line_buffer
936 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
938 if (! stash->dwarf_line_buffer)
942 /* It is possible to get a bad value for the line_offset. Validate
943 it here so that we won't get a segfault below. */
944 if (unit->line_offset >= stash->dwarf_line_size)
946 (*_bfd_error_handler) (_("Dwarf Error: Line offset (%lu) greater than or equal to .debug_line size (%lu)."),
947 unit->line_offset, stash->dwarf_line_size);
948 bfd_set_error (bfd_error_bad_value);
952 amt = sizeof (struct line_info_table);
953 table = bfd_alloc (abfd, amt);
955 table->comp_dir = unit->comp_dir;
957 table->num_files = 0;
964 table->last_line = NULL;
965 table->lcl_head = NULL;
967 line_ptr = stash->dwarf_line_buffer + unit->line_offset;
969 /* Read in the prologue. */
970 lh.total_length = read_4_bytes (abfd, line_ptr);
973 if (lh.total_length == 0xffffffff)
975 lh.total_length = read_8_bytes (abfd, line_ptr);
979 else if (lh.total_length == 0 && unit->addr_size == 8)
981 /* Handle (non-standard) 64-bit DWARF2 formats. */
982 lh.total_length = read_4_bytes (abfd, line_ptr);
986 line_end = line_ptr + lh.total_length;
987 lh.version = read_2_bytes (abfd, line_ptr);
989 if (offset_size == 4)
990 lh.prologue_length = read_4_bytes (abfd, line_ptr);
992 lh.prologue_length = read_8_bytes (abfd, line_ptr);
993 line_ptr += offset_size;
994 lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
996 lh.default_is_stmt = read_1_byte (abfd, line_ptr);
998 lh.line_base = read_1_signed_byte (abfd, line_ptr);
1000 lh.line_range = read_1_byte (abfd, line_ptr);
1002 lh.opcode_base = read_1_byte (abfd, line_ptr);
1004 amt = lh.opcode_base * sizeof (unsigned char);
1005 lh.standard_opcode_lengths = bfd_alloc (abfd, amt);
1007 lh.standard_opcode_lengths[0] = 1;
1009 for (i = 1; i < lh.opcode_base; ++i)
1011 lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
1015 /* Read directory table. */
1016 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1018 line_ptr += bytes_read;
1020 if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
1024 amt = table->num_dirs + DIR_ALLOC_CHUNK;
1025 amt *= sizeof (char *);
1027 tmp = bfd_realloc (table->dirs, amt);
1036 table->dirs[table->num_dirs++] = cur_dir;
1039 line_ptr += bytes_read;
1041 /* Read file name table. */
1042 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1044 line_ptr += bytes_read;
1046 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1048 struct fileinfo *tmp;
1050 amt = table->num_files + FILE_ALLOC_CHUNK;
1051 amt *= sizeof (struct fileinfo);
1053 tmp = bfd_realloc (table->files, amt);
1056 free (table->files);
1063 table->files[table->num_files].name = cur_file;
1064 table->files[table->num_files].dir =
1065 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1066 line_ptr += bytes_read;
1067 table->files[table->num_files].time =
1068 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1069 line_ptr += bytes_read;
1070 table->files[table->num_files].size =
1071 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1072 line_ptr += bytes_read;
1076 line_ptr += bytes_read;
1078 /* Read the statement sequences until there's nothing left. */
1079 while (line_ptr < line_end)
1081 /* State machine registers. */
1082 bfd_vma address = 0;
1083 char * filename = table->num_files ? concat_filename (table, 1) : NULL;
1084 unsigned int line = 1;
1085 unsigned int column = 0;
1086 int is_stmt = lh.default_is_stmt;
1087 int basic_block = 0;
1088 int end_sequence = 0;
1089 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1090 compilers generate address sequences that are wildly out of
1091 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1092 for ia64-Linux). Thus, to determine the low and high
1093 address, we must compare on every DW_LNS_copy, etc. */
1094 bfd_vma low_pc = (bfd_vma) -1;
1095 bfd_vma high_pc = 0;
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 (address < low_pc)
1115 if (address > high_pc)
1118 else switch (op_code)
1120 case DW_LNS_extended_op:
1121 /* Ignore length. */
1123 extended_op = read_1_byte (abfd, line_ptr);
1126 switch (extended_op)
1128 case DW_LNE_end_sequence:
1130 add_line_info (table, address, filename, line, column,
1132 if (address < low_pc)
1134 if (address > high_pc)
1136 arange_add (unit->abfd, &unit->arange, low_pc, high_pc);
1138 case DW_LNE_set_address:
1139 address = read_address (unit, line_ptr);
1140 line_ptr += unit->addr_size;
1142 case DW_LNE_define_file:
1143 cur_file = read_string (abfd, line_ptr, &bytes_read);
1144 line_ptr += bytes_read;
1145 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1147 struct fileinfo *tmp;
1149 amt = table->num_files + FILE_ALLOC_CHUNK;
1150 amt *= sizeof (struct fileinfo);
1151 tmp = bfd_realloc (table->files, amt);
1154 free (table->files);
1161 table->files[table->num_files].name = cur_file;
1162 table->files[table->num_files].dir =
1163 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1164 line_ptr += bytes_read;
1165 table->files[table->num_files].time =
1166 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1167 line_ptr += bytes_read;
1168 table->files[table->num_files].size =
1169 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1170 line_ptr += bytes_read;
1174 (*_bfd_error_handler) (_("Dwarf Error: mangled line number section."));
1175 bfd_set_error (bfd_error_bad_value);
1177 free (table->files);
1183 add_line_info (table, address, filename, line, column, 0);
1185 if (address < low_pc)
1187 if (address > high_pc)
1190 case DW_LNS_advance_pc:
1191 address += lh.minimum_instruction_length
1192 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1193 line_ptr += bytes_read;
1195 case DW_LNS_advance_line:
1196 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
1197 line_ptr += bytes_read;
1199 case DW_LNS_set_file:
1203 /* The file and directory tables are 0
1204 based, the references are 1 based. */
1205 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1206 line_ptr += bytes_read;
1209 filename = concat_filename (table, file);
1212 case DW_LNS_set_column:
1213 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1214 line_ptr += bytes_read;
1216 case DW_LNS_negate_stmt:
1217 is_stmt = (!is_stmt);
1219 case DW_LNS_set_basic_block:
1222 case DW_LNS_const_add_pc:
1223 address += lh.minimum_instruction_length
1224 * ((255 - lh.opcode_base) / lh.line_range);
1226 case DW_LNS_fixed_advance_pc:
1227 address += read_2_bytes (abfd, line_ptr);
1234 /* Unknown standard opcode, ignore it. */
1235 for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
1237 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1238 line_ptr += bytes_read;
1251 /* If ADDR is within TABLE set the output parameters and return TRUE,
1252 otherwise return FALSE. The output parameters, FILENAME_PTR and
1253 LINENUMBER_PTR, are pointers to the objects to be filled in. */
1256 lookup_address_in_line_info_table (struct line_info_table *table,
1258 struct funcinfo *function,
1259 const char **filename_ptr,
1260 unsigned int *linenumber_ptr)
1262 /* Note: table->last_line should be a descendingly sorted list. */
1263 struct line_info* next_line = table->last_line;
1264 struct line_info* each_line = NULL;
1265 *filename_ptr = NULL;
1270 each_line = next_line->prev_line;
1272 /* Check for large addresses */
1273 if (addr > next_line->address)
1274 each_line = NULL; /* ensure we skip over the normal case */
1276 /* Normal case: search the list; save */
1277 while (each_line && next_line)
1279 /* If we have an address match, save this info. This allows us
1280 to return as good as results as possible for strange debugging
1282 bfd_boolean addr_match = FALSE;
1283 if (each_line->address <= addr && addr < next_line->address)
1287 /* If this line appears to span functions, and addr is in the
1288 later function, return the first line of that function instead
1289 of the last line of the earlier one. This check is for GCC
1290 2.95, which emits the first line number for a function late. */
1292 if (function != NULL)
1295 struct arange *arange;
1297 /* Find the lowest address in the function's range list */
1298 lowest_pc = function->arange.low;
1299 for (arange = &function->arange;
1301 arange = arange->next)
1303 if (function->arange.low < lowest_pc)
1304 lowest_pc = function->arange.low;
1306 /* Check for spanning function and set outgoing line info */
1307 if (addr >= lowest_pc
1308 && each_line->address < lowest_pc
1309 && next_line->address > lowest_pc)
1311 *filename_ptr = next_line->filename;
1312 *linenumber_ptr = next_line->line;
1316 *filename_ptr = each_line->filename;
1317 *linenumber_ptr = each_line->line;
1322 *filename_ptr = each_line->filename;
1323 *linenumber_ptr = each_line->line;
1327 if (addr_match && !each_line->end_sequence)
1328 return TRUE; /* we have definitely found what we want */
1330 next_line = each_line;
1331 each_line = each_line->prev_line;
1334 /* At this point each_line is NULL but next_line is not. If we found
1335 a candidate end-of-sequence point in the loop above, we can return
1336 that (compatibility with a bug in the Intel compiler); otherwise,
1337 assuming that we found the containing function for this address in
1338 this compilation unit, return the first line we have a number for
1339 (compatibility with GCC 2.95). */
1340 if (*filename_ptr == NULL && function != NULL)
1342 *filename_ptr = next_line->filename;
1343 *linenumber_ptr = next_line->line;
1350 /* Read in the .debug_ranges section for future reference */
1353 read_debug_ranges (struct comp_unit *unit)
1355 struct dwarf2_debug *stash = unit->stash;
1356 if (! stash->dwarf_ranges_buffer)
1358 bfd *abfd = unit->abfd;
1361 msec = bfd_get_section_by_name (abfd, ".debug_ranges");
1364 (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_ranges section."));
1365 bfd_set_error (bfd_error_bad_value);
1369 stash->dwarf_ranges_size = msec->size;
1370 stash->dwarf_ranges_buffer
1371 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
1373 if (! stash->dwarf_ranges_buffer)
1379 /* Function table functions. */
1381 /* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return TRUE.
1382 Note that we need to find the function that has the smallest
1383 range that contains ADDR, to handle inlined functions without
1384 depending upon them being ordered in TABLE by increasing range. */
1387 lookup_address_in_function_table (struct comp_unit *unit,
1389 struct funcinfo **function_ptr,
1390 const char **functionname_ptr)
1392 struct funcinfo* each_func;
1393 struct funcinfo* best_fit = NULL;
1394 struct arange *arange;
1396 for (each_func = unit->function_table;
1398 each_func = each_func->prev_func)
1400 for (arange = &each_func->arange;
1402 arange = arange->next)
1404 if (addr >= arange->low && addr < arange->high)
1407 ((arange->high - arange->low) < (best_fit->arange.high - best_fit->arange.low)))
1408 best_fit = each_func;
1415 struct funcinfo* curr_func = best_fit;
1417 *functionname_ptr = best_fit->name;
1418 *function_ptr = best_fit;
1420 /* If we found a match and it is a function that was inlined,
1421 traverse the function list looking for the function at the
1422 next higher scope and save a pointer to it for future use.
1423 Note that because of the way the DWARF info is generated, and
1424 the way we build the function list, the first function at the
1425 next higher level is the one we want. */
1427 for (each_func = best_fit -> prev_func;
1428 each_func && (curr_func->tag == DW_TAG_inlined_subroutine);
1429 each_func = each_func->prev_func)
1431 if (each_func->nesting_level < curr_func->nesting_level)
1433 curr_func->caller_func = each_func;
1434 curr_func = each_func;
1445 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
1446 and LINENUMBER_PTR, and return TRUE. */
1449 lookup_symbol_in_function_table (struct comp_unit *unit,
1452 const char **filename_ptr,
1453 unsigned int *linenumber_ptr)
1455 struct funcinfo* each_func;
1456 struct funcinfo* best_fit = NULL;
1457 struct arange *arange;
1458 const char *name = bfd_asymbol_name (sym);
1459 asection *sec = bfd_get_section (sym);
1461 for (each_func = unit->function_table;
1463 each_func = each_func->prev_func)
1465 for (arange = &each_func->arange;
1467 arange = arange->next)
1469 if ((!each_func->sec || each_func->sec == sec)
1470 && addr >= arange->low
1471 && addr < arange->high
1472 && strcmp (name, each_func->name) == 0
1474 || ((arange->high - arange->low)
1475 < (best_fit->arange.high - best_fit->arange.low))))
1476 best_fit = each_func;
1482 best_fit->sec = sec;
1483 *filename_ptr = best_fit->file;
1484 *linenumber_ptr = best_fit->line;
1491 /* Variable table functions. */
1493 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
1494 LINENUMBER_PTR, and return TRUE. */
1497 lookup_symbol_in_variable_table (struct comp_unit *unit,
1500 const char **filename_ptr,
1501 unsigned int *linenumber_ptr)
1503 const char *name = bfd_asymbol_name (sym);
1504 asection *sec = bfd_get_section (sym);
1505 struct varinfo* each;
1507 for (each = unit->variable_table; each; each = each->prev_var)
1508 if (each->stack == 0
1509 && each->file != NULL
1510 && each->name != NULL
1511 && each->addr == addr
1512 && (!each->sec || each->sec == sec)
1513 && strcmp (name, each->name) == 0)
1519 *filename_ptr = each->file;
1520 *linenumber_ptr = each->line;
1528 find_abstract_instance_name (struct comp_unit *unit, bfd_uint64_t die_ref)
1530 bfd *abfd = unit->abfd;
1532 unsigned int abbrev_number, bytes_read, i;
1533 struct abbrev_info *abbrev;
1534 struct attribute attr;
1537 info_ptr = unit->info_ptr_unit + die_ref;
1538 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1539 info_ptr += bytes_read;
1543 abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
1546 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1548 bfd_set_error (bfd_error_bad_value);
1552 for (i = 0; i < abbrev->num_attrs && !name; ++i)
1554 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1560 case DW_AT_specification:
1561 name = find_abstract_instance_name (unit, attr.u.val);
1573 read_rangelist (struct comp_unit *unit, struct arange *arange, bfd_uint64_t offset)
1575 bfd_byte *ranges_ptr;
1576 bfd_vma base_address = unit->base_address;
1578 if (! unit->stash->dwarf_ranges_buffer)
1580 if (! read_debug_ranges (unit))
1583 ranges_ptr = unit->stash->dwarf_ranges_buffer + offset;
1590 if (unit->offset_size == 4)
1592 low_pc = read_4_bytes (unit->abfd, ranges_ptr);
1594 high_pc = read_4_bytes (unit->abfd, ranges_ptr);
1599 low_pc = read_8_bytes (unit->abfd, ranges_ptr);
1601 high_pc = read_8_bytes (unit->abfd, ranges_ptr);
1604 if (low_pc == 0 && high_pc == 0)
1606 if (low_pc == -1UL && high_pc != -1UL)
1607 base_address = high_pc;
1609 arange_add (unit->abfd, arange, base_address + low_pc, base_address + high_pc);
1613 /* DWARF2 Compilation unit functions. */
1615 /* Scan over each die in a comp. unit looking for functions to add
1616 to the function table and variables to the variable table. */
1619 scan_unit_for_symbols (struct comp_unit *unit)
1621 bfd *abfd = unit->abfd;
1622 bfd_byte *info_ptr = unit->first_child_die_ptr;
1623 int nesting_level = 1;
1625 while (nesting_level)
1627 unsigned int abbrev_number, bytes_read, i;
1628 struct abbrev_info *abbrev;
1629 struct attribute attr;
1630 struct funcinfo *func;
1631 struct varinfo *var;
1633 bfd_vma high_pc = 0;
1635 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1636 info_ptr += bytes_read;
1638 if (! abbrev_number)
1644 abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
1647 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1649 bfd_set_error (bfd_error_bad_value);
1654 if (abbrev->tag == DW_TAG_subprogram
1655 || abbrev->tag == DW_TAG_entry_point
1656 || abbrev->tag == DW_TAG_inlined_subroutine)
1658 bfd_size_type amt = sizeof (struct funcinfo);
1659 func = bfd_zalloc (abfd, amt);
1660 func->tag = abbrev->tag;
1661 func->nesting_level = nesting_level;
1662 func->prev_func = unit->function_table;
1663 unit->function_table = func;
1668 if (abbrev->tag == DW_TAG_variable)
1670 bfd_size_type amt = sizeof (struct varinfo);
1671 var = bfd_zalloc (abfd, amt);
1672 var->tag = abbrev->tag;
1674 var->prev_var = unit->variable_table;
1675 unit->variable_table = var;
1679 for (i = 0; i < abbrev->num_attrs; ++i)
1681 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1687 case DW_AT_call_file:
1688 func->caller_file = concat_filename (unit->line_table, attr.u.val);
1691 case DW_AT_call_line:
1692 func->caller_line = attr.u.val;
1695 case DW_AT_abstract_origin:
1696 func->name = find_abstract_instance_name (unit, attr.u.val);
1700 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
1701 if (func->name == NULL)
1702 func->name = attr.u.str;
1705 case DW_AT_MIPS_linkage_name:
1706 func->name = attr.u.str;
1710 low_pc = attr.u.val;
1714 high_pc = attr.u.val;
1718 read_rangelist (unit, &func->arange, attr.u.val);
1721 case DW_AT_decl_file:
1722 func->file = concat_filename (unit->line_table,
1726 case DW_AT_decl_line:
1727 func->line = attr.u.val;
1739 var->name = attr.u.str;
1742 case DW_AT_decl_file:
1743 var->file = concat_filename (unit->line_table,
1747 case DW_AT_decl_line:
1748 var->line = attr.u.val;
1751 case DW_AT_external:
1752 if (attr.u.val != 0)
1756 case DW_AT_location:
1760 case DW_FORM_block1:
1761 case DW_FORM_block2:
1762 case DW_FORM_block4:
1763 if (*attr.u.blk->data == DW_OP_addr)
1766 var->addr = bfd_get ((attr.u.blk->size - 1) * 8,
1768 attr.u.blk->data + 1);
1783 if (func && high_pc != 0)
1785 arange_add (unit->abfd, &func->arange, low_pc, high_pc);
1788 if (abbrev->has_children)
1795 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
1796 includes the compilation unit header that proceeds the DIE's, but
1797 does not include the length field that precedes each compilation
1798 unit header. END_PTR points one past the end of this comp unit.
1799 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
1801 This routine does not read the whole compilation unit; only enough
1802 to get to the line number information for the compilation unit. */
1804 static struct comp_unit *
1805 parse_comp_unit (bfd *abfd,
1806 struct dwarf2_debug *stash,
1807 bfd_vma unit_length,
1808 bfd_byte *info_ptr_unit,
1809 unsigned int offset_size)
1811 struct comp_unit* unit;
1812 unsigned int version;
1813 bfd_uint64_t abbrev_offset = 0;
1814 unsigned int addr_size;
1815 struct abbrev_info** abbrevs;
1816 unsigned int abbrev_number, bytes_read, i;
1817 struct abbrev_info *abbrev;
1818 struct attribute attr;
1819 bfd_byte *info_ptr = stash->info_ptr;
1820 bfd_byte *end_ptr = info_ptr + unit_length;
1823 bfd_vma high_pc = 0;
1825 version = read_2_bytes (abfd, info_ptr);
1827 BFD_ASSERT (offset_size == 4 || offset_size == 8);
1828 if (offset_size == 4)
1829 abbrev_offset = read_4_bytes (abfd, info_ptr);
1831 abbrev_offset = read_8_bytes (abfd, info_ptr);
1832 info_ptr += offset_size;
1833 addr_size = read_1_byte (abfd, info_ptr);
1838 (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 information."), version);
1839 bfd_set_error (bfd_error_bad_value);
1843 if (addr_size > sizeof (bfd_vma))
1845 (*_bfd_error_handler) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
1847 (unsigned int) sizeof (bfd_vma));
1848 bfd_set_error (bfd_error_bad_value);
1852 if (addr_size != 2 && addr_size != 4 && addr_size != 8)
1854 (*_bfd_error_handler) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size);
1855 bfd_set_error (bfd_error_bad_value);
1859 /* Read the abbrevs for this compilation unit into a table. */
1860 abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
1864 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1865 info_ptr += bytes_read;
1866 if (! abbrev_number)
1868 (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u."),
1870 bfd_set_error (bfd_error_bad_value);
1874 abbrev = lookup_abbrev (abbrev_number, abbrevs);
1877 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1879 bfd_set_error (bfd_error_bad_value);
1883 amt = sizeof (struct comp_unit);
1884 unit = bfd_zalloc (abfd, amt);
1886 unit->addr_size = addr_size;
1887 unit->offset_size = offset_size;
1888 unit->abbrevs = abbrevs;
1889 unit->end_ptr = end_ptr;
1890 unit->stash = stash;
1891 unit->info_ptr_unit = info_ptr_unit;
1893 for (i = 0; i < abbrev->num_attrs; ++i)
1895 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1897 /* Store the data if it is of an attribute we want to keep in a
1898 partial symbol table. */
1901 case DW_AT_stmt_list:
1903 unit->line_offset = attr.u.val;
1907 unit->name = attr.u.str;
1911 low_pc = attr.u.val;
1912 /* If the compilation unit DIE has a DW_AT_low_pc attribute,
1913 this is the base address to use when reading location
1914 lists or range lists. */
1915 unit->base_address = low_pc;
1919 high_pc = attr.u.val;
1923 read_rangelist (unit, &unit->arange, attr.u.val);
1926 case DW_AT_comp_dir:
1928 char *comp_dir = attr.u.str;
1931 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1932 directory, get rid of it. */
1933 char *cp = strchr (comp_dir, ':');
1935 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
1938 unit->comp_dir = comp_dir;
1948 arange_add (unit->abfd, &unit->arange, low_pc, high_pc);
1951 unit->first_child_die_ptr = info_ptr;
1955 /* Return TRUE if UNIT contains the address given by ADDR. */
1958 comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
1960 struct arange *arange;
1965 arange = &unit->arange;
1968 if (addr >= arange->low && addr < arange->high)
1970 arange = arange->next;
1977 /* If UNIT contains ADDR, set the output parameters to the values for
1978 the line containing ADDR. The output parameters, FILENAME_PTR,
1979 FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
1982 Return TRUE if UNIT contains ADDR, and no errors were encountered;
1986 comp_unit_find_nearest_line (struct comp_unit *unit,
1988 const char **filename_ptr,
1989 const char **functionname_ptr,
1990 unsigned int *linenumber_ptr,
1991 struct dwarf2_debug *stash)
1995 struct funcinfo *function;
2000 if (! unit->line_table)
2002 if (! unit->stmtlist)
2008 unit->line_table = decode_line_info (unit, stash);
2010 if (! unit->line_table)
2016 if (unit->first_child_die_ptr < unit->end_ptr
2017 && ! scan_unit_for_symbols (unit))
2025 func_p = lookup_address_in_function_table (unit, addr,
2026 &function, functionname_ptr);
2027 if (func_p && (function->tag == DW_TAG_inlined_subroutine))
2028 stash->inliner_chain = function;
2029 line_p = lookup_address_in_line_info_table (unit->line_table, addr,
2030 function, filename_ptr,
2032 return line_p || func_p;
2035 /* If UNIT contains SYM at ADDR, set the output parameters to the
2036 values for the line containing SYM. The output parameters,
2037 FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
2040 Return TRUE if UNIT contains SYM, and no errors were encountered;
2044 comp_unit_find_line (struct comp_unit *unit,
2047 const char **filename_ptr,
2048 unsigned int *linenumber_ptr,
2049 struct dwarf2_debug *stash)
2054 if (! unit->line_table)
2056 if (! unit->stmtlist)
2062 unit->line_table = decode_line_info (unit, stash);
2064 if (! unit->line_table)
2070 if (unit->first_child_die_ptr < unit->end_ptr
2071 && ! scan_unit_for_symbols (unit))
2078 if (sym->flags & BSF_FUNCTION)
2079 return lookup_symbol_in_function_table (unit, sym, addr,
2083 return lookup_symbol_in_variable_table (unit, sym, addr,
2088 /* Locate a section in a BFD containing debugging info. The search starts
2089 from the section after AFTER_SEC, or from the first section in the BFD if
2090 AFTER_SEC is NULL. The search works by examining the names of the
2091 sections. There are two permissiable names. The first is .debug_info.
2092 This is the standard DWARF2 name. The second is a prefix .gnu.linkonce.wi.
2093 This is a variation on the .debug_info section which has a checksum
2094 describing the contents appended onto the name. This allows the linker to
2095 identify and discard duplicate debugging sections for different
2096 compilation units. */
2097 #define DWARF2_DEBUG_INFO ".debug_info"
2098 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
2101 find_debug_info (bfd *abfd, asection *after_sec)
2106 msec = after_sec->next;
2108 msec = abfd->sections;
2112 if (strcmp (msec->name, DWARF2_DEBUG_INFO) == 0)
2115 if (strncmp (msec->name, GNU_LINKONCE_INFO, strlen (GNU_LINKONCE_INFO)) == 0)
2124 /* The DWARF2 version of find_nearest_line. Return TRUE if the line
2125 is found without error. ADDR_SIZE is the number of bytes in the
2126 initial .debug_info length field and in the abbreviation offset.
2127 You may use zero to indicate that the default value should be
2131 _bfd_dwarf2_find_nearest_line (bfd *abfd,
2135 const char **filename_ptr,
2136 const char **functionname_ptr,
2137 unsigned int *linenumber_ptr,
2138 unsigned int addr_size,
2141 /* Read each compilation unit from the section .debug_info, and check
2142 to see if it contains the address we are searching for. If yes,
2143 lookup the address, and return the line number info. If no, go
2144 on to the next compilation unit.
2146 We keep a list of all the previously read compilation units, and
2147 a pointer to the next un-read compilation unit. Check the
2148 previously read units before reading more. */
2149 struct dwarf2_debug *stash;
2151 /* What address are we looking for? */
2154 struct comp_unit* each;
2158 if (section->output_section)
2159 addr += section->output_section->vma + section->output_offset;
2161 addr += section->vma;
2162 *filename_ptr = NULL;
2163 *functionname_ptr = NULL;
2164 *linenumber_ptr = 0;
2166 /* The DWARF2 spec says that the initial length field, and the
2167 offset of the abbreviation table, should both be 4-byte values.
2168 However, some compilers do things differently. */
2171 BFD_ASSERT (addr_size == 4 || addr_size == 8);
2175 bfd_size_type total_size;
2177 bfd_size_type amt = sizeof (struct dwarf2_debug);
2179 stash = bfd_zalloc (abfd, amt);
2185 msec = find_debug_info (abfd, NULL);
2187 /* No dwarf2 info. Note that at this point the stash
2188 has been allocated, but contains zeros, this lets
2189 future calls to this function fail quicker. */
2192 /* There can be more than one DWARF2 info section in a BFD these days.
2193 Read them all in and produce one large stash. We do this in two
2194 passes - in the first pass we just accumulate the section sizes.
2195 In the second pass we read in the section's contents. The allows
2196 us to avoid reallocing the data as we add sections to the stash. */
2197 for (total_size = 0; msec; msec = find_debug_info (abfd, msec))
2198 total_size += msec->size;
2200 stash->info_ptr = bfd_alloc (abfd, total_size);
2201 if (stash->info_ptr == NULL)
2204 stash->info_ptr_end = stash->info_ptr;
2206 for (msec = find_debug_info (abfd, NULL);
2208 msec = find_debug_info (abfd, msec))
2211 bfd_size_type start;
2217 start = stash->info_ptr_end - stash->info_ptr;
2219 if ((bfd_simple_get_relocated_section_contents
2220 (abfd, msec, stash->info_ptr + start, symbols)) == NULL)
2223 stash->info_ptr_end = stash->info_ptr + start + size;
2226 BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size);
2228 stash->sec = find_debug_info (abfd, NULL);
2229 stash->sec_info_ptr = stash->info_ptr;
2230 stash->syms = symbols;
2233 /* A null info_ptr indicates that there is no dwarf2 info
2234 (or that an error occured while setting up the stash). */
2235 if (! stash->info_ptr)
2238 stash->inliner_chain = NULL;
2240 /* Check the previously read comp. units first. */
2241 for (each = stash->all_comp_units; each; each = each->next_unit)
2242 if (comp_unit_contains_address (each, addr))
2243 return comp_unit_find_nearest_line (each, addr, filename_ptr,
2244 functionname_ptr, linenumber_ptr,
2247 /* Read each remaining comp. units checking each as they are read. */
2248 while (stash->info_ptr < stash->info_ptr_end)
2252 unsigned int offset_size = addr_size;
2253 bfd_byte *info_ptr_unit = stash->info_ptr;
2255 length = read_4_bytes (abfd, stash->info_ptr);
2256 /* A 0xffffff length is the DWARF3 way of indicating we use
2257 64-bit offsets, instead of 32-bit offsets. */
2258 if (length == 0xffffffff)
2261 length = read_8_bytes (abfd, stash->info_ptr + 4);
2262 stash->info_ptr += 12;
2264 /* A zero length is the IRIX way of indicating 64-bit offsets,
2265 mostly because the 64-bit length will generally fit in 32
2266 bits, and the endianness helps. */
2267 else if (length == 0)
2270 length = read_4_bytes (abfd, stash->info_ptr + 4);
2271 stash->info_ptr += 8;
2273 /* In the absence of the hints above, we assume addr_size-sized
2274 offsets, for backward-compatibility with pre-DWARF3 64-bit
2276 else if (addr_size == 8)
2278 length = read_8_bytes (abfd, stash->info_ptr);
2279 stash->info_ptr += 8;
2282 stash->info_ptr += 4;
2286 each = parse_comp_unit (abfd, stash, length, info_ptr_unit,
2288 stash->info_ptr += length;
2290 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
2291 == stash->sec->size)
2293 stash->sec = find_debug_info (abfd, stash->sec);
2294 stash->sec_info_ptr = stash->info_ptr;
2299 each->next_unit = stash->all_comp_units;
2300 stash->all_comp_units = each;
2302 /* DW_AT_low_pc and DW_AT_high_pc are optional for
2303 compilation units. If we don't have them (i.e.,
2304 unit->high == 0), we need to consult the line info
2305 table to see if a compilation unit contains the given
2307 if (each->arange.high > 0)
2309 if (comp_unit_contains_address (each, addr))
2310 return comp_unit_find_nearest_line (each, addr,
2318 found = comp_unit_find_nearest_line (each, addr,
2333 /* The DWARF2 version of find_line. Return TRUE if the line is found
2337 _bfd_dwarf2_find_line (bfd *abfd,
2340 const char **filename_ptr,
2341 unsigned int *linenumber_ptr,
2342 unsigned int addr_size,
2345 /* Read each compilation unit from the section .debug_info, and check
2346 to see if it contains the address we are searching for. If yes,
2347 lookup the address, and return the line number info. If no, go
2348 on to the next compilation unit.
2350 We keep a list of all the previously read compilation units, and
2351 a pointer to the next un-read compilation unit. Check the
2352 previously read units before reading more. */
2353 struct dwarf2_debug *stash;
2355 /* What address are we looking for? */
2358 struct comp_unit* each;
2364 section = bfd_get_section (symbol);
2366 addr = symbol->value;
2367 if (section->output_section)
2368 addr += section->output_section->vma + section->output_offset;
2370 addr += section->vma;
2372 *filename_ptr = NULL;
2374 *filename_ptr = NULL;
2375 *linenumber_ptr = 0;
2379 bfd_size_type total_size;
2381 bfd_size_type amt = sizeof (struct dwarf2_debug);
2383 stash = bfd_zalloc (abfd, amt);
2389 msec = find_debug_info (abfd, NULL);
2391 /* No dwarf2 info. Note that at this point the stash
2392 has been allocated, but contains zeros, this lets
2393 future calls to this function fail quicker. */
2396 /* There can be more than one DWARF2 info section in a BFD these days.
2397 Read them all in and produce one large stash. We do this in two
2398 passes - in the first pass we just accumulate the section sizes.
2399 In the second pass we read in the section's contents. The allows
2400 us to avoid reallocing the data as we add sections to the stash. */
2401 for (total_size = 0; msec; msec = find_debug_info (abfd, msec))
2402 total_size += msec->size;
2404 stash->info_ptr = bfd_alloc (abfd, total_size);
2405 if (stash->info_ptr == NULL)
2408 stash->info_ptr_end = stash->info_ptr;
2410 for (msec = find_debug_info (abfd, NULL);
2412 msec = find_debug_info (abfd, msec))
2415 bfd_size_type start;
2421 start = stash->info_ptr_end - stash->info_ptr;
2423 if ((bfd_simple_get_relocated_section_contents
2424 (abfd, msec, stash->info_ptr + start, symbols)) == NULL)
2427 stash->info_ptr_end = stash->info_ptr + start + size;
2430 BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size);
2432 stash->sec = find_debug_info (abfd, NULL);
2433 stash->sec_info_ptr = stash->info_ptr;
2434 stash->syms = symbols;
2437 /* A null info_ptr indicates that there is no dwarf2 info
2438 (or that an error occured while setting up the stash). */
2439 if (! stash->info_ptr)
2442 stash->inliner_chain = NULL;
2444 /* Check the previously read comp. units first. */
2445 for (each = stash->all_comp_units; each; each = each->next_unit)
2446 if ((symbol->flags & BSF_FUNCTION) == 0
2447 || comp_unit_contains_address (each, addr))
2449 found = comp_unit_find_line (each, symbol, addr, filename_ptr,
2450 linenumber_ptr, stash);
2455 /* The DWARF2 spec says that the initial length field, and the
2456 offset of the abbreviation table, should both be 4-byte values.
2457 However, some compilers do things differently. */
2460 BFD_ASSERT (addr_size == 4 || addr_size == 8);
2462 /* Read each remaining comp. units checking each as they are read. */
2463 while (stash->info_ptr < stash->info_ptr_end)
2466 unsigned int offset_size = addr_size;
2467 bfd_byte *info_ptr_unit = stash->info_ptr;
2469 length = read_4_bytes (abfd, stash->info_ptr);
2470 /* A 0xffffff length is the DWARF3 way of indicating we use
2471 64-bit offsets, instead of 32-bit offsets. */
2472 if (length == 0xffffffff)
2475 length = read_8_bytes (abfd, stash->info_ptr + 4);
2476 stash->info_ptr += 12;
2478 /* A zero length is the IRIX way of indicating 64-bit offsets,
2479 mostly because the 64-bit length will generally fit in 32
2480 bits, and the endianness helps. */
2481 else if (length == 0)
2484 length = read_4_bytes (abfd, stash->info_ptr + 4);
2485 stash->info_ptr += 8;
2487 /* In the absence of the hints above, we assume addr_size-sized
2488 offsets, for backward-compatibility with pre-DWARF3 64-bit
2490 else if (addr_size == 8)
2492 length = read_8_bytes (abfd, stash->info_ptr);
2493 stash->info_ptr += 8;
2496 stash->info_ptr += 4;
2500 each = parse_comp_unit (abfd, stash, length, info_ptr_unit,
2502 stash->info_ptr += length;
2504 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
2505 == stash->sec->size)
2507 stash->sec = find_debug_info (abfd, stash->sec);
2508 stash->sec_info_ptr = stash->info_ptr;
2513 each->next_unit = stash->all_comp_units;
2514 stash->all_comp_units = each;
2516 /* DW_AT_low_pc and DW_AT_high_pc are optional for
2517 compilation units. If we don't have them (i.e.,
2518 unit->high == 0), we need to consult the line info
2519 table to see if a compilation unit contains the given
2521 found = (((symbol->flags & BSF_FUNCTION) == 0
2522 || each->arange.high <= 0
2523 || comp_unit_contains_address (each, addr))
2524 && comp_unit_find_line (each, symbol, addr,
2538 _bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED,
2539 const char **filename_ptr,
2540 const char **functionname_ptr,
2541 unsigned int *linenumber_ptr,
2544 struct dwarf2_debug *stash;
2549 struct funcinfo *func = stash->inliner_chain;
2550 if (func && func->caller_func)
2552 *filename_ptr = func->caller_file;
2553 *functionname_ptr = func->caller_func->name;
2554 *linenumber_ptr = func->caller_line;
2555 stash->inliner_chain = func->caller_func;
2564 _bfd_dwarf2_cleanup_debug_info (bfd *abfd)
2566 struct comp_unit *each;
2567 struct dwarf2_debug *stash;
2569 if (abfd == NULL || elf_tdata (abfd) == NULL)
2572 stash = elf_tdata (abfd)->dwarf2_find_line_info;
2577 for (each = stash->all_comp_units; each; each = each->next_unit)
2579 struct abbrev_info **abbrevs = each->abbrevs;
2582 for (i = 0; i < ABBREV_HASH_SIZE; i++)
2584 struct abbrev_info *abbrev = abbrevs[i];
2588 free (abbrev->attrs);
2589 abbrev = abbrev->next;
2593 if (each->line_table)
2595 free (each->line_table->dirs);
2596 free (each->line_table->files);
2600 free (stash->dwarf_abbrev_buffer);
2601 free (stash->dwarf_line_buffer);
2602 free (stash->dwarf_ranges_buffer);