2000-11-16 Kazu Hirata <kazu@hxi.com>

	* dwarf1.c: Fix formatting.
	* dwarf2.c: Likewise.

3 files changed, 172 insertions, 179 deletions

diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index 89d0835..ae2c846 100644
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,3 +1,8 @@
+2000-11-16  Kazu Hirata  <kazu@hxi.com>
+
+	* dwarf1.c: Fix formatting.
+	* dwarf2.c: Likewise.
+
 2000-11-15  Kazu Hirata  <kazu@hxi.com>
 
 	* coff-arm.c: Fix formatting.
diff --git a/bfd/dwarf1.c b/bfd/dwarf1.c
index 62a3a61..b96adc5 100644
--- a/bfd/dwarf1.c
+++ b/bfd/dwarf1.c
@@ -1,7 +1,7 @@
 /* DWARF 1 find nearest line (_bfd_dwarf1_find_nearest_line).
    Copyright 1998, 1999, 2000 Free Software Foundation, Inc.
 
-Written by Gavin Romig-Koch of Cygnus Solutions (gavin@cygnus.com).  
+Written by Gavin Romig-Koch of Cygnus Solutions (gavin@cygnus.com).
 
 This file is part of BFD.
 
@@ -26,121 +26,115 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "elf-bfd.h"
 #include "elf/dwarf.h"
 
-/* dwarf1_debug is the starting point for all dwarf1 info. */
+/* dwarf1_debug is the starting point for all dwarf1 info.  */
 
 struct dwarf1_debug {
 
-  /* The bfd we are working with. */
+  /* The bfd we are working with.  */
   bfd* abfd;
 
-  /* List of already parsed compilation units. */
+  /* 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. */
+  /* 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. */
+  /* Pointer to the end of the .debug_info section memory buffer.  */
   char* debug_section_end;
 
-  /* The buffer for the .line section. */
+  /* The buffer for the .line section.  */
   char* line_section;
 
-  /* End of that buffer. */
+  /* End of that buffer.  */
   char* line_section_end;
 
-  /* The current or next unread die within the .debug section. */
+  /* The current or next unread die within the .debug section.  */
   char* currentDie;
 };
 
-/* One dwarf1_unit for each parsed compilation unit die. */
+/* One dwarf1_unit for each parsed compilation unit die.  */
 
 struct dwarf1_unit {
-  /* Linked starting from stash->lastUnit. */
+  /* Linked starting from stash->lastUnit.  */
   struct dwarf1_unit* prev;
 
-  /* Name of the compilation unit. */
+  /* Name of the compilation unit.  */
   char* name;
 
-  /* The highest and lowest address used in the compilation unit. */
+  /* 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. */
+  /* 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. */
+  /* 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). */
+  /* The decoded line number table (line_count entries).  */
   struct linenumber* linenumber_table;
 
-  /* The list of functions in this unit. */
+  /* 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. */
+  /* Linked starting from aUnit->func_list.  */
   struct dwarf1_func* prev;
-  
-  /* Name of function. */
+
+  /* Name of function.  */
   char* name;
-  
-  /* The highest and lowest address used in the compilation unit. */
+
+  /* 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. */
+/* 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; 
-  
+
+  char* name;
+
   int has_stmt_list;
 
   unsigned short tag;
 };
 
-
-/* Parsed line number information. */
+/* Parsed line number information.  */
 struct linenumber {
-  /* First address in the line. */
+  /* First address in the line.  */
   unsigned long addr;
 
-  /* The line number. */
+  /* The line number.  */
   unsigned long linenumber;
 };
 
-
-/* Find the form of an attr, from the attr field. */
+/* 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'. */
+   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, 
+  struct dwarf1_unit* x =
+    (struct dwarf1_unit*) bfd_zalloc (stash->abfd,
 				      sizeof (struct dwarf1_unit));
   x->prev = stash->lastUnit;
   stash->lastUnit = x;
@@ -149,28 +143,28 @@ alloc_dwarf1_unit (stash)
 }
 
 /* Return a newly allocated dwarf1_func.  It must be cleared and
-   attached into 'aUnit' at 'aUnit->func_list'. */
+   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, 
+  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. 
+   points to was pulled from.
 
-   Return false if the die is invalidly formatted; true otherwise. */
+   Return false if the die is invalidly formatted; true otherwise.  */
 
 static boolean
 parse_die (abfd, aDieInfo, aDiePtr)
@@ -181,36 +175,36 @@ parse_die (abfd, aDieInfo, aDiePtr)
   char* this_die = aDiePtr;
   char* xptr = this_die;
 
-  memset (aDieInfo,0,sizeof(*aDieInfo));
+  memset (aDieInfo,0,sizeof (*aDieInfo));
 
-  /* First comes the length. */
+  /* First comes the length.  */
   aDieInfo->length = bfd_get_32 (abfd, (bfd_byte *) xptr);
   xptr += 4;
   if (aDieInfo->length == 0)
     return false;
   if (aDieInfo->length < 6)
     {
-      /* Just padding bytes. */
+      /* Just padding bytes.  */
       aDieInfo->tag = TAG_padding;
       return true;
     }
 
-  /* Then the tag. */
+  /* Then the tag.  */
   aDieInfo->tag = bfd_get_16 (abfd, (bfd_byte *) xptr);
   xptr += 2;
-      
-  /* Then the attributes. */
+
+  /* Then the attributes.  */
   while (xptr < (this_die + aDieInfo->length))
     {
       unsigned short attr;
-      
-      /* Parse the attribute based on its form.  This section 
+
+      /* 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. */
+	 actual attributes that we care about.  */
 
       attr = bfd_get_16 (abfd, (bfd_byte *) xptr);
       xptr += 2;
-      
+
       switch (FORM_FROM_ATTR (attr))
 	{
 	case FORM_DATA2:
@@ -255,9 +249,9 @@ parse_die (abfd, aDieInfo, aDiePtr)
 }
 
 /* Parse a dwarf1 line number table for 'aUnit->stmt_list_offset'
-   into 'aUnit->linenumber_table'.  Return false if an error 
-   occurs; true otherwise. */
-  
+   into 'aUnit->linenumber_table'.  Return false if an error
+   occurs; true otherwise.  */
+
 static boolean
 parse_line_table (stash, aUnit)
   struct dwarf1_debug* stash;
@@ -265,19 +259,19 @@ parse_line_table (stash, aUnit)
 {
   char* xptr;
 
-  /* Load the ".line" section from the bfd if we haven't already. */ 
+  /* 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 = (char *) bfd_alloc (stash->abfd, size);
-      
+
       if (! stash->line_section)
 	return false;
 
@@ -298,11 +292,11 @@ parse_line_table (stash, aUnit)
       char* tblend;
       unsigned long base;
 
-      /* First comes the length. */
+      /* First comes the length.  */
       tblend = bfd_get_32 (stash->abfd, (bfd_byte *) xptr) + xptr;
       xptr += 4;
 
-      /* Then the base address for each address in the table. */
+      /* Then the base address for each address in the table.  */
       base = bfd_get_32 (stash->abfd, (bfd_byte *) xptr);
       xptr += 4;
 
@@ -310,23 +304,23 @@ parse_line_table (stash, aUnit)
 	 10 = 4 (line number) + 2 (pos in line) + 4 (address in line) */
       aUnit->line_count = (tblend - xptr) / 10;
 
-      /* Allocate an array for the entries. */
+      /* Allocate an array for the entries.  */
       aUnit->linenumber_table = (struct linenumber *)
-	bfd_alloc (stash->abfd, 
+	bfd_alloc (stash->abfd,
 		   sizeof (struct linenumber) * aUnit->line_count);
-	
+
       for (eachLine = 0; eachLine < aUnit->line_count; eachLine++)
 	{
-	  /* A line number. */
+	  /* A line number.  */
 	  aUnit->linenumber_table[eachLine].linenumber
 	    = bfd_get_32 (stash->abfd, (bfd_byte *) xptr);
 	  xptr += 4;
 
-	  /* Skip the position within the line. */
+	  /* Skip the position within the line.  */
 	  xptr += 2;
 
-	  /* And finally the address. */
-	  aUnit->linenumber_table[eachLine].addr 
+	  /* And finally the address.  */
+	  aUnit->linenumber_table[eachLine].addr
 	    = base + bfd_get_32 (stash->abfd, (bfd_byte *) xptr);
 	  xptr += 4;
 	}
@@ -338,7 +332,7 @@ parse_line_table (stash, aUnit)
 /* 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. */
+   Return false if error; true otherwise.  */
 
 static boolean
 parse_functions_in_unit (stash, aUnit)
@@ -353,37 +347,37 @@ parse_functions_in_unit (stash, aUnit)
 	 )
       {
 	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. */
+   Return whether we found the line (or a function) without error.  */
 
 static boolean
-dwarf1_unit_find_nearest_line (stash, aUnit, addr, 
+dwarf1_unit_find_nearest_line (stash, aUnit, addr,
 		       filename_ptr, functionname_ptr,
 		       linenumber_ptr)
   struct dwarf1_debug* stash;
@@ -427,8 +421,8 @@ dwarf1_unit_find_nearest_line (stash, aUnit, addr,
 		}
 	    }
 
-	  for (eachFunc = aUnit->func_list; 
-	       eachFunc; 
+	  for (eachFunc = aUnit->func_list;
+	       eachFunc;
 	       eachFunc = eachFunc->prev)
 	    {
 	      if (eachFunc->low_pc <= addr
@@ -445,11 +439,8 @@ dwarf1_unit_find_nearest_line (stash, aUnit, addr,
   return line_p || func_p;
 }
 
-
-
-
 /* The DWARF 1 version of find_nearest line.
-   Return true if the line is found without error. */
+   Return true if the line is found without error.  */
 
 boolean
 _bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
@@ -472,31 +463,30 @@ _bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
   *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. */
+	     future calls to this function fail quicker.  */
 	  return false;
 	}
 
       size = bfd_get_section_size_before_reloc (msec);
       stash->debug_section = (char *) bfd_alloc (abfd, size);
-      
+
       if (! stash->debug_section)
 	return false;
 
@@ -512,20 +502,19 @@ _bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
     }
 
   /* A null debug_section indicates that there was no dwarf1 info
-     or that an error occured while setting up the stash. */
+     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. */
+     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, 
+					      filename_ptr,
+					      functionname_ptr,
 					      linenumber_ptr);
     }
 
@@ -535,36 +524,36 @@ _bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
 
       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 
+	     not it's sibling.  */
+	  if (aDieInfo.sibling
+	      && stash->currentDie + aDieInfo.length
                     < stash->debug_section_end
-	      && stash->currentDie + aDieInfo.length 
+	      && 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, 
+	    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
@@ -574,5 +563,4 @@ _bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
   return false;
 }
 
-
 /* EOF */
diff --git a/bfd/dwarf2.c b/bfd/dwarf2.c
index 7c8ddfd..203641e 100644
--- a/bfd/dwarf2.c
+++ b/bfd/dwarf2.c
@@ -75,7 +75,7 @@ struct attribute
 #define DW_SND(attr)       ((attr)->u.snd)
 #define DW_ADDR(attr)	   ((attr)->u.addr)
 
-/* Blocks are a bunch of untyped bytes. */
+/* Blocks are a bunch of untyped bytes.  */
 struct dwarf_block
 {
   unsigned int size;
@@ -144,7 +144,7 @@ struct comp_unit
 
   /* True if there is a line number table associated with this comp. unit.  */
   int stmtlist;
-  
+
   /* The offset into .debug_line of the line number table.  */
   unsigned long line_offset;
 
@@ -158,14 +158,14 @@ struct comp_unit
   struct line_info_table* line_table;
 
   /* A list of the functions found in this comp. unit.  */
-  struct funcinfo* function_table; 
+  struct funcinfo* function_table;
 
   /* Address size for this unit - from unit header.  */
   unsigned char addr_size;
 };
 
-/* VERBATIM 
-   The following function up to the END VERBATIM mark are 
+/* VERBATIM
+   The following function up to the END VERBATIM mark are
    copied directly from dwarf2read.c.  */
 
 /* Read dwarf information from a buffer.  */
@@ -260,7 +260,7 @@ read_string (abfd, buf, bytes_read_ptr)
       *bytes_read_ptr = 1;
       return NULL;
     }
-  
+
   *bytes_read_ptr = strlen (buf) + 1;
   return buf;
 }
@@ -279,7 +279,7 @@ read_unsigned_leb128 (abfd, buf, bytes_read_ptr)
   result   = 0;
   shift    = 0;
   num_read = 0;
-  
+
   do
     {
       byte = bfd_get_8 (abfd, (bfd_byte *) buf);
@@ -289,9 +289,9 @@ read_unsigned_leb128 (abfd, buf, bytes_read_ptr)
       shift += 7;
     }
   while (byte & 0x80);
-  
+
   * bytes_read_ptr = num_read;
-  
+
   return result;
 }
 
@@ -319,12 +319,12 @@ read_signed_leb128 (abfd, buf, bytes_read_ptr)
       shift += 7;
     }
   while (byte & 0x80);
-  
+
   if ((shift < 32) && (byte & 0x40))
     result |= -(1 << shift);
 
   * bytes_read_ptr = num_read;
-  
+
   return result;
 }
 
@@ -348,7 +348,7 @@ read_address (unit, buf)
     }
 }
 
-/* This data structure holds the information of an abbrev. */
+/* This data structure holds the information of an abbrev.  */
 struct abbrev_info
 {
   unsigned int number;		/* Number identifying abbrev.  */
@@ -392,7 +392,7 @@ lookup_abbrev (number,abbrevs)
       else
 	abbrev = abbrev->next;
     }
-  
+
   return NULL;
 }
 
@@ -426,13 +426,13 @@ read_abbrevs (abfd, offset)
 	  bfd_set_error (bfd_error_bad_value);
 	  return 0;
 	}
-      
+
       stash->dwarf_abbrev_size = msec->_raw_size;
       stash->dwarf_abbrev_buffer = (char*) bfd_alloc (abfd, stash->dwarf_abbrev_size);
       if (! stash->dwarf_abbrev_buffer)
 	  return 0;
-      
-      if (! bfd_get_section_contents (abfd, msec, 
+
+      if (! bfd_get_section_contents (abfd, msec,
 				      stash->dwarf_abbrev_buffer, 0,
 				      stash->dwarf_abbrev_size))
 	return 0;
@@ -440,13 +440,13 @@ read_abbrevs (abfd, offset)
 
   if (offset > stash->dwarf_abbrev_size)
     {
-      (*_bfd_error_handler) (_("Dwarf Error: Abbrev offset (%u) bigger than abbrev size (%u)."), 
+      (*_bfd_error_handler) (_("Dwarf Error: Abbrev offset (%u) bigger than abbrev size (%u)."),
 			     offset, stash->dwarf_abbrev_size );
       bfd_set_error (bfd_error_bad_value);
       return 0;
     }
 
-  abbrevs = (struct abbrev_info**) bfd_zalloc (abfd, sizeof(struct abbrev_info*) * ABBREV_HASH_SIZE);
+  abbrevs = (struct abbrev_info**) bfd_zalloc (abfd, sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE);
 
   abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
   abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
@@ -469,7 +469,7 @@ read_abbrevs (abfd, offset)
       abbrev_ptr += bytes_read;
       abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
       abbrev_ptr += bytes_read;
-      
+
       while (abbrev_name)
 	{
 	  if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
@@ -481,7 +481,7 @@ read_abbrevs (abfd, offset)
 	      if (! cur_abbrev->attrs)
 		return 0;
 	    }
-	  
+
 	  cur_abbrev->attrs[cur_abbrev->num_attrs].name = abbrev_name;
 	  cur_abbrev->attrs[cur_abbrev->num_attrs++].form = abbrev_form;
 	  abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
@@ -528,7 +528,7 @@ read_attribute (attr, abbrev, unit, info_ptr)
 
   attr->name = abbrev->name;
   attr->form = abbrev->form;
-  
+
   switch (abbrev->form)
     {
     case DW_FORM_addr:
@@ -664,7 +664,7 @@ struct line_info_table
   struct line_info* last_line;
 };
 
-static void 
+static void
 add_line_info (table, address, filename, line, column, end_sequence)
      struct line_info_table* table;
      bfd_vma address;
@@ -723,7 +723,7 @@ arange_add (unit, low_pc, high_pc)
 
   /* First see if we can cheaply extend an existing range.  */
   arange = &unit->arange;
-  
+
   do
     {
       if (low_pc == arange->high)
@@ -787,13 +787,13 @@ decode_line_info (unit)
 	  bfd_set_error (bfd_error_bad_value);
 	  return 0;
 	}
-      
+
       stash->dwarf_line_size = msec->_raw_size;
       stash->dwarf_line_buffer = (char *) bfd_alloc (abfd, stash->dwarf_line_size);
       if (! stash->dwarf_line_buffer)
 	return 0;
 
-      if (! bfd_get_section_contents (abfd, msec, 
+      if (! bfd_get_section_contents (abfd, msec,
 				      stash->dwarf_line_buffer, 0,
 				      stash->dwarf_line_size))
 	return 0;
@@ -813,7 +813,7 @@ decode_line_info (unit)
       return 0;
     }
 
-  table = (struct line_info_table*) bfd_alloc (abfd, 
+  table = (struct line_info_table*) bfd_alloc (abfd,
 					       sizeof (struct line_info_table));
   table->abfd = abfd;
   table->comp_dir = unit->comp_dir;
@@ -851,7 +851,7 @@ decode_line_info (unit)
     bfd_alloc (abfd, lh.opcode_base * sizeof (unsigned char));
 
   lh.standard_opcode_lengths[0] = 1;
-  
+
   for (i = 1; i < lh.opcode_base; ++i)
     {
       lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
@@ -862,7 +862,7 @@ decode_line_info (unit)
   while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
     {
       line_ptr += bytes_read;
-      
+
       if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
 	{
 	  table->dirs = (char **)
@@ -871,17 +871,17 @@ decode_line_info (unit)
 	  if (! table->dirs)
 	    return 0;
 	}
-      
+
       table->dirs[table->num_dirs++] = cur_dir;
     }
-  
+
   line_ptr += bytes_read;
 
   /* Read file name table.  */
   while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
     {
       line_ptr += bytes_read;
-      
+
       if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
 	{
 	  table->files = (struct fileinfo *)
@@ -891,7 +891,7 @@ decode_line_info (unit)
 	  if (! table->files)
 	    return 0;
 	}
-      
+
       table->files[table->num_files].name = cur_file;
       table->files[table->num_files].dir =
 	read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
@@ -904,7 +904,7 @@ decode_line_info (unit)
       line_ptr += bytes_read;
       table->num_files++;
     }
-  
+
   line_ptr += bytes_read;
 
   /* Read the statement sequences until there's nothing left.  */
@@ -925,7 +925,7 @@ decode_line_info (unit)
 	{
 	  op_code = read_1_byte (abfd, line_ptr);
 	  line_ptr += 1;
-	  
+
 	  switch (op_code)
 	    {
 	    case DW_LNS_extended_op:
@@ -1051,9 +1051,9 @@ decode_line_info (unit)
    LINENUMBER_PTR, are pointers to the objects to be filled in.  */
 
 static boolean
-lookup_address_in_line_info_table (table, 
+lookup_address_in_line_info_table (table,
 				   addr,
-				   filename_ptr, 
+				   filename_ptr,
 				   linenumber_ptr)
      struct line_info_table* table;
      bfd_vma addr;
@@ -1062,7 +1062,7 @@ lookup_address_in_line_info_table (table,
 {
   struct line_info* next_line = table->last_line;
   struct line_info* each_line;
-  
+
   if (!next_line)
     return false;
 
@@ -1080,10 +1080,10 @@ lookup_address_in_line_info_table (table,
       next_line = each_line;
       each_line = each_line->prev_line;
     }
-  
+
   return false;
 }
-  
+
 /* Function table functions.  */
 
 struct funcinfo
@@ -1094,10 +1094,10 @@ struct funcinfo
   bfd_vma high;
 };
 
-/* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return true. */
+/* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return true.  */
 
 static boolean
-lookup_address_in_function_table (table, 
+lookup_address_in_function_table (table,
 				  addr,
 				  functionname_ptr)
      struct funcinfo* table;
@@ -1116,7 +1116,7 @@ lookup_address_in_function_table (table,
 	  return true;
 	}
     }
-  
+
   return false;
 }
 
@@ -1149,16 +1149,16 @@ scan_unit_for_functions (unit)
 	  nesting_level--;
 	  continue;
 	}
-      
+
       abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
       if (! abbrev)
 	{
-	  (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %d."), 
+	  (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %d."),
 			     abbrev_number);
 	  bfd_set_error (bfd_error_bad_value);
 	  return false;
 	}
-      
+
       if (abbrev->tag == DW_TAG_subprogram)
 	{
 	  func = (struct funcinfo*) bfd_zalloc (abfd, sizeof (struct funcinfo));
@@ -1167,24 +1167,24 @@ scan_unit_for_functions (unit)
 	}
       else
 	func = NULL;
-  
+
       for (i = 0; i < abbrev->num_attrs; ++i)
 	{
 	  info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
-	  
+
 	  if (func)
 	    {
 	      switch (attr.name)
 		{
 		case DW_AT_name:
-		  
+
 		  name = DW_STRING (&attr);
 
 		  /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name.  */
 		  if (func->name == NULL)
 		    func->name = DW_STRING (&attr);
 		  break;
-		  
+
 		case DW_AT_MIPS_linkage_name:
 		  func->name = DW_STRING (&attr);
 		  break;
@@ -1208,7 +1208,7 @@ scan_unit_for_functions (unit)
 		case DW_AT_name:
 		  name = DW_STRING (&attr);
 		  break;
-		  
+
 		default:
 		  break;
 		}
@@ -1309,10 +1309,10 @@ parse_comp_unit (abfd, info_ptr, end_ptr, abbrev_length)
       bfd_set_error (bfd_error_bad_value);
       return 0;
     }
-  
+
   unit = (struct comp_unit*) bfd_zalloc (abfd, sizeof (struct comp_unit));
   unit->abfd = abfd;
-  unit->addr_size = addr_size; 
+  unit->addr_size = addr_size;
   unit->abbrevs = abbrevs;
   unit->end_ptr = end_ptr;
 
@@ -1386,14 +1386,14 @@ comp_unit_contains_address (unit, addr)
       arange = arange->next;
     }
   while (arange);
-  
+
   return 0;
 }
 
 /* If UNIT contains ADDR, set the output parameters to the values for
    the line containing ADDR.  The output parameters, FILENAME_PTR,
    FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
-   to be filled in.  
+   to be filled in.
 
    Return true of UNIT contains ADDR, and no errors were encountered;
    false otherwise.  */
@@ -1409,7 +1409,7 @@ comp_unit_find_nearest_line (unit, addr,
 {
   boolean line_p;
   boolean func_p;
-  
+
   if (unit->error)
     return false;
 
@@ -1420,7 +1420,7 @@ comp_unit_find_nearest_line (unit, addr,
 	  unit->error = 1;
 	  return false;
 	}
-  
+
       unit->line_table = decode_line_info (unit);
 
       if (! unit->line_table)
@@ -1428,7 +1428,7 @@ comp_unit_find_nearest_line (unit, addr,
 	  unit->error = 1;
 	  return false;
 	}
-      
+
       if (! scan_unit_for_functions (unit))
 	{
 	  unit->error = 1;
@@ -1438,9 +1438,9 @@ comp_unit_find_nearest_line (unit, addr,
 
   line_p = lookup_address_in_line_info_table (unit->line_table,
 					      addr,
-					      filename_ptr, 
+					      filename_ptr,
 					      linenumber_ptr);
-  func_p = lookup_address_in_function_table (unit->function_table, 
+  func_p = lookup_address_in_function_table (unit->function_table,
 					     addr,
 					     functionname_ptr);
   return line_p || func_p;
@@ -1506,10 +1506,10 @@ _bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
   /* Read each compilation unit from the section .debug_info, and check
      to see if it contains the address we are searching for.  If yes,
      lookup the address, and return the line number info.  If no, go
-     on to the next compilation unit.  
+     on to the next compilation unit.
 
      We keep a list of all the previously read compilation units, and
-     a pointer to the next un-read compilation unit.  Check the 
+     a pointer to the next un-read compilation unit.  Check the
      previously read units before reading more.  */
   struct dwarf2_debug *stash = elf_tdata (abfd)->dwarf2_find_line_info;
 
@@ -1517,7 +1517,7 @@ _bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
   bfd_vma addr = offset + section->vma;
 
   struct comp_unit* each;
-  
+
   *filename_ptr = NULL;
   *functionname_ptr = NULL;
   *linenumber_ptr = 0;
@@ -1528,7 +1528,7 @@ _bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
   if (addr_size == 0)
     addr_size = 4;
   BFD_ASSERT (addr_size == 4 || addr_size == 8);
-    
+
   if (! stash)
     {
       unsigned long total_size;
@@ -1553,7 +1553,7 @@ _bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
 	 us to avoid reallocing the data as we add sections to the stash.  */
       for (total_size = 0; msec; msec = find_debug_info (abfd, msec))
 	total_size += msec->_raw_size;
-      
+
       stash->info_ptr = (char *) bfd_alloc (abfd, total_size);
       if (stash->info_ptr == NULL)
 	return false;
@@ -1590,14 +1590,14 @@ _bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
      relocs.  There is a similar problem when the .debug_line
      section is processed as well (e.g., there may be relocs
      against the operand of the DW_LNE_set_address operator).
-     
+
      Unfortunately getting hold of the reloc information is hard...
-     
+
      For now, this means that disassembling object files (as
      opposed to fully executables) does not always work as well as
      we would like.  */
-  
-  /* A null info_ptr indicates that there is no dwarf2 info 
+
+  /* A null info_ptr indicates that there is no dwarf2 info
      (or that an error occured while setting up the stash).  */
   if (! stash->info_ptr)
     return false;
@@ -1605,7 +1605,7 @@ _bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
   /* Check the previously read comp. units first.  */
   for (each = stash->all_comp_units; each; each = each->next_unit)
     if (comp_unit_contains_address (each, addr))
-      return comp_unit_find_nearest_line (each, addr, filename_ptr, 
+      return comp_unit_find_nearest_line (each, addr, filename_ptr,
 					  functionname_ptr, linenumber_ptr);
 
   /* Read each remaining comp. units checking each as they are read.  */
@@ -1623,7 +1623,7 @@ _bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
 
       if (length > 0)
         {
-	  each = parse_comp_unit (abfd, stash->info_ptr, 
+	  each = parse_comp_unit (abfd, stash->info_ptr,
 				  stash->info_ptr + length,
 				  addr_size);
 	  stash->info_ptr += length;