2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 Adapted from gdb/dwarf2read.c by Gavin Koch of Cygnus Solutions
8 From the dwarf2read.c header:
9 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
10 Inc. with support from Florida State University (under contract
11 with the Ada Joint Program Office), and Silicon Graphics, Inc.
12 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
13 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
14 support in dwarfread.c
16 This file is part of BFD.
18 This program is free software; you can redistribute it and/or modify
19 it under the terms of the GNU General Public License as published by
20 the Free Software Foundation; either version 2 of the License, or (at
21 your option) any later version.
23 This program is distributed in the hope that it will be useful, but
24 WITHOUT ANY WARRANTY; without even the implied warranty of
25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
26 General Public License for more details.
28 You should have received a copy of the GNU General Public License
29 along with this program; if not, write to the Free Software
30 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
34 #include "libiberty.h"
37 #include "elf/dwarf2.h"
39 /* The data in the .debug_line statement prologue looks like this. */
44 unsigned short version;
45 bfd_vma prologue_length;
46 unsigned char minimum_instruction_length;
47 unsigned char default_is_stmt;
49 unsigned char line_range;
50 unsigned char opcode_base;
51 unsigned char *standard_opcode_lengths;
54 /* Attributes have a name and a value. */
58 enum dwarf_attribute name;
63 struct dwarf_block *blk;
71 /* Get at parts of an attribute structure. */
73 #define DW_STRING(attr) ((attr)->u.str)
74 #define DW_UNSND(attr) ((attr)->u.unsnd)
75 #define DW_BLOCK(attr) ((attr)->u.blk)
76 #define DW_SND(attr) ((attr)->u.snd)
77 #define DW_ADDR(attr) ((attr)->u.addr)
79 /* Blocks are a bunch of untyped bytes. */
88 /* A list of all previously read comp_units. */
89 struct comp_unit* all_comp_units;
91 /* The next unread compilation unit within the .debug_info section.
92 Zero indicates that the .debug_info section has not been loaded
96 /* Pointer to the end of the .debug_info section memory buffer. */
99 /* Pointer to the section and address of the beginning of the
104 /* Pointer to the symbol table. */
107 /* Pointer to the .debug_abbrev section loaded into memory. */
108 char* dwarf_abbrev_buffer;
110 /* Length of the loaded .debug_abbrev section. */
111 unsigned long dwarf_abbrev_size;
113 /* Buffer for decode_line_info. */
114 char *dwarf_line_buffer;
116 /* Length of the loaded .debug_line section. */
117 unsigned long dwarf_line_size;
119 /* Pointer to the .debug_str section loaded into memory. */
120 char* dwarf_str_buffer;
122 /* Length of the loaded .debug_str section. */
123 unsigned long dwarf_str_size;
133 /* A minimal decoding of DWARF2 compilation units. We only decode
134 what's needed to get to the line number information. */
138 /* Chain the previously read compilation units. */
139 struct comp_unit* next_unit;
141 /* Keep the bdf convenient (for memory allocation). */
144 /* The lowest and higest addresses contained in this compilation
145 unit as specified in the compilation unit header. */
146 struct arange arange;
148 /* The DW_AT_name attribute (for error messages). */
151 /* The abbrev hash table. */
152 struct abbrev_info** abbrevs;
154 /* Note that an error was found by comp_unit_find_nearest_line. */
157 /* The DW_AT_comp_dir attribute. */
160 /* True if there is a line number table associated with this comp. unit. */
163 /* The offset into .debug_line of the line number table. */
164 unsigned long line_offset;
166 /* Pointer to the first child die for the comp unit. */
167 char *first_child_die_ptr;
169 /* The end of the comp unit. */
172 /* The decoded line number, NULL if not yet decoded. */
173 struct line_info_table* line_table;
175 /* A list of the functions found in this comp. unit. */
176 struct funcinfo* function_table;
178 /* Pointer to dwarf2_debug structure. */
179 struct dwarf2_debug *stash;
181 /* Address size for this unit - from unit header. */
182 unsigned char addr_size;
184 /* Offset size for this unit - from unit header. */
185 unsigned char offset_size;
188 /* This data structure holds the information of an abbrev. */
191 unsigned int number; /* Number identifying abbrev. */
192 enum dwarf_tag tag; /* DWARF tag. */
193 int has_children; /* Boolean. */
194 unsigned int num_attrs; /* Number of attributes. */
195 struct attr_abbrev *attrs; /* An array of attribute descriptions. */
196 struct abbrev_info *next; /* Next in chain. */
201 enum dwarf_attribute name;
202 enum dwarf_form form;
205 #ifndef ABBREV_HASH_SIZE
206 #define ABBREV_HASH_SIZE 121
208 #ifndef ATTR_ALLOC_CHUNK
209 #define ATTR_ALLOC_CHUNK 4
212 static unsigned int read_1_byte PARAMS ((bfd *, char *));
213 static int read_1_signed_byte PARAMS ((bfd *, char *));
214 static unsigned int read_2_bytes PARAMS ((bfd *, char *));
215 static unsigned int read_4_bytes PARAMS ((bfd *, char *));
216 static bfd_vma read_8_bytes PARAMS ((bfd *, char *));
217 static char *read_n_bytes PARAMS ((bfd *, char *, unsigned int));
218 static char *read_string PARAMS ((bfd *, char *, unsigned int *));
219 static char *read_indirect_string PARAMS ((struct comp_unit *, char *, unsigned int *));
220 static unsigned int read_unsigned_leb128
221 PARAMS ((bfd *, char *, unsigned int *));
222 static int read_signed_leb128
223 PARAMS ((bfd *, char *, unsigned int *));
224 static bfd_vma read_address PARAMS ((struct comp_unit *, char *));
225 static struct abbrev_info *lookup_abbrev
226 PARAMS ((unsigned int, struct abbrev_info **));
227 static struct abbrev_info **read_abbrevs
228 PARAMS ((bfd *, bfd_vma, struct dwarf2_debug *));
229 static char *read_attribute
230 PARAMS ((struct attribute *, struct attr_abbrev *,
231 struct comp_unit *, char *));
232 static char *read_attribute_value
233 PARAMS ((struct attribute *, unsigned,
234 struct comp_unit *, char *));
235 static void add_line_info
236 PARAMS ((struct line_info_table *, bfd_vma, char *,
237 unsigned int, unsigned int, int));
238 static char *concat_filename PARAMS ((struct line_info_table *, unsigned int));
239 static void arange_add PARAMS ((struct comp_unit *, bfd_vma, bfd_vma));
240 static struct line_info_table *decode_line_info
241 PARAMS ((struct comp_unit *, struct dwarf2_debug *));
242 static boolean lookup_address_in_line_info_table
243 PARAMS ((struct line_info_table *, bfd_vma, struct funcinfo *,
244 const char **, unsigned int *));
245 static boolean lookup_address_in_function_table
246 PARAMS ((struct funcinfo *, bfd_vma, struct funcinfo **, const char **));
247 static boolean scan_unit_for_functions PARAMS ((struct comp_unit *));
248 static bfd_vma find_rela_addend
249 PARAMS ((bfd *, asection *, bfd_size_type, asymbol**));
250 static struct comp_unit *parse_comp_unit
251 PARAMS ((bfd *, struct dwarf2_debug *, bfd_vma, unsigned int));
252 static boolean comp_unit_contains_address
253 PARAMS ((struct comp_unit *, bfd_vma));
254 static boolean comp_unit_find_nearest_line
255 PARAMS ((struct comp_unit *, bfd_vma, const char **, const char **,
256 unsigned int *, struct dwarf2_debug *));
257 static asection *find_debug_info PARAMS ((bfd *, asection *));
260 The following function up to the END VERBATIM mark are
261 copied directly from dwarf2read.c. */
263 /* Read dwarf information from a buffer. */
266 read_1_byte (abfd, buf)
267 bfd *abfd ATTRIBUTE_UNUSED;
270 return bfd_get_8 (abfd, (bfd_byte *) buf);
274 read_1_signed_byte (abfd, buf)
275 bfd *abfd ATTRIBUTE_UNUSED;
278 return bfd_get_signed_8 (abfd, (bfd_byte *) buf);
282 read_2_bytes (abfd, buf)
286 return bfd_get_16 (abfd, (bfd_byte *) buf);
289 #if 0 /* This is not used. */
292 read_2_signed_bytes (abfd, buf)
296 return bfd_get_signed_16 (abfd, (bfd_byte *) buf);
302 read_4_bytes (abfd, buf)
306 return bfd_get_32 (abfd, (bfd_byte *) buf);
309 #if 0 /* This is not used. */
312 read_4_signed_bytes (abfd, buf)
316 return bfd_get_signed_32 (abfd, (bfd_byte *) buf);
322 read_8_bytes (abfd, buf)
326 return bfd_get_64 (abfd, (bfd_byte *) buf);
330 read_n_bytes (abfd, buf, size)
331 bfd *abfd ATTRIBUTE_UNUSED;
333 unsigned int size ATTRIBUTE_UNUSED;
335 /* If the size of a host char is 8 bits, we can return a pointer
336 to the buffer, otherwise we have to copy the data to a buffer
337 allocated on the temporary obstack. */
342 read_string (abfd, buf, bytes_read_ptr)
343 bfd *abfd ATTRIBUTE_UNUSED;
345 unsigned int *bytes_read_ptr;
347 /* Return a pointer to the embedded string. */
354 *bytes_read_ptr = strlen (buf) + 1;
359 read_indirect_string (unit, buf, bytes_read_ptr)
360 struct comp_unit* unit;
362 unsigned int *bytes_read_ptr;
365 struct dwarf2_debug *stash = unit->stash;
367 if (unit->offset_size == 4)
368 offset = read_4_bytes (unit->abfd, buf);
370 offset = read_8_bytes (unit->abfd, buf);
371 *bytes_read_ptr = unit->offset_size;
373 if (! stash->dwarf_str_buffer)
376 bfd *abfd = unit->abfd;
378 msec = bfd_get_section_by_name (abfd, ".debug_str");
381 (*_bfd_error_handler)
382 (_("Dwarf Error: Can't find .debug_str section."));
383 bfd_set_error (bfd_error_bad_value);
387 stash->dwarf_str_size = msec->_raw_size;
388 stash->dwarf_str_buffer = (char*) bfd_alloc (abfd, msec->_raw_size);
389 if (! stash->dwarf_abbrev_buffer)
392 if (! bfd_get_section_contents (abfd, msec, stash->dwarf_str_buffer,
393 (bfd_vma) 0, msec->_raw_size))
397 if (offset >= stash->dwarf_str_size)
399 (*_bfd_error_handler) (_("Dwarf Error: DW_FORM_strp offset (%lu) greater than or equal to .debug_str size (%lu)."),
400 (unsigned long) offset, stash->dwarf_str_size);
401 bfd_set_error (bfd_error_bad_value);
405 buf = stash->dwarf_str_buffer + offset;
412 read_unsigned_leb128 (abfd, buf, bytes_read_ptr)
413 bfd *abfd ATTRIBUTE_UNUSED;
415 unsigned int *bytes_read_ptr;
418 unsigned int num_read;
428 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
431 result |= ((byte & 0x7f) << shift);
436 * bytes_read_ptr = num_read;
442 read_signed_leb128 (abfd, buf, bytes_read_ptr)
443 bfd *abfd ATTRIBUTE_UNUSED;
445 unsigned int * bytes_read_ptr;
458 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
461 result |= ((byte & 0x7f) << shift);
466 if ((shift < 32) && (byte & 0x40))
467 result |= -(1 << shift);
469 * bytes_read_ptr = num_read;
477 read_address (unit, buf)
478 struct comp_unit* unit;
481 switch (unit->addr_size)
484 return bfd_get_64 (unit->abfd, (bfd_byte *) buf);
486 return bfd_get_32 (unit->abfd, (bfd_byte *) buf);
488 return bfd_get_16 (unit->abfd, (bfd_byte *) buf);
494 /* Lookup an abbrev_info structure in the abbrev hash table. */
496 static struct abbrev_info *
497 lookup_abbrev (number,abbrevs)
499 struct abbrev_info **abbrevs;
501 unsigned int hash_number;
502 struct abbrev_info *abbrev;
504 hash_number = number % ABBREV_HASH_SIZE;
505 abbrev = abbrevs[hash_number];
509 if (abbrev->number == number)
512 abbrev = abbrev->next;
518 /* In DWARF version 2, the description of the debugging information is
519 stored in a separate .debug_abbrev section. Before we read any
520 dies from a section we read in all abbreviations and install them
523 static struct abbrev_info**
524 read_abbrevs (abfd, offset, stash)
527 struct dwarf2_debug *stash;
529 struct abbrev_info **abbrevs;
531 struct abbrev_info *cur_abbrev;
532 unsigned int abbrev_number, bytes_read, abbrev_name;
533 unsigned int abbrev_form, hash_number;
536 if (! stash->dwarf_abbrev_buffer)
540 msec = bfd_get_section_by_name (abfd, ".debug_abbrev");
543 (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_abbrev section."));
544 bfd_set_error (bfd_error_bad_value);
548 stash->dwarf_abbrev_size = msec->_raw_size;
549 stash->dwarf_abbrev_buffer = (char*) bfd_alloc (abfd, msec->_raw_size);
550 if (! stash->dwarf_abbrev_buffer)
553 if (! bfd_get_section_contents (abfd, msec, stash->dwarf_abbrev_buffer,
554 (bfd_vma) 0, msec->_raw_size))
558 if (offset >= stash->dwarf_abbrev_size)
560 (*_bfd_error_handler) (_("Dwarf Error: Abbrev offset (%lu) greater than or equal to .debug_abbrev size (%lu)."),
561 (unsigned long) offset, stash->dwarf_abbrev_size);
562 bfd_set_error (bfd_error_bad_value);
566 amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
567 abbrevs = (struct abbrev_info**) bfd_zalloc (abfd, amt);
569 abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
570 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
571 abbrev_ptr += bytes_read;
573 /* Loop until we reach an abbrev number of 0. */
574 while (abbrev_number)
576 amt = sizeof (struct abbrev_info);
577 cur_abbrev = (struct abbrev_info *) bfd_zalloc (abfd, amt);
579 /* Read in abbrev header. */
580 cur_abbrev->number = abbrev_number;
581 cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
582 abbrev_ptr += bytes_read;
583 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
586 /* Now read in declarations. */
587 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
588 abbrev_ptr += bytes_read;
589 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
590 abbrev_ptr += bytes_read;
594 if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
596 amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
597 amt *= sizeof (struct attr_abbrev);
598 cur_abbrev->attrs = ((struct attr_abbrev *)
599 bfd_realloc (cur_abbrev->attrs, amt));
600 if (! cur_abbrev->attrs)
604 cur_abbrev->attrs[cur_abbrev->num_attrs].name = abbrev_name;
605 cur_abbrev->attrs[cur_abbrev->num_attrs++].form = abbrev_form;
606 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
607 abbrev_ptr += bytes_read;
608 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
609 abbrev_ptr += bytes_read;
612 hash_number = abbrev_number % ABBREV_HASH_SIZE;
613 cur_abbrev->next = abbrevs[hash_number];
614 abbrevs[hash_number] = cur_abbrev;
616 /* Get next abbreviation.
617 Under Irix6 the abbreviations for a compilation unit are not
618 always properly terminated with an abbrev number of 0.
619 Exit loop if we encounter an abbreviation which we have
620 already read (which means we are about to read the abbreviations
621 for the next compile unit) or if the end of the abbreviation
623 if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
624 >= stash->dwarf_abbrev_size)
626 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
627 abbrev_ptr += bytes_read;
628 if (lookup_abbrev (abbrev_number,abbrevs) != NULL)
635 /* Read an attribute value described by an attribute form. */
638 read_attribute_value (attr, form, unit, info_ptr)
639 struct attribute *attr;
641 struct comp_unit *unit;
644 bfd *abfd = unit->abfd;
645 unsigned int bytes_read;
646 struct dwarf_block *blk;
654 /* FIXME: DWARF3 draft sais DW_FORM_ref_addr is offset_size. */
655 case DW_FORM_ref_addr:
656 DW_ADDR (attr) = read_address (unit, info_ptr);
657 info_ptr += unit->addr_size;
660 amt = sizeof (struct dwarf_block);
661 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
662 blk->size = read_2_bytes (abfd, info_ptr);
664 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
665 info_ptr += blk->size;
666 DW_BLOCK (attr) = blk;
669 amt = sizeof (struct dwarf_block);
670 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
671 blk->size = read_4_bytes (abfd, info_ptr);
673 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
674 info_ptr += blk->size;
675 DW_BLOCK (attr) = blk;
678 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
682 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
686 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
690 DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read);
691 info_ptr += bytes_read;
694 DW_STRING (attr) = read_indirect_string (unit, info_ptr, &bytes_read);
695 info_ptr += bytes_read;
698 amt = sizeof (struct dwarf_block);
699 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
700 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
701 info_ptr += bytes_read;
702 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
703 info_ptr += blk->size;
704 DW_BLOCK (attr) = blk;
707 amt = sizeof (struct dwarf_block);
708 blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
709 blk->size = read_1_byte (abfd, info_ptr);
711 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
712 info_ptr += blk->size;
713 DW_BLOCK (attr) = blk;
716 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
720 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
724 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
725 info_ptr += bytes_read;
728 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
729 info_ptr += bytes_read;
732 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
736 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
740 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
744 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
747 case DW_FORM_ref_udata:
748 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
749 info_ptr += bytes_read;
751 case DW_FORM_indirect:
752 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
753 info_ptr += bytes_read;
754 info_ptr = read_attribute_value (attr, form, unit, info_ptr);
757 (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %u."),
759 bfd_set_error (bfd_error_bad_value);
764 /* Read an attribute described by an abbreviated attribute. */
767 read_attribute (attr, abbrev, unit, info_ptr)
768 struct attribute *attr;
769 struct attr_abbrev *abbrev;
770 struct comp_unit *unit;
773 attr->name = abbrev->name;
774 info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr);
778 /* Source line information table routines. */
780 #define FILE_ALLOC_CHUNK 5
781 #define DIR_ALLOC_CHUNK 5
785 struct line_info* prev_line;
790 int end_sequence; /* End of (sequential) code sequence. */
801 struct line_info_table
804 unsigned int num_files;
805 unsigned int num_dirs;
808 struct fileinfo* files;
809 struct line_info* last_line;
814 struct funcinfo *prev_func;
821 add_line_info (table, address, filename, line, column, end_sequence)
822 struct line_info_table* table;
829 bfd_size_type amt = sizeof (struct line_info);
830 struct line_info* info = (struct line_info*) bfd_alloc (table->abfd, amt);
832 info->prev_line = table->last_line;
833 table->last_line = info;
835 info->address = address;
836 info->filename = filename;
838 info->column = column;
839 info->end_sequence = end_sequence;
843 concat_filename (table, file)
844 struct line_info_table* table;
849 if (file - 1 >= table->num_files)
851 (*_bfd_error_handler)
852 (_("Dwarf Error: mangled line number section (bad file number)."));
856 filename = table->files[file - 1].name;
857 if (IS_ABSOLUTE_PATH(filename))
862 char* dirname = (table->files[file - 1].dir
863 ? table->dirs[table->files[file - 1].dir - 1]
865 return (char*) concat (dirname, "/", filename, NULL);
870 arange_add (unit, low_pc, high_pc)
871 struct comp_unit *unit;
875 struct arange *arange;
877 /* First see if we can cheaply extend an existing range. */
878 arange = &unit->arange;
882 if (low_pc == arange->high)
884 arange->high = high_pc;
887 if (high_pc == arange->low)
889 arange->low = low_pc;
892 arange = arange->next;
896 if (unit->arange.high == 0)
898 /* This is the first address range: store it in unit->arange. */
899 unit->arange.next = 0;
900 unit->arange.low = low_pc;
901 unit->arange.high = high_pc;
905 /* Need to allocate a new arange and insert it into the arange list. */
906 arange = bfd_zalloc (unit->abfd, (bfd_size_type) sizeof (*arange));
907 arange->low = low_pc;
908 arange->high = high_pc;
910 arange->next = unit->arange.next;
911 unit->arange.next = arange;
914 /* Decode the line number information for UNIT. */
916 static struct line_info_table*
917 decode_line_info (unit, stash)
918 struct comp_unit *unit;
919 struct dwarf2_debug *stash;
921 bfd *abfd = unit->abfd;
922 struct line_info_table* table;
926 unsigned int i, bytes_read, offset_size;
927 char *cur_file, *cur_dir;
928 unsigned char op_code, extended_op, adj_opcode;
931 if (! stash->dwarf_line_buffer)
935 msec = bfd_get_section_by_name (abfd, ".debug_line");
938 (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_line section."));
939 bfd_set_error (bfd_error_bad_value);
943 stash->dwarf_line_size = msec->_raw_size;
944 stash->dwarf_line_buffer = (char *) bfd_alloc (abfd, msec->_raw_size);
945 if (! stash->dwarf_line_buffer)
948 if (! bfd_get_section_contents (abfd, msec, stash->dwarf_line_buffer,
949 (bfd_vma) 0, msec->_raw_size))
952 /* FIXME: We ought to apply the relocs against this section before
956 /* Since we are using un-relocated data, it is possible to get a bad value
957 for the line_offset. Validate it here so that we won't get a segfault
959 if (unit->line_offset >= stash->dwarf_line_size)
961 (*_bfd_error_handler) (_("Dwarf Error: Line offset (%lu) greater than or equal to .debug_line size (%lu)."),
962 unit->line_offset, stash->dwarf_line_size);
963 bfd_set_error (bfd_error_bad_value);
967 amt = sizeof (struct line_info_table);
968 table = (struct line_info_table*) bfd_alloc (abfd, amt);
970 table->comp_dir = unit->comp_dir;
972 table->num_files = 0;
979 table->last_line = NULL;
981 line_ptr = stash->dwarf_line_buffer + unit->line_offset;
983 /* Read in the prologue. */
984 if (unit->addr_size == 4)
986 lh.total_length = read_4_bytes (abfd, line_ptr);
992 BFD_ASSERT (unit->addr_size == 8);
993 lh.total_length = read_8_bytes (abfd, line_ptr);
998 if (lh.total_length == 0xffffffff)
1000 lh.total_length = read_8_bytes (abfd, line_ptr);
1004 line_end = line_ptr + lh.total_length;
1005 lh.version = read_2_bytes (abfd, line_ptr);
1007 if (offset_size == 4)
1008 lh.prologue_length = read_4_bytes (abfd, line_ptr);
1010 lh.prologue_length = read_8_bytes (abfd, line_ptr);
1011 line_ptr += offset_size;
1012 lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
1014 lh.default_is_stmt = read_1_byte (abfd, line_ptr);
1016 lh.line_base = read_1_signed_byte (abfd, line_ptr);
1018 lh.line_range = read_1_byte (abfd, line_ptr);
1020 lh.opcode_base = read_1_byte (abfd, line_ptr);
1022 amt = lh.opcode_base * sizeof (unsigned char);
1023 lh.standard_opcode_lengths = (unsigned char *) bfd_alloc (abfd, amt);
1025 lh.standard_opcode_lengths[0] = 1;
1027 for (i = 1; i < lh.opcode_base; ++i)
1029 lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
1033 /* Read directory table. */
1034 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1036 line_ptr += bytes_read;
1038 if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
1040 amt = table->num_dirs + DIR_ALLOC_CHUNK;
1041 amt *= sizeof (char *);
1042 table->dirs = (char **) bfd_realloc (table->dirs, amt);
1047 table->dirs[table->num_dirs++] = cur_dir;
1050 line_ptr += bytes_read;
1052 /* Read file name table. */
1053 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1055 line_ptr += bytes_read;
1057 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1059 amt = table->num_files + FILE_ALLOC_CHUNK;
1060 amt *= sizeof (struct fileinfo);
1061 table->files = (struct fileinfo *) bfd_realloc (table->files, amt);
1066 table->files[table->num_files].name = cur_file;
1067 table->files[table->num_files].dir =
1068 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1069 line_ptr += bytes_read;
1070 table->files[table->num_files].time =
1071 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1072 line_ptr += bytes_read;
1073 table->files[table->num_files].size =
1074 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1075 line_ptr += bytes_read;
1079 line_ptr += bytes_read;
1081 /* Read the statement sequences until there's nothing left. */
1082 while (line_ptr < line_end)
1084 /* State machine registers. */
1085 bfd_vma address = 0;
1086 char* filename = concat_filename (table, 1);
1087 unsigned int line = 1;
1088 unsigned int column = 0;
1089 int is_stmt = lh.default_is_stmt;
1090 int basic_block = 0;
1091 int end_sequence = 0, need_low_pc = 1;
1094 /* Decode the table. */
1095 while (! end_sequence)
1097 op_code = read_1_byte (abfd, line_ptr);
1100 if (op_code >= lh.opcode_base)
1101 { /* Special operand. */
1102 adj_opcode = op_code - lh.opcode_base;
1103 address += (adj_opcode / lh.line_range)
1104 * lh.minimum_instruction_length;
1105 line += lh.line_base + (adj_opcode % lh.line_range);
1106 /* Append row to matrix using current values. */
1107 add_line_info (table, address, filename, line, column, 0);
1115 else switch (op_code)
1117 case DW_LNS_extended_op:
1118 line_ptr += 1; /* Ignore length. */
1119 extended_op = read_1_byte (abfd, line_ptr);
1121 switch (extended_op)
1123 case DW_LNE_end_sequence:
1125 add_line_info (table, address, filename, line, column,
1132 arange_add (unit, low_pc, address);
1134 case DW_LNE_set_address:
1135 address = read_address (unit, line_ptr);
1136 line_ptr += unit->addr_size;
1138 case DW_LNE_define_file:
1139 cur_file = read_string (abfd, line_ptr, &bytes_read);
1140 line_ptr += bytes_read;
1141 if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1143 amt = table->num_files + FILE_ALLOC_CHUNK;
1144 amt *= sizeof (struct fileinfo);
1146 (struct fileinfo *) bfd_realloc (table->files, amt);
1150 table->files[table->num_files].name = cur_file;
1151 table->files[table->num_files].dir =
1152 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1153 line_ptr += bytes_read;
1154 table->files[table->num_files].time =
1155 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1156 line_ptr += bytes_read;
1157 table->files[table->num_files].size =
1158 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1159 line_ptr += bytes_read;
1163 (*_bfd_error_handler) (_("Dwarf Error: mangled line number section."));
1164 bfd_set_error (bfd_error_bad_value);
1169 add_line_info (table, address, filename, line, column, 0);
1177 case DW_LNS_advance_pc:
1178 address += lh.minimum_instruction_length
1179 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1180 line_ptr += bytes_read;
1182 case DW_LNS_advance_line:
1183 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
1184 line_ptr += bytes_read;
1186 case DW_LNS_set_file:
1190 /* The file and directory tables are 0 based, the references
1192 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1193 line_ptr += bytes_read;
1194 filename = concat_filename (table, file);
1197 case DW_LNS_set_column:
1198 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1199 line_ptr += bytes_read;
1201 case DW_LNS_negate_stmt:
1202 is_stmt = (!is_stmt);
1204 case DW_LNS_set_basic_block:
1207 case DW_LNS_const_add_pc:
1208 address += lh.minimum_instruction_length
1209 * ((255 - lh.opcode_base) / lh.line_range);
1211 case DW_LNS_fixed_advance_pc:
1212 address += read_2_bytes (abfd, line_ptr);
1216 { /* Unknown standard opcode, ignore it. */
1218 for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
1220 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1221 line_ptr += bytes_read;
1231 /* If ADDR is within TABLE set the output parameters and return true,
1232 otherwise return false. The output parameters, FILENAME_PTR and
1233 LINENUMBER_PTR, are pointers to the objects to be filled in. */
1236 lookup_address_in_line_info_table (table,
1241 struct line_info_table* table;
1243 struct funcinfo *function;
1244 const char **filename_ptr;
1245 unsigned int *linenumber_ptr;
1247 struct line_info* next_line = table->last_line;
1248 struct line_info* each_line;
1253 each_line = next_line->prev_line;
1255 while (each_line && next_line)
1257 if (!each_line->end_sequence
1258 && addr >= each_line->address && addr < next_line->address)
1260 /* If this line appears to span functions, and addr is in the
1261 later function, return the first line of that function instead
1262 of the last line of the earlier one. This check is for GCC
1263 2.95, which emits the first line number for a function late. */
1264 if (function != NULL
1265 && each_line->address < function->low
1266 && next_line->address > function->low)
1268 *filename_ptr = next_line->filename;
1269 *linenumber_ptr = next_line->line;
1273 *filename_ptr = each_line->filename;
1274 *linenumber_ptr = each_line->line;
1278 next_line = each_line;
1279 each_line = each_line->prev_line;
1282 /* At this point each_line is NULL but next_line is not. If we found the
1283 containing function in this compilation unit, return the first line we
1284 have a number for. This is also for compatibility with GCC 2.95. */
1285 if (function != NULL)
1287 *filename_ptr = next_line->filename;
1288 *linenumber_ptr = next_line->line;
1295 /* Function table functions. */
1297 /* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return true. */
1300 lookup_address_in_function_table (table,
1304 struct funcinfo* table;
1306 struct funcinfo** function_ptr;
1307 const char **functionname_ptr;
1309 struct funcinfo* each_func;
1311 for (each_func = table;
1313 each_func = each_func->prev_func)
1315 if (addr >= each_func->low && addr < each_func->high)
1317 *functionname_ptr = each_func->name;
1318 *function_ptr = each_func;
1326 /* DWARF2 Compilation unit functions. */
1328 /* Scan over each die in a comp. unit looking for functions to add
1329 to the function table. */
1332 scan_unit_for_functions (unit)
1333 struct comp_unit *unit;
1335 bfd *abfd = unit->abfd;
1336 char *info_ptr = unit->first_child_die_ptr;
1337 int nesting_level = 1;
1339 while (nesting_level)
1341 unsigned int abbrev_number, bytes_read, i;
1342 struct abbrev_info *abbrev;
1343 struct attribute attr;
1344 struct funcinfo *func;
1347 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1348 info_ptr += bytes_read;
1350 if (! abbrev_number)
1356 abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
1359 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1361 bfd_set_error (bfd_error_bad_value);
1365 if (abbrev->tag == DW_TAG_subprogram)
1367 bfd_size_type amt = sizeof (struct funcinfo);
1368 func = (struct funcinfo *) bfd_zalloc (abfd, amt);
1369 func->prev_func = unit->function_table;
1370 unit->function_table = func;
1375 for (i = 0; i < abbrev->num_attrs; ++i)
1377 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1385 name = DW_STRING (&attr);
1387 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
1388 if (func->name == NULL)
1389 func->name = DW_STRING (&attr);
1392 case DW_AT_MIPS_linkage_name:
1393 func->name = DW_STRING (&attr);
1397 func->low = DW_ADDR (&attr);
1401 func->high = DW_ADDR (&attr);
1413 name = DW_STRING (&attr);
1422 if (abbrev->has_children)
1429 /* Look for a RELA relocation to be applied on OFFSET of section SEC,
1430 and return the addend if such a relocation is found. Since this is
1431 only used to find relocations referring to the .debug_abbrev
1432 section, we make sure the relocation refers to this section, but
1433 this is not strictly necessary, and it can probably be safely
1434 removed if needed. However, it is important to note that this
1435 function only returns the addend, it doesn't serve the purpose of
1436 applying a generic relocation.
1438 If no suitable relocation is found, or if it is not a real RELA
1439 relocation, this function returns 0. */
1442 find_rela_addend (abfd, sec, offset, syms)
1445 bfd_size_type offset;
1448 long reloc_size = bfd_get_reloc_upper_bound (abfd, sec);
1449 arelent **relocs = NULL;
1450 long reloc_count, relc;
1452 if (reloc_size <= 0)
1455 relocs = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
1459 reloc_count = bfd_canonicalize_reloc (abfd, sec, relocs, syms);
1461 if (reloc_count <= 0)
1467 for (relc = 0; relc < reloc_count; relc++)
1468 if (relocs[relc]->address == offset
1469 && (*relocs[relc]->sym_ptr_ptr)->flags & BSF_SECTION_SYM
1470 && strcmp ((*relocs[relc]->sym_ptr_ptr)->name,
1471 ".debug_abbrev") == 0)
1473 bfd_vma addend = (relocs[relc]->howto->partial_inplace
1474 ? 0 : relocs[relc]->addend);
1483 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
1484 includes the compilation unit header that proceeds the DIE's, but
1485 does not include the length field that preceeds each compilation
1486 unit header. END_PTR points one past the end of this comp unit.
1487 OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
1489 This routine does not read the whole compilation unit; only enough
1490 to get to the line number information for the compilation unit. */
1492 static struct comp_unit *
1493 parse_comp_unit (abfd, stash, unit_length, offset_size)
1495 struct dwarf2_debug *stash;
1496 bfd_vma unit_length;
1497 unsigned int offset_size;
1499 struct comp_unit* unit;
1500 unsigned int version;
1501 bfd_vma abbrev_offset = 0;
1502 unsigned int addr_size;
1503 struct abbrev_info** abbrevs;
1504 unsigned int abbrev_number, bytes_read, i;
1505 struct abbrev_info *abbrev;
1506 struct attribute attr;
1507 char *info_ptr = stash->info_ptr;
1508 char *end_ptr = info_ptr + unit_length;
1512 version = read_2_bytes (abfd, info_ptr);
1514 BFD_ASSERT (offset_size == 4 || offset_size == 8);
1515 if (offset_size == 4)
1516 abbrev_offset = read_4_bytes (abfd, info_ptr);
1518 abbrev_offset = read_8_bytes (abfd, info_ptr);
1519 /* The abbrev offset is generally a relocation pointing to
1520 .debug_abbrev+offset. On RELA targets, we have to find the
1521 relocation and extract the addend to obtain the actual
1522 abbrev_offset, so do it here. */
1523 off = info_ptr - stash->sec_info_ptr;
1524 abbrev_offset += find_rela_addend (abfd, stash->sec, off, stash->syms);
1525 info_ptr += offset_size;
1526 addr_size = read_1_byte (abfd, info_ptr);
1531 (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 information."), version);
1532 bfd_set_error (bfd_error_bad_value);
1536 if (addr_size > sizeof (bfd_vma))
1538 (*_bfd_error_handler) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
1540 (unsigned int) sizeof (bfd_vma));
1541 bfd_set_error (bfd_error_bad_value);
1545 if (addr_size != 2 && addr_size != 4 && addr_size != 8)
1547 (*_bfd_error_handler) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size);
1548 bfd_set_error (bfd_error_bad_value);
1552 /* Read the abbrevs for this compilation unit into a table. */
1553 abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
1557 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1558 info_ptr += bytes_read;
1559 if (! abbrev_number)
1561 (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u."),
1563 bfd_set_error (bfd_error_bad_value);
1567 abbrev = lookup_abbrev (abbrev_number, abbrevs);
1570 (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1572 bfd_set_error (bfd_error_bad_value);
1576 amt = sizeof (struct comp_unit);
1577 unit = (struct comp_unit*) bfd_zalloc (abfd, amt);
1579 unit->addr_size = addr_size;
1580 unit->offset_size = offset_size;
1581 unit->abbrevs = abbrevs;
1582 unit->end_ptr = end_ptr;
1583 unit->stash = stash;
1585 for (i = 0; i < abbrev->num_attrs; ++i)
1587 info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1589 /* Store the data if it is of an attribute we want to keep in a
1590 partial symbol table. */
1593 case DW_AT_stmt_list:
1595 unit->line_offset = DW_UNSND (&attr);
1599 unit->name = DW_STRING (&attr);
1603 unit->arange.low = DW_ADDR (&attr);
1607 unit->arange.high = DW_ADDR (&attr);
1610 case DW_AT_comp_dir:
1612 char* comp_dir = DW_STRING (&attr);
1615 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1616 directory, get rid of it. */
1617 char *cp = (char*) strchr (comp_dir, ':');
1619 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
1622 unit->comp_dir = comp_dir;
1631 unit->first_child_die_ptr = info_ptr;
1635 /* Return true if UNIT contains the address given by ADDR. */
1638 comp_unit_contains_address (unit, addr)
1639 struct comp_unit* unit;
1642 struct arange *arange;
1647 arange = &unit->arange;
1650 if (addr >= arange->low && addr < arange->high)
1652 arange = arange->next;
1659 /* If UNIT contains ADDR, set the output parameters to the values for
1660 the line containing ADDR. The output parameters, FILENAME_PTR,
1661 FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
1664 Return true of UNIT contains ADDR, and no errors were encountered;
1668 comp_unit_find_nearest_line (unit, addr,
1669 filename_ptr, functionname_ptr, linenumber_ptr,
1671 struct comp_unit* unit;
1673 const char **filename_ptr;
1674 const char **functionname_ptr;
1675 unsigned int *linenumber_ptr;
1676 struct dwarf2_debug *stash;
1680 struct funcinfo *function;
1685 if (! unit->line_table)
1687 if (! unit->stmtlist)
1693 unit->line_table = decode_line_info (unit, stash);
1695 if (! unit->line_table)
1701 if (unit->first_child_die_ptr < unit->end_ptr
1702 && ! scan_unit_for_functions (unit))
1710 func_p = lookup_address_in_function_table (unit->function_table,
1714 line_p = lookup_address_in_line_info_table (unit->line_table,
1719 return line_p || func_p;
1722 /* Locate a section in a BFD containing debugging info. The search starts from the
1723 section after AFTER_SEC, or from the first section in the BFD if AFTER_SEC is
1724 NULL. The search works by examining the names of the sections. There are two
1725 permissiable names. The first is .debug_info. This is the standard DWARF2 name.
1726 The second is a prefix .gnu.linkonce.wi. This is a variation on the .debug_info
1727 section which has a checksum describing the contents appended onto the name. This
1728 allows the linker to identify and discard duplicate debugging sections for
1729 different compilation units. */
1730 #define DWARF2_DEBUG_INFO ".debug_info"
1731 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
1734 find_debug_info (abfd, after_sec)
1736 asection * after_sec;
1741 msec = after_sec->next;
1743 msec = abfd->sections;
1747 if (strcmp (msec->name, DWARF2_DEBUG_INFO) == 0)
1750 if (strncmp (msec->name, GNU_LINKONCE_INFO, strlen (GNU_LINKONCE_INFO)) == 0)
1759 /* The DWARF2 version of find_nearest line. Return true if the line
1760 is found without error. ADDR_SIZE is the number of bytes in the
1761 initial .debug_info length field and in the abbreviation offset.
1762 You may use zero to indicate that the default value should be
1766 _bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
1767 filename_ptr, functionname_ptr,
1774 const char **filename_ptr;
1775 const char **functionname_ptr;
1776 unsigned int *linenumber_ptr;
1777 unsigned int addr_size;
1780 /* Read each compilation unit from the section .debug_info, and check
1781 to see if it contains the address we are searching for. If yes,
1782 lookup the address, and return the line number info. If no, go
1783 on to the next compilation unit.
1785 We keep a list of all the previously read compilation units, and
1786 a pointer to the next un-read compilation unit. Check the
1787 previously read units before reading more. */
1788 struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
1790 /* What address are we looking for? */
1791 bfd_vma addr = offset + section->vma;
1793 struct comp_unit* each;
1795 *filename_ptr = NULL;
1796 *functionname_ptr = NULL;
1797 *linenumber_ptr = 0;
1799 /* The DWARF2 spec says that the initial length field, and the
1800 offset of the abbreviation table, should both be 4-byte values.
1801 However, some compilers do things differently. */
1804 BFD_ASSERT (addr_size == 4 || addr_size == 8);
1808 bfd_size_type total_size;
1810 bfd_size_type amt = sizeof (struct dwarf2_debug);
1812 stash = (struct dwarf2_debug*) bfd_zalloc (abfd, amt);
1816 *pinfo = (PTR) stash;
1818 msec = find_debug_info (abfd, NULL);
1820 /* No dwarf2 info. Note that at this point the stash
1821 has been allocated, but contains zeros, this lets
1822 future calls to this function fail quicker. */
1825 /* There can be more than one DWARF2 info section in a BFD these days.
1826 Read them all in and produce one large stash. We do this in two
1827 passes - in the first pass we just accumulate the section sizes.
1828 In the second pass we read in the section's contents. The allows
1829 us to avoid reallocing the data as we add sections to the stash. */
1830 for (total_size = 0; msec; msec = find_debug_info (abfd, msec))
1831 total_size += msec->_raw_size;
1833 stash->info_ptr = (char *) bfd_alloc (abfd, total_size);
1834 if (stash->info_ptr == NULL)
1837 stash->info_ptr_end = stash->info_ptr;
1839 for (msec = find_debug_info (abfd, NULL);
1841 msec = find_debug_info (abfd, msec))
1844 bfd_size_type start;
1846 size = msec->_raw_size;
1850 start = stash->info_ptr_end - stash->info_ptr;
1852 if (! bfd_get_section_contents (abfd, msec, stash->info_ptr + start,
1856 stash->info_ptr_end = stash->info_ptr + start + size;
1859 BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size);
1861 stash->sec = find_debug_info (abfd, NULL);
1862 stash->sec_info_ptr = stash->info_ptr;
1863 stash->syms = symbols;
1866 /* FIXME: There is a problem with the contents of the
1867 .debug_info section. The 'low' and 'high' addresses of the
1868 comp_units are computed by relocs against symbols in the
1869 .text segment. We need these addresses in order to determine
1870 the nearest line number, and so we have to resolve the
1871 relocs. There is a similar problem when the .debug_line
1872 section is processed as well (e.g., there may be relocs
1873 against the operand of the DW_LNE_set_address operator).
1875 Unfortunately getting hold of the reloc information is hard...
1877 For now, this means that disassembling object files (as
1878 opposed to fully executables) does not always work as well as
1881 /* A null info_ptr indicates that there is no dwarf2 info
1882 (or that an error occured while setting up the stash). */
1883 if (! stash->info_ptr)
1886 /* Check the previously read comp. units first. */
1887 for (each = stash->all_comp_units; each; each = each->next_unit)
1888 if (comp_unit_contains_address (each, addr))
1889 return comp_unit_find_nearest_line (each, addr, filename_ptr,
1890 functionname_ptr, linenumber_ptr,
1893 /* Read each remaining comp. units checking each as they are read. */
1894 while (stash->info_ptr < stash->info_ptr_end)
1898 unsigned int offset_size = addr_size;
1902 length = read_4_bytes (abfd, stash->info_ptr);
1903 if (length == 0xffffffff)
1906 length = read_8_bytes (abfd, stash->info_ptr + 4);
1907 stash->info_ptr += 8;
1911 length = read_8_bytes (abfd, stash->info_ptr);
1912 stash->info_ptr += addr_size;
1916 each = parse_comp_unit (abfd, stash, length, offset_size);
1917 stash->info_ptr += length;
1919 if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
1920 == stash->sec->_raw_size)
1922 stash->sec = find_debug_info (abfd, stash->sec);
1923 stash->sec_info_ptr = stash->info_ptr;
1928 each->next_unit = stash->all_comp_units;
1929 stash->all_comp_units = each;
1931 /* DW_AT_low_pc and DW_AT_high_pc are optional for
1932 compilation units. If we don't have them (i.e.,
1933 unit->high == 0), we need to consult the line info
1934 table to see if a compilation unit contains the given
1936 if (each->arange.high > 0)
1938 if (comp_unit_contains_address (each, addr))
1939 return comp_unit_find_nearest_line (each, addr,
1947 found = comp_unit_find_nearest_line (each, addr,