1 /* DWARF 1 find nearest line (_bfd_dwarf1_find_nearest_line).
2 Copyright 1998 Free Software Foundation, Inc.
4 Written by Gavin Romig-Koch of Cygnus Solutions (gavin@cygnus.com).
6 This file is part of BFD.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or (at
11 your option) any later version.
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
24 #include "libiberty.h"
27 #include "elf/dwarf.h"
29 /* dwarf1_debug is the starting point for all dwarf1 info. */
33 /* The bfd we are working with. */
36 /* List of already parsed compilation units. */
37 struct dwarf1_unit
* lastUnit
;
39 /* The buffer for the .debug section.
40 Zero indicates that the .debug section failed to load. */
43 /* Pointer to the end of the .debug_info section memory buffer. */
44 char* debug_section_end
;
46 /* The buffer for the .line section. */
49 /* End of that buffer. */
50 char* line_section_end
;
52 /* The current or next unread die within the .debug section. */
56 /* One dwarf1_unit for each parsed compilation unit die. */
59 /* Linked starting from stash->lastUnit. */
60 struct dwarf1_unit
* prev
;
62 /* Name of the compilation unit. */
65 /* The highest and lowest address used in the compilation unit. */
67 unsigned long high_pc
;
69 /* Does this unit have a statement list? */
72 /* If any, the offset of the line number table in the .line section. */
73 unsigned long stmt_list_offset
;
75 /* If non-zero, a pointer to the first child of this unit. */
78 /* How many line entries? */
79 unsigned long line_count
;
81 /* The decoded line number table (line_count entries). */
82 struct linenumber
* linenumber_table
;
84 /* The list of functions in this unit. */
85 struct dwarf1_func
* func_list
;
90 /* One dwarf1_func for each parsed function die. */
93 /* Linked starting from aUnit->func_list. */
94 struct dwarf1_func
* prev
;
96 /* Name of function. */
99 /* The highest and lowest address used in the compilation unit. */
100 unsigned long low_pc
;
101 unsigned long high_pc
;
105 /* Used to return info about a parsed die. */
107 unsigned long length
;
108 unsigned long sibling
;
109 unsigned long low_pc
;
110 unsigned long high_pc
;
111 unsigned long stmt_list_offset
;
121 /* Parsed line number information. */
123 /* First address in the line. */
126 /* The line number. */
127 unsigned long linenumber
;
131 /* Find the form of an attr, from the attr field. */
132 #define FORM_FROM_ATTR(attr) ((attr) & 0xF) /* Implicitly specified */
135 /* Return a newly allocated dwarf1_unit. It should be cleared and
136 then attached into the 'stash' at 'stash->lastUnit'. */
138 static struct dwarf1_unit
*
139 alloc_dwarf1_unit (stash
)
140 struct dwarf1_debug
* stash
;
142 struct dwarf1_unit
* x
=
143 (struct dwarf1_unit
*) bfd_alloc (stash
->abfd
,
144 sizeof (struct dwarf1_unit
));
145 x
->prev
= stash
->lastUnit
;
151 /* Return a newly allocated dwarf1_func. It must be cleared and
152 attached into 'aUnit' at 'aUnit->func_list'. */
154 static struct dwarf1_func
*
155 alloc_dwarf1_func (stash
, aUnit
)
156 struct dwarf1_debug
* stash
;
157 struct dwarf1_unit
* aUnit
;
159 struct dwarf1_func
* x
=
160 (struct dwarf1_func
*) bfd_alloc (stash
->abfd
,
161 sizeof (struct dwarf1_func
));
162 x
->prev
= aUnit
->func_list
;
163 aUnit
->func_list
= x
;
168 /* parse_die - parse a Dwarf1 die.
169 Parse the die starting at 'aDiePtr' into 'aDieInfo'.
170 'abfd' must be the bfd from which the section that 'aDiePtr'
171 points to was pulled from.
173 Return false if the die is invalidly formatted; true otherwise. */
176 parse_die (abfd
, aDieInfo
, aDiePtr
)
178 struct die_info
* aDieInfo
;
181 char* this_die
= aDiePtr
;
182 char* xptr
= this_die
;
184 memset (aDieInfo
,0,sizeof(*aDieInfo
));
186 /* First comes the length. */
187 aDieInfo
->length
= bfd_get_32 (abfd
, xptr
);
189 if (aDieInfo
->length
< 6)
191 /* Just padding bytes. */
192 aDieInfo
->tag
= TAG_padding
;
197 aDieInfo
->tag
= bfd_get_16 (abfd
, xptr
);
200 /* Then the attributes. */
201 while (xptr
< (this_die
+ aDieInfo
->length
))
205 /* Parse the attribute based on its form. This section
206 must handle all dwarf1 forms, but need only handle the
207 actual attributes that we care about. */
209 attr
= bfd_get_16 (abfd
, xptr
);
212 switch (FORM_FROM_ATTR (attr
))
219 if (attr
== AT_sibling
)
220 aDieInfo
->sibling
= bfd_get_32 (abfd
, xptr
);
221 else if (attr
== AT_stmt_list
)
223 aDieInfo
->stmt_list_offset
= bfd_get_32 (abfd
, xptr
);
224 aDieInfo
->has_stmt_list
= 1;
232 if (attr
== AT_low_pc
)
233 aDieInfo
->low_pc
= bfd_get_32 (abfd
, xptr
);
234 else if (attr
== AT_high_pc
)
235 aDieInfo
->high_pc
= bfd_get_32 (abfd
, xptr
);
239 xptr
+= 2 + bfd_get_16 (abfd
, xptr
);
242 xptr
+= 4 + bfd_get_32 (abfd
, xptr
);
246 aDieInfo
->name
= xptr
;
247 xptr
+= strlen (xptr
) + 1;
255 /* Parse a dwarf1 line number table for 'aUnit->stmt_list_offset'
256 into 'aUnit->linenumber_table'. Return false if an error
257 occurs; true otherwise. */
260 parse_line_table (stash
, aUnit
)
261 struct dwarf1_debug
* stash
;
262 struct dwarf1_unit
* aUnit
;
266 /* Load the ".line" section from the bfd if we haven't already. */
267 if (stash
->line_section
== 0)
272 msec
= bfd_get_section_by_name (stash
->abfd
, ".line");
276 size
= bfd_get_section_size_before_reloc (msec
);
277 stash
->line_section
= (unsigned char*) bfd_alloc (stash
->abfd
, size
);
279 if (! stash
->line_section
)
282 if (! bfd_get_section_contents (stash
->abfd
, msec
, stash
->line_section
, 0, size
))
284 stash
->line_section
= 0;
288 stash
->line_section_end
= stash
->line_section
+ size
;
291 xptr
= stash
->line_section
+ aUnit
->stmt_list_offset
;
292 if (xptr
< stash
->line_section_end
)
298 unsigned long last_pc
= -1;
299 unsigned long last_line
= 0;
301 /* First comes the length. */
302 tblend
= bfd_get_32 (stash
->abfd
, xptr
) + xptr
;
305 /* Then the base address for each address in the table. */
306 base
= bfd_get_32 (stash
->abfd
, xptr
);
309 /* How many line entrys?
310 10 = 4 (line number) + 2 (pos in line) + 4 (address in line) */
311 aUnit
->line_count
= (tblend
- xptr
) / 10;
313 /* Allocate an array for the entries. */
314 aUnit
->linenumber_table
= (struct linenumber
*)
315 bfd_alloc (stash
->abfd
,
316 sizeof (struct linenumber
) * aUnit
->line_count
);
318 for (eachLine
= 0; eachLine
< aUnit
->line_count
; eachLine
++)
321 aUnit
->linenumber_table
[eachLine
].linenumber
322 = bfd_get_32 (stash
->abfd
, xptr
);
325 /* Skip the position within the line. */
328 /* And finally the address. */
329 aUnit
->linenumber_table
[eachLine
].addr
330 = base
+ bfd_get_32 (stash
->abfd
, xptr
);
338 /* Parse each function die in a compilation unit 'aUnit'.
339 The first child die of 'aUnit' should be in 'aUnit->first_child',
340 the result is placed in 'aUnit->func_list'.
341 Return false if error; true otherwise. */
344 parse_functions_in_unit (stash
, aUnit
)
345 struct dwarf1_debug
* stash
;
346 struct dwarf1_unit
* aUnit
;
350 if (aUnit
->first_child
)
351 for (eachDie
= aUnit
->first_child
;
352 eachDie
< stash
->debug_section_end
;
355 struct die_info eachDieInfo
;
357 if (! parse_die (stash
->abfd
, &eachDieInfo
, eachDie
))
360 if (eachDieInfo
.tag
== TAG_global_subroutine
361 || eachDieInfo
.tag
== TAG_subroutine
362 || eachDieInfo
.tag
== TAG_inlined_subroutine
363 || eachDieInfo
.tag
== TAG_entry_point
)
365 struct dwarf1_func
* aFunc
= alloc_dwarf1_func (stash
,aUnit
);
367 aFunc
->name
= eachDieInfo
.name
;
368 aFunc
->low_pc
= eachDieInfo
.low_pc
;
369 aFunc
->high_pc
= eachDieInfo
.high_pc
;
372 /* Move to next sibling, if none, end loop */
373 if (eachDieInfo
.sibling
)
374 eachDie
= stash
->debug_section
+ eachDieInfo
.sibling
;
382 /* Find the nearest line to 'addr' in 'aUnit'.
383 Return whether we found the line (or a function) without error. */
386 dwarf1_unit_find_nearest_line (stash
, aUnit
, addr
,
387 filename_ptr
, functionname_ptr
,
389 struct dwarf1_debug
* stash
;
390 struct dwarf1_unit
* aUnit
;
392 const char **filename_ptr
;
393 const char **functionname_ptr
;
394 unsigned int *linenumber_ptr
;
399 if (aUnit
->low_pc
<= addr
&& addr
< aUnit
->high_pc
)
401 if (aUnit
->has_stmt_list
)
404 struct dwarf1_func
* eachFunc
;
406 if (! aUnit
->linenumber_table
)
408 if (! parse_line_table (stash
, aUnit
))
412 if (! aUnit
->func_list
)
414 if (! parse_functions_in_unit (stash
, aUnit
))
418 for (i
= 0; i
< aUnit
->line_count
; i
++)
420 if (aUnit
->linenumber_table
[i
].addr
<= addr
421 && addr
< aUnit
->linenumber_table
[i
+1].addr
)
423 *filename_ptr
= aUnit
->name
;
424 *linenumber_ptr
= aUnit
->linenumber_table
[i
].linenumber
;
430 for (eachFunc
= aUnit
->func_list
;
432 eachFunc
= eachFunc
->prev
)
434 if (eachFunc
->low_pc
<= addr
435 && addr
< eachFunc
->high_pc
)
437 *functionname_ptr
= eachFunc
->name
;
445 return line_p
|| func_p
;
451 /* The DWARF 1 version of find_nearest line.
452 Return true if the line is found without error. */
455 _bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
456 filename_ptr
, functionname_ptr
, linenumber_ptr
)
461 const char **filename_ptr
;
462 const char **functionname_ptr
;
463 unsigned int *linenumber_ptr
;
465 struct dwarf1_debug
*stash
= elf_tdata (abfd
)->dwarf1_find_line_info
;
467 struct dwarf1_unit
* eachUnit
;
469 /* What address are we looking for? */
470 bfd_vma addr
= offset
+ section
->vma
;
472 *filename_ptr
= NULL
;
473 *functionname_ptr
= NULL
;
482 stash
= elf_tdata (abfd
)->dwarf1_find_line_info
=
483 (struct dwarf1_debug
*) bfd_zalloc (abfd
, sizeof (struct dwarf1_debug
));
488 msec
= bfd_get_section_by_name (abfd
, ".debug");
491 /* No dwarf1 info. Note that at this point the stash
492 has been allocated, but contains zeros, this lets
493 future calls to this function fail quicker. */
497 size
= bfd_get_section_size_before_reloc (msec
);
498 stash
->debug_section
= (unsigned char*) bfd_alloc (abfd
, size
);
500 if (! stash
->debug_section
)
503 if (! bfd_get_section_contents (abfd
, msec
, stash
->debug_section
, 0, size
))
505 stash
->debug_section
= 0;
509 stash
->debug_section_end
= stash
->debug_section
+ size
;
510 stash
->currentDie
= stash
->debug_section
;
514 /* A null debug_section indicates that there was no dwarf1 info
515 or that an error occured while setting up the stash. */
517 if (! stash
->debug_section
)
521 /* Look at the previously parsed units to see if any contain
523 for (eachUnit
= stash
->lastUnit
; eachUnit
; eachUnit
= eachUnit
->prev
)
525 if (eachUnit
->low_pc
<= addr
&& addr
< eachUnit
->high_pc
)
526 return dwarf1_unit_find_nearest_line (stash
, eachUnit
, addr
,
532 while (stash
->currentDie
< stash
->debug_section_end
)
534 struct die_info aDieInfo
;
536 if (! parse_die (stash
->abfd
, &aDieInfo
, stash
->currentDie
))
539 if (aDieInfo
.tag
== TAG_compile_unit
)
541 struct dwarf1_unit
* aUnit
542 = alloc_dwarf1_unit (stash
);
544 aUnit
->name
= aDieInfo
.name
;
545 aUnit
->low_pc
= aDieInfo
.low_pc
;
546 aUnit
->high_pc
= aDieInfo
.high_pc
;
547 aUnit
->has_stmt_list
= aDieInfo
.has_stmt_list
;
548 aUnit
->stmt_list_offset
= aDieInfo
.stmt_list_offset
;
550 /* A die has a child if it's followed by a die that is
553 && stash
->currentDie
+ aDieInfo
.length
554 < stash
->debug_section_end
555 && stash
->currentDie
+ aDieInfo
.length
556 != stash
->debug_section
+ aDieInfo
.sibling
)
557 aUnit
->first_child
= stash
->currentDie
+ aDieInfo
.length
;
559 aUnit
->first_child
= 0;
561 if (aUnit
->low_pc
<= addr
&& addr
< aUnit
->high_pc
)
562 return dwarf1_unit_find_nearest_line (stash
, aUnit
, addr
,
568 if (aDieInfo
.sibling
!= 0)
569 stash
->currentDie
= stash
->debug_section
+ aDieInfo
.sibling
;
571 stash
->currentDie
+= aDieInfo
.length
;
This page took 0.041149 seconds and 4 git commands to generate.