* 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, 370 insertions, 347 deletions

diff --git a/bfd/hp300hpux.c b/bfd/hp300hpux.c
index 08f7473..5be01e3 100644
--- a/bfd/hp300hpux.c
+++ b/bfd/hp300hpux.c
@@ -187,26 +187,26 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 /* Set parameters about this a.out file that are machine-dependent.
    This routine is called from some_aout_object_p just before it returns.  */
 static bfd_target *
-DEFUN(MY(callback),(abfd),
-      bfd *abfd)
+MY (callback) (abfd)
+     bfd *abfd;
 {
   struct internal_exec *execp = exec_hdr (abfd);
 
   /* Calculate the file positions of the parts of a newly read aout header */
-  obj_textsec (abfd)->_raw_size = N_TXTSIZE(*execp);
+  obj_textsec (abfd)->_raw_size = N_TXTSIZE (*execp);
 
   /* The virtual memory addresses of the sections */
-  obj_textsec (abfd)->vma = N_TXTADDR(*execp);
-  obj_datasec (abfd)->vma = N_DATADDR(*execp);
-  obj_bsssec  (abfd)->vma = N_BSSADDR(*execp);
+  obj_textsec (abfd)->vma = N_TXTADDR (*execp);
+  obj_datasec (abfd)->vma = N_DATADDR (*execp);
+  obj_bsssec (abfd)->vma = N_BSSADDR (*execp);
 
   /* The file offsets of the sections */
   obj_textsec (abfd)->filepos = N_TXTOFF (*execp);
   obj_datasec (abfd)->filepos = N_DATOFF (*execp);
 
   /* The file offsets of the relocation info */
-  obj_textsec (abfd)->rel_filepos = N_TRELOFF(*execp);
-  obj_datasec (abfd)->rel_filepos = N_DRELOFF(*execp);
+  obj_textsec (abfd)->rel_filepos = N_TRELOFF (*execp);
+  obj_datasec (abfd)->rel_filepos = N_DRELOFF (*execp);
 
   /* The file offsets of the string table and symbol table.  */
   obj_sym_filepos (abfd) = N_SYMOFF (*execp);
@@ -214,161 +214,163 @@ DEFUN(MY(callback),(abfd),
 
   /* Determine the architecture and machine type of the object file.  */
 #ifdef SET_ARCH_MACH
-  SET_ARCH_MACH(abfd, *execp);
+  SET_ARCH_MACH (abfd, *execp);
 #else
-  bfd_default_set_arch_mach(abfd, DEFAULT_ARCH, 0);
+  bfd_default_set_arch_mach (abfd, DEFAULT_ARCH, 0);
 #endif
 
 
-  if (obj_aout_subformat(abfd) == gnu_encap_format)
-  {
+  if (obj_aout_subformat (abfd) == gnu_encap_format)
+    {
       /* The file offsets of the relocation info */
-      obj_textsec (abfd)->rel_filepos = N_GNU_TRELOFF(*execp);
-      obj_datasec (abfd)->rel_filepos = N_GNU_DRELOFF(*execp);
+      obj_textsec (abfd)->rel_filepos = N_GNU_TRELOFF (*execp);
+      obj_datasec (abfd)->rel_filepos = N_GNU_DRELOFF (*execp);
 
       /* The file offsets of the string table and symbol table.  */
-      obj_sym_filepos (abfd) = N_GNU_SYMOFF(*execp);
+      obj_sym_filepos (abfd) = N_GNU_SYMOFF (*execp);
       obj_str_filepos (abfd) = (obj_sym_filepos (abfd) + execp->a_syms);
 
       abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
       bfd_get_symcount (abfd) = execp->a_syms / 12;
       obj_symbol_entry_size (abfd) = 12;
       obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
-  }
+    }
 
   return abfd->xvec;
 }
 
-extern boolean aout_32_write_syms PARAMS ((bfd *abfd));
+extern boolean aout_32_write_syms PARAMS ((bfd * abfd));
 
 static boolean
-DEFUN(MY(write_object_contents),(abfd),
-      bfd *abfd)
+MY (write_object_contents) (abfd)
+     bfd *abfd;
 {
-    struct external_exec exec_bytes;
-    struct internal_exec *execp = exec_hdr (abfd);
-    bfd_size_type text_size; /* dummy vars */			
-    file_ptr text_end;
+  struct external_exec exec_bytes;
+  struct internal_exec *execp = exec_hdr (abfd);
+  bfd_size_type text_size;	/* dummy vars */
+  file_ptr text_end;
 
-    memset (&exec_bytes, 0, sizeof (exec_bytes));
+  memset (&exec_bytes, 0, sizeof (exec_bytes));
 #if CHOOSE_RELOC_SIZE
-    CHOOSE_RELOC_SIZE(abfd);
+  CHOOSE_RELOC_SIZE (abfd);
 #else
-    obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
+  obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
 #endif
 
-    if (adata(abfd).magic == undecided_magic)			
-        NAME(aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end);
-    execp->a_syms = 0;
+  if (adata (abfd).magic == undecided_magic)
+    NAME (aout, adjust_sizes_and_vmas) (abfd, &text_size, &text_end);
+  execp->a_syms = 0;
 
-    execp->a_entry = bfd_get_start_address (abfd);			
+  execp->a_entry = bfd_get_start_address (abfd);
 
-    execp->a_trsize = ((obj_textsec (abfd)->reloc_count) *		
-                       obj_reloc_entry_size (abfd));		
-    execp->a_drsize = ((obj_datasec (abfd)->reloc_count) *		
-                       obj_reloc_entry_size (abfd));		
+  execp->a_trsize = ((obj_textsec (abfd)->reloc_count) *
+		     obj_reloc_entry_size (abfd));
+  execp->a_drsize = ((obj_datasec (abfd)->reloc_count) *
+		     obj_reloc_entry_size (abfd));
 
-    N_SET_MACHTYPE(*execp, 0xc);
-    N_SET_FLAGS (*execp, 0x2);
+  N_SET_MACHTYPE (*execp, 0xc);
+  N_SET_FLAGS (*execp, 0x2);
 
-    NAME(aout,swap_exec_header_out) (abfd, execp, &exec_bytes);	
+  NAME (aout, swap_exec_header_out) (abfd, execp, &exec_bytes);
 
-    /* update fields not covered by default swap_exec_header_out */
+  /* update fields not covered by default swap_exec_header_out */
 
-    /* this is really the sym table size but we store it in drelocs */
-    bfd_h_put_32 (abfd,  bfd_get_symcount (abfd) * 12, exec_bytes.e_drelocs);
+  /* this is really the sym table size but we store it in drelocs */
+  bfd_h_put_32 (abfd, bfd_get_symcount (abfd) * 12, exec_bytes.e_drelocs);
 
-    bfd_seek (abfd, 0L, false);					
-    bfd_write ((PTR) &exec_bytes, 1, EXEC_BYTES_SIZE, abfd);
+  bfd_seek (abfd, 0L, false);
+  bfd_write ((PTR) & exec_bytes, 1, EXEC_BYTES_SIZE, abfd);
 
-    /* Write out the symbols, and then the relocs.  We must write out
+  /* Write out the symbols, and then the relocs.  We must write out
        the symbols first so that we know the symbol indices.  */
 
-    if (bfd_get_symcount (abfd) != 0)
-      {
-	/* Skip the relocs to where we want to put the symbols.  */
-	if (bfd_seek (abfd, (file_ptr) N_DRELOFF (*execp) + execp->a_drsize,
-		      SEEK_SET) != 0)
-	  return false;
-      }
+  if (bfd_get_symcount (abfd) != 0)
+    {
+      /* Skip the relocs to where we want to put the symbols.  */
+      if (bfd_seek (abfd, (file_ptr) N_DRELOFF (*execp) + execp->a_drsize,
+		    SEEK_SET) != 0)
+	return false;
+    }
 
-    if (! MY(write_syms) (abfd))
-      return false;
+  if (!MY (write_syms) (abfd))
+    return false;
 
-    if (bfd_get_symcount (abfd) != 0) 				
-    {								
-        bfd_seek (abfd,	(long)(N_TRELOFF(*execp)), false);	
+  if (bfd_get_symcount (abfd) != 0)
+    {
+      bfd_seek (abfd, (long) (N_TRELOFF (*execp)), false);
 
-        if (!NAME(aout,squirt_out_relocs) (abfd, obj_textsec (abfd))) return false;
-        bfd_seek (abfd, (long)(N_DRELOFF(*execp)), false);	
+      if (!NAME (aout, squirt_out_relocs) (abfd, obj_textsec (abfd)))
+	return false;
+      bfd_seek (abfd, (long) (N_DRELOFF (*execp)), false);
 
-        if (!NAME(aout,squirt_out_relocs)(abfd, obj_datasec (abfd))) return false;
+      if (!NAME (aout, squirt_out_relocs) (abfd, obj_datasec (abfd)))
+	return false;
     }
 
-    return true;
-}									
+  return true;
+}
 
 /* convert the hp symbol type to be the same as aout64.h usage so we */
 /* can piggyback routines in aoutx.h.                                */
 
 static void
-DEFUN(convert_sym_type,(sym_pointer, cache_ptr, abfd),
-      struct external_nlist *sym_pointer AND
-      aout_symbol_type *cache_ptr AND
-      bfd *abfd)
+convert_sym_type (sym_pointer, cache_ptr, abfd)
+     struct external_nlist *sym_pointer;
+     aout_symbol_type *cache_ptr;
+     bfd *abfd;
 {
-    int name_type;
-    int new_type;
+  int name_type;
+  int new_type;
 
-    name_type = (cache_ptr->type);
-    new_type  = 0;
+  name_type = (cache_ptr->type);
+  new_type = 0;
 
-    if ((name_type & HP_SYMTYPE_ALIGN) != 0)
+  if ((name_type & HP_SYMTYPE_ALIGN) != 0)
     {
-        /* iou_error ("aligned symbol encountered: %s", name);*/
-        name_type = 0;
+      /* iou_error ("aligned symbol encountered: %s", name);*/
+      name_type = 0;
     }
 
-    if (name_type == HP_SYMTYPE_FILENAME)
-      new_type = N_FN;
-    else
-      {
-	switch (name_type & HP_SYMTYPE_TYPE)
-	  {
-	  case HP_SYMTYPE_UNDEFINED:
-	    new_type = N_UNDF;
-	    break;
-
-	  case HP_SYMTYPE_ABSOLUTE:
-	    new_type = N_ABS;
-	    break;
-
-	  case HP_SYMTYPE_TEXT:
-	    new_type = N_TEXT;
-	    break;
-
-	  case HP_SYMTYPE_DATA:
-	    new_type = N_DATA;
-	    break;
-
-	  case HP_SYMTYPE_BSS:
-	    new_type = N_BSS;
-	    break;
-
-	  case HP_SYMTYPE_COMMON:
-	    new_type = N_COMM;
-	    break;
-
-	  default:
-	    fprintf (stderr, "unknown symbol type encountered: %x", name_type);
-	  }
-	if (name_type & HP_SYMTYPE_EXTERNAL)
-	  new_type |= N_EXT;
-
-        if (name_type & HP_SECONDARY_SYMBOL)
-            new_type = (new_type & ~N_TYPE) | N_INDR;
-      }
-    cache_ptr->type = new_type;
+  if (name_type == HP_SYMTYPE_FILENAME)
+    new_type = N_FN;
+  else
+    {
+      switch (name_type & HP_SYMTYPE_TYPE)
+	{
+	case HP_SYMTYPE_UNDEFINED:
+	  new_type = N_UNDF;
+	  break;
+
+	case HP_SYMTYPE_ABSOLUTE:
+	  new_type = N_ABS;
+	  break;
+
+	case HP_SYMTYPE_TEXT:
+	  new_type = N_TEXT;
+	  break;
+
+	case HP_SYMTYPE_DATA:
+	  new_type = N_DATA;
+	  break;
+
+	case HP_SYMTYPE_BSS:
+	  new_type = N_BSS;
+	  break;
+
+	case HP_SYMTYPE_COMMON:
+	  new_type = N_COMM;
+	  break;
+
+	default:
+	  fprintf (stderr, "unknown symbol type encountered: %x", name_type);
+	}
+      if (name_type & HP_SYMTYPE_EXTERNAL)
+	new_type |= N_EXT;
+
+      if (name_type & HP_SECONDARY_SYMBOL)
+	new_type = (new_type & ~N_TYPE) | N_INDR;
+    }
+  cache_ptr->type = new_type;
 
 }
 
@@ -381,12 +383,12 @@ DESCRIPTION
 */
 
 void
-DEFUN(NAME(aout,swap_exec_header_in),(abfd, raw_bytes, execp),
-      bfd *abfd AND
-      struct external_exec *raw_bytes AND
-      struct internal_exec *execp)
+  NAME (aout, swap_exec_header_in) (abfd, raw_bytes, execp)
+     bfd *abfd;
+     struct external_exec *raw_bytes;
+     struct internal_exec *execp;
 {
-  struct external_exec *bytes = (struct external_exec *)raw_bytes;
+  struct external_exec *bytes = (struct external_exec *) raw_bytes;
 
   /* The internal_exec structure has some fields that are unused in this
      configuration (IE for i960), so ensure that all such uninitialized
@@ -394,12 +396,12 @@ DEFUN(NAME(aout,swap_exec_header_in),(abfd, raw_bytes, execp),
      are memcmp'd, and thus the contents do matter. */
   memset (execp, 0, sizeof (struct internal_exec));
   /* Now fill in fields in the execp, from the bytes in the raw data.  */
-  execp->a_info   = bfd_h_get_32 (abfd, bytes->e_info);
-  execp->a_text   = GET_WORD (abfd, bytes->e_text);
-  execp->a_data   = GET_WORD (abfd, bytes->e_data);
-  execp->a_bss    = GET_WORD (abfd, bytes->e_bss);
-  execp->a_syms   = GET_WORD (abfd, bytes->e_syms);
-  execp->a_entry  = GET_WORD (abfd, bytes->e_entry);
+  execp->a_info = bfd_h_get_32 (abfd, bytes->e_info);
+  execp->a_text = GET_WORD (abfd, bytes->e_text);
+  execp->a_data = GET_WORD (abfd, bytes->e_data);
+  execp->a_bss = GET_WORD (abfd, bytes->e_bss);
+  execp->a_syms = GET_WORD (abfd, bytes->e_syms);
+  execp->a_entry = GET_WORD (abfd, bytes->e_entry);
   execp->a_trsize = GET_WORD (abfd, bytes->e_trsize);
   execp->a_drsize = GET_WORD (abfd, bytes->e_drsize);
 
@@ -410,29 +412,35 @@ DEFUN(NAME(aout,swap_exec_header_in),(abfd, raw_bytes, execp),
   /* to be set.                                                  */
   /***************************************************************/
   do
-  {
+    {
       long syms;
-      struct aout_data_struct  *rawptr;
-      if (bfd_h_get_32 (abfd, bytes->e_passize) != 0) break;
-      if (bfd_h_get_32 (abfd, bytes->e_syms) != 0) break;
-      if (bfd_h_get_32 (abfd, bytes->e_supsize) != 0) break;
+      struct aout_data_struct *rawptr;
+      if (bfd_h_get_32 (abfd, bytes->e_passize) != 0)
+	break;
+      if (bfd_h_get_32 (abfd, bytes->e_syms) != 0)
+	break;
+      if (bfd_h_get_32 (abfd, bytes->e_supsize) != 0)
+	break;
 
       syms = bfd_h_get_32 (abfd, bytes->e_drelocs);
-      if (syms == 0) break;
+      if (syms == 0)
+	break;
 
       /* OK, we've passed the test as best as we can determine */
       execp->a_syms = syms;
 
       /* allocate storage for where we will store this result */
-      rawptr = (struct aout_data_struct  *) bfd_zalloc (abfd, sizeof (*rawptr));
+      rawptr = (struct aout_data_struct *) bfd_zalloc (abfd, sizeof (*rawptr));
 
-      if (rawptr == NULL) {
-          bfd_error = no_memory;
-          return;
-      }
+      if (rawptr == NULL)
+	{
+	  bfd_set_error (bfd_error_no_memory);
+	  return;
+	}
       abfd->tdata.aout_data = rawptr;
-      obj_aout_subformat(abfd) = gnu_encap_format;
-  } while (0);
+      obj_aout_subformat (abfd) = gnu_encap_format;
+    }
+  while (0);
 }
 
 
@@ -460,8 +468,8 @@ DEFUN(NAME(aout,swap_exec_header_in),(abfd, raw_bytes, execp),
 */
 
 boolean
-DEFUN(MY(slurp_symbol_table),(abfd),
-      bfd *abfd)
+MY (slurp_symbol_table) (abfd)
+     bfd *abfd;
 {
   bfd_size_type symbol_bytes;
   struct external_nlist *syms;
@@ -473,50 +481,52 @@ DEFUN(MY(slurp_symbol_table),(abfd),
   unsigned num_secondary = 0;
 
   /* If there's no work to be done, don't do any */
-  if (obj_aout_symbols (abfd) != (aout_symbol_type *)NULL) return true;
-  symbol_bytes = exec_hdr(abfd)->a_syms;
-  if (symbol_bytes == 0) {
-    bfd_error = no_symbols;
-    return false;
-  }
+  if (obj_aout_symbols (abfd) != (aout_symbol_type *) NULL)
+    return true;
+  symbol_bytes = exec_hdr (abfd)->a_syms;
+  if (symbol_bytes == 0)
+    {
+      bfd_set_error (bfd_error_no_symbols);
+      return false;
+    }
 
-  strings = (char *) bfd_alloc(abfd,
-                               symbol_bytes + SYM_EXTRA_BYTES);
+  strings = (char *) bfd_alloc (abfd,
+				symbol_bytes + SYM_EXTRA_BYTES);
   if (!strings)
     {
-      bfd_error = no_memory;
+      bfd_set_error (bfd_error_no_memory);
       return false;
     }
   syms = (struct external_nlist *) (strings + SYM_EXTRA_BYTES);
   bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET);
-  if (bfd_read ((PTR)syms, symbol_bytes, 1, abfd) != symbol_bytes)
-  {
+  if (bfd_read ((PTR) syms, symbol_bytes, 1, abfd) != symbol_bytes)
+    {
       bfd_release (abfd, syms);
       return false;
-  }
+    }
 
 
-  sym_end = (struct external_nlist *) (((char *)syms) + symbol_bytes);
+  sym_end = (struct external_nlist *) (((char *) syms) + symbol_bytes);
 
   /* first, march thru the table and figure out how many symbols there are */
   for (sym_pointer = syms; sym_pointer < sym_end; sym_pointer++, num_syms++)
-  {
-      if (bfd_get_8(abfd,  sym_pointer->e_type) & HP_SECONDARY_SYMBOL)
-          num_secondary++;
+    {
+      if (bfd_get_8 (abfd, sym_pointer->e_type) & HP_SECONDARY_SYMBOL)
+	num_secondary++;
       /* skip over the embedded symbol. */
-      sym_pointer = (struct external_nlist *) (((char *)sym_pointer) +
-                                                     sym_pointer->e_length[0]);
-  }
+      sym_pointer = (struct external_nlist *) (((char *) sym_pointer) +
+					       sym_pointer->e_length[0]);
+    }
 
   /* now that we know the symbol count, update the bfd header */
-  bfd_get_symcount (abfd) = num_syms+num_secondary;
+  bfd_get_symcount (abfd) = num_syms + num_secondary;
 
   cached = (aout_symbol_type *)
-    bfd_zalloc(abfd, (bfd_size_type)(bfd_get_symcount (abfd) *
-                                     sizeof(aout_symbol_type)));
+    bfd_zalloc (abfd, (bfd_size_type) (bfd_get_symcount (abfd) *
+				       sizeof (aout_symbol_type)));
   if (!cached)
     {
-      bfd_error = no_memory;
+      bfd_set_error (bfd_error_no_memory);
       return false;
     }
 
@@ -527,82 +537,82 @@ DEFUN(MY(slurp_symbol_table),(abfd),
   num_secondary = 0;
 
   /* OK, now walk the new symtable, cacheing symbol properties */
-    {
-      aout_symbol_type *cache_ptr = cached;
-      aout_symbol_type cache_save;
-      /* Run through table and copy values */
-      for (sym_pointer = syms, cache_ptr = cached;
-	   sym_pointer < sym_end; sym_pointer++, cache_ptr++)
+  {
+    aout_symbol_type *cache_ptr = cached;
+    aout_symbol_type cache_save;
+    /* Run through table and copy values */
+    for (sym_pointer = syms, cache_ptr = cached;
+	 sym_pointer < sym_end; sym_pointer++, cache_ptr++)
+      {
+	unsigned int length;
+	cache_ptr->symbol.the_bfd = abfd;
+	cache_ptr->symbol.value = GET_SWORD (abfd, sym_pointer->e_value);
+	cache_ptr->desc = bfd_get_16 (abfd, sym_pointer->e_almod);
+	cache_ptr->type = bfd_get_8 (abfd, sym_pointer->e_type);
+	cache_ptr->symbol.udata = 0;
+	length = bfd_get_8 (abfd, sym_pointer->e_length);
+	cache_ptr->other = length;	/* other not used, save length here */
+
+	cache_save = *cache_ptr;
+	convert_sym_type (sym_pointer, cache_ptr, abfd);
+	if (!translate_from_native_sym_flags (sym_pointer, cache_ptr, abfd))
+	  return false;
+
+	/********************************************************/
+	/* for hpux, the 'lenght' value indicates the length of */
+	/* the symbol name which follows the nlist entry.       */
+	/********************************************************/
+	if (length)
 	  {
-            unsigned int length;
-	    cache_ptr->symbol.the_bfd = abfd;
-	    cache_ptr->symbol.value = GET_SWORD(abfd,  sym_pointer->e_value);
-	    cache_ptr->desc = bfd_get_16(abfd, sym_pointer->e_almod);
-	    cache_ptr->type = bfd_get_8(abfd,  sym_pointer->e_type);
-	    cache_ptr->symbol.udata = 0;
-            length = bfd_get_8(abfd, sym_pointer->e_length);
-	    cache_ptr->other = length;  /* other not used, save length here */
-
-            cache_save = *cache_ptr;
-            convert_sym_type(sym_pointer, cache_ptr, abfd);
-	    if (!translate_from_native_sym_flags (sym_pointer, cache_ptr, abfd))
+	    /**************************************************************/
+	    /* the hp string is not null terminated so we create a new one*/
+	    /* by copying the string to overlap the just vacated nlist    */
+	    /* structure before it in memory.                             */
+	    /**************************************************************/
+	    cache_ptr->symbol.name = strings;
+	    memcpy (strings, sym_pointer + 1, length);
+	    strings[length] = '\0';
+	    strings += length + 1;
+	  }
+	else
+	  cache_ptr->symbol.name = (char *) NULL;
+
+	/**********************************************************/
+	/* this is a bit of a kludge, but a secondary hp symbol   */
+	/* gets translated into a gnu indirect symbol.  When this */
+	/* happens, we need to create a "dummy" record to which   */
+	/* we can point the indirect symbol to.                   */
+	/**********************************************************/
+	if ((cache_ptr->type | N_EXT) == (N_INDR | N_EXT))
+	  {
+	    aout_symbol_type *cache_ptr2 = cached + num_syms + num_secondary;
+
+	    num_secondary++;
+
+	    /* aoutx.h assumes the "next" value is the indirect sym  */
+	    /* since we don't want to disturb the order by inserting */
+	    /* a new symbol, we tack on the created secondary syms   */
+	    /* at the end.                                           */
+	    cache_ptr->symbol.value = (bfd_vma) (cache_ptr2);
+	    *cache_ptr2 = cache_save;
+	    cache_ptr2->symbol.name = strings;
+	    memcpy (strings, cache_ptr->symbol.name, length);
+	    strcpy (strings + length, ":secondry");	/* 9 max chars + null */
+	    strings += length + 10;
+	    cache_ptr2->type &= ~HP_SECONDARY_SYMBOL;	/* clear secondary */
+	    convert_sym_type (sym_pointer, cache_ptr2, abfd);
+	    if (!translate_from_native_sym_flags (sym_pointer, cache_ptr2,
+						  abfd))
 	      return false;
-
-            /********************************************************/
-            /* for hpux, the 'lenght' value indicates the length of */
-            /* the symbol name which follows the nlist entry.       */
-            /********************************************************/
-            if (length)
-            {
-                /**************************************************************/
-                /* the hp string is not null terminated so we create a new one*/
-                /* by copying the string to overlap the just vacated nlist    */
-                /* structure before it in memory.                             */
-                /**************************************************************/
-                cache_ptr->symbol.name = strings;
-                memcpy(strings, sym_pointer+1, length);
-                strings[length] = '\0';
-                strings += length + 1;
-            }
-	    else
-	      cache_ptr->symbol.name = (char *)NULL;
-
-            /**********************************************************/
-            /* this is a bit of a kludge, but a secondary hp symbol   */
-            /* gets translated into a gnu indirect symbol.  When this */
-            /* happens, we need to create a "dummy" record to which   */
-            /* we can point the indirect symbol to.                   */
-            /**********************************************************/
-            if ((cache_ptr->type | N_EXT) == (N_INDR | N_EXT))
-            {
-                aout_symbol_type *cache_ptr2 = cached + num_syms+num_secondary;
-
-                num_secondary++;
-
-                /* aoutx.h assumes the "next" value is the indirect sym  */
-                /* since we don't want to disturb the order by inserting */
-                /* a new symbol, we tack on the created secondary syms   */
-                /* at the end.                                           */
-                cache_ptr->symbol.value = (bfd_vma)(cache_ptr2);
-                *cache_ptr2 = cache_save;
-                cache_ptr2->symbol.name = strings;
-                memcpy(strings, cache_ptr->symbol.name, length);
-                strcpy(strings+length,":secondry"); /* 9 max chars + null */
-                strings += length+10;
-                cache_ptr2->type &= ~HP_SECONDARY_SYMBOL;  /* clear secondary */
-                convert_sym_type(sym_pointer, cache_ptr2, abfd);
-                if (!translate_from_native_sym_flags (sym_pointer, cache_ptr2,
-						      abfd))
-		  return false;
-            }
-
-            /* skip over the embedded symbol. */
-            sym_pointer = (struct external_nlist *) (((char *)sym_pointer) +
-                                                 length);
 	  }
-    }
 
-  obj_aout_symbols (abfd) =  cached;
+	/* skip over the embedded symbol. */
+	sym_pointer = (struct external_nlist *) (((char *) sym_pointer) +
+						 length);
+      }
+  }
+
+  obj_aout_symbols (abfd) = cached;
 
   return true;
 }
@@ -610,49 +620,49 @@ DEFUN(MY(slurp_symbol_table),(abfd),
 
 
 void
-DEFUN(MY(swap_std_reloc_in), (abfd, bytes, cache_ptr, symbols),
-  bfd *abfd AND
-  struct hp300hpux_reloc *bytes AND
-  arelent *cache_ptr AND
-  asymbol **symbols)
+MY (swap_std_reloc_in) (abfd, bytes, cache_ptr, symbols)
+     bfd *abfd;
+     struct hp300hpux_reloc *bytes;
+     arelent *cache_ptr;
+     asymbol **symbols;
 {
   int r_index;
   int r_extern = 0;
   unsigned int r_length;
   int r_pcrel = 0;
-  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 = bfd_h_get_16(abfd, bytes->r_index);
+  r_index = bfd_h_get_16 (abfd, bytes->r_index);
 
   switch (bytes->r_type[0])
-  {
-  case HP_RSEGMENT_TEXT:
+    {
+    case HP_RSEGMENT_TEXT:
       r_index = N_TEXT;
       break;
-  case HP_RSEGMENT_DATA:
+    case HP_RSEGMENT_DATA:
       r_index = N_DATA;
       break;
-  case HP_RSEGMENT_BSS:
+    case HP_RSEGMENT_BSS:
       r_index = N_BSS;
       break;
-  case HP_RSEGMENT_EXTERNAL:
+    case HP_RSEGMENT_EXTERNAL:
       r_extern = 1;
       break;
-  case HP_RSEGMENT_PCREL:
+    case HP_RSEGMENT_PCREL:
       r_extern = 1;
       r_pcrel = 1;
       break;
-  case HP_RSEGMENT_RDLT:
+    case HP_RSEGMENT_RDLT:
       break;
-  case HP_RSEGMENT_RPLT:
+    case HP_RSEGMENT_RPLT:
       break;
-  case HP_RSEGMENT_NOOP:
+    case HP_RSEGMENT_NOOP:
       break;
-  default:
+    default:
       fprintf (stderr, "illegal relocation segment type: %x\n",
 	       (bytes->r_type[0]));
-  }
+    }
 
   switch (bytes->r_length[0])
     {
@@ -666,32 +676,32 @@ DEFUN(MY(swap_std_reloc_in), (abfd, bytes, cache_ptr, symbols),
       r_length = 2;
       break;
     default:
-      fprintf (stderr, "illegal relocation length: %x\n",bytes->r_length[0] );
+      fprintf (stderr, "illegal relocation length: %x\n", bytes->r_length[0]);
       r_length = 0;
     }
 
-  cache_ptr->howto =  howto_table_std + r_length + 4 * r_pcrel;
+  cache_ptr->howto = howto_table_std + r_length + 4 * r_pcrel;
   /* FIXME-soon:  Roll baserel, jmptable, relative bits into howto setting */
 
   /* This macro uses the r_index value computed above */
   if (r_pcrel && r_extern)
-  {
-    /* The GNU linker assumes any offset from beginning of section */
-    /* is already incorporated into the image while the HP linker  */
-    /* adds this in later.  Add it in now...                       */
-    MOVE_ADDRESS( - cache_ptr->address);
-  }
+    {
+      /* The GNU linker assumes any offset from beginning of section */
+      /* is already incorporated into the image while the HP linker  */
+      /* adds this in later.  Add it in now...                       */
+      MOVE_ADDRESS (-cache_ptr->address);
+    }
   else
-  {
-    MOVE_ADDRESS(0);
-  }
+    {
+      MOVE_ADDRESS (0);
+    }
 }
 
 boolean
-DEFUN(MY(slurp_reloc_table),(abfd, asect, symbols),
-      bfd *abfd AND
-      sec_ptr asect AND
-      asymbol **symbols)
+MY (slurp_reloc_table) (abfd, asect, symbols)
+     bfd *abfd;
+     sec_ptr asect;
+     asymbol **symbols;
 {
   unsigned int count;
   bfd_size_type reloc_size;
@@ -702,61 +712,68 @@ DEFUN(MY(slurp_reloc_table),(abfd, asect, symbols),
   unsigned int counter;
   arelent *cache_ptr;
 
-  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 (!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 (bfd_read (relocs, 1, reloc_size, abfd) != reloc_size)
+    {
+      bfd_release (abfd, relocs);
+      bfd_release (abfd, reloc_cache);
+      return false;
+    }
 
-    rptr = (struct hp300hpux_reloc*) relocs;
-    counter = 0;
-    cache_ptr = reloc_cache;
+  rptr = (struct hp300hpux_reloc *) relocs;
+  counter = 0;
+  cache_ptr = reloc_cache;
 
-    for (; counter < count; counter++, rptr++, cache_ptr++) {
-	MY(swap_std_reloc_in)(abfd, rptr, cache_ptr, symbols);
+  for (; counter < count; counter++, rptr++, cache_ptr++)
+    {
+      MY (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;
@@ -769,77 +786,83 @@ nomem:
 /* call aout_32 versions if the input file was generated by gcc         */
 /************************************************************************/
 
-unsigned int aout_32_get_symtab PARAMS((bfd *abfd, asymbol **location));
-unsigned int aout_32_get_symtab_upper_bound PARAMS ((bfd *abfd));
+unsigned int aout_32_get_symtab PARAMS ((bfd * abfd, asymbol ** location));
+unsigned int aout_32_get_symtab_upper_bound PARAMS ((bfd * abfd));
 
-unsigned int aout_32_canonicalize_reloc PARAMS((bfd *abfd, sec_ptr section,
-                                                arelent **relptr,
-                                                asymbol **symbols));
+unsigned int aout_32_canonicalize_reloc PARAMS ((bfd * abfd, sec_ptr section,
+						 arelent ** relptr,
+						 asymbol ** symbols));
 
 unsigned int
-DEFUN(MY(get_symtab),(abfd, location),
-      bfd *abfd AND
-      asymbol **location)
+MY (get_symtab) (abfd, location)
+     bfd *abfd;
+     asymbol **location;
 {
-    unsigned int counter = 0;
-    aout_symbol_type *symbase;
+  unsigned int counter = 0;
+  aout_symbol_type *symbase;
 
-    if (obj_aout_subformat(abfd) == gnu_encap_format)
-        return aout_32_get_symtab(abfd,location);
+  if (obj_aout_subformat (abfd) == gnu_encap_format)
+    return aout_32_get_symtab (abfd, location);
 
-    if (!MY(slurp_symbol_table)(abfd)) return 0;
+  if (!MY (slurp_symbol_table) (abfd))
+    return 0;
 
-    for (symbase = obj_aout_symbols(abfd); counter++ < bfd_get_symcount (abfd);)
-      *(location++) = (asymbol *)( symbase++);
-    *location++ =0;
-    return bfd_get_symcount (abfd);
+  for (symbase = obj_aout_symbols (abfd); counter++ < bfd_get_symcount (abfd);)
+    *(location++) = (asymbol *) (symbase++);
+  *location++ = 0;
+  return bfd_get_symcount (abfd);
 }
 
- unsigned int
-DEFUN(MY(get_symtab_upper_bound),(abfd),
-     bfd *abfd)
+unsigned int
+MY (get_symtab_upper_bound) (abfd)
+     bfd *abfd;
 {
-    if (obj_aout_subformat(abfd) == gnu_encap_format)
-        return aout_32_get_symtab_upper_bound(abfd);
-    if (!MY(slurp_symbol_table)(abfd)) return 0;
+  if (obj_aout_subformat (abfd) == gnu_encap_format)
+    return aout_32_get_symtab_upper_bound (abfd);
+  if (!MY (slurp_symbol_table) (abfd))
+    return 0;
 
-    return (bfd_get_symcount (abfd)+1) * (sizeof (aout_symbol_type *));
+  return (bfd_get_symcount (abfd) + 1) * (sizeof (aout_symbol_type *));
 }
 
 
 
 
 unsigned int
-DEFUN(MY(canonicalize_reloc),(abfd, section, relptr, symbols),
-      bfd *abfd AND
-      sec_ptr section AND
-      arelent **relptr AND
-      asymbol **symbols)
+MY (canonicalize_reloc) (abfd, section, relptr, symbols)
+     bfd *abfd;
+     sec_ptr section;
+     arelent **relptr;
+     asymbol **symbols;
 {
   arelent *tblptr = section->relocation;
   unsigned int count;
-  if (obj_aout_subformat(abfd) == gnu_encap_format)
-      return aout_32_canonicalize_reloc(abfd,section,relptr,symbols);
+  if (obj_aout_subformat (abfd) == gnu_encap_format)
+    return aout_32_canonicalize_reloc (abfd, section, relptr, symbols);
 
-  if (!(tblptr || MY(slurp_reloc_table)(abfd, section, symbols)))
+  if (!(tblptr || MY (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;