* dwarf2.c: Change leading whitespace to tabs.

2 files changed, 117 insertions, 113 deletions

diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index 9aff2c3..c80b915 100644
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,3 +1,7 @@
+2008-09-05  Daniel Jacobowitz  <dan@codesourcery.com>
+
+	* dwarf2.c: Change leading whitespace to tabs.
+
 2008-09-05  Tristan Gingold  <gingold@adacore.com>
 
 	Add MacOSX 64 bits support.
diff --git a/bfd/dwarf2.c b/bfd/dwarf2.c
index 73b7b56..7717724 100644
--- a/bfd/dwarf2.c
+++ b/bfd/dwarf2.c
@@ -320,7 +320,7 @@ info_hash_table_newfunc (struct bfd_hash_entry *entry,
 
   /* Call the allocation method of the base class.  */
   ret = ((struct info_hash_entry *)
-         bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
+	 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
 
   /* Initialize the local fields here.  */
   if (ret)
@@ -402,9 +402,9 @@ lookup_info_hash_table (struct info_hash_table *hash_table, const char *key)
 
 static bfd_boolean
 read_section (bfd *abfd,
-              const char* section_name, const char* compressed_section_name,
-              asymbol** syms, bfd_uint64_t offset,
-              bfd_byte **section_buffer, bfd_size_type *section_size)
+	      const char* section_name, const char* compressed_section_name,
+	      asymbol** syms, bfd_uint64_t offset,
+	      bfd_byte **section_buffer, bfd_size_type *section_size)
 {
   asection *msec;
   bfd_boolean section_is_compressed = FALSE;
@@ -430,29 +430,29 @@ read_section (bfd *abfd,
     {
       *section_size = msec->size;
       *section_buffer
-          = bfd_simple_get_relocated_section_contents (abfd, msec, NULL, syms);
+	  = bfd_simple_get_relocated_section_contents (abfd, msec, NULL, syms);
       if (! *section_buffer)
-        return FALSE;
+	return FALSE;
     }
   else
     {
       *section_size = msec->rawsize ? msec->rawsize : msec->size;
       *section_buffer = bfd_malloc (*section_size);
       if (! *section_buffer)
-        return FALSE;
+	return FALSE;
       if (! bfd_get_section_contents (abfd, msec, *section_buffer,
-                                      0, *section_size))
-        return FALSE;
+	                              0, *section_size))
+	return FALSE;
     }
 
   if (section_is_compressed)
     {
       if (! bfd_uncompress_section_contents (section_buffer, section_size))
-        {
-          (*_bfd_error_handler) (_("Dwarf Error: unable to decompress %s section."), compressed_section_name);
-          bfd_set_error (bfd_error_bad_value);
-          return FALSE;
-        }
+	{
+	  (*_bfd_error_handler) (_("Dwarf Error: unable to decompress %s section."), compressed_section_name);
+	  bfd_set_error (bfd_error_bad_value);
+	  return FALSE;
+	}
     }
 
   /* It is possible to get a bad value for the offset into the section
@@ -548,8 +548,8 @@ read_indirect_string (struct comp_unit* unit,
   *bytes_read_ptr = unit->offset_size;
 
   if (! read_section (unit->abfd, ".debug_str", ".zdebug_str",
-                      0, offset,
-                      &stash->dwarf_str_buffer, &stash->dwarf_str_size))
+	              0, offset,
+	              &stash->dwarf_str_buffer, &stash->dwarf_str_size))
     return 0;
 
   str = (char *) stash->dwarf_str_buffer + offset;
@@ -633,8 +633,8 @@ read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
   bfd_size_type amt;
 
   if (! read_section (abfd, ".debug_abbrev", ".zdebug_abbrev",
-                      stash->syms, offset,
-                      &stash->dwarf_abbrev_buffer, &stash->dwarf_abbrev_size))
+	              stash->syms, offset,
+	              &stash->dwarf_abbrev_buffer, &stash->dwarf_abbrev_size))
     return 0;
 
   amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
@@ -1166,8 +1166,8 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
   bfd_size_type amt;
 
   if (! read_section (abfd, ".debug_line", ".zdebug_line",
-                      stash->syms, unit->line_offset,
-                      &stash->dwarf_line_buffer, &stash->dwarf_line_size))
+	              stash->syms, unit->line_offset,
+	              &stash->dwarf_line_buffer, &stash->dwarf_line_size))
     return 0;
 
   amt = sizeof (struct line_info_table);
@@ -1571,8 +1571,8 @@ read_debug_ranges (struct comp_unit *unit)
 {
   struct dwarf2_debug *stash = unit->stash;
   return read_section (unit->abfd, ".debug_ranges", ".zdebug_ranges",
-                       stash->syms, 0,
-                       &stash->dwarf_ranges_buffer, &stash->dwarf_ranges_size);
+	               stash->syms, 0,
+	               &stash->dwarf_ranges_buffer, &stash->dwarf_ranges_size);
 }
 
 /* Function table functions.  */
@@ -2905,99 +2905,99 @@ find_line (bfd *abfd,
 	debug_bfd = abfd;
 
       /* There can be more than one DWARF2 info section in a BFD these
-         days.  First handle the easy case when there's only one.  If
-         there's more than one, try case two: none of the sections is
-         compressed.  In that case, read them all in and produce one
-         large stash.  We do this in two passes - in the first pass we
-         just accumulate the section sizes, and in the second pass we
-         read in the section's contents.  (The allows us to avoid
-         reallocing the data as we add sections to the stash.)  If
-         some or all sections are compressed, then do things the slow
-         way, with a bunch of reallocs.  */
+	 days.  First handle the easy case when there's only one.  If
+	 there's more than one, try case two: none of the sections is
+	 compressed.  In that case, read them all in and produce one
+	 large stash.  We do this in two passes - in the first pass we
+	 just accumulate the section sizes, and in the second pass we
+	 read in the section's contents.  (The allows us to avoid
+	 reallocing the data as we add sections to the stash.)  If
+	 some or all sections are compressed, then do things the slow
+	 way, with a bunch of reallocs.  */
 
       if (! find_debug_info (debug_bfd, msec))
-        {
-          /* Case 1: only one info section.  */
-          total_size = msec->size;
-          if (! read_section (debug_bfd, ".debug_info", ".zdebug_info",
-                              symbols, 0,
-                              &stash->info_ptr_memory, &total_size))
-            goto done;
-          stash->info_ptr = stash->info_ptr_memory;
-          stash->info_ptr_end = stash->info_ptr + total_size;
-        }
+	{
+	  /* Case 1: only one info section.  */
+	  total_size = msec->size;
+	  if (! read_section (debug_bfd, ".debug_info", ".zdebug_info",
+	                      symbols, 0,
+	                      &stash->info_ptr_memory, &total_size))
+	    goto done;
+	  stash->info_ptr = stash->info_ptr_memory;
+	  stash->info_ptr_end = stash->info_ptr + total_size;
+	}
       else
-        {
-          int all_uncompressed = 1;
-          for (total_size = 0; msec; msec = find_debug_info (debug_bfd, msec))
-            {
-              total_size += msec->size;
-              if (strcmp (msec->name, DWARF2_COMPRESSED_DEBUG_INFO) == 0)
-                all_uncompressed = 0;
-            }
-          if (all_uncompressed)
-            {
-              /* Case 2: multiple sections, but none is compressed.  */
-              stash->info_ptr_memory = bfd_malloc (total_size);
-              if (stash->info_ptr_memory == NULL)
-        	goto done;
-
-              stash->info_ptr = stash->info_ptr_memory;
-              stash->info_ptr_end = stash->info_ptr;
-
-              for (msec = find_debug_info (debug_bfd, NULL);
-        	   msec;
-        	   msec = find_debug_info (debug_bfd, msec))
-        	{
-        	  bfd_size_type size;
-        	  bfd_size_type start;
-
-        	  size = msec->size;
-        	  if (size == 0)
-        	    continue;
-
-        	  start = stash->info_ptr_end - stash->info_ptr;
-
-        	  if ((bfd_simple_get_relocated_section_contents
-        	       (debug_bfd, msec, stash->info_ptr + start, symbols))
-                      == NULL)
-        	    continue;
-
-        	  stash->info_ptr_end = stash->info_ptr + start + size;
-        	}
-
-              BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size);
-            }
-          else
-            {
-              /* Case 3: multiple sections, some or all compressed.  */
-              stash->info_ptr_memory = bfd_malloc (1);
-              stash->info_ptr = stash->info_ptr_memory;
-              stash->info_ptr_end = stash->info_ptr;
-              for (msec = find_debug_info (debug_bfd, NULL);
-        	   msec;
-        	   msec = find_debug_info (debug_bfd, msec))
-        	{
-                  bfd_size_type size = msec->size;
-                  bfd_byte* buffer
-                      = (bfd_simple_get_relocated_section_contents
-                         (debug_bfd, msec, NULL, symbols));
-                  if (! buffer)
-                    continue;
-                  if (strcmp (msec->name, DWARF2_COMPRESSED_DEBUG_INFO) == 0)
-                    {
-                      if (! bfd_uncompress_section_contents (&buffer, &size))
-                        continue;
-                    }
-                  stash->info_ptr = bfd_realloc (stash->info_ptr,
-                                                 stash->info_ptr_end
-                                                 - stash->info_ptr + size);
-                  memcpy (stash->info_ptr_end, buffer, size);
-                  free (buffer);
-                  stash->info_ptr_end += size;
-                }
-            }
-        }
+	{
+	  int all_uncompressed = 1;
+	  for (total_size = 0; msec; msec = find_debug_info (debug_bfd, msec))
+	    {
+	      total_size += msec->size;
+	      if (strcmp (msec->name, DWARF2_COMPRESSED_DEBUG_INFO) == 0)
+	        all_uncompressed = 0;
+	    }
+	  if (all_uncompressed)
+	    {
+	      /* Case 2: multiple sections, but none is compressed.  */
+	      stash->info_ptr_memory = bfd_malloc (total_size);
+	      if (stash->info_ptr_memory == NULL)
+		goto done;
+
+	      stash->info_ptr = stash->info_ptr_memory;
+	      stash->info_ptr_end = stash->info_ptr;
+
+	      for (msec = find_debug_info (debug_bfd, NULL);
+		   msec;
+		   msec = find_debug_info (debug_bfd, msec))
+		{
+		  bfd_size_type size;
+		  bfd_size_type start;
+
+		  size = msec->size;
+		  if (size == 0)
+		    continue;
+
+		  start = stash->info_ptr_end - stash->info_ptr;
+
+		  if ((bfd_simple_get_relocated_section_contents
+		       (debug_bfd, msec, stash->info_ptr + start, symbols))
+	              == NULL)
+		    continue;
+
+		  stash->info_ptr_end = stash->info_ptr + start + size;
+		}
+
+	      BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size);
+	    }
+	  else
+	    {
+	      /* Case 3: multiple sections, some or all compressed.  */
+	      stash->info_ptr_memory = bfd_malloc (1);
+	      stash->info_ptr = stash->info_ptr_memory;
+	      stash->info_ptr_end = stash->info_ptr;
+	      for (msec = find_debug_info (debug_bfd, NULL);
+		   msec;
+		   msec = find_debug_info (debug_bfd, msec))
+		{
+	          bfd_size_type size = msec->size;
+	          bfd_byte* buffer
+	              = (bfd_simple_get_relocated_section_contents
+	                 (debug_bfd, msec, NULL, symbols));
+	          if (! buffer)
+	            continue;
+	          if (strcmp (msec->name, DWARF2_COMPRESSED_DEBUG_INFO) == 0)
+	            {
+	              if (! bfd_uncompress_section_contents (&buffer, &size))
+	                continue;
+	            }
+	          stash->info_ptr = bfd_realloc (stash->info_ptr,
+	                                         stash->info_ptr_end
+	                                         - stash->info_ptr + size);
+	          memcpy (stash->info_ptr_end, buffer, size);
+	          free (buffer);
+	          stash->info_ptr_end += size;
+	        }
+	    }
+	}
 
       stash->sec = find_debug_info (debug_bfd, NULL);
       stash->sec_info_ptr = stash->info_ptr;
@@ -3106,7 +3106,7 @@ find_line (bfd *abfd,
       else if (addr_size == 8)
 	{
 	  offset_size = 4;
-          stash->info_ptr += 4;
+	  stash->info_ptr += 4;
 	}
       else
 	stash->info_ptr += 4;