Make all callers of malloc or realloc (including via obstacks)

	check the result for NULL.  Most set bfd_error to no_memory and
	return in that case; a few are harder to fix, and are marked
	with "FIXME <return type>".

	* elf32-hppa.c (hppa_elf_build_arg_reloc_stub
	hppa_elf_build_long_branch_stub):  Check bfd_make_empty_symbol return.
	* linker.c (_bfd_generic_link_output_symbols
	_bfd_generic_link_write_global_symbol): Ditto
	* section.c (bfd_make_section_anyway): Ditto.

	* tekhex.c (find_chunk tekhex_mkobject): Check bfd_alloc.
	(first_phase): Ditto.  FIXME void
	(tekhex_make_empty_symbol): Check bfd_zalloc.

	* sunos.c (sunos_read_dynamic_info): Check bfd_zalloc.
	(MY(read_dynamic_symbols) MY(read_dynamic_relocs)): Check bfd_alloc.

	* stringhash.c (_bfd_stringtab_hash_newfunc): Check bfd_hash_allocate.

	* srec.c: Indent.
	(fillup_symbols): Check bfd_alloc.  FIXME void
	(srec_mkobject srec_get_section_contents
	srec_set_section_contents): Check bfd_alloc.
	(srec_make_empty_symbol): Check bfd_zalloc.

	* som.c (hppa_som_gen_reloc_type): Check bfd_alloc_by_size_t.
	(make_unique_section): Check bfd_alloc.
	(som_new_section_hook): Check bfd_zalloc.
	(bfd_som_attach_aux_hdr): Ditto.  FIXME void

	* rs6000-core.c (rs6000coff_core_p): Check bfd_zalloc.

	* osf-core.c (osf_core_make_empty_symbol): Check bfd_zalloc.
	(osf_core_core_file_p): Check bfd_alloc.

	* oasys.c (oasys_slurp_symbol_table oasys_archive_p
	oasys_mkobject oasys_object_p oasys_new_section_hook
	oasys_set_section_contents): Check bfd_alloc.
	(oasys_slurp_section_data): Check bfd_zalloc and bfd_alloc.
	(oasys_make_empty_symbol): Check bfd_zalloc.

	* nlmcode.h (nlm_make_empty_symbol): Check bfd_zalloc.
	(nlm_slurp_symbol_table): Check bfd_zalloc and bfd_alloc.

	* nlm32-sparc.c (nlm_sparc_read_import): Check bfd_alloc.

	* nlm32-i386.c (nlm_i386_read_import): Check bfd_alloc.

	* nlm32-alpha.c (nlm_alpha_read_import): Check bfd_alloc.

	* linker.c (_bfd_link_hash_newfunc
	(generic_link_hash_newfunc
	(archive_hash_newfunc
	(_bfd_generic_link_add_one_symbol): Check bfd_hash_allocate.
	(_bfd_generic_final_link
	(_bfd_generic_link_output_symbols
	(default_indirect_link_order): Check bfd_alloc.
	(bfd_new_link_order): Check bfd_alloc_by_size_t.

	* irix-core.c (irix_core_make_empty_symbol): Check bfd_zalloc.

	* ieee.c: Indent.
	(read_id get_symbol get_section_entry ieee_archive_p ieee_object_p
	ieee_slurp_section_data ieee_new_section_hook): Check bfd_alloc.
	(do_one): Check bfd_alloc.  Return a boolean.
	(ieee_slurp_section_data): Check it.
	(init_for_output): Check bfd_alloc.  Return a boolean.
	(ieee_set_section_contents): Check it.
	(do_with_relocs):  Check bfd_alloc.  Return a boolean.
	(ieee_bfd_debug_info_accumulate): Ditto.  FIXME void.
	(ieee_mkobject): Check bfd_zalloc.
	(ieee_make_empty_symbol): Check bfd_zmalloc.

	* hpux-core.c (hpux_core_make_empty_symbol): Check
	bfd_zalloc.

	* hppabsd-core.c (hppabsd_core_make_empty_symbol): Check
	bfd_zalloc.
	(hppabsd_core_core_file_p): Check bfd_zalloc.

	* hp300hpux.c (MY(slurp_symbol_table)): Check bfd_alloc.

	* elfcode.h (elf_new_section_hook): Check bfd_alloc.
	(bfd_section_from_phdr): Ditto.
	(write_relocs): Ditto.  FIXME void
	(elf_map_symbols assign_section_numbers map_program_segments):
	Ditto.  Return a boolean.
	(swap_out_syms): Ditto.  Check elf_map_symbols.
	(elf_slurp_symbol_table): Check bfd_zalloc.
	(elf_slurp_reloca_table): Check bfd_alloc.
	(elf_slurp_reloc_table): Ditto.
	(elf_compute_section_file_positions): Check assign_section_numbers.
	(assign_file_positions_except_relocs): Return a boolean.
	Check map_program_segments.
	(elf_compute_section_file_positions): Check it.

	* elf32-mips.c (mips_elf_final_link): Check bfd_alloc.

	* elf32-hppa.c (hppa_elf_stub_branch_reloc): Check bfd_zmalloc and
	realloc.
	(hppa_elf_stub_reloc): Ditto.
	(hppa_elf_build_arg_reloc_stub): Check bfd_zalloc.
	(hppa_elf_build_long_branch_stub): Ditto.
	(elf32_hppa_backend_symbol_table_processing): Ditto.

	* ecoff.c (ecoff_set_symbol_info): Check bfd_alloc.  Return a boolean.
	(ecoff_slurp_symbol_table): Check it.
	(ecoff_slurp_armap): Check bfd_alloc.
	(ecoff_write_armap): Check bfd_zalloc.
	(ecoff_link_hash_newfunc): Check bfd_hash_allocate and
	_bfd_link_hash_newfunc.
	(ecoff_link_add_externals): Check bfd_alloc.

	* ctor.c (bfd_constructor_entry): Check bfd_alloc.

	* coffgen.c (coff_real_object_p): Check bfd_alloc.
	(coff_renumber_symbols): Check bfd_alloc_by_size_t.  Return a boolean.
	(coff_write_symbol): Check bfd_alloc.  FIXME int
	(coff_write_linenumbers): Check bfd_alloc.  Return a boolean.
	(coff_section_symbol): Check bfd_alloc_by_size_t.
	(coff_get_normalized_symtab): Check bfd_alloc.
	(coff_bfd_make_debug_symbol): Check bfd_zalloc.
	* libcoff-in.h: Change decls of coff_renumber_symbols,
	coff_write_linenumbers.
	* libcoff.h: Rebuilt.
	* coffcode.h (coff_write_object_contents): Check
	coff_renumber_symbols, coff_write_linenumbers.

	* coffcode.h: Indent.
	(coff_add_missing_symbols): Check bfd_alloc_by_size_t.  Return a
	boolean.
	(coff_write_object_contents): Check it.

	* coff-alpha.c (alpha_relocate_section): Check bfd_alloc.
	* coff-mips.c (mips_relocate_section): Ditto.

	* archive.c (bfd_slurp_bsd_armap_f2): Check bfd_alloc value.
	(do_slurp_bsd_armap): Ditto.
	(compute_and_write_armap): Check bfd_realloc value.

	* aoutx.h (translate_from_native_sym_flags): Check bfd_alloc
	return value.  Return boolean value.
	(NAME(aout,make_empty_symbol)): Check bfd_zalloc return value.
	(NAME(aout,slurp_symbol_table)): Check bf_alloc and bfd_zalloc
	return value.
	(add_to_stringtab): Ditto.  FIXME void
	(aout_link_hash_newfunc): Check bfd_hash_allocate return value.
	(aout_link_add_symbols): Check bfd_alloc value.
	(translate_symbol_table): Check translate_from_native_sym_flags.
	* hp300hpux.c (MY(slurp_symbol_table)): Ditto.
	* aoutx.h (aout_link_hash_newfunc): Check _bfd_link_hash_newfunc.

	* opncls.c (bfd_zalloc bfd_realloc): Check result of bfd_alloc.

	* opncls.c (obstack_chunk_alloc): Define as malloc, not
	bfd_xmalloc_by_size_t.
	(_bfd_new_bfd): Check obstack_begin for 0 return.

	* ieee.c (obstack_chunk_alloc): Define as malloc, not
	bfd_xmalloc_by_size_t.
	(ieee_archive_p): Check obstack_begin for 0 return and
	obstack_finish for NULL return.

	* hash.c (obstack_chunk_alloc): Define as malloc, not
	bfd_xmalloc_by_size_t.
	(bfd_hash_table_init_n): Check obstack_begin for 0 return and
	obstack_finish for NULL return.
	(bfd_hash_lookup): Check obstack_alloc for NULL return.

	* ecofflink.c (obstack_chunk_alloc): Define as malloc, not
	bfd_xmalloc_by_size_t.
	bfd_ecoff_debug_accumulate
	bfd_ecoff_debug_accumulate_other): Check obstack_alloc.
	(add_file_shuffle add_memory_shuffle): Check obstack_alloc for
	NULL return.  Return boolean, not void.
	(bfd_ecoff_debug_init): Check obstack_begin for 0 return.
	(bfd_ecoff_debug_accumulate): Check add_file_shuffle
	and add_memory_shuffle return.
	(string_hash_newfunc): Check bfd_hash_allocate and bfd_hash_newfunc.
	(bfd_ecoff_debug_accumulate): Check bfd_alloc.
	(ecoff_add_string): Check add_memory_shuffle return.

	* libbfd-in.h (xmalloc, bfd_xmalloc, bfd_xmalloc_by_size_t):
	Remove decls.
	* libbfd.h: Rebuilt.

1 files changed, 988 insertions, 883 deletions

diff --git a/bfd/coffcode.h b/bfd/coffcode.h
index 5c9b576..8f4e25e 100644
--- a/bfd/coffcode.h
+++ b/bfd/coffcode.h
@@ -18,9 +18,9 @@ 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
-/* 
+/*
 Most of this hacked by  Steve Chamberlain,
-			sac@cygnus.com 
+			sac@cygnus.com
 */
 /*
 
@@ -30,7 +30,7 @@ SECTION
 	BFD supports a number of different flavours of coff format.
 	The major differences between formats are the sizes and
 	alignments of fields in structures on disk, and the occasional
-	extra field.  
+	extra field.
 
 	Coff in all its varieties is implemented with a few common
 	files and a number of implementation specific files. For
@@ -45,7 +45,7 @@ SECTION
 	The Intel i960 processor version of coff is implemented in
 	@file{coff-i960.c}. This file has the same structure as
 	@file{coff-m88k.c}, except that it includes @file{coff/i960.h}
-	rather than @file{coff-m88k.h}. 
+	rather than @file{coff-m88k.h}.
 
 SUBSECTION
 	Porting to a new version of coff
@@ -61,7 +61,7 @@ SUBSECTION
 	structures in @file{../include/coff/foo.h} so that they match
 	what you need. You will probably also have to add
 	@code{#ifdef}s to the code in @file{coff/internal.h} and
-	@file{coffcode.h} if your version of coff is too wild. 
+	@file{coffcode.h} if your version of coff is too wild.
 
 	You can verify that your new BFD backend works quite simply by
 	building @file{objdump} from the @file{binutils} directory,
@@ -127,7 +127,7 @@ SUBSUBSECTION
 	@code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
 	correct one. No doubt, some day someone will find a version of
 	coff which has a varying field size not catered to at the
-	moment. To port BFD, that person will have to add more @code{#defines}.  
+	moment. To port BFD, that person will have to add more @code{#defines}.
 	Three of the bit twiddling routines are exported to
 	@code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
 	and @code{coff_swap_linno_in}. @code{GDB} reads the symbol
@@ -149,7 +149,7 @@ SUBSUBSECTION
 	The simple canonical form for symbols used by BFD is not rich
 	enough to keep all the information available in a coff symbol
 	table. The back end gets around this problem by keeping the original
-	symbol table around, "behind the scenes". 
+	symbol table around, "behind the scenes".
 
 	When a symbol table is requested (through a call to
 	@code{bfd_canonicalize_symtab}), a request gets through to
@@ -166,7 +166,7 @@ SUBSUBSECTION
 	(<<C_FILE>> symbols) are modified so that the internal
 	string points to the value in the auxent (the real filename)
 	rather than the normal text associated with the symbol
-	(@code{".file"}). 
+	(@code{".file"}).
 
 	At this time the symbol names are moved around. Coff stores
 	all symbols less than nine characters long physically
@@ -180,10 +180,10 @@ SUBSUBSECTION
 	is inspected in turn, and a decision made (using the
 	@code{sclass} field) about the various flags to set in the
 	@code{asymbol}.  @xref{Symbols}. The generated canonical table
-	shares strings with the hidden internal symbol table. 
+	shares strings with the hidden internal symbol table.
 
 	Any linenumbers are read from the coff file too, and attached
-	to the symbols which own the functions the linenumbers belong to. 
+	to the symbols which own the functions the linenumbers belong to.
 
 SUBSUBSECTION
 	Symbol writing
@@ -217,7 +217,7 @@ SUBSUBSECTION
 	changed at this point to reflect their sum with their owning
 	section.  This transformation uses the
 	<<output_section>> field of the @code{asymbol}'s
-	@code{asection} @xref{Sections}. 
+	@code{asection} @xref{Sections}.
 
 	o <<coff_mangle_symbols>>
 
@@ -231,7 +231,7 @@ SUBSUBSECTION
 
 	This routine runs through the symbol table and patches up the
 	symbols from their internal form into the coff way, calls the
-	bit twiddlers, and writes out the table to the file. 
+	bit twiddlers, and writes out the table to the file.
 
 */
 
@@ -245,20 +245,28 @@ DESCRIPTION
 
 CODE_FRAGMENT
 .
-.typedef struct coff_ptr_struct 
+.typedef struct coff_ptr_struct
 .{
 .
 .       {* Remembers the offset from the first symbol in the file for
 .          this symbol. Generated by coff_renumber_symbols. *}
 .unsigned int offset;
 .
+.       {* Should the value of this symbol be renumbered.  Used for
+.          XCOFF C_BSTAT symbols.  Set by coff_slurp_symbol_table.  *}
+.unsigned int fix_value : 1;
+.
 .       {* Should the tag field of this symbol be renumbered.
 .          Created by coff_pointerize_aux. *}
-.char fix_tag;
+.unsigned int fix_tag : 1;
 .
 .       {* Should the endidx field of this symbol be renumbered.
 .          Created by coff_pointerize_aux. *}
-.char fix_end;
+.unsigned int fix_end : 1;
+.
+.       {* Should the x_csect.x_scnlen field be renumbered.
+.          Created by coff_slurp_symbol_table. *}
+.unsigned int fix_scnlen : 1;
 .
 .       {* The container for the symbol structure as read and translated
 .           from the file. *}
@@ -307,35 +315,35 @@ sec_to_styp_flags (sec_name, sec_flags)
 {
   long styp_flags = 0;
 
-  if (!strcmp(sec_name, _TEXT)) 
+  if (!strcmp (sec_name, _TEXT))
     {
       styp_flags = STYP_TEXT;
     }
-  else if (!strcmp(sec_name, _DATA)) 
+  else if (!strcmp (sec_name, _DATA))
     {
       styp_flags = STYP_DATA;
 #ifdef TWO_DATA_SECS
     }
-  else if (!strcmp(sec_name, ".data2")) 
+  else if (!strcmp (sec_name, ".data2"))
     {
       styp_flags = STYP_DATA;
-#endif				/* TWO_DATA_SECS */
+#endif /* TWO_DATA_SECS */
     }
-  else if (!strcmp(sec_name, _BSS)) 
+  else if (!strcmp (sec_name, _BSS))
     {
       styp_flags = STYP_BSS;
 #ifdef _COMMENT
-    } 
-  else if (!strcmp(sec_name, _COMMENT)) 
+    }
+  else if (!strcmp (sec_name, _COMMENT))
     {
       styp_flags = STYP_INFO;
-#endif				/* _COMMENT */
+#endif /* _COMMENT */
 #ifdef _LIB
     }
-  else if (!strcmp(sec_name, _LIB)) 
+  else if (!strcmp (sec_name, _LIB))
     {
       styp_flags = STYP_LIB;
-#endif				/* _LIB */
+#endif /* _LIB */
 #ifdef _LIT
     }
   else if (!strcmp (sec_name, _LIT))
@@ -343,21 +351,25 @@ sec_to_styp_flags (sec_name, sec_flags)
       styp_flags = STYP_LIT;
 #endif /* _LIT */
     }
-  else if (!strcmp(sec_name, ".debug"))
+  else if (!strcmp (sec_name, ".debug"))
     {
+#ifdef STYP_DEBUG
+      styp_flags = STYP_DEBUG;
+#else
       styp_flags = STYP_INFO;
+#endif
     }
-  else if (!strcmp(sec_name, ".stab")
- 	   || !strncmp(sec_name, ".stabstr", 8))
+  else if (!strcmp (sec_name, ".stab")
+	   || !strncmp (sec_name, ".stabstr", 8))
     {
       styp_flags = STYP_INFO;
     }
   /* Try and figure out what it should be */
-  else if (sec_flags & SEC_CODE) 
+  else if (sec_flags & SEC_CODE)
     {
       styp_flags = STYP_TEXT;
     }
-  else  if (sec_flags & SEC_DATA) 
+  else if (sec_flags & SEC_DATA)
     {
       styp_flags = STYP_DATA;
     }
@@ -367,7 +379,7 @@ sec_to_styp_flags (sec_name, sec_flags)
       styp_flags = STYP_LIT;
 #else
       styp_flags = STYP_TEXT;
-#endif				/* STYP_LIT */
+#endif /* STYP_LIT */
     }
   else if (sec_flags & SEC_LOAD)
     {
@@ -380,10 +392,10 @@ sec_to_styp_flags (sec_name, sec_flags)
 
 #ifdef STYP_NOLOAD
   if (sec_flags & SEC_NEVER_LOAD)
-   styp_flags |= STYP_NOLOAD;
+    styp_flags |= STYP_NOLOAD;
 #endif
 
-  return(styp_flags);
+  return (styp_flags);
 }
 /*
  * Return a word with SEC_* flags set to represent the incoming
@@ -393,47 +405,47 @@ sec_to_styp_flags (sec_name, sec_flags)
  *      in sec_to_styp_flags().
  */
 static flagword
-DEFUN(styp_to_sec_flags, (abfd, hdr),
-      bfd *abfd AND
-      PTR hdr)
+DEFUN (styp_to_sec_flags, (abfd, hdr),
+       bfd * abfd AND
+       PTR hdr)
 {
   struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
   long styp_flags = internal_s->s_flags;
-  flagword	sec_flags=0;
+  flagword sec_flags = 0;
 
 #ifdef STYP_NOLOAD
   if (styp_flags & STYP_NOLOAD)
-  {
-    sec_flags |= SEC_NEVER_LOAD;
-  }
+    {
+      sec_flags |= SEC_NEVER_LOAD;
+    }
 #endif /* STYP_NOLOAD */
 
   /* For 386 COFF, at least, an unloadable text or data section is
      actually a shared library section.  */
   if (styp_flags & STYP_TEXT)
-  {
-    if (sec_flags & SEC_NEVER_LOAD)
-      sec_flags |= SEC_CODE | SEC_SHARED_LIBRARY;
-    else
-      sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
-  }
+    {
+      if (sec_flags & SEC_NEVER_LOAD)
+	sec_flags |= SEC_CODE | SEC_SHARED_LIBRARY;
+      else
+	sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
+    }
   else if (styp_flags & STYP_DATA)
-  {
-    if (sec_flags & SEC_NEVER_LOAD)
-      sec_flags |= SEC_DATA | SEC_SHARED_LIBRARY;
-    else
-      sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
-  }
-  else if (styp_flags & STYP_BSS) 
-  {
+    {
+      if (sec_flags & SEC_NEVER_LOAD)
+	sec_flags |= SEC_DATA | SEC_SHARED_LIBRARY;
+      else
+	sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
+    }
+  else if (styp_flags & STYP_BSS)
+    {
 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
-    if (sec_flags & SEC_NEVER_LOAD)
-      sec_flags |= SEC_ALLOC | SEC_SHARED_LIBRARY;
-    else
+      if (sec_flags & SEC_NEVER_LOAD)
+	sec_flags |= SEC_ALLOC | SEC_SHARED_LIBRARY;
+      else
 #endif
-      sec_flags |= SEC_ALLOC;
-  }
-  else if (styp_flags & STYP_INFO) 
+	sec_flags |= SEC_ALLOC;
+    }
+  else if (styp_flags & STYP_INFO)
     {
       /* This should be marked as SEC_DEBUGGING, but that can't be
 	 done until we make sure that strip can still work.  strip
@@ -442,24 +454,24 @@ DEFUN(styp_to_sec_flags, (abfd, hdr),
 	 position.  */
     }
   else
-  {
-    sec_flags |= SEC_ALLOC | SEC_LOAD;
-  }
+    {
+      sec_flags |= SEC_ALLOC | SEC_LOAD;
+    }
 
 #ifdef STYP_LIT			/* A29k readonly text/data section type */
   if ((styp_flags & STYP_LIT) == STYP_LIT)
-  {
-    sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
-  }
-#endif				/* STYP_LIT */
+    {
+      sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
+    }
+#endif /* STYP_LIT */
 #ifdef STYP_OTHER_LOAD		/* Other loaded sections */
   if (styp_flags & STYP_OTHER_LOAD)
-  {
-    sec_flags = (SEC_LOAD | SEC_ALLOC);
-  }
-#endif				/* STYP_SDATA */
+    {
+      sec_flags = (SEC_LOAD | SEC_ALLOC);
+    }
+#endif /* STYP_SDATA */
 
-  return(sec_flags);
+  return (sec_flags);
 }
 
 #define	get_index(symbol)	((long) (symbol)->udata)
@@ -471,7 +483,7 @@ INTERNAL_DEFINITION
 CODE_FRAGMENT
 
 Special entry points for gdb to swap in coff symbol table parts:
-.typedef struct 
+.typedef struct
 .{
 .  void (*_bfd_coff_swap_aux_in) PARAMS ((
 .       bfd            *abfd,
@@ -677,15 +689,15 @@ dependent COFF routines:
 .#define bfd_coff_reloc16_estimate(abfd, section, symbols, reloc, shrink, link_info)\
 .        ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
 .         (section, symbols, reloc, shrink, link_info))
-. 
+.
 */
 
 /* See whether the magic number matches.  */
 
 static boolean
-DEFUN(coff_bad_format_hook, (abfd, filehdr),
-      bfd *abfd AND
-      PTR filehdr)
+DEFUN (coff_bad_format_hook, (abfd, filehdr),
+       bfd * abfd AND
+       PTR filehdr)
 {
   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 
@@ -711,7 +723,7 @@ DEFUN(coff_bad_format_hook, (abfd, filehdr),
 
 static asection *
 DEFUN (coff_make_section_hook, (abfd, name),
-       bfd *abfd AND
+       bfd * abfd AND
        char *name)
 {
 #ifdef TWO_DATA_SECS
@@ -731,9 +743,9 @@ DEFUN (coff_make_section_hook, (abfd, name),
 */
 
 static boolean
-DEFUN(coff_new_section_hook,(abfd, section),
-      bfd            *abfd AND
-      asection       *section)
+DEFUN (coff_new_section_hook, (abfd, section),
+       bfd * abfd AND
+       asection * section)
 {
   section->alignment_power = abfd->xvec->align_power_min;
   /* Allocate aux records for section symbols, to store size and
@@ -753,8 +765,8 @@ DEFUN(coff_new_section_hook,(abfd, section),
 
 static void
 DEFUN (coff_set_alignment_hook, (abfd, section, scnhdr),
-       bfd *abfd AND
-       asection *section AND
+       bfd * abfd AND
+       asection * section AND
        PTR scnhdr)
 {
   struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
@@ -773,17 +785,18 @@ DEFUN (coff_set_alignment_hook, (abfd, section, scnhdr),
 
 #endif /* ! I960 */
 
-static          boolean
-DEFUN(coff_mkobject,(abfd),
-      bfd            *abfd)
+static boolean
+DEFUN (coff_mkobject, (abfd),
+       bfd * abfd)
 {
   coff_data_type *coff;
 
-  abfd->tdata.coff_obj_data = (struct coff_tdata *)bfd_zalloc (abfd,sizeof(coff_data_type));
-  if (abfd->tdata.coff_obj_data == 0){
-    bfd_error = no_memory;
-    return false;
-  }
+  abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, sizeof (coff_data_type));
+  if (abfd->tdata.coff_obj_data == 0)
+    {
+      bfd_error = no_memory;
+      return false;
+    }
   coff = coff_data (abfd);
   coff->symbols = (coff_symbol_type *) NULL;
   coff->conversion_table = (unsigned int *) NULL;
@@ -796,11 +809,11 @@ DEFUN(coff_mkobject,(abfd),
 
 /* Create the COFF backend specific information.  */
 
-static          PTR
-DEFUN(coff_mkobject_hook,(abfd, filehdr, aouthdr),
-      bfd            *abfd AND
-      PTR	     filehdr AND
-      PTR	     aouthdr)
+static PTR
+DEFUN (coff_mkobject_hook, (abfd, filehdr, aouthdr),
+       bfd * abfd AND
+       PTR filehdr AND
+       PTR aouthdr)
 {
   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
   coff_data_type *coff;
@@ -818,11 +831,11 @@ DEFUN(coff_mkobject_hook,(abfd, filehdr, aouthdr),
      unfortunately vary among coff implementations...  */
   coff->local_n_btmask = N_BTMASK;
   coff->local_n_btshft = N_BTSHFT;
-  coff->local_n_tmask  = N_TMASK;
+  coff->local_n_tmask = N_TMASK;
   coff->local_n_tshift = N_TSHIFT;
-  coff->local_symesz   = SYMESZ;
-  coff->local_auxesz   = AUXESZ;
-  coff->local_linesz   = LINESZ;
+  coff->local_symesz = SYMESZ;
+  coff->local_auxesz = AUXESZ;
+  coff->local_linesz = LINESZ;
 
   return (PTR) coff;
 }
@@ -835,7 +848,7 @@ DEFUN(coff_mkobject_hook,(abfd, filehdr, aouthdr),
    at linking together COFF files for different architectures.  */
 
 static boolean
-coff_set_arch_mach_hook(abfd, filehdr)
+coff_set_arch_mach_hook (abfd, filehdr)
      bfd *abfd;
      PTR filehdr;
 {
@@ -844,71 +857,72 @@ coff_set_arch_mach_hook(abfd, filehdr)
   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 
   machine = 0;
-  switch (internal_f->f_magic) {
+  switch (internal_f->f_magic)
+    {
 #ifdef I386MAGIC
-  case I386MAGIC:
-  case I386PTXMAGIC:
-  case I386AIXMAGIC:		/* Danbury PS/2 AIX C Compiler */
-  case LYNXCOFFMAGIC:		/* shadows the m68k Lynx number below, sigh */
-    arch = bfd_arch_i386;
-    machine = 0;
-    break;
+    case I386MAGIC:
+    case I386PTXMAGIC:
+    case I386AIXMAGIC:		/* Danbury PS/2 AIX C Compiler */
+    case LYNXCOFFMAGIC:	/* shadows the m68k Lynx number below, sigh */
+      arch = bfd_arch_i386;
+      machine = 0;
+      break;
 #endif
 
 #ifdef A29K_MAGIC_BIG
-  case  A29K_MAGIC_BIG:
-  case  A29K_MAGIC_LITTLE:
-    arch = bfd_arch_a29k;
-    machine = 0;
-    break;
+    case A29K_MAGIC_BIG:
+    case A29K_MAGIC_LITTLE:
+      arch = bfd_arch_a29k;
+      machine = 0;
+      break;
 #endif
 
 #ifdef MC68MAGIC
-  case MC68MAGIC:
-  case M68MAGIC:
+    case MC68MAGIC:
+    case M68MAGIC:
 #ifdef MC68KBCSMAGIC
-  case MC68KBCSMAGIC:
+    case MC68KBCSMAGIC:
 #endif
 #ifdef APOLLOM68KMAGIC
-  case APOLLOM68KMAGIC:
+    case APOLLOM68KMAGIC:
 #endif
 #ifdef LYNXCOFFMAGIC
-  case LYNXCOFFMAGIC:
+    case LYNXCOFFMAGIC:
 #endif
-    arch = bfd_arch_m68k;
-    machine = 68020;
-    break;
+      arch = bfd_arch_m68k;
+      machine = 68020;
+      break;
 #endif
 #ifdef MC88MAGIC
-  case MC88MAGIC:
-  case MC88DMAGIC:
-  case MC88OMAGIC:
-    arch = bfd_arch_m88k;
-    machine = 88100;
-    break;
+    case MC88MAGIC:
+    case MC88DMAGIC:
+    case MC88OMAGIC:
+      arch = bfd_arch_m88k;
+      machine = 88100;
+      break;
 #endif
 #ifdef Z8KMAGIC
-   case Z8KMAGIC:
-    arch = bfd_arch_z8k;
-    switch (internal_f->f_flags & F_MACHMASK) 
-      {
-      case F_Z8001:
-	machine = bfd_mach_z8001;
-	break;
-      case F_Z8002:
-	machine = bfd_mach_z8002;
-	break;
-      default:
-	return false;
-      }
-    break;
+    case Z8KMAGIC:
+      arch = bfd_arch_z8k;
+      switch (internal_f->f_flags & F_MACHMASK)
+	{
+	case F_Z8001:
+	  machine = bfd_mach_z8001;
+	  break;
+	case F_Z8002:
+	  machine = bfd_mach_z8002;
+	  break;
+	default:
+	  return false;
+	}
+      break;
 #endif
 #ifdef I960
 #ifdef I960ROMAGIC
-  case I960ROMAGIC:
-  case I960RWMAGIC:
-    arch = bfd_arch_i960;
-    switch (F_I960TYPE & internal_f->f_flags)
+    case I960ROMAGIC:
+    case I960RWMAGIC:
+      arch = bfd_arch_i960;
+      switch (F_I960TYPE & internal_f->f_flags)
 	{
 	default:
 	case F_I960CORE:
@@ -917,7 +931,7 @@ coff_set_arch_mach_hook(abfd, filehdr)
 	case F_I960KB:
 	  machine = bfd_mach_i960_kb_sb;
 	  break;
-	case  F_I960MC:
+	case F_I960MC:
 	  machine = bfd_mach_i960_mc;
 	  break;
 	case F_I960XA:
@@ -930,71 +944,71 @@ coff_set_arch_mach_hook(abfd, filehdr)
 	  machine = bfd_mach_i960_ka_sa;
 	  break;
 	}
-    break;
+      break;
 #endif
 #endif
 
 #ifdef U802ROMAGIC
-  case U802ROMAGIC:
-  case U802WRMAGIC:
-  case U802TOCMAGIC:
-    arch = bfd_arch_rs6000;
-    machine = 6000;
-    break;
+    case U802ROMAGIC:
+    case U802WRMAGIC:
+    case U802TOCMAGIC:
+      arch = bfd_arch_rs6000;
+      machine = 6000;
+      break;
 #endif
 
 #ifdef WE32KMAGIC
-  case WE32KMAGIC:
-    arch = bfd_arch_we32k;
-    machine = 0;
-    break;
+    case WE32KMAGIC:
+      arch = bfd_arch_we32k;
+      machine = 0;
+      break;
 #endif
 
 #ifdef H8300MAGIC
-  case H8300MAGIC:
-    arch = bfd_arch_h8300;
-    machine = bfd_mach_h8300;
-    /* !! FIXME this probably isn't the right place for this */
-    abfd->flags |= BFD_IS_RELAXABLE;
-    break;
+    case H8300MAGIC:
+      arch = bfd_arch_h8300;
+      machine = bfd_mach_h8300;
+      /* !! FIXME this probably isn't the right place for this */
+      abfd->flags |= BFD_IS_RELAXABLE;
+      break;
 #endif
 
 #ifdef H8300HMAGIC
-  case H8300HMAGIC:
-    arch = bfd_arch_h8300;
-    machine = bfd_mach_h8300h;
-    /* !! FIXME this probably isn't the right place for this */
-    abfd->flags |= BFD_IS_RELAXABLE;
-    break;
+    case H8300HMAGIC:
+      arch = bfd_arch_h8300;
+      machine = bfd_mach_h8300h;
+      /* !! FIXME this probably isn't the right place for this */
+      abfd->flags |= BFD_IS_RELAXABLE;
+      break;
 #endif
 
 #ifdef SHMAGIC
-  case SHMAGIC:
-    arch = bfd_arch_sh;
-    machine = 0;
-    break;
+    case SHMAGIC:
+      arch = bfd_arch_sh;
+      machine = 0;
+      break;
 #endif
 
 #ifdef H8500MAGIC
-  case H8500MAGIC:
-    arch = bfd_arch_h8500;
-    machine = 0;
-    break;
+    case H8500MAGIC:
+      arch = bfd_arch_h8500;
+      machine = 0;
+      break;
 #endif
 
 #ifdef SPARCMAGIC
-  case SPARCMAGIC:
-    arch = bfd_arch_sparc;
-    machine = 0;
-    break;
+    case SPARCMAGIC:
+      arch = bfd_arch_sparc;
+      machine = 0;
+      break;
 #endif
 
-  default:			/* Unreadable input file type */
-    arch = bfd_arch_obscure;
-break;
-  }
+    default:			/* Unreadable input file type */
+      arch = bfd_arch_obscure;
+      break;
+    }
 
-  bfd_default_set_arch_mach(abfd, arch, machine);
+  bfd_default_set_arch_mach (abfd, arch, machine);
   return true;
 }
 
@@ -1002,7 +1016,7 @@ break;
 
 static boolean
 DEFUN (symname_in_debug_hook, (abfd, sym),
-       bfd *abfd AND
+       bfd * abfd AND
        struct internal_syment *sym)
 {
   return SYMNAME_IN_DEBUG (sym) ? true : false;
@@ -1027,155 +1041,159 @@ SUBSUBSECTION
 	address and the relocation offset; the type is dug directly
 	from the howto field.  Then the @code{internal_reloc} is
 	swapped into the shape of an @code{external_reloc} and written
-	out to disk. 
+	out to disk.
 
 */
 
 static void
-DEFUN(coff_write_relocs,(abfd),
-      bfd            *abfd)
+DEFUN (coff_write_relocs, (abfd),
+       bfd * abfd)
 {
-  asection       *s;
-  for (s = abfd->sections; s != (asection *) NULL; s = s->next) {
-    unsigned int i;
-    struct external_reloc dst;
-
-    arelent **p = s->orelocation;
-    bfd_seek(abfd, s->rel_filepos, SEEK_SET);
-    for (i = 0; i < s->reloc_count; i++) {
-      struct internal_reloc    n;
-      arelent        *q = p[i];
-      memset((PTR)&n, 0, sizeof(n));
-
-      n.r_vaddr = q->address + s->vma;
-
-#ifdef R_IHCONST                       
-      /* The 29k const/consth reloc pair is a real kludge.  The consth
+  asection *s;
+  for (s = abfd->sections; s != (asection *) NULL; s = s->next)
+    {
+      unsigned int i;
+      struct external_reloc dst;
+
+      arelent **p = s->orelocation;
+      bfd_seek (abfd, s->rel_filepos, SEEK_SET);
+      for (i = 0; i < s->reloc_count; i++)
+	{
+	  struct internal_reloc n;
+	  arelent *q = p[i];
+	  memset ((PTR) & n, 0, sizeof (n));
+
+	  n.r_vaddr = q->address + s->vma;
+
+#ifdef R_IHCONST
+	  /* The 29k const/consth reloc pair is a real kludge.  The consth
 	 part doesn't have a symbol; it has an offset.  So rebuilt
 	 that here.  */
-      if (q->howto->type == R_IHCONST)
-	n.r_symndx = q->addend;
-      else
+	  if (q->howto->type == R_IHCONST)
+	    n.r_symndx = q->addend;
+	  else
 #endif
-	if (q->sym_ptr_ptr) 
-	  {
-	    if (q->sym_ptr_ptr == bfd_abs_section.symbol_ptr_ptr) 
-	      /* This is a relocation relative to the absolute symbol.  */
-	      n.r_symndx = -1;
-	    else
-	      {
-		n.r_symndx = get_index((*(q->sym_ptr_ptr)));
-		/* Take notice if the symbol reloc points to a symbol
+	  if (q->sym_ptr_ptr)
+	    {
+	      if (q->sym_ptr_ptr == bfd_abs_section.symbol_ptr_ptr)
+		/* This is a relocation relative to the absolute symbol.  */
+		n.r_symndx = -1;
+	      else
+		{
+		  n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
+		  /* Take notice if the symbol reloc points to a symbol
 		   we don't have in our symbol table.  What should we
 		   do for this??  */
-		if (n.r_symndx > obj_conv_table_size (abfd))
-		  abort ();
-	      }
-	  }
+		  if (n.r_symndx > obj_conv_table_size (abfd))
+		    abort ();
+		}
+	    }
 
 #ifdef SWAP_OUT_RELOC_OFFSET
-      n.r_offset = q->addend;
+	  n.r_offset = q->addend;
 #endif
 
 #ifdef SELECT_RELOC
-      /* Work out reloc type from what is required */
-      SELECT_RELOC(n, q->howto);
+	  /* Work out reloc type from what is required */
+	  SELECT_RELOC (n, q->howto);
 #else
-      n.r_type = q->howto->type;
+	  n.r_type = q->howto->type;
 #endif
-      coff_swap_reloc_out(abfd, &n, &dst);
-      bfd_write((PTR) &dst, 1, RELSZ, abfd);
+	  coff_swap_reloc_out (abfd, &n, &dst);
+	  bfd_write ((PTR) & dst, 1, RELSZ, abfd);
+	}
     }
-  }
 }
 
 /* Set flags and magic number of a coff file from architecture and machine
    type.  Result is true if we can represent the arch&type, false if not.  */
 
-static          boolean
-DEFUN(coff_set_flags,(abfd, magicp, flagsp),
-      bfd            *abfd AND
-      unsigned       *magicp AND
-      unsigned short *flagsp)
+static boolean
+DEFUN (coff_set_flags, (abfd, magicp, flagsp),
+       bfd * abfd AND
+       unsigned *magicp AND
+       unsigned short *flagsp)
 {
-  switch (bfd_get_arch(abfd)) {
-#ifdef Z8KMAGIC
-   case bfd_arch_z8k:
-    *magicp = Z8KMAGIC;
-    switch (bfd_get_mach(abfd)) 
+  switch (bfd_get_arch (abfd))
     {
-     case bfd_mach_z8001:
-      *flagsp = F_Z8001;
-      break;
-     case bfd_mach_z8002:
-      *flagsp = F_Z8002;
-      break;
-     default:
-      return false;
-    }
-    return true;
+#ifdef Z8KMAGIC
+    case bfd_arch_z8k:
+      *magicp = Z8KMAGIC;
+      switch (bfd_get_mach (abfd))
+	{
+	case bfd_mach_z8001:
+	  *flagsp = F_Z8001;
+	  break;
+	case bfd_mach_z8002:
+	  *flagsp = F_Z8002;
+	  break;
+	default:
+	  return false;
+	}
+      return true;
 #endif
 #ifdef I960ROMAGIC
 
     case bfd_arch_i960:
 
       {
-	unsigned        flags;
+	unsigned flags;
 	*magicp = I960ROMAGIC;
 	/*
 	  ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
 	  I960RWMAGIC);   FIXME???
 	  */
-	switch (bfd_get_mach(abfd)) {
-	case bfd_mach_i960_core:
-	  flags = F_I960CORE;
-	  break;
-	case bfd_mach_i960_kb_sb:
-	  flags = F_I960KB;
-	  break;
-	case bfd_mach_i960_mc:
-	  flags = F_I960MC;
-	  break;
-	case bfd_mach_i960_xa:
-	  flags = F_I960XA;
-	  break;
-	case bfd_mach_i960_ca:
-	  flags = F_I960CA;
-	  break;
-	case bfd_mach_i960_ka_sa:
-	  flags = F_I960KA;
-	  break;
-	default:
-	  return false;
-	}
+	switch (bfd_get_mach (abfd))
+	  {
+	  case bfd_mach_i960_core:
+	    flags = F_I960CORE;
+	    break;
+	  case bfd_mach_i960_kb_sb:
+	    flags = F_I960KB;
+	    break;
+	  case bfd_mach_i960_mc:
+	    flags = F_I960MC;
+	    break;
+	  case bfd_mach_i960_xa:
+	    flags = F_I960XA;
+	    break;
+	  case bfd_mach_i960_ca:
+	    flags = F_I960CA;
+	    break;
+	  case bfd_mach_i960_ka_sa:
+	    flags = F_I960KA;
+	    break;
+	  default:
+	    return false;
+	  }
 	*flagsp = flags;
 	return true;
       }
-    break;
+      break;
 #endif
 #ifdef I386MAGIC
-  case bfd_arch_i386:
-    *magicp = I386MAGIC;
+    case bfd_arch_i386:
+      *magicp = I386MAGIC;
 #ifdef LYNXOS
-    /* Just overwrite the usual value if we're doing Lynx. */
-    *magicp = LYNXCOFFMAGIC;
+      /* Just overwrite the usual value if we're doing Lynx. */
+      *magicp = LYNXCOFFMAGIC;
 #endif
-    return true;
-    break;
+      return true;
+      break;
 #endif
 #ifdef MC68MAGIC
-  case bfd_arch_m68k:
+    case bfd_arch_m68k:
 #ifdef APOLLOM68KMAGIC
-    *magicp = APOLLO_COFF_VERSION_NUMBER;
+      *magicp = APOLLO_COFF_VERSION_NUMBER;
 #else
-    *magicp = MC68MAGIC;
+      *magicp = MC68MAGIC;
 #endif
 #ifdef LYNXOS
-    /* Just overwrite the usual value if we're doing Lynx. */
-    *magicp = LYNXCOFFMAGIC;
+      /* Just overwrite the usual value if we're doing Lynx. */
+      *magicp = LYNXCOFFMAGIC;
 #endif
-    return true;
-    break;
+      return true;
+      break;
 #endif
 
 #ifdef MC88MAGIC
@@ -1186,34 +1204,34 @@ DEFUN(coff_set_flags,(abfd, magicp, flagsp),
 #endif
 #ifdef H8300MAGIC
     case bfd_arch_h8300:
-    switch (bfd_get_mach (abfd)) 
-      {
-      case bfd_mach_h8300:
-	*magicp = H8300MAGIC;
-	return true;
-      case bfd_mach_h8300h:
-	*magicp = H8300HMAGIC;
-	return true;
-      }
+      switch (bfd_get_mach (abfd))
+	{
+	case bfd_mach_h8300:
+	  *magicp = H8300MAGIC;
+	  return true;
+	case bfd_mach_h8300h:
+	  *magicp = H8300HMAGIC;
+	  return true;
+	}
       break;
 #endif
 
 #ifdef SHMAGIC
-  case bfd_arch_sh:
+    case bfd_arch_sh:
       *magicp = SHMAGIC;
       return true;
       break;
 #endif
 
 #ifdef SPARCMAGIC
-  case bfd_arch_sparc:
-    *magicp = SPARCMAGIC;
+    case bfd_arch_sparc:
+      *magicp = SPARCMAGIC;
 #ifdef LYNXOS
-    /* Just overwrite the usual value if we're doing Lynx. */
-    *magicp = LYNXCOFFMAGIC;
+      /* Just overwrite the usual value if we're doing Lynx. */
+      *magicp = LYNXCOFFMAGIC;
 #endif
-    return true;
-    break;
+      return true;
+      break;
 #endif
 
 #ifdef H8500MAGIC
@@ -1225,49 +1243,49 @@ DEFUN(coff_set_flags,(abfd, magicp, flagsp),
 #ifdef A29K_MAGIC_BIG
     case bfd_arch_a29k:
       if (abfd->xvec->byteorder_big_p)
-       *magicp = A29K_MAGIC_BIG;
+	*magicp = A29K_MAGIC_BIG;
       else
-       *magicp = A29K_MAGIC_LITTLE;
+	*magicp = A29K_MAGIC_LITTLE;
       return true;
       break;
 #endif
 
 #ifdef WE32KMAGIC
-  case bfd_arch_we32k:
-    *magicp = WE32KMAGIC;
-    return true;
-    break;
+    case bfd_arch_we32k:
+      *magicp = WE32KMAGIC;
+      return true;
+      break;
 #endif
 
 #ifdef U802TOCMAGIC
-  case bfd_arch_rs6000:
-    *magicp = U802TOCMAGIC;
-    return true;
-    break;
+    case bfd_arch_rs6000:
+      *magicp = U802TOCMAGIC;
+      return true;
+      break;
 #endif
 
-  default:			/* Unknown architecture */
-    /* return false;  -- fall through to "return false" below, to avoid
+    default:			/* Unknown architecture */
+      /* return false;  -- fall through to "return false" below, to avoid
        "statement never reached" errors on the one below. */
-    break;
-  }
+      break;
+    }
 
   return false;
 }
 
 
-static          boolean
-DEFUN(coff_set_arch_mach,(abfd, arch, machine),
-      bfd            *abfd AND
-      enum bfd_architecture arch AND
-      unsigned long   machine)
+static boolean
+DEFUN (coff_set_arch_mach, (abfd, arch, machine),
+       bfd * abfd AND
+       enum bfd_architecture arch AND
+       unsigned long machine)
 {
-  unsigned        dummy1;
-  unsigned     short dummy2;
-  bfd_default_set_arch_mach(abfd, arch, machine);
+  unsigned dummy1;
+  unsigned short dummy2;
+  bfd_default_set_arch_mach (abfd, arch, machine);
 
   if (arch != bfd_arch_unknown &&
-      coff_set_flags(abfd, &dummy1, &dummy2) != true)
+      coff_set_flags (abfd, &dummy1, &dummy2) != true)
     return false;		/* We can't represent this type */
   return true;			/* We're easy ... */
 }
@@ -1276,49 +1294,51 @@ DEFUN(coff_set_arch_mach,(abfd, arch, machine),
 /* Calculate the file position for each section. */
 
 static void
-DEFUN(coff_compute_section_file_positions,(abfd),
-      bfd            *abfd)
+DEFUN (coff_compute_section_file_positions, (abfd),
+       bfd * abfd)
 {
-  asection       *current;
-  asection	*previous = (asection *)NULL;
-  file_ptr        sofar = FILHSZ;
+  asection *current;
+  asection *previous = (asection *) NULL;
+  file_ptr sofar = FILHSZ;
 #ifndef I960
-  file_ptr	old_sofar;
+  file_ptr old_sofar;
 #endif
-  if (bfd_get_start_address(abfd)) 
-  {
-    /*  A start address may have been added to the original file. In this
+  if (bfd_get_start_address (abfd))
+    {
+      /*  A start address may have been added to the original file. In this
 	case it will need an optional header to record it.  */
-    abfd->flags |= EXEC_P;
-  }
+      abfd->flags |= EXEC_P;
+    }
 
   if (abfd->flags & EXEC_P)
-   sofar += AOUTSZ;
+    sofar += AOUTSZ;
 
   sofar += abfd->section_count * SCNHSZ;
   for (current = abfd->sections;
-       current != (asection *)NULL;
-       current = current->next) {
+       current != (asection *) NULL;
+       current = current->next)
+    {
 
       /* Only deal with sections which have contents */
       if (!(current->flags & SEC_HAS_CONTENTS))
-       continue;
+	continue;
 
       /* Align the sections in the file to the same boundary on
 	 which they are aligned in virtual memory.  I960 doesn't
 	 do this (FIXME) so we can stay in sync with Intel.  960
 	 doesn't yet page from files... */
 #ifndef I960
-    {
-      /* make sure this section is aligned on the right boundary - by
+      {
+	/* make sure this section is aligned on the right boundary - by
 	 padding the previous section up if necessary */
 
-      old_sofar= sofar;
-      sofar = BFD_ALIGN(sofar, 1 << current->alignment_power);
-      if (previous != (asection *)NULL) {
-	  previous->_raw_size += sofar - old_sofar;
-	}
-    }
+	old_sofar = sofar;
+	sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
+	if (previous != (asection *) NULL)
+	  {
+	    previous->_raw_size += sofar - old_sofar;
+	  }
+      }
 
 #endif
       /* FIXME, in demand paged files, the low order bits of the file
@@ -1331,9 +1351,9 @@ DEFUN(coff_compute_section_file_positions,(abfd),
       sofar += current->_raw_size;
 #ifndef I960
       /* make sure that this section is of the right size too */
-      old_sofar =  sofar;
-      sofar = BFD_ALIGN(sofar, 1 << current->alignment_power);
-      current->_raw_size += sofar - old_sofar ;
+      old_sofar = sofar;
+      sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
+      current->_raw_size += sofar - old_sofar;
 #endif
 
 #ifdef _LIB
@@ -1346,13 +1366,15 @@ DEFUN(coff_compute_section_file_positions,(abfd),
 
       previous = current;
     }
-  obj_relocbase(abfd) = sofar;
+  obj_relocbase (abfd) = sofar;
 }
 
+#ifndef RS6000COFF_C
+
 /* If .file, .text, .data, .bss symbols are missing, add them.  */
 /* @@ Should we only be adding missing symbols, or overriding the aux
    values for existing section symbols?  */
-static void
+static boolean
 coff_add_missing_symbols (abfd)
      bfd *abfd;
 {
@@ -1366,38 +1388,43 @@ coff_add_missing_symbols (abfd)
     {
       coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
       CONST char *name;
-      if (csym) 
-      {
-	/* only do this if there is a coff representation of the input
-	   symbol */
-	if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
+      if (csym)
 	{
-	  need_file = 0;
-	  continue;
-	}
-	name = csym->symbol.name;
-	if (!name)
-	 continue;
-	if (!strcmp (name, _TEXT))
-	 need_text = 0;
+	  /* only do this if there is a coff representation of the input
+	   symbol */
+	  if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
+	    {
+	      need_file = 0;
+	      continue;
+	    }
+	  name = csym->symbol.name;
+	  if (!name)
+	    continue;
+	  if (!strcmp (name, _TEXT))
+	    need_text = 0;
 #ifdef APOLLO_M68
-	else if (!strcmp(name, ".wtext"))
-	  need_text = 0;
+	  else if (!strcmp (name, ".wtext"))
+	    need_text = 0;
 #endif
-	else if (!strcmp (name, _DATA))
-	 need_data = 0;
-	else if (!strcmp (name, _BSS))
-	 need_bss = 0;
-      }
+	  else if (!strcmp (name, _DATA))
+	    need_data = 0;
+	  else if (!strcmp (name, _BSS))
+	    need_bss = 0;
+	}
     }
   /* Now i == bfd_get_symcount (abfd).  */
   /* @@ For now, don't deal with .file symbol.  */
   need_file = 0;
 
   if (!need_text && !need_data && !need_bss && !need_file)
-    return;
+    return true;
   nsyms += need_text + need_data + need_bss + need_file;
-  sympp2 = (asymbol**) bfd_alloc_by_size_t (abfd, nsyms * sizeof (asymbol *));
+  sympp2 = (asymbol **) bfd_alloc_by_size_t (abfd, nsyms * sizeof (asymbol *));
+  if (!sympp2)
+    {
+      bfd_error = no_memory;
+      return false;
+    }
   memcpy (sympp2, sympp, i * sizeof (asymbol *));
   if (need_file)
     {
@@ -1412,29 +1439,32 @@ coff_add_missing_symbols (abfd)
     sympp2[i++] = coff_section_symbol (abfd, _BSS);
   BFD_ASSERT (i == nsyms);
   bfd_set_symtab (abfd, sympp2, nsyms);
+  return true;
 }
 
+#endif /* ! defined (RS6000COFF_C) */
+
 /* SUPPRESS 558 */
 /* SUPPRESS 529 */
-static          boolean
-DEFUN(coff_write_object_contents,(abfd),
-      bfd            *abfd)
+static boolean
+DEFUN (coff_write_object_contents, (abfd),
+       bfd * abfd)
 {
-  asection       *current;
+  asection *current;
   unsigned int count;
-  
-  boolean         hasrelocs = false;
-  boolean         haslinno = false;
-  file_ptr        reloc_base;
-  file_ptr        lineno_base;
-  file_ptr        sym_base;
-  file_ptr        scn_base;
-  file_ptr        data_base;
-  unsigned long   reloc_size = 0;
-  unsigned long   lnno_size = 0;
-  asection       *text_sec = NULL;
-  asection       *data_sec = NULL;
-  asection       *bss_sec = NULL;
+
+  boolean hasrelocs = false;
+  boolean haslinno = false;
+  file_ptr reloc_base;
+  file_ptr lineno_base;
+  file_ptr sym_base;
+  file_ptr scn_base;
+  file_ptr data_base;
+  unsigned long reloc_size = 0;
+  unsigned long lnno_size = 0;
+  asection *text_sec = NULL;
+  asection *data_sec = NULL;
+  asection *bss_sec = NULL;
 
   struct internal_filehdr internal_f;
   struct internal_aouthdr internal_a;
@@ -1446,161 +1476,178 @@ DEFUN(coff_write_object_contents,(abfd),
      @@ The code doesn't make this check.  Is it supposed to be done,
      or isn't it??  */
   count = 1;
-  for (current = abfd->sections; current != (asection *)NULL; 
-       current = current->next) 
-  {
+  for (current = abfd->sections; current != (asection *) NULL;
+       current = current->next)
+    {
       current->target_index = count;
       count++;
-  }
+    }
 
-  if(abfd->output_has_begun == false) {
-      coff_compute_section_file_positions(abfd);
+  if (abfd->output_has_begun == false)
+    {
+      coff_compute_section_file_positions (abfd);
     }
 
-  if (abfd->sections != (asection *)NULL) {
+  if (abfd->sections != (asection *) NULL)
+    {
       scn_base = abfd->sections->filepos;
     }
-  else {
+  else
+    {
       scn_base = 0;
     }
-  if (bfd_seek(abfd, scn_base, SEEK_SET) != 0)
-   return false;
-  reloc_base = obj_relocbase(abfd);
+  if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
+    return false;
+  reloc_base = obj_relocbase (abfd);
 
   /* Make a pass through the symbol table to count line number entries and
      put them into the correct asections */
 
-  lnno_size =  coff_count_linenumbers(abfd) * LINESZ;
+  lnno_size = coff_count_linenumbers (abfd) * LINESZ;
   data_base = scn_base;
 
   /* Work out the size of the reloc and linno areas */
 
   for (current = abfd->sections; current != NULL; current =
-       current->next) 
-  {
-    /* We give section headers to +ve indexes */
-    if (current->target_index > 0) 
+       current->next)
     {
-	
-      reloc_size += current->reloc_count * RELSZ;
-      data_base += SCNHSZ;
+      /* We give section headers to +ve indexes */
+      if (current->target_index > 0)
+	{
+
+	  reloc_size += current->reloc_count * RELSZ;
+	  data_base += SCNHSZ;
+	}
+
     }
-      
-  }
 
   lineno_base = reloc_base + reloc_size;
   sym_base = lineno_base + lnno_size;
 
   /* Indicate in each section->line_filepos its actual file address */
   for (current = abfd->sections; current != NULL; current =
-       current->next) 
-  {
-    if (current->target_index > 0) 
+       current->next)
     {
-	
-      if (current->lineno_count) {
-	  current->line_filepos = lineno_base;
-	  current->moving_line_filepos = lineno_base;
-	  lineno_base += current->lineno_count * LINESZ;
-	}
-      else {
-	  current->line_filepos = 0;
-	}
-      if (current->reloc_count) {
-	  current->rel_filepos = reloc_base;
-	  reloc_base += current->reloc_count * RELSZ;
-	}
-      else {
-	  current->rel_filepos = 0;
+      if (current->target_index > 0)
+	{
+
+	  if (current->lineno_count)
+	    {
+	      current->line_filepos = lineno_base;
+	      current->moving_line_filepos = lineno_base;
+	      lineno_base += current->lineno_count * LINESZ;
+	    }
+	  else
+	    {
+	      current->line_filepos = 0;
+	    }
+	  if (current->reloc_count)
+	    {
+	      current->rel_filepos = reloc_base;
+	      reloc_base += current->reloc_count * RELSZ;
+	    }
+	  else
+	    {
+	      current->rel_filepos = 0;
+	    }
 	}
     }
-  }    
-      
+
 
 
   /* Write section headers to the file.  */
   internal_f.f_nscns = 0;
-  bfd_seek(abfd,
-	   (file_ptr) ((abfd->flags & EXEC_P) ?
-		       (FILHSZ + AOUTSZ) : FILHSZ),
-	   SEEK_SET);
+  bfd_seek (abfd,
+	    (file_ptr) ((abfd->flags & EXEC_P) ?
+			(FILHSZ + AOUTSZ) : FILHSZ),
+	    SEEK_SET);
 
-{
+  {
 #if 0
-  unsigned int    pad = abfd->flags & D_PAGED ? data_base : 0;
+    unsigned int pad = abfd->flags & D_PAGED ? data_base : 0;
 #endif
-  unsigned int    pad = 0;
+    unsigned int pad = 0;
 
-  for (current = abfd->sections;
-       current != NULL;
-       current = current->next) {
-      struct internal_scnhdr section;
-      if (current->target_index > 0) 
+    for (current = abfd->sections;
+	 current != NULL;
+	 current = current->next)
       {
-	internal_f.f_nscns ++;
-	strncpy(&(section.s_name[0]), current->name, 8);
+	struct internal_scnhdr section;
+	if (current->target_index > 0)
+	  {
+	    internal_f.f_nscns++;
+	    strncpy (&(section.s_name[0]), current->name, 8);
 #ifdef _LIB
-	/* Always set s_vaddr of .lib to 0.  This is right for SVR3.2
+	    /* Always set s_vaddr of .lib to 0.  This is right for SVR3.2
 	   Ian Taylor <ian@cygnus.com>.  */
-	if (strcmp (current->name, _LIB) == 0)
-	  section.s_vaddr = 0;
-	else
+	    if (strcmp (current->name, _LIB) == 0)
+	      section.s_vaddr = 0;
+	    else
 #endif
-	section.s_vaddr = current->lma + pad;
-	section.s_paddr = current->lma + pad;
-	section.s_size = current->_raw_size - pad;
-	/*
+	      section.s_vaddr = current->lma + pad;
+	    section.s_paddr = current->lma + pad;
+	    section.s_size = current->_raw_size - pad;
+	    /*
 	  If this section has no size or is unloadable then the scnptr
 	  will be 0 too
 	  */
-	if (current->_raw_size - pad == 0 ||
-	    (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0) {
-	    section.s_scnptr = 0;
-	  }
-	else {
-	    section.s_scnptr = current->filepos;
-	  }
-	section.s_relptr = current->rel_filepos;
-	section.s_lnnoptr = current->line_filepos;
-	section.s_nreloc = current->reloc_count;
-	section.s_nlnno = current->lineno_count;
-	if (current->reloc_count != 0)
-	 hasrelocs = true;
-	if (current->lineno_count != 0)
-	 haslinno = true;
-
-	section.s_flags = sec_to_styp_flags(current->name,current->flags);
-
-	if (!strcmp(current->name, _TEXT)) {
-	    text_sec = current;
-	  } else if (!strcmp(current->name, _DATA)) {
-	      data_sec = current;
+	    if (current->_raw_size - pad == 0 ||
+		(current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
+	      {
+		section.s_scnptr = 0;
+	      }
+	    else
+	      {
+		section.s_scnptr = current->filepos;
+	      }
+	    section.s_relptr = current->rel_filepos;
+	    section.s_lnnoptr = current->line_filepos;
+	    section.s_nreloc = current->reloc_count;
+	    section.s_nlnno = current->lineno_count;
+	    if (current->reloc_count != 0)
+	      hasrelocs = true;
+	    if (current->lineno_count != 0)
+	      haslinno = true;
+
+	    section.s_flags = sec_to_styp_flags (current->name, current->flags);
+
+	    if (!strcmp (current->name, _TEXT))
+	      {
+		text_sec = current;
+	      }
+	    else if (!strcmp (current->name, _DATA))
+	      {
+		data_sec = current;
 #ifdef TWO_DATA_SECS
-	    } else if (!strcmp(current->name, ".data2")) {
-	      data_sec = current;
+	      }
+	    else if (!strcmp (current->name, ".data2"))
+	      {
+		data_sec = current;
 #endif /* TWO_DATA_SECS */
-	    } else if (!strcmp(current->name, _BSS)) {
+	      }
+	    else if (!strcmp (current->name, _BSS))
+	      {
 		bss_sec = current;
 	      }
 
 #ifdef I960
-	section.s_align = (current->alignment_power
-			   ? 1 << current->alignment_power
-			   : 0);
+	    section.s_align = (current->alignment_power
+			       ? 1 << current->alignment_power
+			       : 0);
 
 #endif
-      {
-	SCNHDR          buff;
+	    {
+	      SCNHDR buff;
 
-	coff_swap_scnhdr_out(abfd, &section, &buff);
-	bfd_write((PTR) (&buff), 1, SCNHSZ, abfd);
+	      coff_swap_scnhdr_out (abfd, &section, &buff);
+	      bfd_write ((PTR) (&buff), 1, SCNHSZ, abfd);
 
-      }
+	    }
 
-	pad = 0;
+	    pad = 0;
+	  }
       }
-    }	
-}
+  }
 
 
   /* OK, now set up the filehdr... */
@@ -1615,31 +1662,31 @@ DEFUN(coff_write_object_contents,(abfd),
     */
   internal_f.f_timdat = 0;
 
-  if (bfd_get_symcount(abfd) != 0)
-   internal_f.f_symptr = sym_base;
+  if (bfd_get_symcount (abfd) != 0)
+    internal_f.f_symptr = sym_base;
   else
-   internal_f.f_symptr = 0;
+    internal_f.f_symptr = 0;
 
   internal_f.f_flags = 0;
 
   if (abfd->flags & EXEC_P)
-   internal_f.f_opthdr = AOUTSZ;
+    internal_f.f_opthdr = AOUTSZ;
   else
-   internal_f.f_opthdr = 0;
+    internal_f.f_opthdr = 0;
 
   if (!hasrelocs)
-   internal_f.f_flags |= F_RELFLG;
+    internal_f.f_flags |= F_RELFLG;
   if (!haslinno)
-   internal_f.f_flags |= F_LNNO;
-  if (0 == bfd_get_symcount(abfd))
-   internal_f.f_flags |= F_LSYMS;
+    internal_f.f_flags |= F_LNNO;
+  if (0 == bfd_get_symcount (abfd))
+    internal_f.f_flags |= F_LSYMS;
   if (abfd->flags & EXEC_P)
-   internal_f.f_flags |= F_EXEC;
+    internal_f.f_flags |= F_EXEC;
 
   if (!abfd->xvec->byteorder_big_p)
-   internal_f.f_flags |= F_AR32WR;
-  else 
-  internal_f.f_flags |= F_AR32W;
+    internal_f.f_flags |= F_AR32WR;
+  else
+    internal_f.f_flags |= F_AR32W;
 
   /*
     FIXME, should do something about the other byte orders and
@@ -1650,156 +1697,169 @@ DEFUN(coff_write_object_contents,(abfd),
 
   /* Set up architecture-dependent stuff */
 
-{ unsigned int   magic = 0;
-  unsigned short    flags = 0;
-  coff_set_flags(abfd, &magic, &flags);
-  internal_f.f_magic = magic;
-  internal_f.f_flags |= flags;
-  /* ...and the "opt"hdr... */
+  {
+    unsigned int magic = 0;
+    unsigned short flags = 0;
+    coff_set_flags (abfd, &magic, &flags);
+    internal_f.f_magic = magic;
+    internal_f.f_flags |= flags;
+    /* ...and the "opt"hdr... */
 
 #ifdef A29K
-# ifdef ULTRA3			/* NYU's machine */
-  /* FIXME: This is a bogus check.  I really want to see if there
+#ifdef ULTRA3			/* NYU's machine */
+    /* FIXME: This is a bogus check.  I really want to see if there
    * is a .shbss or a .shdata section, if so then set the magic
    * number to indicate a shared data executable.
    */
-  if (internal_f.f_nscns >= 7)
-   internal_a.magic = SHMAGIC; 	/* Shared magic */
-  else
-# endif				/* ULTRA3 */
-   internal_a.magic = NMAGIC; 	/* Assume separate i/d */
+    if (internal_f.f_nscns >= 7)
+      internal_a.magic = SHMAGIC;	/* Shared magic */
+    else
+#endif /* ULTRA3 */
+      internal_a.magic = NMAGIC;/* Assume separate i/d */
 #define __A_MAGIC_SET__
-#endif				/* A29K */
+#endif /* A29K */
 #ifdef I960
-  internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
+    internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
 #define __A_MAGIC_SET__
-#endif				/* I960 */
+#endif /* I960 */
 #if M88
 #define __A_MAGIC_SET__
-  internal_a.magic = PAGEMAGICBCS;
-#endif				/* M88 */
+    internal_a.magic = PAGEMAGICBCS;
+#endif /* M88 */
 
 #if APOLLO_M68
 #define __A_MAGIC_SET__
-  internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
+    internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
 #endif
 
 #if M68 || WE32K
 #define __A_MAGIC_SET__
-  /* Never was anything here for the 68k */
-#endif				/* M68 || WE32K */
+    /* Never was anything here for the 68k */
+#endif /* M68 || WE32K */
 
 #if I386
-# define __A_MAGIC_SET__
-  internal_a.magic = ZMAGIC;
+#define __A_MAGIC_SET__
+    internal_a.magic = ZMAGIC;
 #endif /* I386 */
 
 #if RS6000COFF_C
 #define __A_MAGIC_SET__
-  internal_a.magic = (abfd->flags & D_PAGED)? RS6K_AOUTHDR_ZMAGIC:
-  (abfd->flags & WP_TEXT)? RS6K_AOUTHDR_NMAGIC:
-  RS6K_AOUTHDR_OMAGIC;
+    internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
+      (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
+      RS6K_AOUTHDR_OMAGIC;
 #endif
 
 #ifndef __A_MAGIC_SET__
-# include "Your aouthdr magic number is not being set!"
+#include "Your aouthdr magic number is not being set!"
 #else
-# undef __A_MAGIC_SET__
+#undef __A_MAGIC_SET__
 #endif
-}
+  }
   /* Now should write relocs, strings, syms */
-  obj_sym_filepos(abfd) = sym_base;
-
-  if (bfd_get_symcount(abfd) != 0) {
-      coff_add_missing_symbols (abfd);
-      coff_renumber_symbols(abfd);
-      coff_mangle_symbols(abfd);
-      coff_write_symbols(abfd);
-      coff_write_linenumbers(abfd);
-      coff_write_relocs(abfd);
+  obj_sym_filepos (abfd) = sym_base;
+
+  if (bfd_get_symcount (abfd) != 0)
+    {
+#ifndef RS6000COFF_C
+      if (!coff_add_missing_symbols (abfd))
+	return false;
+#endif
+      if (!coff_renumber_symbols (abfd))
+	return false;
+      coff_mangle_symbols (abfd);
+      coff_write_symbols (abfd);
+      if (!coff_write_linenumbers (abfd))
+	return false;
+      coff_write_relocs (abfd);
     }
-  if (text_sec) {
-      internal_a.tsize = bfd_get_section_size_before_reloc(text_sec);
+  if (text_sec)
+    {
+      internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
       internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
     }
-  if (data_sec) {
-      internal_a.dsize = bfd_get_section_size_before_reloc(data_sec);
-      internal_a.data_start = internal_a.dsize ? data_sec->vma      : 0;
+  if (data_sec)
+    {
+      internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
+      internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
     }
-  if (bss_sec) {
-      internal_a.bsize = bfd_get_section_size_before_reloc(bss_sec);
+  if (bss_sec)
+    {
+      internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
     }
 
-  internal_a.entry = bfd_get_start_address(abfd);
-  internal_f.f_nsyms =  bfd_get_symcount(abfd);
+  internal_a.entry = bfd_get_start_address (abfd);
+  internal_f.f_nsyms = bfd_get_symcount (abfd);
 
   /* now write them */
-  if (bfd_seek(abfd, (file_ptr) 0, SEEK_SET) != 0)
-   return false;
-{
-  FILHDR buff;
-  coff_swap_filehdr_out(abfd, (PTR)&internal_f, (PTR)&buff);
-  bfd_write((PTR) &buff, 1, FILHSZ, abfd);
-}
-  if (abfd->flags & EXEC_P) {
+  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
+    return false;
+  {
+    FILHDR buff;
+    coff_swap_filehdr_out (abfd, (PTR) & internal_f, (PTR) & buff);
+    bfd_write ((PTR) & buff, 1, FILHSZ, abfd);
+  }
+  if (abfd->flags & EXEC_P)
+    {
       AOUTHDR buff;
-      coff_swap_aouthdr_out(abfd, (PTR)&internal_a, (PTR)&buff);
-      bfd_write((PTR) &buff, 1, AOUTSZ, abfd);
+      coff_swap_aouthdr_out (abfd, (PTR) & internal_a, (PTR) & buff);
+      bfd_write ((PTR) & buff, 1, AOUTSZ, abfd);
     }
   return true;
 }
 
-static          boolean
-DEFUN(coff_set_section_contents,(abfd, section, location, offset, count),
-      bfd            *abfd AND
-      sec_ptr         section AND
-      PTR             location AND
-      file_ptr        offset AND
-      bfd_size_type   count)
+static boolean
+DEFUN (coff_set_section_contents, (abfd, section, location, offset, count),
+       bfd * abfd AND
+       sec_ptr section AND
+       PTR location AND
+       file_ptr offset AND
+       bfd_size_type count)
 {
-    if (abfd->output_has_begun == false)	/* set by bfd.c handler */
-	coff_compute_section_file_positions(abfd);
+  if (abfd->output_has_begun == false)	/* set by bfd.c handler */
+    coff_compute_section_file_positions (abfd);
 
 #ifdef _LIB
-    /* If this is a .lib section, bump the vma address so that it
+  /* If this is a .lib section, bump the vma address so that it
        winds up being the number of .lib sections output.  This is
        right for SVR3.2.  Shared libraries should probably get more
        generic support.  Ian Taylor <ian@cygnus.com>.  */
-    if (strcmp (section->name, _LIB) == 0)
-      ++section->lma;
+  if (strcmp (section->name, _LIB) == 0)
+    ++section->lma;
 #endif
 
-    /* Don't write out bss sections - one way to do this is to 
-       see if the filepos has not been set. */ 
-    if (section->filepos == 0)
-      return true;
+  /* Don't write out bss sections - one way to do this is to
+       see if the filepos has not been set. */
+  if (section->filepos == 0)
+    return true;
 
-    bfd_seek(abfd, (file_ptr) (section->filepos + offset), SEEK_SET);
+  bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET);
 
-    if (count != 0) {
-	return (bfd_write(location, 1, count, abfd) == count) ? true : false;
+  if (count != 0)
+    {
+      return (bfd_write (location, 1, count, abfd) == count) ? true : false;
     }
-    return true;
+  return true;
 }
 #if 0
-static          boolean
-coff_close_and_cleanup(abfd)
-    bfd            *abfd;
+static boolean
+coff_close_and_cleanup (abfd)
+     bfd *abfd;
 {
-  if (!bfd_read_p(abfd))
-    switch (abfd->format) {
-    case bfd_archive:
-      if (!_bfd_write_archive_contents(abfd))
-	return false;
-      break;
-    case bfd_object:
-      if (!coff_write_object_contents(abfd))
+  if (!bfd_read_p (abfd))
+    switch (abfd->format)
+      {
+      case bfd_archive:
+	if (!_bfd_write_archive_contents (abfd))
+	  return false;
+	break;
+      case bfd_object:
+	if (!coff_write_object_contents (abfd))
+	  return false;
+	break;
+      default:
+	bfd_error = invalid_operation;
 	return false;
-      break;
-    default:
-      bfd_error = invalid_operation;
-      return false;
-    }
+      }
 
   /* We depend on bfd_close to free all the memory on the obstack.  */
   /* FIXME if bfd_release is not using obstacks! */
@@ -1809,27 +1869,29 @@ coff_close_and_cleanup(abfd)
 #endif
 
 static PTR
-buy_and_read(abfd, where, seek_direction, size)
-    bfd            *abfd;
-    file_ptr        where;
-    int             seek_direction;
-    size_t          size;
+buy_and_read (abfd, where, seek_direction, size)
+     bfd *abfd;
+     file_ptr where;
+     int seek_direction;
+     size_t size;
 {
-    PTR             area = (PTR) bfd_alloc(abfd, size);
-    if (!area) {
-	bfd_error = no_memory;
-	return (NULL);
+  PTR area = (PTR) bfd_alloc (abfd, size);
+  if (!area)
+    {
+      bfd_error = no_memory;
+      return (NULL);
     }
-    bfd_seek(abfd, where, seek_direction);
-    if (bfd_read(area, 1, size, abfd) != size) {
-	bfd_error = system_call_error;
-	return (NULL);
+  bfd_seek (abfd, where, seek_direction);
+  if (bfd_read (area, 1, size, abfd) != size)
+    {
+      bfd_error = system_call_error;
+      return (NULL);
     }				/* on error */
-    return (area);
+  return (area);
 }				/* buy_and_read() */
 
 /*
-SUBSUBSECTION 
+SUBSUBSECTION
 	Reading linenumbers
 
 	Creating the linenumber table is done by reading in the entire
@@ -1839,7 +1901,7 @@ SUBSUBSECTION
 	is marked as having a line number of 0. Each line within the
 	function is an offset from the first line in the function. The
 	base of the line number information for the table is stored in
-	the symbol associated with the function. 
+	the symbol associated with the function.
 
 	The information is copied from the external to the internal
 	table, and each symbol which marks a function is marked by
@@ -1850,22 +1912,22 @@ SUBSUBSECTION
 */
 
 static boolean
-coff_slurp_line_table(abfd, asect)
+coff_slurp_line_table (abfd, asect)
      bfd *abfd;
      asection *asect;
 {
-  LINENO  *native_lineno;
+  LINENO *native_lineno;
   alent *lineno_cache;
 
-  BFD_ASSERT(asect->lineno == (alent *) NULL);
+  BFD_ASSERT (asect->lineno == (alent *) NULL);
 
-  native_lineno = (LINENO *) buy_and_read(abfd,
-					  asect->line_filepos,
-					  SEEK_SET,
-					  (size_t) (LINESZ *
-						    asect->lineno_count));
+  native_lineno = (LINENO *) buy_and_read (abfd,
+					   asect->line_filepos,
+					   SEEK_SET,
+					   (size_t) (LINESZ *
+						     asect->lineno_count));
   lineno_cache =
-    (alent *) bfd_alloc(abfd, (size_t) ((asect->lineno_count + 1) * sizeof(alent)));
+    (alent *) bfd_alloc (abfd, (size_t) ((asect->lineno_count + 1) * sizeof (alent)));
   if (lineno_cache == NULL)
     {
       bfd_error = no_memory;
@@ -1873,29 +1935,29 @@ coff_slurp_line_table(abfd, asect)
     }
   else
     {
-      unsigned int    counter = 0;
-      alent          *cache_ptr = lineno_cache;
-      LINENO  *src = native_lineno;
+      unsigned int counter = 0;
+      alent *cache_ptr = lineno_cache;
+      LINENO *src = native_lineno;
 
       while (counter < asect->lineno_count)
 	{
 	  struct internal_lineno dst;
-	  coff_swap_lineno_in(abfd, src, &dst);
+	  coff_swap_lineno_in (abfd, src, &dst);
 	  cache_ptr->line_number = dst.l_lnno;
 
 	  if (cache_ptr->line_number == 0)
 	    {
 	      coff_symbol_type *sym =
-		(coff_symbol_type *) (dst.l_addr.l_symndx
-				      + obj_raw_syments(abfd))->u.syment._n._n_n._n_zeroes;
+	      (coff_symbol_type *) (dst.l_addr.l_symndx
+		      + obj_raw_syments (abfd))->u.syment._n._n_n._n_zeroes;
 	      cache_ptr->u.sym = (asymbol *) sym;
 	      sym->lineno = cache_ptr;
 	    }
 	  else
 	    {
 	      cache_ptr->u.offset = dst.l_addr.l_paddr
-		- bfd_section_vma(abfd, asect);
-	    } /* If no linenumber expect a symbol index */
+		- bfd_section_vma (abfd, asect);
+	    }			/* If no linenumber expect a symbol index */
 
 	  cache_ptr++;
 	  src++;
@@ -1910,229 +1972,270 @@ coff_slurp_line_table(abfd, asect)
 }
 
 static boolean
-DEFUN(coff_slurp_symbol_table,(abfd),
-      bfd            *abfd)
+DEFUN (coff_slurp_symbol_table, (abfd),
+       bfd * abfd)
 {
-  combined_entry_type         *native_symbols;
+  combined_entry_type *native_symbols;
   coff_symbol_type *cached_area;
-  unsigned int   *table_ptr;
+  unsigned int *table_ptr;
 
-  unsigned int    number_of_symbols = 0;
-  if (obj_symbols(abfd))
+  unsigned int number_of_symbols = 0;
+  if (obj_symbols (abfd))
     return true;
-  bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET);
+  bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET);
 
   /* Read in the symbol table */
-  if ((native_symbols = coff_get_normalized_symtab(abfd)) == NULL) {
-    return (false);
-  }				/* on error */
+  if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
+    {
+      return (false);
+    }				/* on error */
 
   /* Allocate enough room for all the symbols in cached form */
   cached_area =
     (coff_symbol_type *)
-      bfd_alloc(abfd, (size_t) (bfd_get_symcount(abfd) * sizeof(coff_symbol_type)));
+    bfd_alloc (abfd, (size_t) (bfd_get_symcount (abfd) * sizeof (coff_symbol_type)));
 
-  if (cached_area == NULL) {
-    bfd_error = no_memory;
-    return false;
-  }				/* on error */
+  if (cached_area == NULL)
+    {
+      bfd_error = no_memory;
+      return false;
+    }				/* on error */
   table_ptr =
     (unsigned int *)
-      bfd_alloc(abfd, (size_t) (bfd_get_symcount(abfd) * sizeof(unsigned int)));
+    bfd_alloc (abfd, (size_t) (bfd_get_symcount (abfd) * sizeof (unsigned int)));
 
-  if (table_ptr == NULL) {
-    bfd_error = no_memory;
-    return false;
-  } 
-  else 
-  {
-    coff_symbol_type *dst = cached_area;
-    unsigned int    last_native_index = bfd_get_symcount(abfd);
-    unsigned int    this_index = 0;
-    while (this_index < last_native_index) {
-      combined_entry_type         *src = native_symbols + this_index;
-      table_ptr[this_index] = number_of_symbols;
-      dst->symbol.the_bfd = abfd;
-
-      dst->symbol.name = (char *)(src->u.syment._n._n_n._n_offset);
-      /* We use the native name field to point to the cached field.  */
-      src->u.syment._n._n_n._n_zeroes = (long) dst;
-      dst->symbol.section = coff_section_from_bfd_index(abfd,
-							src->u.syment.n_scnum);
-      dst->symbol.flags = 0;
-      dst->done_lineno = false;
-      
-      switch (src->u.syment.n_sclass) {
+  if (table_ptr == NULL)
+    {
+      bfd_error = no_memory;
+      return false;
+    }
+  else
+    {
+      coff_symbol_type *dst = cached_area;
+      unsigned int last_native_index = bfd_get_symcount (abfd);
+      unsigned int this_index = 0;
+      while (this_index < last_native_index)
+	{
+	  combined_entry_type *src = native_symbols + this_index;
+	  table_ptr[this_index] = number_of_symbols;
+	  dst->symbol.the_bfd = abfd;
+
+	  dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
+	  /* We use the native name field to point to the cached field.  */
+	  src->u.syment._n._n_n._n_zeroes = (long) dst;
+	  dst->symbol.section = coff_section_from_bfd_index (abfd,
+						     src->u.syment.n_scnum);
+	  dst->symbol.flags = 0;
+	  dst->done_lineno = false;
+
+	  switch (src->u.syment.n_sclass)
+	    {
 #ifdef I960
-      case C_LEAFEXT:
+	    case C_LEAFEXT:
 #if 0
-	dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
-	dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
-	dst->symbol.flags |= BSF_NOT_AT_END;
+	      dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
+	      dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
+	      dst->symbol.flags |= BSF_NOT_AT_END;
 #endif
-	/* Fall through to next case */
+	      /* Fall through to next case */
 
 #endif
 
-      case C_EXT:
+	    case C_EXT:
 #ifdef RS6000COFF_C
-      case C_HIDEXT:
-#endif
-	if ((src->u.syment.n_scnum) == 0) {
-	  if ((src->u.syment.n_value) == 0) {
-	    dst->symbol.section = &bfd_und_section;
-	    dst->symbol.value= 0;
-	  }
-	  else {
-	    dst->symbol.section = &bfd_com_section;
-	    dst->symbol.value = (src->u.syment.n_value);
-	  }
-	}
-	else {
-	  /*
+	    case C_HIDEXT:
+#endif
+	      if ((src->u.syment.n_scnum) == 0)
+		{
+		  if ((src->u.syment.n_value) == 0)
+		    {
+		      dst->symbol.section = &bfd_und_section;
+		      dst->symbol.value = 0;
+		    }
+		  else
+		    {
+		      dst->symbol.section = &bfd_com_section;
+		      dst->symbol.value = (src->u.syment.n_value);
+		    }
+		}
+	      else
+		{
+		  /*
 	    Base the value as an index from the base of the
 	    section
 	    */
 
-	    dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
-	    dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
+		  dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
+		  dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
 
-	  if (ISFCN((src->u.syment.n_type))) {
-	    /*
+		  if (ISFCN ((src->u.syment.n_type)))
+		    {
+		      /*
 	      A function ext does not go at the end of a file
 	      */
-	    dst->symbol.flags |= BSF_NOT_AT_END;
-	  }
-	}
-
+		      dst->symbol.flags |= BSF_NOT_AT_END;
+		    }
+		}
 
-	break;
-
-      case C_STAT:		/* static			 */
+#ifdef RS6000COFF_C
+	      /* If this symbol has a csect aux of type LD, the scnlen field
+	   is actually the index of the containing csect symbol.  We
+	   need to pointerize it.  */
+	      if (src->u.syment.n_numaux > 0)
+		{
+		  combined_entry_type *aux;
+
+		  aux = src + src->u.syment.n_numaux - 1;
+		  if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
+		    {
+		      aux->u.auxent.x_csect.x_scnlen.p =
+			native_symbols + aux->u.auxent.x_csect.x_scnlen.l;
+		      aux->fix_scnlen = 1;
+		    }
+		}
+#endif
+
+	      break;
+
+	    case C_STAT:	/* static			 */
 #ifdef I960
-      case C_LEAFSTAT:		/* static leaf procedure        */
-#endif
-      case C_LABEL:		/* label			 */
-	if (src->u.syment.n_scnum == -2)
-	  dst->symbol.flags = BSF_DEBUGGING;
-	else
-	  dst->symbol.flags = BSF_LOCAL;
-	/*
+	    case C_LEAFSTAT:	/* static leaf procedure        */
+#endif
+	    case C_LABEL:	/* label			 */
+	      if (src->u.syment.n_scnum == -2)
+		dst->symbol.flags = BSF_DEBUGGING;
+	      else
+		dst->symbol.flags = BSF_LOCAL;
+	      /*
 	  Base the value as an index from the base of the section, if
 	  there is one
 	  */
-	if (dst->symbol.section)
-	  dst->symbol.value = (src->u.syment.n_value) -
-	    dst->symbol.section->vma;
-	else
-	  dst->symbol.value = (src->u.syment.n_value) ;
-	break;
-
-      case C_MOS:		/* member of structure	 */
-      case C_EOS:		/* end of structure		 */
-#ifdef NOTDEF	/* C_AUTOARG has the same value */
+	      if (dst->symbol.section)
+		dst->symbol.value = (src->u.syment.n_value) -
+		  dst->symbol.section->vma;
+	      else
+		dst->symbol.value = (src->u.syment.n_value);
+	      break;
+
+	    case C_MOS:	/* member of structure	 */
+	    case C_EOS:	/* end of structure		 */
+#ifdef NOTDEF			/* C_AUTOARG has the same value */
 #ifdef C_GLBLREG
-      case C_GLBLREG:		/* A29k-specific storage class */
+	    case C_GLBLREG:	/* A29k-specific storage class */
 #endif
 #endif
-      case C_REGPARM:		/* register parameter		 */
-      case C_REG:		/* register variable		 */
+	    case C_REGPARM:	/* register parameter		 */
+	    case C_REG:	/* register variable		 */
 #ifdef C_AUTOARG
-      case C_AUTOARG:		/* 960-specific storage class */
-#endif
-      case C_TPDEF:		/* type definition		 */
-      case C_ARG:
-      case C_AUTO:		/* automatic variable */
-      case C_FIELD:		/* bit field */
-      case C_ENTAG:		/* enumeration tag		 */
-      case C_MOE:		/* member of enumeration	 */
-      case C_MOU:		/* member of union		 */
-      case C_UNTAG:		/* union tag			 */
-	dst->symbol.flags = BSF_DEBUGGING;
-	dst->symbol.value = (src->u.syment.n_value);
-	break;
-
-      case C_FILE:		/* file name			 */
-      case C_STRTAG:		/* structure tag		 */
+	    case C_AUTOARG:	/* 960-specific storage class */
+#endif
+	    case C_TPDEF:	/* type definition		 */
+	    case C_ARG:
+	    case C_AUTO:	/* automatic variable */
+	    case C_FIELD:	/* bit field */
+	    case C_ENTAG:	/* enumeration tag		 */
+	    case C_MOE:	/* member of enumeration	 */
+	    case C_MOU:	/* member of union		 */
+	    case C_UNTAG:	/* union tag			 */
+	      dst->symbol.flags = BSF_DEBUGGING;
+	      dst->symbol.value = (src->u.syment.n_value);
+	      break;
+
+	    case C_FILE:	/* file name			 */
+	    case C_STRTAG:	/* structure tag		 */
 #ifdef RS6000COFF_C
-      case C_BINCL:		/* beginning of include file     */
-      case C_EINCL:		/* ending of include file        */
-      case C_GSYM:
-      case C_LSYM:
-      case C_PSYM:
-      case C_RSYM:
-      case C_RPSYM:
-      case C_STSYM:
-      case C_DECL:
-      case C_ENTRY:
-      case C_FUN:
-      case C_BSTAT:
-      case C_ESTAT:
-#endif
-	dst->symbol.flags = BSF_DEBUGGING;
-	dst->symbol.value = (src->u.syment.n_value);
-	break;
+	    case C_BINCL:	/* beginning of include file     */
+	    case C_EINCL:	/* ending of include file        */
+	    case C_GSYM:
+	    case C_LSYM:
+	    case C_PSYM:
+	    case C_RSYM:
+	    case C_RPSYM:
+	    case C_STSYM:
+	    case C_DECL:
+	    case C_ENTRY:
+	    case C_FUN:
+	    case C_ESTAT:
+#endif
+	      dst->symbol.flags = BSF_DEBUGGING;
+	      dst->symbol.value = (src->u.syment.n_value);
+	      break;
 
-      case C_BLOCK:		/* ".bb" or ".eb"		 */
-      case C_FCN:		/* ".bf" or ".ef"		 */
-      case C_EFCN:		/* physical end of function	 */
-	dst->symbol.flags = BSF_LOCAL;
-	/*
+#ifdef RS6000COFF_C
+	    case C_BSTAT:
+	      dst->symbol.flags = BSF_DEBUGGING;
+	      dst->symbol.value = src->u.syment.n_value;
+
+	      /* The value is actually a symbol index.  Save a pointer to
+	   the symbol instead of the index.  FIXME: This should use a
+	   union.  */
+	      src->u.syment.n_value =
+		(long) (native_symbols + src->u.syment.n_value);
+	      src->fix_value = 1;
+	      break;
+#endif
+
+	    case C_BLOCK:	/* ".bb" or ".eb"		 */
+	    case C_FCN:	/* ".bf" or ".ef"		 */
+	    case C_EFCN:	/* physical end of function	 */
+	      dst->symbol.flags = BSF_LOCAL;
+	      /*
 	  Base the value as an index from the base of the section
 	  */
-	dst->symbol.value = (src->u.syment.n_value) - dst->symbol.section->vma;
-	break;
-
-      case C_NULL:
-      case C_EXTDEF:		/* external definition		 */
-      case C_ULABEL:		/* undefined label		 */
-      case C_USTATIC:		/* undefined static		 */
-      case C_LINE:		/* line # reformatted as symbol table entry */
-      case C_ALIAS:		/* duplicate tag		 */
-      case C_HIDDEN:		/* ext symbol in dmert public lib */
-      default:
-
-	fprintf(stderr,"Unrecognized storage class %d (assuming debugging)\n  for %s symbol `%s'\n",
-		src->u.syment.n_sclass, dst->symbol.section->name,
-		dst->symbol.name);
+	      dst->symbol.value = (src->u.syment.n_value) - dst->symbol.section->vma;
+	      break;
+
+	    case C_NULL:
+	    case C_EXTDEF:	/* external definition		 */
+	    case C_ULABEL:	/* undefined label		 */
+	    case C_USTATIC:	/* undefined static		 */
+	    case C_LINE:	/* line # reformatted as symbol table entry */
+	    case C_ALIAS:	/* duplicate tag		 */
+	    case C_HIDDEN:	/* ext symbol in dmert public lib */
+	    default:
+
+	      fprintf (stderr, "Unrecognized storage class %d (assuming debugging)\n  for %s symbol `%s'\n",
+		       src->u.syment.n_sclass, dst->symbol.section->name,
+		       dst->symbol.name);
 /*	abort();*/
-	dst->symbol.flags = BSF_DEBUGGING;
-	dst->symbol.value = (src->u.syment.n_value);
-	break;
-      }
+	      dst->symbol.flags = BSF_DEBUGGING;
+	      dst->symbol.value = (src->u.syment.n_value);
+	      break;
+	    }
 
 /*      BFD_ASSERT(dst->symbol.flags != 0);*/
 
-      dst->native = src;
+	  dst->native = src;
 
-      dst->symbol.udata = 0;
-      dst->lineno = (alent *) NULL;
-      this_index += (src->u.syment.n_numaux) + 1;
-      dst++;
-      number_of_symbols++;
-    }				/* walk the native symtab */
-  }				/* bfdize the native symtab */
+	  dst->symbol.udata = 0;
+	  dst->lineno = (alent *) NULL;
+	  this_index += (src->u.syment.n_numaux) + 1;
+	  dst++;
+	  number_of_symbols++;
+	}			/* walk the native symtab */
+    }				/* bfdize the native symtab */
 
-  obj_symbols(abfd) = cached_area;
-  obj_raw_syments(abfd) = native_symbols;
+  obj_symbols (abfd) = cached_area;
+  obj_raw_syments (abfd) = native_symbols;
 
   obj_conv_table_size (abfd) = bfd_get_symcount (abfd);
-  bfd_get_symcount(abfd) = number_of_symbols;
-  obj_convert(abfd) = table_ptr;
+  bfd_get_symcount (abfd) = number_of_symbols;
+  obj_convert (abfd) = table_ptr;
   /* Slurp the line tables for each section too */
-    {
-      asection       *p;
-      p = abfd->sections;
-      while (p) {
-	coff_slurp_line_table(abfd, p);
+  {
+    asection *p;
+    p = abfd->sections;
+    while (p)
+      {
+	coff_slurp_line_table (abfd, p);
 	p = p->next;
       }
-    }
+  }
   return true;
 }				/* coff_slurp_symbol_table() */
 
 /*
-SUBSUBSECTION 
+SUBSUBSECTION
 	Reading relocations
 
 	Coff relocations are easily transformed into the internal BFD form
@@ -2170,79 +2273,80 @@ SUBSUBSECTION
 	    }						\
 	    else {					\
 		cache_ptr->addend = 0;			\
-	    }			
+	    }
 #endif
 
-static          boolean
-DEFUN(coff_slurp_reloc_table,(abfd, asect, symbols),
-      bfd            *abfd AND
-      sec_ptr         asect AND
-      asymbol       **symbols)
+static boolean
+DEFUN (coff_slurp_reloc_table, (abfd, asect, symbols),
+       bfd * abfd AND
+       sec_ptr asect AND
+       asymbol ** symbols)
 {
-  RELOC   *native_relocs;
-  arelent        *reloc_cache;
-  arelent        *cache_ptr;
+  RELOC *native_relocs;
+  arelent *reloc_cache;
+  arelent *cache_ptr;
 
   unsigned int idx;
-  
+
   if (asect->relocation)
-   return true;
+    return true;
   if (asect->reloc_count == 0)
-   return true;
+    return true;
   if (asect->flags & SEC_CONSTRUCTOR)
-   return true;
-  if (!coff_slurp_symbol_table(abfd))
-   return false;
+    return true;
+  if (!coff_slurp_symbol_table (abfd))
+    return false;
   native_relocs =
-   (RELOC *) buy_and_read(abfd,
-			  asect->rel_filepos,
-			  SEEK_SET,
-			  (size_t) (RELSZ *
-				    asect->reloc_count));
+    (RELOC *) buy_and_read (abfd,
+			    asect->rel_filepos,
+			    SEEK_SET,
+			    (size_t) (RELSZ *
+				      asect->reloc_count));
   reloc_cache = (arelent *)
-   bfd_alloc(abfd, (size_t) (asect->reloc_count * sizeof(arelent)));
+    bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
 
-  if (reloc_cache == NULL) {
+  if (reloc_cache == NULL)
+    {
       bfd_error = no_memory;
       return false;
-    } 
+    }
 
-  
-  for (idx = 0; idx < asect->reloc_count; idx ++) 
-  {
+
+  for (idx = 0; idx < asect->reloc_count; idx++)
+    {
 #ifdef RELOC_PROCESSING
       struct internal_reloc dst;
-      struct external_reloc  *src;
+      struct external_reloc *src;
 
       cache_ptr = reloc_cache + idx;
       src = native_relocs + idx;
-      bfd_swap_reloc_in(abfd, src, &dst);
+      bfd_swap_reloc_in (abfd, src, &dst);
 
-      RELOC_PROCESSING(cache_ptr, &dst, symbols, abfd, asect);
+      RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
 #else
       struct internal_reloc dst;
-      asymbol        *ptr;
-      struct external_reloc  *src;
+      asymbol *ptr;
+      struct external_reloc *src;
 
       cache_ptr = reloc_cache + idx;
       src = native_relocs + idx;
 
-      bfd_swap_reloc_in(abfd, src, &dst);
+      bfd_swap_reloc_in (abfd, src, &dst);
 
 
       cache_ptr->address = dst.r_vaddr;
 
-      if (dst.r_symndx != -1) 
+      if (dst.r_symndx != -1)
 	{
 	  /* @@ Should never be greater than count of symbols!  */
 	  if (dst.r_symndx >= obj_conv_table_size (abfd))
 	    abort ();
-	  cache_ptr->sym_ptr_ptr = symbols + obj_convert(abfd)[dst.r_symndx];
+	  cache_ptr->sym_ptr_ptr = symbols + obj_convert (abfd)[dst.r_symndx];
 	  ptr = *(cache_ptr->sym_ptr_ptr);
 	}
-      else 
+      else
 	{
-	  cache_ptr->sym_ptr_ptr= bfd_abs_section.symbol_ptr_ptr;
+	  cache_ptr->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
 	  ptr = 0;
 	}
 
@@ -2254,16 +2358,16 @@ DEFUN(coff_slurp_reloc_table,(abfd, asect, symbols),
 	 Note that symbols which used to be common must be left alone */
 
       /* Calculate any reloc addend by looking at the symbol */
-      CALC_ADDEND(abfd, ptr, dst, cache_ptr);
+      CALC_ADDEND (abfd, ptr, dst, cache_ptr);
 
       cache_ptr->address -= asect->vma;
 /* !!     cache_ptr->section = (asection *) NULL;*/
 
       /* Fill in the cache_ptr->howto field from dst.r_type */
-      RTYPE2HOWTO(cache_ptr, &dst);
+      RTYPE2HOWTO (cache_ptr, &dst);
 #endif
 
-  }
+    }
 
   asect->relocation = reloc_cache;
   return true;
@@ -2272,54 +2376,54 @@ DEFUN(coff_slurp_reloc_table,(abfd, asect, symbols),
 
 /* This is stupid.  This function should be a boolean predicate.  */
 static unsigned int
-DEFUN(coff_canonicalize_reloc, (abfd, section, relptr, symbols),
-bfd            *abfd AND
-sec_ptr         section AND
-arelent       **relptr AND
-asymbol       **symbols)
+DEFUN (coff_canonicalize_reloc, (abfd, section, relptr, symbols),
+       bfd * abfd AND
+       sec_ptr section AND
+       arelent ** relptr AND
+       asymbol ** symbols)
 {
-  arelent        *tblptr = section->relocation;
-  unsigned int    count = 0;
+  arelent *tblptr = section->relocation;
+  unsigned int count = 0;
 
 
-  if (section->flags & SEC_CONSTRUCTOR) 
-  {
-    /* this section has relocs made up by us, they are not in the
+  if (section->flags & SEC_CONSTRUCTOR)
+    {
+      /* this section has relocs made up by us, they are not in the
        file, so take them out of their chain and place them into
        the data area provided */
-    arelent_chain *chain = section->constructor_chain;
-    for (count = 0; count < section->reloc_count; count ++) 
-    {
-      *relptr ++ = &chain->relent;
-      chain = chain->next;
-    }
+      arelent_chain *chain = section->constructor_chain;
+      for (count = 0; count < section->reloc_count; count++)
+	{
+	  *relptr++ = &chain->relent;
+	  chain = chain->next;
+	}
 
-  }
-  else 
-  { 
-    coff_slurp_reloc_table(abfd, section, symbols);
+    }
+  else
+    {
+      coff_slurp_reloc_table (abfd, section, symbols);
 
 
-    tblptr = section->relocation;
-    if (!tblptr)
-     return 0;
+      tblptr = section->relocation;
+      if (!tblptr)
+	return 0;
 
-    for (; count++ < section->reloc_count;)
-     *relptr++ = tblptr++;
+      for (; count++ < section->reloc_count;)
+	*relptr++ = tblptr++;
 
 
-  }
+    }
   *relptr = 0;
   return section->reloc_count;
 }
 
 #ifdef GNU960
 file_ptr
-coff_sym_filepos(abfd)
-bfd *abfd;
-  {
-    return obj_sym_filepos(abfd);
-  }
+coff_sym_filepos (abfd)
+     bfd *abfd;
+{
+  return obj_sym_filepos (abfd);
+}
 #endif
 
 #ifndef coff_reloc16_estimate
@@ -2352,28 +2456,29 @@ dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
      unsigned int *src_ptr;
      unsigned int *dst_ptr;
 {
-  fprintf(stderr, "%s\n", reloc->howto->name);
+  fprintf (stderr, "%s\n", reloc->howto->name);
   abort ();
 }
 #endif
 
-static CONST bfd_coff_backend_data bfd_coff_std_swap_table = {
- coff_swap_aux_in, coff_swap_sym_in, coff_swap_lineno_in,
- coff_swap_aux_out, coff_swap_sym_out,
- coff_swap_lineno_out, coff_swap_reloc_out,
- coff_swap_filehdr_out, coff_swap_aouthdr_out,
- coff_swap_scnhdr_out,
- FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, LINESZ,
+static CONST bfd_coff_backend_data bfd_coff_std_swap_table =
+{
+  coff_swap_aux_in, coff_swap_sym_in, coff_swap_lineno_in,
+  coff_swap_aux_out, coff_swap_sym_out,
+  coff_swap_lineno_out, coff_swap_reloc_out,
+  coff_swap_filehdr_out, coff_swap_aouthdr_out,
+  coff_swap_scnhdr_out,
+  FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, LINESZ,
 #ifdef COFF_LONG_FILENAMES
- true,
+  true,
 #else
- false,
+  false,
 #endif
- coff_swap_filehdr_in, coff_swap_aouthdr_in, coff_swap_scnhdr_in,
- coff_bad_format_hook, coff_set_arch_mach_hook, coff_mkobject_hook,
- styp_to_sec_flags, coff_make_section_hook, coff_set_alignment_hook,
- coff_slurp_symbol_table, symname_in_debug_hook, 
- coff_reloc16_extra_cases, coff_reloc16_estimate
+  coff_swap_filehdr_in, coff_swap_aouthdr_in, coff_swap_scnhdr_in,
+  coff_bad_format_hook, coff_set_arch_mach_hook, coff_mkobject_hook,
+  styp_to_sec_flags, coff_make_section_hook, coff_set_alignment_hook,
+  coff_slurp_symbol_table, symname_in_debug_hook,
+  coff_reloc16_extra_cases, coff_reloc16_estimate
 };
 
 #define coff_core_file_failing_command	_bfd_dummy_core_file_failing_command