gcc -Wall lint:

	* coff-h8300.c (h8300_reloc16_estimate): Declare return type.
	Remove useless statement probably left by code copy.
	* cpu-i960.c (compatible): Fully bracket matrix initializer.
	* elf32-hppa.c (hppa_elf_build_arg_reloc_stub): Use bfd_xmalloc
	rather than xmalloc.  Use realloc and check the return value
	rather than xrealloc.
	(hppa_elf_get_section_contents): Add some casts.
	* elf32-i386.c (elf_i386_reloc_type_lookup): Remove unused
	variable.  Add default case to switch.
	* hp300hpux.c: Declare aout_32_write_syms.
	* i386bsd.c, i386linux.c, netbsd386.c (N_SHARED_LIB): Define as 0
	(definition from aout/aout64.h is always 0 anyhow).
	* i386lynx.c (swap_std_reloc_in): Remove unused variable.
	* ieee.c (ieee_write_id): length can never be negative.
	(read_id): Likewise.
	(ieee_archive_p): Remove unused variable.
	* libcoff-in.h (bfd_perform_slip): Declare.
	* libcoff.h: Rebuilt.
	* oasys.c (oasys_write_sections): Remove zero initialization of
	static structure.
	* reloc16.c: Indentation change.

5 files changed, 569 insertions, 173 deletions

diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index cc9a7ea..78c1b02 100644
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,3 +1,28 @@
+Thu Oct 28 16:23:40 1993  Ian Lance Taylor  (ian@tweedledumb.cygnus.com)
+
+	gcc -Wall lint:
+	* coff-h8300.c (h8300_reloc16_estimate): Declare return type.
+	Remove useless statement probably left by code copy.
+	* cpu-i960.c (compatible): Fully bracket matrix initializer.
+	* elf32-hppa.c (hppa_elf_build_arg_reloc_stub): Use bfd_xmalloc
+	rather than xmalloc.  Use realloc and check the return value
+	rather than xrealloc.
+	(hppa_elf_get_section_contents): Add some casts.
+	* elf32-i386.c (elf_i386_reloc_type_lookup): Remove unused
+	variable.  Add default case to switch.
+	* hp300hpux.c: Declare aout_32_write_syms.
+	* i386bsd.c, i386linux.c, netbsd386.c (N_SHARED_LIB): Define as 0
+	(definition from aout/aout64.h is always 0 anyhow).
+	* i386lynx.c (swap_std_reloc_in): Remove unused variable.
+	* ieee.c (ieee_write_id): length can never be negative.
+	(read_id): Likewise.
+	(ieee_archive_p): Remove unused variable.
+	* libcoff-in.h (bfd_perform_slip): Declare.
+	* libcoff.h: Rebuilt.
+	* oasys.c (oasys_write_sections): Remove zero initialization of
+	static structure.
+	* reloc16.c: Indentation change.
+
 Wed Oct 27 16:51:29 1993  Jim Kingdon  (kingdon@lioth.cygnus.com)
 
 	* configure.in, config/i386-mach3.mt: Update for new configuration
diff --git a/bfd/coff-h8300.c b/bfd/coff-h8300.c
index d368f78..5ae8833 100644
--- a/bfd/coff-h8300.c
+++ b/bfd/coff-h8300.c
@@ -1,7 +1,6 @@
-/* Hitachi H8/300 COFF back-end for BFD.
-   Copyright (C) 1990-1991 Free Software Foundation, Inc.
-   Written by Steve Chamberlain
-   sac@cygnus.com
+/* BFD back-end for Hitachi H8/300 COFF binaries.
+   Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
+   Written by Steve Chamberlain, <sac@cygnus.com>.
 
 This file is part of BFD, the Binary File Descriptor library.
 
@@ -19,29 +18,35 @@ You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
-
 #include "bfd.h"
 #include "sysdep.h"
 #include "libbfd.h"
 #include "obstack.h"
 #include "coff/h8300.h"
 #include "coff/internal.h"
+#include "seclet.h"
 #include "libcoff.h"
+extern bfd_error_vector_type bfd_error_vector;
 
-static reloc_howto_type howto_table[] = 
+static reloc_howto_type howto_table[] =
 {
-  HOWTO(R_RELBYTE,	       0,  0,  	8,  false, 0, true,  true,0,"8",	true, 0x000000ff,0x000000ff, false),
-  HOWTO(R_RELWORD,	       0,  1, 	16, false, 0, true,  true,0,"16",	true, 0x0000ffff,0x0000ffff, false),
-  HOWTO(R_RELLONG,	       0,  2, 	32, false, 0, true,  true,0,"32",	true, 0xffffffff,0xffffffff, false),
-  HOWTO(R_PCRBYTE,	       0,  0, 	8,  true,  0, false, true,0,"DISP8",    true, 0x000000ff,0x000000ff, true),
-  HOWTO(R_PCRWORD,	       0,  1, 	16, true,  0, false, true,0,"DISP16",   true, 0x0000ffff,0x0000ffff, true),
-  HOWTO(R_PCRLONG,	       0,  2, 	32, true,  0, false, true,0,"DISP32",   true, 0xffffffff,0xffffffff, true),
-  HOWTO(R_MOVB1,	       0,  1, 	16, false, 0, true,
-	true,0,"16/8",	true, 0x0000ffff,0x0000ffff, false),
-  HOWTO(R_MOVB2,	       0,  1, 	16, false, 0, true,
-	true,0,"8/16",	true, 0x0000ffff,0x0000ffff, false),
-  HOWTO(R_JMP1,	       0,  1, 	16, false, 0, true,  true,0,"16/pcrel",	true, 0x0000ffff,0x0000ffff, false),
-  HOWTO(R_JMP2,	       0,  0,  	8,  false, 0, true,  true,0,"pcrecl/16",	true, 0x000000ff,0x000000ff, false),
+  HOWTO (R_RELBYTE, 0, 0, 8, false, 0, complain_overflow_bitfield, 0, "8", true, 0x000000ff, 0x000000ff, false),
+  HOWTO (R_RELWORD, 0, 1, 16, false, 0, complain_overflow_bitfield, 0, "16", true, 0x0000ffff, 0x0000ffff, false),
+  HOWTO (R_RELLONG, 0, 2, 32, false, 0, complain_overflow_bitfield, 0, "32", true, 0xffffffff, 0xffffffff, false),
+  HOWTO (R_PCRBYTE, 0, 0, 8, true, 0, complain_overflow_signed, 0, "DISP8", true, 0x000000ff, 0x000000ff, true),
+  HOWTO (R_PCRWORD, 0, 1, 16, true, 0, complain_overflow_signed, 0, "DISP16", true, 0x0000ffff, 0x0000ffff, true),
+  HOWTO (R_PCRLONG, 0, 2, 32, true, 0, complain_overflow_signed, 0, "DISP32", true, 0xffffffff, 0xffffffff, true),
+  HOWTO (R_MOVB1, 0, 1, 16, false, 0, complain_overflow_bitfield, 0, "16/8", true, 0x0000ffff, 0x0000ffff, false),
+  HOWTO (R_MOVB2, 0, 1, 16, false, 0, complain_overflow_bitfield, 0, "8/16", true, 0x0000ffff, 0x0000ffff, false),
+  HOWTO (R_JMP1, 0, 1, 16, false, 0, complain_overflow_bitfield, 0, "16/pcrel", true, 0x0000ffff, 0x0000ffff, false),
+  HOWTO (R_JMP2, 0, 0, 8, false, 0, complain_overflow_bitfield, 0, "pcrecl/16", true, 0x000000ff, 0x000000ff, false),
+
+
+  HOWTO (R_JMPL1, 0, 1, 32, false, 0, complain_overflow_bitfield, 0, "24/pcrell", true, 0x0000ffff, 0x0000ffff, false),
+  HOWTO (R_JMPL_B8, 0, 0, 8, false, 0, complain_overflow_bitfield, 0, "pc8/24", true, 0x000000ff, 0x000000ff, false),
+
+  HOWTO (R_MOVLB1, 0, 1, 16, false, 0, complain_overflow_bitfield, 0, "24/8", true, 0x0000ffff, 0x0000ffff, false),
+  HOWTO (R_MOVLB2, 0, 1, 16, false, 0, complain_overflow_bitfield, 0, "8/24", true, 0x0000ffff, 0x0000ffff, false),
 
 };
 
@@ -49,10 +54,10 @@ static reloc_howto_type howto_table[] =
 /* Turn a howto into a reloc number */
 
 #define SELECT_RELOC(x,howto) \
-  { x = howto_table[howto->size +(int)howto->pc_relative*3].type; }
+  { x = select_reloc(howto); }
 
-#define BADMAG(x) H8300BADMAG(x)
-#define H8300 1		/* Customize coffcode.h */
+#define BADMAG(x) (H8300BADMAG(x)&& H8300HBADMAG(x))
+#define H8300 1			/* Customize coffcode.h */
 #define __A_MAGIC_SET__
 
 
@@ -62,28 +67,43 @@ static reloc_howto_type howto_table[] =
 #define SWAP_OUT_RELOC_OFFSET bfd_h_put_32
 #define SWAP_OUT_RELOC_EXTRA(abfd, src, dst) \
   dst->r_stuff[0] = 'S'; \
-  dst->r_stuff[1] = 'C'; 
+  dst->r_stuff[1] = 'C';
+
+
+static int
+select_reloc (howto)
+     reloc_howto_type *howto;
+{
+  return howto->type;
+}
 
 /* Code to turn a r_type into a howto ptr, uses the above howto table
    */
 
-static void 
-DEFUN(rtype2howto,(internal, dst),
-arelent *internal AND
-struct internal_reloc *dst)
+static void
+rtype2howto (internal, dst)
+     arelent *internal;
+     struct internal_reloc *dst;
 {
-  switch (dst->r_type) {
+  switch (dst->r_type)
+    {
     case R_RELBYTE:
-      internal->howto =  howto_table+ 0;
+      internal->howto = howto_table + 0;
       break;
     case R_RELWORD:
-      internal->howto =  howto_table+ 1;
-      break;    
+      internal->howto = howto_table + 1;
+      break;
+    case R_RELLONG:
+      internal->howto = howto_table + 2;
+      break;
     case R_PCRBYTE:
-      internal->howto =  howto_table+3;
+      internal->howto = howto_table + 3;
       break;
     case R_PCRWORD:
-      internal->howto =  howto_table+ 4;
+      internal->howto = howto_table + 4;
+      break;
+    case R_PCRLONG:
+      internal->howto = howto_table + 5;
       break;
     case R_MOVB1:
       internal->howto = howto_table + 6;
@@ -92,15 +112,25 @@ struct internal_reloc *dst)
       internal->howto = howto_table + 7;
       break;
     case R_JMP1:
-      internal->howto = howto_table +8;
+      internal->howto = howto_table + 8;
       break;
-
     case R_JMP2:
-      internal->howto = howto_table +9;
+      internal->howto = howto_table + 9;
+      break;
+    case R_JMPL1:
+      internal->howto = howto_table + 10;
+      break;
+    case R_JMPL_B8:
+      internal->howto = howto_table + 11;
+      break;
+    case R_MOVLB1:
+      internal->howto = howto_table + 12;
+      break;
+    case R_MOVLB2:
+      internal->howto = howto_table + 13;
       break;
-      
     default:
-fprintf(stderr,"Bad reloc\n");
+      fprintf (stderr, "Bad reloc\n");
       break;
     }
 }
@@ -114,50 +144,386 @@ fprintf(stderr,"Bad reloc\n");
 #define CALC_ADDEND(abfd, symbol, ext_reloc, cache_ptr) \
  cache_ptr->addend =  ext_reloc.r_offset;
 
- 
+
 #define RELOC_PROCESSING(relent,reloc,symbols,abfd,section) \
  reloc_processing(relent, reloc, symbols, abfd, section)
 
-static void DEFUN(reloc_processing,(relent,reloc, symbols, abfd, section) ,
-	   arelent *relent AND
-	   struct internal_reloc *reloc AND
-	   asymbol **symbols AND
-	   bfd *abfd AND
-	   asection *section)
+static void
+DEFUN (reloc_processing, (relent, reloc, symbols, abfd, section),
+       arelent * relent AND
+       struct internal_reloc *reloc AND
+       asymbol ** symbols AND
+       bfd * abfd AND
+       asection * section)
 {
-  relent->address = reloc->r_vaddr;		
-  rtype2howto(relent,reloc);
-
-  if (reloc->r_symndx > 0) 
-  {
-    
-    relent->sym_ptr_ptr = symbols + obj_convert(abfd)[reloc->r_symndx];
-
-  }
-  else 
-  {
-    relent->sym_ptr_ptr = &(bfd_abs_symbol);
-  }
+  relent->address = reloc->r_vaddr;
+  rtype2howto (relent, reloc);
+
+  if (((int) reloc->r_symndx) > 0)
+    {
+      relent->sym_ptr_ptr = symbols + obj_convert (abfd)[reloc->r_symndx];
+    }
+  else
+    {
+      relent->sym_ptr_ptr = &(bfd_abs_symbol);
+    }
+
+
+
+  relent->addend = reloc->r_offset;
+
+  relent->address -= section->vma;
+  /*  relent->section = 0;*/
+}
+
+
+static int
+h8300_reloc16_estimate(input_section, symbols, reloc, shrink)
+     asection *input_section;
+     asymbol **symbols;
+     arelent *reloc;
+     unsigned int shrink;
+{
+  bfd_vma value;  
+  bfd_vma dot;
+  bfd_vma gap;
+
+  /* The address of the thing to be relocated will have moved back by 
+   the size of the shrink  - but we don't change reloc->address here,
+   since we need it to know where the relocation lives in the source
+   uncooked section */
+
+  /*  reloc->address -= shrink;   conceptual */
+
+  bfd_vma address = reloc->address - shrink;
   
 
+  switch (reloc->howto->type)
+    {     
+    case R_MOVB2:
+    case R_JMP2:
+      shrink+=2;
+      break;
+
+      /* Thing is a move one byte */
+    case R_MOVB1:
+      value = bfd_coff_reloc16_get_value(reloc,0);
+	
+      if (value >= 0xff00)
+	{ 
+
+	  /* Change the reloc type from 16bit, possible 8 to 8bit
+	     possible 16 */
+	  reloc->howto = reloc->howto + 1;	  
+	  /* The place to relc moves back by one */
+	  /* This will be two bytes smaller in the long run */
+	  shrink +=2 ;
+	  bfd_perform_slip(symbols, 2, input_section, address);
+	}      
+
+      break;
+      /* This is the 24 bit branch which could become an 8 bitter, 
+       the relocation points to the first byte of the insn, not the
+       actual data */
+
+    case R_JMPL1:
+      value = bfd_coff_reloc16_get_value(reloc, 0);
+	
+      dot = input_section->output_section->vma +
+	input_section->output_offset + address;
   
-  relent->addend = reloc->r_offset;
+      /* See if the address we're looking at within 127 bytes of where
+	 we are, if so then we can use a small branch rather than the
+	 jump we were going to */
+
+      gap = value - dot ;
+  
+      if (-120 < (long)gap && (long)gap < 120 )
+	{ 
+
+	  /* Change the reloc type from 24bit, possible 8 to 8bit
+	     possible 32 */
+	  reloc->howto = reloc->howto + 1;	  
+	  /* This will be two bytes smaller in the long run */
+	  shrink +=2 ;
+	  bfd_perform_slip(symbols, 2, input_section, address);
+	}
+      break;
+
+    case R_JMP1:
+
+      value = bfd_coff_reloc16_get_value(reloc, 0);
+	
+      dot = input_section->output_section->vma +
+	input_section->output_offset + address;
+  
+      /* See if the address we're looking at within 127 bytes of where
+	 we are, if so then we can use a small branch rather than the
+	 jump we were going to */
+
+      gap = value - (dot - shrink);
+  
+
+      if (-120 < (long)gap && (long)gap < 120 )
+	{ 
+
+	  /* Change the reloc type from 16bit, possible 8 to 8bit
+	     possible 16 */
+	  reloc->howto = reloc->howto + 1;	  
+	  /* The place to relc moves back by one */
+
+	  /* This will be two bytes smaller in the long run */
+	  shrink +=2 ;
+	  bfd_perform_slip(symbols, 2, input_section, address);
+	}
+      break;
+    }
+
   
-  relent->address-= section->vma;
-/*  relent->section = 0;*/
+  return shrink;
 }
 
+
+/* First phase of a relaxing link */
+
+/* Reloc types
+   large		small
+   R_MOVB1		R_MOVB2		mov.b with 16bit or 8 bit address
+   R_JMP1		R_JMP2		jmp or pcrel branch
+   R_JMPL1		R_JMPL_B8	24jmp or pcrel branch
+   R_MOVLB1		R_MOVLB2	24 or 8 bit reloc for mov.b
+
+*/
+
+static void
+h8300_reloc16_extra_cases (abfd, seclet, reloc, data, src_ptr, dst_ptr)
+     bfd *abfd;
+     struct bfd_seclet *seclet;
+     arelent *reloc;
+     bfd_byte *data;
+     unsigned int *src_ptr;
+     unsigned int *dst_ptr;
+{
+  unsigned int src_address = *src_ptr;
+  unsigned int dst_address = *dst_ptr;
+
+  switch (reloc->howto->type)
+    {
+      /* A 24 bit branch which could be a 8 bit pcrel, really pointing to
+	 the byte before the 24bit hole, so we can treat it as a 32bit pointer */
+    case R_PCRBYTE:
+      {
+	bfd_vma dot = seclet->offset 
+	  + dst_address 
+	    + seclet->u.indirect.section->output_section->vma;
+	int gap = bfd_coff_reloc16_get_value (reloc, seclet) - dot;
+	if (gap > 127 || gap < -128)
+	  {
+	    bfd_error_vector.reloc_value_truncated (reloc, seclet);
+	  }
+
+	bfd_put_8 (abfd, gap, data + dst_address);
+	dst_address++;
+	src_address++;
+
+	break;
+      }
+
+    case R_RELBYTE:
+      {
+	unsigned int gap = bfd_coff_reloc16_get_value (reloc, seclet);
+	if (gap > 0xff && gap < ~0xff)
+	  {
+	    bfd_error_vector.reloc_value_truncated (reloc, seclet);
+	  }
+
+	bfd_put_8 (abfd, gap, data + dst_address);
+	dst_address += 1;
+	src_address += 1;
+
+
+      }
+      break;
+    case R_JMP1:
+      /* A relword which would have like to have been a pcrel */
+    case R_MOVB1:
+      /* A relword which would like to have been modified but
+	     didn't make it */
+    case R_RELWORD:
+      bfd_put_16 (abfd, bfd_coff_reloc16_get_value (reloc, seclet),
+		  data + dst_address);
+      dst_address += 2;
+      src_address += 2;
+      break;
+    case R_RELLONG:
+      bfd_put_32 (abfd, bfd_coff_reloc16_get_value (reloc, seclet),
+		  data + dst_address);
+      dst_address += 4;
+      src_address += 4;
+      break;
+
+    case R_MOVB2:
+      /* Special relaxed type, there will be a gap between where we
+	     get stuff from and where we put stuff to now
+	
+	     for a mov.b @aa:16 -> mov.b @aa:8
+	     opcode 0x6a 0x0y offset
+	     ->     0x2y off
+	     */
+      if (data[dst_address - 1] != 0x6a)
+	abort ();
+      switch (data[src_address] & 0xf0)
+	{
+	case 0x00:
+	  /* Src is memory */
+	  data[dst_address - 1] = (data[src_address] & 0xf) | 0x20;
+	  break;
+	case 0x80:
+	  /* Src is reg */
+	  data[dst_address - 1] = (data[src_address] & 0xf) | 0x30;
+	  break;
+	default:
+	  abort ();
+	}
+
+      /* the offset must fit ! after all, what was all the relaxing
+	     about ? */
+
+      bfd_put_8 (abfd, bfd_coff_reloc16_get_value (reloc, seclet),
+		 data + dst_address);
+
+      /* Note the magic - src goes up by two bytes, but dst by only
+	     one */
+      dst_address += 1;
+      src_address += 3;
+
+      break;
+
+    case R_JMP2:
+      
+      /* Speciial relaxed type */
+      {
+	bfd_vma dot = seclet->offset
+	+ dst_address
+	+ seclet->u.indirect.section->output_section->vma;
+
+	int gap = bfd_coff_reloc16_get_value (reloc, seclet) - dot - 1;
+
+	if ((gap & ~0xff) != 0 && ((gap & 0xff00) != 0xff00))
+	  abort ();
+
+	bfd_put_8 (abfd, gap, data + dst_address);
+
+	switch (data[dst_address - 1])
+	  {
+	  case 0x5e:
+	    /* jsr -> bsr */
+	    bfd_put_8 (abfd, 0x55, data + dst_address - 1);
+	    break;
+	  case 0x5a:
+	    /* jmp ->bra */
+	    bfd_put_8 (abfd, 0x40, data + dst_address - 1);
+	    break;
+
+	  default:
+	    abort ();
+	  }
+	dst_address++;
+	src_address += 3;
+
+	break;
+      }
+      break;
+      
+    case R_JMPL_B8: /* 24 bit branch which is now 8 bits */
+      
+      /* Speciial relaxed type */
+      {
+	bfd_vma dot = seclet->offset
+	+ dst_address
+	+ seclet->u.indirect.section->output_section->vma;
+
+	int gap = bfd_coff_reloc16_get_value (reloc, seclet) - dot - 2;
+
+	if ((gap & ~0xff) != 0 && ((gap & 0xff00) != 0xff00))
+	  abort ();
+
+	switch (data[src_address])
+	  {
+	  case 0x5e:
+	    /* jsr -> bsr */
+	    bfd_put_8 (abfd, 0x55, data + dst_address);
+	    break;
+	  case 0x5a:
+	    /* jmp ->bra */
+	    bfd_put_8 (abfd, 0x40, data + dst_address);
+	    break;
+
+	  default:
+	    bfd_put_8 (abfd, 0xde, data + dst_address);
+	    break;
+	  }
+
+	bfd_put_8 (abfd, gap, data + dst_address + 1);
+	dst_address += 2;
+	src_address += 4;
+
+	break;
+      }
+
+    case R_JMPL1:
+      {
+	int v = bfd_coff_reloc16_get_value (reloc, seclet);
+	int o = bfd_get_32 (abfd, data + src_address);
+	v = (v & 0x00ffffff) | (o & 0xff000000);
+	bfd_put_32 (abfd, v, data + dst_address);
+	dst_address += 4;
+	src_address += 4;
+      }
+
+      break;
+
+
+      /* A 24 bit mov  which could be an 8 bit move, really pointing to
+	 the byte before the 24bit hole, so we can treat it as a 32bit pointer */
+    case R_MOVLB1:
+      {
+	int v = bfd_coff_reloc16_get_value (reloc, seclet);
+	int o = bfd_get_32 (abfd, data + dst_address);
+	v = (v & 0x00ffffff) | (o & 0xff000000);
+	bfd_put_32 (abfd, v, data + dst_address);
+	dst_address += 4;
+	src_address += 4;
+      }
+
+      break;
+    default:
+
+      abort ();
+      break;
+
+    }
+  *src_ptr = src_address;
+  *dst_ptr = dst_address;
+
+}
+
+#define coff_reloc16_extra_cases h8300_reloc16_extra_cases
+#define coff_reloc16_estimate h8300_reloc16_estimate
+
 #include "coffcode.h"
 
 
-#undef  coff_bfd_get_relocated_section_contents 
+#undef coff_bfd_get_relocated_section_contents
 #undef coff_bfd_relax_section
-#define  coff_bfd_get_relocated_section_contents bfd_coff_get_relocated_section_contents
-#define coff_bfd_relax_section bfd_coff_relax_section
+#define  coff_bfd_get_relocated_section_contents bfd_coff_reloc16_get_relocated_section_contents
+#define coff_bfd_relax_section bfd_coff_reloc16_relax_section
+
+
 
 bfd_target h8300coff_vec =
 {
-  "coff-h8300",		/* name */
+  "coff-h8300",			/* name */
   bfd_target_coff_flavour,
   true,				/* data byte order is big */
   true,				/* header byte order is big */
@@ -165,21 +531,25 @@ bfd_target h8300coff_vec =
   (HAS_RELOC | EXEC_P |		/* object flags */
    HAS_LINENO | HAS_DEBUG |
    HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT),
-  ( SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
-    '_',			/* leading char */
+  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC),	/* section flags */
+  '_',				/* leading char */
   '/',				/* ar_pad_char */
   15,				/* ar_max_namelen */
   1,				/* minimum section alignment */
-_do_getb64, _do_putb64,  _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* data */
-_do_getb64, _do_putb64,  _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* hdrs */
-
-  {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
-     bfd_generic_archive_p, _bfd_dummy_target},
-  {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
-     bfd_false},
+  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
+  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
+  bfd_getb16, bfd_getb_signed_16, bfd_putb16,	/* data */
+  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
+  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
+  bfd_getb16, bfd_getb_signed_16, bfd_putb16,	/* hdrs */
+
+  {_bfd_dummy_target, coff_object_p,	/* bfd_check_format */
+   bfd_generic_archive_p, _bfd_dummy_target},
+  {bfd_false, coff_mkobject, _bfd_generic_mkarchive,	/* bfd_set_format */
+   bfd_false},
   {bfd_false, coff_write_object_contents,	/* bfd_write_contents */
-     _bfd_write_archive_contents, bfd_false},
+   _bfd_write_archive_contents, bfd_false},
 
-     JUMP_TABLE(coff),
-    COFF_SWAP_TABLE
+  JUMP_TABLE (coff),
+  COFF_SWAP_TABLE,
 };
diff --git a/bfd/ieee.c b/bfd/ieee.c
index 3018996..da2193a 100644
--- a/bfd/ieee.c
+++ b/bfd/ieee.c
@@ -116,7 +116,7 @@ DEFUN(ieee_write_id,(abfd, id),
       CONST char *id)
 {
   size_t length = strlen(id);
-  if (length >= 0 && length <= 127) {
+  if (length <= 127) {
     ieee_write_byte(abfd, (bfd_byte)length);
   }
   else if (length < 255) {
@@ -173,7 +173,7 @@ DEFUN(read_id,(ieee),
   size_t length;
   char *string;
   length = this_byte_and_next(ieee);
-  if (length >= 0x00 && length <= 0x7f) {
+  if (length <= 0x7f) {
     /* Simple string of length 0 to 127 */
   }
   else if (length == 0xde) {
@@ -360,27 +360,27 @@ typedef struct
 
 static 
 reloc_howto_type abs32_howto 
- = HOWTO(1,0,2,32,false,0,false,true,0,"abs32",true,0xffffffff, 0xffffffff,false);
+ = HOWTO(1,0,2,32,false,0,complain_overflow_bitfield,0,"abs32",true,0xffffffff, 0xffffffff,false);
 static
 reloc_howto_type abs16_howto 
- = HOWTO(1,0,1,16,false,0,false,true,0,"abs16",true,0x0000ffff, 0x0000ffff,false);
+ = HOWTO(1,0,1,16,false,0,complain_overflow_bitfield,0,"abs16",true,0x0000ffff, 0x0000ffff,false);
 
 static
 reloc_howto_type abs8_howto 
- = HOWTO(1,0,0,8,false,0,false,true,0,"abs8",true,0x000000ff, 0x000000ff,false);
+ = HOWTO(1,0,0,8,false,0,complain_overflow_bitfield,0,"abs8",true,0x000000ff, 0x000000ff,false);
 
 static 
 reloc_howto_type rel32_howto 
- = HOWTO(1,0,2,32,true,0,false,true,0,"rel32",true,0xffffffff,
+ = HOWTO(1,0,2,32,true,0,complain_overflow_signed,0,"rel32",true,0xffffffff,
 	 0xffffffff,false);
 
 static
 reloc_howto_type rel16_howto 
- = HOWTO(1,0,1,16,true,0,false,true,0,"rel16",true,0x0000ffff, 0x0000ffff,false);
+ = HOWTO(1,0,1,16,true,0,complain_overflow_signed,0,"rel16",true,0x0000ffff, 0x0000ffff,false);
 
 static
 reloc_howto_type rel8_howto 
- = HOWTO(1,0,0,8,true,0,false,true,0,"rel8",true,0x000000ff, 0x000000ff,false);
+ = HOWTO(1,0,0,8,true,0,complain_overflow_signed,0,"rel8",true,0x000000ff, 0x000000ff,false);
 
 
 static ieee_symbol_index_type NOSYMBOL = {  0, 0};
@@ -1055,7 +1055,7 @@ DEFUN(ieee_archive_p,(abfd),
     ieee_ar_obstack_type t; 
     int rec =read_2bytes(&(ieee->h));
     if (rec ==(int)ieee_assign_value_to_variable_enum) {
-      int record_number = must_parse_int(&(ieee->h));
+      must_parse_int(&(ieee->h));
       t.file_offset = must_parse_int(&(ieee->h));
       t.abfd = (bfd *)NULL;
       ieee->element_count++;
@@ -3001,12 +3001,12 @@ bfd_target ieee_vec =
   ' ',				/* ar_pad_char */
   16,				/* ar_max_namelen */
     1,				/* minimum alignment */
-_do_getb64, _do_getb_signed_64, _do_putb64,
-    _do_getb32, _do_getb_signed_32, _do_putb32,
-    _do_getb16, _do_getb_signed_16, _do_putb16, /* data */
-_do_getb64, _do_getb_signed_64, _do_putb64,
-    _do_getb32, _do_getb_signed_32, _do_putb32,
-    _do_getb16, _do_getb_signed_16, _do_putb16, /* hdrs */
+bfd_getb64, bfd_getb_signed_64, bfd_putb64,
+    bfd_getb32, bfd_getb_signed_32, bfd_putb32,
+    bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
+bfd_getb64, bfd_getb_signed_64, bfd_putb64,
+    bfd_getb32, bfd_getb_signed_32, bfd_putb32,
+    bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
 
   { _bfd_dummy_target,
      ieee_object_p,		/* bfd_check_format */
diff --git a/bfd/netbsd386.c b/bfd/netbsd386.c
index 7a42700..ab6aa12 100644
--- a/bfd/netbsd386.c
+++ b/bfd/netbsd386.c
@@ -25,6 +25,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 /* ZMAGIC files start at address 0.  This does not apply to QMAGIC.  */
 #define TEXT_START_ADDR 0
+#define N_SHARED_LIB(x) 0
 
 #define	PAGE_SIZE	4096
 #define	SEGMENT_SIZE	PAGE_SIZE
diff --git a/bfd/oasys.c b/bfd/oasys.c
index 201fedf..f144192 100644
--- a/bfd/oasys.c
+++ b/bfd/oasys.c
@@ -147,7 +147,7 @@ DEFUN(oasys_slurp_symbol_table,(abfd),
 	    }
 	    break;
 	  case RELOCATION_TYPE_UND:
-	    dest = data->symbols + bfd_h_get_16(abfd, (bfd_byte *)&record.symbol.refno[0]);
+	    dest = data->symbols + bfd_h_get_16(abfd, record.symbol.refno);
 	    dest->section = &bfd_und_section;
 	    break;
 	  case RELOCATION_TYPE_COM:
@@ -166,7 +166,7 @@ DEFUN(oasys_slurp_symbol_table,(abfd),
 	  dest->name = string_ptr;
 	  dest->the_bfd = abfd;
 	  dest->udata = (PTR)NULL;
-	  dest->value = bfd_h_get_32(abfd, (bfd_byte *)&record.symbol.value[0]);
+	  dest->value = bfd_h_get_32(abfd, record.symbol.value);
 
 #ifdef UNDERSCORE_HACK
 	  if (record.symbol.name[0] != '_') {
@@ -232,20 +232,18 @@ DEFUN(oasys_archive_p,(abfd),
   oasys_extarchive_header_type header_ext;
   unsigned int i;
   file_ptr filepos;  
-  bfd_seek(abfd, (file_ptr) 0, false);
 
-  
+  bfd_seek(abfd, (file_ptr) 0, false);
   bfd_read((PTR)&header_ext, 1, sizeof(header_ext), abfd);
 
-
-  header.version = bfd_h_get_32(abfd, (bfd_byte *)header_ext.version);
-  header.mod_count = bfd_h_get_32(abfd, (bfd_byte *)header_ext.mod_count);
-  header.mod_tbl_offset = bfd_h_get_32(abfd, (bfd_byte *)header_ext.mod_tbl_offset);
-  header.sym_tbl_size = bfd_h_get_32(abfd, (bfd_byte *)header_ext.sym_tbl_size);
-  header.sym_count = bfd_h_get_32(abfd, (bfd_byte *)header_ext.sym_count);
-  header.sym_tbl_offset = bfd_h_get_32(abfd, (bfd_byte *)header_ext.sym_tbl_offset);
-  header.xref_count = bfd_h_get_32(abfd, (bfd_byte *)header_ext.xref_count);
-  header.xref_lst_offset = bfd_h_get_32(abfd, (bfd_byte *)header_ext.xref_lst_offset);
+  header.version = bfd_h_get_32(abfd, header_ext.version);
+  header.mod_count = bfd_h_get_32(abfd, header_ext.mod_count);
+  header.mod_tbl_offset = bfd_h_get_32(abfd, header_ext.mod_tbl_offset);
+  header.sym_tbl_size = bfd_h_get_32(abfd, header_ext.sym_tbl_size);
+  header.sym_count = bfd_h_get_32(abfd, header_ext.sym_count);
+  header.sym_tbl_offset = bfd_h_get_32(abfd, header_ext.sym_tbl_offset);
+  header.xref_count = bfd_h_get_32(abfd, header_ext.xref_count);
+  header.xref_lst_offset = bfd_h_get_32(abfd, header_ext.xref_lst_offset);
 
   /*
     There isn't a magic number in an Oasys archive, so the best we
@@ -259,27 +257,23 @@ DEFUN(oasys_archive_p,(abfd),
       header.xref_count > 100000) return (bfd_target *)NULL;
 
   /*
-    That all worked, lets buy the space for the header and read in
+    That all worked, let's buy the space for the header and read in
     the headers.
     */
     {
       oasys_ar_data_type *ar =
 	(oasys_ar_data_type*) bfd_alloc(abfd, sizeof(oasys_ar_data_type));
 
-
       oasys_module_info_type *module = 
 	(oasys_module_info_type*)
 	  bfd_alloc(abfd, sizeof(oasys_module_info_type) * header.mod_count);
 
-
       oasys_module_table_type record;
 
-
       abfd->tdata.oasys_ar_data = ar;
       ar->module = module;
       ar->module_count = header.mod_count;
 
-
       filepos = header.mod_tbl_offset;
       for (i = 0; i < header.mod_count; i++) {
         bfd_seek(abfd, filepos, SEEK_SET);
@@ -290,14 +284,12 @@ DEFUN(oasys_archive_p,(abfd),
 	  oasys_extmodule_table_type_a_type record_ext;
 	  bfd_read((PTR)&record_ext, 1, sizeof(record_ext), abfd);
 	
-	  record.mod_size = bfd_h_get_32(abfd, (bfd_byte *)record_ext.mod_size);
-	  record.file_offset = bfd_h_get_32(abfd,
-					 (bfd_byte *)   record_ext.file_offset);
-
-	  record.dep_count = bfd_h_get_32(abfd, (bfd_byte *)record_ext.dep_count);
-	  record.depee_count = bfd_h_get_32(abfd,(bfd_byte *) record_ext.depee_count);
-	  record.sect_count = bfd_h_get_32(abfd, (bfd_byte *) record_ext.sect_count);
+	  record.mod_size = bfd_h_get_32(abfd, record_ext.mod_size);
+	  record.file_offset = bfd_h_get_32(abfd, record_ext.file_offset);
 
+	  record.dep_count = bfd_h_get_32(abfd, record_ext.dep_count);
+	  record.depee_count = bfd_h_get_32(abfd, record_ext.depee_count);
+	  record.sect_count = bfd_h_get_32(abfd, record_ext.sect_count);
 
 	  module[i].name = bfd_alloc(abfd,33);
 
@@ -312,14 +304,13 @@ DEFUN(oasys_archive_p,(abfd),
 	  oasys_extmodule_table_type_b_type record_ext;
 	  bfd_read((PTR)&record_ext, 1, sizeof(record_ext), abfd);
 	
-	  record.mod_size = bfd_h_get_32(abfd, (bfd_byte *) record_ext.mod_size);
-	  record.file_offset = bfd_h_get_32(abfd,
-					    (bfd_byte *)record_ext.file_offset);
+	  record.mod_size = bfd_h_get_32(abfd, record_ext.mod_size);
+	  record.file_offset = bfd_h_get_32(abfd, record_ext.file_offset);
 
-	  record.dep_count = bfd_h_get_32(abfd, (bfd_byte *) record_ext.dep_count);
-	  record.depee_count = bfd_h_get_32(abfd, (bfd_byte *) record_ext.depee_count);
-	  record.sect_count = bfd_h_get_32(abfd, (bfd_byte *) record_ext.sect_count);
-	  record.module_name_size = bfd_h_get_32(abfd, (bfd_byte *) record_ext.mod_name_length);
+	  record.dep_count = bfd_h_get_32(abfd, record_ext.dep_count);
+	  record.depee_count = bfd_h_get_32(abfd, record_ext.depee_count);
+	  record.sect_count = bfd_h_get_32(abfd, record_ext.sect_count);
+	  record.module_name_size = bfd_h_get_32(abfd, record_ext.mod_name_length);
 
 	  module[i].name = bfd_alloc(abfd,record.module_name_size + 1);
 	  bfd_read((PTR)module[i].name, 1, record.module_name_size, abfd);
@@ -413,8 +404,8 @@ DEFUN(oasys_object_p,(abfd),
 	    BFD_FAIL();
 	  }
 
-	  s->_raw_size  = bfd_h_get_32(abfd, (bfd_byte *) & record.section.value[0]) ;
-	  s->vma = bfd_h_get_32(abfd, (bfd_byte *)&record.section.vma[0]);
+	  s->_raw_size  = bfd_h_get_32(abfd, record.section.value);
+	  s->vma = bfd_h_get_32(abfd, record.section.vma);
 	  s->flags= 0;
 	  had_usefull = true;
 	}
@@ -459,6 +450,17 @@ DEFUN(oasys_object_p,(abfd),
 
 
 static void 
+DEFUN(oasys_get_symbol_info,(ignore_abfd, symbol, ret),
+      bfd *ignore_abfd AND
+      asymbol *symbol AND
+      symbol_info *ret)
+{
+  bfd_symbol_info (symbol, ret);
+  if (!symbol->section)
+    ret->type = (symbol->flags & BSF_LOCAL) ? 'a' : 'A';
+}
+
+static void 
 DEFUN(oasys_print_symbol,(ignore_abfd, afile, symbol, how),
       bfd *ignore_abfd AND
       PTR afile AND
@@ -473,7 +475,6 @@ DEFUN(oasys_print_symbol,(ignore_abfd, afile, symbol, how),
     fprintf(file,"%s", symbol->name);
     break;
   case bfd_print_symbol_all:
-  case bfd_print_symbol_nm:
     {
       CONST char *section_name = symbol->section == (asection *)NULL ?
 	(CONST char *) "*abs" : symbol->section->name;
@@ -494,10 +495,10 @@ DEFUN(oasys_print_symbol,(ignore_abfd, afile, symbol, how),
 static reloc_howto_type howto_table[]= 
 {
 
-HOWTO(  0, 0,  1,   16, false,0,   true,true,0,"abs16",true,0x0000ffff, 0x0000ffff,false),
-HOWTO(  0, 0,  2,   32, false,0,   true,true,0,"abs32",true,0xffffffff, 0xffffffff,false),
-HOWTO(  0, 0,  1,   16, true,0,   true,true,0,"pcrel16",true,0x0000ffff, 0x0000ffff,false),
-HOWTO(  0, 0,  2,   32, true,0,   true,true,0,"pcrel32",true,0xffffffff, 0xffffffff,false)
+HOWTO(  0, 0,  1,   16, false,0,complain_overflow_bitfield,0,"abs16",true,0x0000ffff, 0x0000ffff,false),
+HOWTO(  0, 0,  2,   32, false,0,complain_overflow_bitfield,0,"abs32",true,0xffffffff, 0xffffffff,false),
+HOWTO(  0, 0,  1,   16, true,0,complain_overflow_signed,0,"pcrel16",true,0x0000ffff, 0x0000ffff,false),
+HOWTO(  0, 0,  2,   32, true,0,complain_overflow_signed,0,"pcrel32",true,0xffffffff, 0xffffffff,false)
 };
 
 /* Read in all the section data and relocation stuff too */
@@ -532,18 +533,17 @@ DEFUN(oasys_slurp_section_data,(abfd),
 	case oasys_record_is_data_enum:
 	    {
 
-	      uint8e_type *src = record.data.data;
-	      uint8e_type *end_src = ((uint8e_type *)&record) +
-		record.header.length;
+	      bfd_byte *src = record.data.data;
+	      bfd_byte *end_src = ((bfd_byte *)&record) + record.header.length;
+	      bfd_byte *dst_ptr;
+	      bfd_byte *dst_base_ptr;
 	      unsigned int relbit;
-	      bfd_byte *dst_ptr ;
-	      bfd_byte *dst_base_ptr ;
 	      unsigned int count;
 	      asection *  section =
 		data->sections[record.data.relb & RELOCATION_SECT_BITS];
 	      bfd_vma dst_offset ;
-	      per =  oasys_per_section(section);
 
+	      per =  oasys_per_section(section);
 
 	      if (per->initialized == false) 
 		  {
@@ -558,15 +558,12 @@ DEFUN(oasys_slurp_section_data,(abfd),
 	      dst_offset = bfd_h_get_32(abfd, record.data.addr) ;
 	      if (per->had_vma == false) {
 		/* Take the first vma we see as the base */
-
 		section->vma = dst_offset;
 		per->had_vma = true;
 	      }
 
-
 	      dst_offset -=   section->vma;
 
-
 	      dst_base_ptr = oasys_per_section(section)->data;
 	      dst_ptr = oasys_per_section(section)->data +
 		dst_offset;
@@ -575,8 +572,8 @@ DEFUN(oasys_slurp_section_data,(abfd),
 		section->flags |= SEC_LOAD | SEC_HAS_CONTENTS;
 	      }
 	      while (src < end_src) {
-		uint8e_type mod_byte = *src++;
-		uint32_type gap = end_src - src;
+		unsigned char mod_byte = *src++;
+		size_t gap = end_src - src;
 		
 		count = 8;
 		if (mod_byte == 0 && gap >= 8) {
@@ -596,7 +593,7 @@ DEFUN(oasys_slurp_section_data,(abfd),
 		      {
 			if (relbit & mod_byte) 
 			    {
-			      uint8e_type reloc = *src;
+			      unsigned char reloc = *src;
 			      /* This item needs to be relocated */
 			      switch (reloc & RELOCATION_TYPE_BITS) {
 			      case RELOCATION_TYPE_ABS:
@@ -625,7 +622,7 @@ DEFUN(oasys_slurp_section_data,(abfd),
 						     RELOCATION_SECT_BITS];
 
 				    r->relent.addend = -
-				     r->relent.section->vma;
+				      r->relent.section->vma;
 #endif
 				    r->relent.address = dst_ptr - dst_base_ptr;
 				    r->relent.howto = &howto_table[reloc>>6];
@@ -709,7 +706,7 @@ DEFUN(oasys_slurp_section_data,(abfd),
 
 
 
-bfd_error_vector_type bfd_error_vector;
+extern bfd_error_vector_type bfd_error_vector;
 
 static boolean
 DEFUN(oasys_new_section_hook,(abfd, newsect),
@@ -805,12 +802,13 @@ DEFUN(oasys_write_record,(abfd, type, record, size),
 {
   int checksum;
   size_t i;
-  uint8e_type *ptr;
+  unsigned char *ptr;
+
   record->header.length = size;
   record->header.type = (int)type;
   record->header.check_sum = 0;
   record->header.fill = 0;
-  ptr = &record->pad[0];
+  ptr = (unsigned char *)&record->pad[0];
   checksum = 0;
   for (i = 0; i < size; i++) {
     checksum += *ptr++;
@@ -839,17 +837,17 @@ DEFUN(oasys_write_syms, (abfd),
 
     if (bfd_is_com_section (g->section)) {
       symbol.relb = RELOCATION_TYPE_COM;
-      bfd_h_put_16(abfd, index, (uint8e_type *)(&symbol.refno[0]));
+      bfd_h_put_16(abfd, index, symbol.refno);
       index++;
     }
     else if (g->section == & bfd_abs_section) {
       symbol.relb = RELOCATION_TYPE_ABS;
-      bfd_h_put_16(abfd, 0, (uint8e_type *)(&symbol.refno[0]));
+      bfd_h_put_16(abfd, 0, symbol.refno);
 
     }
     else if (g->section == &bfd_und_section) {
       symbol.relb = RELOCATION_TYPE_UND ;
-      bfd_h_put_16(abfd, index, (uint8e_type *)(&symbol.refno[0]));
+      bfd_h_put_16(abfd, index, symbol.refno);
       /* Overload the value field with the output index number */
       index++;
     }
@@ -867,7 +865,7 @@ DEFUN(oasys_write_syms, (abfd),
       else {
 	symbol.relb = RELOCATION_TYPE_REL |g->section->output_section->target_index;
       }
-      bfd_h_put_16(abfd, 0, (uint8e_type *)(&symbol.refno[0]));
+      bfd_h_put_16(abfd, 0, symbol.refno);
     }
 #ifdef UNDERSCORE_HACK
     if (src[l] == '_')
@@ -878,7 +876,7 @@ DEFUN(oasys_write_syms, (abfd),
       l++;
     }
 
-    bfd_h_put_32(abfd, g->value, (bfd_byte*) symbol.value);
+    bfd_h_put_32(abfd, g->value, symbol.value);
 
       
     if (g->flags & BSF_LOCAL) {
@@ -904,7 +902,7 @@ DEFUN(oasys_write_sections, (abfd),
       bfd *CONST abfd)
 {
   asection *s;
-  static  oasys_section_record_type out = {0};
+  static oasys_section_record_type out;
 
   for (s = abfd->sections; s != (asection *)NULL; s = s->next) {
     if (!isdigit(s->name[0])) 
@@ -913,8 +911,8 @@ DEFUN(oasys_write_sections, (abfd),
 						    s->name);
 	}
     out.relb = RELOCATION_TYPE_REL | s->target_index;
-    bfd_h_put_32(abfd, s->_cooked_size, (bfd_byte *) out.value);
-    bfd_h_put_32(abfd, s->vma, (bfd_byte *) out.vma);
+    bfd_h_put_32(abfd, s->_cooked_size, out.value);
+    bfd_h_put_32(abfd, s->vma, out.vma);
 
     oasys_write_record(abfd,
 		       oasys_record_is_section_enum,
@@ -957,11 +955,11 @@ DEFUN(oasys_write_end,(abfd),
       bfd *CONST abfd)
 {
   oasys_end_record_type end;
-  uint8e_type null = 0;
+  unsigned char null = 0;
   end.relb = RELOCATION_TYPE_ABS;
-  bfd_h_put_32(abfd, abfd->start_address, (bfd_byte *)end.entry); 
-  bfd_h_put_16(abfd, 0, (bfd_byte *)end.fill);
-  end.zero =0;
+  bfd_h_put_32(abfd, abfd->start_address, end.entry); 
+  bfd_h_put_16(abfd, 0, end.fill);
+  end.zero = 0;
   oasys_write_record(abfd,
 		     oasys_record_is_end_enum,
 		     (oasys_record_union_type *)&end,
@@ -990,7 +988,7 @@ DEFUN(oasys_write_data, (abfd),
   asection *s;
   for (s = abfd->sections; s != (asection *)NULL; s = s->next) {
     if (s->flags & SEC_LOAD) {
-      uint8e_type *raw_data = oasys_per_section(s)->data;
+      bfd_byte *raw_data = oasys_per_section(s)->data;
       oasys_data_record_type processed_data;
       bfd_size_type current_byte_index = 0;
       unsigned int relocs_to_go = s->reloc_count;
@@ -1011,10 +1009,10 @@ DEFUN(oasys_write_data, (abfd),
 	  {
 	    /* Scan forwards by eight bytes or however much is left and see if
 	       there are any relocations going on */
-	    uint8e_type *mod = &processed_data.data[0];
-	    uint8e_type *dst = &processed_data.data[1];
+	    bfd_byte *mod = &processed_data.data[0];
+	    bfd_byte *dst = &processed_data.data[1];
 
-	    unsigned int i;
+	    unsigned int i = 0;
 	    *mod = 0;
 
 
@@ -1029,7 +1027,7 @@ DEFUN(oasys_write_data, (abfd),
  	       the magic number 8 comes from.
  	    */
  	    while (current_byte_index < s->_raw_size && dst <=
- 		(uint8e_type*)&processed_data.data[sizeof(processed_data.data)-8]) {
+ 		&processed_data.data[sizeof(processed_data.data)-8]) {
  	    
 
 		if (relocs_to_go != 0) {	
@@ -1037,13 +1035,14 @@ DEFUN(oasys_write_data, (abfd),
 		  reloc_howto_type *CONST how=r->howto;
 		  /* There is a relocation, is it for this byte ? */
 		  if (r->address == current_byte_index) {
-		    uint8e_type rel_byte;
+		    unsigned char rel_byte;
+
 		    p++;
 		    relocs_to_go--;
 
 		    *mod |= (1<<i);
 		    if(how->pc_relative) {
-		      rel_byte = 0x80;
+		      rel_byte = RELOCATION_PCREL_BIT;
 
 		      /* Also patch the raw data so that it doesn't have
 			 the -ve stuff any more */
@@ -1063,7 +1062,7 @@ DEFUN(oasys_write_data, (abfd),
 		      rel_byte = 0;
 		    }
 		    if (how->size ==2) {
-		      rel_byte |= 0x40;
+		      rel_byte |= RELOCATION_32BIT_BIT;
 		    }
 		  
 		    /* Is this a section relative relocation, or a symbol
@@ -1095,8 +1094,6 @@ DEFUN(oasys_write_data, (abfd),
 			  }
 			  else {
 			    rel_byte |= RELOCATION_TYPE_UND;
-		  
-
 			    *dst++ = rel_byte;
 			    /* Next two bytes are a symbol index - we can get
 			       this from the symbol value which has been zapped
@@ -1106,7 +1103,6 @@ DEFUN(oasys_write_data, (abfd),
 			    *dst++ = p->value >> 8;
 			    *dst++ = p->value;
 			  }
-
 			}
 #define ADVANCE { if (++i >= 8) { i = 0; mod = dst++; *mod = 0; } current_byte_index++; }
 		    /* relocations never occur from an unloadable section,
@@ -1127,7 +1123,7 @@ DEFUN(oasys_write_data, (abfd),
 		}
 		/* If this is coming from an unloadable section then copy
 		   zeros */
-		if (raw_data == (uint8e_type *)NULL) {
+		if (raw_data == NULL) {
 		  *dst++ = 0;
 		}
 		else {
@@ -1144,7 +1140,7 @@ DEFUN(oasys_write_data, (abfd),
 	    oasys_write_record(abfd,
 			       oasys_record_is_data_enum,
 			       (oasys_record_union_type *)&processed_data,
-			       dst - (uint8e_type*)&processed_data);
+			       dst - (bfd_byte *)&processed_data);
 			 
 	  }
     }
@@ -1332,8 +1328,12 @@ bfd_target oasys_vec =
   ' ',				/* ar_pad_char */
   16,				/* ar_max_namelen */
   1,				/* minimum alignment */
-  _do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* data */
-  _do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* hdrs */
+  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
+    bfd_getb32, bfd_getb_signed_32, bfd_putb32,
+    bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
+  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
+    bfd_getb32, bfd_getb_signed_32, bfd_putb32,
+    bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
 
     {_bfd_dummy_target,
        oasys_object_p,		/* bfd_check_format */