2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004 Free Software Foundation, Inc.
5 Adapted from gdb/dwarf2read.c by Gavin Koch of Cygnus Solutions
8 From the dwarf2read.c header:
9 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
10 Inc. with support from Florida State University (under contract
11 with the Ada Joint Program Office), and Silicon Graphics, Inc.
12 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
13 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
14 support in dwarfread.c
16 This file is part of BFD.
18 This program is free software; you can redistribute it and/or modify
19 it under the terms of the GNU General Public License as published by
20 the Free Software Foundation; either version 2 of the License, or (at
21 your option) any later version.
23 This program is distributed in the hope that it will be useful, but
24 WITHOUT ANY WARRANTY; without even the implied warranty of
25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
26 General Public License for more details.
28 You should have received a copy of the GNU General Public License
29 along with this program; if not, write to the Free Software
30 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
34 #include "libiberty.h"
37 #include "elf/dwarf2.h"
39 /* The data in the .debug_line statement prologue looks like this. */
44 unsigned short version;
45 bfd_vma prologue_length;
46 unsigned char minimum_instruction_length;
47 unsigned char default_is_stmt;
49 unsigned char line_range;
50 unsigned char opcode_base;
51 unsigned char *standard_opcode_lengths;
54 /* Attributes have a name and a value. */
58 enum dwarf_attribute name;
63 struct dwarf_block *blk;
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. */
90 /* Pointer to the section and address of the beginning of the
95 /* Pointer to the symbol table. */
98 /* Pointer to the .debug_abbrev section loaded into memory. */
99 char* dwarf_abbrev_buffer;
101 /* Length of the loaded .debug_abbrev section. */
102 unsigned long dwarf_abbrev_size;
104 /* Buffer for decode_line_info. */
105 char *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 char* dwarf_str_buffer;
113 /* Length of the loaded .debug_str section. */
114 unsigned long dwarf_str_size;
124 /* A minimal decoding of DWARF2 compilation units. We only decode
125 what's needed to get to the line number information. */
129 /* Chain the previously read compilation units. */
130 struct comp_unit* next_unit;
132 /* Keep the bdf convenient (for memory allocation). */
135 /* The lowest and higest addresses contained in this compilation
136 unit as specified in the compilation unit header. */
137 struct arange arange;
139 /* The DW_AT_name attribute (for error messages). */
142 /* The abbrev hash table. */
143 struct abbrev_info** abbrevs;
145 /* Note that an error was found by comp_unit_find_nearest_line. */
148 /* The DW_AT_comp_dir attribute. */
151 /* TRUE if there is a line number table associated with this comp. unit. */
154 /* The offset into .debug_line of the line number table. */
155 unsigned long line_offset;
157 /* Pointer to the first child die for the comp unit. */
158 char *first_child_die_ptr;
160 /* The end of the comp unit. */
163 /* The decoded line number, NULL if not yet decoded. */
164 struct line_info_table* line_table;
166 /* A list of the functions found in this comp. unit. */
167 struct funcinfo* function_table;
169 /* Pointer to dwarf2_debug structure. */
170 struct dwarf2_debug *stash;
172 /* Address size for this unit - from unit header. */
173 unsigned char addr_size;
175 /* Offset size for this unit - from unit header. */
176 unsigned char offset_size;
179 /* This data structure holds the information of an abbrev. */
182 unsigned int number; /* Number identifying abbrev. */
183 enum dwarf_tag tag; /* DWARF tag. */
184 int has_children; /* Boolean. */
185 unsigned int num_attrs; /* Number of attributes. */
186 struct attr_abbrev *attrs; /* An array of attribute descriptions. */
187 struct abbrev_info *next; /* Next in chain. */
192 enum dwarf_attribute name;
193 enum dwarf_form form;
196 #ifndef ABBREV_HASH_SIZE
197 #define ABBREV_HASH_SIZE 121
199 #ifndef ATTR_ALLOC_CHUNK
200 #define ATTR_ALLOC_CHUNK 4
204 The following function up to the END VERBATIM mark are
205 copied directly from dwarf2read.c. */
207 /* Read dwarf information from a buffer. */
210 read_1_byte (bfd *abfd ATTRIBUTE_UNUSED, char *buf)
212 return bfd_get_8 (abfd, buf);
216 read_1_signed_byte (bfd *abfd ATTRIBUTE_UNUSED, char *buf)
218 return bfd_get_signed_8 (abfd, buf);
222 read_2_bytes (bfd *abfd, char *buf)
224 return bfd_get_16 (abfd, buf);
228 read_4_bytes (bfd *abfd, char *buf)
230 return bfd_get_32 (abfd, buf);
234 read_8_bytes (bfd *abfd, char *buf)
236 return bfd_get_64 (abfd, buf);
240 read_n_bytes (bfd *abfd ATTRIBUTE_UNUSED,
242 unsigned int size ATTRIBUTE_UNUSED)
244 /* If the size of a host char is 8 bits, we can return a pointer
245 to the buffer, otherwise we have to copy the data to a buffer
246 allocated on the temporary obstack. */
251 read_string (bfd *abfd ATTRIBUTE_UNUSED,
253 unsigned int *bytes_read_ptr)
255 /* Return a pointer to the embedded string. */
262 *bytes_read_ptr = strlen (buf) + 1;
267 read_indirect_string (struct comp_unit* unit,
269 unsigned int *bytes_read_ptr)
272 struct dwarf2_debug *stash = unit->stash;
274 if (unit->offset_size == 4)
275 offset = read_4_bytes (unit->abfd, buf);
277 offset = read_8_bytes (unit->abfd, buf);
278 *bytes_read_ptr = unit->offset_size;
280 if (! stash->dwarf_str_buffer)
283 bfd *abfd = unit->abfd;
285 msec = bfd_get_section_by_name (abfd, ".debug_str");
288 (*_bfd_error_handler)
289 (_("Dwarf Error: Can't find .debug_str section."));
290 bfd_set_error (bfd_error_bad_value);
294 stash->dwarf_str_size = msec->_raw_size;
295 stash->dwarf_str_buffer = bfd_alloc (abfd, msec->_raw_size);
296 if (! stash->dwarf_abbrev_buffer)
299 if (! bfd_get_section_contents (abfd, msec, stash->dwarf_str_buffer,
304 if (offset >= stash->dwarf_str_size)
306 (*_bfd_error_handler) (_("Dwarf Error: DW_FORM_strp offset (%lu) greater than or equal to .debug_str size (%lu)."),
307 (unsigned long) offset, stash->dwarf_str_size);
308 bfd_set_error (bfd_error_bad_value);
312 buf = stash->dwarf_str_buffer + offset;
319 read_unsigned_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
321 unsigned int *bytes_read_ptr)
324 unsigned int num_read;
334 byte = bfd_get_8 (abfd, buf);
337 result |= ((byte & 0x7f) << shift);
342 * bytes_read_ptr = num_read;
348 read_signed_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
350 unsigned int * bytes_read_ptr)
363 byte = bfd_get_8 (abfd, buf);
366 result |= ((byte & 0x7f) << shift);
371 if ((shift < 32) && (byte & 0x40))
372 result |= -(1 << shift);
374 * bytes_read_ptr = num_read;
382 read_address (struct comp_unit *unit, char *buf)
384 switch (unit->addr_size)
387 return bfd_get_64 (unit->abfd, buf);
389 return bfd_get_32 (unit->abfd, buf);
391 return bfd_get_16 (unit->abfd, buf);
397 /* Lookup an abbrev_info structure in the abbrev hash table. */
399 static struct abbrev_info *
400 lookup_abbrev (unsigned int number, struct abbrev_info **abbrevs)
402 unsigned int hash_number;
403 struct abbrev_info *abbrev;
405 hash_number = number % ABBREV_HASH_SIZE;
406 abbrev = abbrevs[hash_number];
410 if (abbrev->number == number)
413 abbrev = abbrev->next;
419 /* In DWARF version 2, the description of the debugging information is
420 stored in a separate .debug_abbrev section. Before we read any
421 dies from a section we read in all abbreviations and install them
424 static struct abbrev_info**
425 read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
427 struct abbrev_info **abbrevs;
429 struct abbrev_info *cur_abbrev;
430 unsigned int abbrev_number, bytes_read, abbrev_name;
431 unsigned int abbrev_form, hash_number;
434 if (! stash->dwarf_abbrev_buffer)
438 msec = bfd_get_section_by_name (abfd, ".debug_abbrev");
441 (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_abbrev section."));
442 bfd_set_error (bfd_error_bad_value);
446 stash->dwarf_abbrev_size = msec->_raw_size;
447 stash->dwarf_abbrev_buffer
448 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
450 if (! stash->dwarf_abbrev_buffer)
454 if (offset >= stash->dwarf_abbrev_size)
456 (*_bfd_error_handler) (_("Dwarf Error: Abbrev offset (%lu) greater than or equal to .debug_abbrev size (%lu)."),
457 (unsigned long) offset, stash->dwarf_abbrev_size);
458 bfd_set_error (bfd_error_bad_value);
462 amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
463 abbrevs = bfd_zalloc (abfd, amt);
465 abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
466 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
467 abbrev_ptr += bytes_read;
469 /* Loop until we reach an abbrev number of 0. */
470 while (abbrev_number)
472 amt = sizeof (struct abbrev_info);
473 cur_abbrev = bfd_zalloc (abfd, amt);
475 /* Read in abbrev header. */
476 cur_abbrev->number = abbrev_number;
477 cur_abbrev->tag = (enum dwarf_tag)
478 read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
479 abbrev_ptr += bytes_read;
480 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
483 /* Now read in declarations. */
484 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
485 abbrev_ptr += bytes_read;
486 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
487 abbrev_ptr += bytes_read;
491 if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
493 amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
494 amt *= sizeof (struct attr_abbrev);
495 cur_abbrev->attrs = bfd_realloc (cur_abbrev->attrs, amt);
496 if (! cur_abbrev->attrs)
500 cur_abbrev->attrs[cur_abbrev->num_attrs].name
501 = (enum dwarf_attribute) abbrev_name;
502 cur_abbrev->attrs[cur_abbrev->num_attrs++].form
503 = (enum dwarf_form) abbrev_form;
504 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
505 abbrev_ptr += bytes_read;
506 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
507 abbrev_ptr += bytes_read;
510 hash_number = abbrev_number % ABBREV_HASH_SIZE;
511 cur_abbrev->next = abbrevs[hash_number];
512 abbrevs[hash_number] = cur_abbrev;
514 /* Get next abbreviation.
515 Under Irix6 the abbreviations for a compilation unit are not
516 always properly terminated with an abbrev number of 0.
517 Exit loop if we encounter an abbreviation which we have
518 already read (which means we are about to read the abbreviations
519 for the next compile unit) or if the end of the abbreviation
521 if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
522 >= stash->dwarf_abbrev_size)
524 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
525 abbrev_ptr += bytes_read;
526 if (lookup_abbrev (abbrev_number,abbrevs) != NULL)
533 /* Read an attribute value described by an attribute form. */
536 read_attribute_value (struct attribute *attr,
538 struct comp_unit *unit,
541 bfd *abfd = unit->abfd;
542 unsigned int bytes_read;
543 struct dwarf_block *blk;
546 attr->form = (enum dwarf_form) form;
551 /* FIXME: DWARF3 draft says DW_FORM_ref_addr is offset_size. */
552 case DW_FORM_ref_addr:
553 attr->u.val = read_address (unit, info_ptr);
554 info_ptr += unit->addr_size;
557 amt = sizeof (struct dwarf_block);
558 blk = bfd_alloc (abfd, amt);
559 blk->size = read_2_bytes (abfd, info_ptr);
561 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
562 info_ptr += blk->size;
566 amt = sizeof (struct dwarf_block);
567 blk = bfd_alloc (abfd, amt);
568 blk->size = read_4_bytes (abfd, info_ptr);
570 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
571 info_ptr += blk->size;
575 attr->u.val = read_2_bytes (abfd, info_ptr);
579 attr->u.val = read_4_bytes (abfd, info_ptr);
583 attr->u.val = read_8_bytes (abfd, info_ptr);
587 attr->u.str = read_string (abfd, info_ptr, &bytes_read);
588 info_ptr += bytes_read;
591 attr->u.str = read_indirect_string (unit, info_ptr, &bytes_read);
592 info_ptr += bytes_read;
595 amt = sizeof (struct dwarf_block);
596 blk = bfd_alloc (abfd, amt);
597 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
598 info_ptr += bytes_read;
599 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
600 info_ptr += blk->size;
604 amt = sizeof (struct dwarf_block);
605 blk = bfd_alloc (abfd, amt);
606 blk->size = read_1_byte (abfd, info_ptr);
608 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
609 info_ptr += blk->size;
613 attr->u.val = read_1_byte (abfd, info_ptr);
617 attr->u.val = read_1_byte (abfd, info_ptr);
621 attr->u.sval = read_signed_leb128 (abfd, info_ptr, &bytes_read);
622 info_ptr += bytes_read;
625 attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
626 info_ptr += bytes_read;
629 attr->u.val = read_1_byte (abfd, info_ptr);
633 attr->u.val = read_2_bytes (abfd, info_ptr);
637 attr->u.val = read_4_bytes (abfd, info_ptr);
641 attr->u.val = read_8_bytes (abfd, info_ptr);
644 case DW_FORM_ref_udata:
645 attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
646 info_ptr += bytes_read;
648 case DW_FORM_indirect:
649 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
650 info_ptr += bytes_read;
651 info_ptr = read_attribute_value (attr, form, unit, info_ptr);
654 (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %u."),
656 bfd_set_error (bfd_error_bad_value);
661 /* Read an attribute described by an abbreviated attribute. */
664 read_attribute (struct attribute *attr,
665 struct attr_abbrev *abbrev,
666 struct comp_unit *unit,
669 attr->name = abbrev->name;
670 info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr);
674 /* Source line information table routines. */
676 #define FILE_ALLOC_CHUNK 5
677 #define DIR_ALLOC_CHUNK 5
681 struct line_info* prev_line;
686 int end_sequence; /* End of (sequential) code sequence. */
697 struct line_info_table
700 unsigned int num_files;
701 unsigned int num_dirs;
704 struct fileinfo* files;
705 struct line_info* last_line; /* largest VMA */
706 struct line_info* lcl_head; /* local head; used in 'add_line_info' */
711 struct funcinfo *prev_func;
717 /* Adds a new entry to the line_info list in the line_info_table, ensuring
718 that the list is sorted. Note that the line_info list is sorted from
719 highest to lowest VMA (with possible duplicates); that is,
720 line_info->prev_line always accesses an equal or smaller VMA. */
723 add_line_info (struct line_info_table *table,
730 bfd_size_type amt = sizeof (struct line_info);
731 struct line_info* info = bfd_alloc (table->abfd, amt);
733 /* Find the correct location for 'info'. Normally we will receive
734 new line_info data 1) in order and 2) with increasing VMAs.
735 However some compilers break the rules (cf. decode_line_info) and
736 so we include some heuristics for quickly finding the correct
737 location for 'info'. In particular, these heuristics optimize for
738 the common case in which the VMA sequence that we receive is a
739 list of locally sorted VMAs such as
740 p...z a...j (where a < j < p < z)
742 Note: table->lcl_head is used to head an *actual* or *possible*
743 sequence within the list (such as a...j) that is not directly
744 headed by table->last_line
746 Note: we may receive duplicate entries from 'decode_line_info'. */
749 if (!table->last_line
750 || address >= table->last_line->address)
752 /* Normal case: add 'info' to the beginning of the list */
753 info->prev_line = table->last_line;
754 table->last_line = info;
756 /* lcl_head: initialize to head a *possible* sequence at the end. */
757 if (!table->lcl_head)
758 table->lcl_head = info;
761 else if (!table->lcl_head->prev_line
762 && table->lcl_head->address > address)
764 /* Abnormal but easy: lcl_head is 1) at the *end* of the line
765 list and 2) the head of 'info'. */
766 info->prev_line = NULL;
767 table->lcl_head->prev_line = info;
770 else if (table->lcl_head->prev_line
771 && table->lcl_head->address > address
772 && address >= table->lcl_head->prev_line->address)
774 /* Abnormal but easy: lcl_head is 1) in the *middle* of the line
775 list and 2) the head of 'info'. */
776 info->prev_line = table->lcl_head->prev_line;
777 table->lcl_head->prev_line = info;
782 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head' are valid
783 heads for 'info'. Reset 'lcl_head' and repeat. */
784 struct line_info* li2 = table->last_line; /* always non-NULL */
785 struct line_info* li1 = li2->prev_line;
789 if (li2->address > address && address >= li1->address)
792 li2 = li1; /* always non-NULL */
793 li1 = li1->prev_line;
795 table->lcl_head = li2;
798 /* Set member data of 'info'. */
799 info->address = address;
801 info->column = column;
802 info->end_sequence = end_sequence;
804 if (filename && filename[0])
806 info->filename = bfd_alloc (table->abfd, strlen (filename) + 1);
808 strcpy (info->filename, filename);
811 info->filename = NULL;
814 /* Extract a fully qualified filename from a line info table.
815 The returned string has been malloc'ed and it is the caller's
816 responsibility to free it. */
819 concat_filename (struct line_info_table *table, unsigned int file)
823 if (file - 1 >= table->num_files)
825 (*_bfd_error_handler)
826 (_("Dwarf Error: mangled line number section (bad file number)."));
827 return strdup ("<unknown>");
830 filename = table->files[file - 1].name;
832 if (! IS_ABSOLUTE_PATH (filename))
834 char* dirname = (table->files[file - 1].dir
835 ? table->dirs[table->files[file - 1].dir - 1]
838 /* Not all tools set DW_AT_comp_dir, so dirname may be unknown.
839 The best we can do is return the filename part. */
842 unsigned int len = strlen (dirname) + strlen (filename) + 2;
845 name = bfd_malloc (len);
847 sprintf (name, "%s/%s", dirname, filename);
852 return strdup (filename);
856 arange_add (struct comp_unit *unit, bfd_vma low_pc, bfd_vma high_pc)
858 struct arange *arange;
860 /* First see if we can cheaply extend an existing range. */
861 arange = &unit->arange;
865 if (low_pc == arange->high)
867 arange->high = high_pc;
870 if (high_pc == arange->low)
872 arange->low = low_pc;
875 arange = arange->next;
879 if (unit->arange.high == 0)
881 /* This is the first address range: store it in unit->arange. */
882 unit->arange.next = 0;
883 unit->arange.low = low_pc;
884 unit->arange.high = high_pc;
888 /* Need to allocate a new arange and insert it into the arange list. */
889 arange = bfd_zalloc (unit->abfd, sizeof (*arange));
890 arange->low = low_pc;
891 arange->high = high_pc;
893 arange->next = unit->arange.next;
894 unit->arange.next = arange;
897 /* Decode the line number information for UNIT. */
899 static struct line_info_table*
900 decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
902 bfd *abfd = unit->abfd;
903 struct line_info_table* table;
907 unsigned int i, bytes_read, offset_size;
908 char *cur_file, *cur_dir;
909 unsigned char op_code, extended_op, adj_opcode;
912 if (! stash->dwarf_line_buffer)
916 msec = bfd_get_section_by_name (abfd, ".debug_line");
919 (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_line section."));
920 bfd_set_error (bfd_error_bad_value);
924 stash->dwarf_line_size = msec->_raw_size;
925 stash->dwarf_line_buffer
926 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
928 if (! stash->dwarf_line_buffer)
932 /* It is possible to get a bad value for the line_offset. Validate
933 it here so that we won't get a segfault below. */
934 if (unit->line_offset >= stash->dwarf_line_size)
936 (*_bfd_error_handler) (_("Dwarf Error: Line offset (%lu) greater than or equal to .debug_line size (%lu)."),
937 unit->line_offset, stash->dwarf_line_size);
938 bfd_set_error (bfd_error_bad_value);
942 amt = sizeof (struct line_info_table);
943 table = bfd_alloc (abfd, amt);
945 table->comp_dir = unit->comp_dir;
947 table->num_files = 0;
954 table->last_line = NULL;
955 table->lcl_head = NULL;
957 line_ptr = stash->dwarf_line_buffer + unit->line_offset;
959 /* Read in the prologue. */
960 lh.total_length = read_4_bytes (abfd, line_ptr);
963 if (lh.total_length == 0xffffffff)
965 lh.total_length = read_8_bytes (abfd, line_ptr);
969 else if (lh.total_length == 0 && unit->addr_size == 8)
971 /* Handle (non-standard) 64-bit DWARF2 formats. */
972 lh.total_length = read_4_bytes (abfd, line_ptr);
976 line_end = line_ptr + lh.total_length;
977 lh.version = read_2_bytes (abfd, line_ptr);
979 if (offset_size == 4)
980 lh.prologue_length = read_4_bytes (abfd, line_ptr);
982 lh.prologue_length = read_8_bytes (abfd, line_ptr);
983 line_ptr += offset_size;
984 lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
986 lh.default_is_stmt = read_1_byte (abfd, line_ptr);
988 lh.line_base = read_1_signed_byte (abfd, line_ptr);
990 lh.line_range = read_1_byte (abfd, line_ptr);
992 lh.opcode_base = read_1_byte (abfd, line_ptr);
994 amt = lh.opcode_base * sizeof (unsigned char);
995 lh.standard_opcode_lengths = bfd_alloc (abfd, amt);
997 lh.standard_opcode_lengths[0] = 1;
999 for (i = 1; i < lh.opcode_base; ++i)
1001 lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
1005 /* Read directory table. */
1006 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1008 line_ptr += bytes_read;
1010 if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
1012 amt = table->num_dirs + DIR_ALLOC_CHUNK;
1013 amt *= sizeof (char *);
1014 table->dirs = bfd_realloc (table->dirs, amt);
1019 table->dirs[table->num_dirs++] = cur_dir;
1022 line_ptr += bytes_read;
1024 /* Read file name table. */
1025 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1027 line_ptr += bytes_read;
1029 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1031 amt = table->num_files + FILE_ALLOC_CHUNK;
1032 amt *= sizeof (struct fileinfo);
1033 table->files = bfd_realloc (table->files, amt);
1038 table->files[table->num_files].name = cur_file;
1039 table->files[table->num_files].dir =
1040 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1041 line_ptr += bytes_read;
1042 table->files[table->num_files].time =
1043 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1044 line_ptr += bytes_read;
1045 table->files[table->num_files].size =
1046 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1047 line_ptr += bytes_read;
1051 line_ptr += bytes_read;
1053 /* Read the statement sequences until there's nothing left. */
1054 while (line_ptr < line_end)
1056 /* State machine registers. */
1057 bfd_vma address = 0;
1058 char * filename = table->num_files ? concat_filename (table, 1) : NULL;
1059 unsigned int line = 1;
1060 unsigned int column = 0;
1061 int is_stmt = lh.default_is_stmt;
1062 int basic_block = 0;
1063 int end_sequence = 0;
1064 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1065 compilers generate address sequences that are wildly out of
1066 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1067 for ia64-Linux). Thus, to determine the low and high
1068 address, we must compare on every DW_LNS_copy, etc. */
1070 bfd_vma high_pc = 0;
1072 /* Decode the table. */
1073 while (! end_sequence)
1075 op_code = read_1_byte (abfd, line_ptr);
1078 if (op_code >= lh.opcode_base)
1080 /* Special operand. */
1081 adj_opcode = op_code - lh.opcode_base;
1082 address += (adj_opcode / lh.line_range)
1083 * lh.minimum_instruction_length;
1084 line += lh.line_base + (adj_opcode % lh.line_range);
1085 /* Append row to matrix using current values. */
1086 add_line_info (table, address, filename, line, column, 0);
1088 if (low_pc == 0 || address < low_pc)
1090 if (address > high_pc)
1093 else switch (op_code)
1095 case DW_LNS_extended_op:
1096 /* Ignore length. */
1098 extended_op = read_1_byte (abfd, line_ptr);
1101 switch (extended_op)
1103 case DW_LNE_end_sequence:
1105 add_line_info (table, address, filename, line, column,
1107 if (low_pc == 0 || address < low_pc)
1109 if (address > high_pc)
1111 arange_add (unit, low_pc, high_pc);
1113 case DW_LNE_set_address:
1114 address = read_address (unit, line_ptr);
1115 line_ptr += unit->addr_size;
1117 case DW_LNE_define_file:
1118 cur_file = read_string (abfd, line_ptr, &bytes_read);
1119 line_ptr += bytes_read;
1120 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1122 amt = table->num_files + FILE_ALLOC_CHUNK;
1123 amt *= sizeof (struct fileinfo);
1124 table->files = bfd_realloc (table->files, amt);
1128 table->files[table->num_files].name = cur_file;
1129 table->files[table->num_files].dir =
1130 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1131 line_ptr += bytes_read;
1132 table->files[table->num_files].time =
1133 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1134 line_ptr += bytes_read;
1135 table->files[table->num_files].size =
1136 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1137 line_ptr += bytes_read;
1141 (*_bfd_error_handler) (_("Dwarf Error: mangled line number section."));
1142 bfd_set_error (bfd_error_bad_value);
1147 add_line_info (table, address, filename, line, column, 0);
1149 if (low_pc == 0 || address < low_pc)
1151 if (address > high_pc)
1154 case DW_LNS_advance_pc:
1155 address += lh.minimum_instruction_length
1156 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1157 line_ptr += bytes_read;
1159 case DW_LNS_advance_line:
1160 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
1161 line_ptr += bytes_read;
1163 case DW_LNS_set_file:
1167 /* The file and directory tables are 0
1168 based, the references are 1 based. */
1169 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1170 line_ptr += bytes_read;
1173 filename = concat_filename (table, file);
1176 case DW_LNS_set_column:
1177 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1178 line_ptr += bytes_read;
1180 case DW_LNS_negate_stmt:
1181 is_stmt = (!is_stmt);
1183 case DW_LNS_set_basic_block:
1186 case DW_LNS_const_add_pc:
1187 address += lh.minimum_instruction_length
1188 * ((255 - lh.opcode_base) / lh.line_range);
1190 case DW_LNS_fixed_advance_pc:
1191 address += read_2_bytes (abfd, line_ptr);
1198 /* Unknown standard opcode, ignore it. */
1199 for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
1201 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1202 line_ptr += bytes_read;
1215 /* If ADDR is within TABLE set the output parameters and return TRUE,
1216 otherwise return FALSE. The output parameters, FILENAME_PTR and
1217 LINENUMBER_PTR, are pointers to the objects to be filled in. */
1220 lookup_address_in_line_info_table (struct line_info_table *table,
1222 struct funcinfo *function,
1223 const char **filename_ptr,
1224 unsigned int *linenumber_ptr)
1226 /* Note: table->last_line should be a descendingly sorted list. */
1227 struct line_info* next_line = table->last_line;
1228 struct line_info* each_line = NULL;
1229 *filename_ptr = NULL;
1234 each_line = next_line->prev_line;
1236 /* Check for large addresses */
1237 if (addr > next_line->address)
1238 each_line = NULL; /* ensure we skip over the normal case */
1240 /* Normal case: search the list; save */
1241 while (each_line && next_line)
1243 /* If we have an address match, save this info. This allows us
1244 to return as good as results as possible for strange debugging
1246 bfd_boolean addr_match = FALSE;
1247 if (each_line->address <= addr && addr <= next_line->address)
1251 /* If this line appears to span functions, and addr is in the
1252 later function, return the first line of that function instead
1253 of the last line of the earlier one. This check is for GCC
1254 2.95, which emits the first line number for a function late. */
1255 if (function != NULL
1256 && each_line->address < function->low
1257 && next_line->address > function->low)
1259 *filename_ptr = next_line->filename;
1260 *linenumber_ptr = next_line->line;
1264 *filename_ptr = each_line->filename;
1265 *linenumber_ptr = each_line->line;
1269 if (addr_match && !each_line->end_sequence)
1270 return TRUE; /* we have definitely found what we want */
1272 next_line = each_line;
1273 each_line = each_line->prev_line;
1276 /* At this point each_line is NULL but next_line is not. If we found
1277 a candidate end-of-sequence point in the loop above, we can return
1278 that (compatibility with a bug in the Intel compiler); otherwise,
1279 assuming that we found the containing function for this address in
1280 this compilation unit, return the first line we have a number for
1281 (compatibility with GCC 2.95). */
1282 if (*filename_ptr == NULL && function != NULL)
1284 *filename_ptr = next_line->filename;
1285 *linenumber_ptr = next_line->line;
1292 /* Function table functions. */
1294 /* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return TRUE. */
1297 lookup_address_in_function_table (struct funcinfo *table,
1299 struct funcinfo **function_ptr,
1300 const char **functionname_ptr)
1302 struct funcinfo* each_func;
1304 for (each_func = table;
1306 each_func = each_func->prev_func)
1308 if (addr >= each_func->low && addr < each_func->high)
1310 *functionname_ptr = each_func->name;
1311 *function_ptr = each_func;
1319 /* DWARF2 Compilation unit functions. */
1321 /* Scan over each die in a comp. unit looking for functions to add
1322 to the function table. */
1325 scan_unit_for_functions (struct comp_unit *unit)
1327 bfd *abfd = unit->abfd;
1328 char *info_ptr = unit->first_child_die_ptr;
1329 int nesting_level = 1;
1331 while (nesting_level)
1333 unsigned int abbrev_number, bytes_read, i;
1334 struct abbrev_info *abbrev;
1335 struct attribute attr;
1336 struct funcinfo *func;
1339 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1340 info_ptr += bytes_read;
1342 if (! abbrev_number)
1348 abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
1351 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1353 bfd_set_error (bfd_error_bad_value);
1357 if (abbrev->tag == DW_TAG_subprogram)
1359 bfd_size_type amt = sizeof (struct funcinfo);
1360 func = bfd_zalloc (abfd, amt);
1361 func->prev_func = unit->function_table;
1362 unit->function_table = func;
1367 for (i = 0; i < abbrev->num_attrs; ++i)
1369 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1379 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
1380 if (func->name == NULL)
1381 func->name = attr.u.str;
1384 case DW_AT_MIPS_linkage_name:
1385 func->name = attr.u.str;
1389 func->low = attr.u.val;
1393 func->high = attr.u.val;
1414 if (abbrev->has_children)
1421 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
1422 includes the compilation unit header that proceeds the DIE's, but
1423 does not include the length field that precedes each compilation
1424 unit header. END_PTR points one past the end of this comp unit.
1425 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
1427 This routine does not read the whole compilation unit; only enough
1428 to get to the line number information for the compilation unit. */
1430 static struct comp_unit *
1431 parse_comp_unit (bfd *abfd,
1432 struct dwarf2_debug *stash,
1433 bfd_vma unit_length,
1434 unsigned int offset_size)
1436 struct comp_unit* unit;
1437 unsigned int version;
1438 bfd_uint64_t abbrev_offset = 0;
1439 unsigned int addr_size;
1440 struct abbrev_info** abbrevs;
1441 unsigned int abbrev_number, bytes_read, i;
1442 struct abbrev_info *abbrev;
1443 struct attribute attr;
1444 char *info_ptr = stash->info_ptr;
1445 char *end_ptr = info_ptr + unit_length;
1448 version = read_2_bytes (abfd, info_ptr);
1450 BFD_ASSERT (offset_size == 4 || offset_size == 8);
1451 if (offset_size == 4)
1452 abbrev_offset = read_4_bytes (abfd, info_ptr);
1454 abbrev_offset = read_8_bytes (abfd, info_ptr);
1455 info_ptr += offset_size;
1456 addr_size = read_1_byte (abfd, info_ptr);
1461 (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 information."), version);
1462 bfd_set_error (bfd_error_bad_value);
1466 if (addr_size > sizeof (bfd_vma))
1468 (*_bfd_error_handler) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
1470 (unsigned int) sizeof (bfd_vma));
1471 bfd_set_error (bfd_error_bad_value);
1475 if (addr_size != 2 && addr_size != 4 && addr_size != 8)
1477 (*_bfd_error_handler) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size);
1478 bfd_set_error (bfd_error_bad_value);
1482 /* Read the abbrevs for this compilation unit into a table. */
1483 abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
1487 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1488 info_ptr += bytes_read;
1489 if (! abbrev_number)
1491 (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u."),
1493 bfd_set_error (bfd_error_bad_value);
1497 abbrev = lookup_abbrev (abbrev_number, abbrevs);
1500 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1502 bfd_set_error (bfd_error_bad_value);
1506 amt = sizeof (struct comp_unit);
1507 unit = bfd_zalloc (abfd, amt);
1509 unit->addr_size = addr_size;
1510 unit->offset_size = offset_size;
1511 unit->abbrevs = abbrevs;
1512 unit->end_ptr = end_ptr;
1513 unit->stash = stash;
1515 for (i = 0; i < abbrev->num_attrs; ++i)
1517 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1519 /* Store the data if it is of an attribute we want to keep in a
1520 partial symbol table. */
1523 case DW_AT_stmt_list:
1525 unit->line_offset = attr.u.val;
1529 unit->name = attr.u.str;
1533 unit->arange.low = attr.u.val;
1537 unit->arange.high = attr.u.val;
1540 case DW_AT_comp_dir:
1542 char* comp_dir = attr.u.str;
1545 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1546 directory, get rid of it. */
1547 char *cp = strchr (comp_dir, ':');
1549 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
1552 unit->comp_dir = comp_dir;
1561 unit->first_child_die_ptr = info_ptr;
1565 /* Return TRUE if UNIT contains the address given by ADDR. */
1568 comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
1570 struct arange *arange;
1575 arange = &unit->arange;
1578 if (addr >= arange->low && addr < arange->high)
1580 arange = arange->next;
1587 /* If UNIT contains ADDR, set the output parameters to the values for
1588 the line containing ADDR. The output parameters, FILENAME_PTR,
1589 FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
1592 Return TRUE if UNIT contains ADDR, and no errors were encountered;
1596 comp_unit_find_nearest_line (struct comp_unit *unit,
1598 const char **filename_ptr,
1599 const char **functionname_ptr,
1600 unsigned int *linenumber_ptr,
1601 struct dwarf2_debug *stash)
1605 struct funcinfo *function;
1610 if (! unit->line_table)
1612 if (! unit->stmtlist)
1618 unit->line_table = decode_line_info (unit, stash);
1620 if (! unit->line_table)
1626 if (unit->first_child_die_ptr < unit->end_ptr
1627 && ! scan_unit_for_functions (unit))
1635 func_p = lookup_address_in_function_table (unit->function_table, addr,
1636 &function, functionname_ptr);
1637 line_p = lookup_address_in_line_info_table (unit->line_table, addr,
1638 function, filename_ptr,
1640 return line_p || func_p;
1643 /* Locate a section in a BFD containing debugging info. The search starts
1644 from the section after AFTER_SEC, or from the first section in the BFD if
1645 AFTER_SEC is NULL. The search works by examining the names of the
1646 sections. There are two permissiable names. The first is .debug_info.
1647 This is the standard DWARF2 name. The second is a prefix .gnu.linkonce.wi.
1648 This is a variation on the .debug_info section which has a checksum
1649 describing the contents appended onto the name. This allows the linker to
1650 identify and discard duplicate debugging sections for different
1651 compilation units. */
1652 #define DWARF2_DEBUG_INFO ".debug_info"
1653 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
1656 find_debug_info (bfd *abfd, asection *after_sec)
1661 msec = after_sec->next;
1663 msec = abfd->sections;
1667 if (strcmp (msec->name, DWARF2_DEBUG_INFO) == 0)
1670 if (strncmp (msec->name, GNU_LINKONCE_INFO, strlen (GNU_LINKONCE_INFO)) == 0)
1679 /* The DWARF2 version of find_nearest_line. Return TRUE if the line
1680 is found without error. ADDR_SIZE is the number of bytes in the
1681 initial .debug_info length field and in the abbreviation offset.
1682 You may use zero to indicate that the default value should be
1686 _bfd_dwarf2_find_nearest_line (bfd *abfd,
1690 const char **filename_ptr,
1691 const char **functionname_ptr,
1692 unsigned int *linenumber_ptr,
1693 unsigned int addr_size,
1696 /* Read each compilation unit from the section .debug_info, and check
1697 to see if it contains the address we are searching for. If yes,
1698 lookup the address, and return the line number info. If no, go
1699 on to the next compilation unit.
1701 We keep a list of all the previously read compilation units, and
1702 a pointer to the next un-read compilation unit. Check the
1703 previously read units before reading more. */
1704 struct dwarf2_debug *stash = *pinfo;
1706 /* What address are we looking for? */
1707 bfd_vma addr = offset + section->vma;
1709 struct comp_unit* each;
1711 *filename_ptr = NULL;
1712 *functionname_ptr = NULL;
1713 *linenumber_ptr = 0;
1715 /* The DWARF2 spec says that the initial length field, and the
1716 offset of the abbreviation table, should both be 4-byte values.
1717 However, some compilers do things differently. */
1720 BFD_ASSERT (addr_size == 4 || addr_size == 8);
1724 bfd_size_type total_size;
1726 bfd_size_type amt = sizeof (struct dwarf2_debug);
1728 stash = bfd_zalloc (abfd, amt);
1734 msec = find_debug_info (abfd, NULL);
1736 /* No dwarf2 info. Note that at this point the stash
1737 has been allocated, but contains zeros, this lets
1738 future calls to this function fail quicker. */
1741 /* There can be more than one DWARF2 info section in a BFD these days.
1742 Read them all in and produce one large stash. We do this in two
1743 passes - in the first pass we just accumulate the section sizes.
1744 In the second pass we read in the section's contents. The allows
1745 us to avoid reallocing the data as we add sections to the stash. */
1746 for (total_size = 0; msec; msec = find_debug_info (abfd, msec))
1747 total_size += msec->_raw_size;
1749 stash->info_ptr = bfd_alloc (abfd, total_size);
1750 if (stash->info_ptr == NULL)
1753 stash->info_ptr_end = stash->info_ptr;
1755 for (msec = find_debug_info (abfd, NULL);
1757 msec = find_debug_info (abfd, msec))
1760 bfd_size_type start;
1762 size = msec->_raw_size;
1766 start = stash->info_ptr_end - stash->info_ptr;
1768 if ((bfd_simple_get_relocated_section_contents
1769 (abfd, msec, stash->info_ptr + start, symbols)) == NULL)
1772 stash->info_ptr_end = stash->info_ptr + start + size;
1775 BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size);
1777 stash->sec = find_debug_info (abfd, NULL);
1778 stash->sec_info_ptr = stash->info_ptr;
1779 stash->syms = symbols;
1782 /* A null info_ptr indicates that there is no dwarf2 info
1783 (or that an error occured while setting up the stash). */
1784 if (! stash->info_ptr)
1787 /* Check the previously read comp. units first. */
1788 for (each = stash->all_comp_units; each; each = each->next_unit)
1789 if (comp_unit_contains_address (each, addr))
1790 return comp_unit_find_nearest_line (each, addr, filename_ptr,
1791 functionname_ptr, linenumber_ptr,
1794 /* Read each remaining comp. units checking each as they are read. */
1795 while (stash->info_ptr < stash->info_ptr_end)
1799 unsigned int offset_size = addr_size;
1801 length = read_4_bytes (abfd, stash->info_ptr);
1802 /* A 0xffffff length is the DWARF3 way of indicating we use
1803 64-bit offsets, instead of 32-bit offsets. */
1804 if (length == 0xffffffff)
1807 length = read_8_bytes (abfd, stash->info_ptr + 4);
1808 stash->info_ptr += 12;
1810 /* A zero length is the IRIX way of indicating 64-bit offsets,
1811 mostly because the 64-bit length will generally fit in 32
1812 bits, and the endianness helps. */
1813 else if (length == 0)
1816 length = read_4_bytes (abfd, stash->info_ptr + 4);
1817 stash->info_ptr += 8;
1819 /* In the absence of the hints above, we assume addr_size-sized
1820 offsets, for backward-compatibility with pre-DWARF3 64-bit
1822 else if (addr_size == 8)
1824 length = read_8_bytes (abfd, stash->info_ptr);
1825 stash->info_ptr += 8;
1828 stash->info_ptr += 4;
1832 each = parse_comp_unit (abfd, stash, length, offset_size);
1833 stash->info_ptr += length;
1835 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
1836 == stash->sec->_raw_size)
1838 stash->sec = find_debug_info (abfd, stash->sec);
1839 stash->sec_info_ptr = stash->info_ptr;
1844 each->next_unit = stash->all_comp_units;
1845 stash->all_comp_units = each;
1847 /* DW_AT_low_pc and DW_AT_high_pc are optional for
1848 compilation units. If we don't have them (i.e.,
1849 unit->high == 0), we need to consult the line info
1850 table to see if a compilation unit contains the given
1852 if (each->arange.high > 0)
1854 if (comp_unit_contains_address (each, addr))
1855 return comp_unit_find_nearest_line (each, addr,
1863 found = comp_unit_find_nearest_line (each, addr,