2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
5 Adapted from gdb/dwarf2read.c by Gavin Koch of Cygnus Solutions
8 From the dwarf2read.c header:
9 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
10 Inc. with support from Florida State University (under contract
11 with the Ada Joint Program Office), and Silicon Graphics, Inc.
12 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
13 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
14 support in dwarfread.c
16 This file is part of BFD.
18 This program is free software; you can redistribute it and/or modify
19 it under the terms of the GNU General Public License as published by
20 the Free Software Foundation; either version 2 of the License, or (at
21 your option) any later version.
23 This program is distributed in the hope that it will be useful, but
24 WITHOUT ANY WARRANTY; without even the implied warranty of
25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
26 General Public License for more details.
28 You should have received a copy of the GNU General Public License
29 along with this program; if not, write to the Free Software
30 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
34 #include "libiberty.h"
37 #include "elf/dwarf2.h"
39 /* The data in the .debug_line statement prologue looks like this. */
44 unsigned short version;
45 bfd_vma prologue_length;
46 unsigned char minimum_instruction_length;
47 unsigned char default_is_stmt;
49 unsigned char line_range;
50 unsigned char opcode_base;
51 unsigned char *standard_opcode_lengths;
54 /* Attributes have a name and a value. */
58 enum dwarf_attribute name;
63 struct dwarf_block *blk;
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
203 static unsigned int read_1_byte PARAMS ((bfd *, char *));
204 static int read_1_signed_byte PARAMS ((bfd *, char *));
205 static unsigned int read_2_bytes PARAMS ((bfd *, char *));
206 static unsigned int read_4_bytes PARAMS ((bfd *, char *));
207 static bfd_vma read_8_bytes PARAMS ((bfd *, char *));
208 static char *read_n_bytes PARAMS ((bfd *, char *, unsigned int));
209 static char *read_string PARAMS ((bfd *, char *, unsigned int *));
210 static char *read_indirect_string PARAMS ((struct comp_unit *, char *, unsigned int *));
211 static unsigned int read_unsigned_leb128
212 PARAMS ((bfd *, char *, unsigned int *));
213 static int read_signed_leb128
214 PARAMS ((bfd *, char *, unsigned int *));
215 static bfd_vma read_address PARAMS ((struct comp_unit *, char *));
216 static struct abbrev_info *lookup_abbrev
217 PARAMS ((unsigned int, struct abbrev_info **));
218 static struct abbrev_info **read_abbrevs
219 PARAMS ((bfd *, bfd_vma, struct dwarf2_debug *));
220 static char *read_attribute
221 PARAMS ((struct attribute *, struct attr_abbrev *,
222 struct comp_unit *, char *));
223 static char *read_attribute_value
224 PARAMS ((struct attribute *, unsigned,
225 struct comp_unit *, char *));
226 static void add_line_info
227 PARAMS ((struct line_info_table *, bfd_vma, char *,
228 unsigned int, unsigned int, int));
229 static char *concat_filename PARAMS ((struct line_info_table *, unsigned int));
230 static void arange_add PARAMS ((struct comp_unit *, bfd_vma, bfd_vma));
231 static struct line_info_table *decode_line_info
232 PARAMS ((struct comp_unit *, struct dwarf2_debug *));
233 static bfd_boolean lookup_address_in_line_info_table
234 PARAMS ((struct line_info_table *, bfd_vma, struct funcinfo *,
235 const char **, unsigned int *));
236 static bfd_boolean lookup_address_in_function_table
237 PARAMS ((struct funcinfo *, bfd_vma, struct funcinfo **, const char **));
238 static bfd_boolean scan_unit_for_functions PARAMS ((struct comp_unit *));
239 static struct comp_unit *parse_comp_unit
240 PARAMS ((bfd *, struct dwarf2_debug *, bfd_vma, unsigned int));
241 static bfd_boolean comp_unit_contains_address
242 PARAMS ((struct comp_unit *, bfd_vma));
243 static bfd_boolean comp_unit_find_nearest_line
244 PARAMS ((struct comp_unit *, bfd_vma, const char **, const char **,
245 unsigned int *, struct dwarf2_debug *));
246 static asection *find_debug_info PARAMS ((bfd *, asection *));
249 The following function up to the END VERBATIM mark are
250 copied directly from dwarf2read.c. */
252 /* Read dwarf information from a buffer. */
255 read_1_byte (abfd, buf)
256 bfd *abfd ATTRIBUTE_UNUSED;
259 return bfd_get_8 (abfd, (bfd_byte *) buf);
263 read_1_signed_byte (abfd, buf)
264 bfd *abfd ATTRIBUTE_UNUSED;
267 return bfd_get_signed_8 (abfd, (bfd_byte *) buf);
271 read_2_bytes (abfd, buf)
275 return bfd_get_16 (abfd, (bfd_byte *) buf);
278 #if 0 /* This is not used. */
281 read_2_signed_bytes (abfd, buf)
285 return bfd_get_signed_16 (abfd, (bfd_byte *) buf);
291 read_4_bytes (abfd, buf)
295 return bfd_get_32 (abfd, (bfd_byte *) buf);
298 #if 0 /* This is not used. */
301 read_4_signed_bytes (abfd, buf)
305 return bfd_get_signed_32 (abfd, (bfd_byte *) buf);
311 read_8_bytes (abfd, buf)
315 return bfd_get_64 (abfd, (bfd_byte *) buf);
319 read_n_bytes (abfd, buf, size)
320 bfd *abfd ATTRIBUTE_UNUSED;
322 unsigned int size ATTRIBUTE_UNUSED;
324 /* If the size of a host char is 8 bits, we can return a pointer
325 to the buffer, otherwise we have to copy the data to a buffer
326 allocated on the temporary obstack. */
331 read_string (abfd, buf, bytes_read_ptr)
332 bfd *abfd ATTRIBUTE_UNUSED;
334 unsigned int *bytes_read_ptr;
336 /* Return a pointer to the embedded string. */
343 *bytes_read_ptr = strlen (buf) + 1;
348 read_indirect_string (unit, buf, bytes_read_ptr)
349 struct comp_unit* unit;
351 unsigned int *bytes_read_ptr;
354 struct dwarf2_debug *stash = unit->stash;
356 if (unit->offset_size == 4)
357 offset = read_4_bytes (unit->abfd, buf);
359 offset = read_8_bytes (unit->abfd, buf);
360 *bytes_read_ptr = unit->offset_size;
362 if (! stash->dwarf_str_buffer)
365 bfd *abfd = unit->abfd;
367 msec = bfd_get_section_by_name (abfd, ".debug_str");
370 (*_bfd_error_handler)
371 (_("Dwarf Error: Can't find .debug_str section."));
372 bfd_set_error (bfd_error_bad_value);
376 stash->dwarf_str_size = msec->_raw_size;
377 stash->dwarf_str_buffer = (char*) bfd_alloc (abfd, msec->_raw_size);
378 if (! stash->dwarf_abbrev_buffer)
381 if (! bfd_get_section_contents (abfd, msec, stash->dwarf_str_buffer,
382 (bfd_vma) 0, msec->_raw_size))
386 if (offset >= stash->dwarf_str_size)
388 (*_bfd_error_handler) (_("Dwarf Error: DW_FORM_strp offset (%lu) greater than or equal to .debug_str size (%lu)."),
389 (unsigned long) offset, stash->dwarf_str_size);
390 bfd_set_error (bfd_error_bad_value);
394 buf = stash->dwarf_str_buffer + offset;
401 read_unsigned_leb128 (abfd, buf, bytes_read_ptr)
402 bfd *abfd ATTRIBUTE_UNUSED;
404 unsigned int *bytes_read_ptr;
407 unsigned int num_read;
417 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
420 result |= ((byte & 0x7f) << shift);
425 * bytes_read_ptr = num_read;
431 read_signed_leb128 (abfd, buf, bytes_read_ptr)
432 bfd *abfd ATTRIBUTE_UNUSED;
434 unsigned int * bytes_read_ptr;
447 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
450 result |= ((byte & 0x7f) << shift);
455 if ((shift < 32) && (byte & 0x40))
456 result |= -(1 << shift);
458 * bytes_read_ptr = num_read;
466 read_address (unit, buf)
467 struct comp_unit* unit;
470 switch (unit->addr_size)
473 return bfd_get_64 (unit->abfd, (bfd_byte *) buf);
475 return bfd_get_32 (unit->abfd, (bfd_byte *) buf);
477 return bfd_get_16 (unit->abfd, (bfd_byte *) buf);
483 /* Lookup an abbrev_info structure in the abbrev hash table. */
485 static struct abbrev_info *
486 lookup_abbrev (number,abbrevs)
488 struct abbrev_info **abbrevs;
490 unsigned int hash_number;
491 struct abbrev_info *abbrev;
493 hash_number = number % ABBREV_HASH_SIZE;
494 abbrev = abbrevs[hash_number];
498 if (abbrev->number == number)
501 abbrev = abbrev->next;
507 /* In DWARF version 2, the description of the debugging information is
508 stored in a separate .debug_abbrev section. Before we read any
509 dies from a section we read in all abbreviations and install them
512 static struct abbrev_info**
513 read_abbrevs (abfd, offset, stash)
516 struct dwarf2_debug *stash;
518 struct abbrev_info **abbrevs;
520 struct abbrev_info *cur_abbrev;
521 unsigned int abbrev_number, bytes_read, abbrev_name;
522 unsigned int abbrev_form, hash_number;
525 if (! stash->dwarf_abbrev_buffer)
529 msec = bfd_get_section_by_name (abfd, ".debug_abbrev");
532 (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_abbrev section."));
533 bfd_set_error (bfd_error_bad_value);
537 stash->dwarf_abbrev_size = msec->_raw_size;
538 stash->dwarf_abbrev_buffer
539 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
541 if (! stash->dwarf_abbrev_buffer)
545 if (offset >= stash->dwarf_abbrev_size)
547 (*_bfd_error_handler) (_("Dwarf Error: Abbrev offset (%lu) greater than or equal to .debug_abbrev size (%lu)."),
548 (unsigned long) offset, stash->dwarf_abbrev_size);
549 bfd_set_error (bfd_error_bad_value);
553 amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
554 abbrevs = (struct abbrev_info**) bfd_zalloc (abfd, amt);
556 abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
557 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
558 abbrev_ptr += bytes_read;
560 /* Loop until we reach an abbrev number of 0. */
561 while (abbrev_number)
563 amt = sizeof (struct abbrev_info);
564 cur_abbrev = (struct abbrev_info *) bfd_zalloc (abfd, amt);
566 /* Read in abbrev header. */
567 cur_abbrev->number = abbrev_number;
568 cur_abbrev->tag = (enum dwarf_tag)
569 read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
570 abbrev_ptr += bytes_read;
571 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
574 /* Now read in declarations. */
575 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
576 abbrev_ptr += bytes_read;
577 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
578 abbrev_ptr += bytes_read;
582 if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
584 amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
585 amt *= sizeof (struct attr_abbrev);
586 cur_abbrev->attrs = ((struct attr_abbrev *)
587 bfd_realloc (cur_abbrev->attrs, amt));
588 if (! cur_abbrev->attrs)
592 cur_abbrev->attrs[cur_abbrev->num_attrs].name
593 = (enum dwarf_attribute) abbrev_name;
594 cur_abbrev->attrs[cur_abbrev->num_attrs++].form
595 = (enum dwarf_form) abbrev_form;
596 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
597 abbrev_ptr += bytes_read;
598 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
599 abbrev_ptr += bytes_read;
602 hash_number = abbrev_number % ABBREV_HASH_SIZE;
603 cur_abbrev->next = abbrevs[hash_number];
604 abbrevs[hash_number] = cur_abbrev;
606 /* Get next abbreviation.
607 Under Irix6 the abbreviations for a compilation unit are not
608 always properly terminated with an abbrev number of 0.
609 Exit loop if we encounter an abbreviation which we have
610 already read (which means we are about to read the abbreviations
611 for the next compile unit) or if the end of the abbreviation
613 if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
614 >= stash->dwarf_abbrev_size)
616 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
617 abbrev_ptr += bytes_read;
618 if (lookup_abbrev (abbrev_number,abbrevs) != NULL)
625 /* Read an attribute value described by an attribute form. */
628 read_attribute_value (attr, form, unit, info_ptr)
629 struct attribute *attr;
631 struct comp_unit *unit;
634 bfd *abfd = unit->abfd;
635 unsigned int bytes_read;
636 struct dwarf_block *blk;
639 attr->form = (enum dwarf_form) form;
644 /* FIXME: DWARF3 draft says DW_FORM_ref_addr is offset_size. */
645 case DW_FORM_ref_addr:
646 attr->u.val = read_address (unit, info_ptr);
647 info_ptr += unit->addr_size;
650 amt = sizeof (struct dwarf_block);
651 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
652 blk->size = read_2_bytes (abfd, info_ptr);
654 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
655 info_ptr += blk->size;
659 amt = sizeof (struct dwarf_block);
660 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
661 blk->size = read_4_bytes (abfd, info_ptr);
663 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
664 info_ptr += blk->size;
668 attr->u.val = read_2_bytes (abfd, info_ptr);
672 attr->u.val = read_4_bytes (abfd, info_ptr);
676 attr->u.val = read_8_bytes (abfd, info_ptr);
680 attr->u.str = read_string (abfd, info_ptr, &bytes_read);
681 info_ptr += bytes_read;
684 attr->u.str = read_indirect_string (unit, info_ptr, &bytes_read);
685 info_ptr += bytes_read;
688 amt = sizeof (struct dwarf_block);
689 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
690 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
691 info_ptr += bytes_read;
692 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
693 info_ptr += blk->size;
697 amt = sizeof (struct dwarf_block);
698 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
699 blk->size = read_1_byte (abfd, info_ptr);
701 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
702 info_ptr += blk->size;
706 attr->u.val = read_1_byte (abfd, info_ptr);
710 attr->u.val = read_1_byte (abfd, info_ptr);
714 attr->u.sval = read_signed_leb128 (abfd, info_ptr, &bytes_read);
715 info_ptr += bytes_read;
718 attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
719 info_ptr += bytes_read;
722 attr->u.val = read_1_byte (abfd, info_ptr);
726 attr->u.val = read_2_bytes (abfd, info_ptr);
730 attr->u.val = read_4_bytes (abfd, info_ptr);
734 attr->u.val = read_8_bytes (abfd, info_ptr);
737 case DW_FORM_ref_udata:
738 attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
739 info_ptr += bytes_read;
741 case DW_FORM_indirect:
742 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
743 info_ptr += bytes_read;
744 info_ptr = read_attribute_value (attr, form, unit, info_ptr);
747 (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %u."),
749 bfd_set_error (bfd_error_bad_value);
754 /* Read an attribute described by an abbreviated attribute. */
757 read_attribute (attr, abbrev, unit, info_ptr)
758 struct attribute *attr;
759 struct attr_abbrev *abbrev;
760 struct comp_unit *unit;
763 attr->name = abbrev->name;
764 info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr);
768 /* Source line information table routines. */
770 #define FILE_ALLOC_CHUNK 5
771 #define DIR_ALLOC_CHUNK 5
775 struct line_info* prev_line;
780 int end_sequence; /* End of (sequential) code sequence. */
791 struct line_info_table
794 unsigned int num_files;
795 unsigned int num_dirs;
798 struct fileinfo* files;
799 struct line_info* last_line; /* largest VMA */
800 struct line_info* lcl_head; /* local head; used in 'add_line_info' */
805 struct funcinfo *prev_func;
811 /* Adds a new entry to the line_info list in the line_info_table, ensuring
812 that the list is sorted. Note that the line_info list is sorted from
813 highest to lowest VMA (with possible duplicates); that is,
814 line_info->prev_line always accesses an equal or smaller VMA. */
817 add_line_info (table, address, filename, line, column, end_sequence)
818 struct line_info_table* table;
825 bfd_size_type amt = sizeof (struct line_info);
826 struct line_info* info = (struct line_info*) bfd_alloc (table->abfd, amt);
828 /* Find the correct location for 'info'. Normally we will receive
829 new line_info data 1) in order and 2) with increasing VMAs.
830 However some compilers break the rules (cf. decode_line_info) and
831 so we include some heuristics for quickly finding the correct
832 location for 'info'. In particular, these heuristics optimize for
833 the common case in which the VMA sequence that we receive is a
834 list of locally sorted VMAs such as
835 p...z a...j (where a < j < p < z)
837 Note: table->lcl_head is used to head an *actual* or *possible*
838 sequence within the list (such as a...j) that is not directly
839 headed by table->last_line
841 Note: we may receive duplicate entries from 'decode_line_info'. */
844 if (!table->last_line
845 || address >= table->last_line->address)
847 /* Normal case: add 'info' to the beginning of the list */
848 info->prev_line = table->last_line;
849 table->last_line = info;
851 /* lcl_head: initialize to head a *possible* sequence at the end. */
852 if (!table->lcl_head)
853 table->lcl_head = info;
856 else if (!table->lcl_head->prev_line
857 && table->lcl_head->address > address)
859 /* Abnormal but easy: lcl_head is 1) at the *end* of the line
860 list and 2) the head of 'info'. */
861 info->prev_line = NULL;
862 table->lcl_head->prev_line = info;
865 else if (table->lcl_head->prev_line
866 && table->lcl_head->address > address
867 && address >= table->lcl_head->prev_line->address)
869 /* Abnormal but easy: lcl_head is 1) in the *middle* of the line
870 list and 2) the head of 'info'. */
871 info->prev_line = table->lcl_head->prev_line;
872 table->lcl_head->prev_line = info;
877 /* Abnormal and hard: Neither 'last_line' nor 'lcl_head' are valid
878 heads for 'info'. Reset 'lcl_head' and repeat. */
879 struct line_info* li2 = table->last_line; /* always non-NULL */
880 struct line_info* li1 = li2->prev_line;
884 if (li2->address > address && address >= li1->address)
887 li2 = li1; /* always non-NULL */
888 li1 = li1->prev_line;
890 table->lcl_head = li2;
893 /* Set member data of 'info'. */
894 info->address = address;
896 info->column = column;
897 info->end_sequence = end_sequence;
899 amt = strlen (filename);
902 info->filename = bfd_alloc (table->abfd, amt + 1);
904 strcpy (info->filename, filename);
907 info->filename = NULL;
910 /* Extract a fully qualified filename from a line info table.
911 The returned string has been malloc'ed and it is the caller's
912 responsibility to free it. */
915 concat_filename (table, file)
916 struct line_info_table* table;
921 if (file - 1 >= table->num_files)
923 (*_bfd_error_handler)
924 (_("Dwarf Error: mangled line number section (bad file number)."));
925 return strdup ("<unknown>");
928 filename = table->files[file - 1].name;
930 if (! IS_ABSOLUTE_PATH (filename))
932 char* dirname = (table->files[file - 1].dir
933 ? table->dirs[table->files[file - 1].dir - 1]
936 /* Not all tools set DW_AT_comp_dir, so dirname may be unknown.
937 The best we can do is return the filename part. */
940 unsigned int len = strlen (dirname) + strlen (filename) + 2;
943 name = bfd_malloc (len);
945 sprintf (name, "%s/%s", dirname, filename);
950 return strdup (filename);
954 arange_add (unit, low_pc, high_pc)
955 struct comp_unit *unit;
959 struct arange *arange;
961 /* First see if we can cheaply extend an existing range. */
962 arange = &unit->arange;
966 if (low_pc == arange->high)
968 arange->high = high_pc;
971 if (high_pc == arange->low)
973 arange->low = low_pc;
976 arange = arange->next;
980 if (unit->arange.high == 0)
982 /* This is the first address range: store it in unit->arange. */
983 unit->arange.next = 0;
984 unit->arange.low = low_pc;
985 unit->arange.high = high_pc;
989 /* Need to allocate a new arange and insert it into the arange list. */
990 arange = (struct arange *)
991 bfd_zalloc (unit->abfd, (bfd_size_type) sizeof (*arange));
992 arange->low = low_pc;
993 arange->high = high_pc;
995 arange->next = unit->arange.next;
996 unit->arange.next = arange;
999 /* Decode the line number information for UNIT. */
1001 static struct line_info_table*
1002 decode_line_info (unit, stash)
1003 struct comp_unit *unit;
1004 struct dwarf2_debug *stash;
1006 bfd *abfd = unit->abfd;
1007 struct line_info_table* table;
1010 struct line_head lh;
1011 unsigned int i, bytes_read, offset_size;
1012 char *cur_file, *cur_dir;
1013 unsigned char op_code, extended_op, adj_opcode;
1016 if (! stash->dwarf_line_buffer)
1020 msec = bfd_get_section_by_name (abfd, ".debug_line");
1023 (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_line section."));
1024 bfd_set_error (bfd_error_bad_value);
1028 stash->dwarf_line_size = msec->_raw_size;
1029 stash->dwarf_line_buffer
1030 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
1032 if (! stash->dwarf_line_buffer)
1036 /* It is possible to get a bad value for the line_offset. Validate
1037 it here so that we won't get a segfault below. */
1038 if (unit->line_offset >= stash->dwarf_line_size)
1040 (*_bfd_error_handler) (_("Dwarf Error: Line offset (%lu) greater than or equal to .debug_line size (%lu)."),
1041 unit->line_offset, stash->dwarf_line_size);
1042 bfd_set_error (bfd_error_bad_value);
1046 amt = sizeof (struct line_info_table);
1047 table = (struct line_info_table*) bfd_alloc (abfd, amt);
1049 table->comp_dir = unit->comp_dir;
1051 table->num_files = 0;
1052 table->files = NULL;
1054 table->num_dirs = 0;
1057 table->files = NULL;
1058 table->last_line = NULL;
1059 table->lcl_head = NULL;
1061 line_ptr = stash->dwarf_line_buffer + unit->line_offset;
1063 /* Read in the prologue. */
1064 lh.total_length = read_4_bytes (abfd, line_ptr);
1067 if (lh.total_length == 0xffffffff)
1069 lh.total_length = read_8_bytes (abfd, line_ptr);
1073 else if (lh.total_length == 0 && unit->addr_size == 8)
1075 /* Handle (non-standard) 64-bit DWARF2 formats. */
1076 lh.total_length = read_4_bytes (abfd, line_ptr);
1080 line_end = line_ptr + lh.total_length;
1081 lh.version = read_2_bytes (abfd, line_ptr);
1083 if (offset_size == 4)
1084 lh.prologue_length = read_4_bytes (abfd, line_ptr);
1086 lh.prologue_length = read_8_bytes (abfd, line_ptr);
1087 line_ptr += offset_size;
1088 lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
1090 lh.default_is_stmt = read_1_byte (abfd, line_ptr);
1092 lh.line_base = read_1_signed_byte (abfd, line_ptr);
1094 lh.line_range = read_1_byte (abfd, line_ptr);
1096 lh.opcode_base = read_1_byte (abfd, line_ptr);
1098 amt = lh.opcode_base * sizeof (unsigned char);
1099 lh.standard_opcode_lengths = (unsigned char *) bfd_alloc (abfd, amt);
1101 lh.standard_opcode_lengths[0] = 1;
1103 for (i = 1; i < lh.opcode_base; ++i)
1105 lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
1109 /* Read directory table. */
1110 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1112 line_ptr += bytes_read;
1114 if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
1116 amt = table->num_dirs + DIR_ALLOC_CHUNK;
1117 amt *= sizeof (char *);
1118 table->dirs = (char **) bfd_realloc (table->dirs, amt);
1123 table->dirs[table->num_dirs++] = cur_dir;
1126 line_ptr += bytes_read;
1128 /* Read file name table. */
1129 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1131 line_ptr += bytes_read;
1133 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1135 amt = table->num_files + FILE_ALLOC_CHUNK;
1136 amt *= sizeof (struct fileinfo);
1137 table->files = (struct fileinfo *) bfd_realloc (table->files, amt);
1142 table->files[table->num_files].name = cur_file;
1143 table->files[table->num_files].dir =
1144 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1145 line_ptr += bytes_read;
1146 table->files[table->num_files].time =
1147 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1148 line_ptr += bytes_read;
1149 table->files[table->num_files].size =
1150 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1151 line_ptr += bytes_read;
1155 line_ptr += bytes_read;
1157 /* Read the statement sequences until there's nothing left. */
1158 while (line_ptr < line_end)
1160 /* State machine registers. */
1161 bfd_vma address = 0;
1162 char * filename = table->num_files ? concat_filename (table, 1) : NULL;
1163 unsigned int line = 1;
1164 unsigned int column = 0;
1165 int is_stmt = lh.default_is_stmt;
1166 int basic_block = 0;
1167 int end_sequence = 0;
1168 /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1169 compilers generate address sequences that are wildly out of
1170 order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1171 for ia64-Linux). Thus, to determine the low and high
1172 address, we must compare on every DW_LNS_copy, etc. */
1174 bfd_vma high_pc = 0;
1176 /* Decode the table. */
1177 while (! end_sequence)
1179 op_code = read_1_byte (abfd, line_ptr);
1182 if (op_code >= lh.opcode_base)
1184 /* Special operand. */
1185 adj_opcode = op_code - lh.opcode_base;
1186 address += (adj_opcode / lh.line_range)
1187 * lh.minimum_instruction_length;
1188 line += lh.line_base + (adj_opcode % lh.line_range);
1189 /* Append row to matrix using current values. */
1190 add_line_info (table, address, filename, line, column, 0);
1192 if (low_pc == 0 || address < low_pc)
1194 if (address > high_pc)
1197 else switch (op_code)
1199 case DW_LNS_extended_op:
1200 /* Ignore length. */
1202 extended_op = read_1_byte (abfd, line_ptr);
1205 switch (extended_op)
1207 case DW_LNE_end_sequence:
1209 add_line_info (table, address, filename, line, column,
1211 if (low_pc == 0 || address < low_pc)
1213 if (address > high_pc)
1215 arange_add (unit, low_pc, high_pc);
1217 case DW_LNE_set_address:
1218 address = read_address (unit, line_ptr);
1219 line_ptr += unit->addr_size;
1221 case DW_LNE_define_file:
1222 cur_file = read_string (abfd, line_ptr, &bytes_read);
1223 line_ptr += bytes_read;
1224 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1226 amt = table->num_files + FILE_ALLOC_CHUNK;
1227 amt *= sizeof (struct fileinfo);
1229 (struct fileinfo *) bfd_realloc (table->files, amt);
1233 table->files[table->num_files].name = cur_file;
1234 table->files[table->num_files].dir =
1235 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1236 line_ptr += bytes_read;
1237 table->files[table->num_files].time =
1238 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1239 line_ptr += bytes_read;
1240 table->files[table->num_files].size =
1241 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1242 line_ptr += bytes_read;
1246 (*_bfd_error_handler) (_("Dwarf Error: mangled line number section."));
1247 bfd_set_error (bfd_error_bad_value);
1252 add_line_info (table, address, filename, line, column, 0);
1254 if (low_pc == 0 || address < low_pc)
1256 if (address > high_pc)
1259 case DW_LNS_advance_pc:
1260 address += lh.minimum_instruction_length
1261 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1262 line_ptr += bytes_read;
1264 case DW_LNS_advance_line:
1265 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
1266 line_ptr += bytes_read;
1268 case DW_LNS_set_file:
1272 /* The file and directory tables are 0
1273 based, the references are 1 based. */
1274 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1275 line_ptr += bytes_read;
1278 filename = concat_filename (table, file);
1281 case DW_LNS_set_column:
1282 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1283 line_ptr += bytes_read;
1285 case DW_LNS_negate_stmt:
1286 is_stmt = (!is_stmt);
1288 case DW_LNS_set_basic_block:
1291 case DW_LNS_const_add_pc:
1292 address += lh.minimum_instruction_length
1293 * ((255 - lh.opcode_base) / lh.line_range);
1295 case DW_LNS_fixed_advance_pc:
1296 address += read_2_bytes (abfd, line_ptr);
1303 /* Unknown standard opcode, ignore it. */
1304 for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
1306 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1307 line_ptr += bytes_read;
1320 /* If ADDR is within TABLE set the output parameters and return TRUE,
1321 otherwise return FALSE. The output parameters, FILENAME_PTR and
1322 LINENUMBER_PTR, are pointers to the objects to be filled in. */
1325 lookup_address_in_line_info_table (table, addr, function, filename_ptr,
1327 struct line_info_table* table;
1329 struct funcinfo *function;
1330 const char **filename_ptr;
1331 unsigned int *linenumber_ptr;
1333 /* Note: table->last_line should be a descendingly sorted list. */
1334 struct line_info* next_line = table->last_line;
1335 struct line_info* each_line = NULL;
1336 *filename_ptr = NULL;
1341 each_line = next_line->prev_line;
1343 /* Check for large addresses */
1344 if (addr > next_line->address)
1345 each_line = NULL; /* ensure we skip over the normal case */
1347 /* Normal case: search the list; save */
1348 while (each_line && next_line)
1350 /* If we have an address match, save this info. This allows us
1351 to return as good as results as possible for strange debugging
1353 bfd_boolean addr_match = FALSE;
1354 if (each_line->address <= addr && addr <= next_line->address)
1358 /* If this line appears to span functions, and addr is in the
1359 later function, return the first line of that function instead
1360 of the last line of the earlier one. This check is for GCC
1361 2.95, which emits the first line number for a function late. */
1362 if (function != NULL
1363 && each_line->address < function->low
1364 && next_line->address > function->low)
1366 *filename_ptr = next_line->filename;
1367 *linenumber_ptr = next_line->line;
1371 *filename_ptr = each_line->filename;
1372 *linenumber_ptr = each_line->line;
1376 if (addr_match && !each_line->end_sequence)
1377 return TRUE; /* we have definitely found what we want */
1379 next_line = each_line;
1380 each_line = each_line->prev_line;
1383 /* At this point each_line is NULL but next_line is not. If we found
1384 a candidate end-of-sequence point in the loop above, we can return
1385 that (compatibility with a bug in the Intel compiler); otherwise,
1386 assuming that we found the containing function for this address in
1387 this compilation unit, return the first line we have a number for
1388 (compatibility with GCC 2.95). */
1389 if (*filename_ptr == NULL && function != NULL)
1391 *filename_ptr = next_line->filename;
1392 *linenumber_ptr = next_line->line;
1399 /* Function table functions. */
1401 /* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return TRUE. */
1404 lookup_address_in_function_table (table, addr, function_ptr,
1406 struct funcinfo* table;
1408 struct funcinfo** function_ptr;
1409 const char **functionname_ptr;
1411 struct funcinfo* each_func;
1413 for (each_func = table;
1415 each_func = each_func->prev_func)
1417 if (addr >= each_func->low && addr < each_func->high)
1419 *functionname_ptr = each_func->name;
1420 *function_ptr = each_func;
1428 /* DWARF2 Compilation unit functions. */
1430 /* Scan over each die in a comp. unit looking for functions to add
1431 to the function table. */
1434 scan_unit_for_functions (unit)
1435 struct comp_unit *unit;
1437 bfd *abfd = unit->abfd;
1438 char *info_ptr = unit->first_child_die_ptr;
1439 int nesting_level = 1;
1441 while (nesting_level)
1443 unsigned int abbrev_number, bytes_read, i;
1444 struct abbrev_info *abbrev;
1445 struct attribute attr;
1446 struct funcinfo *func;
1449 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1450 info_ptr += bytes_read;
1452 if (! abbrev_number)
1458 abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
1461 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1463 bfd_set_error (bfd_error_bad_value);
1467 if (abbrev->tag == DW_TAG_subprogram)
1469 bfd_size_type amt = sizeof (struct funcinfo);
1470 func = (struct funcinfo *) bfd_zalloc (abfd, amt);
1471 func->prev_func = unit->function_table;
1472 unit->function_table = func;
1477 for (i = 0; i < abbrev->num_attrs; ++i)
1479 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1489 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
1490 if (func->name == NULL)
1491 func->name = attr.u.str;
1494 case DW_AT_MIPS_linkage_name:
1495 func->name = attr.u.str;
1499 func->low = attr.u.val;
1503 func->high = attr.u.val;
1524 if (abbrev->has_children)
1531 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
1532 includes the compilation unit header that proceeds the DIE's, but
1533 does not include the length field that preceeds each compilation
1534 unit header. END_PTR points one past the end of this comp unit.
1535 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
1537 This routine does not read the whole compilation unit; only enough
1538 to get to the line number information for the compilation unit. */
1540 static struct comp_unit *
1541 parse_comp_unit (abfd, stash, unit_length, offset_size)
1543 struct dwarf2_debug *stash;
1544 bfd_vma unit_length;
1545 unsigned int offset_size;
1547 struct comp_unit* unit;
1548 unsigned int version;
1549 bfd_vma abbrev_offset = 0;
1550 unsigned int addr_size;
1551 struct abbrev_info** abbrevs;
1552 unsigned int abbrev_number, bytes_read, i;
1553 struct abbrev_info *abbrev;
1554 struct attribute attr;
1555 char *info_ptr = stash->info_ptr;
1556 char *end_ptr = info_ptr + unit_length;
1559 version = read_2_bytes (abfd, info_ptr);
1561 BFD_ASSERT (offset_size == 4 || offset_size == 8);
1562 if (offset_size == 4)
1563 abbrev_offset = read_4_bytes (abfd, info_ptr);
1565 abbrev_offset = read_8_bytes (abfd, info_ptr);
1566 info_ptr += offset_size;
1567 addr_size = read_1_byte (abfd, info_ptr);
1572 (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 information."), version);
1573 bfd_set_error (bfd_error_bad_value);
1577 if (addr_size > sizeof (bfd_vma))
1579 (*_bfd_error_handler) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
1581 (unsigned int) sizeof (bfd_vma));
1582 bfd_set_error (bfd_error_bad_value);
1586 if (addr_size != 2 && addr_size != 4 && addr_size != 8)
1588 (*_bfd_error_handler) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size);
1589 bfd_set_error (bfd_error_bad_value);
1593 /* Read the abbrevs for this compilation unit into a table. */
1594 abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
1598 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1599 info_ptr += bytes_read;
1600 if (! abbrev_number)
1602 (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u."),
1604 bfd_set_error (bfd_error_bad_value);
1608 abbrev = lookup_abbrev (abbrev_number, abbrevs);
1611 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1613 bfd_set_error (bfd_error_bad_value);
1617 amt = sizeof (struct comp_unit);
1618 unit = (struct comp_unit*) bfd_zalloc (abfd, amt);
1620 unit->addr_size = addr_size;
1621 unit->offset_size = offset_size;
1622 unit->abbrevs = abbrevs;
1623 unit->end_ptr = end_ptr;
1624 unit->stash = stash;
1626 for (i = 0; i < abbrev->num_attrs; ++i)
1628 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1630 /* Store the data if it is of an attribute we want to keep in a
1631 partial symbol table. */
1634 case DW_AT_stmt_list:
1636 unit->line_offset = attr.u.val;
1640 unit->name = attr.u.str;
1644 unit->arange.low = attr.u.val;
1648 unit->arange.high = attr.u.val;
1651 case DW_AT_comp_dir:
1653 char* comp_dir = attr.u.str;
1656 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1657 directory, get rid of it. */
1658 char *cp = (char*) strchr (comp_dir, ':');
1660 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
1663 unit->comp_dir = comp_dir;
1672 unit->first_child_die_ptr = info_ptr;
1676 /* Return TRUE if UNIT contains the address given by ADDR. */
1679 comp_unit_contains_address (unit, addr)
1680 struct comp_unit* unit;
1683 struct arange *arange;
1688 arange = &unit->arange;
1691 if (addr >= arange->low && addr < arange->high)
1693 arange = arange->next;
1700 /* If UNIT contains ADDR, set the output parameters to the values for
1701 the line containing ADDR. The output parameters, FILENAME_PTR,
1702 FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
1705 Return TRUE if UNIT contains ADDR, and no errors were encountered;
1709 comp_unit_find_nearest_line (unit, addr, filename_ptr, functionname_ptr,
1710 linenumber_ptr, stash)
1711 struct comp_unit* unit;
1713 const char **filename_ptr;
1714 const char **functionname_ptr;
1715 unsigned int *linenumber_ptr;
1716 struct dwarf2_debug *stash;
1720 struct funcinfo *function;
1725 if (! unit->line_table)
1727 if (! unit->stmtlist)
1733 unit->line_table = decode_line_info (unit, stash);
1735 if (! unit->line_table)
1741 if (unit->first_child_die_ptr < unit->end_ptr
1742 && ! scan_unit_for_functions (unit))
1750 func_p = lookup_address_in_function_table (unit->function_table, addr,
1751 &function, functionname_ptr);
1752 line_p = lookup_address_in_line_info_table (unit->line_table, addr,
1753 function, filename_ptr,
1755 return line_p || func_p;
1758 /* Locate a section in a BFD containing debugging info. The search starts
1759 from the section after AFTER_SEC, or from the first section in the BFD if
1760 AFTER_SEC is NULL. The search works by examining the names of the
1761 sections. There are two permissiable names. The first is .debug_info.
1762 This is the standard DWARF2 name. The second is a prefix .gnu.linkonce.wi.
1763 This is a variation on the .debug_info section which has a checksum
1764 describing the contents appended onto the name. This allows the linker to
1765 identify and discard duplicate debugging sections for different
1766 compilation units. */
1767 #define DWARF2_DEBUG_INFO ".debug_info"
1768 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
1771 find_debug_info (abfd, after_sec)
1773 asection * after_sec;
1778 msec = after_sec->next;
1780 msec = abfd->sections;
1784 if (strcmp (msec->name, DWARF2_DEBUG_INFO) == 0)
1787 if (strncmp (msec->name, GNU_LINKONCE_INFO, strlen (GNU_LINKONCE_INFO)) == 0)
1796 /* The DWARF2 version of find_nearest line. Return TRUE if the line
1797 is found without error. ADDR_SIZE is the number of bytes in the
1798 initial .debug_info length field and in the abbreviation offset.
1799 You may use zero to indicate that the default value should be
1803 _bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
1804 filename_ptr, functionname_ptr,
1805 linenumber_ptr, addr_size, pinfo)
1810 const char **filename_ptr;
1811 const char **functionname_ptr;
1812 unsigned int *linenumber_ptr;
1813 unsigned int addr_size;
1816 /* Read each compilation unit from the section .debug_info, and check
1817 to see if it contains the address we are searching for. If yes,
1818 lookup the address, and return the line number info. If no, go
1819 on to the next compilation unit.
1821 We keep a list of all the previously read compilation units, and
1822 a pointer to the next un-read compilation unit. Check the
1823 previously read units before reading more. */
1824 struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
1826 /* What address are we looking for? */
1827 bfd_vma addr = offset + section->vma;
1829 struct comp_unit* each;
1831 *filename_ptr = NULL;
1832 *functionname_ptr = NULL;
1833 *linenumber_ptr = 0;
1835 /* The DWARF2 spec says that the initial length field, and the
1836 offset of the abbreviation table, should both be 4-byte values.
1837 However, some compilers do things differently. */
1840 BFD_ASSERT (addr_size == 4 || addr_size == 8);
1844 bfd_size_type total_size;
1846 bfd_size_type amt = sizeof (struct dwarf2_debug);
1848 stash = (struct dwarf2_debug*) bfd_zalloc (abfd, amt);
1852 *pinfo = (PTR) stash;
1854 msec = find_debug_info (abfd, NULL);
1856 /* No dwarf2 info. Note that at this point the stash
1857 has been allocated, but contains zeros, this lets
1858 future calls to this function fail quicker. */
1861 /* There can be more than one DWARF2 info section in a BFD these days.
1862 Read them all in and produce one large stash. We do this in two
1863 passes - in the first pass we just accumulate the section sizes.
1864 In the second pass we read in the section's contents. The allows
1865 us to avoid reallocing the data as we add sections to the stash. */
1866 for (total_size = 0; msec; msec = find_debug_info (abfd, msec))
1867 total_size += msec->_raw_size;
1869 stash->info_ptr = (char *) bfd_alloc (abfd, total_size);
1870 if (stash->info_ptr == NULL)
1873 stash->info_ptr_end = stash->info_ptr;
1875 for (msec = find_debug_info (abfd, NULL);
1877 msec = find_debug_info (abfd, msec))
1880 bfd_size_type start;
1882 size = msec->_raw_size;
1886 start = stash->info_ptr_end - stash->info_ptr;
1888 if ((bfd_simple_get_relocated_section_contents
1889 (abfd, msec, stash->info_ptr + start, symbols)) == NULL)
1892 stash->info_ptr_end = stash->info_ptr + start + size;
1895 BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size);
1897 stash->sec = find_debug_info (abfd, NULL);
1898 stash->sec_info_ptr = stash->info_ptr;
1899 stash->syms = symbols;
1902 /* A null info_ptr indicates that there is no dwarf2 info
1903 (or that an error occured while setting up the stash). */
1904 if (! stash->info_ptr)
1907 /* Check the previously read comp. units first. */
1908 for (each = stash->all_comp_units; each; each = each->next_unit)
1909 if (comp_unit_contains_address (each, addr))
1910 return comp_unit_find_nearest_line (each, addr, filename_ptr,
1911 functionname_ptr, linenumber_ptr,
1914 /* Read each remaining comp. units checking each as they are read. */
1915 while (stash->info_ptr < stash->info_ptr_end)
1919 unsigned int offset_size = addr_size;
1921 length = read_4_bytes (abfd, stash->info_ptr);
1922 /* A 0xffffff length is the DWARF3 way of indicating we use
1923 64-bit offsets, instead of 32-bit offsets. */
1924 if (length == 0xffffffff)
1927 length = read_8_bytes (abfd, stash->info_ptr + 4);
1928 stash->info_ptr += 12;
1930 /* A zero length is the IRIX way of indicating 64-bit offsets,
1931 mostly because the 64-bit length will generally fit in 32
1932 bits, and the endianness helps. */
1933 else if (length == 0)
1936 length = read_4_bytes (abfd, stash->info_ptr + 4);
1937 stash->info_ptr += 8;
1939 /* In the absence of the hints above, we assume addr_size-sized
1940 offsets, for backward-compatibility with pre-DWARF3 64-bit
1942 else if (addr_size == 8)
1944 length = read_8_bytes (abfd, stash->info_ptr);
1945 stash->info_ptr += 8;
1948 stash->info_ptr += 4;
1952 each = parse_comp_unit (abfd, stash, length, offset_size);
1953 stash->info_ptr += length;
1955 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
1956 == stash->sec->_raw_size)
1958 stash->sec = find_debug_info (abfd, stash->sec);
1959 stash->sec_info_ptr = stash->info_ptr;
1964 each->next_unit = stash->all_comp_units;
1965 stash->all_comp_units = each;
1967 /* DW_AT_low_pc and DW_AT_high_pc are optional for
1968 compilation units. If we don't have them (i.e.,
1969 unit->high == 0), we need to consult the line info
1970 table to see if a compilation unit contains the given
1972 if (each->arange.high > 0)
1974 if (comp_unit_contains_address (each, addr))
1975 return comp_unit_find_nearest_line (each, addr,
1983 found = comp_unit_find_nearest_line (each, addr,