1/* DWARF 1 find nearest line (_bfd_dwarf1_find_nearest_line).
2   Copyright 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2007
3   Free Software Foundation, Inc.
4
5   Written by Gavin Romig-Koch of Cygnus Solutions (gavin@cygnus.com).
6
7   This file is part of BFD.
8
9   This program is free software; you can redistribute it and/or modify
10   it under the terms of the GNU General Public License as published by
11   the Free Software Foundation; either version 2 of the License, or (at
12   your option) any later version.
13
14   This program is distributed in the hope that it will be useful, but
15   WITHOUT ANY WARRANTY; without even the implied warranty of
16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17   General Public License for more details.
18
19   You should have received a copy of the GNU General Public License
20   along with this program; if not, write to the Free Software
21   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
22
23#include "sysdep.h"
24#include "bfd.h"
25#include "libiberty.h"
26#include "libbfd.h"
27#include "elf-bfd.h"
28#include "elf/dwarf.h"
29
30/* dwarf1_debug is the starting point for all dwarf1 info.  */
31
32struct dwarf1_debug
33{
34  /* The bfd we are working with.  */
35  bfd* abfd;
36
37  /* List of already parsed compilation units.  */
38  struct dwarf1_unit* lastUnit;
39
40  /* The buffer for the .debug section.
41     Zero indicates that the .debug section failed to load.  */
42  char* debug_section;
43
44  /* Pointer to the end of the .debug_info section memory buffer.  */
45  char* debug_section_end;
46
47  /* The buffer for the .line section.  */
48  char* line_section;
49
50  /* End of that buffer.  */
51  char* line_section_end;
52
53  /* The current or next unread die within the .debug section.  */
54  char* currentDie;
55};
56
57/* One dwarf1_unit for each parsed compilation unit die.  */
58
59struct dwarf1_unit
60{
61  /* Linked starting from stash->lastUnit.  */
62  struct dwarf1_unit* prev;
63
64  /* Name of the compilation unit.  */
65  char* name;
66
67  /* The highest and lowest address used in the compilation unit.  */
68  unsigned long low_pc;
69  unsigned long high_pc;
70
71  /* Does this unit have a statement list?  */
72  int has_stmt_list;
73
74  /* If any, the offset of the line number table in the .line section.  */
75  unsigned long stmt_list_offset;
76
77  /* If non-zero, a pointer to the first child of this unit.  */
78  char* first_child;
79
80  /* How many line entries?  */
81  unsigned long line_count;
82
83  /* The decoded line number table (line_count entries).  */
84  struct linenumber* linenumber_table;
85
86  /* The list of functions in this unit.  */
87  struct dwarf1_func* func_list;
88};
89
90/* One dwarf1_func for each parsed function die.  */
91
92struct dwarf1_func
93{
94  /* Linked starting from aUnit->func_list.  */
95  struct dwarf1_func* prev;
96
97  /* Name of function.  */
98  char* name;
99
100  /* The highest and lowest address used in the compilation unit.  */
101  unsigned long low_pc;
102  unsigned long high_pc;
103};
104
105/* Used to return info about a parsed die.  */
106struct die_info
107{
108  unsigned long length;
109  unsigned long sibling;
110  unsigned long low_pc;
111  unsigned long high_pc;
112  unsigned long stmt_list_offset;
113
114  char* name;
115
116  int has_stmt_list;
117
118  unsigned short tag;
119};
120
121/* Parsed line number information.  */
122struct linenumber
123{
124  /* First address in the line.  */
125  unsigned long addr;
126
127  /* The line number.  */
128  unsigned long linenumber;
129};
130
131/* Find the form of an attr, from the attr field.  */
132#define FORM_FROM_ATTR(attr)	((attr) & 0xF)	/* Implicitly specified.  */
133
134/* Return a newly allocated dwarf1_unit.  It should be cleared and
135   then attached into the 'stash' at 'stash->lastUnit'.  */
136
137static struct dwarf1_unit*
138alloc_dwarf1_unit (struct dwarf1_debug* stash)
139{
140  bfd_size_type amt = sizeof (struct dwarf1_unit);
141
142  struct dwarf1_unit* x = bfd_zalloc (stash->abfd, amt);
143  x->prev = stash->lastUnit;
144  stash->lastUnit = x;
145
146  return x;
147}
148
149/* Return a newly allocated dwarf1_func.  It must be cleared and
150   attached into 'aUnit' at 'aUnit->func_list'.  */
151
152static struct dwarf1_func *
153alloc_dwarf1_func (struct dwarf1_debug* stash, struct dwarf1_unit* aUnit)
154{
155  bfd_size_type amt = sizeof (struct dwarf1_func);
156
157  struct dwarf1_func* x = bfd_zalloc (stash->abfd, amt);
158  x->prev = aUnit->func_list;
159  aUnit->func_list = x;
160
161  return x;
162}
163
164/* parse_die - parse a Dwarf1 die.
165   Parse the die starting at 'aDiePtr' into 'aDieInfo'.
166   'abfd' must be the bfd from which the section that 'aDiePtr'
167   points to was pulled from.
168
169   Return FALSE if the die is invalidly formatted; TRUE otherwise.  */
170
171static bfd_boolean
172parse_die (bfd *             abfd,
173	   struct die_info * aDieInfo,
174	   char *            aDiePtr,
175	   char *            aDiePtrEnd)
176{
177  char* this_die = aDiePtr;
178  char* xptr = this_die;
179
180  memset (aDieInfo, 0, sizeof (* aDieInfo));
181
182  /* First comes the length.  */
183  aDieInfo->length = bfd_get_32 (abfd, (bfd_byte *) xptr);
184  xptr += 4;
185  if (aDieInfo->length == 0
186      || (this_die + aDieInfo->length) >= aDiePtrEnd)
187    return FALSE;
188  if (aDieInfo->length < 6)
189    {
190      /* Just padding bytes.  */
191      aDieInfo->tag = TAG_padding;
192      return TRUE;
193    }
194
195  /* Then the tag.  */
196  aDieInfo->tag = bfd_get_16 (abfd, (bfd_byte *) xptr);
197  xptr += 2;
198
199  /* Then the attributes.  */
200  while (xptr < (this_die + aDieInfo->length))
201    {
202      unsigned short attr;
203
204      /* Parse the attribute based on its form.  This section
205         must handle all dwarf1 forms, but need only handle the
206	 actual attributes that we care about.  */
207      attr = bfd_get_16 (abfd, (bfd_byte *) xptr);
208      xptr += 2;
209
210      switch (FORM_FROM_ATTR (attr))
211	{
212	case FORM_DATA2:
213	  xptr += 2;
214	  break;
215	case FORM_DATA4:
216	case FORM_REF:
217	  if (attr == AT_sibling)
218	    aDieInfo->sibling = bfd_get_32 (abfd, (bfd_byte *) xptr);
219	  else if (attr == AT_stmt_list)
220	    {
221	      aDieInfo->stmt_list_offset = bfd_get_32 (abfd, (bfd_byte *) xptr);
222	      aDieInfo->has_stmt_list = 1;
223	    }
224	  xptr += 4;
225	  break;
226	case FORM_DATA8:
227	  xptr += 8;
228	  break;
229	case FORM_ADDR:
230	  if (attr == AT_low_pc)
231	    aDieInfo->low_pc = bfd_get_32 (abfd, (bfd_byte *) xptr);
232	  else if (attr == AT_high_pc)
233	    aDieInfo->high_pc = bfd_get_32 (abfd, (bfd_byte *) xptr);
234	  xptr += 4;
235	  break;
236	case FORM_BLOCK2:
237	  xptr += 2 + bfd_get_16 (abfd, (bfd_byte *) xptr);
238	  break;
239	case FORM_BLOCK4:
240	  xptr += 4 + bfd_get_32 (abfd, (bfd_byte *) xptr);
241	  break;
242	case FORM_STRING:
243	  if (attr == AT_name)
244	    aDieInfo->name = xptr;
245	  xptr += strlen (xptr) + 1;
246	  break;
247	}
248    }
249
250  return TRUE;
251}
252
253/* Parse a dwarf1 line number table for 'aUnit->stmt_list_offset'
254   into 'aUnit->linenumber_table'.  Return FALSE if an error
255   occurs; TRUE otherwise.  */
256
257static bfd_boolean
258parse_line_table (struct dwarf1_debug* stash, struct dwarf1_unit* aUnit)
259{
260  char* xptr;
261
262  /* Load the ".line" section from the bfd if we haven't already.  */
263  if (stash->line_section == 0)
264    {
265      asection *msec;
266      bfd_size_type size;
267
268      msec = bfd_get_section_by_name (stash->abfd, ".line");
269      if (! msec)
270	return FALSE;
271
272      size = msec->rawsize ? msec->rawsize : msec->size;
273      stash->line_section = bfd_alloc (stash->abfd, size);
274
275      if (! stash->line_section)
276	return FALSE;
277
278      if (! bfd_get_section_contents (stash->abfd, msec, stash->line_section,
279				      0, size))
280	{
281	  stash->line_section = 0;
282	  return FALSE;
283	}
284
285      stash->line_section_end = stash->line_section + size;
286    }
287
288  xptr = stash->line_section + aUnit->stmt_list_offset;
289  if (xptr < stash->line_section_end)
290    {
291      unsigned long eachLine;
292      char *tblend;
293      unsigned long base;
294      bfd_size_type amt;
295
296      /* First comes the length.  */
297      tblend = bfd_get_32 (stash->abfd, (bfd_byte *) xptr) + xptr;
298      xptr += 4;
299
300      /* Then the base address for each address in the table.  */
301      base = bfd_get_32 (stash->abfd, (bfd_byte *) xptr);
302      xptr += 4;
303
304      /* How many line entrys?
305	 10 = 4 (line number) + 2 (pos in line) + 4 (address in line).  */
306      aUnit->line_count = (tblend - xptr) / 10;
307
308      /* Allocate an array for the entries.  */
309      amt = sizeof (struct linenumber) * aUnit->line_count;
310      aUnit->linenumber_table = bfd_alloc (stash->abfd, amt);
311
312      for (eachLine = 0; eachLine < aUnit->line_count; eachLine++)
313	{
314	  /* A line number.  */
315	  aUnit->linenumber_table[eachLine].linenumber
316	    = bfd_get_32 (stash->abfd, (bfd_byte *) xptr);
317	  xptr += 4;
318
319	  /* Skip the position within the line.  */
320	  xptr += 2;
321
322	  /* And finally the address.  */
323	  aUnit->linenumber_table[eachLine].addr
324	    = base + bfd_get_32 (stash->abfd, (bfd_byte *) xptr);
325	  xptr += 4;
326	}
327    }
328
329  return TRUE;
330}
331
332/* Parse each function die in a compilation unit 'aUnit'.
333   The first child die of 'aUnit' should be in 'aUnit->first_child',
334   the result is placed in 'aUnit->func_list'.
335   Return FALSE if error; TRUE otherwise.  */
336
337static bfd_boolean
338parse_functions_in_unit (struct dwarf1_debug* stash, struct dwarf1_unit* aUnit)
339{
340  char* eachDie;
341
342  if (aUnit->first_child)
343    for (eachDie = aUnit->first_child;
344 	 eachDie < stash->debug_section_end;
345	 )
346      {
347	struct die_info eachDieInfo;
348
349	if (! parse_die (stash->abfd, &eachDieInfo, eachDie,
350			 stash->debug_section_end))
351	  return FALSE;
352
353	if (eachDieInfo.tag == TAG_global_subroutine
354	    || eachDieInfo.tag == TAG_subroutine
355	    || eachDieInfo.tag == TAG_inlined_subroutine
356	    || eachDieInfo.tag == TAG_entry_point)
357	  {
358	    struct dwarf1_func* aFunc = alloc_dwarf1_func (stash,aUnit);
359
360	    aFunc->name = eachDieInfo.name;
361	    aFunc->low_pc = eachDieInfo.low_pc;
362	    aFunc->high_pc = eachDieInfo.high_pc;
363	  }
364
365	/* Move to next sibling, if none, end loop */
366	if (eachDieInfo.sibling)
367	  eachDie = stash->debug_section + eachDieInfo.sibling;
368	else
369	  break;
370      }
371
372  return TRUE;
373}
374
375/* Find the nearest line to 'addr' in 'aUnit'.
376   Return whether we found the line (or a function) without error.  */
377
378static bfd_boolean
379dwarf1_unit_find_nearest_line (struct dwarf1_debug* stash,
380			       struct dwarf1_unit* aUnit,
381			       unsigned long addr,
382			       const char **filename_ptr,
383			       const char **functionname_ptr,
384			       unsigned int *linenumber_ptr)
385{
386  int line_p = FALSE;
387  int func_p = FALSE;
388
389  if (aUnit->low_pc <= addr && addr < aUnit->high_pc)
390    {
391      if (aUnit->has_stmt_list)
392	{
393	  unsigned long i;
394	  struct dwarf1_func* eachFunc;
395
396	  if (! aUnit->linenumber_table)
397	    {
398	      if (! parse_line_table (stash, aUnit))
399		return FALSE;
400	    }
401
402	  if (! aUnit->func_list)
403	    {
404	      if (! parse_functions_in_unit (stash, aUnit))
405		return FALSE;
406	    }
407
408	  for (i = 0; i < aUnit->line_count; i++)
409	    {
410	      if (aUnit->linenumber_table[i].addr <= addr
411		  && addr < aUnit->linenumber_table[i+1].addr)
412		{
413		  *filename_ptr = aUnit->name;
414		  *linenumber_ptr = aUnit->linenumber_table[i].linenumber;
415		  line_p = TRUE;
416		  break;
417		}
418	    }
419
420	  for (eachFunc = aUnit->func_list;
421	       eachFunc;
422	       eachFunc = eachFunc->prev)
423	    {
424	      if (eachFunc->low_pc <= addr
425		  && addr < eachFunc->high_pc)
426		{
427		  *functionname_ptr = eachFunc->name;
428		  func_p = TRUE;
429		  break;
430		}
431	    }
432	}
433    }
434
435  return line_p || func_p;
436}
437
438/* The DWARF 1 version of find_nearest line.
439   Return TRUE if the line is found without error.  */
440
441bfd_boolean
442_bfd_dwarf1_find_nearest_line (bfd *abfd,
443			       asection *section,
444			       asymbol **symbols ATTRIBUTE_UNUSED,
445			       bfd_vma offset,
446			       const char **filename_ptr,
447			       const char **functionname_ptr,
448			       unsigned int *linenumber_ptr)
449{
450  struct dwarf1_debug *stash = elf_tdata (abfd)->dwarf1_find_line_info;
451
452  struct dwarf1_unit* eachUnit;
453
454  /* What address are we looking for? */
455  unsigned long addr = (unsigned long)(offset + section->vma);
456
457  *filename_ptr = NULL;
458  *functionname_ptr = NULL;
459  *linenumber_ptr = 0;
460
461  if (! stash)
462    {
463      asection *msec;
464      bfd_size_type size = sizeof (struct dwarf1_debug);
465
466      stash = elf_tdata (abfd)->dwarf1_find_line_info
467	= bfd_zalloc (abfd, size);
468
469      if (! stash)
470	return FALSE;
471
472      msec = bfd_get_section_by_name (abfd, ".debug");
473      if (! msec)
474	/* No dwarf1 info.  Note that at this point the stash
475	   has been allocated, but contains zeros, this lets
476	   future calls to this function fail quicker.  */
477	return FALSE;
478
479      size = msec->rawsize ? msec->rawsize : msec->size;
480      stash->debug_section = bfd_alloc (abfd, size);
481
482      if (! stash->debug_section)
483	return FALSE;
484
485      if (! bfd_get_section_contents (abfd, msec, stash->debug_section,
486				      0, size))
487	{
488	  stash->debug_section = 0;
489	  return FALSE;
490	}
491
492      stash->debug_section_end = stash->debug_section + size;
493      stash->currentDie = stash->debug_section;
494      stash->abfd = abfd;
495    }
496
497  /* A null debug_section indicates that there was no dwarf1 info
498     or that an error occured while setting up the stash.  */
499
500  if (! stash->debug_section)
501    return FALSE;
502
503  /* Look at the previously parsed units to see if any contain
504     the addr.  */
505  for (eachUnit = stash->lastUnit; eachUnit; eachUnit = eachUnit->prev)
506    if (eachUnit->low_pc <= addr && addr < eachUnit->high_pc)
507      return dwarf1_unit_find_nearest_line (stash, eachUnit, addr,
508					    filename_ptr,
509					    functionname_ptr,
510					    linenumber_ptr);
511
512  while (stash->currentDie < stash->debug_section_end)
513    {
514      struct die_info aDieInfo;
515
516      if (! parse_die (stash->abfd, &aDieInfo, stash->currentDie,
517		       stash->debug_section_end))
518	return FALSE;
519
520      if (aDieInfo.tag == TAG_compile_unit)
521	{
522	  struct dwarf1_unit* aUnit
523	    = alloc_dwarf1_unit (stash);
524
525	  aUnit->name = aDieInfo.name;
526	  aUnit->low_pc = aDieInfo.low_pc;
527	  aUnit->high_pc = aDieInfo.high_pc;
528	  aUnit->has_stmt_list = aDieInfo.has_stmt_list;
529	  aUnit->stmt_list_offset = aDieInfo.stmt_list_offset;
530
531	  /* A die has a child if it's followed by a die that is
532	     not it's sibling.  */
533	  if (aDieInfo.sibling
534	      && stash->currentDie + aDieInfo.length
535                    < stash->debug_section_end
536	      && stash->currentDie + aDieInfo.length
537	            != stash->debug_section + aDieInfo.sibling)
538	    aUnit->first_child = stash->currentDie + aDieInfo.length;
539	  else
540	    aUnit->first_child = 0;
541
542	  if (aUnit->low_pc <= addr && addr < aUnit->high_pc)
543	    return dwarf1_unit_find_nearest_line (stash, aUnit, addr,
544						  filename_ptr,
545						  functionname_ptr,
546						  linenumber_ptr);
547	}
548
549      if (aDieInfo.sibling != 0)
550	stash->currentDie = stash->debug_section + aDieInfo.sibling;
551      else
552	stash->currentDie += aDieInfo.length;
553    }
554
555  return FALSE;
556}
557