1 /* DWARF 1 find nearest line (_bfd_dwarf1_find_nearest_line).
2 Copyright 1998, 1999, 2000, 2001 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;
88 /* One dwarf1_func for each parsed function die. */
91 /* Linked starting from aUnit->func_list. */
92 struct dwarf1_func* prev;
94 /* Name of function. */
97 /* The highest and lowest address used in the compilation unit. */
99 unsigned long high_pc;
102 /* Used to return info about a parsed die. */
104 unsigned long length;
105 unsigned long sibling;
106 unsigned long low_pc;
107 unsigned long high_pc;
108 unsigned long stmt_list_offset;
117 /* Parsed line number information. */
119 /* First address in the line. */
122 /* The line number. */
123 unsigned long linenumber;
126 /* Find the form of an attr, from the attr field. */
127 #define FORM_FROM_ATTR(attr) ((attr) & 0xF) /* Implicitly specified */
129 static struct dwarf1_unit *alloc_dwarf1_unit PARAMS ((struct dwarf1_debug *));
130 static struct dwarf1_func *alloc_dwarf1_func
131 PARAMS ((struct dwarf1_debug *, struct dwarf1_unit *));
132 static boolean parse_die PARAMS ((bfd *, struct die_info *, char *, char *));
133 static boolean parse_line_table
134 PARAMS ((struct dwarf1_debug *, struct dwarf1_unit *));
135 static boolean parse_functions_in_unit
136 PARAMS ((struct dwarf1_debug *, struct dwarf1_unit *));
137 static boolean dwarf1_unit_find_nearest_line
138 PARAMS ((struct dwarf1_debug *, struct dwarf1_unit *, unsigned long,
139 const char **, const char **, unsigned int *));
141 /* Return a newly allocated dwarf1_unit. It should be cleared and
142 then attached into the 'stash' at 'stash->lastUnit'. */
144 static struct dwarf1_unit*
145 alloc_dwarf1_unit (stash)
146 struct dwarf1_debug* stash;
148 struct dwarf1_unit* x =
149 (struct dwarf1_unit*) bfd_zalloc (stash->abfd,
150 sizeof (struct dwarf1_unit));
151 x->prev = stash->lastUnit;
157 /* Return a newly allocated dwarf1_func. It must be cleared and
158 attached into 'aUnit' at 'aUnit->func_list'. */
160 static struct dwarf1_func*
161 alloc_dwarf1_func (stash, aUnit)
162 struct dwarf1_debug* stash;
163 struct dwarf1_unit* aUnit;
165 struct dwarf1_func* x =
166 (struct dwarf1_func*) bfd_zalloc (stash->abfd,
167 sizeof (struct dwarf1_func));
168 x->prev = aUnit->func_list;
169 aUnit->func_list = x;
174 /* parse_die - parse a Dwarf1 die.
175 Parse the die starting at 'aDiePtr' into 'aDieInfo'.
176 'abfd' must be the bfd from which the section that 'aDiePtr'
177 points to was pulled from.
179 Return false if the die is invalidly formatted; true otherwise. */
182 parse_die (abfd, aDieInfo, aDiePtr, aDiePtrEnd)
184 struct die_info* aDieInfo;
188 char* this_die = aDiePtr;
189 char* xptr = this_die;
191 memset (aDieInfo,0,sizeof (*aDieInfo));
193 /* First comes the length. */
194 aDieInfo->length = bfd_get_32 (abfd, (bfd_byte *) xptr);
196 if (aDieInfo->length == 0
197 || (this_die + aDieInfo->length) >= aDiePtrEnd)
199 if (aDieInfo->length < 6)
201 /* Just padding bytes. */
202 aDieInfo->tag = TAG_padding;
207 aDieInfo->tag = bfd_get_16 (abfd, (bfd_byte *) xptr);
210 /* Then the attributes. */
211 while (xptr < (this_die + aDieInfo->length))
215 /* Parse the attribute based on its form. This section
216 must handle all dwarf1 forms, but need only handle the
217 actual attributes that we care about. */
219 attr = bfd_get_16 (abfd, (bfd_byte *) xptr);
222 switch (FORM_FROM_ATTR (attr))
229 if (attr == AT_sibling)
230 aDieInfo->sibling = bfd_get_32 (abfd, (bfd_byte *) xptr);
231 else if (attr == AT_stmt_list)
233 aDieInfo->stmt_list_offset = bfd_get_32 (abfd, (bfd_byte *) xptr);
234 aDieInfo->has_stmt_list = 1;
242 if (attr == AT_low_pc)
243 aDieInfo->low_pc = bfd_get_32 (abfd, (bfd_byte *) xptr);
244 else if (attr == AT_high_pc)
245 aDieInfo->high_pc = bfd_get_32 (abfd, (bfd_byte *) xptr);
249 xptr += 2 + bfd_get_16 (abfd, (bfd_byte *) xptr);
252 xptr += 4 + bfd_get_32 (abfd, (bfd_byte *) xptr);
256 aDieInfo->name = xptr;
257 xptr += strlen (xptr) + 1;
265 /* Parse a dwarf1 line number table for 'aUnit->stmt_list_offset'
266 into 'aUnit->linenumber_table'. Return false if an error
267 occurs; true otherwise. */
270 parse_line_table (stash, aUnit)
271 struct dwarf1_debug* stash;
272 struct dwarf1_unit* aUnit;
276 /* Load the ".line" section from the bfd if we haven't already. */
277 if (stash->line_section == 0)
282 msec = bfd_get_section_by_name (stash->abfd, ".line");
286 size = bfd_get_section_size_before_reloc (msec);
287 stash->line_section = (char *) bfd_alloc (stash->abfd, size);
289 if (! stash->line_section)
292 if (! bfd_get_section_contents (stash->abfd, msec, stash->line_section, 0, size))
294 stash->line_section = 0;
298 stash->line_section_end = stash->line_section + size;
301 xptr = stash->line_section + aUnit->stmt_list_offset;
302 if (xptr < stash->line_section_end)
304 unsigned long eachLine;
309 /* First comes the length. */
310 tblend = bfd_get_32 (stash->abfd, (bfd_byte *) xptr) + xptr;
313 /* Then the base address for each address in the table. */
314 base = bfd_get_32 (stash->abfd, (bfd_byte *) xptr);
317 /* How many line entrys?
318 10 = 4 (line number) + 2 (pos in line) + 4 (address in line) */
319 aUnit->line_count = (tblend - xptr) / 10;
321 /* Allocate an array for the entries. */
322 aUnit->linenumber_table = (struct linenumber *)
323 bfd_alloc (stash->abfd,
324 sizeof (struct linenumber) * aUnit->line_count);
326 for (eachLine = 0; eachLine < aUnit->line_count; eachLine++)
329 aUnit->linenumber_table[eachLine].linenumber
330 = bfd_get_32 (stash->abfd, (bfd_byte *) xptr);
333 /* Skip the position within the line. */
336 /* And finally the address. */
337 aUnit->linenumber_table[eachLine].addr
338 = base + bfd_get_32 (stash->abfd, (bfd_byte *) xptr);
346 /* Parse each function die in a compilation unit 'aUnit'.
347 The first child die of 'aUnit' should be in 'aUnit->first_child',
348 the result is placed in 'aUnit->func_list'.
349 Return false if error; true otherwise. */
352 parse_functions_in_unit (stash, aUnit)
353 struct dwarf1_debug* stash;
354 struct dwarf1_unit* aUnit;
358 if (aUnit->first_child)
359 for (eachDie = aUnit->first_child;
360 eachDie < stash->debug_section_end;
363 struct die_info eachDieInfo;
365 if (! parse_die (stash->abfd, &eachDieInfo, eachDie,
366 stash->debug_section_end))
369 if (eachDieInfo.tag == TAG_global_subroutine
370 || eachDieInfo.tag == TAG_subroutine
371 || eachDieInfo.tag == TAG_inlined_subroutine
372 || eachDieInfo.tag == TAG_entry_point)
374 struct dwarf1_func* aFunc = alloc_dwarf1_func (stash,aUnit);
376 aFunc->name = eachDieInfo.name;
377 aFunc->low_pc = eachDieInfo.low_pc;
378 aFunc->high_pc = eachDieInfo.high_pc;
381 /* Move to next sibling, if none, end loop */
382 if (eachDieInfo.sibling)
383 eachDie = stash->debug_section + eachDieInfo.sibling;
391 /* Find the nearest line to 'addr' in 'aUnit'.
392 Return whether we found the line (or a function) without error. */
395 dwarf1_unit_find_nearest_line (stash, aUnit, addr,
396 filename_ptr, functionname_ptr,
398 struct dwarf1_debug* stash;
399 struct dwarf1_unit* aUnit;
401 const char **filename_ptr;
402 const char **functionname_ptr;
403 unsigned int *linenumber_ptr;
408 if (aUnit->low_pc <= addr && addr < aUnit->high_pc)
410 if (aUnit->has_stmt_list)
413 struct dwarf1_func* eachFunc;
415 if (! aUnit->linenumber_table)
417 if (! parse_line_table (stash, aUnit))
421 if (! aUnit->func_list)
423 if (! parse_functions_in_unit (stash, aUnit))
427 for (i = 0; i < aUnit->line_count; i++)
429 if (aUnit->linenumber_table[i].addr <= addr
430 && addr < aUnit->linenumber_table[i+1].addr)
432 *filename_ptr = aUnit->name;
433 *linenumber_ptr = aUnit->linenumber_table[i].linenumber;
439 for (eachFunc = aUnit->func_list;
441 eachFunc = eachFunc->prev)
443 if (eachFunc->low_pc <= addr
444 && addr < eachFunc->high_pc)
446 *functionname_ptr = eachFunc->name;
454 return line_p || func_p;
457 /* The DWARF 1 version of find_nearest line.
458 Return true if the line is found without error. */
461 _bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
462 filename_ptr, functionname_ptr, linenumber_ptr)
465 asymbol **symbols ATTRIBUTE_UNUSED;
467 const char **filename_ptr;
468 const char **functionname_ptr;
469 unsigned int *linenumber_ptr;
471 struct dwarf1_debug *stash = elf_tdata (abfd)->dwarf1_find_line_info;
473 struct dwarf1_unit* eachUnit;
475 /* What address are we looking for? */
476 unsigned long addr = (unsigned long)(offset + section->vma);
478 *filename_ptr = NULL;
479 *functionname_ptr = NULL;
487 stash = elf_tdata (abfd)->dwarf1_find_line_info =
488 (struct dwarf1_debug*) bfd_zalloc (abfd, sizeof (struct dwarf1_debug));
493 msec = bfd_get_section_by_name (abfd, ".debug");
496 /* No dwarf1 info. Note that at this point the stash
497 has been allocated, but contains zeros, this lets
498 future calls to this function fail quicker. */
502 size = bfd_get_section_size_before_reloc (msec);
503 stash->debug_section = (char *) bfd_alloc (abfd, size);
505 if (! stash->debug_section)
508 if (! bfd_get_section_contents (abfd, msec, stash->debug_section, 0, size))
510 stash->debug_section = 0;
514 stash->debug_section_end = stash->debug_section + size;
515 stash->currentDie = stash->debug_section;
519 /* A null debug_section indicates that there was no dwarf1 info
520 or that an error occured while setting up the stash. */
522 if (! stash->debug_section)
525 /* Look at the previously parsed units to see if any contain
527 for (eachUnit = stash->lastUnit; eachUnit; eachUnit = eachUnit->prev)
529 if (eachUnit->low_pc <= addr && addr < eachUnit->high_pc)
530 return dwarf1_unit_find_nearest_line (stash, eachUnit, addr,
536 while (stash->currentDie < stash->debug_section_end)
538 struct die_info aDieInfo;
540 if (! parse_die (stash->abfd, &aDieInfo, stash->currentDie,
541 stash->debug_section_end))
544 if (aDieInfo.tag == TAG_compile_unit)
546 struct dwarf1_unit* aUnit
547 = alloc_dwarf1_unit (stash);
549 aUnit->name = aDieInfo.name;
550 aUnit->low_pc = aDieInfo.low_pc;
551 aUnit->high_pc = aDieInfo.high_pc;
552 aUnit->has_stmt_list = aDieInfo.has_stmt_list;
553 aUnit->stmt_list_offset = aDieInfo.stmt_list_offset;
555 /* A die has a child if it's followed by a die that is
558 && stash->currentDie + aDieInfo.length
559 < stash->debug_section_end
560 && stash->currentDie + aDieInfo.length
561 != stash->debug_section + aDieInfo.sibling)
562 aUnit->first_child = stash->currentDie + aDieInfo.length;
564 aUnit->first_child = 0;
566 if (aUnit->low_pc <= addr && addr < aUnit->high_pc)
567 return dwarf1_unit_find_nearest_line (stash, aUnit, addr,
573 if (aDieInfo.sibling != 0)
574 stash->currentDie = stash->debug_section + aDieInfo.sibling;
576 stash->currentDie += aDieInfo.length;