* libbfd.c (bfd_read): Set bfd_error as appropriate for a short

        read. (bfd_error_system_call or bfd_error_file_truncated).

        * som.c: Do not blindly set bfd_error_system_call after a
        failing bfd_read, bfd_write, or bfd_seek.  In a few places
        (like som_object_p) override the error status set by bfd_read.

        * aix386-core.c, aout-encap,c archive.c, bout.c: Likewise.
        * coff-rs6000.c, coffgen.c ecoff.c, elf.c: Likewise.
        * elf32-hppa.c, elfcode.h, hp300hpux.c, i386lynx.c: Likewise.
        * nlm32-alpha.c, nlm32-i386.c, nlm32-sparc.c: Likewise.

        * som.c: Check return values from several bfd_{seek,read,write}
        calls that we just assumed were not failing.

1 files changed, 234 insertions, 225 deletions

diff --git a/bfd/i386lynx.c b/bfd/i386lynx.c
index 04af2b7..9a47e00 100644
--- a/bfd/i386lynx.c
+++ b/bfd/i386lynx.c
@@ -1,4 +1,4 @@
-/* BFD back-end for i386 a.out binaries under Lynx.
+/* BFD back-end for i386 a.out binaries under LynxOS.
    Copyright (C) 1990, 1991, 1992 Free Software Foundation, Inc.
 
 This file is part of BFD, the Binary File Descriptor library.
@@ -58,7 +58,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 	    {								      \
 	      bfd_seek (abfd, (file_ptr)(N_SYMOFF(*execp)), SEEK_SET);	      \
 									      \
-	      NAME(aout,write_syms)(abfd);				      \
+	      if (! NAME(aout,write_syms)(abfd)) return false;		      \
 									      \
 	      bfd_seek (abfd, (file_ptr)(N_TRELOFF(*execp)), SEEK_SET);	      \
 									      \
@@ -67,7 +67,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 									      \
 	      if (!NAME(lynx,squirt_out_relocs)(abfd, obj_datasec (abfd))) return false; \
 	    }								      \
-      }									      
+      }
 #endif
 
 #include "libaout.h"
@@ -75,10 +75,10 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 #ifdef HOST_LYNX
 
-char *lynx_core_file_failing_command();
-int lynx_core_file_failing_signal();
-boolean lynx_core_file_matches_executable_p();
-bfd_target *lynx_core_file_p();
+char *lynx_core_file_failing_command ();
+int lynx_core_file_failing_signal ();
+boolean lynx_core_file_matches_executable_p ();
+bfd_target *lynx_core_file_p ();
 
 #define	MY_core_file_failing_command lynx_core_file_failing_command
 #define	MY_core_file_failing_signal lynx_core_file_failing_signal
@@ -86,8 +86,8 @@ bfd_target *lynx_core_file_p();
 #define	MY_core_file_p lynx_core_file_p
 
 #endif /* HOST_LYNX */
-
 
+
 #define KEEPIT flags
 
 extern reloc_howto_type aout_32_ext_howto_table[];
@@ -97,10 +97,10 @@ extern reloc_howto_type aout_32_std_howto_table[];
 /* Output standard relocation information to a file in target byte order. */
 
 void
-DEFUN(NAME(lynx,swap_std_reloc_out),(abfd, g, natptr),
-      bfd *abfd AND
-      arelent *g AND
-      struct reloc_std_external *natptr)
+NAME (lynx, swap_std_reloc_out) (abfd, g, natptr)
+     bfd *abfd;
+     arelent *g;
+     struct reloc_std_external *natptr;
 {
   int r_index;
   asymbol *sym = *(g->sym_ptr_ptr);
@@ -111,78 +111,81 @@ DEFUN(NAME(lynx,swap_std_reloc_out),(abfd, g, natptr),
   unsigned int r_addend;
   asection *output_section = sym->section->output_section;
 
-  PUT_WORD(abfd, g->address, natptr->r_address);
+  PUT_WORD (abfd, g->address, natptr->r_address);
 
-  r_length = g->howto->size ;	/* Size as a power of two */
-  r_pcrel  = (int) g->howto->pc_relative; /* Relative to PC? */
+  r_length = g->howto->size;	/* Size as a power of two */
+  r_pcrel = (int) g->howto->pc_relative;	/* Relative to PC? */
   /* r_baserel, r_jmptable, r_relative???  FIXME-soon */
   r_baserel = 0;
   r_jmptable = 0;
   r_relative = 0;
-    
+
   r_addend = g->addend + (*(g->sym_ptr_ptr))->section->output_section->vma;
-    
+
   /* name was clobbered by aout_write_syms to be symbol index */
 
-  /* If this relocation is relative to a symbol then set the 
+  /* If this relocation is relative to a symbol then set the
      r_index to the symbols index, and the r_extern bit.
 
      Absolute symbols can come in in two ways, either as an offset
      from the abs section, or as a symbol which has an abs value.
      check for that here
      */
-     
+
 
   if (bfd_is_com_section (output_section)
       || output_section == &bfd_abs_section
-      || output_section == &bfd_und_section) 
+      || output_section == &bfd_und_section)
     {
       if (bfd_abs_section.symbol == sym)
-      {
-	/* Whoops, looked like an abs symbol, but is really an offset
+	{
+	  /* Whoops, looked like an abs symbol, but is really an offset
 	   from the abs section */
-	r_index = 0;
-	r_extern = 0;
-       }
-      else 
-      {
-	/* Fill in symbol */
-	r_extern = 1;
-	r_index =  stoi((*(g->sym_ptr_ptr))->KEEPIT);
-     
-      }
+	  r_index = 0;
+	  r_extern = 0;
+	}
+      else
+	{
+	  /* Fill in symbol */
+	  r_extern = 1;
+	  r_index = stoi ((*(g->sym_ptr_ptr))->KEEPIT);
+
+	}
     }
-  else 
+  else
     {
       /* Just an ordinary section */
       r_extern = 0;
-      r_index  = output_section->target_index;      
+      r_index = output_section->target_index;
     }
 
   /* now the fun stuff */
-  if (abfd->xvec->header_byteorder_big_p != false) {
+  if (abfd->xvec->header_byteorder_big_p != false)
+    {
       natptr->r_index[0] = r_index >> 16;
       natptr->r_index[1] = r_index >> 8;
       natptr->r_index[2] = r_index;
       natptr->r_type[0] =
-       (r_extern?    RELOC_STD_BITS_EXTERN_BIG: 0)
-	| (r_pcrel?     RELOC_STD_BITS_PCREL_BIG: 0)
-	 | (r_baserel?   RELOC_STD_BITS_BASEREL_BIG: 0)
-	  | (r_jmptable?  RELOC_STD_BITS_JMPTABLE_BIG: 0)
-	   | (r_relative?  RELOC_STD_BITS_RELATIVE_BIG: 0)
-	    | (r_length <<  RELOC_STD_BITS_LENGTH_SH_BIG);
-    } else {
-	natptr->r_index[2] = r_index >> 16;
-	natptr->r_index[1] = r_index >> 8;
-	natptr->r_index[0] = r_index;
-	natptr->r_type[0] =
-	 (r_extern?    RELOC_STD_BITS_EXTERN_LITTLE: 0)
-	  | (r_pcrel?     RELOC_STD_BITS_PCREL_LITTLE: 0)
-	   | (r_baserel?   RELOC_STD_BITS_BASEREL_LITTLE: 0)
-	    | (r_jmptable?  RELOC_STD_BITS_JMPTABLE_LITTLE: 0)
-	     | (r_relative?  RELOC_STD_BITS_RELATIVE_LITTLE: 0)
-	      | (r_length <<  RELOC_STD_BITS_LENGTH_SH_LITTLE);
-      }
+	(r_extern ? RELOC_STD_BITS_EXTERN_BIG : 0)
+	| (r_pcrel ? RELOC_STD_BITS_PCREL_BIG : 0)
+	| (r_baserel ? RELOC_STD_BITS_BASEREL_BIG : 0)
+	| (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
+	| (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
+	| (r_length << RELOC_STD_BITS_LENGTH_SH_BIG);
+    }
+  else
+    {
+      natptr->r_index[2] = r_index >> 16;
+      natptr->r_index[1] = r_index >> 8;
+      natptr->r_index[0] = r_index;
+      natptr->r_type[0] =
+	(r_extern ? RELOC_STD_BITS_EXTERN_LITTLE : 0)
+	| (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE : 0)
+	| (r_baserel ? RELOC_STD_BITS_BASEREL_LITTLE : 0)
+	| (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
+	| (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
+	| (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE);
+    }
 }
 
 
@@ -190,81 +193,84 @@ DEFUN(NAME(lynx,swap_std_reloc_out),(abfd, g, natptr),
 /* Output extended relocation information to a file in target byte order. */
 
 void
-DEFUN(NAME(lynx,swap_ext_reloc_out),(abfd, g, natptr),
-      bfd *abfd AND
-      arelent *g AND
-      register struct reloc_ext_external *natptr)
+NAME (lynx, swap_ext_reloc_out) (abfd, g, natptr)
+     bfd *abfd;
+     arelent *g;
+     register struct reloc_ext_external *natptr;
 {
   int r_index;
   int r_extern;
   unsigned int r_type;
   unsigned int r_addend;
-  asymbol *sym = *(g->sym_ptr_ptr);    
+  asymbol *sym = *(g->sym_ptr_ptr);
   asection *output_section = sym->section->output_section;
-  
+
   PUT_WORD (abfd, g->address, natptr->r_address);
-    
+
   r_type = (unsigned int) g->howto->type;
-    
+
   r_addend = g->addend + (*(g->sym_ptr_ptr))->section->output_section->vma;
 
 
-  /* If this relocation is relative to a symbol then set the 
+  /* If this relocation is relative to a symbol then set the
      r_index to the symbols index, and the r_extern bit.
 
      Absolute symbols can come in in two ways, either as an offset
      from the abs section, or as a symbol which has an abs value.
      check for that here
      */
-     
+
   if (bfd_is_com_section (output_section)
       || output_section == &bfd_abs_section
       || output_section == &bfd_und_section)
-  {
-    if (bfd_abs_section.symbol == sym)
     {
-      /* Whoops, looked like an abs symbol, but is really an offset
+      if (bfd_abs_section.symbol == sym)
+	{
+	  /* Whoops, looked like an abs symbol, but is really an offset
 	 from the abs section */
-      r_index = 0;
-      r_extern = 0;
-     }
-    else 
+	  r_index = 0;
+	  r_extern = 0;
+	}
+      else
+	{
+	  r_extern = 1;
+	  r_index = stoi ((*(g->sym_ptr_ptr))->KEEPIT);
+	}
+    }
+  else
     {
-      r_extern = 1;
-      r_index =  stoi((*(g->sym_ptr_ptr))->KEEPIT);
+      /* Just an ordinary section */
+      r_extern = 0;
+      r_index = output_section->target_index;
     }
-  }
-  else 
-  {
-    /* Just an ordinary section */
-    r_extern = 0;
-    r_index  = output_section->target_index;      
-  }
-	 
-	 
+
+
   /* now the fun stuff */
-  if (abfd->xvec->header_byteorder_big_p != false) {
-    natptr->r_index[0] = r_index >> 16;
-    natptr->r_index[1] = r_index >> 8;
-    natptr->r_index[2] = r_index;
-    natptr->r_type[0] =
-     (r_extern? RELOC_EXT_BITS_EXTERN_BIG: 0)
-      | (r_type << RELOC_EXT_BITS_TYPE_SH_BIG);
-  } else {
-    natptr->r_index[2] = r_index >> 16;
-    natptr->r_index[1] = r_index >> 8;
-    natptr->r_index[0] = r_index;
-    natptr->r_type[0] =
-     (r_extern? RELOC_EXT_BITS_EXTERN_LITTLE: 0)
-      | (r_type << RELOC_EXT_BITS_TYPE_SH_LITTLE);
-  }
+  if (abfd->xvec->header_byteorder_big_p != false)
+    {
+      natptr->r_index[0] = r_index >> 16;
+      natptr->r_index[1] = r_index >> 8;
+      natptr->r_index[2] = r_index;
+      natptr->r_type[0] =
+	(r_extern ? RELOC_EXT_BITS_EXTERN_BIG : 0)
+	| (r_type << RELOC_EXT_BITS_TYPE_SH_BIG);
+    }
+  else
+    {
+      natptr->r_index[2] = r_index >> 16;
+      natptr->r_index[1] = r_index >> 8;
+      natptr->r_index[0] = r_index;
+      natptr->r_type[0] =
+	(r_extern ? RELOC_EXT_BITS_EXTERN_LITTLE : 0)
+	| (r_type << RELOC_EXT_BITS_TYPE_SH_LITTLE);
+    }
 
   PUT_WORD (abfd, r_addend, natptr->r_addend);
 }
 
 /* BFD deals internally with all things based from the section they're
    in. so, something in 10 bytes into a text section  with a base of
-   50 would have a symbol (.text+10) and know .text vma was 50. 
+   50 would have a symbol (.text+10) and know .text vma was 50.
 
    Aout keeps all it's symbols based from zero, so the symbol would
    contain 60. This macro subs the base of each section from the value
@@ -305,11 +311,11 @@ DEFUN(NAME(lynx,swap_ext_reloc_out),(abfd, g, natptr),
   }     								\
 
 void
-DEFUN(NAME(lynx,swap_ext_reloc_in), (abfd, bytes, cache_ptr, symbols),
-      bfd *abfd AND
-      struct reloc_ext_external *bytes AND
-      arelent *cache_ptr AND
-      asymbol **symbols)
+NAME (lynx, swap_ext_reloc_in) (abfd, bytes, cache_ptr, symbols)
+     bfd *abfd;
+     struct reloc_ext_external *bytes;
+     arelent *cache_ptr;
+     asymbol **symbols;
 {
   int r_index;
   int r_extern;
@@ -318,68 +324,53 @@ DEFUN(NAME(lynx,swap_ext_reloc_in), (abfd, bytes, cache_ptr, symbols),
 
   cache_ptr->address = (GET_SWORD (abfd, bytes->r_address));
 
-  /* now the fun stuff */
-  if (1 /* abfd->xvec->header_byteorder_big_p != false */) {
-    r_index =  (bytes->r_index[0] << 16)
-	     | (bytes->r_index[1] << 8)
-	     |  bytes->r_index[2];
-    r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
-    r_type   =       (bytes->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
-				      >> RELOC_EXT_BITS_TYPE_SH_BIG;
-  } else {
-    r_index =  (bytes->r_index[2] << 16)
-	     | (bytes->r_index[1] << 8)
-	     |  bytes->r_index[0];
-    r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
-    r_type   =       (bytes->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
-				      >> RELOC_EXT_BITS_TYPE_SH_LITTLE;
-  }
-
-  cache_ptr->howto =  aout_32_ext_howto_table + r_type;
-  MOVE_ADDRESS(GET_SWORD(abfd, bytes->r_addend));
+  r_index = bytes->r_index[1];
+  r_extern = (0 != (bytes->r_index[0] & RELOC_EXT_BITS_EXTERN_BIG));
+  r_type = (bytes->r_index[0] & RELOC_EXT_BITS_TYPE_BIG)
+    >> RELOC_EXT_BITS_TYPE_SH_BIG;
+
+  cache_ptr->howto = aout_32_ext_howto_table + r_type;
+  MOVE_ADDRESS (GET_SWORD (abfd, bytes->r_addend));
 }
 
 void
-DEFUN(NAME(lynx,swap_std_reloc_in), (abfd, bytes, cache_ptr, symbols),
-  bfd *abfd AND
-  struct reloc_std_external *bytes AND
-  arelent *cache_ptr AND
-  asymbol **symbols)
+NAME (lynx, swap_std_reloc_in) (abfd, bytes, cache_ptr, symbols)
+     bfd *abfd;
+     struct reloc_std_external *bytes;
+     arelent *cache_ptr;
+     asymbol **symbols;
 {
-  char tmp;
   int r_index;
   int r_extern;
   unsigned int r_length;
   int r_pcrel;
   int r_baserel, r_jmptable, r_relative;
-  struct aoutdata  *su = &(abfd->tdata.aout_data->a);
+  struct aoutdata *su = &(abfd->tdata.aout_data->a);
 
   cache_ptr->address = bfd_h_get_32 (abfd, bytes->r_address);
 
-  r_index = (bytes->r_type[0] << 16)
-    | (bytes->r_index[2] << 8)
-      |  bytes->r_index[1];
-  r_extern  = (0 != (bytes->r_index[0] & RELOC_STD_BITS_EXTERN_BIG));
-  r_pcrel   = (0 != (bytes->r_index[0] & RELOC_STD_BITS_PCREL_BIG));
+  r_index = bytes->r_index[1];
+  r_extern = (0 != (bytes->r_index[0] & RELOC_STD_BITS_EXTERN_BIG));
+  r_pcrel = (0 != (bytes->r_index[0] & RELOC_STD_BITS_PCREL_BIG));
   r_baserel = (0 != (bytes->r_index[0] & RELOC_STD_BITS_BASEREL_BIG));
-  r_jmptable= (0 != (bytes->r_index[0] & RELOC_STD_BITS_JMPTABLE_BIG));
-  r_relative= (0 != (bytes->r_index[0] & RELOC_STD_BITS_RELATIVE_BIG));
-  r_length  =       (bytes->r_index[0] & RELOC_STD_BITS_LENGTH_BIG) 
+  r_jmptable = (0 != (bytes->r_index[0] & RELOC_STD_BITS_JMPTABLE_BIG));
+  r_relative = (0 != (bytes->r_index[0] & RELOC_STD_BITS_RELATIVE_BIG));
+  r_length = (bytes->r_index[0] & RELOC_STD_BITS_LENGTH_BIG)
     >> RELOC_STD_BITS_LENGTH_SH_BIG;
 
-  cache_ptr->howto =  aout_32_std_howto_table + r_length + 4 * r_pcrel;
+  cache_ptr->howto = aout_32_std_howto_table + r_length + 4 * r_pcrel;
   /* FIXME-soon:  Roll baserel, jmptable, relative bits into howto setting */
 
-  MOVE_ADDRESS(0);
+  MOVE_ADDRESS (0);
 }
 
 /* Reloc hackery */
 
 boolean
-DEFUN(NAME(lynx,slurp_reloc_table),(abfd, asect, symbols),
-      bfd *abfd AND
-      sec_ptr asect AND
-      asymbol **symbols)
+NAME (lynx, slurp_reloc_table) (abfd, asect, symbols)
+     bfd *abfd;
+     sec_ptr asect;
+     asymbol **symbols;
 {
   unsigned int count;
   bfd_size_type reloc_size;
@@ -387,71 +378,82 @@ DEFUN(NAME(lynx,slurp_reloc_table),(abfd, asect, symbols),
   arelent *reloc_cache;
   size_t each_size;
 
-  if (asect->relocation) return true;
+  if (asect->relocation)
+    return true;
 
-  if (asect->flags & SEC_CONSTRUCTOR) return true;
+  if (asect->flags & SEC_CONSTRUCTOR)
+    return true;
 
-  if (asect == obj_datasec (abfd)) {
-    reloc_size = exec_hdr(abfd)->a_drsize;
-    goto doit;
-  }
+  if (asect == obj_datasec (abfd))
+    {
+      reloc_size = exec_hdr (abfd)->a_drsize;
+      goto doit;
+    }
 
-  if (asect == obj_textsec (abfd)) {
-    reloc_size = exec_hdr(abfd)->a_trsize;
-    goto doit;
-  }
+  if (asect == obj_textsec (abfd))
+    {
+      reloc_size = exec_hdr (abfd)->a_trsize;
+      goto doit;
+    }
 
-  bfd_error = invalid_operation;
+  bfd_set_error (bfd_error_invalid_operation);
   return false;
 
- doit:
+doit:
   bfd_seek (abfd, asect->rel_filepos, SEEK_SET);
   each_size = obj_reloc_entry_size (abfd);
 
   count = reloc_size / each_size;
 
 
-  reloc_cache = (arelent *) bfd_zalloc (abfd, (size_t)(count * sizeof
-						       (arelent)));
-  if (!reloc_cache) {
-nomem:
-    bfd_error = no_memory;
-    return false;
-  }
+  reloc_cache = (arelent *) bfd_zalloc (abfd, (size_t) (count * sizeof
+							(arelent)));
+  if (!reloc_cache)
+    {
+    nomem:
+      bfd_set_error (bfd_error_no_memory);
+      return false;
+    }
 
   relocs = (PTR) bfd_alloc (abfd, reloc_size);
-  if (!relocs) {
-    bfd_release (abfd, reloc_cache);
-    goto nomem;
-  }
-
-  if (bfd_read (relocs, 1, reloc_size, abfd) != reloc_size) {
-    bfd_release (abfd, relocs);
-    bfd_release (abfd, reloc_cache);
-    bfd_error = system_call_error;
-    return false;
-  }
-
-  if (each_size == RELOC_EXT_SIZE) {
-    register struct reloc_ext_external *rptr = (struct reloc_ext_external *) relocs;
-    unsigned int counter = 0;
-    arelent *cache_ptr = reloc_cache;
-
-    for (; counter < count; counter++, rptr++, cache_ptr++) {
-      NAME(lynx,swap_ext_reloc_in)(abfd, rptr, cache_ptr, symbols);
+  if (!relocs)
+    {
+      bfd_release (abfd, reloc_cache);
+      goto nomem;
     }
-  } else {
-    register struct reloc_std_external *rptr = (struct reloc_std_external*) relocs;
-    unsigned int counter = 0;
-    arelent *cache_ptr = reloc_cache;
 
-    for (; counter < count; counter++, rptr++, cache_ptr++) {
-	NAME(lynx,swap_std_reloc_in)(abfd, rptr, cache_ptr, symbols);
+  if (bfd_read (relocs, 1, reloc_size, abfd) != reloc_size)
+    {
+      bfd_release (abfd, relocs);
+      bfd_release (abfd, reloc_cache);
+      return false;
+    }
+
+  if (each_size == RELOC_EXT_SIZE)
+    {
+      register struct reloc_ext_external *rptr = (struct reloc_ext_external *) relocs;
+      unsigned int counter = 0;
+      arelent *cache_ptr = reloc_cache;
+
+      for (; counter < count; counter++, rptr++, cache_ptr++)
+	{
+	  NAME (lynx, swap_ext_reloc_in) (abfd, rptr, cache_ptr, symbols);
+	}
     }
+  else
+    {
+      register struct reloc_std_external *rptr = (struct reloc_std_external *) relocs;
+      unsigned int counter = 0;
+      arelent *cache_ptr = reloc_cache;
+
+      for (; counter < count; counter++, rptr++, cache_ptr++)
+	{
+	  NAME (lynx, swap_std_reloc_in) (abfd, rptr, cache_ptr, symbols);
+	}
 
-  }
+    }
 
-  bfd_release (abfd,relocs);
+  bfd_release (abfd, relocs);
   asect->relocation = reloc_cache;
   asect->reloc_count = count;
   return true;
@@ -462,9 +464,9 @@ nomem:
 /* Write out a relocation section into an object file.  */
 
 boolean
-DEFUN(NAME(lynx,squirt_out_relocs),(abfd, section),
-      bfd *abfd AND
-      asection *section)
+NAME (lynx, squirt_out_relocs) (abfd, section)
+     bfd *abfd;
+     asection *section;
 {
   arelent **generic;
   unsigned char *native, *natptr;
@@ -473,37 +475,40 @@ DEFUN(NAME(lynx,squirt_out_relocs),(abfd, section),
   unsigned int count = section->reloc_count;
   size_t natsize;
 
-  if (count == 0) return true;
+  if (count == 0)
+    return true;
 
   each_size = obj_reloc_entry_size (abfd);
   natsize = each_size * count;
   native = (unsigned char *) bfd_zalloc (abfd, natsize);
-  if (!native) {
-    bfd_error = no_memory;
-    return false;
-  }
+  if (!native)
+    {
+      bfd_set_error (bfd_error_no_memory);
+      return false;
+    }
 
   generic = section->orelocation;
 
-  if (each_size == RELOC_EXT_SIZE) 
+  if (each_size == RELOC_EXT_SIZE)
     {
       for (natptr = native;
 	   count != 0;
 	   --count, natptr += each_size, ++generic)
-	NAME(lynx,swap_ext_reloc_out) (abfd, *generic, (struct reloc_ext_external *)natptr);
+	NAME (lynx, swap_ext_reloc_out) (abfd, *generic, (struct reloc_ext_external *) natptr);
     }
-  else 
+  else
     {
       for (natptr = native;
 	   count != 0;
 	   --count, natptr += each_size, ++generic)
-	NAME(lynx,swap_std_reloc_out)(abfd, *generic, (struct reloc_std_external *)natptr);
+	NAME (lynx, swap_std_reloc_out) (abfd, *generic, (struct reloc_std_external *) natptr);
     }
 
-  if ( bfd_write ((PTR) native, 1, natsize, abfd) != natsize) {
-    bfd_release(abfd, native);
-    return false;
-  }
+  if (bfd_write ((PTR) native, 1, natsize, abfd) != natsize)
+    {
+      bfd_release (abfd, native);
+      return false;
+    }
   bfd_release (abfd, native);
 
   return true;
@@ -511,34 +516,38 @@ DEFUN(NAME(lynx,squirt_out_relocs),(abfd, section),
 
 /* This is stupid.  This function should be a boolean predicate */
 unsigned int
-DEFUN(NAME(lynx,canonicalize_reloc),(abfd, section, relptr, symbols),
-      bfd *abfd AND
-      sec_ptr section AND
-      arelent **relptr AND
-      asymbol **symbols)
+NAME (lynx, canonicalize_reloc) (abfd, section, relptr, symbols)
+     bfd *abfd;
+     sec_ptr section;
+     arelent **relptr;
+     asymbol **symbols;
 {
   arelent *tblptr = section->relocation;
   unsigned int count;
 
-  if (!(tblptr || NAME(lynx,slurp_reloc_table)(abfd, section, symbols)))
+  if (!(tblptr || NAME (lynx, slurp_reloc_table) (abfd, section, symbols)))
     return 0;
 
-  if (section->flags & SEC_CONSTRUCTOR) {
-    arelent_chain *chain = section->constructor_chain;
-    for (count = 0; count < section->reloc_count; count ++) {
-      *relptr ++ = &chain->relent;
-      chain = chain->next;
+  if (section->flags & SEC_CONSTRUCTOR)
+    {
+      arelent_chain *chain = section->constructor_chain;
+      for (count = 0; count < section->reloc_count; count++)
+	{
+	  *relptr++ = &chain->relent;
+	  chain = chain->next;
+	}
+    }
+  else
+    {
+      tblptr = section->relocation;
+      if (!tblptr)
+	return 0;
+
+      for (count = 0; count++ < section->reloc_count;)
+	{
+	  *relptr++ = tblptr++;
+	}
     }
-  }
-  else {
-    tblptr = section->relocation;
-    if (!tblptr) return 0;
-
-    for (count = 0; count++ < section->reloc_count;) 
-      {
-	*relptr++ = tblptr++;
-      }
-  }
   *relptr = 0;
 
   return section->reloc_count;