Fix formatting of reloc16.c

Regernate generated files.

1 files changed, 57 insertions, 64 deletions

diff --git a/bfd/reloc16.c b/bfd/reloc16.c
index 0e7c18a..cb9636f 100644
--- a/bfd/reloc16.c
+++ b/bfd/reloc16.c
@@ -1,5 +1,5 @@
 /* 8 and 16 bit COFF relocation functions, for BFD.
-   Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 1998
+   Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 2000
    Free Software Foundation, Inc.
    Written by Cygnus Support.
 
@@ -19,10 +19,7 @@ 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.  */
 
-/* 
-Most of this hacked by  Steve Chamberlain,
-			sac@cygnus.com 
-*/
+/* Most of this hacked by Steve Chamberlain <sac@cygnus.com>.  */
 
 /* These routines are used by coff-h8300 and coff-z8k to do
    relocation.
@@ -53,7 +50,7 @@ bfd_coff_reloc16_get_value (reloc, link_info, input_section)
   asymbol *symbol = *(reloc->sym_ptr_ptr);
   /* A symbol holds a pointer to a section, and an offset from the
      base of the section.  To relocate, we find where the section will
-     live in the output and add that in */
+     live in the output and add that in.  */
 
   if (bfd_is_und_section (symbol->section)
       || bfd_is_com_section (symbol->section))
@@ -79,29 +76,29 @@ bfd_coff_reloc16_get_value (reloc, link_info, input_section)
 	value = h->u.c.size;
       else
 	{
-	  if (! ((*link_info->callbacks->undefined_symbol)
-		 (link_info, bfd_asymbol_name (symbol),
-		  input_section->owner, input_section, reloc->address,
-		  true)))
+	  if (!((*link_info->callbacks->undefined_symbol)
+		(link_info, bfd_asymbol_name (symbol),
+		 input_section->owner, input_section, reloc->address,
+		 true)))
 	    abort ();
 	  value = 0;
 	}
     }
-  else 
+  else
     {
-      value = symbol->value +
-	symbol->section->output_offset +
-	  symbol->section->output_section->vma;
+      value = symbol->value
+	+ symbol->section->output_offset
+	+ symbol->section->output_section->vma;
     }
-  
-  /* Add the value contained in the relocation */
+
+  /* Add the value contained in the relocation.  */
   value += reloc->addend;
-  
+
   return value;
 }
 
 void
-bfd_perform_slip(abfd, slip, input_section, value)
+bfd_perform_slip (abfd, slip, input_section, value)
      bfd *abfd;
      unsigned int slip;
      asection *input_section;
@@ -113,13 +110,13 @@ bfd_perform_slip(abfd, slip, input_section, value)
   BFD_ASSERT (s != (asymbol **) NULL);
 
   /* Find all symbols past this point, and make them know
-     what's happened */
-  while (*s) 
+     what's happened.  */
+  while (*s)
     {
       asymbol *p = *s;
-      if (p->section == input_section) 
+      if (p->section == input_section)
 	{
-	  /* This was pointing into this section, so mangle it */
+	  /* This was pointing into this section, so mangle it.  */
 	  if (p->value > value)
 	    {
 	      p->value -= slip;
@@ -136,17 +133,17 @@ bfd_perform_slip(abfd, slip, input_section, value)
 	    }
 	}
       s++;
-    }    
+    }
 }
 
-boolean 
+boolean
 bfd_coff_reloc16_relax_section (abfd, i, link_info, again)
      bfd *abfd;
      asection *i;
      struct bfd_link_info *link_info;
      boolean *again;
 {
-  /* Get enough memory to hold the stuff */
+  /* Get enough memory to hold the stuff.  */
   bfd *input_bfd = i->owner;
   asection *input_section = i;
   int *shrinks;
@@ -166,7 +163,7 @@ bfd_coff_reloc16_relax_section (abfd, i, link_info, again)
   if (!reloc_vector && reloc_size > 0)
     return false;
 
-  /* Get the relocs and think about them */
+  /* Get the relocs and think about them.  */
   reloc_count =
     bfd_canonicalize_reloc (input_bfd, input_section, reloc_vector,
 			    _bfd_generic_link_get_symbols (input_bfd));
@@ -190,7 +187,7 @@ bfd_coff_reloc16_relax_section (abfd, i, link_info, again)
      entire link, we could use the generic relaxing code in the linker
      and get better results, particularly for jsr->bsr and 24->16 bit
      memory reference relaxations.  */
-     
+
   if (reloc_count > 0)
     {
       int another_pass = 0;
@@ -208,7 +205,7 @@ bfd_coff_reloc16_relax_section (abfd, i, link_info, again)
 
 	another_pass = 0;
 
-	for (i = 0, parent = reloc_vector; *parent; parent++, i++) 
+	for (i = 0, parent = reloc_vector; *parent; parent++, i++)
 	  {
 	    /* Let the target/machine dependent code examine each reloc
 	       in this section and attempt to shrink it.  */
@@ -224,15 +221,15 @@ bfd_coff_reloc16_relax_section (abfd, i, link_info, again)
 		  shrinks[j] += shrink - shrinks[i];
 	      }
 	  }
-  
-      } while (another_pass);
+      }
+      while (another_pass);
 
       shrink = shrinks[reloc_count];
-      free((char *)shrinks);
+      free ((char *) shrinks);
     }
 
-  input_section->_cooked_size -= shrink;  
-  free((char *)reloc_vector);
+  input_section->_cooked_size -= shrink;
+  free ((char *) reloc_vector);
   return true;
 }
 
@@ -250,7 +247,7 @@ bfd_coff_reloc16_get_relocated_section_contents(in_abfd,
      boolean relocateable;
      asymbol **symbols;
 {
-  /* Get enough memory to hold the stuff */
+  /* Get enough memory to hold the stuff.  */
   bfd *input_bfd = link_order->u.indirect.section->owner;
   asection *input_section = link_order->u.indirect.section;
   long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
@@ -267,20 +264,19 @@ bfd_coff_reloc16_get_relocated_section_contents(in_abfd,
 						       data, relocateable,
 						       symbols);
 
-  /* read in the section */
-  if (! bfd_get_section_contents(input_bfd,
-				 input_section,
-				 data,
-				 0,
-				 input_section->_raw_size))
+  /* Read in the section.  */
+  if (!bfd_get_section_contents(input_bfd,
+				input_section,
+				data,
+				0,
+				input_section->_raw_size))
     return NULL;
-  
-  
-  reloc_vector = (arelent **) bfd_malloc((size_t) reloc_size);
+
+  reloc_vector = (arelent **) bfd_malloc ((size_t) reloc_size);
   if (!reloc_vector && reloc_size != 0)
     return NULL;
-  
-  reloc_count = bfd_canonicalize_reloc (input_bfd, 
+
+  reloc_count = bfd_canonicalize_reloc (input_bfd,
 					input_section,
 					reloc_vector,
 					symbols);
@@ -289,49 +285,46 @@ bfd_coff_reloc16_get_relocated_section_contents(in_abfd,
       free (reloc_vector);
       return NULL;
     }
-    
+
   if (reloc_count > 0)
     {
       arelent **parent = reloc_vector;
-      arelent *reloc ;
+      arelent *reloc;
       unsigned int dst_address = 0;
       unsigned int src_address = 0;
       unsigned int run;
       unsigned int idx;
-    
-      /* Find how long a run we can do */
-      while (dst_address < link_order->size) 
+
+      /* Find how long a run we can do.  */
+      while (dst_address < link_order->size)
 	{
 	  reloc = *parent;
-	  if (reloc) 
+	  if (reloc)
 	    {
 	      /* Note that the relaxing didn't tie up the addresses in the
 		 relocation, so we use the original address to work out the
-		 run of non-relocated data */
+		 run of non-relocated data.  */
 	      run = reloc->address - src_address;
 	      parent++;
 	    }
-	  else 
+	  else
 	    {
 	      run = link_order->size - dst_address;
 	    }
-	  /* Copy the bytes */
+
+	  /* Copy the bytes.  */
 	  for (idx = 0; idx < run; idx++)
-	    {
-	      data[dst_address++] = data[src_address++];
-	    }
-    
-	  /* Now do the relocation */
-    
-	  if (reloc) 
+	    data[dst_address++] = data[src_address++];
+
+	  /* Now do the relocation.  */
+	  if (reloc)
 	    {
 	      bfd_coff_reloc16_extra_cases (input_bfd, link_info, link_order,
 					    reloc, data, &src_address,
 					    &dst_address);
-	    }    
+	    }
 	}
     }
-  free((char *)reloc_vector);
+  free ((char *) reloc_vector);
   return data;
 }
-