Fixed all the places where there were problems with the size and

alignments of structures on disk and structures in memory. #ifed out
all the code in coffswap.c, since it should be done using the target
swap routines now.

4 files changed, 1331 insertions, 1180 deletions

diff --git a/bfd/coff-code.h b/bfd/coff-code.h
index 0f8eee7..41a0f79 100755
--- a/bfd/coff-code.h
+++ b/bfd/coff-code.h
@@ -40,27 +40,42 @@ You should have received a copy of the GNU General Public License along with
 
 #define sp(x) bfd_h_put_x(abfd, x, &x)
 
-PROTO(static void,force_indices_file_symbol_relative,(bfd *abfd, SYMENT *symtab));
+PROTO(static void,force_indices_file_symbol_relative,(bfd *abfd,
+						      struct internal_syment *symtab));
 
 /* All the swapping routines:
+*/
 
-   FIXME, these routines assume that the sizes, alignments, and offsets of
-   these fields are the same in the host and target.  This is an invalid
-   assumption, which in particular breaks on the 386 and SPARC.  Fix this
-   the same way that a.out.h and sunos.c were fixed:  define char arrays
-   that represent the headers in the target systems' file, and have these
-   functions translate in from that format, and out to that format.  */
 
-static void 
-DEFUN(swap_reloc,(abfd, reloc),
+
+static void
+DEFUN(swap_reloc_in,(abfd, reloc_src, reloc_dst),
       bfd            *abfd AND
-      RELOC          *reloc)
+      RELOC *reloc_src AND
+      struct internal_reloc *reloc_dst)
 {
-    sp(reloc->r_vaddr);
-    sp(reloc->r_symndx);
-    sp(reloc->r_type);
+  reloc_dst->r_vaddr = bfd_h_getlong(abfd, reloc_src->r_vaddr);
+  reloc_dst->r_symndx = bfd_h_getlong(abfd, reloc_src->r_symndx);
+  reloc_dst->r_type = bfd_h_getshort(abfd, reloc_src->r_type);
+#if M88
+  reloc_dst->r_offset = bfd_h_getshort(abfd, reloc_src->r_offset);
+#endif
 }
 
+static void
+DEFUN(swap_reloc_out,(abfd, reloc_src, reloc_dst),
+      bfd            *abfd AND
+      struct internal_reloc *reloc_src AND
+      struct external_reloc *reloc_dst)
+{
+  bfd_h_putlong(abfd, reloc_src->r_vaddr, reloc_dst->r_vaddr);
+  bfd_h_putlong(abfd, reloc_src->r_symndx, reloc_dst->r_symndx);
+  bfd_h_putshort(abfd, reloc_src->r_type, reloc_dst->r_type);
+#if M88
+  bfd_h_putshort(abfd, reloc_src->r_offset, reloc_dst->r_offset);
+#endif
+
+}
 
 static void 
 DEFUN(swap_filehdr,(abfd, filehdr),
@@ -78,6 +93,186 @@ DEFUN(swap_filehdr,(abfd, filehdr),
 
 }
 
+
+static void 
+DEFUN(bfd_coff_swap_name_in,(abfd, ptr),
+      bfd            *abfd AND
+      long           *ptr)
+{
+    if (ptr[0] == 0) {
+	/* There is an index which needs to be swapped */
+	bfd_h_put_x(abfd, ptr[1], (ptr + 1));
+    }
+    else {
+	/* This is a string .. leave it alone */
+    }
+}
+
+static void 
+DEFUN(bfd_coff_swap_sym_in,(abfd, ext, in),
+      bfd            *abfd AND
+      SYMENT *ext AND
+      struct internal_syment      *in)
+{
+  if( ext->e.e_name[0] == 0) {
+    in->_n._n_n._n_zeroes = 0;
+    in->_n._n_n._n_offset = bfd_h_getlong(abfd, &ext->e.e.e_offset);
+  }
+  else {
+    memcpy(in->_n._n_name, ext->e.e_name, SYMNMLEN);
+  }
+  in->n_value = bfd_h_get_x(abfd, &ext->e_value);
+  in->n_scnum = bfd_h_get_x(abfd, &ext->e_scnum);
+  in->n_type = bfd_h_get_x(abfd, &ext->e_type);
+  in->n_sclass = bfd_h_get_x(abfd, &ext->e_sclass);
+  in->n_numaux = bfd_h_get_x(abfd, &ext->e_numaux);
+}
+
+static void 
+DEFUN(bfd_coff_swap_sym_out,(abfd,in,  ext),
+      bfd            *abfd AND
+      struct internal_syment      *in AND
+      SYMENT *ext)
+{
+  if(in->_n._n_name[0] == 0) {
+    bfd_h_putlong(abfd, 0, ext->e.e.e_zeroes);
+    bfd_h_putlong(abfd, in->_n._n_n._n_offset,  ext->e.e.e_offset);
+  }
+  else {
+    memcpy(ext->e.e_name, in->_n._n_name, SYMNMLEN);
+  }
+  bfd_h_put_x(abfd,  in->n_value , &ext->e_value);
+  bfd_h_put_x(abfd,  in->n_scnum , &ext->e_scnum);
+  bfd_h_put_x(abfd,  in->n_type , &ext->e_type);
+  bfd_h_put_x(abfd,  in->n_sclass , &ext->e_sclass);
+  bfd_h_put_x(abfd,  in->n_numaux , &ext->e_numaux);
+}
+
+static void
+DEFUN(bfd_coff_swap_aux_in,(abfd, ext, type, class, in),
+      bfd            *abfd AND
+      AUXENT    *ext AND
+      int             type AND
+      int             class AND
+      union internal_auxent  *in)
+{
+  switch (class) {
+  case C_FILE:
+    if (ext->x_file.x_fname[0] == 0) {
+      in->x_file.x_n.x_zeroes = 0;
+      in->x_file.x_n.x_offset  = bfd_h_getlong(abfd, &ext->x_file.x_n.x_offset);
+    }
+
+    break;
+  case C_STAT:
+#ifdef C_LEAFSTAT
+  case C_LEAFSTAT:
+#endif
+  case C_HIDDEN:
+    if (type == T_NULL) {
+      in->x_scn.x_scnlen = bfd_h_get_x(abfd, & ext->x_scn.x_scnlen);
+      in->x_scn.x_nreloc = bfd_h_get_x(abfd, &ext->x_scn.x_nreloc);
+      in->x_scn.x_nlinno = bfd_h_get_x(abfd, &ext->x_scn.x_nlinno);
+      break;
+    }
+  default:
+    in->x_sym.x_tagndx = bfd_h_get_x(abfd, &ext->x_sym.x_tagndx);
+    in->x_sym.x_tvndx = bfd_h_get_x(abfd, &ext->x_sym.x_tvndx);
+
+    if (ISARY(type) || class == C_BLOCK) {
+      in->x_sym.x_fcnary.x_ary.x_dimen[0] = bfd_h_get_x(abfd, & ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
+      in->x_sym.x_fcnary.x_ary.x_dimen[1] = bfd_h_get_x(abfd, & ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
+      in->x_sym.x_fcnary.x_ary.x_dimen[2] = bfd_h_get_x(abfd, & ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
+      in->x_sym.x_fcnary.x_ary.x_dimen[3] = bfd_h_get_x(abfd, &ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
+    }
+    else {
+      in->x_sym.x_fcnary.x_fcn.x_lnnoptr = bfd_h_get_x(abfd, & ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
+      in->x_sym.x_fcnary.x_fcn.x_endndx = bfd_h_get_x(abfd, & ext->x_sym.x_fcnary.x_fcn.x_endndx);
+    }
+    if (ISFCN(type)) {
+      in->x_sym.x_misc.x_fsize = bfd_h_get_x(abfd, &ext->x_sym.x_misc.x_fsize);
+    }
+    else {
+      in->x_sym.x_misc.x_lnsz.x_lnno = bfd_h_get_x(abfd, & ext->x_sym.x_misc.x_lnsz.x_lnno);
+      in->x_sym.x_misc.x_lnsz.x_size = bfd_h_get_x(abfd, & ext->x_sym.x_misc.x_lnsz.x_size);
+    }
+  }
+}
+
+static void
+DEFUN(bfd_coff_swap_aux_out,(abfd, in, type, class, ext),
+  bfd   *abfd AND
+  union internal_auxent *in AND
+  int    type AND
+  int    class AND
+  AUXENT *ext)
+{
+  switch (class) {
+  case C_FILE:
+    if (in->x_file.x_fname[0] == 0) {
+      bfd_h_put_x(abfd, 0,&ext->x_file.x_n.x_zeroes );
+      bfd_h_put_x(abfd, in->x_file.x_n.x_offset, &ext->x_file.x_n.x_offset);
+    }
+
+    break;
+  case C_STAT:
+#ifdef C_LEAFSTAT
+  case C_LEAFSTAT:
+#endif
+  case C_HIDDEN:
+    if (type == T_NULL) {
+      bfd_h_put_x(abfd, in->x_scn.x_scnlen, & ext->x_scn.x_scnlen);
+      bfd_h_put_x(abfd, in->x_scn.x_nreloc, & ext->x_scn.x_nreloc);
+      bfd_h_put_x(abfd, in->x_scn.x_nlinno, & ext->x_scn.x_nlinno);
+      break;
+    }
+  default:
+    bfd_h_put_x(abfd, in->x_sym.x_tagndx, &ext->x_sym.x_tagndx);
+    bfd_h_put_x(abfd, in->x_sym.x_tvndx , &ext->x_sym.x_tvndx);
+
+    if (ISARY(type) || class == C_BLOCK) {
+      bfd_h_put_x(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0], & ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
+      bfd_h_put_x(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1], & ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
+      bfd_h_put_x(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2], & ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
+      bfd_h_put_x(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3], & ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
+    }
+    else {
+      bfd_h_put_x(abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, & ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
+      bfd_h_put_x(abfd, in->x_sym.x_fcnary.x_fcn.x_endndx, & ext->x_sym.x_fcnary.x_fcn.x_endndx);
+    }
+    if (ISFCN(type)) {
+      bfd_h_put_x(abfd, in->x_sym.x_misc.x_fsize, &ext->x_sym.x_misc.x_fsize);
+    }
+    else {
+      bfd_h_put_x(abfd, in->x_sym.x_misc.x_lnsz.x_lnno, & ext->x_sym.x_misc.x_lnsz.x_lnno);
+      bfd_h_put_x(abfd, in->x_sym.x_misc.x_lnsz.x_size, & ext->x_sym.x_misc.x_lnsz.x_size);
+    }
+  }
+}
+
+static void
+DEFUN(bfd_coff_swap_lineno_in,(abfd, ext, in),
+      bfd            *abfd AND
+      LINENO *ext AND
+      struct internal_lineno      *in)
+{
+    in->l_addr.l_symndx = bfd_h_get_x(abfd, &ext->l_addr.l_symndx);
+    in->l_lnno = bfd_h_get_x(abfd, & ext->l_lnno);
+}
+
+static void
+DEFUN(bfd_coff_swap_lineno_out,(abfd, in, ext),
+      bfd            *abfd AND
+      struct internal_lineno      *in AND
+      struct external_lineno *ext)
+{
+  bfd_h_put_x(abfd, in->l_addr.l_symndx, &ext->l_addr.l_symndx);
+  bfd_h_put_x(abfd, in->l_lnno, &ext->l_lnno);
+}
+
+
+
+
 static void 
 DEFUN(swap_aouthdr,(abfd, aouthdr),
       bfd            *abfd AND
@@ -151,6 +346,9 @@ DEFUN(coff_new_section_hook,(abfd_ignore, section_ignore),
   /* Align to at least 16 bytes */
   section_ignore->alignment_power = 4;
 #endif
+#if M68
+  section_ignore->alignment_power = 3;
+#endif
   return true;
 }
 
@@ -297,7 +495,7 @@ DEFUN(coff_real_object_p,(abfd, nscns, opthdr),
   switch (filehdr->f_magic) {
 #ifdef MC68MAGIC
   case MC68MAGIC:
-  case MC68DMAGIC:
+  case M68MAGIC:
     abfd->obj_arch = bfd_arch_m68k;
     abfd->obj_machine = 68020;
     break;
@@ -484,8 +682,9 @@ DEFUN(coff_count_linenumbers,(abfd),
 
 */
 static boolean
-DEFUN(uses_x_sym_x_tagndx_p,(native),
-      SYMENT *native)
+DEFUN(uses_x_sym_x_tagndx_p,(abfd, native),
+      bfd *abfd AND
+      struct internal_syment *native)
 {
     if (BTYPE(native->n_type) == T_STRUCT) return true;
     if (BTYPE(native->n_type) == T_UNION)  return true;
@@ -536,11 +735,11 @@ bfd *bfd_ptr;
 {
   unsigned int symbol_count = bfd_get_symcount(bfd_ptr);
   asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
-  SYMENT *last_tagndx = (SYMENT *)NULL;
-  SYMENT *last_file = (SYMENT *)NULL;
-  SYMENT *last_fcn = (SYMENT *)NULL;
-  SYMENT *block_stack[50];
-  SYMENT **last_block = &block_stack[0];
+  struct internal_syment *last_tagndx = (struct internal_syment *)NULL;
+  struct internal_syment *last_file = (struct internal_syment *)NULL;
+  struct internal_syment *last_fcn = (struct internal_syment *)NULL;
+  struct internal_syment *block_stack[50];
+  struct internal_syment **last_block = &block_stack[0];
   boolean first_time = true;  
   unsigned int symbol_index;
   unsigned int native_index = 0;
@@ -556,31 +755,32 @@ bfd *bfd_ptr;
       native_index++;
     }
     else {
-      SYMENT *syment = coff_symbol_ptr->native;
-      if (syment == (SYMENT *)NULL) {
+      struct internal_syment *syment = coff_symbol_ptr->native;
+      if (syment == (struct internal_syment *)NULL) {
 	native_index++;
       }
       else {
 	/* Normalize the symbol flags */
 	if (coff_symbol_ptr->symbol.flags & BSF_FORT_COMM) {
 	  /* a common symbol is undefined with a value */
-	  syment->n_scnum = N_UNDEF;
-	  syment->n_value = coff_symbol_ptr->symbol.value;
+	 syment->n_scnum = N_UNDEF;
+	 syment->n_value = coff_symbol_ptr->symbol.value;
 	}
 	else if (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) {
 	  syment->n_value = coff_symbol_ptr->symbol.value;
 	}
 	else if (coff_symbol_ptr->symbol.flags & BSF_UNDEFINED) {
-	  syment->n_scnum = N_UNDEF;
-	  syment->n_value = 0;
+	   syment->n_scnum = N_UNDEF;
+	    syment->n_value = 0;
 	}	  
 	else if (coff_symbol_ptr->symbol.flags & BSF_ABSOLUTE) {
 	  syment->n_scnum = N_ABS;
 	  syment->n_value = coff_symbol_ptr->symbol.value;
 	}	  
 	else {
-	  syment->n_scnum =
+	  syment->n_scnum	 = 
 	    coff_symbol_ptr->symbol.section->output_section->index+1;
+
 	  syment->n_value = 
 	    coff_symbol_ptr->symbol.value +
 	      coff_symbol_ptr->symbol.section->output_offset +
@@ -590,9 +790,9 @@ bfd *bfd_ptr;
 
 	/* If this symbol ties up something then do it */
 
-	if (syment->n_sclass == C_FILE && last_file != (SYMENT *)NULL)
+	if (syment->n_sclass == C_FILE && last_file != (struct internal_syment *)NULL)
 	  {
-	    last_file->n_value = native_index;
+	     last_file->n_value = native_index;
 	  }
 	else if ((syment->n_sclass == C_EXT 
 		  || syment->n_sclass == C_STAT 
@@ -601,70 +801,67 @@ bfd *bfd_ptr;
 		  || syment->n_sclass == C_LEAFSTAT
 #endif
 		  )
-		 && last_fcn != (SYMENT *)NULL) 
+		 && last_fcn != (struct internal_syment *)NULL) 
 	  {
-	    AUXENT *auxent = (AUXENT *)(last_fcn+1);
+	    union internal_auxent *auxent = (union internal_auxent *)(last_fcn+1);
 	    auxent->x_sym.x_fcnary.x_fcn.x_endndx = native_index;
-	    last_fcn = (SYMENT *)NULL;
+	    last_fcn = (struct internal_syment *)NULL;
 
 	  }
-	else if (syment->n_sclass == C_EOS && last_tagndx != (SYMENT*)NULL)
+	else if (syment->n_sclass == C_EOS && last_tagndx != (struct internal_syment*)NULL)
 	  {
-	    AUXENT *auxent = (AUXENT *)(last_tagndx+1);
+	    union internal_auxent *auxent = (union internal_auxent *)(last_tagndx+1);
 	    /* Remember that we keep the native index in the offset 
-	       so patch the beginning of the struct to point to this
-	       */
-	    auxent->x_sym.x_tagndx = last_tagndx->n_offset;
-	    auxent->x_sym.x_fcnary.x_fcn.x_endndx =
-	      native_index + syment->n_numaux + 1 ;
+	      so patch the beginning of the struct to point to this
+		*/
+	    auxent->x_sym.x_tagndx =    last_tagndx->_n._n_n._n_offset;
+	    auxent->x_sym.x_fcnary.x_fcn.x_endndx = syment->n_numaux + 1 + native_index;
 	    /* Now point the eos to the structure */
-	    auxent = (AUXENT *)(syment+1);
-	    auxent->x_sym.x_tagndx = last_tagndx->n_offset;
-	      
-	    
+	    auxent = (union internal_auxent *)(syment+1);
+	    auxent->x_sym.x_tagndx =  last_tagndx->_n._n_n._n_offset;
 	  }
 	else if (syment->n_sclass == C_BLOCK 
 		 && coff_symbol_ptr->symbol.name[1] == 'e') 
-	  {
-	    AUXENT *auxent = (AUXENT *)((*(--last_block))+1);
-	    auxent->x_sym.x_fcnary.x_fcn.x_endndx = 
-	      native_index + syment->n_numaux + 1;
-	  }
+	    {
+	      union internal_auxent *auxent = (union internal_auxent *)((*(--last_block))+1);
+	      auxent->x_sym.x_fcnary.x_fcn.x_endndx = native_index + syment->n_numaux + 1;
+	    }
 	if (syment->n_sclass == C_EXT 
 	    && !ISFCN(syment->n_type) 
 	    && first_time == true 
-	    && last_file != (SYMENT *)NULL) {
+	    && last_file != (struct internal_syment *)NULL) {
 	  /* This is the first external symbol seen which isn't a 
-	     function place it in the last .file entry */
-	  last_file->n_value = native_index;
+	    function place it in the last .file entry */
+	   last_file->n_value = native_index;
 	  first_time = false;
 	}
 #ifdef C_LEAFPROC
-	if (syment->n_sclass == C_LEAFPROC && syment->n_numaux == 2) {
-	  AUXENT *auxent = (AUXENT *)(syment+2);
+	if (syment->n_sclass == C_LEAFPROC &&
+	    bfd_h_get_x(bfd_ptr, &syment->n_numaux) == 2) {
+	  union internal_auxent *auxent = (union internal_auxent *)(syment+2);
 	  /* This is the definition of a leaf proc, we'll relocate the 
-	  address */
-
-	  auxent->x_bal.x_balntry +=
-	      coff_symbol_ptr->symbol.section->output_offset + 
-	    coff_symbol_ptr->symbol.section->output_section->vma ;
+	     address */
+	  auxent->x_bal.x_balntry = 	  
+	    coff_symbol_ptr->symbol.section->output_offset + 
+	      coff_symbol_ptr->symbol.section->output_section->vma +
+		auxent->x_bal.x_balntry   ;
 	}
 #endif
 	/* If this symbol needs to be tied up then remember some facts */
 	if (syment->n_sclass == C_FILE) 
- 	  {
-	    last_file = syment;
-	  }
+	    {
+	      last_file = syment;
+	    }
 	if (syment->n_numaux != 0) {
 	  /*
-	     If this symbol would like to point to something in the
-	     future then remember where it is 
-	     */
-	  if (uses_x_sym_x_tagndx_p(syment)) {
+	    If this symbol would like to point to something in the
+	      future then remember where it is 
+		*/
+	  if (uses_x_sym_x_tagndx_p(bfd_ptr, syment)) {
 	    /* 
-	       If this is a ref to a structure then we'll tie it up 
-	       now - there are never any forward refs for one 
-	       */
+	      If this is a ref to a structure then we'll tie it up 
+		now - there are never any forward refs for one 
+		  */
 	    if (syment->n_sclass == C_STRTAG ||
 		syment->n_sclass == C_ENTAG ||
 		syment->n_sclass == C_UNTAG) {
@@ -672,28 +869,29 @@ bfd *bfd_ptr;
 	    }
 	    else {
 	      /*
-		 This is a ref to a structure - the structure must
-		 have been defined within the same file, and previous
-		 to this point, so we can deduce the new tagndx
-		 directly.
-		 */
-	      AUXENT *auxent = (AUXENT *)(syment+1);
+		This is a ref to a structure - the structure must
+		have been defined within the same file, and previous
+		to this point, so we can deduce the new tagndx
+		directly.
+		*/
+	      union internal_auxent *auxent = (union internal_auxent *)(syment+1);
 	      bfd *bfd_ptr = coff_symbol_ptr->symbol.the_bfd;
-	      SYMENT *base = obj_raw_syments(bfd_ptr);	      
-	      auxent->x_sym.x_tagndx = base[auxent->x_sym.x_tagndx].n_offset;
-
+	      struct internal_syment *base = obj_raw_syments(bfd_ptr);	      
+	      auxent->x_sym.x_tagndx = base[auxent->x_sym.x_tagndx]._n._n_n._n_offset;
+	      
+	      
 	    }
 	  }
 	  if (ISFCN(syment->n_type)) {
 	    last_fcn = syment;
 	  }
-	  if (syment->n_sclass == C_BLOCK 
+	  if (bfd_h_get_x(bfd_ptr, & syment->n_sclass) == C_BLOCK 
 	      && coff_symbol_ptr->symbol.name[1] == 'b')
-	    {
-	      *last_block++ = syment;
-	    }
+	      {
+		*last_block++ = syment;
+	      }
 	}
-	syment->n_offset = native_index;
+	syment->_n._n_n._n_offset = native_index;
 	native_index = native_index + 1 + syment->n_numaux;
       }
     }
@@ -703,445 +901,449 @@ bfd *bfd_ptr;
 
 static void 
 coff_write_symbols(abfd)
-    bfd            *abfd;
-{
-  unsigned int    i;
-  unsigned int    limit = bfd_get_symcount(abfd);
-  unsigned int    written = 0;
-  SYMENT          dummy;
-  asymbol       **p;
-  unsigned int    string_size = 0;
-
-
-  /* Seek to the right place */
-  bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET);
-
-  /* Output all the symbols we have */
-
-  written = 0;
-  for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) {
-    asymbol        *symbol = *p;
-    coff_symbol_type *c_symbol = coff_symbol_from(abfd, symbol);
-
-    unsigned int    j;
-    SYMENT         *native;
-    if (c_symbol == (coff_symbol_type *) NULL ||
-	c_symbol->native == (SYMENT *) NULL) {
-      /*
-	 This symbol has been created by the loader, or come from a non
-	 coff format. It  has no native element to inherit, make our
-	 own
-	 */
-
-      native = &dummy;
-      native->n_type = T_NULL;
-#ifdef I960
-      native->n_flags = 0;
-#endif
-      if (symbol->flags & BSF_ABSOLUTE) {
-	native->n_scnum = N_ABS;
-	native->n_value = symbol->value;
-      }
-      else if (symbol->flags & (BSF_UNDEFINED | BSF_FORT_COMM)) {
-	native->n_scnum = N_UNDEF;
-	native->n_value = symbol->value;
-      }
-      else if (symbol->flags & BSF_DEBUGGING) {
-	/*
-	   remove name so it doesn't take up any space
-	   */
-	symbol->name = "";
-#if 0				/* FIXME -- Steve hasn't decided what to do
-				   with these */
+bfd            *abfd;
+  {
+    unsigned int    i;
+    unsigned int    limit = bfd_get_symcount(abfd);
+    unsigned int    written = 0;
+    struct internal_syment          dummy;
+    asymbol       **p;
+    unsigned int    string_size = 0;
+    
+    
+    /* Seek to the right place */
+    bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET);
+    
+    /* Output all the symbols we have */
+    
+    written = 0;
+    for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) {
+      asymbol        *symbol = *p;
+      coff_symbol_type *c_symbol = coff_symbol_from(abfd, symbol);
+      
+      unsigned int    j;
+      struct internal_syment         *native;
+      if (c_symbol == (coff_symbol_type *) NULL ||
+	  c_symbol->native == (struct internal_syment *) NULL) {
 	/*
-	   Don't do anything with debugs from the loader
-	   */
-	native->n_scnum = N_DEBUG;
-#endif
-	continue;
-      }
-      else {
-	native->n_scnum = symbol->section->output_section->index + 1;
-	native->n_value = symbol->value +
-	  symbol->section->output_section->vma +
-	    symbol->section->output_offset;
+	  This symbol has been created by the loader, or come from a non
+	    coff format. It  has no native element to inherit, make our
+	      own
+		*/
+	
+	native = &dummy;
+	native->n_type =  T_NULL;
 #ifdef I960
-	/* Copy the any flags from the the file hdr into the symbol  */
-	{
-	  coff_symbol_type *c = coff_symbol_from(abfd, symbol);
-	  if (c != (coff_symbol_type *)NULL) {
-	    native->n_flags = c->symbol.the_bfd->flags;
-	  }
+	native->n_flags =  0;
+#endif
+	if (symbol->flags & BSF_ABSOLUTE) {
+	  native->n_scnum  =  N_ABS;
+	  native->n_value =  symbol->value;
+	}
+	else if (symbol->flags & (BSF_UNDEFINED | BSF_FORT_COMM)) {
+	  native->n_scnum =  N_UNDEF;
+	  native->n_value =  symbol->value;
+	}
+	else if (symbol->flags & BSF_DEBUGGING) {
+	  /*
+	    remove name so it doesn't take up any space
+	      */
+	  symbol->name = "";
+	  continue;
 	}
+	else {
+	  native->n_scnum  =   symbol->section->output_section->index +
+	    1;
+	  native->n_value =   symbol->value +
+	    symbol->section->output_section->vma +
+	      symbol->section->output_offset;
+#ifdef I960
+	  /* Copy the any flags from the the file hdr into the symbol  */
+	    {
+	      coff_symbol_type *c = coff_symbol_from(abfd, symbol);
+	      if (c != (coff_symbol_type *)NULL) {
+	    native->n_flags =   c->symbol.the_bfd->flags;
+	      }
+	    }
 #endif
 	}
-
-
-
+	
 #ifdef HASPAD1
-      native->pad1[0] = 0;
-      native->pad1[0] = 0;
+	native->pad1[0] = 0;
+	native->pad1[0] = 0;
 #endif
 
-      native->pad2[0] = 0;
-      native->pad2[1] = 0;
-
-      native->n_type = 0;
-      native->n_sclass = C_EXT;
-      native->n_numaux = 0;
-    }
-    else
-      /*
-	 Does this symbol have an ascociated line number - if so then
-	 make it remember this symbol index. Also tag the auxent of
-	 this symbol to point to the right place in the lineno table
-	 */
-      {
-	alent          *lineno = c_symbol->lineno;
-	native = c_symbol->native;
-	if (lineno) {
-	  unsigned int    count = 0;
-	  lineno[count].u.offset = written;
-	  if (native->n_numaux) {
-	    union auxent   *a = (union auxent *) (native + 1);
-	    a->x_sym.x_fcnary.x_fcn.x_lnnoptr =
-	      c_symbol->symbol.section->output_section->moving_line_filepos;
+	 native->n_type =  0;
+	if (symbol->flags & BSF_LOCAL)
+	   native->n_sclass =  C_STAT;
+	else 
+	   native->n_sclass =  C_EXT;
+	 native->n_numaux =  0;
+      }
+      else
+	/*
+	  Does this symbol have an ascociated line number - if so then
+	    make it remember this symbol index. Also tag the auxent of
+	      this symbol to point to the right place in the lineno table
+		*/
+	  {
+	    alent          *lineno = c_symbol->lineno;
+	    native = c_symbol->native;
+	    if (lineno) {
+	      unsigned int    count = 0;
+	      lineno[count].u.offset = written;
+	      if (native->n_numaux) {
+		union internal_auxent  *a = (union internal_auxent *) (native + 1);
+		
+			    a->x_sym.x_fcnary.x_fcn.x_lnnoptr =  
+			    c_symbol->symbol.section->output_section->moving_line_filepos;
+	      }
+	      /*
+		And count and relocate all other linenumbers
+		  */
+	      count++;
+	      while (lineno[count].line_number) {
+		lineno[count].u.offset +=
+		  c_symbol->symbol.section->output_section->vma +
+		    c_symbol->symbol.section->output_offset;
+		count++;
+	      }
+	      c_symbol->symbol.section->output_section->moving_line_filepos +=
+		count * LINESZ;
+	      
+	    }
+	  }			/* if symbol new to coff */
+      
+      /* Fix the symbol names */
+	{
+	  unsigned int    name_length;
+	  if (symbol->name == (char *) NULL) {
+	    /*
+	      coff symbols always have names, so we'll make one up
+		*/
+	    symbol->name = "strange";
 	  }
-	  /*
-	     And count and relocate all other linenumbers
-	     */
-	  count++;
-	  while (lineno[count].line_number) {
-	    lineno[count].u.offset +=
-	      c_symbol->symbol.section->output_section->vma +
-		c_symbol->symbol.section->output_offset;
-	    count++;
+	  name_length = strlen(symbol->name);
+	  if (name_length <= SYMNMLEN) {
+	    /* This name will fit into the symbol neatly */
+	    strncpy(native->_n._n_name, symbol->name, SYMNMLEN);
 	  }
-	  c_symbol->symbol.section->output_section->moving_line_filepos +=
-	    count * sizeof(struct lineno);
-
+	  else {
+	    native->_n._n_n._n_offset =  string_size + 4;
+	    native->_n._n_n._n_zeroes = 0;
+	    string_size += name_length + 1;
+	  }
+	    {
+	      unsigned int    numaux = native->n_numaux;
+	      int             type = native->n_type;
+	      int             class =  native->n_sclass;
+	      SYMENT buf;
+ 	      bfd_coff_swap_sym_out(abfd, native, &buf);
+	      bfd_write((PTR)& buf, 1, SYMESZ, abfd);
+	      for (j = 0; j != bfd_h_get_x(abfd, &native->n_numaux);
+		   j++) {
+		AUXENT buf1;
+		bfd_coff_swap_aux_out(abfd,
+				      (union internal_auxent *)(native + j + 1), type, class, &buf1);
+		bfd_write((PTR) (native + j + 1), 1, AUXESZ, abfd);
+	      }
+	      /*
+		Reuse somewhere in the symbol to keep the index
+		  */
+	      set_index(symbol, written);
+	      written += 1 + numaux;
+	    }
 	}
-      }	/* if symbol new to coff */
-
-    /* Fix the symbol names */
-    {
-      unsigned int    name_length;
-      if (symbol->name == (char *) NULL) {
-	/*
-	   coff symbols always have names, so we'll make one up
-	   */
-	symbol->name = "strange";
-      }
-      name_length = strlen(symbol->name);
-      if (name_length <= SYMNMLEN) {
-	/* This name will fit into the symbol neatly */
-	strncpy(native->n_name, symbol->name, SYMNMLEN);
-      }
-      else {
-	native->n_offset = string_size + 4;
-	native->n_zeroes = 0;
-	string_size += name_length + 1;
-      }
-      {
-	unsigned int    numaux = native->n_numaux;
-	int             type = native->n_type;
-	int             class = native->n_sclass;
-	bfd_coff_swap_sym(abfd, native);
-	bfd_write((PTR) native, 1, SYMESZ, abfd);
-	for (j = 0; j != native->n_numaux; j++) {
-	  bfd_coff_swap_aux(abfd, (AUXENT *)(native + j + 1), type, class);
-	  bfd_write((PTR) (native + j + 1), 1, AUXESZ, abfd);
-
+    }			/* for each out symbol */
+    
+    bfd_get_symcount(abfd) = written;
+    /* Now write out strings */
+    
+    if (string_size) {
+      unsigned int    size = string_size + 4;
+      size =  size;
+      bfd_write((PTR) &size, 1, sizeof(size), abfd);
+      for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) {
+	asymbol        *q = *p;
+	size_t          name_length = strlen(q->name);
+	if (name_length > SYMNMLEN) {
+	  bfd_write((PTR) (q->name), 1, name_length + 1, abfd);
 	}
-	/*
-	   Reuse somewhere in the symbol to keep the index
-	   */
-	set_index(symbol, written);
-	written += 1 + numaux;
       }
     }
-  } /* for each out symbol */
-
-  bfd_get_symcount(abfd) = written;
-  /* Now write out strings */
-
-  if (string_size) {
-    unsigned int    size = string_size + 4;
-    bfd_h_put_x(abfd, size, &size);
-    bfd_write((PTR) &size, 1, sizeof(size), abfd);
-    for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) {
-      asymbol        *q = *p;
-      size_t          name_length = strlen(q->name);
-      if (name_length > SYMNMLEN) {
-	bfd_write((PTR) (q->name), 1, name_length + 1, abfd);
-      }
+    else {
+      /* We would normally not write anything here, but we'll write
+	out 4 so that any stupid coff reader which tries to read
+	  the string table even when there isn't one won't croak.
+	    */
+      
+      uint32e_type size = 4;
+      size =  size;
+      bfd_write((PTR)&size, 1, sizeof(size), abfd);
+      
     }
+    
   }
-  else {
-    /* We would normally not write anything here, but we'll write
-       out 4 so that any stupid coff reader which tries to read
-       the string table even when there isn't one won't croak.
-       */
-
-    uint32e_type size = 4;
-    bfd_h_put_x(abfd, size, &size);
-    bfd_write((PTR)&size, 1, sizeof(size), abfd);
-	
-  }
-
-}
 
 static void 
 coff_write_relocs(abfd)
-    bfd            *abfd;
-{
+bfd            *abfd;
+  {
     asection       *s;
     for (s = abfd->sections; s != (asection *) NULL; s = s->next) {
-	unsigned int    i;
-	arelent       **p = s->orelocation;
-	bfd_seek(abfd, s->rel_filepos, SEEK_SET);
-	for (i = 0; i < s->reloc_count; i++) {
-	    struct reloc    n;
-	    arelent        *q = p[i];
-	    memset((PTR)&n, 0, sizeof(n));
-	    n.r_vaddr = q->address + s->vma;
-	    if (q->sym_ptr_ptr) {
-	    n.r_symndx = get_index((*(q->sym_ptr_ptr)));
-	  }
-	    n.r_type = q->howto->type;
-	    swap_reloc(abfd, &n);
-	    bfd_write((PTR) &n, 1, RELSZ, abfd);
+      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;
+	if (q->sym_ptr_ptr) {
+	  n.r_symndx = get_index((*(q->sym_ptr_ptr)));
 	}
+#ifdef SELECT_RELOC
+	/* Work out reloc type from what is required */
+	SELECT_RELOC(n.r_type, q->howto);
+#else
+	n.r_type = q->howto->type;
+#endif
+	swap_reloc_out(abfd, &n, &dst);
+	bfd_write((PTR) &n, 1, RELSZ, abfd);
+      }
     }
-}
+  }
 
 static void 
 coff_write_linenumbers(abfd)
-    bfd            *abfd;
-{
+bfd            *abfd;
+  {
     asection       *s;
     for (s = abfd->sections; s != (asection *) NULL; s = s->next) {
-	if (s->lineno_count) {
-	    asymbol       **q = abfd->outsymbols;
-	    bfd_seek(abfd, s->line_filepos, SEEK_SET);
-	    /* Find all the linenumbers in this section */
-	    while (*q) {
-		asymbol        *p = *q;
-		alent          *l = BFD_SEND(p->the_bfd, _get_lineno, (p->the_bfd, p));
-		if (l) {
-		    /* Found a linenumber entry, output */
-		    struct lineno   out;
-		    bzero( (PTR)&out, sizeof(out));
-		    out.l_lnno = 0;
-		    out.l_addr.l_symndx = l->u.offset;
-		    bfd_coff_swap_lineno(abfd, &out);
-		    bfd_write((PTR) &out, 1, LINESZ, abfd);
-		    l++;
-		    while (l->line_number) {
-			out.l_lnno = l->line_number;
-			out.l_addr.l_symndx = l->u.offset;
-			bfd_coff_swap_lineno(abfd, &out);
-			bfd_write((PTR) &out, 1, LINESZ, abfd);
-			l++;
-		    }
-		}
-		q++;
+      if (s->lineno_count) {
+	asymbol       **q = abfd->outsymbols;
+	bfd_seek(abfd, s->line_filepos, SEEK_SET);
+	/* Find all the linenumbers in this section */
+	while (*q) {
+	  asymbol        *p = *q;
+	  alent          *l = BFD_SEND(p->the_bfd, _get_lineno, (p->the_bfd, p));
+	  if (l) {
+	    /* Found a linenumber entry, output */
+	    struct internal_lineno  out;
+	    LINENO buff;
+	    bzero( (PTR)&out, sizeof(out));
+	    out.l_lnno = 0;
+	    out.l_addr.l_symndx = l->u.offset;
+	    bfd_coff_swap_lineno_out(abfd, &out, &buff);
+	    bfd_write((PTR) &buff, 1, LINESZ, abfd);
+	    l++;
+	    while (l->line_number) {
+	      out.l_lnno = l->line_number;
+	      out.l_addr.l_symndx = l->u.offset;
+	      bfd_coff_swap_lineno_out(abfd, &out, &buff);
+	      bfd_write((PTR) &buff, 1, LINESZ, abfd);
+	      l++;
 	    }
+	  }
+	  q++;
 	}
+      }
     }
-}
+  }
 
 
 static asymbol *
 coff_make_empty_symbol(abfd)
-    bfd            *abfd;
-{
+bfd            *abfd;
+  {
     coff_symbol_type *new = (coff_symbol_type *) bfd_alloc(abfd, sizeof(coff_symbol_type));
     if (new == NULL) {
-	bfd_error = no_memory;
-	return (NULL);
-    }				/* on error */
+      bfd_error = no_memory;
+      return (NULL);
+    }			/* on error */
     new->native = 0;
     new->lineno = (alent *) NULL;
     new->symbol.the_bfd = abfd;
     return &new->symbol;
-}
+  }
 
 static void 
 coff_print_symbol(ignore_abfd, file, symbol, how)
-    bfd            *ignore_abfd;
-    FILE           *file;
-    asymbol        *symbol;
-    bfd_print_symbol_enum_type how;
-{
+bfd            *ignore_abfd;
+FILE           *file;
+asymbol        *symbol;
+bfd_print_symbol_enum_type how;
+  {
     switch (how) {
     case bfd_print_symbol_name_enum:
-	fprintf(file, "%s", symbol->name);
-	break;
+      fprintf(file, "%s", symbol->name);
+      break;
     case bfd_print_symbol_type_enum:
-	fprintf(file, "coff %lx %lx", (unsigned long) coffsymbol(symbol)->native,
-		(unsigned long) coffsymbol(symbol)->lineno);
-	break;
+      fprintf(file, "coff %lx %lx", (unsigned long) coffsymbol(symbol)->native,
+	      (unsigned long) coffsymbol(symbol)->lineno);
+      break;
     case bfd_print_symbol_all_enum:
 	{
-	 CONST char           *section_name = symbol->section == (asection *) NULL ?
+	  CONST char           *section_name = symbol->section == (asection *) NULL ?
 	    "*abs" : symbol->section->name;
-	    bfd_print_symbol_vandf((PTR) file, symbol);
-
-	    fprintf(file, " %-5s %s %s %s",
-		    section_name,
-		    coffsymbol(symbol)->native ? "n" : "g",
-		    coffsymbol(symbol)->lineno ? "l" : " ",
-		    symbol->name);
+	  bfd_print_symbol_vandf((PTR) file, symbol);
+	  
+	  fprintf(file, " %-5s %s %s %s",
+		  section_name,
+		  coffsymbol(symbol)->native ? "n" : "g",
+		  coffsymbol(symbol)->lineno ? "l" : " ",
+		  symbol->name);
 	}
-
-
-	break;
+      
+      
+      break;
     }
-}
+  }
 
 static alent   *
 coff_get_lineno(ignore_abfd, symbol)
-    bfd            *ignore_abfd;
-    asymbol        *symbol;
-{
+bfd            *ignore_abfd;
+asymbol        *symbol;
+  {
     return coffsymbol(symbol)->lineno;
-}
+  }
 
 /*
-   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.
+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
 coff_set_flags(abfd, magicp, flagsp)
-    bfd            *abfd;
-    unsigned       *magicp,
-                   *flagsp;
-{
-
+bfd            *abfd;
+unsigned       *magicp,
+*flagsp;
+  {
+    
     switch (abfd->obj_arch) {
-
+      
 #ifdef I960ROMAGIC
-
+      
     case bfd_arch_i960:
-
+      
 	{
-	    unsigned        flags;
-	    *magicp = I960ROMAGIC;
-	    /*
-	       ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
-	       I960RWMAGIC);   FIXME???
-	    */
-	    switch (abfd->obj_machine) {
-	    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;
+	  unsigned        flags;
+	  *magicp = I960ROMAGIC;
+	  /*
+	    ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
+	     I960RWMAGIC);   FIXME???
+	       */
+	  switch (abfd->obj_machine) {
+	  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;
 #endif
-
+	
 #ifdef MC68MAGIC
-    case bfd_arch_m68k:
+      case bfd_arch_m68k:
 	*magicp = MC68MAGIC;
 	return true;
 #endif
-
+	
 #ifdef MC88MAGIC
-    case bfd_arch_m88k:
+      case bfd_arch_m88k:
 	*magicp = MC88OMAGIC;
 	return true;
 	break;
 #endif
-
-    default:			/* Unknown architecture */
+	
+      default:		/* Unknown architecture */
 	return false;
-    }
-
+      }
+    
     return false;
-}
+  }
 
 
 static          boolean
 coff_set_arch_mach(abfd, arch, machine)
-    bfd            *abfd;
-    enum bfd_architecture arch;
-    unsigned long   machine;
-{
+bfd            *abfd;
+enum bfd_architecture arch;
+unsigned long   machine;
+  {
     unsigned        dummy1,
-                    dummy2;
+    dummy2;
     abfd->obj_arch = arch;
     abfd->obj_machine = machine;
     if (arch != bfd_arch_unknown &&
 	coff_set_flags(abfd, &dummy1, &dummy2) != true)
-	return false;		/* We can't represent this type */
-    return true;		/* We're easy ... */
-}
+      return false;		/* We can't represent this type */
+    return true;	/* We're easy ... */
+  }
 
 
 /* Calculate the file position for each section. */
 
 static void 
 coff_compute_section_file_positions(abfd)
-    bfd            *abfd;
-{
+bfd            *abfd;
+  {
     asection       *current;
     file_ptr        sofar = FILHSZ;
     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;
+      /*
+	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;
     }
     if (abfd->flags & EXEC_P)
-	sofar += AOUTSZ;
-
-
+      sofar += AOUTSZ;
+    
+    
     sofar += abfd->section_count * SCNHSZ;
-
+    
     for (current = abfd->sections; current != NULL; current =
 	 current->next) {
       /* Only deal with sections which have contents */
       if (!(current->flags & SEC_HAS_CONTENTS))
 	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... */
+	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
       sofar = ALIGN(sofar, 1 << current->alignment_power);
 #endif
       /* FIXME, in demand paged files, the low order bits of the file
-	 offset must match the low order bits of the virtual address.
-	 "Low order" is apparently implementation defined.  Add code
-	 here to round sofar up to match the virtual address.  */
-
+	offset must match the low order bits of the virtual address.
+	  "Low order" is apparently implementation defined.  Add code
+	    here to round sofar up to match the virtual address.  */
+      
       current->filepos = sofar;
       sofar += current->size;
     }
     obj_relocbase(abfd) = sofar;
-}
+  }
 
 
 
@@ -1150,138 +1352,138 @@ coff_compute_section_file_positions(abfd)
 /* SUPPRESS 529 */
 static          boolean
 coff_write_object_contents(abfd)
-    bfd            *abfd;
-{
-  struct filehdr  file_header;
-  asection       *current;
-  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;
-  unsigned        magic,
-  
-  flags;
-
-  struct icofdata *coff = obj_icof(abfd);
-
-
-  bfd_error = system_call_error;
-
-
-  if(abfd->output_has_begun == false) {
-    coff_compute_section_file_positions(abfd);
-  }
-
-  if (abfd->sections != (asection *)NULL) {
-    scn_base = abfd->sections->filepos;
-  }
-  else {
-    scn_base = 0;
-  }
-  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 */
-
-  coff_count_linenumbers(abfd);
-  data_base = scn_base;
-
-  /* Work out the size of the reloc and linno areas */
-
-  for (current = abfd->sections; current != NULL; current = current->next) {
-    reloc_size += current->reloc_count * sizeof(struct reloc);
-    lnno_size += current->lineno_count * sizeof(struct lineno);
-    data_base += sizeof(struct scnhdr);
-  }
-
-  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->lineno_count) {
-      current->line_filepos = lineno_base;
-      current->moving_line_filepos = lineno_base;
-      lineno_base += current->lineno_count * sizeof(struct lineno);
-    }
-    else {
-      current->line_filepos = 0;
+bfd            *abfd;
+  {
+    struct filehdr  file_header;
+    asection       *current;
+    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;
+    unsigned        magic,
+    
+    flags;
+    
+    struct icofdata *coff = obj_icof(abfd);
+    
+    
+    bfd_error = system_call_error;
+    
+    
+    if(abfd->output_has_begun == false) {
+      coff_compute_section_file_positions(abfd);
     }
-    if (current->reloc_count) {
-      current->rel_filepos = reloc_base;
-      reloc_base += current->reloc_count * sizeof(struct reloc);
+    
+    if (abfd->sections != (asection *)NULL) {
+      scn_base = abfd->sections->filepos;
     }
     else {
-      current->rel_filepos = 0;
+      scn_base = 0;
     }
-  }
-
-  /* Write section headers to the file.  */
-
-  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;
-#endif
-    unsigned int    pad = 0;
-
+    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 */
+    
+    coff_count_linenumbers(abfd);
+    data_base = scn_base;
+    
+    /* Work out the size of the reloc and linno areas */
+    
     for (current = abfd->sections; current != NULL; current = current->next) {
-      SCNHDR          section;
-      strncpy(&(section.s_name[0]), current->name, 8);
-      section.s_vaddr = current->vma + pad;
-      section.s_paddr = current->vma + pad;
-      section.s_size = current->size - pad;
-      /*
-	If this section has no size or is unloadable then the scnptr
-	will be 0 too
-	*/
-      if (current->size - pad == 0 ||
-	  (current->flags & SEC_LOAD) == 0) {
-	section.s_scnptr = 0;
-
+      reloc_size += current->reloc_count * RELSZ;
+      lnno_size += current->lineno_count * LINESZ;
+      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->lineno_count) {
+	current->line_filepos = lineno_base;
+	current->moving_line_filepos = lineno_base;
+	lineno_base += current->lineno_count * LINESZ;
       }
       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;
-
-      if (!strcmp(current->name, _TEXT)) {
-	text_sec = current;
-	section.s_flags = STYP_TEXT; /* kinda stupid */
+	current->line_filepos = 0;
       }
-      else if (!strcmp(current->name, _DATA)) {
-	data_sec = current;
-	section.s_flags = STYP_DATA; /* kinda stupid */
+      if (current->reloc_count) {
+	current->rel_filepos = reloc_base;
+	reloc_base += current->reloc_count * sizeof(struct internal_reloc);
       }
-      else if (!strcmp(current->name, _BSS)) {
-	bss_sec = current;
-	section.s_flags = STYP_BSS; /* kinda stupid */
+      else {
+	current->rel_filepos = 0;
       }
-
-
+    }
+    
+    /* Write section headers to the file.  */
+    
+    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;
+#endif
+	unsigned int    pad = 0;
+	
+	for (current = abfd->sections; current != NULL; current = current->next) {
+	  SCNHDR          section;
+	  strncpy(&(section.s_name[0]), current->name, 8);
+	  section.s_vaddr = current->vma + pad;
+	  section.s_paddr = current->vma + pad;
+	  section.s_size = current->size - pad;
+	  /*
+	    If this section has no size or is unloadable then the scnptr
+	      will be 0 too
+		*/
+	  if (current->size - pad == 0 ||
+	      (current->flags & SEC_LOAD) == 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;
+	  
+	  if (!strcmp(current->name, _TEXT)) {
+	    text_sec = current;
+	    section.s_flags = STYP_TEXT; /* kinda stupid */
+	  }
+	  else if (!strcmp(current->name, _DATA)) {
+	    data_sec = current;
+	    section.s_flags = STYP_DATA; /* kinda stupid */
+	  }
+	  else if (!strcmp(current->name, _BSS)) {
+	    bss_sec = current;
+	    section.s_flags = STYP_BSS; /* kinda stupid */
+	  }
+	  
+	  
 #ifdef I960
-      section.s_align = (current->alignment_power
+	  section.s_align = (current->alignment_power
 			 ? 1 << current->alignment_power
 			 : 0);
 
@@ -1466,28 +1668,29 @@ buy_and_read(abfd, where, seek_direction, size)
 }				/* buy_and_read() */
 
 static void 
-offset_symbol_indices(symtab, count, offset)
-    SYMENT         *symtab;
-    unsigned long   count;
-    long            offset;
+DEFUN(offset_symbol_indices,(abfd, symtab, count, offset),
+      bfd *abfd AND
+      struct internal_syment         *symtab AND
+      unsigned long   count AND
+      long            offset)
 {
-  SYMENT         *end = symtab + count;
+  struct internal_syment         *end = symtab + count;
   for (; symtab < end; ++symtab) {
-    if (symtab->n_sclass == C_FILE) {
-      symtab->n_value = 0;
+    if (bfd_h_get_x(abfd, &symtab->n_sclass) == C_FILE) {
+      bfd_h_put_x(abfd, 0, & symtab->n_value);
     }
-    else if (symtab->n_sclass == C_ALIAS) {
+    else if (bfd_h_get_x(abfd, &symtab->n_sclass) == C_ALIAS) {
       /*
 	These guys have indices in their values.
 	*/
-      symtab->n_value += offset;
-
+      bfd_h_put_x(abfd, bfd_h_get_x(abfd, & symtab->n_value) + offset, & symtab->n_value);
+      
     }
     else if (symtab->n_numaux) {
       /*
 	anybody else without an aux, has no indices.
 	*/
-
+      
       if (symtab->n_sclass == C_EOS
 	  || (BTYPE(symtab->n_type) == T_STRUCT
 	      && symtab->n_sclass != C_STRTAG)
@@ -1495,281 +1698,224 @@ offset_symbol_indices(symtab, count, offset)
 	  || BTYPE(symtab->n_type) == T_ENUM) {
 	/* If the tagndx is 0 then the struct hasn't really been
 	   defined, so leave it alone */
-
-	if(((AUXENT *) (symtab + 1))->x_sym.x_tagndx != 0) {
-	  ((AUXENT *) (symtab + 1))->x_sym.x_tagndx += offset;
+	
+	if(((union internal_auxent *) (symtab + 1))->x_sym.x_tagndx != 0) {
+	  ((union internal_auxent *) (symtab + 1))->x_sym.x_tagndx += offset;
 	}
-
+	
       }				/* These guys have a tagndx */
       if (symtab->n_sclass == C_STRTAG
 	  || symtab->n_sclass == C_UNTAG
 	  || symtab->n_sclass == C_ENTAG
 	  || symtab->n_sclass == C_BLOCK
 	  || symtab->n_sclass == C_FCN
-	  || ISFCN(symtab->n_type)) {
-
-	((AUXENT *) (symtab + 1))->x_sym.x_fcnary.x_fcn.x_endndx += offset;
-
+	  || ISFCN(bfd_h_get_x(abfd, &symtab->n_type))) {
+	
+	((union internal_auxent *) (symtab +
+				    1))->x_sym.x_fcnary.x_fcn.x_endndx
+				      += offset;
+	
       }				/* These guys have an endndx */
 #ifndef I960
-      if (ISFCN(symtab->n_type)) {
-	((AUXENT *) (symtab + 1))->x_sym.x_tvndx += offset;
+      if (ISFCN(bfd_h_get_x(abfd,& symtab->n_type))) {
+	((union internal_auxent *) (symtab + 1))->x_sym.x_tvndx += offset;
       }				/* These guys have a tvndx.  I think...
 				   (FIXME) */
 #endif				/* Not I960 */
-
+      
     }				/* if value, else if aux */
-    symtab += symtab->n_numaux;
+    symtab += bfd_h_get_x(abfd, &symtab->n_numaux);
   }				/* walk the symtab */
-
+  
   return;
 }				/* offset_symbol_indices() */
 
-/* swap the entire symbol table */
+#if 0
+/* swap the entire symbol table - we c*/
 static void 
 swap_raw_symtab(abfd, raw_symtab)
-    bfd            *abfd;
-    SYMENT         *raw_symtab;
-{
+bfd            *abfd;
+SYMENT         *raw_symtab;
+  {
     long            i;
     SYMENT         *end = raw_symtab + bfd_get_symcount(abfd);
     for (; raw_symtab < end; ++raw_symtab) {
-	bfd_coff_swap_sym(abfd, raw_symtab);
-
-	for (i = raw_symtab->n_numaux; i; --i, ++raw_symtab) {
-	    bfd_coff_swap_aux(abfd,
-			      (AUXENT *)(raw_symtab + 1),
-			      raw_symtab->n_type,
-			      raw_symtab->n_sclass);
-	}			/* swap all the aux entries */
+      bfd_coff_swap_sym(abfd, raw_symtab);
+      
+      for (i = raw_symtab->n_numaux; i; --i, ++raw_symtab) {
+	bfd_coff_swap_aux(abfd,
+			  (AUXENT *)(raw_symtab + 1),
+			  raw_symtab->n_type,
+			  raw_symtab->n_sclass);
+      }				/* swap all the aux entries */
     }				/* walk the symbol table */
-
+    
     return;
-}				/* swap_raw_symtab() */
-
+  }				/* swap_raw_symtab() */
+#endif
 /*
-   read a symbol table into freshly mallocated memory, swap it, and knit the
-   symbol names into a normalized form. By normalized here I mean that all
-   symbols have an n_offset pointer that points to a NULL terminated string.
-   Oh, and the first symbol MUST be a C_FILE.  If there wasn't one there
-   before, put one there.
+read a symbol table into freshly mallocated memory, swap it, and knit the
+symbol names into a normalized form. By normalized here I mean that all
+symbols have an n_offset pointer that points to a NULL terminated string.
+Oh, and the first symbol MUST be a C_FILE.  If there wasn't one there
+before, put one there.
 */
 
-static SYMENT  *
-get_normalized_symtab(abfd)
-    bfd            *abfd;
+static struct internal_syment  *
+DEFUN(get_normalized_symtab,(abfd),
+bfd            *abfd)
 {
-    SYMENT         *end;
-    SYMENT         *retval;
-    SYMENT         *s;
-    char           *string_table = NULL;
-    unsigned long   size;
-    unsigned long   string_table_size = 0;
-
-    if ((size = bfd_get_symcount(abfd) * sizeof(SYMENT)) == 0) {
-	bfd_error = no_symbols;
-	return (NULL);
-    }				/* no symbols */
 
-    /* This is a hack.  Some tool chains fail to put a C_FILE symbol at the
-       beginning of the symbol table.  To make life simpler for our users, we
-       inject one if it wasn't there originally.
-    
-    We'd like to keep all of this bfd's native symbols in one block to keep
-       table traversals simple.  To do that, we need to know whether we will
-       be prepending the C_FILE symbol before we read the rest of the table.
-    */
-    if ((s = (SYMENT *) bfd_alloc(abfd, sizeof(SYMENT) * 2)) == NULL) {
-	bfd_error = no_memory;
-	return (NULL);
-    }				/* on error */
-    if (bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET) == -1
-	|| bfd_read((char *)s, sizeof(SYMENT), 1, abfd) != sizeof(SYMENT)) {
-	bfd_error = system_call_error;
-	return (NULL);
-    }				/* on error */
-    bfd_coff_swap_sym(abfd, s);
-
-    if (s->n_sclass == C_FILE) {
-	obj_symbol_slew(abfd) = 0;
-
-	if ((retval = (SYMENT *) bfd_alloc(abfd, size)) == NULL) {
-	    bfd_error = no_memory;
-	    return (NULL);
-	}			/* on malloc error */
-    }
-    else {
-	unsigned long   namelength = 0;
-	CONST char           *filename;
-	obj_symbol_slew(abfd) = 2;
-
-	if ((retval = (SYMENT *) bfd_alloc(abfd, size
-					+ (obj_symbol_slew(abfd)
-					   * sizeof(SYMENT)))) == NULL) {
-	    bfd_error = no_memory;
-	    return (NULL);
-	}			/* on malloc error */
-	bzero((char *) retval, size + (obj_symbol_slew(abfd) * sizeof(SYMENT)));
-
-#define FILE_ENTRY_NAME	".file"
-
-	if ((retval->n_offset = (int) bfd_alloc(abfd, strlen(FILE_ENTRY_NAME)
-					     + 1)) == NULL) {
-	    bfd_error = no_memory;
-	    return (NULL);
-	}			/* on malloc error */
-	strcpy((char *) retval->n_offset, FILE_ENTRY_NAME);
-	retval->n_sclass = C_FILE;
-	retval->n_scnum = N_DEBUG;
-	retval->n_numaux = 1;
-	retval->n_value = 2; /* Say that externals follow */
-
-#undef FILE_ENTRY_NAME
-
-	if ((filename = bfd_get_filename(abfd)) == NULL) {
-	    filename = "fake";
-	}			/* if we know it's name */
-	if ((namelength = strlen(filename)) <= FILNMLEN) {
-	    strncpy(((AUXENT *) (retval + 1))->x_file.x_fname, filename, FILNMLEN);
-	}
-	else {
-	    if ((((AUXENT *) (retval + 1))->x_file.x_n.x_offset
-		 = (int) bfd_alloc(abfd, namelength+1)) == NULL) {
-		bfd_error = no_memory;
-		return (NULL);
-	    }			/* on error */
-	    strcpy((char *) (((AUXENT *) (retval + 1))->x_file.x_n.x_offset),
-		   filename);
-
-	}			/* if "short" name */
-    }				/* missing file entry. */
-
-
-
-    if (bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET) == -1
-	|| bfd_read((char *)(retval + obj_symbol_slew(abfd)), size, 1, abfd)
-		 != size) {
-	bfd_error = system_call_error;
-	return (NULL);
-    }				/* on read error */
-    /* mark the end of the symbols */
-    end = retval + obj_symbol_slew(abfd) + bfd_get_symcount(abfd);
-    /*
-       FIXME SOMEDAY.  A string table size of zero is very weird, but
-       probably possible.  If one shows up, it will probably kill us.
-    */
-
-    swap_raw_symtab(abfd, retval + obj_symbol_slew(abfd));
-
-    /* ...and normalize symbol names. */
-
-    for (s = retval + obj_symbol_slew(abfd); s < end; ++s) {
-	if (s->n_zeroes != 0) {
-	    /*
-	       This is a "short" name.  Make it long.
-	    */
-	    unsigned long   i = 0;
-	    char           *newstring = NULL;
-	    /*
-	       find the length of this string without walking into memory
-	       that isn't ours.
-	    */
-
-	    for (i = 0; i < 8; ++i) {
-		if (s->n_name[i] == '\0') {
-		    break;
-		}		/* if end of string */
-	    }			/* possible lengths of this string. */
-
-	    if ((newstring = (PTR) bfd_alloc(abfd, ++i)) == NULL) {
-		bfd_error = no_memory;
-		return (NULL);
-	    }			/* on error */
-	    bzero(newstring, i);
-	    strncpy(newstring, s->n_name, i-1);
-	    s->n_offset = (int) newstring;
-	    s->n_zeroes = 0;
+  struct internal_syment         *internal;
+  struct internal_syment         *internal_ptr;
+  struct internal_syment         *internal_end;
+  SYMENT *raw;
+  SYMENT *raw_src;
+  SYMENT *raw_end;
+  char           *string_table = NULL;
+  unsigned long   size;
+  char string_table_size_buffer[4];
+  unsigned long   string_table_size = 0;
+  unsigned int raw_size;
+  if (obj_raw_syments(abfd) != (struct internal_syment *)NULL) {
+    return obj_raw_syments(abfd);
+  }
+  if ((size = bfd_get_symcount(abfd) * sizeof(struct internal_syment)) == 0) {
+    bfd_error = no_symbols;
+    return (NULL);
+  }
 
-	}
-	else {
-	    if (string_table == NULL) {
-		/*
-		   NOTE: we don't read the string table until now because we
-		   don't necessarily know that we have one until now.
-		*/
-		/*
-		   At this point we should be "seek"'d to the end of the
-		   symbols === the symbol table size.
-		*/
+  internal = (struct internal_syment *)bfd_alloc(abfd, size);
+  internal_end = internal + bfd_get_symcount(abfd);
 
-		if (bfd_read((char *) &string_table_size, sizeof(string_table_size), 1, abfd) != sizeof(string_table_size)) {
-		    bfd_error = system_call_error;
-		    return (NULL);
-		}		/* on error */
-		sp(string_table_size);
-
-		if ((string_table = (PTR) bfd_alloc(abfd, string_table_size -= 4)) == NULL) {
-		    bfd_error = no_memory;
-		    return (NULL);
-		}		/* on mallocation error */
-		if (bfd_read(string_table, string_table_size, 1, abfd) != string_table_size) {
-		    bfd_error = system_call_error;
-		    return (NULL);
-		}		/* on error */
-	    }			/* have not yet read the string table. */
-	    /*
-	       This is a long name already. Just point it at the string in
-	       memory.
-	    */
-	    s->n_offset = (int) (string_table - 4 + s->n_offset);
-	}			/* switch on type of symbol name */
+  raw_size =      bfd_get_symcount(abfd) * SYMESZ;
+  raw = (SYMENT *)bfd_alloc(abfd,raw_size);
 
-	s += s->n_numaux;
-    }				/* for each symbol */
-    /*
-       If we had to insert a C_FILE symbol, then everybody's indices are off
-       by 2, so correct them.
+  if (bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET) == -1
+      || bfd_read((PTR)raw, raw_size, 1, abfd) != raw_size) {
+    bfd_error = system_call_error;
+    return (NULL);
+  }
+  /* mark the end of the symbols */
+  raw_end = raw + bfd_get_symcount(abfd);
+  /*
+    FIXME SOMEDAY.  A string table size of zero is very weird, but
+    probably possible.  If one shows up, it will probably kill us.
     */
 
-    if (obj_symbol_slew(abfd) > 0) {
-	offset_symbol_indices(retval + 2, bfd_get_symcount(abfd), 2);
-
-	/* and let the world know there are two more of them. */
-	bfd_get_symcount(abfd) += 2;
+  /* Swap all the raw entries */
+  for (raw_src = raw, internal_ptr = internal; raw_src < raw_end; raw_src++, internal_ptr++) {
+    unsigned int i;
+    bfd_coff_swap_sym_in(abfd, raw_src,internal_ptr);    
+    for (i = internal_ptr->n_numaux; i; --i, raw_src++, internal_ptr++) {
+      bfd_coff_swap_aux_in(abfd, (AUXENT *)(raw_src +1), internal_ptr->n_type,
+			   internal_ptr->n_sclass, (union
+						    internal_auxent *)(internal_ptr +1));
+    }
+  }
+      
+  /* Free all the raw stuff */
+  bfd_release(abfd, raw_src);
 
+  for (internal_ptr = internal; internal_ptr < internal_end; internal_ptr ++) {
 
-    }				/* if we added a C_FILE */
+    if (internal_ptr->_n._n_n._n_zeroes != 0) {
+      /*
+	This is a "short" name.  Make it long.
+	*/
+      unsigned long   i = 0;
+      char           *newstring = NULL;
+      /*
+	find the length of this string without walking into memory
+	that isn't ours.
+	*/
+	
+      for (i = 0; i < 8; ++i) {
+	if (internal_ptr->_n._n_name[i] == '\0') {
+	  break;
+	}			/* if end of string */
+      }				/* possible lengths of this string. */
+	
+      if ((newstring = (PTR) bfd_alloc(abfd, ++i)) == NULL) {
+	bfd_error = no_memory;
+	return (NULL);
+      }				/* on error */
+      bzero(newstring, i);
+      strncpy(newstring, internal_ptr->_n._n_name, i-1);
+      internal_ptr->_n._n_n._n_offset =  (int) newstring;
+      internal_ptr->_n._n_n._n_zeroes = 0;
+	
+    }
+    else {
+      if (string_table == NULL) {
+	/*
+	  NOTE: we don't read the string table until now because we
+	  don't necessarily know that we have one until now.
+	  */
+	/*
+	  At this point we should be "seek"'d to the end of the
+	  symbols === the symbol table size.
+	  */
+	  
+	if (bfd_read((char *) &string_table_size_buffer,
+		     sizeof(string_table_size_buffer),
+		     1, abfd) != sizeof(string_table_size)) {
+	  bfd_error = system_call_error;
+	  return (NULL);
+	}			/* on error */
+	  
+	string_table_size = bfd_h_getlong(abfd, &string_table_size_buffer);
+	  
+	if ((string_table = (PTR) bfd_alloc(abfd, string_table_size -= 4)) == NULL) {
+	  bfd_error = no_memory;
+	  return (NULL);
+	}			/* on mallocation error */
+	if (bfd_read(string_table, string_table_size, 1, abfd) != string_table_size) {
+	  bfd_error = system_call_error;
+	  return (NULL);
+	}			/* on error */
+      }				/* have not yet read the string table. */
+      /*
+	This is a long name already. Just point it at the string in
+	memory.
+	*/
+      internal_ptr->_n._n_n._n_offset = (int) (string_table - 4 +  internal_ptr->_n._n_n._n_offset);
 
+    }				/* switch on type of symbol name */
+      
+    internal_ptr += internal_ptr->n_numaux;
+  }				/* for each symbol */
+#if 0
 #ifndef GNU960
-	/* I'm not sure of the repercussions of this, so the Intel
-	   folks will always do the force
-	   */
-    if (obj_symbol_slew(abfd) > 0) 
-      force_indices_file_symbol_relative(abfd, retval);
+  /* I'm not sure of the repercussions of this, so the Intel
+     folks will always do the force
+     */
+  if (obj_symbol_slew(abfd) > 0) 
+    force_indices_file_symbol_relative(abfd, internal);
 #else
-    force_indices_file_symbol_relative(abfd, retval);
+  force_indices_file_symbol_relative(abfd, internal);
 #endif
-
-    obj_raw_syments(abfd) = retval;
-    obj_string_table(abfd) = string_table;
-
-    return (retval);
+#endif
+  obj_raw_syments(abfd) = internal;
+  obj_string_table(abfd) = string_table;
+    
+  return (internal);
 }				/* get_normalized_symtab() */
 
 static
 struct sec *
-section_from_bfd_index(abfd, index)
-    bfd            *abfd;
-    int             index;
+DEFUN(section_from_bfd_index,(abfd, index),
+      bfd            *abfd AND
+      int             index)
 {
-    if (index > 0) {
-	struct sec *answer = abfd->sections;
-	while (--index) {
-	    answer = answer->next;
-	}
-	return answer;
+  if (index > 0) {
+    struct sec *answer = abfd->sections;
+    while (--index) {
+      answer = answer->next;
     }
-    return 0;
+    return answer;
+  }
+  return 0;
 }
 
 
@@ -1777,456 +1923,454 @@ section_from_bfd_index(abfd, index)
 
 static boolean
 coff_slurp_line_table(abfd, asect)
-    bfd            *abfd;
-    asection       *asect;
-{
-    struct lineno  *native_lineno;
+bfd            *abfd;
+asection       *asect;
+  {
+    LINENO  *native_lineno;
     alent          *lineno_cache;
-
+    
     BFD_ASSERT(asect->lineno == (alent *) NULL);
-
-    native_lineno = (struct lineno *) buy_and_read(abfd,
-						   asect->line_filepos,
-						   SEEK_SET,
-					   (size_t) (sizeof(struct lineno) *
-						     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;
-	return false;
+      bfd_error = no_memory;
+      return false;
     } else {	
-	unsigned int    counter = 0;
-	alent          *cache_ptr = lineno_cache;
-	struct lineno  *src = native_lineno;
-
-	while (counter < asect->lineno_count) {
-	    bfd_coff_swap_lineno(abfd, src);
-	    cache_ptr->line_number = src->l_lnno;
-
-	    if (cache_ptr->line_number == 0) {
-		coff_symbol_type *sym =
-		(coff_symbol_type *) (src->l_addr.l_symndx
-				      + obj_symbol_slew(abfd)
-				      + obj_raw_syments(abfd))->n_zeroes;
-		cache_ptr->u.sym = (asymbol *) sym;
-		sym->lineno = cache_ptr;
-	    }
-	    else {
-		cache_ptr->u.offset = src->l_addr.l_paddr
-		    - bfd_section_vma(abfd, asect);
-	    }			/* If no linenumber expect a symbol index */
-
-	    cache_ptr++;
-	    src++;
-	    counter++;
+      unsigned int    counter = 0;
+      alent          *cache_ptr = lineno_cache;
+      LINENO  *src = native_lineno;
+      
+      while (counter < asect->lineno_count) {
+	struct internal_lineno dst;
+	bfd_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_symbol_slew(abfd)
+				  + obj_raw_syments(abfd))->_n._n_n._n_zeroes;
+	  cache_ptr->u.sym = (asymbol *) sym;
+	  sym->lineno = cache_ptr;
 	}
-	cache_ptr->line_number = 0;
-
+	else {
+	  cache_ptr->u.offset = dst.l_addr.l_paddr
+	    - bfd_section_vma(abfd, asect);
+	}				/* If no linenumber expect a symbol index */
+	
+	cache_ptr++;
+	src++;
+	counter++;
+      }
+      cache_ptr->line_number = 0;
+      
     }
     asect->lineno = lineno_cache;
     /* FIXME, free native_lineno here, or use alloca or something. */
     return true;
-}				/* coff_slurp_line_table() */
+  }				/* coff_slurp_line_table() */
 
-static SYMENT  *
-find_next_file_symbol(current, end)
-    SYMENT         *current;
-    SYMENT         *end;
+static struct internal_syment  *
+DEFUN(find_next_file_symbol,(abfd, current, end),
+      bfd *abfd AND
+      struct internal_syment *current AND
+      struct internal_syment *end)
 {
   current += current->n_numaux + 1;
-
+    
   while (current < end) {
-    if (current->n_sclass == C_FILE) {
+    if (current->n_sclass== C_FILE) {
       return (current);
     }	
     current += current->n_numaux + 1;
   }
-
   return end;
 }
 
 
 /*
-   Note that C_FILE symbols can, and some do, have more than 1 aux entry.
+Note that C_FILE symbols can, and some do, have more than 1 aux entry.
 */
 
 static void
 DEFUN(force_indices_file_symbol_relative,(abfd, symtab),
       bfd            *abfd AND
-      SYMENT         *symtab)
+     struct internal_syment         *symtab)
 {
-    SYMENT         *end = symtab + bfd_get_symcount(abfd);
-    SYMENT         *current;
-    SYMENT         *next;
-    /* the first symbol had damn well better be a C_FILE. */
-    BFD_ASSERT(symtab->n_sclass == C_FILE);
-
-    for (current = find_next_file_symbol(symtab, end);
-	 current < end;
-	 current = next) {
-	offset_symbol_indices(current,
-			      ((next =
-				find_next_file_symbol(current,
-						      end)) - current),
-			      symtab - current);
-    }				/* walk the table */
-
-    return;
-}				/* force_indices_file_symbol_relative() */
+  struct internal_syment         *end = symtab + bfd_get_symcount(abfd);
+  struct internal_syment         *current;
+  struct internal_syment         *next;
+  /* the first symbol had damn well better be a C_FILE. */
+  BFD_ASSERT(symtab->n_sclass == C_FILE);
+    
+  for (current = find_next_file_symbol(abfd, symtab, end);
+       current < end;
+       current = next) {
+    offset_symbol_indices(abfd, current,
+			  ((next =
+			    find_next_file_symbol(abfd, current,
+						  end)) - current),
+			  symtab - current);
+  }
+  return;
+}	
 
 static          boolean
-coff_slurp_symbol_table(abfd)
-    bfd            *abfd;
-{
-    SYMENT         *native_symbols;
+DEFUN(coff_slurp_symbol_table,(abfd),
+      bfd            *abfd)
+  {
+    struct internal_syment         *native_symbols;
     coff_symbol_type *cached_area;
     unsigned int   *table_ptr;
-
+    
     unsigned int    number_of_symbols = 0;
     if (obj_symbols(abfd))
-	return true;
+      return true;
     bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET);
-
+    
     /* Read in the symbol table */
     if ((native_symbols = get_normalized_symtab(abfd)) == NULL) {
-	return (false);
+      return (false);
     }				/* on error */
-
-
+    
+    
     /* Allocate enough room for all the symbols in cached form */
     cached_area =
-	(coff_symbol_type *)
+      (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;
+      bfd_error = no_memory;
+      return false;
     }				/* on error */
     table_ptr =
-	(unsigned int *)
+      (unsigned int *)
 	bfd_alloc(abfd, (size_t) (bfd_get_symcount(abfd) * sizeof(unsigned int)));
-
+    
     if (table_ptr == NULL) {
-	bfd_error = no_memory;
-	return false;
+      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) {
-	    SYMENT         *src = native_symbols + this_index;
-	    table_ptr[this_index] = number_of_symbols;
-	    dst->symbol.the_bfd = abfd;
-
-	    dst->symbol.name = (char *) src->n_offset;	/* which was normalized
-							   to point to a null
-							   terminated string. */
-	    /*
-	       We use the native name field to point to the cached field
+      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) {
+	struct internal_syment         *src = native_symbols + this_index;
+	table_ptr[this_index] = number_of_symbols;
+	dst->symbol.the_bfd = abfd;
+	
+	dst->symbol.name = (char *)(src->_n._n_n._n_offset);
+	/*
+	  We use the native name field to point to the cached field
 	    */
-	    src->n_zeroes = (int) dst;
-	    dst->symbol.section = section_from_bfd_index(abfd, src->n_scnum);
-
-	    switch (src->n_sclass) {
+	src->_n._n_n._n_zeroes = (int) dst;
+	dst->symbol.section = section_from_bfd_index(abfd,
+						     src->n_scnum);
+	switch (src->n_sclass) {
 #ifdef I960
-	    case C_LEAFEXT:
+	case C_LEAFEXT:
 #if 0
-		dst->symbol.value = src->n_value - dst->symbol.section->vma;
-		dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
-		dst->symbol.flags |= BSF_NOT_AT_END;
+	  dst->symbol.value = src->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:
-		if (src->n_scnum == 0) {
-		    if (src->n_value == 0) {
-			dst->symbol.flags = BSF_UNDEFINED;
-		    }
-		    else {
-			dst->symbol.flags = BSF_FORT_COMM;
-			dst->symbol.value = src->n_value;
-		    }
-		}
-		else {
-		    /*
-		       Base the value as an index from the base of the
-		       section
-		    */
-		    if (dst->symbol.section == (asection *) NULL) {
-			dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL | BSF_ABSOLUTE;
-			dst->symbol.value = src->n_value;
-		    }
-		    else {
-			dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
-			dst->symbol.value = src->n_value - dst->symbol.section->vma;
-		    }
-		    if (ISFCN(src->n_type)) {
-			/*
-			   A function ext does not go at the end of a file
-			*/
-			dst->symbol.flags |= BSF_NOT_AT_END;
-		    }
-		}
-
-		break;
-	    case C_STAT:	/* static			 */
+	  
+	case C_EXT:
+	  if ((src->n_scnum) == 0) {
+	    if ((src->n_value) == 0) {
+	      dst->symbol.flags = BSF_UNDEFINED;
+	      dst->symbol.value= 0;
+	    }
+	    else {
+	      dst->symbol.flags = BSF_FORT_COMM;
+	      dst->symbol.value = (src->n_value);
+	    }
+	  }
+	  else {
+	    /*
+	      Base the value as an index from the base of the
+		section
+		  */
+	    if (dst->symbol.section == (asection *) NULL) {
+	      dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL | BSF_ABSOLUTE;
+	      dst->symbol.value = src->n_value;
+	    }
+	    else {
+	      dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
+	      dst->symbol.value = src->n_value - dst->symbol.section->vma;
+	    }
+	    if (ISFCN((src->n_type))) {
+	      /*
+		A function ext does not go at the end of a file
+		  */
+	      dst->symbol.flags |= BSF_NOT_AT_END;
+	    }
+	  }
+	  
+	  break;
+	case C_STAT:			/* static			 */
 #ifdef I960
-	    case C_LEAFSTAT:	/* static leaf procedure        */
+	case C_LEAFSTAT:		/* static leaf procedure        */
 #endif
-	    case C_LABEL:	/* label			 */
-		dst->symbol.flags = BSF_LOCAL;
-		/*
-		   Base the value as an index from the base of the section
-		*/
-		dst->symbol.value = src->n_value - dst->symbol.section->vma;
-		break;
-
-	    case C_MOS:	/* member of structure	 */
-	    case C_EOS:	/* end of structure		 */
-	    case C_REGPARM:	/* register parameter		 */
-	    case C_REG:	/* register variable		 */
+	case C_LABEL:			/* label			 */
+	  dst->symbol.flags = BSF_LOCAL;
+	  /*
+	    Base the value as an index from the base of the section
+	      */
+	  dst->symbol.value = (src->n_value) - dst->symbol.section->vma;
+	  break;
+	  
+	case C_MOS:			/* member of structure	 */
+	case C_EOS:			/* end of structure		 */
+	case C_REGPARM:			/* register parameter		 */
+	case C_REG:			/* register variable		 */
 #ifdef C_AUTOARG
-	    case C_AUTOARG:	/* 960-specific storage class */
+	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->n_value;
-		break;
-
-	    case C_FILE:	/* file name			 */
-	    case C_STRTAG:	/* structure tag		 */
-		dst->symbol.flags = BSF_DEBUGGING;
-		dst->symbol.value = src->n_value;
-
-		break;
-	    case C_BLOCK:	/* ".bb" or ".eb"		 */
-	    case C_FCN:	/* ".bf" or ".ef"		 */
-		dst->symbol.flags = BSF_LOCAL;
-		/*
-		   Base the value as an index from the base of the section
-		*/
-		dst->symbol.value = src->n_value - dst->symbol.section->vma;
-
-		break;
-	    case C_EFCN:	/* physical end of function	 */
-	    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:
-
-		printf("SICK%d\n", src->n_sclass);
-		abort();
-		dst->symbol.flags = BSF_DEBUGGING;
-		dst->symbol.value = src->n_value;
-
-		break;
-	    }
-
-	    BFD_ASSERT(dst->symbol.flags != 0);
-
-	    dst->native = src;
-
-	    dst->symbol.udata = 0;
-	    dst->lineno = (alent *) NULL;
-	    this_index += src->n_numaux + 1;
-	    dst++;
-	    number_of_symbols++;
-	}			/* walk the native symtab */
+	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->n_value);
+	  break;
+	  
+	case C_FILE:			/* file name			 */
+	case C_STRTAG:			/* structure tag		 */
+	  dst->symbol.flags = BSF_DEBUGGING;
+	  dst->symbol.value = (src->n_value);
+	  
+	  break;
+	case C_BLOCK:			/* ".bb" or ".eb"		 */
+	case C_FCN:			/* ".bf" or ".ef"		 */
+	  dst->symbol.flags = BSF_LOCAL;
+	  /*
+	    Base the value as an index from the base of the section
+	      */
+	  dst->symbol.value = (src->n_value) - dst->symbol.section->vma;
+	  
+	  break;
+	case C_EFCN:			/* physical end of function	 */
+	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:
+	  
+	  abort();
+	  dst->symbol.flags = BSF_DEBUGGING;
+	  dst->symbol.value = (src->n_value);
+	  
+	  break;
+	}
+	
+	BFD_ASSERT(dst->symbol.flags != 0);
+	
+	dst->native = src;
+	
+	dst->symbol.udata = 0;
+	dst->lineno = (alent *) NULL;
+	this_index += (src->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;
-
+    
     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);
-	    p = p->next;
+	  coff_slurp_line_table(abfd, p);
+	  p = p->next;
 	}
-    }
+      }
     return true;
-}				/* coff_slurp_symbol_table() */
+  }				/* coff_slurp_symbol_table() */
 
 static unsigned int
 coff_get_symtab_upper_bound(abfd)
-    bfd            *abfd;
-{
+bfd            *abfd;
+  {
     if (!coff_slurp_symbol_table(abfd))
-	return 0;
-
+      return 0;
+    
     return (bfd_get_symcount(abfd) + 1) * (sizeof(coff_symbol_type *));
-}
+  }
 
 
 static unsigned int
 coff_get_symtab(abfd, alocation)
-    bfd            *abfd;
-    asymbol       **alocation;
-{
+bfd            *abfd;
+asymbol       **alocation;
+  {
     unsigned int    counter = 0;
     coff_symbol_type *symbase;
     coff_symbol_type **location = (coff_symbol_type **) (alocation);
     if (!coff_slurp_symbol_table(abfd))
-	return 0;
-
+      return 0;
+    
     for (symbase = obj_symbols(abfd); counter++ < bfd_get_symcount(abfd);)
-	*(location++) = symbase++;
+      *(location++) = symbase++;
     *location++ = 0;
     return bfd_get_symcount(abfd);
-}
+  }
 
 static unsigned int
 coff_get_reloc_upper_bound(abfd, asect)
-    bfd            *abfd;
-    sec_ptr         asect;
-{
-  if (bfd_get_format(abfd) != bfd_object) {
-    bfd_error = invalid_operation;
-    return 0;
+bfd            *abfd;
+sec_ptr         asect;
+  {
+    if (bfd_get_format(abfd) != bfd_object) {
+      bfd_error = invalid_operation;
+      return 0;
+    }
+    return (asect->reloc_count + 1) * sizeof(arelent *);
   }
-  return (asect->reloc_count + 1) * sizeof(arelent *);
-}
-
 
 static          boolean
-coff_slurp_reloc_table(abfd, asect, symbols)
-    bfd            *abfd;
-    sec_ptr         asect;
-    asymbol       **symbols;
-{
-  struct reloc   *native_relocs;
-  arelent        *reloc_cache;
-  if (asect->relocation)
-    return true;
-  if (asect->reloc_count == 0)
-    return true;
-  if (!coff_slurp_symbol_table(abfd))
-    return false;
-  native_relocs =
-    (struct reloc *) buy_and_read(abfd,
-				  asect->rel_filepos,
-				  SEEK_SET,
-				  (size_t) (sizeof(struct reloc) *
-					    asect->reloc_count));
-  reloc_cache = (arelent *)
-    bfd_alloc(abfd, (size_t) (asect->reloc_count * sizeof(arelent)));
-
-  if (reloc_cache == NULL) {
-    bfd_error = no_memory;
-    return false;
-  } {				/* on error */
-    arelent        *cache_ptr;
-    struct reloc   *src;
-    for (cache_ptr = reloc_cache,
-	 src = native_relocs;
-	 cache_ptr < reloc_cache + asect->reloc_count;
-	 cache_ptr++,
-	 src++) {
-      asymbol        *ptr;
-      swap_reloc(abfd, src);
-      src->r_symndx += obj_symbol_slew(abfd);
-      cache_ptr->sym_ptr_ptr = symbols + obj_convert(abfd)[src->r_symndx];
-
-      ptr = *(cache_ptr->sym_ptr_ptr);
-      cache_ptr->address = src->r_vaddr;
-      /*
-	The symbols definitions that we have read in have been
-	relocated as if their sections started at 0. But the offsets
-	refering to the symbols in the raw data have not been
-	modified, so we have to have a negative addend to compensate.
+DEFUN(coff_slurp_reloc_table,(abfd, asect, symbols),
+      bfd            *abfd AND
+      sec_ptr         asect AND
+      asymbol       **symbols)
+  {
+    RELOC   *native_relocs;
+    arelent        *reloc_cache;
+    if (asect->relocation)
+      return true;
+    if (asect->reloc_count == 0)
+      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_cache = (arelent *)
+      bfd_alloc(abfd, (size_t) (asect->reloc_count * sizeof(arelent)));
+    
+    if (reloc_cache == NULL) {
+      bfd_error = no_memory;
+      return false;
+    } {				/* on error */
+      arelent        *cache_ptr;
+      RELOC   *src;
+      for (cache_ptr = reloc_cache,
+	   src = native_relocs;
+	   cache_ptr < reloc_cache + asect->reloc_count;
+	   cache_ptr++,
+	   src++) {
+	struct internal_reloc dst;
+	asymbol        *ptr;
+	swap_reloc_in(abfd, src, &dst);
+	dst.r_symndx += obj_symbol_slew(abfd);
+	cache_ptr->sym_ptr_ptr = symbols + obj_convert(abfd)[dst.r_symndx];
+	
+	ptr = *(cache_ptr->sym_ptr_ptr);
+	cache_ptr->address = dst.r_vaddr;
+	/*
+	  The symbols definitions that we have read in have been
+	  relocated as if their sections started at 0. But the offsets
+	  refering to the symbols in the raw data have not been
+	  modified, so we have to have a negative addend to compensate.
+	  
+	  Note that symbols which used to be common must be left alone
+	  */
+	
+	if (ptr->the_bfd == abfd 
+	    && ptr->section != (asection *) NULL 
+	    && ((ptr->flags & BSF_OLD_COMMON)== 0)) 
+	    {
+	      cache_ptr->addend = -(ptr->section->vma + ptr->value);
+	    }
+	else {
+	  cache_ptr->addend = 0;
+	}
+	
+	cache_ptr->address -= asect->vma;
+	
+	cache_ptr->section = (asection *) NULL;
 	
-	Note that symbols which used to be common must be left alone
-	*/
-
-      if (ptr->the_bfd == abfd 
-	  && ptr->section != (asection *) NULL 
-	  && ((ptr->flags & BSF_OLD_COMMON)== 0)) 
-	  {
-	    cache_ptr->addend = -(ptr->section->vma + ptr->value);
-	  }
-      else {
-	cache_ptr->addend = 0;
-      }
-
-      cache_ptr->address -= asect->vma;
-
-      cache_ptr->section = (asection *) NULL;
-
 #if I960
-      cache_ptr->howto = howto_table + src->r_type;
-#endif
-#if M88
-      if (src->r_type >= R_PCR16L && src->r_type <= R_VRT32) {
-	cache_ptr->howto = howto_table + src->r_type - R_PCR16L;
-	cache_ptr->addend += src->r_offset << 16;
-      }
-      else {
-	BFD_ASSERT(0);
-      }
+	cache_ptr->howto = howto_table + dst.r_type;
 #endif
 #if M68
-      cache_ptr->howto = howto_table + src->r_type;
+	cache_ptr->howto = howto_table + dst.r_type - R_RELBYTE;
 #endif
-
+#if M88
+	if (dst.r_type >= R_PCR16L && dst.r_type <= R_VRT32) {
+	  cache_ptr->howto = howto_table + dst.r_type - R_PCR16L;
+	  cache_ptr->addend += dst.r_offset << 16;
+	}
+	else {
+	  BFD_ASSERT(0);
+	}
+#endif
+	
+      }
+      
     }
-
+    
+    asect->relocation = reloc_cache;
+    return true;
   }
 
-  asect->relocation = reloc_cache;
-  return true;
-}
-
 
 /* This is stupid.  This function should be a boolean predicate */
 static unsigned int
 coff_canonicalize_reloc(abfd, section, relptr, symbols)
-    bfd            *abfd;
-    sec_ptr         section;
-    arelent       **relptr;
-    asymbol       **symbols;
-{
+bfd            *abfd;
+sec_ptr         section;
+arelent       **relptr;
+asymbol       **symbols;
+  {
     arelent        *tblptr = section->relocation;
     unsigned int    count = 0;
     if (!(tblptr || coff_slurp_reloc_table(abfd, section, symbols)))
-	return 0;
+      return 0;
     tblptr = section->relocation;
     if (!tblptr)
-	return 0;
-
+      return 0;
+    
     for (; count++ < section->reloc_count;)
-	*relptr++ = tblptr++;
-
+      *relptr++ = tblptr++;
+    
     *relptr = 0;
-
+    
     return section->reloc_count;
-}
+  }
 
 
 /*
-   provided a bfd, a section and an offset into the section, calculate and
-   return the name of the source file and the line nearest to the wanted
-   location.
+provided a bfd, a section and an offset into the section, calculate and
+return the name of the source file and the line nearest to the wanted
+location.
 */
 
 static          boolean
@@ -2250,65 +2394,65 @@ DEFUN(coff_find_nearest_line,(abfd,
   static bfd_vma  cache_offset;
   static unsigned int cache_i;
   static alent   *cache_l;
-
+    
   unsigned int    i = 0;
   struct icofdata *cof = obj_icof(abfd);
   /* Run through the raw syments if available */
-  SYMENT         *p;
+  struct internal_syment         *p;
   alent          *l;
   unsigned int    line_base = 0;
-
-
+    
+    
   *filename_ptr = 0;
   *functionname_ptr = 0;
   *line_ptr = 0;
-
+    
   /* Don't try and find line numbers in a non coff file */
   if (abfd->xvec->flavour != bfd_target_coff_flavour_enum)
     return false;
-
+    
   if (cof == (struct icofdata *)NULL)
     return false;
-
+    
   p = cof->raw_syments;
   /*
-     I don't know for sure what's right, but this isn't it. First off, an
-     object file may not have any C_FILE's in it.  After
-     get_normalized_symtab(), it should have at least 1, the one I put
-     there, but otherwise, all bets are off.  Point #2, the first C_FILE
-     isn't necessarily the right C_FILE because any given object may have
-     many.  I think you'll have to track sections as they coelesce in order
-     to find the C_STAT symbol for this section. Then you'll have to work
-     backwards to find the previous C_FILE, or choke if you get to a C_STAT
-     for the same kind of section.  That will mean that the original object
-     file didn't have a C_FILE. xoxorich.
-     */
-
+    I don't know for sure what's right, but this isn't it. First off, an
+    object file may not have any C_FILE's in it.  After
+    get_normalized_symtab(), it should have at least 1, the one I put
+    there, but otherwise, all bets are off.  Point #2, the first C_FILE
+    isn't necessarily the right C_FILE because any given object may have
+    many.  I think you'll have to track sections as they coelesce in order
+    to find the C_STAT symbol for this section. Then you'll have to work
+    backwards to find the previous C_FILE, or choke if you get to a C_STAT
+    for the same kind of section.  That will mean that the original object
+    file didn't have a C_FILE. xoxorich.
+    */
+    
 #ifdef WEREBEINGPEDANTIC
   return false;
 #endif
-
+    
   for (i = 0; i < cof->raw_syment_count; i++) {
-    if (p->n_sclass == C_FILE) {
+    if (bfd_h_get_x(abfd, &p->n_sclass) == C_FILE) {
       /* File name is embeded in auxent */
       /*
-	 This isn't right.  The fname should probably be normalized
-	 during get_normalized_symtab().  In any case, what was here
-	 wasn't right because a SYMENT.n_name isn't an
-	 AUXENT.x_file.x_fname. xoxorich.
-	 */
-
+	This isn't right.  The fname should probably be normalized
+	during get_normalized_symtab().  In any case, what was here
+	wasn't right because a SYMENT.n_name isn't an
+	AUXENT.x_file.x_fname. xoxorich.
+	*/
+	
       *filename_ptr = ((AUXENT *) (p + 1))->x_file.x_fname;
       break;
     }
-    p += 1 + p->n_numaux;
+    p += 1 + bfd_h_get_x(abfd, & p->n_numaux);
   }
   /* Now wander though the raw linenumbers of the section */
   /*
-     If this is the same bfd as we were previously called with and this is
-     the same section, and the offset we want is further down then we can
-     prime the lookup loop
-     */
+    If this is the same bfd as we were previously called with and this is
+    the same section, and the offset we want is further down then we can
+    prime the lookup loop
+    */
   if (abfd == cache_abfd &&
       section == cache_section &&
       offset >= cache_offset) {
@@ -2319,24 +2463,24 @@ DEFUN(coff_find_nearest_line,(abfd,
     i = 0;
     l = section->lineno;
   }
-
+    
   for (; i < section->lineno_count; i++) {
     if (l->line_number == 0) {
       /* Get the symbol this line number points at */
       coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
       *functionname_ptr = coff->symbol.name;
       if (coff->native) {
-	struct syment  *s = coff->native;
+	struct internal_syment  *s = coff->native;
 	s = s + 1 + s->n_numaux;
 	/*
-	   S should now point to the .bf of the function
-	   */
+	  S should now point to the .bf of the function
+	  */
 	if (s->n_numaux) {
 	  /*
-	     The linenumber is stored in the auxent
-	     */
-	  union auxent   *a = (union auxent *) (s + 1);
-	  line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
+	    The linenumber is stored in the auxent
+	    */
+	  union internal_auxent   *a = (union internal_auxent *) (s + 1);
+	  line_base = bfd_h_get_x(abfd, &a->x_sym.x_misc.x_lnsz.x_lnno);
 	}
       }
     }
@@ -2347,7 +2491,7 @@ DEFUN(coff_find_nearest_line,(abfd,
     }
     l++;
   }
-
+    
   cache_abfd = abfd;
   cache_section = section;
   cache_offset = offset;
@@ -2360,9 +2504,9 @@ DEFUN(coff_find_nearest_line,(abfd,
 file_ptr
 coff_sym_filepos(abfd)
 bfd *abfd;
-{
-return obj_sym_filepos(abfd);
-}
+  {
+    return obj_sym_filepos(abfd);
+  }
 #endif
 
 
@@ -2370,20 +2514,20 @@ static int
 DEFUN(coff_sizeof_headers,(abfd, reloc),
       bfd *abfd AND
       boolean reloc)
-{
-  size_t size;
-
-  if (reloc == false) {
-    size = sizeof(struct filehdr) + sizeof(AOUTHDR);
-  }
-  else {
-    size = sizeof(struct filehdr);
+  {
+    size_t size;
+    
+    if (reloc == false) {
+      size = sizeof(struct filehdr) + sizeof(AOUTHDR);
+    }
+    else {
+      size = sizeof(struct filehdr);
+    }
+    
+    size +=  abfd->section_count * SCNHSZ;
+    return size;
   }
 
-  size +=  abfd->section_count * SCNHSZ;
-  return size;
-}
-
 
 #define coff_core_file_failing_command	_bfd_dummy_core_file_failing_command
 #define coff_core_file_failing_signal	_bfd_dummy_core_file_failing_signal
diff --git a/bfd/coff-i960.c b/bfd/coff-i960.c
index 4768104..b80c80d 100644
--- a/bfd/coff-i960.c
+++ b/bfd/coff-i960.c
@@ -53,7 +53,7 @@ asection *ignore_input_section;
   /* So the target symbol has to be of coff type, and the symbol 
      has to have the correct native information within it */
   if ((cs->symbol.the_bfd->xvec->flavour != bfd_target_coff_flavour_enum)
-      || (cs->native == (struct syment *)NULL)) {
+      || (cs->native == (struct internal_syment *)NULL)) {
      /* This is interesting, consider the case where we're outputting */
      /* coff from a mix n match input, linking from coff to a symbol */
      /* defined in a bout file will cause this match to be true. Should */
@@ -62,22 +62,23 @@ asection *ignore_input_section;
      result = bfd_reloc_dangerous;
   }
   else  {
-    switch (cs->native->n_sclass) 
+    switch (bfd_h_get_x(abfd, & cs->native->n_sclass)) 
       {
       case C_LEAFSTAT:
       case C_LEAFEXT:
   	/* This is a call to a leaf procedure, replace instruction with a bal
 	 to the correct location */
 	{
- 	 union auxent *aux = (union auxent *)(cs->native+2);
+	 AUXENT *aux = (AUXENT *)(cs->native+2);
 	  int word = bfd_getlong(abfd, data + reloc_entry->address);
-	  BFD_ASSERT(cs->native->n_numaux==2);
+	  BFD_ASSERT(bfd_h_get_x(abfd, &cs->native->n_numaux)==2);
 	  /* We replace the original call instruction with a bal to */
 	  /* the bal entry point - the offset of which is described in the */
 	  /* 2nd auxent of the original symbol. We keep the native sym and */
 	  /* auxents untouched, so the delta between the two is the */
 	  /* offset of the bal entry point */
-	  word = ((word + (aux->x_bal.x_balntry - cs->native->n_value))
+	  word = ((word + (bfd_h_get_x(abfd, &aux->x_bal.x_balntry) -
+			   bfd_h_get_x(abfd, &cs->native->n_value)))
 		  & BAL_MASK) | BAL;
   	  bfd_putlong(abfd, word,  data+reloc_entry->address);
   	}
diff --git a/bfd/coffswap.c b/bfd/coffswap.c
index eef2c96..78aea53 100755
--- a/bfd/coffswap.c
+++ b/bfd/coffswap.c
@@ -26,15 +26,15 @@ You should have received a copy of the GNU General Public License along with
 #include "libcoff.h"		/* to allow easier abstraction-breaking */
 
 #define sp(x) bfd_h_put_x(abfd, x, &x)
+#if 0
+/* All the generic swapping routines:
 
-/* All the swapping routines:
-
-   FIXME, these routines assume that the sizes, alignments, and offsets of
-   these fields are the same in the host and target.  This is an invalid
-   assumption, which in particular breaks on the 386 and SPARC.  Fix this
-   the same way that a.out.h and sunos.c were fixed:  define char arrays
-   that represent the headers in the target systems' file, and have these
-   functions translate in from that format, and out to that format.  */
+FIXME
+   These routines cater for the sizes and alignments and offsets of
+   all the contained fields. Because of this, the fields can change
+   size, so these should be phased out to use the ones specific to the
+   file format.
+ */
 
 void 
 DEFUN(bfd_coff_swap_name,(abfd, ptr),
@@ -53,7 +53,7 @@ DEFUN(bfd_coff_swap_name,(abfd, ptr),
 void 
 DEFUN(bfd_coff_swap_sym,(abfd, se),
       bfd            *abfd AND
-      SYMENT         *se)
+      struct internal_syment      *se)
 {
     bfd_coff_swap_name(abfd, (long*)(se->n_name));
     bfd_h_put_x(abfd, se->n_value, &se->n_value);
@@ -66,7 +66,7 @@ DEFUN(bfd_coff_swap_sym,(abfd, se),
 void
 DEFUN(bfd_coff_swap_aux,(abfd, au, type, class),
       bfd            *abfd AND
-      AUXENT         *au AND
+      struct internal_auxent    *au AND
       int             type AND
       int             class)
 {
@@ -112,10 +112,12 @@ DEFUN(bfd_coff_swap_aux,(abfd, au, type, class),
 void
 DEFUN(bfd_coff_swap_lineno,(abfd, lineno),
       bfd            *abfd AND
-      LINENO         *lineno)
+      struct internal_lineno      *lineno)
 {
     sp(lineno->l_addr.l_symndx);
     sp(lineno->l_lnno);
 }
 
 
+
+#endif
diff --git a/bfd/libcoff.h b/bfd/libcoff.h
index 67b9c98..f439272 100644
--- a/bfd/libcoff.h
+++ b/bfd/libcoff.h
@@ -31,12 +31,16 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #define obj_relocbase(bfd)	(obj_icof(bfd)->relocbase)
 #define obj_raw_syments(bfd)	(obj_icof(bfd)->raw_syments)
 #define obj_convert(bfd)	(obj_icof(bfd)->conversion_table)
+#if CFILE_STUFF
 #define obj_symbol_slew(bfd)	(obj_icof(bfd)->symbol_index_slew)
+#else
+#define obj_symbol_slew(bfd) 0
+#endif
 #define obj_string_table(bfd)	(obj_icof(bfd)->string_table)
 
 typedef struct {
   asymbol symbol;
-  struct syment *native;
+  struct internal_syment *native;
   struct lineno_cache_entry *lineno;
 } coff_symbol_type;
 
@@ -50,7 +54,7 @@ typedef struct icofdata
   long symbol_index_slew;	/* used during read to mark whether a
 				   C_FILE symbol as been added. */
 
-  struct syment *raw_syments;
+  struct internal_syment *raw_syments;
   struct lineno *raw_linenos;
   unsigned int raw_syment_count;
   char *string_table;