1 /* DWARF 1 find nearest line (_bfd_dwarf1_find_nearest_line).
2 Copyright (C) 1998-2018 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 3 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., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
25 #include "libiberty.h"
28 #include "elf/dwarf.h"
30 /* dwarf1_debug is the starting point for all dwarf1 info. */
34 /* The bfd we are working with. */
37 /* Pointer to the symbol table. */
40 /* List of already parsed compilation units. */
41 struct dwarf1_unit* lastUnit;
43 /* The buffer for the .debug section.
44 Zero indicates that the .debug section failed to load. */
45 bfd_byte *debug_section;
47 /* Pointer to the end of the .debug_info section memory buffer. */
48 bfd_byte *debug_section_end;
50 /* The buffer for the .line section. */
51 bfd_byte *line_section;
53 /* End of that buffer. */
54 bfd_byte *line_section_end;
56 /* The current or next unread die within the .debug section. */
60 /* One dwarf1_unit for each parsed compilation unit die. */
64 /* Linked starting from stash->lastUnit. */
65 struct dwarf1_unit* prev;
67 /* Name of the compilation unit. */
70 /* The highest and lowest address used in the compilation unit. */
72 unsigned long high_pc;
74 /* Does this unit have a statement list? */
77 /* If any, the offset of the line number table in the .line section. */
78 unsigned long stmt_list_offset;
80 /* If non-zero, a pointer to the first child of this unit. */
81 bfd_byte *first_child;
83 /* How many line entries? */
84 unsigned long line_count;
86 /* The decoded line number table (line_count entries). */
87 struct linenumber* linenumber_table;
89 /* The list of functions in this unit. */
90 struct dwarf1_func* func_list;
93 /* One dwarf1_func for each parsed function die. */
97 /* Linked starting from aUnit->func_list. */
98 struct dwarf1_func* prev;
100 /* Name of function. */
103 /* The highest and lowest address used in the compilation unit. */
104 unsigned long low_pc;
105 unsigned long high_pc;
108 /* Used to return info about a parsed die. */
111 unsigned long length;
112 unsigned long sibling;
113 unsigned long low_pc;
114 unsigned long high_pc;
115 unsigned long stmt_list_offset;
124 /* Parsed line number information. */
127 /* First address in the line. */
130 /* The line number. */
131 unsigned long linenumber;
134 /* Find the form of an attr, from the attr field. */
135 #define FORM_FROM_ATTR(attr) ((attr) & 0xF) /* Implicitly specified. */
137 /* Return a newly allocated dwarf1_unit. It should be cleared and
138 then attached into the 'stash' at 'stash->lastUnit'. */
140 static struct dwarf1_unit*
141 alloc_dwarf1_unit (struct dwarf1_debug* stash)
143 bfd_size_type amt = sizeof (struct dwarf1_unit);
145 struct dwarf1_unit* x = (struct dwarf1_unit *) bfd_zalloc (stash->abfd, amt);
148 x->prev = stash->lastUnit;
155 /* Return a newly allocated dwarf1_func. It must be cleared and
156 attached into 'aUnit' at 'aUnit->func_list'. */
158 static struct dwarf1_func *
159 alloc_dwarf1_func (struct dwarf1_debug* stash, struct dwarf1_unit* aUnit)
161 bfd_size_type amt = sizeof (struct dwarf1_func);
163 struct dwarf1_func* x = (struct dwarf1_func *) bfd_zalloc (stash->abfd, amt);
166 x->prev = aUnit->func_list;
167 aUnit->func_list = x;
173 /* parse_die - parse a Dwarf1 die.
174 Parse the die starting at 'aDiePtr' into 'aDieInfo'.
175 'abfd' must be the bfd from which the section that 'aDiePtr'
176 points to was pulled from.
178 Return FALSE if the die is invalidly formatted; TRUE otherwise. */
181 parse_die (bfd * abfd,
182 struct die_info * aDieInfo,
184 bfd_byte * aDiePtrEnd)
186 bfd_byte *this_die = aDiePtr;
187 bfd_byte *xptr = this_die;
189 memset (aDieInfo, 0, sizeof (* aDieInfo));
191 /* First comes the length. */
192 if (xptr + 4 > aDiePtrEnd)
194 aDieInfo->length = bfd_get_32 (abfd, xptr);
196 if (aDieInfo->length == 0
197 || this_die + aDieInfo->length > aDiePtrEnd)
199 aDiePtrEnd = this_die + aDieInfo->length;
200 if (aDieInfo->length < 6)
202 /* Just padding bytes. */
203 aDieInfo->tag = TAG_padding;
208 if (xptr + 2 > aDiePtrEnd)
210 aDieInfo->tag = bfd_get_16 (abfd, xptr);
213 /* Then the attributes. */
214 while (xptr + 2 <= aDiePtrEnd)
218 /* Parse the attribute based on its form. This section
219 must handle all dwarf1 forms, but need only handle the
220 actual attributes that we care about. */
221 attr = bfd_get_16 (abfd, xptr);
224 switch (FORM_FROM_ATTR (attr))
231 if (xptr + 4 <= aDiePtrEnd)
233 if (attr == AT_sibling)
234 aDieInfo->sibling = bfd_get_32 (abfd, xptr);
235 else if (attr == AT_stmt_list)
237 aDieInfo->stmt_list_offset = bfd_get_32 (abfd, xptr);
238 aDieInfo->has_stmt_list = 1;
247 if (xptr + 4 <= aDiePtrEnd)
249 if (attr == AT_low_pc)
250 aDieInfo->low_pc = bfd_get_32 (abfd, xptr);
251 else if (attr == AT_high_pc)
252 aDieInfo->high_pc = bfd_get_32 (abfd, xptr);
257 if (xptr + 2 <= aDiePtrEnd)
258 xptr += bfd_get_16 (abfd, xptr);
262 if (xptr + 4 <= aDiePtrEnd)
263 xptr += bfd_get_32 (abfd, xptr);
268 aDieInfo->name = (char *) xptr;
269 xptr += strnlen ((char *) xptr, aDiePtrEnd - xptr) + 1;
277 /* Parse a dwarf1 line number table for 'aUnit->stmt_list_offset'
278 into 'aUnit->linenumber_table'. Return FALSE if an error
279 occurs; TRUE otherwise. */
282 parse_line_table (struct dwarf1_debug* stash, struct dwarf1_unit* aUnit)
286 /* Load the ".line" section from the bfd if we haven't already. */
287 if (stash->line_section == 0)
292 msec = bfd_get_section_by_name (stash->abfd, ".line");
296 size = msec->rawsize ? msec->rawsize : msec->size;
298 = bfd_simple_get_relocated_section_contents
299 (stash->abfd, msec, NULL, stash->syms);
301 if (! stash->line_section)
304 stash->line_section_end = stash->line_section + size;
307 xptr = stash->line_section + aUnit->stmt_list_offset;
308 if (xptr + 8 <= stash->line_section_end)
310 unsigned long eachLine;
315 /* First comes the length. */
316 tblend = bfd_get_32 (stash->abfd, (bfd_byte *) xptr) + xptr;
319 /* Then the base address for each address in the table. */
320 base = bfd_get_32 (stash->abfd, (bfd_byte *) xptr);
323 /* How many line entrys?
324 10 = 4 (line number) + 2 (pos in line) + 4 (address in line). */
325 aUnit->line_count = (tblend - xptr) / 10;
327 /* Allocate an array for the entries. */
328 amt = sizeof (struct linenumber) * aUnit->line_count;
329 aUnit->linenumber_table = (struct linenumber *) bfd_alloc (stash->abfd,
331 if (!aUnit->linenumber_table)
334 for (eachLine = 0; eachLine < aUnit->line_count; eachLine++)
336 if (xptr + 10 > stash->line_section_end)
338 aUnit->line_count = eachLine;
342 aUnit->linenumber_table[eachLine].linenumber
343 = bfd_get_32 (stash->abfd, (bfd_byte *) xptr);
346 /* Skip the position within the line. */
349 /* And finally the address. */
350 aUnit->linenumber_table[eachLine].addr
351 = base + bfd_get_32 (stash->abfd, (bfd_byte *) xptr);
359 /* Parse each function die in a compilation unit 'aUnit'.
360 The first child die of 'aUnit' should be in 'aUnit->first_child',
361 the result is placed in 'aUnit->func_list'.
362 Return FALSE if error; TRUE otherwise. */
365 parse_functions_in_unit (struct dwarf1_debug* stash, struct dwarf1_unit* aUnit)
369 if (aUnit->first_child)
370 for (eachDie = aUnit->first_child;
371 eachDie < stash->debug_section_end;
374 struct die_info eachDieInfo;
376 if (! parse_die (stash->abfd, &eachDieInfo, eachDie,
377 stash->debug_section_end))
380 if (eachDieInfo.tag == TAG_global_subroutine
381 || eachDieInfo.tag == TAG_subroutine
382 || eachDieInfo.tag == TAG_inlined_subroutine
383 || eachDieInfo.tag == TAG_entry_point)
385 struct dwarf1_func* aFunc = alloc_dwarf1_func (stash,aUnit);
389 aFunc->name = eachDieInfo.name;
390 aFunc->low_pc = eachDieInfo.low_pc;
391 aFunc->high_pc = eachDieInfo.high_pc;
394 /* Move to next sibling, if none, end loop */
395 if (eachDieInfo.sibling)
396 eachDie = stash->debug_section + eachDieInfo.sibling;
404 /* Find the nearest line to 'addr' in 'aUnit'.
405 Return whether we found the line (or a function) without error. */
408 dwarf1_unit_find_nearest_line (struct dwarf1_debug* stash,
409 struct dwarf1_unit* aUnit,
411 const char **filename_ptr,
412 const char **functionname_ptr,
413 unsigned int *linenumber_ptr)
418 if (aUnit->low_pc <= addr && addr < aUnit->high_pc)
420 if (aUnit->has_stmt_list)
423 struct dwarf1_func* eachFunc;
425 if (! aUnit->linenumber_table)
427 if (! parse_line_table (stash, aUnit))
431 if (! aUnit->func_list)
433 if (! parse_functions_in_unit (stash, aUnit))
437 for (i = 0; i < aUnit->line_count; i++)
439 if (aUnit->linenumber_table[i].addr <= addr
440 && addr < aUnit->linenumber_table[i+1].addr)
442 *filename_ptr = aUnit->name;
443 *linenumber_ptr = aUnit->linenumber_table[i].linenumber;
449 for (eachFunc = aUnit->func_list;
451 eachFunc = eachFunc->prev)
453 if (eachFunc->low_pc <= addr
454 && addr < eachFunc->high_pc)
456 *functionname_ptr = eachFunc->name;
464 return line_p || func_p;
467 /* The DWARF 1 version of find_nearest line.
468 Return TRUE if the line is found without error. */
471 _bfd_dwarf1_find_nearest_line (bfd *abfd,
475 const char **filename_ptr,
476 const char **functionname_ptr,
477 unsigned int *linenumber_ptr)
479 struct dwarf1_debug *stash = elf_tdata (abfd)->dwarf1_find_line_info;
481 struct dwarf1_unit* eachUnit;
483 /* What address are we looking for? */
484 unsigned long addr = (unsigned long)(offset + section->vma);
486 *filename_ptr = NULL;
487 *functionname_ptr = NULL;
493 bfd_size_type size = sizeof (struct dwarf1_debug);
495 stash = elf_tdata (abfd)->dwarf1_find_line_info
496 = (struct dwarf1_debug *) bfd_zalloc (abfd, size);
501 msec = bfd_get_section_by_name (abfd, ".debug");
503 /* No dwarf1 info. Note that at this point the stash
504 has been allocated, but contains zeros, this lets
505 future calls to this function fail quicker. */
508 size = msec->rawsize ? msec->rawsize : msec->size;
510 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
513 if (! stash->debug_section)
516 stash->debug_section_end = stash->debug_section + size;
517 stash->currentDie = stash->debug_section;
519 stash->syms = symbols;
522 /* A null debug_section indicates that there was no dwarf1 info
523 or that an error occured while setting up the stash. */
525 if (! stash->debug_section)
528 /* Look at the previously parsed units to see if any contain
530 for (eachUnit = stash->lastUnit; eachUnit; eachUnit = eachUnit->prev)
531 if (eachUnit->low_pc <= addr && addr < eachUnit->high_pc)
532 return dwarf1_unit_find_nearest_line (stash, eachUnit, addr,
537 while (stash->currentDie < stash->debug_section_end)
539 struct die_info aDieInfo;
541 if (! parse_die (stash->abfd, &aDieInfo, stash->currentDie,
542 stash->debug_section_end))
545 if (aDieInfo.tag == TAG_compile_unit)
547 struct dwarf1_unit* aUnit
548 = alloc_dwarf1_unit (stash);
552 aUnit->name = aDieInfo.name;
553 aUnit->low_pc = aDieInfo.low_pc;
554 aUnit->high_pc = aDieInfo.high_pc;
555 aUnit->has_stmt_list = aDieInfo.has_stmt_list;
556 aUnit->stmt_list_offset = aDieInfo.stmt_list_offset;
558 /* A die has a child if it's followed by a die that is
561 && stash->currentDie + aDieInfo.length
562 < stash->debug_section_end
563 && stash->currentDie + aDieInfo.length
564 != stash->debug_section + aDieInfo.sibling)
565 aUnit->first_child = stash->currentDie + aDieInfo.length;
567 aUnit->first_child = 0;
569 if (aUnit->low_pc <= addr && addr < aUnit->high_pc)
570 return dwarf1_unit_find_nearest_line (stash, aUnit, addr,
576 if (aDieInfo.sibling != 0)
577 stash->currentDie = stash->debug_section + aDieInfo.sibling;
579 stash->currentDie += aDieInfo.length;