Various portability lints.

Fixed reloc bug in ieee and oasys.

8 files changed, 474 insertions, 539 deletions

diff --git a/bfd/aout.c b/bfd/aout.c
index b714bf9..35f2d4f 100755
--- a/bfd/aout.c
+++ b/bfd/aout.c
@@ -1273,7 +1273,9 @@ swap_std_reloc_out (abfd, g, natptr)
   else {
     r_extern = 0;
     if (g->section == NULL) {
-      BFD_ASSERT(0);
+      /* It is possible to have a reloc with nothing, we generate an
+	 abs + 0 */
+      r_addend = 0;
       r_index = N_ABS | N_EXT;
     }
     else  if(g->section->output_section == obj_textsec(abfd)) {
diff --git a/bfd/archive.c b/bfd/archive.c
index 4df6318..f1d8a6a 100644
--- a/bfd/archive.c
+++ b/bfd/archive.c
@@ -1144,7 +1144,7 @@ bsd_write_armap (arch, elength, map, orl_count, stridx)
   /* now write the strings themselves */
   /* FIXME, this needs to be byte-swapped! */
   temp = stridx + 4;
-  bfd_write (&temp, 1, sizeof (temp), arch);
+  bfd_write ((PTR)&temp, 1, sizeof (temp), arch);
   for (count = 0; count < orl_count; count++)
     bfd_write (*((map[count]).name), 1, strlen (*((map[count]).name))+1, arch);
 
@@ -1211,9 +1211,9 @@ coff_write_armap (arch, elength, map, orl_count, stridx)
 
     /* Write the ar header for this item and the number of symbols */
 
-    bfd_write ((char *)&hdr, 1, sizeof (struct ar_hdr), arch);
+    bfd_write ((PTR)&hdr, 1, sizeof (struct ar_hdr), arch);
     /* FIXME, this needs to be byte-swapped */
-    bfd_write (&orl_count, 1, sizeof (orl_count), arch);
+    bfd_write ((PTR)&orl_count, 1, sizeof (orl_count), arch);
 
     /* Two passes, first write the file offsets for each symbol -
        remembering that each offset is on a two byte boundary
@@ -1230,7 +1230,7 @@ coff_write_armap (arch, elength, map, orl_count, stridx)
 	    last_eltno++;
 	}
 	/* FIXME, this needs to be byte-swapped */
-	bfd_write (&archive_member_file_ptr,
+	bfd_write ((PTR)&archive_member_file_ptr,
 		   1,
 		   sizeof (archive_member_file_ptr),
 		   arch);
@@ -1238,7 +1238,7 @@ coff_write_armap (arch, elength, map, orl_count, stridx)
 
     /* now write the strings themselves */
     for (count = 0; count < orl_count; count++) {
-	bfd_write (*((map[count]).name),
+	bfd_write ((PTR)*((map[count]).name),
 		   1,
 		   strlen (*((map[count]).name))+1, arch);
 
diff --git a/bfd/coff-mips.c b/bfd/coff-mips.c
index ebdf221..d424932 100644
--- a/bfd/coff-mips.c
+++ b/bfd/coff-mips.c
@@ -168,7 +168,7 @@ ecoff_object_p (abfd)
   bfd_error = no_error;
 
   /* figure out how much to read */
-  if (bfd_read (short_bytes, 1, SHORT_SIZE, abfd) != SHORT_SIZE)
+  if (bfd_read ((PTR)short_bytes, 1, SHORT_SIZE, abfd) != SHORT_SIZE)
     return 0;
 
   magic = bfd_h_getshort (abfd, short_bytes);
@@ -176,13 +176,13 @@ ecoff_object_p (abfd)
     bfd_error = wrong_format;
     return 0;
   }
-  if (bfd_read (short_bytes, 1, SHORT_SIZE, abfd) != SHORT_SIZE)
+  if (bfd_read ((PTR)short_bytes, 1, SHORT_SIZE, abfd) != SHORT_SIZE)
     return 0;
   nscns = bfd_h_getshort (abfd, short_bytes);
 
   if (bfd_seek (abfd,(file_ptr) ((sizeof (long)) * 3), true) < 0) 
     return 0;
-  if (bfd_read (short_bytes, 1, SHORT_SIZE, abfd) != SHORT_SIZE)
+  if (bfd_read ((PTR)short_bytes, 1, SHORT_SIZE, abfd) != SHORT_SIZE)
     return 0;
   opthdr = bfd_h_getshort (abfd, short_bytes);
 
diff --git a/bfd/ieee.c b/bfd/ieee.c
index 84f64ac..6bc3730 100644
--- a/bfd/ieee.c
+++ b/bfd/ieee.c
@@ -1,4 +1,5 @@
-/* bfd backend for ieee-695 objects.
+
+ /* bfd backend for ieee-695 objects.
 
    IEEE 695 format is a stream of records, which we parse using a simple one
    token (which is one byte in this lexicon) lookahead recursive decent
@@ -23,17 +24,13 @@ along with BFD; see the file COPYING.  If not, write to
 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 #include "sysdep.h"
+
 #include "bfd.h"
 #include "libbfd.h"
-#include "obstack.h"
 #include "ieee.h"
 #include "libieee.h"
 
 
-#define obstack_chunk_alloc malloc
-#define obstack_chunk_free  free
-#define ieee_malloc(abfd,size) \
-  obstack_alloc(&( ieee_data(abfd)->ieee_obstack), (size))
 
 typedef void generic_symbol_type;
 
@@ -49,7 +46,7 @@ DEFUN(ieee_write_byte,(abfd, byte),
       bfd *abfd AND
       bfd_byte byte)
 {
-  bfd_write(&byte, 1, 1, abfd);
+  bfd_write((PTR)&byte, 1, 1, abfd);
 }
 
 
@@ -62,7 +59,7 @@ DEFUN(ieee_write_2bytes,(abfd, bytes),
   buffer[0] = bytes >> 8;
   buffer[1] = bytes & 0xff;
 
-  bfd_write(buffer, 1, 2, abfd);
+  bfd_write((PTR)buffer, 1, 2, abfd);
 }
 
 static void
@@ -123,72 +120,75 @@ DEFUN(ieee_write_id,(abfd, id),
   else {
     BFD_FAIL();
   }
-  bfd_write((bfd_byte *)id, 1, length, abfd);
+  bfd_write((PTR)id, 1, length, abfd);
 }
 /***************************************************************************
 Functions for reading from ieee files in the strange way that the
 standard requires:
 */
 
-#define this_byte(abfd) *(ptr(abfd))
-#define next_byte(abfd) (ptr(abfd)++)
-#define this_byte_and_next(abfd) *(ptr(abfd)++)
+
+#define this_byte(ieee) *(ieee->input_p)
+#define next_byte(ieee) (ieee->input_p++)
+#define this_byte_and_next(ieee) (*(ieee->input_p++))
 
 
 static unsigned short 
-DEFUN(read_2bytes,(abfd),
-      bfd *abfd)
+DEFUN(read_2bytes,(ieee),
+     ieee_data_type *ieee)
 {
-  unsigned  char c1 = this_byte_and_next(abfd);
-  unsigned  char c2 = this_byte_and_next(abfd);
+  unsigned  char c1 = this_byte_and_next(ieee);
+  unsigned  char c2 = this_byte_and_next(ieee);
   return (c1<<8 ) | c2;
 
 }
 
 static void
-DEFUN(bfd_get_string,(abfd, string, length),
-      bfd *abfd AND
+DEFUN(bfd_get_string,(ieee, string, length),
+    ieee_data_type *ieee AND
       char *string AND
       size_t length)
 {
   size_t i;
   for (i= 0; i < length; i++) {
-    string[i] = this_byte_and_next(abfd);
+    string[i] = this_byte_and_next(ieee);
   }
 }
 
 static char *
-DEFUN(read_id,(abfd),
-      bfd *abfd)
+DEFUN(read_id,(ieee),
+    ieee_data_type *ieee)
 {
   size_t length;
   char *string;
-  length = this_byte_and_next(abfd);
+  length = this_byte_and_next(ieee);
   if (length >= 0x00 && length <= 0x7f) {
     /* Simple string of length 0 to 127 */
   }
   else if (length == 0xde) {
     /* Length is next byte, allowing 0..255 */
-    length = this_byte_and_next(abfd);
+    length = this_byte_and_next(ieee);
   }
   else if (length == 0xdf) {
     /* Length is next two bytes, allowing 0..65535 */
-    length = this_byte_and_next(abfd) ;
-    length = (length * 256) + this_byte_and_next(abfd);
+    length = this_byte_and_next(ieee) ;
+    length = (length * 256) + this_byte_and_next(ieee);
   }
   /* Buy memory and read string */
-  string = ieee_malloc(abfd, length+1);
-  bfd_get_string(abfd, string, length);
+  string = bfd_alloc(ieee->abfd, length+1);
+  bfd_get_string(ieee, string, length);
   string[length] = 0;
   return string;
 }
 
 static void
-DEFUN(ieee_write_expression,(abfd, value, section, symbol),
+DEFUN(ieee_write_expression,(abfd, value, section, symbol, pcrel, index),
       bfd*abfd AND
       bfd_vma value AND
       asection *section AND
-      asymbol *symbol)
+      asymbol *symbol AND
+      boolean pcrel AND
+			    unsigned int index)
 {
   unsigned int plus_count = 0;
   ieee_write_int(abfd, value);
@@ -198,6 +198,8 @@ DEFUN(ieee_write_expression,(abfd, value, section, symbol),
     ieee_write_byte(abfd, section->index  +IEEE_SECTION_NUMBER_BASE);
   }
 
+
+
   if (symbol != (asymbol *)NULL) {
     plus_count++;
     if ((symbol->flags & BSF_UNDEFINED ) ||
@@ -228,7 +230,14 @@ DEFUN(ieee_write_expression,(abfd, value, section, symbol),
     }
   }
 
-  while (plus_count != 0) {
+  if(pcrel) {
+    /* subtract the pc from here by asking for PC of this section*/
+    ieee_write_byte(abfd, ieee_variable_P_enum);
+    ieee_write_byte(abfd, index  +IEEE_SECTION_NUMBER_BASE);
+    ieee_write_byte(abfd, ieee_function_minus_enum);
+  }
+
+  while (plus_count > 0) {
     ieee_write_byte(abfd, ieee_function_plus_enum);
     plus_count--;
   }
@@ -264,30 +273,30 @@ DEFUN(ieee_write_int5_out, (abfd, value),
       bfd *abfd AND
       bfd_vma value)
 {
-  char b[5];
+  bfd_byte b[5];
   ieee_write_int5(b, value);
-  bfd_write(b,1,5,abfd);
+  bfd_write((PTR)b,1,5,abfd);
 }
 
 
 static boolean 
-DEFUN(parse_int,(abfd, value_ptr),
-      bfd *abfd AND
+DEFUN(parse_int,(ieee, value_ptr),
+      ieee_data_type  *ieee AND
       bfd_vma *value_ptr)
 {
-  int value = this_byte(abfd);
+  int value = this_byte(ieee);
   int result;
   if (value >= 0 && value <= 127) {
     *value_ptr = value;
-    next_byte(abfd);
+    next_byte(ieee);
     return true;
   } 
   else if (value >= 0x80 && value <= 0x88) {
     unsigned int count = value & 0xf;
     result = 0;
-    next_byte(abfd);
+    next_byte(ieee);
     while (count) {
-      result =(result << 8) | this_byte_and_next(abfd);
+      result =(result << 8) | this_byte_and_next(ieee);
       count--;
     }
     *value_ptr = result;
@@ -296,21 +305,21 @@ DEFUN(parse_int,(abfd, value_ptr),
   return false;
 }
 static int
-DEFUN(parse_i,(abfd, ok),
-      bfd *abfd AND
+DEFUN(parse_i,(ieee, ok),
+    ieee_data_type *ieee AND
       boolean *ok)
 {
   bfd_vma x;
-  *ok = parse_int(abfd, &x);
+  *ok = parse_int(ieee, &x);
   return x;
 }
 
 static bfd_vma 
-DEFUN(must_parse_int,(abfd),
-      bfd *abfd)
+DEFUN(must_parse_int,(ieee),
+      ieee_data_type *ieee)
 {
   bfd_vma result;
-  BFD_ASSERT(parse_int(abfd, &result) == true);
+  BFD_ASSERT(parse_int(ieee, &result) == true);
   return result;
 }
 
@@ -324,22 +333,30 @@ typedef struct
 
 static 
 reloc_howto_type abs32_howto 
- = HOWTO(1,0,2,32,0,0,0,true,0,"abs32",false,0xffffffff, 0xffffffff,false);
+ = HOWTO(1,0,2,32,0,0,0,true,0,"abs32",true,0xffffffff, 0xffffffff,false);
 static
 reloc_howto_type abs16_howto 
- = HOWTO(1,0,1,16,0,0,0,true,0,"abs16",false,0x0000ffff, 0x0000ffff,false);
+ = HOWTO(1,0,1,16,0,0,0,true,0,"abs16",true,0x0000ffff, 0x0000ffff,false);
+
+static 
+reloc_howto_type rel32_howto 
+ = HOWTO(1,0,2,32,1,0,0,true,0,"rel32",true,0xffffffff, 0xffffffff,false);
+static
+reloc_howto_type rel16_howto 
+ = HOWTO(1,0,1,16,1,0,0,true,0,"rel16",true,0x0000ffff, 0x0000ffff,false);
 
 static ieee_symbol_index_type NOSYMBOL = {  0, 0};
 
 
 static void
-DEFUN(parse_expression,(abfd, value, section, symbol, pcrel, extra),
-      bfd *abfd AND
+DEFUN(parse_expression,(ieee, value, section, symbol, pcrel, extra),
+      ieee_data_type *ieee AND
       bfd_vma *value AND
       asection **section AND
       ieee_symbol_index_type *symbol AND
       boolean *pcrel AND
       unsigned int *extra)
+
 {
 #define POS sp[1]
 #define TOS sp[0]
@@ -356,110 +373,108 @@ DEFUN(parse_expression,(abfd, value, section, symbol, pcrel, extra),
   ieee_value_type *sp = stack;
 
   while (loop) {
-    switch (this_byte(abfd)) 
-      {
-      case ieee_variable_P_enum:
-	/* P variable, current program counter for section n */
+    switch (this_byte(ieee)) 
 	{
-	  int section_n ;
-	  next_byte(abfd);
-	  section_n  = must_parse_int(abfd);
-	  PUSH(NOSYMBOL, 0,
-	       TOS.value = ieee_data(abfd)->section_table[section_n]->vma +
-	       ieee_per_section(ieee_data(abfd)->section_table[section_n])->pc);
+	case ieee_variable_P_enum:
+	  /* P variable, current program counter for section n */
+	    {
+	      int section_n ;
+	      next_byte(ieee);
+	      *pcrel = true;
+	      section_n  = must_parse_int(ieee);
+	      PUSH(NOSYMBOL, 0,
+		   TOS.value = ieee->section_table[section_n]->vma +
+		   ieee_per_section(ieee->section_table[section_n])->pc);
+	      break;
+	    }
+	case ieee_variable_L_enum:
+	  /* L variable  address of section N */
+	  next_byte(ieee);
+	  PUSH(NOSYMBOL,ieee->section_table[must_parse_int(ieee)],0);
+	  break;
+	case ieee_variable_R_enum:
+	  /* R variable, logical address of section module */
+	  /* FIXME, this should be different to L */
+	  next_byte(ieee);
+	  PUSH(NOSYMBOL,ieee->section_table[must_parse_int(ieee)],0);
+	  break;
+	case ieee_variable_S_enum:
+	  /* S variable, size in MAUS of section module */
+	  next_byte(ieee);
+	  PUSH(NOSYMBOL,
+	       0,
+	       ieee->section_table[must_parse_int(ieee)]->size);
 	  break;
-	}
-      case ieee_variable_L_enum:
-	/* L variable  address of section N */
-	next_byte(abfd);
-	PUSH(NOSYMBOL,ieee_data(abfd)->section_table[must_parse_int(abfd)],0);
-	break;
-      case ieee_variable_R_enum:
-	/* R variable, logical address of section module */
-	/* FIXME, this should be different to L */
-	next_byte(abfd);
-	PUSH(NOSYMBOL,ieee_data(abfd)->section_table[must_parse_int(abfd)],0);
-	break;
-      case ieee_variable_S_enum:
-	/* S variable, size in MAUS of section module */
-	next_byte(abfd);
-	PUSH(NOSYMBOL,
-	     0,
-	     ieee_data(abfd)->section_table[must_parse_int(abfd)]->size);
-	break;
 
-      case ieee_variable_X_enum:
-	/* Push the address of external variable n */
-	{
-	  ieee_symbol_index_type sy;
-	  next_byte(abfd);
-	  sy.index  = (int)(must_parse_int(abfd)) ;
-	  sy.letter = 'X';
+	case ieee_variable_X_enum:
+	  /* Push the address of external variable n */
+	    {
+	      ieee_symbol_index_type sy;
+	      next_byte(ieee);
+	      sy.index  = (int)(must_parse_int(ieee)) ;
+	      sy.letter = 'X';
 
-	  PUSH(sy, 0, 0);
-	}	
-	break;
-      case ieee_function_minus_enum:
-	{
-	  bfd_vma value1, value2;
-	  asection *section;
-	  ieee_symbol_index_type sy;
-	  next_byte(abfd);
-
-	  POP(sy, section, value1);
-	  POP(sy, section, value2);
-	  PUSH(NOSYMBOL, 0, value1-value2);
-	}
-	break;
-      case ieee_function_plus_enum:
-	{
-	  bfd_vma value1, value2;
-	  asection *section1;
-	  asection *section2;
-	  ieee_symbol_index_type sy1;
-	  ieee_symbol_index_type sy2;
-	  next_byte(abfd);
-
-	  POP(sy1, section1, value1);
-	  POP(sy2, section2, value2);
-	  PUSH(sy1.letter ? sy1 : sy2, section1 ? section1: section2, value1+value2);
-	}
-	break;
-      default: 
-	{
-	  bfd_vma va;
-	  BFD_ASSERT(this_byte(abfd) < ieee_variable_A_enum 
-		     || this_byte(abfd) > ieee_variable_Z_enum);
-	  if (parse_int(abfd, &va)) 
+	      PUSH(sy, 0, 0);
+	    }	
+	  break;
+	case ieee_function_minus_enum:
 	    {
-	      PUSH(NOSYMBOL,0, va);
+	      bfd_vma value1, value2;
+	      asection *section1, *section_dummy;
+	      ieee_symbol_index_type sy;
+	      next_byte(ieee);
+
+	      POP(sy, section1, value1);
+	      POP(sy, section_dummy, value2);
+	      PUSH(sy, section1, value1-value2);
 	    }
-	  else {
-	    /* 
-	       Thats all that we can understand. As far as I can see
-	       there is a bug in the Microtec IEEE output which I'm
-	       using to scan, whereby the comma operator is ommited
-	       sometimes in an expression, giving expressions with too
-	       many terms. We can tell if that's the case by ensuring
-	       that sp == stack here. If not, then we've pushed
-	       something too far. - 
-	       */
-
-	    POP(*symbol, *section, *value);
-	    if (sp != stack) {
-	      BFD_ASSERT(*section == 0);
-	      *extra = *value;
-	      /* Get what should be returned */
-	      POP(*symbol, *section, *value);
+	  break;
+	case ieee_function_plus_enum:
+	    {
+	      bfd_vma value1, value2;
+	      asection *section1;
+	      asection *section2;
+	      ieee_symbol_index_type sy1;
+	      ieee_symbol_index_type sy2;
+	      next_byte(ieee);
+
+	      POP(sy1, section1, value1);
+	      POP(sy2, section2, value2);
+	      PUSH(sy1.letter ? sy1 : sy2, section1 ? section1: section2, value1+value2);
 	    }
-	    else {
-	      *extra = 0;
+	  break;
+	default: 
+	    {
+	      bfd_vma va;
+	      BFD_ASSERT(this_byte(ieee) < ieee_variable_A_enum 
+			 || this_byte(ieee) > ieee_variable_Z_enum);
+	      if (parse_int(ieee, &va)) 
+		  {
+		    PUSH(NOSYMBOL,0, va);
+		  }
+	      else {
+		/* 
+		  Thats all that we can understand. As far as I can see
+		  there is a bug in the Microtec IEEE output which I'm
+		  using to scan, whereby the comma operator is ommited
+		  sometimes in an expression, giving expressions with too
+		  many terms. We can tell if that's the case by ensuring
+		  that sp == stack here. If not, then we've pushed
+		  something too far, so we keep adding
+		  */
+
+		while (sp != stack+1) {
+		  asection *section1;
+		  ieee_symbol_index_type sy1;
+		  POP(sy1, section1, *extra);
+		}
+
+		POP(*symbol, *section, *value);
+		loop = false;
+	      }
 	    }
-	    loop = false;
-	  }
-	}
 
-      }
+	}
   }
 }
 
@@ -486,22 +501,22 @@ DEFUN(ieee_slurp_external_symbols,(abfd),
   ieee_seek(abfd, offset );
 
   while (loop) {
-    switch (this_byte(abfd)) {
+    switch (this_byte(ieee)) {
     case ieee_external_symbol_enum:
-      next_byte(abfd);
-      symbol =  (ieee_symbol_type *)ieee_malloc(abfd, sizeof(ieee_symbol_type));
+      next_byte(ieee);
+      symbol =  (ieee_symbol_type *)bfd_alloc(ieee->abfd, sizeof(ieee_symbol_type));
 
       *prev_symbols_ptr = symbol;
       prev_symbols_ptr= &symbol->next;
-      symbol->index = must_parse_int(abfd);
+      symbol->index = must_parse_int(ieee);
       if (symbol->index > ieee->external_symbol_max_index) {
 	ieee->external_symbol_max_index = symbol->index;
       }
       BFD_ASSERT (symbol->index >= ieee->external_symbol_min_index);
       symbol_count++;
       symbol->symbol.the_bfd = abfd;
-      symbol->symbol.name = read_id(abfd);
-      symbol->symbol.udata = (void *)NULL;
+      symbol->symbol.name = read_id(ieee);
+      symbol->symbol.udata = (PTR)NULL;
       symbol->symbol.flags = BSF_NO_FLAGS;
       break;
     case ieee_attribute_record_enum >> 8:
@@ -510,13 +525,13 @@ DEFUN(ieee_slurp_external_symbols,(abfd),
 	unsigned int symbol_type_index;
 	unsigned int symbol_attribute_def;
 	bfd_vma value;
-	next_byte(abfd);	/* Skip prefix */
-	next_byte(abfd);
-	symbol_name_index = must_parse_int(abfd);
-	symbol_type_index = must_parse_int(abfd);
-	symbol_attribute_def = must_parse_int(abfd);
+	next_byte(ieee);	/* Skip prefix */
+	next_byte(ieee);
+	symbol_name_index = must_parse_int(ieee);
+	symbol_type_index = must_parse_int(ieee);
+	symbol_attribute_def = must_parse_int(ieee);
 
-	parse_int(abfd,&value);
+	parse_int(ieee,&value);
 
       }
       break;
@@ -525,17 +540,17 @@ DEFUN(ieee_slurp_external_symbols,(abfd),
 	unsigned int symbol_name_index;
 	ieee_symbol_index_type symbol_ignore;
 	boolean pcrel_ignore;
-	unsigned int extra_ignore;
-	next_byte(abfd);
-	next_byte(abfd);
+	unsigned int extra;
+	next_byte(ieee);
+	next_byte(ieee);
 
-	symbol_name_index = must_parse_int(abfd);
-	parse_expression(abfd,
+	symbol_name_index = must_parse_int(ieee);
+	parse_expression(ieee,
 	     &symbol->symbol.value,
 	     &symbol->symbol.section,
 	     &symbol_ignore, 
-	     &pcrel_ignore,
-	     &extra_ignore);
+	     &pcrel_ignore, 
+			 &extra);
 	if (symbol->symbol.section != (asection *)NULL) {
 	  symbol->symbol.flags  = BSF_GLOBAL | BSF_EXPORT;
 	}
@@ -547,13 +562,13 @@ DEFUN(ieee_slurp_external_symbols,(abfd),
     case ieee_weak_external_reference_enum:
       { bfd_vma size;
 	bfd_vma value ;
-	next_byte(abfd);
+	next_byte(ieee);
 	/* Throw away the external reference index */
-	(void)must_parse_int(abfd);
+	(void)must_parse_int(ieee);
 	/* Fetch the default size if not resolved */
-	size = must_parse_int(abfd);
+	size = must_parse_int(ieee);
 	/* Fetch the defautlt value if available */
-	if (  parse_int(abfd, &value) == false) {
+	if (  parse_int(ieee, &value) == false) {
 	  value = 0;
 	}
 	/* This turns into a common */
@@ -563,15 +578,15 @@ DEFUN(ieee_slurp_external_symbols,(abfd),
       break;
 
     case ieee_external_reference_enum: 
-      next_byte(abfd);
-      symbol = (ieee_symbol_type *)ieee_malloc(abfd, sizeof(ieee_symbol_type));
+      next_byte(ieee);
+      symbol = (ieee_symbol_type *)bfd_alloc(ieee->abfd, sizeof(ieee_symbol_type));
       symbol_count++;
       *prev_reference_ptr = symbol;
       prev_reference_ptr = &symbol->next;
-      symbol->index = must_parse_int(abfd);
+      symbol->index = must_parse_int(ieee);
       symbol->symbol.the_bfd = abfd;
-      symbol->symbol.name = read_id(abfd);
-      symbol->symbol.udata = (void *)NULL;
+      symbol->symbol.name = read_id(ieee);
+      symbol->symbol.udata = (PTR)NULL;
       symbol->symbol.section = (asection *)NULL;
       symbol->symbol.value = (bfd_vma)0;
       symbol->symbol.flags = BSF_UNDEFINED;
@@ -626,7 +641,7 @@ DEFUN(ieee_slurp_symbol_table,(abfd),
   }
 }
 
-size_t
+unsigned int
 DEFUN(ieee_get_symtab_upper_bound,(abfd),
       bfd *abfd)
 {
@@ -642,7 +657,6 @@ symbol index order
 */
 
 extern bfd_target ieee_vec;
-
 unsigned int
 DEFUN(ieee_get_symtab,(abfd, location),
       bfd *abfd AND
@@ -651,7 +665,8 @@ DEFUN(ieee_get_symtab,(abfd, location),
   ieee_symbol_type *symp;
   static bfd dummy_bfd;
   static asymbol empty_symbol =
-    { &dummy_bfd," ieee empty",(symvalue)0,BSF_DEBUGGING | BSF_FAKE};
+    { &dummy_bfd," ieee empty",(symvalue)0,BSF_DEBUGGING | BSF_ABSOLUTE};
+
 
   ieee_data_type *ieee = ieee_data(abfd);
   dummy_bfd.xvec= &ieee_vec;
@@ -709,12 +724,12 @@ DEFUN(ieee_slurp_sections,(abfd),
     bfd_byte section_type[3];
     ieee_seek(abfd, offset);
     while (true) {
-      switch (this_byte(abfd)) {
+      switch (this_byte(ieee)) {
       case ieee_section_type_enum:
 	{
 	  unsigned int section_index ;
-	  next_byte(abfd);
-	  section_index = must_parse_int(abfd);
+	  next_byte(ieee);
+	  section_index = must_parse_int(ieee);
 	  /* Fixme to be nice about a silly number of sections */
 	  BFD_ASSERT(section_index < NSECTIONS);
 
@@ -722,24 +737,24 @@ DEFUN(ieee_slurp_sections,(abfd),
 	  ieee->section_table[section_index] = section;
 	  section->flags = SEC_NO_FLAGS;
 	  section->target_index = section_index;
-	  section_type[0] =  this_byte_and_next(abfd);
+	  section_type[0] =  this_byte_and_next(ieee);
 	  switch (section_type[0]) {
 	  case 0xC3:
-	    section_type[1] = this_byte(abfd);
+	    section_type[1] = this_byte(ieee);
 	    section->flags = SEC_LOAD;
 	    switch (section_type[1]) {
 	    case 0xD0:
 	      /* Normal code */
-	      next_byte(abfd);
+	      next_byte(ieee);
 	      section->flags |= SEC_LOAD | SEC_CODE;
 	      break;
 	    case 0xC4:
-	      next_byte(abfd);
+	      next_byte(ieee);
 	      section->flags |= SEC_LOAD  | SEC_DATA;
 	      /* Normal data */
 	      break;
 	    case 0xD2:
-	      next_byte(abfd);
+	      next_byte(ieee);
 	      /* Normal rom data */
 	      section->flags |= SEC_LOAD | SEC_ROM | SEC_DATA;
 	      break;
@@ -747,11 +762,11 @@ DEFUN(ieee_slurp_sections,(abfd),
 	      break;
 	    }
 	  }
-	  section->name = read_id(abfd);
+	  section->name = read_id(ieee);
 	  { bfd_vma parent, brother, context;
-	    parse_int(abfd, &parent);
-	    parse_int(abfd, &brother);
-	    parse_int(abfd, &context);
+	    parse_int(ieee, &parent);
+	    parse_int(ieee, &brother);
+	    parse_int(ieee, &context);
 	  }
 
 
@@ -761,47 +776,47 @@ DEFUN(ieee_slurp_sections,(abfd),
 	{ 
 	  unsigned int section_index;
 	  bfd_vma value;
-	  next_byte(abfd);
-	  section_index = must_parse_int(abfd);
+	  next_byte(ieee);
+	  section_index = must_parse_int(ieee);
 	  if (section_index > ieee->section_count) {
 	    ieee->section_count = section_index;
 	  }
 	  ieee->section_table[section_index]->alignment_power =
-	    bfd_log2(must_parse_int(abfd));
-	  (void)parse_int(abfd, & value);
+	    bfd_log2(must_parse_int(ieee));
+	  (void)parse_int(ieee, & value);
 	}
 	break;
       case ieee_e2_first_byte_enum: 
 	{
-	  ieee_record_enum_type t = read_2bytes(abfd);
+	  ieee_record_enum_type t = read_2bytes(ieee);
 	  switch (t) {
 	  case ieee_section_size_enum:
-	    section = ieee->section_table[must_parse_int(abfd)];
-	    section->size = must_parse_int(abfd);
+	    section = ieee->section_table[must_parse_int(ieee)];
+	    section->size = must_parse_int(ieee);
 	    break;
 	  case ieee_physical_region_size_enum:
-	    section = ieee->section_table[must_parse_int(abfd)];
-	    section->size = must_parse_int(abfd);
+	    section = ieee->section_table[must_parse_int(ieee)];
+	    section->size = must_parse_int(ieee);
 	    break;
 	  case ieee_region_base_address_enum:
-	    section = ieee->section_table[must_parse_int(abfd)];
-	    section->vma = must_parse_int(abfd);
+	    section = ieee->section_table[must_parse_int(ieee)];
+	    section->vma = must_parse_int(ieee);
 	    break;
 	  case ieee_mau_size_enum:
-	    must_parse_int(abfd);
-	    must_parse_int(abfd);
+	    must_parse_int(ieee);
+	    must_parse_int(ieee);
 	    break;
 	  case ieee_m_value_enum:
-	    must_parse_int(abfd);
-	    must_parse_int(abfd);
+	    must_parse_int(ieee);
+	    must_parse_int(ieee);
 	    break;
 	  case ieee_section_base_address_enum:
-	    section = ieee->section_table[must_parse_int(abfd)];
-	    section->vma = must_parse_int(abfd);
+	    section = ieee->section_table[must_parse_int(ieee)];
+	    section->vma = must_parse_int(ieee);
 	    break;
 	  case ieee_section_offset_enum:
-	    (void) must_parse_int(abfd);
-	    (void) must_parse_int(abfd);
+	    (void) must_parse_int(ieee);
+	    (void) must_parse_int(ieee);
 	    break;
 	  default:
 	    return;
@@ -822,21 +837,25 @@ bfd_target *
 DEFUN(ieee_archive_p,(abfd),
       bfd *abfd)
 {
+  return 0;			
+#if 0
   char *library;
   boolean loop;
   ieee_ar_data_type *ar;
   unsigned int i;
-  return 0;			/* FIXME */
+
+
+/* FIXME */
   ieee_seek(abfd, (file_ptr) 0);
   if (this_byte(abfd) != Module_Beginning) return (bfd_target*)NULL;
-  next_byte(abfd);
-  library= read_id(abfd);
+  next_byte(ieee);
+  library= read_id(ieee);
   if (strcmp(library , "LIBRARY") != 0) {
     free(library);
     return (bfd_target *)NULL;
   }
   /* Throw away the filename */
-  free( read_id(abfd));
+  free( read_id(ieee));
   /* This must be an IEEE archive, so we'll buy some space to do
      things */
   ar = (ieee_ar_data_type *) malloc(sizeof(ieee_ar_data_type));
@@ -845,9 +864,9 @@ DEFUN(ieee_archive_p,(abfd),
   ar->element_index = 0;
   obstack_init(&ar->element_obstack);
 
-  next_byte(abfd);		/* Drop the ad part */
-  must_parse_int(abfd);		/* And the two dummy numbers */
-  must_parse_int(abfd);
+  next_byte(ieee);		/* Drop the ad part */
+  must_parse_int(ieee);		/* And the two dummy numbers */
+  must_parse_int(ieee);
 
   loop = true;
   /* Read the index of the BB table */
@@ -855,8 +874,8 @@ DEFUN(ieee_archive_p,(abfd),
     ieee_ar_obstack_type t; 
     int rec =read_2bytes(abfd);
     if (rec ==ieee_assign_value_to_variable_enum) {
-      int record_number = must_parse_int(abfd);
-      t.file_offset = must_parse_int(abfd);
+      int record_number = must_parse_int(ieee);
+      t.file_offset = must_parse_int(ieee);
       t.abfd = (bfd *)NULL;
       ar->element_count++;
       obstack_grow(&ar->element_obstack, (PTR)&t, sizeof(t));
@@ -871,34 +890,28 @@ DEFUN(ieee_archive_p,(abfd),
 
   for (i = 2; i < ar->element_count; i++) {
     ieee_seek(abfd, ar->elements[i].file_offset);
-    next_byte(abfd);		/* Drop F8 */
-    next_byte(abfd);		/* Drop 14 */
-    must_parse_int(abfd);	/* Drop size of block */
-    if (must_parse_int(abfd) != 0) {
+    next_byte(ieee);		/* Drop F8 */
+    next_byte(ieee);		/* Drop 14 */
+    must_parse_int(ieee);	/* Drop size of block */
+    if (must_parse_int(ieee) != 0) {
       /* This object has been deleted */
       ar->elements[i].file_offset = 0;
     }
     else {
-      ar->elements[i].file_offset = must_parse_int(abfd);
+      ar->elements[i].file_offset = must_parse_int(ieee);
     }
   }
 
   obstack_finish(&ar->element_obstack);
   return abfd->xvec;
+#endif
 }
 
 static boolean
 DEFUN(ieee_mkobject,(abfd),
       bfd *abfd)
 {
-  struct obstack tmp_obstack;
-  ieee_data_type *ieee;
-
-  obstack_init(&tmp_obstack);
-  BFD_ASSERT(ieee_data(abfd) == 0);
-  set_tdata (abfd, obstack_alloc(&tmp_obstack,sizeof(ieee_data_type)));
-  ieee = ieee_data(abfd);
-  ieee->ieee_obstack = tmp_obstack;
+  ieee_data(abfd) = (ieee_data_type *)bfd_alloc(abfd,sizeof(ieee_data_type));
   return true;
 }
 
@@ -909,17 +922,17 @@ DEFUN(ieee_object_p,(abfd),
   char *processor;
   unsigned int part;
   ieee_data_type *ieee;
-  char buffer[300];
-
+  uint8e_type buffer[300];
+  ieee_data_type *save = ieee_data(abfd);
   set_tdata (abfd, 0);
   ieee_mkobject(abfd);
   ieee = ieee_data(abfd);
   
   /* Read the first few bytes in to see if it makes sense */
-  bfd_read(buffer, 1, sizeof(buffer), abfd);
+  bfd_read((PTR)buffer, 1, sizeof(buffer), abfd);
 
-  ptr(abfd)= buffer;
-  if (*(ptr(abfd)++) != Module_Beginning) goto fail;
+  ieee->input_p = buffer;
+  if (this_byte_and_next(ieee) != Module_Beginning) goto fail;
 
   ieee->read_symbols= false;
   ieee->read_data= false;
@@ -928,45 +941,46 @@ DEFUN(ieee_object_p,(abfd),
   ieee->external_symbol_min_index = IEEE_PUBLIC_BASE;
   ieee->external_reference_min_index =IEEE_REFERENCE_BASE;
   ieee->external_reference_max_index = 0;
+  ieee->abfd = abfd;
   memset((PTR)ieee->section_table, 0,	 sizeof(ieee->section_table));
 
-  processor = ieee->mb.processor = read_id(abfd);
+  processor = ieee->mb.processor = read_id(ieee);
   if (strcmp(processor,"LIBRARY") == 0) goto fail;
-  ieee->mb.module_name = read_id(abfd);
+  ieee->mb.module_name = read_id(ieee);
   if (abfd->filename == (char *)NULL) {
     abfd->filename =  ieee->mb.module_name;
   }
   /* Determine the architecture and machine type of the object file.  */
   bfd_scan_arch_mach(processor, &abfd->obj_arch, &abfd->obj_machine);
 
-  if (this_byte(abfd) != ieee_address_descriptor_enum) {
+  if (this_byte(ieee) != ieee_address_descriptor_enum) {
     goto fail;
   }
-  next_byte(abfd);	
+  next_byte(ieee);	
 
-  if (parse_int(abfd, &ieee->ad.number_of_bits_mau) == false) {
+  if (parse_int(ieee, &ieee->ad.number_of_bits_mau) == false) {
     goto fail;
   }
-  if(parse_int(abfd, &ieee->ad.number_of_maus_in_address) == false) {
+  if(parse_int(ieee, &ieee->ad.number_of_maus_in_address) == false) {
     goto fail;
   }
 
   /* If there is a byte order info, take it */
-  if (this_byte(abfd) == ieee_variable_L_enum ||
-      this_byte(abfd) == ieee_variable_M_enum)
-    next_byte(abfd);
+  if (this_byte(ieee) == ieee_variable_L_enum ||
+      this_byte(ieee) == ieee_variable_M_enum)
+    next_byte(ieee);
 
 
   for (part = 0; part < N_W_VARIABLES; part++) {
     boolean ok;
-    if (read_2bytes(abfd) != ieee_assign_value_to_variable_enum) {
+    if (read_2bytes(ieee) != ieee_assign_value_to_variable_enum) {
       goto fail;
     }
-    if (this_byte_and_next(abfd) != part)  {
+    if (this_byte_and_next(ieee) != part)  {
       goto fail;
     }
 
-    ieee->w.offset[part] = parse_i(abfd, &ok);
+    ieee->w.offset[part] = parse_i(ieee, &ok);
     if (ok==false) {
       goto fail;
     }
@@ -979,15 +993,16 @@ DEFUN(ieee_object_p,(abfd),
    quickly. We can work out how big the file is from the trailer
    record */
 
-  ieee_data(abfd)->first_byte = ieee_malloc(abfd, ieee->w.r.me_record
+  ieee_data(abfd)->first_byte = (uint8e_type *) bfd_alloc(ieee->abfd, ieee->w.r.me_record
 					    + 50);
   bfd_seek(abfd, 0, 0);
-  bfd_read(ieee_data(abfd)->first_byte, 1,   ieee->w.r.me_record+50,  abfd);
+  bfd_read((PTR)(ieee_data(abfd)->first_byte), 1,   ieee->w.r.me_record+50,  abfd);
 
   ieee_slurp_sections(abfd);
   return abfd->xvec;
  fail:
-  obstack_finish(&ieee->ieee_obstack);
+  (void)  bfd_release(abfd, ieee);
+  ieee_data(abfd) = save;
   return (bfd_target *)NULL;
 }
 
@@ -1014,16 +1029,20 @@ DEFUN(ieee_print_symbol,(ignore_abfd, file,  symbol, how),
       {
 	CONST char *section_name = symbol->section == (asection *)NULL ?
 	  "*abs" : symbol->section->name;
+	if (symbol->name[0] == ' ') {
+	  fprintf(file,"* empty table entry ");
+	}
+	else {
+	  bfd_print_symbol_vandf((PTR)file,symbol);
 
-	bfd_print_symbol_vandf((void *)file,symbol);
-
-	fprintf(file," %-5s %04x %02x %s",
-		section_name,
-		(unsigned)	      ieee_symbol(symbol)->index,
-		(unsigned)	      0, /*
+	  fprintf(file," %-5s %04x %02x %s",
+		  section_name,
+		  (unsigned)	      ieee_symbol(symbol)->index,
+		  (unsigned)	      0, /*
 					   aout_symbol(symbol)->desc & 0xffff,
 					   aout_symbol(symbol)->other  & 0xff,*/
-		symbol->name);
+		  symbol->name);
+	}
       }
     break;
   }
@@ -1052,7 +1071,7 @@ DEFUN(ieee_slurp_section_data,(abfd),
 
   for (s = abfd->sections; s != (asection *)NULL; s = s->next) {
     ieee_per_section_type *per = (ieee_per_section_type *) s->used_by_bfd;
-    per->data = (bfd_byte *) ieee_malloc(abfd, s->size);
+    per->data = (bfd_byte *) bfd_alloc(ieee->abfd, s->size);
     /*SUPPRESS 68*/
     per->reloc_tail_ptr =
       (ieee_reloc_type **)&(s->relocation);
@@ -1061,15 +1080,15 @@ DEFUN(ieee_slurp_section_data,(abfd),
 
 
   while (true) {
-    switch (this_byte(abfd)) 
+    switch (this_byte(ieee)) 
       {
 	/* IF we see anything strange then quit */
       default:
 	return true;
 
       case ieee_set_current_section_enum:
-	next_byte(abfd);
-	section_number = must_parse_int(abfd);
+	next_byte(ieee);
+	section_number = must_parse_int(ieee);
 	s = ieee->section_table[section_number];
 	current_map = (ieee_per_section_type *) s->used_by_bfd;
 	location_ptr = current_map->data - s->vma;
@@ -1083,19 +1102,19 @@ DEFUN(ieee_slurp_section_data,(abfd),
 	{
 	  unsigned int number_of_maus;
 	  unsigned int i;
-	  next_byte(abfd);
-	  number_of_maus = must_parse_int(abfd);
+	  next_byte(ieee);
+	  number_of_maus = must_parse_int(ieee);
 
 	  for (i = 0; i < number_of_maus; i++) {
-	    location_ptr[current_map->pc++]= this_byte(abfd);
-	    next_byte(abfd);
+	    location_ptr[current_map->pc++]= this_byte(ieee);
+	    next_byte(ieee);
 	  }
 	}
 	break;
 
       case ieee_e2_first_byte_enum:
-	next_byte(abfd);
-	switch (this_byte(abfd))
+	next_byte(ieee);
+	switch (this_byte(ieee))
 	  {
 	  case ieee_set_current_pc_enum & 0xff:
 	    {
@@ -1104,9 +1123,10 @@ DEFUN(ieee_slurp_section_data,(abfd),
 	      ieee_symbol_index_type symbol;
 	      unsigned int extra;
 	      boolean pcrel;
-	      next_byte(abfd);
-	      must_parse_int(abfd); /* Thow away section #*/
-	      parse_expression(abfd, &value, &dsection, &symbol, &pcrel, &extra);
+	      next_byte(ieee);
+	      must_parse_int(ieee); /* Thow away section #*/
+	      parse_expression(ieee, &value, &dsection, &symbol,
+			       &pcrel, &extra);
 	      current_map->pc = value;
 	      BFD_ASSERT((unsigned)(value - s->vma) <= s->size);
 	    }
@@ -1115,7 +1135,6 @@ DEFUN(ieee_slurp_section_data,(abfd),
 	  case ieee_value_starting_address_enum & 0xff:
 	    /* We've got to the end of the data now - */
 	    return true;
-	    break;
 	  default:
 	    BFD_FAIL();
 	    return true;
@@ -1124,10 +1143,10 @@ DEFUN(ieee_slurp_section_data,(abfd),
       case ieee_load_with_relocation_enum:
 	{
 	  boolean loop = true;
-	  next_byte(abfd);
+	  next_byte(ieee);
 	  while (loop) 
 	    {
-	      switch (this_byte(abfd)) 
+	      switch (this_byte(ieee)) 
 		{
 		case ieee_variable_R_enum:
 
@@ -1135,75 +1154,93 @@ DEFUN(ieee_slurp_section_data,(abfd),
 		case ieee_function_unsigned_open_b_enum:
 		case ieee_function_either_open_b_enum:
 		  {
-		    unsigned int extra;
-		    boolean pcrel;
+		    unsigned int extra = 4;
+		    boolean pcrel = false;
 
-		    ieee_reloc_type *r =
-		      (ieee_reloc_type *) ieee_malloc(abfd,
-				      sizeof(ieee_reloc_type));
+		    ieee_reloc_type *r = 
+		      (ieee_reloc_type *) bfd_alloc(ieee->abfd,
+						    sizeof(ieee_reloc_type));
 
 		    *(current_map->reloc_tail_ptr) = r;
 		    current_map->reloc_tail_ptr= &r->next;
 		    r->next = (ieee_reloc_type *)NULL;
-		    next_byte(abfd);
-		    parse_expression(abfd,
-			 &r->relent.addend,
-			 &r->relent.section,
-			 &r->symbol,
-			 &pcrel,
-			 &extra);
+		    next_byte(ieee);
+		    parse_expression(ieee,
+				     &r->relent.addend,
+				     &r->relent.section,
+				     &r->symbol,
+				     &pcrel, &extra);
 		    r->relent.address = current_map->pc;
 		    s->reloc_count++;
-		    switch (this_byte(abfd)) {
+		    switch (this_byte(ieee)) {
 		    case ieee_function_signed_close_b_enum:
-		      next_byte(abfd);
+		      next_byte(ieee);
 		      break;
 		    case ieee_function_unsigned_close_b_enum:
-		      next_byte(abfd);
+		      next_byte(ieee);
 		      break;
 		    case ieee_function_either_close_b_enum:
-		      next_byte(abfd);
+		      next_byte(ieee);
 		      break;
 		    default:
 		      break;
 		    }
 		    /* Build a relocation entry for this type */
-		    if (this_byte(abfd) == ieee_comma) {
-
-		      next_byte(abfd);
+		    if (this_byte(ieee) == ieee_comma) {
+		      next_byte(ieee);
 		      /* Fetch number of bytes to pad */
-		      extra = must_parse_int(abfd);
-		      BFD_FAIL();
-		    }
-		    switch (extra) {
-		    case 0:
-		    case 4:
-		      location_ptr[current_map->pc++] = 0;
-		      location_ptr[current_map->pc++] = 0;
-		      location_ptr[current_map->pc++] = 0;
-		      location_ptr[current_map->pc++] = 0;
-		      r->relent.howto = &abs32_howto;
-		      break;
-		    case 2:
-		      location_ptr[current_map->pc++] = 0;
-		      location_ptr[current_map->pc++] = 0;
-		      r->relent.howto = &abs16_howto;
-		      break;
-
-		    default:
-		      BFD_FAIL();
-		      break;
-		    }
+		      extra = must_parse_int(ieee);
+		    };
+		   
+		    /* If pc rel then stick -ve pc into instruction
+		       and take out of reloc*/
+		    
+		    switch (extra) 
+			{
+			case 0:
+			case 4:
+			  if (pcrel == true) 
+			      {
+				bfd_putlong(abfd, -current_map->pc, location_ptr +
+					    current_map->pc);
+				r->relent.howto = &rel32_howto;
+				r->relent.addend -= current_map->pc;
+			      }
+			  else 
+			      {
+				bfd_putlong(abfd, 0, location_ptr +
+					    current_map->pc);
+				r->relent.howto = &abs32_howto;
+			      }
+			  current_map->pc +=4;
+			  break;
+			case 2:
+			  if (pcrel == true) {
+			    bfd_putshort(abfd, (int)(-current_map->pc),  location_ptr +current_map->pc);
+			    r->relent.addend -= current_map->pc;
+			    r->relent.howto = &rel16_howto;
+			  }
+			  else {
+			    bfd_putshort(abfd, 0,  location_ptr +current_map->pc);
+			    r->relent.howto = &abs16_howto;
+			  }
+			  current_map->pc +=2;
+			  break;
+
+			default:
+			  BFD_FAIL();
+			  break;
+			}
 		  }
 		  break;
 		default: 
 		  {
 		    bfd_vma this_size ;
-		    if (parse_int(abfd, &this_size) == true) {
+		    if (parse_int(ieee, &this_size) == true) {
 		      unsigned int i;
 		      for (i = 0; i < this_size; i++) {
-			location_ptr[current_map->pc ++] = this_byte(abfd);
-			next_byte(abfd);
+			location_ptr[current_map->pc ++] = this_byte(ieee);
+			next_byte(ieee);
 		      }
 		    }
 		    else {
@@ -1225,7 +1262,7 @@ DEFUN(ieee_new_section_hook,(abfd, newsect),
       asection *newsect)
 {
   newsect->used_by_bfd = (PTR)
-    ieee_malloc(abfd, sizeof(ieee_per_section_type));
+    bfd_alloc(abfd, sizeof(ieee_per_section_type));
   ieee_per_section( newsect)->data = (bfd_byte *)NULL;
   ieee_per_section(newsect)->section = newsect;
   return true;
@@ -1245,9 +1282,9 @@ static boolean
 DEFUN(ieee_get_section_contents,(abfd, section, location, offset, count),
       bfd *abfd AND
       sec_ptr section AND
-      void  *location AND
+      PTR location AND
       file_ptr offset AND
-      unsigned      int count)
+      int count)
 {
   ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;
   ieee_slurp_section_data(abfd);
@@ -1263,7 +1300,7 @@ DEFUN(ieee_canonicalize_reloc,(abfd, section, relptr, symbols),
       arelent **relptr AND
       asymbol **symbols)
 {
-  ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;
+/*  ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;*/
   ieee_reloc_type *src = (ieee_reloc_type *)(section->relocation);
   ieee_data_type *ieee = ieee_data(abfd);
 
@@ -1387,12 +1424,11 @@ DEFUN(ieee_write_data_part,(abfd),
 	unsigned int relocs_to_go = s->reloc_count;
 	size_t current_byte_index = 0;
 
-
 	/* Sort the reloc records so we can insert them in the correct
 	   places */
 	if (s->reloc_count != 0) {
 	  qsort(s->orelocation,
-		s->reloc_count,
+		relocs_to_go,
 		sizeof(arelent **),
 		comp);
 	}
@@ -1407,21 +1443,21 @@ DEFUN(ieee_write_data_part,(abfd),
 	header[4] = s->index + IEEE_SECTION_NUMBER_BASE;
 	ieee_write_int5(header+5, s->vma );
 	header[10] = ieee_load_with_relocation_enum;
-	bfd_write(header, 1, sizeof(header), abfd);
+	bfd_write((PTR)header, 1, sizeof(header), abfd);
 
 	/* Output the data stream as the longest sequence of bytes
 	   possible, allowing for the a reasonable packet size and
 	   relocation stuffs */
 
-	if (stream == (void *)NULL) {
+	if ((PTR)stream == (PTR)NULL) {
 	  /* Outputting a section without data, fill it up */
-	  stream = ieee_malloc(abfd, s->size);
-	  memset(stream, 0, s->size);
+	  stream = (uint8e_type *)(bfd_alloc(abfd, s->size));
+	  memset((PTR)stream, 0, s->size);
 	}
 	while (current_byte_index < s->size) {
 	  size_t run;
 	  unsigned int MAXRUN = 32;
-	  if (p && *p) {
+	  if (relocs_to_go) {
 	    run = (*p)->address - current_byte_index;
 	  }
 	  else {
@@ -1434,7 +1470,7 @@ DEFUN(ieee_write_data_part,(abfd),
 	  if (run != 0) {
 	    /* Output a stream of bytes */
 	    ieee_write_int(abfd, run);
-	    bfd_write(stream + current_byte_index, 
+	    bfd_write((PTR)(stream + current_byte_index), 
 		      1,
 		      run,
 		      abfd);
@@ -1445,24 +1481,51 @@ DEFUN(ieee_write_data_part,(abfd),
 	    while (relocs_to_go && (*p) && (*p)->address == current_byte_index) {
 
 	      arelent *r = *p;
+	      bfd_vma ov;
+	      if (r->howto->pc_relative) {
+		r->addend += current_byte_index;
+	      }
+
+	      switch (r->howto->size) {
+	      case 2:
+
+		ov = bfd_getlong(abfd,
+				 stream+current_byte_index);
+	    current_byte_index +=4;
+		break;
+	      case 1:
+		ov = bfd_getshort(abfd,
+				  stream+current_byte_index);
+	    current_byte_index +=2;
+		break;
+	      default:
+		BFD_FAIL();
+	      }
 	      ieee_write_byte(abfd, ieee_function_either_open_b_enum);
+
 	      if (r->sym_ptr_ptr != (asymbol **)NULL) {
-		ieee_write_expression(abfd, r->addend,
+		ieee_write_expression(abfd, r->addend + ov,
 				      r->section,
-				      *(r->sym_ptr_ptr));
+				      *(r->sym_ptr_ptr),
+				      r->howto->pc_relative, s->target_index);
 	      }
 	      else {
-		ieee_write_expression(abfd, r->addend,
+		ieee_write_expression(abfd, r->addend + ov,
 				      r->section,
-				      (asymbol *)NULL);
+				      (asymbol *)NULL,
+				      r->howto->pc_relative, s->target_index);
 	      }
 	      ieee_write_byte(abfd,
 			      ieee_function_either_close_b_enum);
+	      if (r->howto->size != 2) {
+	      ieee_write_byte(abfd, ieee_comma);
+	      ieee_write_int(abfd, 1<< r->howto->size);
+	    }
+
 	      relocs_to_go --;
 	      p++;
 	    }
-	    /* FIXME !! Are all relocations 4 bytes ? */
-	    current_byte_index += 4;
+
 	  }
 	}
       }
@@ -1478,7 +1541,7 @@ DEFUN(init_for_output,(abfd),
   asection *s; 
   for (s = abfd->sections; s != (asection *)NULL; s = s->next) {
     if (s->size != 0) {
-      ieee_per_section(s)->data = (bfd_byte *)(ieee_malloc(abfd, s->size));
+      ieee_per_section(s)->data = (bfd_byte *)(bfd_alloc(abfd, s->size));
     }
   }
 }
@@ -1492,7 +1555,7 @@ boolean
 DEFUN(ieee_set_section_contents,(abfd, section, location, offset, count),
       bfd *abfd AND
       sec_ptr section AND
-      unsigned char *location AND
+      PTR location AND
       file_ptr offset AND
       int count)
 {
@@ -1557,14 +1620,14 @@ DEFUN(ieee_write_external_part,(abfd),
 	    ieee_write_expression(abfd,
 				  p->value + p->section->output_offset,
 				  p->section->output_section,
-				  (asymbol *)NULL);
+				  (asymbol *)NULL, false, 0);
 	  }
 	else
 	  {
 	    ieee_write_expression(abfd,
 				  p->value,
 				  (asection *)NULL,
-				  (asymbol *)NULL);
+				  (asymbol *)NULL, false, 0);
 	  }
 	p->value = public_index;
 	public_index++;
@@ -1668,144 +1731,7 @@ DEFUN(ieee_make_empty_symbol,(abfd),
 
 }
 
-void
-DEFUN(ieee_reclaim_symbol_table, (abfd),
-      bfd *abfd)
-{
-#if 0
-  asection *section;
-
-  if (!bfd_get_symcount (abfd)) return;
-
-  for (section = abfd->sections; section != NULL; section = section->next)
-    if (section->relocation) {
-      free ((void *)section->relocation);
-      section->relocation = NULL;
-      section->reloc_count = 0;
-    }
 
-  bfd_get_symcount (abfd) = 0;
-  free ((void *)obj_aout_symbols (abfd));
-  obj_aout_symbols (abfd) = (aout_symbol_type *)NULL;
-#endif
-}
-
-
-
-
-/* Obsolete procedural interface; better to look at the cache directly */
-
-/* User should have checked the file flags; perhaps we should return
-BFD_NO_MORE_SYMBOLS if there are none? */
-
-int
-DEFUN(ieee_get_symcount_upper_bound,(abfd),
-      bfd *abfd)
-{
-#if 0
-  /* In case we're doing an output file or something...?  */
-  if (bfd_get_symcount (abfd)) return bfd_get_symcount (abfd);
-
-  return (exec_hdr (abfd)->a_syms) / (sizeof (struct nlist));
-#endif
-return 0;
-}
-
-symindex
-DEFUN(ieee_get_first_symbol,(ignore_abfd),
-      bfd * ignore_abfd)
-{
-  return 0;
-}
-
-symindex
-DEFUN(ieee_get_next_symbol,(abfd, oidx),
-      bfd *abfd AND
-      symindex oidx)
-{
-#if 0
-  if (oidx == BFD_NO_MORE_SYMBOLS) return BFD_NO_MORE_SYMBOLS;
-  return ++oidx >= bfd_get_symcount (abfd) ? BFD_NO_MORE_SYMBOLS :
-  oidx;
-#endif
-return 0;
-}
-
-char *
-ieee_symbol_name (abfd, idx)
-bfd *abfd;
-symindex idx;
-{
-#if 0
-  return (obj_aout_symbols (abfd) + idx)->symbol.name;
-#endif
-return 0;
-}
-
-long
-ieee_symbol_value (abfd, idx)
-bfd *abfd;
-symindex idx;
-{
-#if 0
-  return (obj_aout_symbols (abfd) + idx)->symbol.value;
-#endif
-return 0;
-}
-
-symclass
-ieee_classify_symbol (abfd, idx)
-bfd *abfd;
-symindex idx;
-{
-#if 0
-  aout_symbol_type *sym = obj_aout_symbols (abfd) + idx;
-
-  if ((sym->symbol.flags & BSF_FORT_COMM) != 0)   return bfd_symclass_fcommon;
-  if ((sym->symbol.flags & BSF_GLOBAL) != 0)    return bfd_symclass_global;
-  if ((sym->symbol.flags & BSF_DEBUGGING) != 0)  return bfd_symclass_debugger;
-  if ((sym->symbol.flags & BSF_UNDEFINED) != 0) return bfd_symclass_undefined;
-#endif
-  return bfd_symclass_unknown;
-}
-
-boolean
-ieee_symbol_hasclass (abfd, idx, class)
-bfd *abfd;
-symindex idx;
-symclass class;
-{
-#if 0
-  aout_symbol_type *sym = obj_aout_symbols (abfd) + idx;
-  switch (class) {
-  case bfd_symclass_fcommon:
-    return (sym->symbol.flags & BSF_FORT_COMM) ? true :false;
-  case bfd_symclass_global:
-    return (sym->symbol.flags & BSF_GLOBAL) ? true:false;
-  case bfd_symclass_debugger:
-    return (sym->symbol.flags & BSF_DEBUGGING) ? true:false;;
-  case bfd_symclass_undefined:
-    return (sym->symbol.flags & BSF_UNDEFINED) ? true:false;;
-  default: return false;
-  }
-#endif
-return 0;
-}
-
-
-void
-ieee_reclaim_reloc (ignore_abfd, section)
-bfd *ignore_abfd;
-sec_ptr section;
-{
-#if 0
-  if (section->relocation) {
-    free (section->relocation);
-    section->relocation = NULL;
-    section->reloc_count = 0;
-  }
-#endif
-}
 
 boolean
 ieee_close_and_cleanup (abfd)
@@ -1829,11 +1755,6 @@ bfd *abfd;
     }
 
 
-  if (ieee_data(abfd) != (ieee_data_type *)NULL) {
-    /* FIXME MORE LEAKS */
-
-  }
-
   return true;
 }
 
@@ -1881,10 +1802,9 @@ asymbol **symbols;
 bfd_vma offset;
 char **filename_ptr;
 char **functionname_ptr;
-unsigned int *line_ptr;
+int *line_ptr;
 {
   return false;
-
 }
 
 
@@ -1905,20 +1825,21 @@ struct stat *buf;
   }
 }
 static int 
-DEFUN(ieee_sizeof_headers,(abfd),
-      bfd *abfd)
+DEFUN(ieee_sizeof_headers,(abfd, x),
+      bfd *abfd AND
+      boolean x)
 {
-return 0;
+  return 0;
 }
 
-#define ieee_core_file_failing_command bfd_false
-#define ieee_core_file_failing_signal bfd_false
-#define ieee_core_file_matches_executable_p bfd_false
+#define ieee_core_file_failing_command (char *(*)())(bfd_nullvoidptr)
+#define ieee_core_file_failing_signal (int (*)())bfd_0
+#define ieee_core_file_matches_executable_p ( PROTO(boolean, (*),(bfd *, bfd *)))bfd_false
 #define ieee_slurp_armap bfd_true
 #define ieee_slurp_extended_name_table bfd_true
-#define ieee_truncate_arname bfd_false
-#define ieee_write_armap bfd_false
-#define ieee_get_lineno bfd_false
+#define ieee_truncate_arname (void (*)())bfd_nullvoidptr
+#define ieee_write_armap  (PROTO( boolean, (*),(bfd *, unsigned int, struct orl *, int, int))) bfd_nullvoidptr
+#define ieee_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr
 
 
 /*SUPPRESS 460 */
@@ -1939,10 +1860,10 @@ bfd_target ieee_vec =
   _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* data */
   _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* hdrs */
 
-  {_bfd_dummy_target,
+  { _bfd_dummy_target,
      ieee_object_p,		/* bfd_check_format */
      ieee_archive_p,
-     bfd_false
+    _bfd_dummy_target,
      },
   {
     bfd_false,
diff --git a/bfd/libbfd.c b/bfd/libbfd.c
index f339092..f278a9c 100644
--- a/bfd/libbfd.c
+++ b/bfd/libbfd.c
@@ -50,11 +50,11 @@ bfd_true (ignore)
   return true;
 }
 
-void *
+PTR
 bfd_nullvoidptr(ignore)
 bfd *ignore;
 {
-  return (void *)NULL;
+  return (PTR)NULL;
 }
 
 int 
diff --git a/bfd/oasys.c b/bfd/oasys.c
index 757a7b2..431f510 100644
--- a/bfd/oasys.c
+++ b/bfd/oasys.c
@@ -23,26 +23,24 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 #define UNDERSCORE_HACK 1
 #define offsetof(type, identifier) (size_t) &(((type *) 0)->identifier) 
-
 #include <ansidecl.h>
+
 #include "sysdep.h"
 #include "bfd.h"
 #include "libbfd.h"
-#include "obstack.h"
 #include "oasys.h"
 #include "liboasys.h"
-
 static void 
 DEFUN(oasys_read_record,(abfd, record),
       bfd *CONST abfd AND 
       oasys_record_union_type *record)
 {
 
-  bfd_read(record, 1, sizeof(record->header), abfd);
+  bfd_read((PTR)record, 1, sizeof(record->header), abfd);
 
   if ((size_t) record->header.length <= (size_t) sizeof (record->header))
     return;
-  bfd_read(((char *)record )+ sizeof(record->header),
+  bfd_read((PTR)(((char *)record )+ sizeof(record->header)),
 	   1, record->header.length - sizeof(record->header),
 	   abfd);
 }
@@ -77,7 +75,6 @@ DEFUN(oasys_slurp_symbol_table,(abfd),
   oasys_record_union_type record;
   oasys_data_type *data = oasys_data(abfd);
   boolean loop = true;
-  asymbol *dest_undefined;
   asymbol *dest_defined;
   asymbol *dest;
   char *string_ptr;
@@ -92,12 +89,12 @@ DEFUN(oasys_slurp_symbol_table,(abfd),
 #ifdef UNDERSCORE_HACK
   /* buy 1 more char for each symbol to keep the underscore in*/
   data->strings = bfd_alloc(abfd, data->symbol_string_length +
-			       abfd->symcount);
+			    abfd->symcount);
 #else
   data->strings = bfd_alloc(abfd, data->symbol_string_length);
 #endif
 
-  dest_undefined = data->symbols;
+
   dest_defined = data->symbols + abfd->symcount -1;
 
   string_ptr = data->strings;
@@ -137,7 +134,7 @@ DEFUN(oasys_slurp_symbol_table,(abfd),
 	    }
 	    break;
 	  case RELOCATION_TYPE_UND:
-	    dest = data->symbols + bfd_h_getshort(abfd, &record.symbol.refno[0]);
+	    dest = data->symbols + bfd_h_getshort(abfd, (bfd_byte *)&record.symbol.refno[0]);
 	    dest->section = (asection *)NULL;
 	    dest->flags = BSF_UNDEFINED;
 	    break;
@@ -176,7 +173,7 @@ DEFUN(oasys_slurp_symbol_table,(abfd),
 
 }
 
-static size_t
+static unsigned int
 DEFUN(oasys_get_symtab_upper_bound,(abfd),
      bfd *CONST abfd)
 {
@@ -222,7 +219,7 @@ DEFUN(oasys_archive_p,(abfd),
   bfd_seek(abfd, (file_ptr) 0, false);
 
   
-  bfd_read(&header, 1, sizeof(header), abfd);
+  bfd_read((PTR)&header, 1, sizeof(header), abfd);
 
   
   swap(header.version);
@@ -266,8 +263,7 @@ DEFUN(oasys_archive_p,(abfd),
 
     bfd_seek(abfd , header.mod_tbl_offset, SEEK_SET);
     for (i = 0; i < header.mod_count; i++) {
-
-      bfd_read(&record, 1, sizeof(record), abfd);
+      bfd_read((PTR)&record, 1, sizeof(record), abfd);
       swap(record.mod_size);
       swap(record.file_offset);
       swap(record.mod_name_length);
@@ -304,6 +300,7 @@ DEFUN(oasys_object_p,(abfd),
       bfd *abfd)
 {
   oasys_data_type *oasys;
+  oasys_data_type *save = oasys_data(abfd);
   boolean loop = true;
   boolean had_usefull = false;
 
@@ -393,6 +390,7 @@ DEFUN(oasys_object_p,(abfd),
 
  fail:
   (void)  bfd_release(abfd, oasys);
+  oasys_data(abfd) = save;
   return (bfd_target *)NULL;
 }
 
@@ -852,6 +850,7 @@ DEFUN(oasys_write_end,(abfd),
       bfd *CONST abfd)
 {
   oasys_end_record_type end;
+  uint8e_type null = 0;
   end.relb = RELOCATION_TYPE_ABS;
   bfd_h_putlong(abfd, abfd->start_address, end.entry); 
   bfd_h_putshort(abfd, 0, end.fill);
@@ -860,6 +859,7 @@ DEFUN(oasys_write_end,(abfd),
 		     oasys_record_is_end_enum,
 		     (oasys_record_union_type *)&end,
 		     sizeof(end));
+  bfd_write((PTR)&null, 1, 1, abfd);
 }
 
 static int 
@@ -1081,7 +1081,6 @@ DEFUN(oasys_make_empty_symbol,(abfd),
 
 
 
-/* Obsbolete procedural interface; better to look at the cache directly */
 
 /* User should have checked the file flags; perhaps we should return
 BFD_NO_MORE_SYMBOLS if there are none? */
@@ -1185,20 +1184,22 @@ DEFUN(oasys_generic_stat_arch_elt,(abfd, buf),
 }
 
 static int 
-DEFUN(oasys_sizeof_headers,(abfd),
-      bfd *abfd)
+DEFUN(oasys_sizeof_headers,(abfd, exec),
+      bfd *abfd AND
+      boolean exec)
 {
 return 0;
 }
 
-#define oasys_core_file_failing_command bfd_false
-#define oasys_core_file_failing_signal bfd_false
-#define oasys_core_file_matches_executable_p bfd_false
-#define oasys_slurp_armap bfd_false
-#define oasys_slurp_extended_name_table bfd_false
-#define oasys_truncate_arname bfd_false
-#define oasys_write_armap bfd_false
-#define oasys_get_lineno bfd_false
+#define oasys_core_file_failing_command (char *(*)())(bfd_nullvoidptr)
+#define oasys_core_file_failing_signal (int (*)())bfd_0
+#define oasys_core_file_matches_executable_p  0 /*(PROTO(boolean, (*),(bfd*, bfd*)))bfd_false*/
+#define oasys_slurp_armap bfd_true
+#define oasys_slurp_extended_name_table bfd_true
+#define oasys_truncate_arname (void (*)())bfd_nullvoidptr
+#define oasys_write_armap 0 /* (PROTO( boolean, (*),(bfd *, unsigned int, struct orl *, int, int))) bfd_nullvoidptr*/
+#define oasys_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr
+
 
 
 
@@ -1223,7 +1224,7 @@ bfd_target oasys_vec =
   {_bfd_dummy_target,
      oasys_object_p,		/* bfd_check_format */
      oasys_archive_p,
-     bfd_false
+ _bfd_dummy_target,
      },
   {
     bfd_false,
diff --git a/bfd/srec.c b/bfd/srec.c
index fe4fa7c..b5123ea 100644
--- a/bfd/srec.c
+++ b/bfd/srec.c
@@ -42,7 +42,11 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 /* $Id$
  * $Log$
- * Revision 1.6  1991/04/25 04:06:21  gnu
+ * Revision 1.7  1991/05/08 19:21:47  steve
+ * Various portability lints.
+ * Fixed reloc bug in ieee and oasys.
+ *
+ * Revision 1.6  1991/04/25  04:06:21  gnu
  * Fix minor pointer type problems that "cc" complains about.
  *
  * Revision 1.5  1991/04/23  22:44:14  steve
@@ -213,7 +217,7 @@ asection *section;
 
       bytes_on_line = HEX(&buffer.size);
     
-      bfd_read(buffer.u.data, 1 , bytes_on_line * 2, abfd);
+      bfd_read((PTR)buffer.u.data, 1 , bytes_on_line * 2, abfd);
 
       switch (buffer.type) {
       case '6':
@@ -380,7 +384,7 @@ int bytes_to_do;
     data++;
 
     * ( (char *)(data)) = '\n';
-    bfd_write(&buffer, 1, (char *)data - (char *)&buffer + 1 , abfd);
+    bfd_write((PTR)&buffer, 1, (char *)data - (char *)&buffer + 1 , abfd);
 
     bytes_written += bytes_this_chunk;
     location += bytes_this_chunk;
@@ -427,13 +431,7 @@ return 0;
 }
 
 /*SUPPRESS 460 */
-#define srec_core_file_failing_command bfd_false
-#define srec_core_file_failing_signal bfd_false
-#define srec_core_file_matches_executable_p bfd_false
-#define srec_slurp_armap bfd_false
-#define srec_slurp_extended_name_table bfd_false
-#define srec_truncate_arname bfd_false
-#define srec_write_armap bfd_false
+
 #define srec_new_section_hook bfd_false
 #define srec_get_symtab_upper_bound bfd_false
 #define srec_get_symtab bfd_false
@@ -441,11 +439,22 @@ return 0;
 #define srec_canonicalize_reloc bfd_false
 #define srec_make_empty_symbol bfd_false
 #define srec_print_symbol bfd_false
-#define srec_get_lineno bfd_false
+
 #define srec_openr_next_archived_file bfd_false
 #define srec_find_nearest_line bfd_false
 #define srec_generic_stat_arch_elt bfd_false
 
+
+#define srec_core_file_failing_command (char *(*)())(bfd_nullvoidptr)
+#define srec_core_file_failing_signal (int (*)())bfd_0
+#define srec_core_file_matches_executable_p (PROTO(boolean, (*),(bfd*, bfd*)))bfd_false
+#define srec_slurp_armap bfd_true
+#define srec_slurp_extended_name_table bfd_true
+#define srec_truncate_arname (void (*)())bfd_nullvoidptr
+#define srec_write_armap  (PROTO( boolean, (*),(bfd *, unsigned int, struct orl *, int, int))) bfd_nullvoidptr
+#define srec_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr
+
+
 bfd_target srec_vec =
 {
   "srec",			/* name */
diff --git a/bfd/sunos.c b/bfd/sunos.c
index b714bf9..35f2d4f 100644
--- a/bfd/sunos.c
+++ b/bfd/sunos.c
@@ -1273,7 +1273,9 @@ swap_std_reloc_out (abfd, g, natptr)
   else {
     r_extern = 0;
     if (g->section == NULL) {
-      BFD_ASSERT(0);
+      /* It is possible to have a reloc with nothing, we generate an
+	 abs + 0 */
+      r_addend = 0;
       r_index = N_ABS | N_EXT;
     }
     else  if(g->section->output_section == obj_textsec(abfd)) {