[binutils.git] / bfd / dwarf1.c

/* DWARF 1 find nearest line (_bfd_dwarf1_find_nearest_line).
   Copyright 1998, 1999 Free Software Foundation, Inc.

Written by Gavin Romig-Koch of Cygnus Solutions ([email protected]).  

This file is part of BFD.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or (at
your option) any later version.

This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#include "bfd.h"
#include "sysdep.h"
#include "libiberty.h"
#include "libbfd.h"
#include "elf-bfd.h"
#include "elf/dwarf.h"

/* dwarf1_debug is the starting point for all dwarf1 info. */

struct dwarf1_debug {

  /* The bfd we are working with. */
  bfd* abfd;

  /* List of already parsed compilation units. */
  struct dwarf1_unit* lastUnit;

  /* The buffer for the .debug section. 
     Zero indicates that the .debug section failed to load. */
  char* debug_section;

  /* Pointer to the end of the .debug_info section memory buffer. */
  char* debug_section_end;

  /* The buffer for the .line section. */
  char* line_section;

  /* End of that buffer. */
  char* line_section_end;

  /* The current or next unread die within the .debug section. */
  char* currentDie;
};

/* One dwarf1_unit for each parsed compilation unit die. */

struct dwarf1_unit {
  /* Linked starting from stash->lastUnit. */
  struct dwarf1_unit* prev;

  /* Name of the compilation unit. */
  char* name;

  /* The highest and lowest address used in the compilation unit. */
  unsigned long low_pc;
  unsigned long high_pc;

  /* Does this unit have a statement list? */
  int has_stmt_list;

  /* If any, the offset of the line number table in the .line section. */
  unsigned long stmt_list_offset;

  /* If non-zero, a pointer to the first child of this unit. */
  char* first_child;

  /* How many line entries? */
  unsigned long line_count;

  /* The decoded line number table (line_count entries). */
  struct linenumber* linenumber_table;

  /* The list of functions in this unit. */
  struct dwarf1_func* func_list;
};


/* One dwarf1_func for each parsed function die.  */

struct dwarf1_func {
  /* Linked starting from aUnit->func_list. */
  struct dwarf1_func* prev;
  
  /* Name of function. */
  char* name;
  
  /* The highest and lowest address used in the compilation unit. */
  unsigned long low_pc;
  unsigned long high_pc;
};


/* Used to return info about a parsed die. */
struct die_info {
  unsigned long length;
  unsigned long sibling;
  unsigned long low_pc;
  unsigned long high_pc;
  unsigned long stmt_list_offset;
  
  char* name; 
  
  int has_stmt_list;

  unsigned short tag;
};


/* Parsed line number information. */
struct linenumber {
  /* First address in the line. */
  unsigned long addr;

  /* The line number. */
  unsigned long linenumber;
};


/* Find the form of an attr, from the attr field. */
#define FORM_FROM_ATTR(attr)	((attr) & 0xF)	/* Implicitly specified */


/* Return a newly allocated dwarf1_unit.  It should be cleared and
   then attached into the 'stash' at 'stash->lastUnit'. */

static struct dwarf1_unit*
alloc_dwarf1_unit (stash)
  struct dwarf1_debug* stash;
{
  struct dwarf1_unit* x = 
    (struct dwarf1_unit*) bfd_zalloc (stash->abfd, 
				      sizeof (struct dwarf1_unit));
  x->prev = stash->lastUnit;
  stash->lastUnit = x;

  return x;
}

/* Return a newly allocated dwarf1_func.  It must be cleared and
   attached into 'aUnit' at 'aUnit->func_list'. */

static struct dwarf1_func*
alloc_dwarf1_func (stash, aUnit)
     struct dwarf1_debug* stash;
     struct dwarf1_unit* aUnit;
{
  struct dwarf1_func* x = 
    (struct dwarf1_func*) bfd_zalloc (stash->abfd, 
				      sizeof (struct dwarf1_func));
  x->prev = aUnit->func_list;
  aUnit->func_list = x;
  
  return x;
}

/* parse_die - parse a Dwarf1 die.
   Parse the die starting at 'aDiePtr' into 'aDieInfo'.
   'abfd' must be the bfd from which the section that 'aDiePtr'
   points to was pulled from. 

   Return false if the die is invalidly formatted; true otherwise. */

static boolean
parse_die (abfd, aDieInfo, aDiePtr)
     bfd* abfd;
     struct die_info* aDieInfo;
     char*            aDiePtr;
{
  char* this_die = aDiePtr;
  char* xptr = this_die;

  memset (aDieInfo,0,sizeof(*aDieInfo));

  /* First comes the length. */
  aDieInfo->length = bfd_get_32 (abfd, xptr);
  xptr += 4;
  if (aDieInfo->length < 6)
    {
      /* Just padding bytes. */
      aDieInfo->tag = TAG_padding;
      return true;
    }

  /* Then the tag. */
  aDieInfo->tag = bfd_get_16 (abfd, xptr);
  xptr += 2;
      
  /* Then the attributes. */
  while (xptr < (this_die + aDieInfo->length))
    {
      unsigned short attr;
      
      /* Parse the attribute based on its form.  This section 
         must handle all dwarf1 forms, but need only handle the
	 actual attributes that we care about. */

      attr = bfd_get_16 (abfd, xptr);
      xptr += 2;
      
      switch (FORM_FROM_ATTR (attr))
	{
	case FORM_DATA2:
	  xptr += 2;
	  break;
	case FORM_DATA4:
	case FORM_REF:
	  if (attr == AT_sibling)
	    aDieInfo->sibling = bfd_get_32 (abfd, xptr);
	  else if (attr == AT_stmt_list)
	    {
	      aDieInfo->stmt_list_offset = bfd_get_32 (abfd, xptr);
	      aDieInfo->has_stmt_list = 1;
	    }
	  xptr += 4;
	  break;
	case FORM_DATA8:
	  xptr += 8;
	  break;
	case FORM_ADDR:
	  if (attr == AT_low_pc)
	    aDieInfo->low_pc = bfd_get_32 (abfd, xptr);
	  else if (attr == AT_high_pc)
	    aDieInfo->high_pc = bfd_get_32 (abfd, xptr);
	  xptr += 4;
	  break;
	case FORM_BLOCK2:
	  xptr += 2 + bfd_get_16 (abfd, xptr);
	  break;
	case FORM_BLOCK4:
	  xptr += 4 + bfd_get_32 (abfd, xptr);
	  break;
	case FORM_STRING:
	  if (attr == AT_name)
	    aDieInfo->name = xptr;
	  xptr += strlen (xptr) + 1;
	  break;
	}
    }

  return true;
}

/* Parse a dwarf1 line number table for 'aUnit->stmt_list_offset'
   into 'aUnit->linenumber_table'.  Return false if an error 
   occurs; true otherwise. */
  
static boolean
parse_line_table (stash, aUnit)
  struct dwarf1_debug* stash;
  struct dwarf1_unit* aUnit;
{
  char* xptr;

  /* Load the ".line" section from the bfd if we haven't already. */ 
  if (stash->line_section == 0)
    {
      asection *msec;
      unsigned long size;
      
      msec = bfd_get_section_by_name (stash->abfd, ".line");
      if (! msec)
	return false;
	  
      size = bfd_get_section_size_before_reloc (msec);
      stash->line_section = (unsigned char*) bfd_alloc (stash->abfd, size);
      
      if (! stash->line_section)
	return false;

      if (! bfd_get_section_contents (stash->abfd, msec, stash->line_section, 0, size))
	{
	  stash->line_section = 0;
	  return false;
	}

      stash->line_section_end = stash->line_section + size;
    }

  xptr = stash->line_section + aUnit->stmt_list_offset;
  if (xptr < stash->line_section_end)
    {
      unsigned long eachLine;

      char* tblend;
      unsigned long base;

      /* First comes the length. */
      tblend = bfd_get_32 (stash->abfd, xptr) + xptr;
      xptr += 4;

      /* Then the base address for each address in the table. */
      base = bfd_get_32 (stash->abfd, xptr);
      xptr += 4;

      /* How many line entrys?
	 10 = 4 (line number) + 2 (pos in line) + 4 (address in line) */
      aUnit->line_count = (tblend - xptr) / 10;

      /* Allocate an array for the entries. */
      aUnit->linenumber_table = (struct linenumber*)
	bfd_alloc (stash->abfd, 
		   sizeof (struct linenumber) * aUnit->line_count);
	
      for (eachLine = 0; eachLine < aUnit->line_count; eachLine++)
	{
	  /* A line number. */
	  aUnit->linenumber_table[eachLine].linenumber
	    = bfd_get_32 (stash->abfd, xptr);
	  xptr += 4;

	  /* Skip the position within the line. */
	  xptr += 2;

	  /* And finally the address. */
	  aUnit->linenumber_table[eachLine].addr 
	    = base + bfd_get_32 (stash->abfd, xptr);
	  xptr += 4;
	}
    }

  return true;
}

/* Parse each function die in a compilation unit 'aUnit'.
   The first child die of 'aUnit' should be in 'aUnit->first_child',
   the result is placed in 'aUnit->func_list'.
   Return false if error; true otherwise. */

static boolean
parse_functions_in_unit (stash, aUnit)
     struct dwarf1_debug* stash;
     struct dwarf1_unit* aUnit;
{
  char* eachDie;

  if (aUnit->first_child)
    for (eachDie = aUnit->first_child;
	 eachDie < stash->debug_section_end;
	 )
      {
	struct die_info eachDieInfo;
	
	if (! parse_die (stash->abfd, &eachDieInfo, eachDie))
	  return false;
	
	if (eachDieInfo.tag == TAG_global_subroutine
	    || eachDieInfo.tag == TAG_subroutine
	    || eachDieInfo.tag == TAG_inlined_subroutine
	    || eachDieInfo.tag == TAG_entry_point)
	  {
	    struct dwarf1_func* aFunc = alloc_dwarf1_func (stash,aUnit);
	    
	    aFunc->name = eachDieInfo.name;
	    aFunc->low_pc = eachDieInfo.low_pc;
	    aFunc->high_pc = eachDieInfo.high_pc;
	  }
	
	/* Move to next sibling, if none, end loop */
	if (eachDieInfo.sibling)
	  eachDie = stash->debug_section + eachDieInfo.sibling;
	else
	  break;
      }
  
  return true;
}

/* Find the nearest line to 'addr' in 'aUnit'.
   Return whether we found the line (or a function) without error. */

static boolean
dwarf1_unit_find_nearest_line (stash, aUnit, addr, 
		       filename_ptr, functionname_ptr,
		       linenumber_ptr)
  struct dwarf1_debug* stash;
  struct dwarf1_unit* aUnit;
  unsigned long addr;
  const char **filename_ptr;
  const char **functionname_ptr;
  unsigned int *linenumber_ptr;
{
  int line_p = false;
  int func_p = false;

  if (aUnit->low_pc <= addr && addr < aUnit->high_pc)
    {
      if (aUnit->has_stmt_list)
	{
	  unsigned long i;
	  struct dwarf1_func* eachFunc;

	  if (! aUnit->linenumber_table)
	    {
	      if (! parse_line_table (stash, aUnit))
		return false;
	    }

	  if (! aUnit->func_list)
	    {
	      if (! parse_functions_in_unit (stash, aUnit))
		return false;
	    }

	  for (i = 0; i < aUnit->line_count; i++)
	    {
	      if (aUnit->linenumber_table[i].addr <= addr
		  && addr < aUnit->linenumber_table[i+1].addr)
		{
		  *filename_ptr = aUnit->name;
		  *linenumber_ptr = aUnit->linenumber_table[i].linenumber;
		  line_p = true;
		  break;
		}
	    }

	  for (eachFunc = aUnit->func_list; 
	       eachFunc; 
	       eachFunc = eachFunc->prev)
	    {
	      if (eachFunc->low_pc <= addr
		  && addr < eachFunc->high_pc)
		{
		  *functionname_ptr = eachFunc->name;
		  func_p = true;
		  break;
		}
	    }
	}
    }

  return line_p || func_p;
}


/* The DWARF 1 version of find_nearest line.
   Return true if the line is found without error. */

boolean
_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
                              filename_ptr, functionname_ptr, linenumber_ptr)
     bfd *abfd;
     asection *section;
     asymbol **symbols ATTRIBUTE_UNUSED;
     bfd_vma offset;
     const char **filename_ptr;
     const char **functionname_ptr;
     unsigned int *linenumber_ptr;
{
  struct dwarf1_debug *stash = elf_tdata (abfd)->dwarf1_find_line_info;

  struct dwarf1_unit* eachUnit;

  /* What address are we looking for? */
  bfd_vma addr = offset + section->vma;

  *filename_ptr = NULL;
  *functionname_ptr = NULL;
  *linenumber_ptr = 0;
  

  if (! stash)
    {
      asection *msec;
      unsigned long size;
      
      stash = elf_tdata (abfd)->dwarf1_find_line_info =
	(struct dwarf1_debug*) bfd_zalloc (abfd, sizeof (struct dwarf1_debug));
      
      if (! stash)
	return false;
      
      msec = bfd_get_section_by_name (abfd, ".debug");
      if (! msec)
	{
	  /* No dwarf1 info.  Note that at this point the stash
	     has been allocated, but contains zeros, this lets
	     future calls to this function fail quicker. */
	  return false;
	}

      size = bfd_get_section_size_before_reloc (msec);
      stash->debug_section = (unsigned char*) bfd_alloc (abfd, size);
      
      if (! stash->debug_section)
	return false;

      if (! bfd_get_section_contents (abfd, msec, stash->debug_section, 0, size))
	{
	  stash->debug_section = 0;
	  return false;
	}

      stash->debug_section_end = stash->debug_section + size;
      stash->currentDie = stash->debug_section;
      stash->abfd = abfd;
    }

  /* A null debug_section indicates that there was no dwarf1 info
     or that an error occured while setting up the stash. */

  if (! stash->debug_section)
    return false;
  

  /* Look at the previously parsed units to see if any contain
     the addr. */
  for (eachUnit = stash->lastUnit; eachUnit; eachUnit = eachUnit->prev)
    {
      if (eachUnit->low_pc <= addr && addr < eachUnit->high_pc)
	return dwarf1_unit_find_nearest_line (stash, eachUnit, addr,
					      filename_ptr, 
					      functionname_ptr, 
					      linenumber_ptr);
    }

  while (stash->currentDie < stash->debug_section_end)
    {
      struct die_info aDieInfo;

      if (! parse_die (stash->abfd, &aDieInfo, stash->currentDie))
	return false;
      
      if (aDieInfo.tag == TAG_compile_unit)
	{
	  struct dwarf1_unit* aUnit
	    = alloc_dwarf1_unit (stash);
	  
	  aUnit->name = aDieInfo.name;
	  aUnit->low_pc = aDieInfo.low_pc;
	  aUnit->high_pc = aDieInfo.high_pc;
	  aUnit->has_stmt_list = aDieInfo.has_stmt_list;
	  aUnit->stmt_list_offset = aDieInfo.stmt_list_offset;
	  
	  /* A die has a child if it's followed by a die that is
	     not it's sibling. */
	  if (aDieInfo.sibling 
	      && stash->currentDie + aDieInfo.length 
                    < stash->debug_section_end
	      && stash->currentDie + aDieInfo.length 
	            != stash->debug_section + aDieInfo.sibling)
	    aUnit->first_child = stash->currentDie + aDieInfo.length;
	  else
	    aUnit->first_child = 0;

	  if (aUnit->low_pc <= addr && addr < aUnit->high_pc)
	    return dwarf1_unit_find_nearest_line (stash, aUnit, addr, 
						  filename_ptr, 
						  functionname_ptr, 
						  linenumber_ptr);
	}
      
      if (aDieInfo.sibling != 0)
	stash->currentDie = stash->debug_section + aDieInfo.sibling;
      else
	stash->currentDie += aDieInfo.length;
    }

  return false;
}


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