Lint (detected on hp300bsd & sconix)

2 files changed, 479 insertions, 295 deletions

diff --git a/bfd/coffcode.h b/bfd/coffcode.h
index 01a2ffa..6f1af86 100644
--- a/bfd/coffcode.h
+++ b/bfd/coffcode.h
@@ -421,7 +421,8 @@ DEFUN(bfd_swap_reloc_in,(abfd, reloc_src, reloc_dst),
 #endif
 
 #ifdef SWAP_IN_RELOC_OFFSET
-  reloc_dst->r_offset = SWAP_IN_RELOC_OFFSET(abfd, reloc_src->r_offset);
+  reloc_dst->r_offset = SWAP_IN_RELOC_OFFSET(abfd,
+					     (bfd_byte *) reloc_src->r_offset);
 #endif
 }
 
@@ -3168,42 +3169,24 @@ DEFUN(coff_slurp_reloc_table,(abfd, asect, symbols),
       bfd_swap_reloc_in(abfd, src, &dst);
 
 
+#ifdef RELOC_PROCESSING
+      RELOC_PROCESSING(cache_ptr, &dst, symbols, abfd, asect);
+#else
+
+      cache_ptr->address = dst.r_vaddr;
+
       if (dst.r_symndx != -1) 
       {
-	cache_ptr->sym_ptr_ptr = symbols + obj_convert(abfd)[dst.r_symndx];
+	  cache_ptr->sym_ptr_ptr = symbols + obj_convert(abfd)[dst.r_symndx];
+	  ptr = *(cache_ptr->sym_ptr_ptr);
       }
       else 
       {
-	cache_ptr->sym_ptr_ptr = 0;
-	ptr = 0;
-	goto puke_logic;
+	  cache_ptr->sym_ptr_ptr = 0;
+	  ptr = 0;
 	      
       }
-	    
-#ifdef A29K
-      /* AMD has two relocation entries for the 'consth' instruction.
-       * The first is R_IHIHALF (part 1), the second is R_IHCONST
-       * (part 2).  The second entry's r_symndx does not contain
-       * an index to a symbol but rather a value (apparently).
-       * Also, see the ifdef below for saving the r_symndx value in addend.
-       */
-      if (dst.r_type == R_IHCONST)  {
-	  ptr = NULL;
-	} 
-      else
-#endif
-	     ptr = *(cache_ptr->sym_ptr_ptr);
-	    cache_ptr->address = dst.r_vaddr;
-	    /*
-	      The symbols definitions that we have read in have been
-	      relocated as if their sections started at 0. But the offsets
-	      refering to the symbols in the raw data have not been
-	      modified, so we have to have a negative addend to compensate.
-	      
-	      Note that symbols which used to be common must be left alone */
 
-    puke_logic:
-      cache_ptr->address = dst.r_vaddr;
       /*
 	The symbols definitions that we have read in have been
 	relocated as if their sections started at 0. But the offsets
@@ -3220,7 +3203,9 @@ DEFUN(coff_slurp_reloc_table,(abfd, asect, symbols),
 
       /* Fill in the cache_ptr->howto field from dst.r_type */
       RTYPE2HOWTO(cache_ptr, dst);
-    }
+#endif
+
+  }
 
   asect->relocation = reloc_cache;
   return true;
diff --git a/bfd/srec.c b/bfd/srec.c
index 442ab0e..226d6f2 100644
--- a/bfd/srec.c
+++ b/bfd/srec.c
@@ -1,6 +1,6 @@
 /* BFD backend for s-record objects.
    Copyright (C) 1990-1991 Free Software Foundation, Inc.
-   Written by Steve Chamberlain of Cygnus Support <steve@cygnus.com>.
+   Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
 
 This file is part of BFD, the Binary File Descriptor library.
 
@@ -18,83 +18,138 @@ 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.  */
 
-/* S-records cannot hold anything but addresses and data, so that's all
-   that we implement.
-   
-   The only interesting thing is that s-records may come out of order and
-   there is no header, so an initial scan is required to discover the
-   minimum and maximum addresses used to create the vma and size of the
-   only section we create.  We arbitrarily call this section ".text".
-
-   When bfd_get_section_contents is called the file is read again, and
-   this time the data is placed into a bfd_alloc'd area.
+/*
+SUBSECTION
+	S-record handling
 
-   Any number of sections may be created for output, we just output them
-   in the order provided to bfd_set_section_contents.  */
+DESCRIPTION
+	
+	S-records cannot hold anything but addresses and data, so
+	that's all that we implement.
+   
+	The only interesting thing is that s-records may come out of
+	order and there is no header, so an initial scan is required
+	to discover the minimum and maximum addresses used to create
+	the vma and size of the only section we create.  We
+	arbitrarily call this section ".text". 
+
+	When bfd_get_section_contents is called the file is read
+	again, and this time the data is placed into a bfd_alloc'd
+	area.
+
+	Any number of sections may be created for output, we save them
+	up and output them when it's time to close the bfd.
+
+	An s record looks like:
+	
+EXAMPLE
+	S<length><type><address><data><checksum>
+	
+DESCRIPTION
+	Where
+	o length
+	is the number of bytes following upto the checksum. Note that
+	this is not the number of chars following, since it takes two
+	chars to represent a byte.
+	o type
+	is one of:
+	0) header record
+	1) two byte address data record
+	2) three byte address data record
+	3) four byte address data record
+	7) four byte address termination record
+	8) three byte address termination record
+	9) two byte address termination record
+	
+	o address
+	is the start address of the data following, or in the case of
+	a termination record, the start address of the image
+	o data
+	is the data.
+	o checksum
+	is the sum of all the raw byte data in the record, from the length
+	upwards, modulo 256 and subtracted from 255.
+	
+*/
 
-#include <sysdep.h>
 #include "bfd.h"
+#include "sysdep.h"
 #include "libbfd.h"
 
-
 static char digs[] = "0123456789ABCDEF";
 
-/* Macros for converting between hex and binary */
+/* Horrible ascii dependent macros for converting between hex and
+   binary */
+
+#define CHARS_IN_SET 256
+static char hex_value[CHARS_IN_SET];
+#define NOT_HEX 20
+#define NIBBLE(x) hex_value[x]
+#define HEX(buffer) ((NIBBLE((buffer)[0])<<4) + NIBBLE((buffer)[1]))
+#define TOHEX(d,x, ch) \
+d[1] = digs[(x) & 0xf]; \
+d[0] = digs[((x)>>4)&0xf]; ch += (x & 0xff);
+#define	ISHEX(x)  (hex_value[x] != NOT_HEX)
 
-#define NIBBLE(x) (((x) >= '0' && (x) <= '9') ? ((x) - '0') : ((x) - 'A' + 10))
-#define HEX(buffer) ((NIBBLE((buffer)->high) <<4) + NIBBLE((buffer)->low))
-#define TOHEX(d,x) \
-  ((d)->low = digs[(x) & 0xf], (d)->high = digs[((x)>>4)&0xf], (x))
-#define	ISHEX(x)  (((x) >= '0' && (x) <= '9') || ((x) >= 'A' && (x) <= 'F'))
 
-typedef struct {
-  char high;
-  char low;
-} byte_as_two_char_type;
+
+static 
+DEFUN_VOID(srec_init) 
+{
+    unsigned int i;
+    static boolean inited = false;
+    
+    if (inited == false) 
+    {
+	
+	inited = true;
+	
+	for (i = 0; i < CHARS_IN_SET; i++) 
+	{
+	    hex_value[i] = NOT_HEX;
+	}
+    
+	for (i = 0; i < 10; i++) 
+	{
+	    hex_value[i + '0'] = i;
+	
+	}
+	for (i = 0; i < 6; i++) 
+	{
+	    hex_value[i + 'a'] = i+10;
+	    hex_value[i + 'A'] = i+10;
+	}
+    }    
+}
+
 
 /* The maximum number of bytes on a line is FF */
 #define MAXCHUNK 0xff 
 /* The number of bytes we fit onto a line on output */
-#define CHUNK 16 
+#define CHUNK 21
+
+/* We cannot output our srecords as we see them, we have to glue them
+   together, this is done in this structure : */
+
+struct srec_data_list_struct
+{
+    unsigned    char *data;
+    bfd_vma where;
+    bfd_size_type size;
+    struct srec_data_list_struct *next;
+    
+} ;
+typedef struct srec_data_list_struct srec_data_list_type;
+
 
-/* The shape of an s-record .. */
 typedef struct 
 {
-  char S;
-  char type;
-  byte_as_two_char_type size;
-  union {
-    struct {
-      byte_as_two_char_type address[4];
-      byte_as_two_char_type data[MAXCHUNK];
-      /* If there isn't MAXCHUNK bytes of data then the checksum will 
-	 appear earlier */
-      byte_as_two_char_type checksum;
-      char nl;
-    } type_3;
-    struct {
-      byte_as_two_char_type address[4];
-      byte_as_two_char_type data[MAXCHUNK];
-      byte_as_two_char_type checksum;
-      char nl;
-    } type_6;
-
-    struct {
-      byte_as_two_char_type address[3];
-      byte_as_two_char_type data[MAXCHUNK];
-      byte_as_two_char_type checksum;
-      char nl;
-    } type_2;
-
-    struct {
-      byte_as_two_char_type address[2];
-      byte_as_two_char_type data[MAXCHUNK];
-      byte_as_two_char_type checksum;
-      char nl;
-    } type_1;
-    byte_as_two_char_type data[MAXCHUNK];
-  } u;
-} srec_type;
+    srec_data_list_type *head;    
+    unsigned int type;
+
+} tdata_type;
+
+
 
 #define enda(x) (x->vma + x->size)
 /* 
@@ -102,18 +157,19 @@ typedef struct
  */
 
 static bfd_vma low,high;
+
 static void
-size_srec(abfd, section, address, raw, length)
-bfd *abfd;
-asection *section;
-bfd_vma address;
-byte_as_two_char_type *raw;
-unsigned int length;
+DEFUN(size_srec,(abfd, section, address, raw, length),
+      bfd *abfd AND
+      asection *section AND
+      bfd_vma address AND
+      bfd_byte *raw AND
+      unsigned int length)
 {
   if (address < low)
     low = address;
   if (address + length > high) 
-    high = address + length;
+    high = address + length -1;
 }
 
 
@@ -122,99 +178,112 @@ unsigned int length;
  */
 
 static void
-fillup(abfd, section, address, raw, length)
-bfd *abfd;
-asection *section;
-bfd_vma address;
-byte_as_two_char_type *raw;
-unsigned int length;
+DEFUN(fillup,(abfd, section, address, raw, length),
+bfd *abfd AND
+asection *section AND
+bfd_vma address AND
+bfd_byte *raw AND
+unsigned int length)
 {
-  unsigned int i;
-  bfd_byte *dst = (bfd_byte *)(section->used_by_bfd) +  address - section->vma;
-  for (i = 0; i < length; i++) {
-    *dst = HEX(raw);
-    dst++;
-    raw++;
-  }
+    unsigned int i;
+    bfd_byte *dst =
+     (bfd_byte *)(section->used_by_bfd) +
+     address - section->vma;
+    /* length -1 because we don't read in the checksum */
+    for (i = 0; i < length -1 ; i++) {
+	    *dst = HEX(raw);
+	    dst++;
+	    raw+=2;
+	}
 }
 
 /* Pass over an s-record file, calling one of the above functions on each
    record.  */
 
 static void
-pass_over(abfd, func, section)
-     bfd *abfd;
-     void (*func)();
-     asection *section;
+DEFUN(pass_over,(abfd, func, section),
+      bfd *abfd AND
+      void (*func)() AND
+      asection *section)
 {
-  unsigned int bytes_on_line;
-  boolean eof = false;
-  bfd_vma address;
-  /* To the front of the file */
-  bfd_seek(abfd, (file_ptr)0, SEEK_SET);
-  while (eof == false)
+    unsigned int bytes_on_line;
+    boolean eof = false;
+    bfd_vma address;
+    /* To the front of the file */
+    bfd_seek(abfd, (file_ptr)0, SEEK_SET);
+    while (eof == false)
     {
-      srec_type buffer;
-
-      /* Find first 'S' */
-      eof =  bfd_read(&buffer.S, 1, 1, abfd) != 1;
-      while (buffer.S != 'S' && !eof) {
-	eof =  bfd_read(&buffer.S, 1, 1, abfd) != 1;
-      }
-      if (eof) break;
-
-      bfd_read(&buffer.type, 1, 3, abfd);
-
-      if (!ISHEX (buffer.size.high) || !ISHEX (buffer.size.low))
-	break;
-      bytes_on_line = HEX(&buffer.size);
-      if (bytes_on_line > MAXCHUNK/2)
-	break;
-    
-      bfd_read((PTR)buffer.u.data, 1 , bytes_on_line * 2, abfd);
-
-      switch (buffer.type) {
-      case '6':
-	/* Prologue - ignore */
-	break;
-
-      case '3':
-	address = (HEX(buffer.u.type_3.address+0) << 24)
-		+ (HEX(buffer.u.type_3.address+1) << 16)
-		+ (HEX(buffer.u.type_3.address+2) << 8) 
-		+ (HEX(buffer.u.type_3.address+3));
-        func(abfd,section, address, buffer.u.type_3.data, bytes_on_line -1);
-	break;
-
-      case '2':
-	address = (HEX(buffer.u.type_2.address+0) << 16)
-		+ (HEX(buffer.u.type_2.address+1) << 8)
-		+ (HEX(buffer.u.type_2.address+2));
-        func(abfd,section, address, buffer.u.type_2.data, bytes_on_line -1);
-	break;
-
-      case '1':
-	address = (HEX(buffer.u.type_1.address+0) << 8) 
-	        + (HEX(buffer.u.type_1.address+1));
-        func(abfd, section, address, buffer.u.type_1.data, bytes_on_line -1);
-	break;
-
-      default:
-	goto end_of_file;
-      }
+	char buffer[MAXCHUNK];
+	char *src = buffer;
+	char type;
+	bfd_vma address = 0;
+
+	/* Find first 'S' */
+	eof =  (boolean)(bfd_read(src, 1, 1, abfd) != 1);
+	while (*src!= 'S' && !eof) {
+		eof = (boolean)(bfd_read(src, 1, 1, abfd) != 1);
+	    }
+	if (eof) break;
+	src++;
+
+	/* Fetch the type and the length */
+	bfd_read(src, 1, 3, abfd);
+
+	type = *src++;
+
+	if (!ISHEX (src[0]) || !ISHEX (src[1]))
+	 break;
+
+	bytes_on_line = HEX(src);
+
+	if (bytes_on_line > MAXCHUNK/2)
+	 break;
+	src+=2 ;
+
+	bfd_read(src, 1 , bytes_on_line * 2, abfd);
+
+	switch (type) {
+	      case '0':
+	      case '5':
+		/* Prologue - ignore */
+		break;
+	     case '3':
+		address = HEX(src);
+		src+=2;
+		bytes_on_line--;
+		
+	      case '2':
+		address = HEX(src) | (address<<8) ;
+		src+=2;
+		bytes_on_line--;
+	      case '1':
+		address = HEX(src) | (address<<8) ;
+		src+=2;
+		address = HEX(src) | (address<<8) ;
+		src+=2;
+		bytes_on_line-=2;
+		func(abfd,section, address, src, bytes_on_line);
+		break;
+	      default:
+		return;
+	    }
     }
-  end_of_file: ;
+
 }
 
 
-bfd_target *
-srec_object_p (abfd)
-bfd *abfd;
+
+static bfd_target *
+DEFUN(srec_object_p, (abfd),
+      bfd *abfd)
 {
   char b[4];
   asection *section;
+  srec_init();
+  
   bfd_seek(abfd, (file_ptr)0, SEEK_SET);
   bfd_read(b, 1, 4, abfd);
+
   if (b[0] != 'S' || !ISHEX(b[1]) || !ISHEX(b[2]) || !ISHEX(b[3]))
     return (bfd_target*) NULL;
   
@@ -229,129 +298,255 @@ bfd *abfd;
   pass_over(abfd, size_srec, section);
   section->size = high - low;
   section->vma = low;
+  section->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
+  
   return abfd->xvec;
 }
 
 
 static boolean
-srec_get_section_contents (abfd, section, location, offset, count)
-bfd *abfd;
-sec_ptr section;
-void  *location;
-file_ptr offset;
-unsigned      int count;
+DEFUN(srec_get_section_contents,(abfd, section, location, offset, count),
+      bfd *abfd AND
+      asection *section AND
+      PTR location AND
+      file_ptr offset AND
+      bfd_size_type count)
 {
-  if (section->used_by_bfd == (PTR)NULL) {
-    section->used_by_bfd = (PTR)bfd_alloc (abfd, section->size);
-    pass_over(abfd, fillup, section);
-  }
-  (void) memcpy((PTR)location, (PTR)((char *)(section->used_by_bfd) + offset), count);
-  return true;
+    if (section->used_by_bfd == (PTR)NULL) 
+    {
+	section->used_by_bfd = (PTR)bfd_alloc (abfd, section->size);
+	pass_over(abfd, fillup, section);
+    }
+    (void) memcpy((PTR)location,
+		  (PTR)((char *)(section->used_by_bfd) + offset),
+		  count);
+    return true;
 }
       
 
 
 boolean
-srec_set_arch_mach (abfd, arch, machine)
-bfd *abfd;
-enum bfd_architecture arch;
-unsigned long machine;
+DEFUN(srec_set_arch_mach,(abfd, arch, machine),
+      bfd *abfd AND
+      enum bfd_architecture arch AND
+      unsigned long machine)
 {
-  abfd->obj_arch = arch;
-  abfd->obj_machine = machine;
-  return true;
+  return bfd_default_set_arch_mach(abfd, arch, machine);
 }
 
 
+/* we have to save up all the Srecords for a splurge before output,
+   also remember   */
 
-boolean
-srec_set_section_contents (abfd, section, location, offset, bytes_to_do)
-bfd *abfd;
-sec_ptr section;
-unsigned char *location;
-file_ptr offset;
-int bytes_to_do;
+static boolean
+DEFUN(srec_set_section_contents,(abfd, section, location, offset, bytes_to_do),
+      bfd *abfd AND
+      sec_ptr section AND
+      PTR location AND
+      file_ptr offset AND
+      bfd_size_type bytes_to_do)
 {
-  bfd_vma address;
-  int bytes_written;
-
-  int type;
-  unsigned int i;
-  srec_type buffer;
-  bytes_written = 0;
-  if (section->vma <= 0xffff) 
-    type = 1;
-  else if (section->vma <= 0xffffff) 
-    type = 2;
-  else
-    type = 3;
-
-  buffer.S = 'S';
-  buffer.type = '0' + type;
-
-  while (bytes_written < bytes_to_do) {
-    unsigned int size;
-    unsigned int check_sum;
-    byte_as_two_char_type *data; 
- unsigned   int bytes_this_chunk = bytes_to_do - bytes_written;
-
-    if (bytes_this_chunk > CHUNK) {
-      bytes_this_chunk = CHUNK;
+    tdata_type  *tdata = (tdata_type *)(abfd->tdata);
+    srec_data_list_type *entry = (srec_data_list_type *)
+     bfd_alloc(abfd, sizeof(srec_data_list_type));
+    unsigned  char *data = (unsigned char *) bfd_alloc(abfd, bytes_to_do);
+    memcpy(data, location, bytes_to_do);
+
+    if ((section->vma + offset + bytes_to_do) <= 0xffff)  
+    {
+
+    }
+    else if ((section->vma + offset + bytes_to_do) <= 0xffffff 
+	     && tdata->type < 2) 
+    {
+	tdata->type = 2;
     }
+    else 
+    {
+	tdata->type = 3;
+    }
+
+    entry->data = data;
+    entry->where = section->vma + offset;
+    entry->size = bytes_to_do;
+    entry->next = tdata->head;
+    tdata->head = entry;
+    
+}
+
+/* Write a record of type, of the supplied number of bytes. The
+   supplied bytes and length don't have a checksum. That's worked out
+   here
+*/
+static
+void DEFUN(srec_write_record,(abfd, type, address, data, end),
+	   bfd *abfd AND
+	   char type AND
+	   bfd_vma address AND
+	   CONST unsigned char *data AND
+	   CONST unsigned char *end)
+
+{
+    char buffer[MAXCHUNK];
+    
+    unsigned int check_sum = 0;
+    unsigned CONST char *src = data;
+    char *dst =buffer;
+    char *length;
+    
+
+    *dst++ = 'S';
+    *dst++ = '0' + type;
+
+    length = dst;
+    dst+=2;			/* leave room for dst*/
+    
+    switch (type) 
+    {
+      case 3:
+      case 7:
+	TOHEX(dst, (address >> 24), check_sum);
+	dst+=2;
+      case 8:
+      case 2:
+	TOHEX(dst, (address >> 16), check_sum);
+	dst+=2;
+      case 9:
+      case 1:
+      case 0:
+	TOHEX(dst, (address >> 8), check_sum);
+	dst+=2;
+	TOHEX(dst, (address), check_sum);
+	dst+=2;
+	break;
 
-    address = section->vma + offset + bytes_written;
-
-    switch (type) {
-    case 3:
-      check_sum = TOHEX(buffer.u.type_3.address, address >> 24);
-      check_sum += TOHEX(buffer.u.type_3.address+1, address >> 16);
-      check_sum += TOHEX(buffer.u.type_3.address+2, address >> 8);
-      check_sum += TOHEX(buffer.u.type_3.address+3, address >> 0);
-      size = bytes_this_chunk + 5;
-      data = buffer.u.type_3.data;
-      break;
-    case 2:
-      check_sum = TOHEX(buffer.u.type_3.address, address >> 16);
-      check_sum += TOHEX(buffer.u.type_3.address+1, address >> 8);
-      check_sum += TOHEX(buffer.u.type_3.address+2, address >> 0);
-      size = bytes_this_chunk + 4;
-      data = buffer.u.type_2.data;
-      break;
-
-    case 1:
-      check_sum = TOHEX(buffer.u.type_3.address+0, address >> 8);
-      check_sum += TOHEX(buffer.u.type_3.address+1, address >> 0);
-      size = bytes_this_chunk + 3;
-      data = buffer.u.type_1.data;
-      break;
     }
+    for (src = data; src < end; src++) 
+    {
+	TOHEX(dst, *src, check_sum);
+	dst+=2;
 
-    for (i = 0; i < bytes_this_chunk; i++) {
-      check_sum += TOHEX(data, (location[i]));
-      data++;
     }
 
-    check_sum += TOHEX(&(buffer.size), size );
-    (void) TOHEX(data, ~check_sum);
-    data++;
+    /* Fill in the length */
+    TOHEX(length, (dst - length)/2, check_sum);
+    check_sum &= 0xff;
+    check_sum = 255 - check_sum;
+    TOHEX(dst, check_sum, check_sum);
+    dst+=2;
+    
+    *dst ++ = '\n';
+    bfd_write((PTR)buffer, 1, dst - buffer , abfd);
+}
 
-    * ( (char *)(data)) = '\n';
-    bfd_write((PTR)&buffer, 1, (char *)data - (char *)&buffer + 1 , abfd);
 
-    bytes_written += bytes_this_chunk;
-    location += bytes_this_chunk;
-  }
 
+static void
+DEFUN(srec_write_header,(abfd),
+      bfd *abfd)
+{
+    unsigned char buffer[MAXCHUNK];
+    unsigned char *dst = buffer;
+    unsigned int i;
 
-  return true;
+    /* I'll put an arbitary 40 char limit on header size */
+    for (i = 0; i < 40 && abfd->filename[i];  i++) 
+    {
+	*dst++ = abfd->filename[i];
+    }
+    srec_write_record(abfd,0, 0, buffer, dst);
 }
 
-boolean
-srec_write_object_contents (abfd)
-     bfd *abfd;
+static void
+DEFUN(srec_write_section,(abfd, tdata, list),
+       bfd *abfd AND
+       tdata_type *tdata AND
+       srec_data_list_type *list)
+{
+    unsigned int bytes_written = 0;
+    unsigned char *location = list->data;
+
+    while (bytes_written < list->size)
+    {
+	char buffer[MAXCHUNK];
+	char *dst = buffer;
+	bfd_vma address;
+	unsigned int i;
+	
+	unsigned int bytes_this_chunk = list->size - bytes_written;
+
+	if (bytes_this_chunk > CHUNK) 
+	{
+	    bytes_this_chunk = CHUNK;
+	}
+
+	address = list->where +  bytes_written;
+
+	srec_write_record(abfd,
+			  tdata->type,
+			  address,
+			  location,
+			  location + bytes_this_chunk);
+
+	bytes_written += bytes_this_chunk;
+	location += bytes_this_chunk;
+    }
+
+}
+
+static void
+DEFUN(srec_write_terminator,(abfd, tdata),
+      bfd *abfd AND
+      tdata_type *tdata)
+{
+    unsigned    char buffer[2];
+    
+    srec_write_record(abfd, 10 - tdata->type,
+		      abfd->start_address, buffer, buffer);
+
+
+}
+static boolean
+DEFUN(srec_mkobject, (abfd), 
+      bfd *abfd)
+{
+    tdata_type *tdata = (tdata_type *)bfd_alloc(abfd,  sizeof(tdata_type));
+    abfd->tdata = (PTR)tdata;
+    tdata->type = 1;
+    tdata->head = (srec_data_list_type *)NULL;
+    return true;
+    
+}
+
+      
+static boolean
+DEFUN(srec_write_object_contents,(abfd),
+     bfd *abfd)
 {
-  bfd_write("S9030000FC\n", 1,11,abfd);
-  return true;
+    bfd_vma address;
+    int bytes_written;
+    
+    int type;
+    unsigned int i;
+    tdata_type *tdata = (tdata_type *)(abfd->tdata);
+    srec_data_list_type *list;
+
+    bytes_written = 0;
+
+
+    
+    srec_write_header(abfd);
+    
+    /* Now wander though all the sections provided and output them */
+    list = tdata->head;
+
+    while (list != (srec_data_list_type*)NULL) 
+    {
+	srec_write_section(abfd, tdata, list); 
+	list = list->next;
+    }
+    srec_write_terminator(abfd, tdata);
+    return true;
 }
 
 static int 
@@ -377,7 +572,7 @@ DEFUN(srec_make_empty_symbol, (abfd),
 #define srec_get_reloc_upper_bound (FOO(unsigned int, (*),(bfd*, asection *)))bfd_false
 #define srec_canonicalize_reloc (FOO(unsigned int, (*),(bfd*,asection *, arelent **, asymbol **))) bfd_0
 
-#define srec_print_symbol (FOO(void,(*),(bfd *, PTR, asymbol *, bfd_print_symbol_enum_type))) bfd_void
+#define srec_print_symbol (FOO(void,(*),(bfd *, PTR, asymbol *, bfd_print_symbol_type))) bfd_void
 
 #define srec_openr_next_archived_file (FOO(bfd *, (*), (bfd*,bfd*))) bfd_nullvoidptr
 #define srec_find_nearest_line (FOO(boolean, (*),(bfd*,asection*,asymbol**,bfd_vma, CONST char**, CONST char**, unsigned int *))) bfd_false
@@ -390,7 +585,7 @@ DEFUN(srec_make_empty_symbol, (abfd),
 #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  (FOO( boolean, (*),(bfd *, unsigned int, struct orl *, int, int))) bfd_nullvoidptr
+#define srec_write_armap  (FOO( boolean, (*),(bfd *, unsigned int, struct orl *, unsigned int, int))) bfd_nullvoidptr
 #define srec_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr
 #define	srec_close_and_cleanup	bfd_generic_close_and_cleanup
 #define srec_bfd_debug_info_start bfd_void
@@ -400,37 +595,41 @@ DEFUN(srec_make_empty_symbol, (abfd),
 
 bfd_target srec_vec =
 {
-  "srec",			/* name */
-  bfd_target_srec_flavour_enum,
-  true,				/* target byte order */
-  true,				/* target headers byte order */
-  (HAS_RELOC | EXEC_P |		/* object flags */
-   HAS_LINENO | HAS_DEBUG |
-   HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
-  (SEC_CODE|SEC_DATA|SEC_ROM|SEC_HAS_CONTENTS
-   |SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
-  ' ',				/* ar_pad_char */
-  16,				/* ar_max_namelen */
+    "srec",			/* name */
+    bfd_target_srec_flavour,
+    true,			/* target byte order */
+    true,			/* target headers byte order */
+    (HAS_RELOC | EXEC_P |	/* object flags */
+     HAS_LINENO | HAS_DEBUG |
+     HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
+    (SEC_CODE|SEC_DATA|SEC_ROM|SEC_HAS_CONTENTS
+     |SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
+    ' ',			/* 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_dummy_target,
-       srec_object_p,		/* bfd_check_format */
-       (struct bfd_target *(*)()) bfd_nullvoidptr,
-       (struct bfd_target *(*)())     bfd_nullvoidptr,
-     },
-    {
+    _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,
+      srec_object_p,		/* bfd_check_format */
+      (struct bfd_target *(*)()) bfd_nullvoidptr,
+      (struct bfd_target *(*)())     bfd_nullvoidptr,
+  },
+  {
       bfd_false,
-      bfd_true,			/* mkobject */
+      srec_mkobject,
       _bfd_generic_mkarchive,
       bfd_false,
-    },
-    {				/* bfd_write_contents */
+  },
+  {				/* bfd_write_contents */
       bfd_false,
       srec_write_object_contents,
       _bfd_write_archive_contents,
       bfd_false,
-    },
-  JUMP_TABLE(srec)
-  };
+  },
+    JUMP_TABLE(srec)
+ };
+