2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
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. */
43 unsigned int total_length
;
44 unsigned short version
;
45 unsigned int 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
;
127 /* A minimal decoding of DWARF2 compilation units. We only decode
128 what's needed to get to the line number information. */
132 /* Chain the previously read compilation units. */
133 struct comp_unit
* next_unit
;
135 /* Keep the bdf convenient (for memory allocation). */
138 /* The lowest and higest addresses contained in this compilation
139 unit as specified in the compilation unit header. */
140 struct arange arange
;
142 /* The DW_AT_name attribute (for error messages). */
145 /* The abbrev hash table. */
146 struct abbrev_info
** abbrevs
;
148 /* Note that an error was found by comp_unit_find_nearest_line. */
151 /* The DW_AT_comp_dir attribute. */
154 /* True if there is a line number table associated with this comp. unit. */
157 /* The offset into .debug_line of the line number table. */
158 unsigned long line_offset
;
160 /* Pointer to the first child die for the comp unit. */
161 char *first_child_die_ptr
;
163 /* The end of the comp unit. */
166 /* The decoded line number, NULL if not yet decoded. */
167 struct line_info_table
* line_table
;
169 /* A list of the functions found in this comp. unit. */
170 struct funcinfo
* function_table
;
172 /* Address size for this unit - from unit header. */
173 unsigned char addr_size
;
176 /* This data structure holds the information of an abbrev. */
179 unsigned int number
; /* Number identifying abbrev. */
180 enum dwarf_tag tag
; /* DWARF tag. */
181 int has_children
; /* Boolean. */
182 unsigned int num_attrs
; /* Number of attributes. */
183 struct attr_abbrev
*attrs
; /* An array of attribute descriptions. */
184 struct abbrev_info
*next
; /* Next in chain. */
189 enum dwarf_attribute name
;
190 enum dwarf_form form
;
193 #ifndef ABBREV_HASH_SIZE
194 #define ABBREV_HASH_SIZE 121
196 #ifndef ATTR_ALLOC_CHUNK
197 #define ATTR_ALLOC_CHUNK 4
200 static unsigned int read_1_byte
PARAMS ((bfd
*, char *));
201 static int read_1_signed_byte
PARAMS ((bfd
*, char *));
202 static unsigned int read_2_bytes
PARAMS ((bfd
*, char *));
203 static unsigned int read_4_bytes
PARAMS ((bfd
*, char *));
204 static unsigned int read_8_bytes
PARAMS ((bfd
*, char *));
205 static char *read_n_bytes
PARAMS ((bfd
*, char *, unsigned int));
206 static char *read_string
PARAMS ((bfd
*, char *, unsigned int *));
207 static unsigned int read_unsigned_leb128
208 PARAMS ((bfd
*, char *, unsigned int *));
209 static int read_signed_leb128
210 PARAMS ((bfd
*, char *, unsigned int *));
211 static bfd_vma read_address
PARAMS ((struct comp_unit
*, char *));
212 static struct abbrev_info
*lookup_abbrev
213 PARAMS ((unsigned int, struct abbrev_info
**));
214 static struct abbrev_info
**read_abbrevs
215 PARAMS ((bfd
*, unsigned int, struct dwarf2_debug
*));
216 static char *read_attribute
217 PARAMS ((struct attribute
*, struct attr_abbrev
*,
218 struct comp_unit
*, char *));
219 static void add_line_info
220 PARAMS ((struct line_info_table
*, bfd_vma
, char *,
221 unsigned int, unsigned int, int));
222 static char *concat_filename
PARAMS ((struct line_info_table
*, unsigned int));
223 static void arange_add
PARAMS ((struct comp_unit
*, bfd_vma
, bfd_vma
));
224 static struct line_info_table
*decode_line_info
225 PARAMS ((struct comp_unit
*, struct dwarf2_debug
*));
226 static boolean lookup_address_in_line_info_table
227 PARAMS ((struct line_info_table
*, bfd_vma
, const char **, unsigned int *));
228 static boolean lookup_address_in_function_table
229 PARAMS ((struct funcinfo
*, bfd_vma
, const char **));
230 static boolean scan_unit_for_functions
PARAMS ((struct comp_unit
*));
231 static bfd_vma find_rela_addend
232 PARAMS ((bfd
*, asection
*, bfd_size_type
, asymbol
**));
233 static struct comp_unit
*parse_comp_unit
234 PARAMS ((bfd
*, struct dwarf2_debug
*, bfd_vma
, unsigned int));
235 static boolean comp_unit_contains_address
236 PARAMS ((struct comp_unit
*, bfd_vma
));
237 static boolean comp_unit_find_nearest_line
238 PARAMS ((struct comp_unit
*, bfd_vma
, const char **, const char **,
239 unsigned int *, struct dwarf2_debug
*));
240 static asection
*find_debug_info
PARAMS ((bfd
*, asection
*));
243 The following function up to the END VERBATIM mark are
244 copied directly from dwarf2read.c. */
246 /* Read dwarf information from a buffer. */
249 read_1_byte (abfd
, buf
)
250 bfd
*abfd ATTRIBUTE_UNUSED
;
253 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
257 read_1_signed_byte (abfd
, buf
)
258 bfd
*abfd ATTRIBUTE_UNUSED
;
261 return bfd_get_signed_8 (abfd
, (bfd_byte
*) buf
);
265 read_2_bytes (abfd
, buf
)
269 return bfd_get_16 (abfd
, (bfd_byte
*) buf
);
272 #if 0 /* This is not used. */
275 read_2_signed_bytes (abfd
, buf
)
279 return bfd_get_signed_16 (abfd
, (bfd_byte
*) buf
);
285 read_4_bytes (abfd
, buf
)
289 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
292 #if 0 /* This is not used. */
295 read_4_signed_bytes (abfd
, buf
)
299 return bfd_get_signed_32 (abfd
, (bfd_byte
*) buf
);
305 read_8_bytes (abfd
, buf
)
309 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
313 read_n_bytes (abfd
, buf
, size
)
314 bfd
*abfd ATTRIBUTE_UNUSED
;
316 unsigned int size ATTRIBUTE_UNUSED
;
318 /* If the size of a host char is 8 bits, we can return a pointer
319 to the buffer, otherwise we have to copy the data to a buffer
320 allocated on the temporary obstack. */
325 read_string (abfd
, buf
, bytes_read_ptr
)
326 bfd
*abfd ATTRIBUTE_UNUSED
;
328 unsigned int *bytes_read_ptr
;
330 /* If the size of a host char is 8 bits, we can return a pointer
331 to the string, otherwise we have to copy the string to a buffer
332 allocated on the temporary obstack. */
339 *bytes_read_ptr
= strlen (buf
) + 1;
344 read_unsigned_leb128 (abfd
, buf
, bytes_read_ptr
)
345 bfd
*abfd ATTRIBUTE_UNUSED
;
347 unsigned int *bytes_read_ptr
;
350 unsigned int num_read
;
360 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
363 result
|= ((byte
& 0x7f) << shift
);
368 * bytes_read_ptr
= num_read
;
374 read_signed_leb128 (abfd
, buf
, bytes_read_ptr
)
375 bfd
*abfd ATTRIBUTE_UNUSED
;
377 unsigned int * bytes_read_ptr
;
390 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
393 result
|= ((byte
& 0x7f) << shift
);
398 if ((shift
< 32) && (byte
& 0x40))
399 result
|= -(1 << shift
);
401 * bytes_read_ptr
= num_read
;
409 read_address (unit
, buf
)
410 struct comp_unit
* unit
;
413 switch (unit
->addr_size
)
416 return bfd_get_64 (unit
->abfd
, (bfd_byte
*) buf
);
418 return bfd_get_32 (unit
->abfd
, (bfd_byte
*) buf
);
420 return bfd_get_16 (unit
->abfd
, (bfd_byte
*) buf
);
426 /* Lookup an abbrev_info structure in the abbrev hash table. */
428 static struct abbrev_info
*
429 lookup_abbrev (number
,abbrevs
)
431 struct abbrev_info
**abbrevs
;
433 unsigned int hash_number
;
434 struct abbrev_info
*abbrev
;
436 hash_number
= number
% ABBREV_HASH_SIZE
;
437 abbrev
= abbrevs
[hash_number
];
441 if (abbrev
->number
== number
)
444 abbrev
= abbrev
->next
;
450 /* In DWARF version 2, the description of the debugging information is
451 stored in a separate .debug_abbrev section. Before we read any
452 dies from a section we read in all abbreviations and install them
455 static struct abbrev_info
**
456 read_abbrevs (abfd
, offset
, stash
)
459 struct dwarf2_debug
*stash
;
461 struct abbrev_info
**abbrevs
;
463 struct abbrev_info
*cur_abbrev
;
464 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
465 unsigned int abbrev_form
, hash_number
;
468 if (! stash
->dwarf_abbrev_buffer
)
472 msec
= bfd_get_section_by_name (abfd
, ".debug_abbrev");
475 (*_bfd_error_handler
) (_("Dwarf Error: Can't find .debug_abbrev section."));
476 bfd_set_error (bfd_error_bad_value
);
480 stash
->dwarf_abbrev_size
= msec
->_raw_size
;
481 stash
->dwarf_abbrev_buffer
= (char*) bfd_alloc (abfd
, msec
->_raw_size
);
482 if (! stash
->dwarf_abbrev_buffer
)
485 if (! bfd_get_section_contents (abfd
, msec
, stash
->dwarf_abbrev_buffer
,
486 (bfd_vma
) 0, msec
->_raw_size
))
490 if (offset
>= stash
->dwarf_abbrev_size
)
492 (*_bfd_error_handler
) (_("Dwarf Error: Abbrev offset (%u) greater than or equal to abbrev size (%u)."),
493 offset
, stash
->dwarf_abbrev_size
);
494 bfd_set_error (bfd_error_bad_value
);
498 amt
= sizeof (struct abbrev_info
*) * ABBREV_HASH_SIZE
;
499 abbrevs
= (struct abbrev_info
**) bfd_zalloc (abfd
, amt
);
501 abbrev_ptr
= stash
->dwarf_abbrev_buffer
+ offset
;
502 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
503 abbrev_ptr
+= bytes_read
;
505 /* Loop until we reach an abbrev number of 0. */
506 while (abbrev_number
)
508 amt
= sizeof (struct abbrev_info
);
509 cur_abbrev
= (struct abbrev_info
*) bfd_zalloc (abfd
, amt
);
511 /* Read in abbrev header. */
512 cur_abbrev
->number
= abbrev_number
;
513 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
514 abbrev_ptr
+= bytes_read
;
515 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
518 /* Now read in declarations. */
519 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
520 abbrev_ptr
+= bytes_read
;
521 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
522 abbrev_ptr
+= bytes_read
;
526 if ((cur_abbrev
->num_attrs
% ATTR_ALLOC_CHUNK
) == 0)
528 amt
= cur_abbrev
->num_attrs
+ ATTR_ALLOC_CHUNK
;
529 amt
*= sizeof (struct attr_abbrev
);
530 cur_abbrev
->attrs
= ((struct attr_abbrev
*)
531 bfd_realloc (cur_abbrev
->attrs
, amt
));
532 if (! cur_abbrev
->attrs
)
536 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
537 cur_abbrev
->attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
538 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
539 abbrev_ptr
+= bytes_read
;
540 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
541 abbrev_ptr
+= bytes_read
;
544 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
545 cur_abbrev
->next
= abbrevs
[hash_number
];
546 abbrevs
[hash_number
] = cur_abbrev
;
548 /* Get next abbreviation.
549 Under Irix6 the abbreviations for a compilation unit are not
550 always properly terminated with an abbrev number of 0.
551 Exit loop if we encounter an abbreviation which we have
552 already read (which means we are about to read the abbreviations
553 for the next compile unit) or if the end of the abbreviation
555 if ((unsigned int) (abbrev_ptr
- stash
->dwarf_abbrev_buffer
)
556 >= stash
->dwarf_abbrev_size
)
558 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
559 abbrev_ptr
+= bytes_read
;
560 if (lookup_abbrev (abbrev_number
,abbrevs
) != NULL
)
567 /* Read an attribute described by an abbreviated attribute. */
570 read_attribute (attr
, abbrev
, unit
, info_ptr
)
571 struct attribute
*attr
;
572 struct attr_abbrev
*abbrev
;
573 struct comp_unit
*unit
;
576 bfd
*abfd
= unit
->abfd
;
577 unsigned int bytes_read
;
578 struct dwarf_block
*blk
;
581 attr
->name
= abbrev
->name
;
582 attr
->form
= abbrev
->form
;
584 switch (abbrev
->form
)
587 case DW_FORM_ref_addr
:
588 DW_ADDR (attr
) = read_address (unit
, info_ptr
);
589 info_ptr
+= unit
->addr_size
;
592 amt
= sizeof (struct dwarf_block
);
593 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
594 blk
->size
= read_2_bytes (abfd
, info_ptr
);
596 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
597 info_ptr
+= blk
->size
;
598 DW_BLOCK (attr
) = blk
;
601 amt
= sizeof (struct dwarf_block
);
602 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
603 blk
->size
= read_4_bytes (abfd
, info_ptr
);
605 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
606 info_ptr
+= blk
->size
;
607 DW_BLOCK (attr
) = blk
;
610 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
614 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
618 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
622 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
623 info_ptr
+= bytes_read
;
626 amt
= sizeof (struct dwarf_block
);
627 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
628 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
629 info_ptr
+= bytes_read
;
630 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
631 info_ptr
+= blk
->size
;
632 DW_BLOCK (attr
) = blk
;
635 amt
= sizeof (struct dwarf_block
);
636 blk
= (struct dwarf_block
*) bfd_alloc (abfd
, amt
);
637 blk
->size
= read_1_byte (abfd
, info_ptr
);
639 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
640 info_ptr
+= blk
->size
;
641 DW_BLOCK (attr
) = blk
;
644 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
648 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
652 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
653 info_ptr
+= bytes_read
;
656 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
657 info_ptr
+= bytes_read
;
660 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
664 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
668 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
672 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
675 case DW_FORM_ref_udata
:
676 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
677 info_ptr
+= bytes_read
;
680 case DW_FORM_indirect
:
682 (*_bfd_error_handler
) (_("Dwarf Error: Invalid or unhandled FORM value: %d."),
684 bfd_set_error (bfd_error_bad_value
);
689 /* Source line information table routines. */
691 #define FILE_ALLOC_CHUNK 5
692 #define DIR_ALLOC_CHUNK 5
696 struct line_info
* prev_line
;
701 int end_sequence
; /* End of (sequential) code sequence. */
712 struct line_info_table
715 unsigned int num_files
;
716 unsigned int num_dirs
;
719 struct fileinfo
* files
;
720 struct line_info
* last_line
;
724 add_line_info (table
, address
, filename
, line
, column
, end_sequence
)
725 struct line_info_table
* table
;
732 bfd_size_type amt
= sizeof (struct line_info
);
733 struct line_info
* info
= (struct line_info
*) bfd_alloc (table
->abfd
, amt
);
735 info
->prev_line
= table
->last_line
;
736 table
->last_line
= info
;
738 info
->address
= address
;
739 info
->filename
= filename
;
741 info
->column
= column
;
742 info
->end_sequence
= end_sequence
;
746 concat_filename (table
, file
)
747 struct line_info_table
* table
;
752 if (file
- 1 >= table
->num_files
)
754 (*_bfd_error_handler
)
755 (_("Dwarf Error: mangled line number section (bad file number)."));
759 filename
= table
->files
[file
- 1].name
;
760 if (IS_ABSOLUTE_PATH(filename
))
765 char* dirname
= (table
->files
[file
- 1].dir
766 ? table
->dirs
[table
->files
[file
- 1].dir
- 1]
768 return (char*) concat (dirname
, "/", filename
, NULL
);
773 arange_add (unit
, low_pc
, high_pc
)
774 struct comp_unit
*unit
;
778 struct arange
*arange
;
780 /* First see if we can cheaply extend an existing range. */
781 arange
= &unit
->arange
;
785 if (low_pc
== arange
->high
)
787 arange
->high
= high_pc
;
790 if (high_pc
== arange
->low
)
792 arange
->low
= low_pc
;
795 arange
= arange
->next
;
799 if (unit
->arange
.high
== 0)
801 /* This is the first address range: store it in unit->arange. */
802 unit
->arange
.next
= 0;
803 unit
->arange
.low
= low_pc
;
804 unit
->arange
.high
= high_pc
;
808 /* Need to allocate a new arange and insert it into the arange list. */
809 arange
= bfd_zalloc (unit
->abfd
, (bfd_size_type
) sizeof (*arange
));
810 arange
->low
= low_pc
;
811 arange
->high
= high_pc
;
813 arange
->next
= unit
->arange
.next
;
814 unit
->arange
.next
= arange
;
817 /* Decode the line number information for UNIT. */
819 static struct line_info_table
*
820 decode_line_info (unit
, stash
)
821 struct comp_unit
*unit
;
822 struct dwarf2_debug
*stash
;
824 bfd
*abfd
= unit
->abfd
;
825 struct line_info_table
* table
;
829 unsigned int i
, bytes_read
;
830 char *cur_file
, *cur_dir
;
831 unsigned char op_code
, extended_op
, adj_opcode
;
834 if (! stash
->dwarf_line_buffer
)
838 msec
= bfd_get_section_by_name (abfd
, ".debug_line");
841 (*_bfd_error_handler
) (_("Dwarf Error: Can't find .debug_line section."));
842 bfd_set_error (bfd_error_bad_value
);
846 stash
->dwarf_line_size
= msec
->_raw_size
;
847 stash
->dwarf_line_buffer
= (char *) bfd_alloc (abfd
, msec
->_raw_size
);
848 if (! stash
->dwarf_line_buffer
)
851 if (! bfd_get_section_contents (abfd
, msec
, stash
->dwarf_line_buffer
,
852 (bfd_vma
) 0, msec
->_raw_size
))
855 /* FIXME: We ought to apply the relocs against this section before
859 /* Since we are using un-relocated data, it is possible to get a bad value
860 for the line_offset. Validate it here so that we won't get a segfault
862 if (unit
->line_offset
>= stash
->dwarf_line_size
)
864 (*_bfd_error_handler
) (_("Dwarf Error: Line offset (%u) greater than or equal to line size (%u)."),
865 unit
->line_offset
, stash
->dwarf_line_size
);
866 bfd_set_error (bfd_error_bad_value
);
870 amt
= sizeof (struct line_info_table
);
871 table
= (struct line_info_table
*) bfd_alloc (abfd
, amt
);
873 table
->comp_dir
= unit
->comp_dir
;
875 table
->num_files
= 0;
882 table
->last_line
= NULL
;
884 line_ptr
= stash
->dwarf_line_buffer
+ unit
->line_offset
;
886 /* Read in the prologue. */
887 lh
.total_length
= read_4_bytes (abfd
, line_ptr
);
889 line_end
= line_ptr
+ lh
.total_length
;
890 lh
.version
= read_2_bytes (abfd
, line_ptr
);
892 lh
.prologue_length
= read_4_bytes (abfd
, line_ptr
);
894 lh
.minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
896 lh
.default_is_stmt
= read_1_byte (abfd
, line_ptr
);
898 lh
.line_base
= read_1_signed_byte (abfd
, line_ptr
);
900 lh
.line_range
= read_1_byte (abfd
, line_ptr
);
902 lh
.opcode_base
= read_1_byte (abfd
, line_ptr
);
904 amt
= lh
.opcode_base
* sizeof (unsigned char);
905 lh
.standard_opcode_lengths
= (unsigned char *) bfd_alloc (abfd
, amt
);
907 lh
.standard_opcode_lengths
[0] = 1;
909 for (i
= 1; i
< lh
.opcode_base
; ++i
)
911 lh
.standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
915 /* Read directory table. */
916 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
918 line_ptr
+= bytes_read
;
920 if ((table
->num_dirs
% DIR_ALLOC_CHUNK
) == 0)
922 amt
= table
->num_dirs
+ DIR_ALLOC_CHUNK
;
923 amt
*= sizeof (char *);
924 table
->dirs
= (char **) bfd_realloc (table
->dirs
, amt
);
929 table
->dirs
[table
->num_dirs
++] = cur_dir
;
932 line_ptr
+= bytes_read
;
934 /* Read file name table. */
935 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
937 line_ptr
+= bytes_read
;
939 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
941 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
942 amt
*= sizeof (struct fileinfo
);
943 table
->files
= (struct fileinfo
*) bfd_realloc (table
->files
, amt
);
948 table
->files
[table
->num_files
].name
= cur_file
;
949 table
->files
[table
->num_files
].dir
=
950 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
951 line_ptr
+= bytes_read
;
952 table
->files
[table
->num_files
].time
=
953 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
954 line_ptr
+= bytes_read
;
955 table
->files
[table
->num_files
].size
=
956 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
957 line_ptr
+= bytes_read
;
961 line_ptr
+= bytes_read
;
963 /* Read the statement sequences until there's nothing left. */
964 while (line_ptr
< line_end
)
966 /* State machine registers. */
968 char* filename
= concat_filename (table
, 1);
969 unsigned int line
= 1;
970 unsigned int column
= 0;
971 int is_stmt
= lh
.default_is_stmt
;
973 int end_sequence
= 0, need_low_pc
= 1;
976 /* Decode the table. */
977 while (! end_sequence
)
979 op_code
= read_1_byte (abfd
, line_ptr
);
982 if (op_code
>= lh
.opcode_base
)
983 { /* Special operand. */
984 adj_opcode
= op_code
- lh
.opcode_base
;
985 address
+= (adj_opcode
/ lh
.line_range
)
986 * lh
.minimum_instruction_length
;
987 line
+= lh
.line_base
+ (adj_opcode
% lh
.line_range
);
988 /* Append row to matrix using current values. */
989 add_line_info (table
, address
, filename
, line
, column
, 0);
997 else switch (op_code
)
999 case DW_LNS_extended_op
:
1000 line_ptr
+= 1; /* Ignore length. */
1001 extended_op
= read_1_byte (abfd
, line_ptr
);
1003 switch (extended_op
)
1005 case DW_LNE_end_sequence
:
1007 add_line_info (table
, address
, filename
, line
, column
,
1014 arange_add (unit
, low_pc
, address
);
1016 case DW_LNE_set_address
:
1017 address
= read_address (unit
, line_ptr
);
1018 line_ptr
+= unit
->addr_size
;
1020 case DW_LNE_define_file
:
1021 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
1022 line_ptr
+= bytes_read
;
1023 if ((table
->num_files
% FILE_ALLOC_CHUNK
) == 0)
1025 amt
= table
->num_files
+ FILE_ALLOC_CHUNK
;
1026 amt
*= sizeof (struct fileinfo
);
1028 (struct fileinfo
*) bfd_realloc (table
->files
, amt
);
1032 table
->files
[table
->num_files
].name
= cur_file
;
1033 table
->files
[table
->num_files
].dir
=
1034 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1035 line_ptr
+= bytes_read
;
1036 table
->files
[table
->num_files
].time
=
1037 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1038 line_ptr
+= bytes_read
;
1039 table
->files
[table
->num_files
].size
=
1040 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1041 line_ptr
+= bytes_read
;
1045 (*_bfd_error_handler
) (_("Dwarf Error: mangled line number section."));
1046 bfd_set_error (bfd_error_bad_value
);
1051 add_line_info (table
, address
, filename
, line
, column
, 0);
1059 case DW_LNS_advance_pc
:
1060 address
+= lh
.minimum_instruction_length
1061 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1062 line_ptr
+= bytes_read
;
1064 case DW_LNS_advance_line
:
1065 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
1066 line_ptr
+= bytes_read
;
1068 case DW_LNS_set_file
:
1072 /* The file and directory tables are 0 based, the references
1074 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1075 line_ptr
+= bytes_read
;
1076 filename
= concat_filename (table
, file
);
1079 case DW_LNS_set_column
:
1080 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1081 line_ptr
+= bytes_read
;
1083 case DW_LNS_negate_stmt
:
1084 is_stmt
= (!is_stmt
);
1086 case DW_LNS_set_basic_block
:
1089 case DW_LNS_const_add_pc
:
1090 address
+= lh
.minimum_instruction_length
1091 * ((255 - lh
.opcode_base
) / lh
.line_range
);
1093 case DW_LNS_fixed_advance_pc
:
1094 address
+= read_2_bytes (abfd
, line_ptr
);
1098 { /* Unknown standard opcode, ignore it. */
1100 for (i
= 0; i
< lh
.standard_opcode_lengths
[op_code
]; i
++)
1102 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
1103 line_ptr
+= bytes_read
;
1113 /* If ADDR is within TABLE set the output parameters and return true,
1114 otherwise return false. The output parameters, FILENAME_PTR and
1115 LINENUMBER_PTR, are pointers to the objects to be filled in. */
1118 lookup_address_in_line_info_table (table
,
1122 struct line_info_table
* table
;
1124 const char **filename_ptr
;
1125 unsigned int *linenumber_ptr
;
1127 struct line_info
* next_line
= table
->last_line
;
1128 struct line_info
* each_line
;
1133 each_line
= next_line
->prev_line
;
1135 while (each_line
&& next_line
)
1137 if (!each_line
->end_sequence
1138 && addr
>= each_line
->address
&& addr
< next_line
->address
)
1140 *filename_ptr
= each_line
->filename
;
1141 *linenumber_ptr
= each_line
->line
;
1144 next_line
= each_line
;
1145 each_line
= each_line
->prev_line
;
1151 /* Function table functions. */
1155 struct funcinfo
*prev_func
;
1161 /* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return true. */
1164 lookup_address_in_function_table (table
,
1167 struct funcinfo
* table
;
1169 const char **functionname_ptr
;
1171 struct funcinfo
* each_func
;
1173 for (each_func
= table
;
1175 each_func
= each_func
->prev_func
)
1177 if (addr
>= each_func
->low
&& addr
< each_func
->high
)
1179 *functionname_ptr
= each_func
->name
;
1187 /* DWARF2 Compilation unit functions. */
1189 /* Scan over each die in a comp. unit looking for functions to add
1190 to the function table. */
1193 scan_unit_for_functions (unit
)
1194 struct comp_unit
*unit
;
1196 bfd
*abfd
= unit
->abfd
;
1197 char *info_ptr
= unit
->first_child_die_ptr
;
1198 int nesting_level
= 1;
1200 while (nesting_level
)
1202 unsigned int abbrev_number
, bytes_read
, i
;
1203 struct abbrev_info
*abbrev
;
1204 struct attribute attr
;
1205 struct funcinfo
*func
;
1208 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
1209 info_ptr
+= bytes_read
;
1211 if (! abbrev_number
)
1217 abbrev
= lookup_abbrev (abbrev_number
,unit
->abbrevs
);
1220 (*_bfd_error_handler
) (_("Dwarf Error: Could not find abbrev number %d."),
1222 bfd_set_error (bfd_error_bad_value
);
1226 if (abbrev
->tag
== DW_TAG_subprogram
)
1228 bfd_size_type amt
= sizeof (struct funcinfo
);
1229 func
= (struct funcinfo
*) bfd_zalloc (abfd
, amt
);
1230 func
->prev_func
= unit
->function_table
;
1231 unit
->function_table
= func
;
1236 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
1238 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
);
1246 name
= DW_STRING (&attr
);
1248 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
1249 if (func
->name
== NULL
)
1250 func
->name
= DW_STRING (&attr
);
1253 case DW_AT_MIPS_linkage_name
:
1254 func
->name
= DW_STRING (&attr
);
1258 func
->low
= DW_ADDR (&attr
);
1262 func
->high
= DW_ADDR (&attr
);
1274 name
= DW_STRING (&attr
);
1283 if (abbrev
->has_children
)
1290 /* Look for a RELA relocation to be applied on OFFSET of section SEC,
1291 and return the addend if such a relocation is found. Since this is
1292 only used to find relocations referring to the .debug_abbrev
1293 section, we make sure the relocation refers to this section, but
1294 this is not strictly necessary, and it can probably be safely
1295 removed if needed. However, it is important to note that this
1296 function only returns the addend, it doesn't serve the purpose of
1297 applying a generic relocation.
1299 If no suitable relocation is found, or if it is not a real RELA
1300 relocation, this function returns 0. */
1303 find_rela_addend (abfd
, sec
, offset
, syms
)
1306 bfd_size_type offset
;
1309 long reloc_size
= bfd_get_reloc_upper_bound (abfd
, sec
);
1310 arelent
**relocs
= NULL
;
1311 long reloc_count
, relc
;
1313 if (reloc_size
<= 0)
1316 relocs
= (arelent
**) bfd_malloc ((bfd_size_type
) reloc_size
);
1320 reloc_count
= bfd_canonicalize_reloc (abfd
, sec
, relocs
, syms
);
1322 if (reloc_count
<= 0)
1328 for (relc
= 0; relc
< reloc_count
; relc
++)
1329 if (relocs
[relc
]->address
== offset
1330 && (*relocs
[relc
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
1331 && strcmp ((*relocs
[relc
]->sym_ptr_ptr
)->name
,
1332 ".debug_abbrev") == 0)
1334 bfd_vma addend
= (relocs
[relc
]->howto
->partial_inplace
1335 ? 0 : relocs
[relc
]->addend
);
1344 /* Parse a DWARF2 compilation unit starting at INFO_PTR. This
1345 includes the compilation unit header that proceeds the DIE's, but
1346 does not include the length field that preceeds each compilation
1347 unit header. END_PTR points one past the end of this comp unit.
1348 If ABBREV_LENGTH is 0, then the length of the abbreviation offset
1349 is assumed to be four bytes. Otherwise, it it is the size given.
1351 This routine does not read the whole compilation unit; only enough
1352 to get to the line number information for the compilation unit. */
1354 static struct comp_unit
*
1355 parse_comp_unit (abfd
, stash
, unit_length
, abbrev_length
)
1357 struct dwarf2_debug
*stash
;
1358 bfd_vma unit_length
;
1359 unsigned int abbrev_length
;
1361 struct comp_unit
* unit
;
1363 unsigned short version
;
1364 unsigned int abbrev_offset
= 0;
1365 unsigned char addr_size
;
1366 struct abbrev_info
** abbrevs
;
1368 unsigned int abbrev_number
, bytes_read
, i
;
1369 struct abbrev_info
*abbrev
;
1370 struct attribute attr
;
1372 char *info_ptr
= stash
->info_ptr
;
1373 char *end_ptr
= info_ptr
+ unit_length
;
1377 version
= read_2_bytes (abfd
, info_ptr
);
1379 BFD_ASSERT (abbrev_length
== 0
1380 || abbrev_length
== 4
1381 || abbrev_length
== 8);
1382 if (abbrev_length
== 0 || abbrev_length
== 4)
1383 abbrev_offset
= read_4_bytes (abfd
, info_ptr
);
1384 else if (abbrev_length
== 8)
1385 abbrev_offset
= read_8_bytes (abfd
, info_ptr
);
1386 /* The abbrev offset is generally a relocation pointing to
1387 .debug_abbrev+offset. On RELA targets, we have to find the
1388 relocation and extract the addend to obtain the actual
1389 abbrev_offset, so do it here. */
1390 off
= info_ptr
- stash
->sec_info_ptr
;
1391 abbrev_offset
+= find_rela_addend (abfd
, stash
->sec
, off
, stash
->syms
);
1392 info_ptr
+= abbrev_length
;
1393 addr_size
= read_1_byte (abfd
, info_ptr
);
1398 (*_bfd_error_handler
) (_("Dwarf Error: found dwarf version '%hu', this reader only handles version 2 information."), version
);
1399 bfd_set_error (bfd_error_bad_value
);
1403 if (addr_size
> sizeof (bfd_vma
))
1405 (*_bfd_error_handler
) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
1408 bfd_set_error (bfd_error_bad_value
);
1412 if (addr_size
!= 2 && addr_size
!= 4 && addr_size
!= 8)
1414 (*_bfd_error_handler
) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size
);
1415 bfd_set_error (bfd_error_bad_value
);
1419 /* Read the abbrevs for this compilation unit into a table. */
1420 abbrevs
= read_abbrevs (abfd
, abbrev_offset
, stash
);
1424 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
1425 info_ptr
+= bytes_read
;
1426 if (! abbrev_number
)
1428 (*_bfd_error_handler
) (_("Dwarf Error: Bad abbrev number: %d."),
1430 bfd_set_error (bfd_error_bad_value
);
1434 abbrev
= lookup_abbrev (abbrev_number
, abbrevs
);
1437 (*_bfd_error_handler
) (_("Dwarf Error: Could not find abbrev number %d."),
1439 bfd_set_error (bfd_error_bad_value
);
1443 amt
= sizeof (struct comp_unit
);
1444 unit
= (struct comp_unit
*) bfd_zalloc (abfd
, amt
);
1446 unit
->addr_size
= addr_size
;
1447 unit
->abbrevs
= abbrevs
;
1448 unit
->end_ptr
= end_ptr
;
1450 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
1452 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], unit
, info_ptr
);
1454 /* Store the data if it is of an attribute we want to keep in a
1455 partial symbol table. */
1458 case DW_AT_stmt_list
:
1460 unit
->line_offset
= DW_UNSND (&attr
);
1464 unit
->name
= DW_STRING (&attr
);
1468 unit
->arange
.low
= DW_ADDR (&attr
);
1472 unit
->arange
.high
= DW_ADDR (&attr
);
1475 case DW_AT_comp_dir
:
1477 char* comp_dir
= DW_STRING (&attr
);
1480 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1481 directory, get rid of it. */
1482 char *cp
= (char*) strchr (comp_dir
, ':');
1484 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
1487 unit
->comp_dir
= comp_dir
;
1496 unit
->first_child_die_ptr
= info_ptr
;
1500 /* Return true if UNIT contains the address given by ADDR. */
1503 comp_unit_contains_address (unit
, addr
)
1504 struct comp_unit
* unit
;
1507 struct arange
*arange
;
1512 arange
= &unit
->arange
;
1515 if (addr
>= arange
->low
&& addr
< arange
->high
)
1517 arange
= arange
->next
;
1524 /* If UNIT contains ADDR, set the output parameters to the values for
1525 the line containing ADDR. The output parameters, FILENAME_PTR,
1526 FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
1529 Return true of UNIT contains ADDR, and no errors were encountered;
1533 comp_unit_find_nearest_line (unit
, addr
,
1534 filename_ptr
, functionname_ptr
, linenumber_ptr
,
1536 struct comp_unit
* unit
;
1538 const char **filename_ptr
;
1539 const char **functionname_ptr
;
1540 unsigned int *linenumber_ptr
;
1541 struct dwarf2_debug
*stash
;
1549 if (! unit
->line_table
)
1551 if (! unit
->stmtlist
)
1557 unit
->line_table
= decode_line_info (unit
, stash
);
1559 if (! unit
->line_table
)
1565 if (unit
->first_child_die_ptr
< unit
->end_ptr
1566 && ! scan_unit_for_functions (unit
))
1573 line_p
= lookup_address_in_line_info_table (unit
->line_table
,
1577 func_p
= lookup_address_in_function_table (unit
->function_table
,
1580 return line_p
|| func_p
;
1583 /* Locate a section in a BFD containing debugging info. The search starts from the
1584 section after AFTER_SEC, or from the first section in the BFD if AFTER_SEC is
1585 NULL. The search works by examining the names of the sections. There are two
1586 permissiable names. The first is .debug_info. This is the standard DWARF2 name.
1587 The second is a prefix .gnu.linkonce.wi. This is a variation on the .debug_info
1588 section which has a checksum describing the contents appended onto the name. This
1589 allows the linker to identify and discard duplicate debugging sections for
1590 different compilation units. */
1591 #define DWARF2_DEBUG_INFO ".debug_info"
1592 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
1595 find_debug_info (abfd
, after_sec
)
1597 asection
* after_sec
;
1602 msec
= after_sec
->next
;
1604 msec
= abfd
->sections
;
1608 if (strcmp (msec
->name
, DWARF2_DEBUG_INFO
) == 0)
1611 if (strncmp (msec
->name
, GNU_LINKONCE_INFO
, strlen (GNU_LINKONCE_INFO
)) == 0)
1620 /* The DWARF2 version of find_nearest line. Return true if the line
1621 is found without error. ADDR_SIZE is the number of bytes in the
1622 initial .debug_info length field and in the abbreviation offset.
1623 You may use zero to indicate that the default value should be
1627 _bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
1628 filename_ptr
, functionname_ptr
,
1635 const char **filename_ptr
;
1636 const char **functionname_ptr
;
1637 unsigned int *linenumber_ptr
;
1638 unsigned int addr_size
;
1641 /* Read each compilation unit from the section .debug_info, and check
1642 to see if it contains the address we are searching for. If yes,
1643 lookup the address, and return the line number info. If no, go
1644 on to the next compilation unit.
1646 We keep a list of all the previously read compilation units, and
1647 a pointer to the next un-read compilation unit. Check the
1648 previously read units before reading more. */
1649 struct dwarf2_debug
*stash
= (struct dwarf2_debug
*) *pinfo
;
1651 /* What address are we looking for? */
1652 bfd_vma addr
= offset
+ section
->vma
;
1654 struct comp_unit
* each
;
1656 *filename_ptr
= NULL
;
1657 *functionname_ptr
= NULL
;
1658 *linenumber_ptr
= 0;
1660 /* The DWARF2 spec says that the initial length field, and the
1661 offset of the abbreviation table, should both be 4-byte values.
1662 However, some compilers do things differently. */
1665 BFD_ASSERT (addr_size
== 4 || addr_size
== 8);
1669 bfd_size_type total_size
;
1671 bfd_size_type amt
= sizeof (struct dwarf2_debug
);
1673 stash
= (struct dwarf2_debug
*) bfd_zalloc (abfd
, amt
);
1677 *pinfo
= (PTR
) stash
;
1679 msec
= find_debug_info (abfd
, NULL
);
1681 /* No dwarf2 info. Note that at this point the stash
1682 has been allocated, but contains zeros, this lets
1683 future calls to this function fail quicker. */
1686 /* There can be more than one DWARF2 info section in a BFD these days.
1687 Read them all in and produce one large stash. We do this in two
1688 passes - in the first pass we just accumulate the section sizes.
1689 In the second pass we read in the section's contents. The allows
1690 us to avoid reallocing the data as we add sections to the stash. */
1691 for (total_size
= 0; msec
; msec
= find_debug_info (abfd
, msec
))
1692 total_size
+= msec
->_raw_size
;
1694 stash
->info_ptr
= (char *) bfd_alloc (abfd
, total_size
);
1695 if (stash
->info_ptr
== NULL
)
1698 stash
->info_ptr_end
= stash
->info_ptr
;
1700 for (msec
= find_debug_info (abfd
, NULL
);
1702 msec
= find_debug_info (abfd
, msec
))
1705 bfd_size_type start
;
1707 size
= msec
->_raw_size
;
1711 start
= stash
->info_ptr_end
- stash
->info_ptr
;
1713 if (! bfd_get_section_contents (abfd
, msec
, stash
->info_ptr
+ start
,
1717 stash
->info_ptr_end
= stash
->info_ptr
+ start
+ size
;
1720 BFD_ASSERT (stash
->info_ptr_end
== stash
->info_ptr
+ total_size
);
1722 stash
->sec
= find_debug_info (abfd
, NULL
);
1723 stash
->sec_info_ptr
= stash
->info_ptr
;
1724 stash
->syms
= symbols
;
1727 /* FIXME: There is a problem with the contents of the
1728 .debug_info section. The 'low' and 'high' addresses of the
1729 comp_units are computed by relocs against symbols in the
1730 .text segment. We need these addresses in order to determine
1731 the nearest line number, and so we have to resolve the
1732 relocs. There is a similar problem when the .debug_line
1733 section is processed as well (e.g., there may be relocs
1734 against the operand of the DW_LNE_set_address operator).
1736 Unfortunately getting hold of the reloc information is hard...
1738 For now, this means that disassembling object files (as
1739 opposed to fully executables) does not always work as well as
1742 /* A null info_ptr indicates that there is no dwarf2 info
1743 (or that an error occured while setting up the stash). */
1744 if (! stash
->info_ptr
)
1747 /* Check the previously read comp. units first. */
1748 for (each
= stash
->all_comp_units
; each
; each
= each
->next_unit
)
1749 if (comp_unit_contains_address (each
, addr
))
1750 return comp_unit_find_nearest_line (each
, addr
, filename_ptr
,
1751 functionname_ptr
, linenumber_ptr
,
1754 /* Read each remaining comp. units checking each as they are read. */
1755 while (stash
->info_ptr
< stash
->info_ptr_end
)
1761 length
= read_4_bytes (abfd
, stash
->info_ptr
);
1763 length
= read_8_bytes (abfd
, stash
->info_ptr
);
1764 stash
->info_ptr
+= addr_size
;
1768 each
= parse_comp_unit (abfd
, stash
, length
, addr_size
);
1769 stash
->info_ptr
+= length
;
1771 if ((bfd_vma
) (stash
->info_ptr
- stash
->sec_info_ptr
)
1772 == stash
->sec
->_raw_size
)
1774 stash
->sec
= find_debug_info (abfd
, stash
->sec
);
1775 stash
->sec_info_ptr
= stash
->info_ptr
;
1780 each
->next_unit
= stash
->all_comp_units
;
1781 stash
->all_comp_units
= each
;
1783 /* DW_AT_low_pc and DW_AT_high_pc are optional for
1784 compilation units. If we don't have them (i.e.,
1785 unit->high == 0), we need to consult the line info
1786 table to see if a compilation unit contains the given
1788 if (each
->arange
.high
> 0)
1790 if (comp_unit_contains_address (each
, addr
))
1791 return comp_unit_find_nearest_line (each
, addr
,
1799 found
= comp_unit_find_nearest_line (each
, addr
,