WebSVN – Kolibri OS – Diff – /contrib/toolchain/binutils/bfd/srec.c


/* BFD back-end for s-record objects.
 
 
   Copyright (C) 1990-2015 Free Software Foundation, Inc.
   Written by Steve Chamberlain of Cygnus Support .
 
   This file is part of BFD, the Binary File Descriptor library.
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   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., 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */
 
 
/* SUBSECTION
	S-Record handling
 
   DESCRIPTION
 
	Ordinary 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
 
   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.
 
   SUBSECTION
	Symbol S-Record handling
 
   DESCRIPTION
	Some ICE equipment understands an addition to the standard
	S-Record format; symbols and their addresses can be sent
	before the data.
 
	The format of this is:
	($$ 
		(  )*)
	$$
 
	so a short symbol table could look like:
 
   EXAMPLE
	$$ flash.x
	$$ flash.c
	  _port6 $0
	  _delay $4
	  _start $14
	  _etext $8036
	  _edata $8036
 	  _end $8036
	$$
 
   DESCRIPTION
	We allow symbols to be anywhere in the data stream - the module names
	are always ignored.  */
 
#include "sysdep.h"
#include "bfd.h"
#include "libbfd.h"
#include "libiberty.h"
#include "safe-ctype.h"
 
 
/* Macros for converting between hex and binary.  */
 
static const char digs[] = "0123456789ABCDEF";
 
#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_p(x)
 
/* The maximum number of address+data+crc bytes on a line is FF.  */
#define MAXCHUNK 0xff
 
/* Default size for a CHUNK.  */
#define DEFAULT_CHUNK 16
 
/* The number of data bytes we actually fit onto a line on output.
   This variable can be modified by objcopy's --srec-len parameter.
   For a 0x75 byte record you should set --srec-len=0x70.  */
unsigned int Chunk = DEFAULT_CHUNK;
 
/* The type of srec output (free or forced to S3).
   This variable can be modified by objcopy's --srec-forceS3
   parameter.  */
bfd_boolean S3Forced = FALSE;
 
/* When writing an S-record file, the S-records can not be output as
   they are seen.  This structure is used to hold them in memory.  */
 
struct srec_data_list_struct
{
  struct srec_data_list_struct *next;
  bfd_byte *data;
  bfd_vma where;
  bfd_size_type size;
};
 
typedef struct srec_data_list_struct srec_data_list_type;
 
/* When scanning the S-record file, a linked list of srec_symbol
   structures is built to represent the symbol table (if there is
   one).  */
 
struct srec_symbol
{
  struct srec_symbol *next;
  const char *name;
  bfd_vma val;
};
 
/* The S-record tdata information.  */
 
typedef struct srec_data_struct
  {
    srec_data_list_type *head;
    srec_data_list_type *tail;
    unsigned int type;
    struct srec_symbol *symbols;
    struct srec_symbol *symtail;
    asymbol *csymbols;
  }
tdata_type;
 
/* Initialize by filling in the hex conversion array.  */
 
static void
srec_init (void)
{
  static bfd_boolean inited = FALSE;
 
  if (! inited)
    {
      inited = TRUE;
      hex_init ();
    }
}
 
/* Set up the S-record tdata information.  */
 
static bfd_boolean
srec_mkobject (bfd *abfd)
{
  tdata_type *tdata;
 
  srec_init ();
 
  tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type));
  if (tdata == NULL)
    return FALSE;
 
  abfd->tdata.srec_data = tdata;
  tdata->type = 1;
  tdata->head = NULL;
  tdata->tail = NULL;
  tdata->symbols = NULL;
  tdata->symtail = NULL;
  tdata->csymbols = NULL;
 
  return TRUE;
}
 
/* Read a byte from an S record file.  Set *ERRORPTR if an error
   occurred.  Return EOF on error or end of file.  */
 
static int
srec_get_byte (bfd *abfd, bfd_boolean *errorptr)
{
  bfd_byte c;
 
  if (bfd_bread (&c, (bfd_size_type) 1, abfd) != 1)
    {
      if (bfd_get_error () != bfd_error_file_truncated)
	*errorptr = TRUE;
      return EOF;
    }
 
  return (int) (c & 0xff);
}
 
/* Report a problem in an S record file.  FIXME: This probably should
   not call fprintf, but we really do need some mechanism for printing
   error messages.  */
 
static void
srec_bad_byte (bfd *abfd,
	       unsigned int lineno,
	       int c,
	       bfd_boolean error)
{
  if (c == EOF)
    {
      if (! error)
	bfd_set_error (bfd_error_file_truncated);
    }
  else
    {
      char buf[40];
 
      if (! ISPRINT (c))
	sprintf (buf, "\\%03o", (unsigned int) c & 0xff);
      else
	{
	  buf[0] = c;
	  buf[1] = '\0';
	}
      (*_bfd_error_handler)
	(_("%B:%d: Unexpected character `%s' in S-record file\n"),
	 abfd, lineno, buf);
      bfd_set_error (bfd_error_bad_value);
    }
}
 
/* Add a new symbol found in an S-record file.  */
 
static bfd_boolean
srec_new_symbol (bfd *abfd, const char *name, bfd_vma val)
{
  struct srec_symbol *n;
 
  n = (struct srec_symbol *) bfd_alloc (abfd, sizeof (* n));
  if (n == NULL)
    return FALSE;
 
  n->name = name;
  n->val = val;
 
  if (abfd->tdata.srec_data->symbols == NULL)
    abfd->tdata.srec_data->symbols = n;
  else
    abfd->tdata.srec_data->symtail->next = n;
  abfd->tdata.srec_data->symtail = n;
  n->next = NULL;
 
  ++abfd->symcount;
 
  return TRUE;
}
 
/* Read the S record file and turn it into sections.  We create a new
   section for each contiguous set of bytes.  */
 
static bfd_boolean
srec_scan (bfd *abfd)
{
  int c;
  unsigned int lineno = 1;
  bfd_boolean error = FALSE;
  bfd_byte *buf = NULL;
  size_t bufsize = 0;
  asection *sec = NULL;
  char *symbuf = NULL;
 
  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
    goto error_return;
 
  while ((c = srec_get_byte (abfd, &error)) != EOF)
    {
      /* We only build sections from contiguous S-records, so if this
	 is not an S-record, then stop building a section.  */
      if (c != 'S' && c != '\r' && c != '\n')
	sec = NULL;
 
      switch (c)
	{
	default:
	  srec_bad_byte (abfd, lineno, c, error);
	  goto error_return;
 
	case '\n':
	  ++lineno;
	  break;
 
	case '\r':
	  break;
 
	case '$':
	  /* Starting a module name, which we ignore.  */
	  while ((c = srec_get_byte (abfd, &error)) != '\n'
		 && c != EOF)
	    ;
	  if (c == EOF)
	    {
	      srec_bad_byte (abfd, lineno, c, error);
	      goto error_return;
	    }
 
	  ++lineno;
	  break;
 
	case ' ':
	  do
	    {
	      bfd_size_type alc;
	      char *p, *symname;
	      bfd_vma symval;
 
	      /* Starting a symbol definition.  */
	      while ((c = srec_get_byte (abfd, &error)) != EOF
		     && (c == ' ' || c == '\t'))
		;
 
	      if (c == '\n' || c == '\r')
		break;
 
	      if (c == EOF)
		{
		  srec_bad_byte (abfd, lineno, c, error);
		  goto error_return;
		}
 
	      alc = 10;
	      symbuf = (char *) bfd_malloc (alc + 1);
	      if (symbuf == NULL)
		goto error_return;
 
	      p = symbuf;
 
	      *p++ = c;
	      while ((c = srec_get_byte (abfd, &error)) != EOF
		     && ! ISSPACE (c))
		{
		  if ((bfd_size_type) (p - symbuf) >= alc)
		    {
		      char *n;
 
		      alc *= 2;
		      n = (char *) bfd_realloc (symbuf, alc + 1);
		      if (n == NULL)
			goto error_return;
		      p = n + (p - symbuf);
		      symbuf = n;
		    }
 
		  *p++ = c;
		}
 
	      if (c == EOF)
		{
		  srec_bad_byte (abfd, lineno, c, error);
		  goto error_return;
		}
 
	      *p++ = '\0';
	      symname = (char *) bfd_alloc (abfd, (bfd_size_type) (p - symbuf));
	      if (symname == NULL)
		goto error_return;
	      strcpy (symname, symbuf);
	      free (symbuf);
	      symbuf = NULL;
 
	      while ((c = srec_get_byte (abfd, &error)) != EOF
		     && (c == ' ' || c == '\t'))
		;
	      if (c == EOF)
		{
		  srec_bad_byte (abfd, lineno, c, error);
		  goto error_return;
		}
 
	      /* Skip a dollar sign before the hex value.  */
	      if (c == '$')
		{
		  c = srec_get_byte (abfd, &error);
		  if (c == EOF)
		    {
		      srec_bad_byte (abfd, lineno, c, error);
		      goto error_return;
		    }
		}
 
	      symval = 0;
	      while (ISHEX (c))
		{
		  symval <<= 4;
		  symval += NIBBLE (c);
		  c = srec_get_byte (abfd, &error);
		  if (c == EOF)
		    {
		      srec_bad_byte (abfd, lineno, c, error);
		      goto error_return;
		    }
		}
 
	      if (! srec_new_symbol (abfd, symname, symval))
		goto error_return;
	    }
	  while (c == ' ' || c == '\t')
	    ;
 
	  if (c == '\n')
	    ++lineno;
	  else if (c != '\r')
	    {
	      srec_bad_byte (abfd, lineno, c, error);
	      goto error_return;
	    }
 
	  break;
 
	case 'S':
	  {
	    file_ptr pos;
	    unsigned char hdr[3];
	    unsigned int bytes, min_bytes;
	    bfd_vma address;
	    bfd_byte *data;
	    unsigned char check_sum;
 
	    /* Starting an S-record.  */
 
	    pos = bfd_tell (abfd) - 1;
 
	    if (bfd_bread (hdr, (bfd_size_type) 3, abfd) != 3)
	      goto error_return;
 
	    if (! ISHEX (hdr[1]) || ! ISHEX (hdr[2]))
	      {
		if (! ISHEX (hdr[1]))
		  c = hdr[1];
		else
		  c = hdr[2];
		srec_bad_byte (abfd, lineno, c, error);
		goto error_return;
	      }
 
	    check_sum = bytes = HEX (hdr + 1);
	    min_bytes = 3;
	    if (hdr[0] == '2' || hdr[0] == '8')
	      min_bytes = 4;
	    else if (hdr[0] == '3' || hdr[0] == '7')
	      min_bytes = 5;
	    if (bytes < min_bytes)
	      {
		(*_bfd_error_handler) (_("%B:%d: byte count %d too small\n"),
				       abfd, lineno, bytes);
		bfd_set_error (bfd_error_bad_value);
		goto error_return;
	      }
 
	    if (bytes * 2 > bufsize)
	      {
		if (buf != NULL)
		  free (buf);
		buf = (bfd_byte *) bfd_malloc ((bfd_size_type) bytes * 2);
		if (buf == NULL)
		  goto error_return;
		bufsize = bytes * 2;
	      }
 
	    if (bfd_bread (buf, (bfd_size_type) bytes * 2, abfd) != bytes * 2)
	      goto error_return;
 
	    /* Ignore the checksum byte.  */
	    --bytes;
 
	    address = 0;
	    data = buf;
	    switch (hdr[0])
	      {
	      case '0':
	      case '5':
		/* Prologue--ignore the file name, but stop building a
		   section at this point.  */
		sec = NULL;
		break;
 
	      case '3':
		check_sum += HEX (data);
		address = HEX (data);
		data += 2;
		--bytes;
		/* Fall through.  */
	      case '2':
		check_sum += HEX (data);
		address = (address << 8) | HEX (data);
		data += 2;
		--bytes;
		/* Fall through.  */
	      case '1':
		check_sum += HEX (data);
		address = (address << 8) | HEX (data);
		data += 2;
		check_sum += HEX (data);
		address = (address << 8) | HEX (data);
		data += 2;
		bytes -= 2;
 
		if (sec != NULL
		    && sec->vma + sec->size == address)
		  {
		    /* This data goes at the end of the section we are
		       currently building.  */
		    sec->size += bytes;
		  }
		else
		  {
		    char secbuf[20];
		    char *secname;
		    bfd_size_type amt;
		    flagword flags;
 
		    sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
		    amt = strlen (secbuf) + 1;
		    secname = (char *) bfd_alloc (abfd, amt);
		    strcpy (secname, secbuf);
		    flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
		    sec = bfd_make_section_with_flags (abfd, secname, flags);
		    if (sec == NULL)
		      goto error_return;
		    sec->vma = address;
		    sec->lma = address;
		    sec->size = bytes;
		    sec->filepos = pos;
		  }
 
		while (bytes > 0)
		  {
		    check_sum += HEX (data);
		    data += 2;
		    bytes--;
		  }
		check_sum = 255 - (check_sum & 0xff);
		if (check_sum != HEX (data))
		  {
		    (*_bfd_error_handler)
		      (_("%B:%d: Bad checksum in S-record file\n"),
		       abfd, lineno);
		    bfd_set_error (bfd_error_bad_value);
		    goto error_return;
		  }
 
		break;
 
	      case '7':
		check_sum += HEX (data);
		address = HEX (data);
		data += 2;
		/* Fall through.  */
	      case '8':
		check_sum += HEX (data);
		address = (address << 8) | HEX (data);
		data += 2;
		/* Fall through.  */
	      case '9':
		check_sum += HEX (data);
		address = (address << 8) | HEX (data);
		data += 2;
		check_sum += HEX (data);
		address = (address << 8) | HEX (data);
		data += 2;
 
		/* This is a termination record.  */
		abfd->start_address = address;
 
		check_sum = 255 - (check_sum & 0xff);
		if (check_sum != HEX (data))
		  {
		    (*_bfd_error_handler)
		      (_("%B:%d: Bad checksum in S-record file\n"),
		       abfd, lineno);
		    bfd_set_error (bfd_error_bad_value);
		    goto error_return;
		  }
 
		if (buf != NULL)
		  free (buf);
 
		return TRUE;
	      }
	  }
	  break;
	}
    }
 
  if (error)
    goto error_return;
 
  if (buf != NULL)
    free (buf);
 
  return TRUE;
 
 error_return:
  if (symbuf != NULL)
    free (symbuf);
  if (buf != NULL)
    free (buf);
  return FALSE;
}
 
/* Check whether an existing file is an S-record file.  */
 
static const bfd_target *
srec_object_p (bfd *abfd)
{
  void * tdata_save;
  bfd_byte b[4];
 
  srec_init ();
 
  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
      || bfd_bread (b, (bfd_size_type) 4, abfd) != 4)
    return NULL;
 
  if (b[0] != 'S' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
    {
      bfd_set_error (bfd_error_wrong_format);
      return NULL;
    }
 
  tdata_save = abfd->tdata.any;
  if (! srec_mkobject (abfd) || ! srec_scan (abfd))
    {
      if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
	bfd_release (abfd, abfd->tdata.any);
      abfd->tdata.any = tdata_save;
      return NULL;
    }
 
  if (abfd->symcount > 0)
    abfd->flags |= HAS_SYMS;
 
  return abfd->xvec;
}
 
/* Check whether an existing file is an S-record file with symbols.  */
 
static const bfd_target *
symbolsrec_object_p (bfd *abfd)
{
  void * tdata_save;
  char b[2];
 
  srec_init ();
 
  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
      || bfd_bread (b, (bfd_size_type) 2, abfd) != 2)
    return NULL;
 
  if (b[0] != '$' || b[1] != '$')
    {
      bfd_set_error (bfd_error_wrong_format);
      return NULL;
    }
 
  tdata_save = abfd->tdata.any;
  if (! srec_mkobject (abfd) || ! srec_scan (abfd))
    {
      if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
	bfd_release (abfd, abfd->tdata.any);
      abfd->tdata.any = tdata_save;
      return NULL;
    }
 
  if (abfd->symcount > 0)
    abfd->flags |= HAS_SYMS;
 
  return abfd->xvec;
}
 
/* Read in the contents of a section in an S-record file.  */
 
static bfd_boolean
srec_read_section (bfd *abfd, asection *section, bfd_byte *contents)
{
  int c;
  bfd_size_type sofar = 0;
  bfd_boolean error = FALSE;
  bfd_byte *buf = NULL;
  size_t bufsize = 0;
 
  if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0)
    goto error_return;
 
  while ((c = srec_get_byte (abfd, &error)) != EOF)
    {
      bfd_byte hdr[3];
      unsigned int bytes;
      bfd_vma address;
      bfd_byte *data;
 
      if (c == '\r' || c == '\n')
	continue;
 
      /* This is called after srec_scan has already been called, so we
	 ought to know the exact format.  */
      BFD_ASSERT (c == 'S');
 
      if (bfd_bread (hdr, (bfd_size_type) 3, abfd) != 3)
	goto error_return;
 
      BFD_ASSERT (ISHEX (hdr[1]) && ISHEX (hdr[2]));
 
      bytes = HEX (hdr + 1);
 
      if (bytes * 2 > bufsize)
	{
	  if (buf != NULL)
	    free (buf);
	  buf = (bfd_byte *) bfd_malloc ((bfd_size_type) bytes * 2);
	  if (buf == NULL)
	    goto error_return;
	  bufsize = bytes * 2;
	}
 
      if (bfd_bread (buf, (bfd_size_type) bytes * 2, abfd) != bytes * 2)
	goto error_return;
 
      address = 0;
      data = buf;
      switch (hdr[0])
	{
	default:
	  BFD_ASSERT (sofar == section->size);
	  if (buf != NULL)
	    free (buf);
	  return TRUE;
 
	case '3':
	  address = HEX (data);
	  data += 2;
	  --bytes;
	  /* Fall through.  */
	case '2':
	  address = (address << 8) | HEX (data);
	  data += 2;
	  --bytes;
	  /* Fall through.  */
	case '1':
	  address = (address << 8) | HEX (data);
	  data += 2;
	  address = (address << 8) | HEX (data);
	  data += 2;
	  bytes -= 2;
 
	  if (address != section->vma + sofar)
	    {
	      /* We've come to the end of this section.  */
	      BFD_ASSERT (sofar == section->size);
	      if (buf != NULL)
		free (buf);
	      return TRUE;
	    }
 
	  /* Don't consider checksum.  */
	  --bytes;
 
	  while (bytes-- != 0)
	    {
	      contents[sofar] = HEX (data);
	      data += 2;
	      ++sofar;
	    }
 
	  break;
	}
    }
 
  if (error)
    goto error_return;
 
  BFD_ASSERT (sofar == section->size);
 
  if (buf != NULL)
    free (buf);
 
  return TRUE;
 
 error_return:
  if (buf != NULL)
    free (buf);
  return FALSE;
}
 
/* Get the contents of a section in an S-record file.  */
 
static bfd_boolean
srec_get_section_contents (bfd *abfd,
			   asection *section,
			   void * location,
			   file_ptr offset,
			   bfd_size_type count)
{
  if (count == 0)
    return TRUE;
 
  if (offset + count < count
      || offset + count > section->size)
    {
      bfd_set_error (bfd_error_invalid_operation);
      return FALSE;
    }
 
  if (section->used_by_bfd == NULL)
    {
      section->used_by_bfd = bfd_alloc (abfd, section->size);
      if (section->used_by_bfd == NULL)
	return FALSE;
 
      if (! srec_read_section (abfd, section,
                               (bfd_byte *) section->used_by_bfd))
	return FALSE;
    }
 
  memcpy (location, (bfd_byte *) section->used_by_bfd + offset,
	  (size_t) count);
 
  return TRUE;
}
 
/* Set the architecture.  We accept an unknown architecture here.  */
 
static bfd_boolean
srec_set_arch_mach (bfd *abfd, enum bfd_architecture arch, unsigned long mach)
{
  if (arch != bfd_arch_unknown)
    return bfd_default_set_arch_mach (abfd, arch, mach);
 
  abfd->arch_info = & bfd_default_arch_struct;
  return TRUE;
}
 
/* We have to save up all the Srecords for a splurge before output.  */
 
static bfd_boolean
srec_set_section_contents (bfd *abfd,
			   sec_ptr section,
			   const void * location,
			   file_ptr offset,
			   bfd_size_type bytes_to_do)
{
  int opb = bfd_octets_per_byte (abfd);
  tdata_type *tdata = abfd->tdata.srec_data;
  srec_data_list_type *entry;
 
  entry = (srec_data_list_type *) bfd_alloc (abfd, sizeof (* entry));
  if (entry == NULL)
    return FALSE;
 
  if (bytes_to_do
      && (section->flags & SEC_ALLOC)
      && (section->flags & SEC_LOAD))
    {
      bfd_byte *data;
 
      data = (bfd_byte *) bfd_alloc (abfd, bytes_to_do);
      if (data == NULL)
	return FALSE;
      memcpy ((void *) data, location, (size_t) bytes_to_do);
 
      /* Ff S3Forced is TRUE then always select S3 records,
	 regardless of the siez of the addresses.  */
      if (S3Forced)
	tdata->type = 3;
      else if ((section->lma + (offset + bytes_to_do) / opb - 1) <= 0xffff)
	;  /* The default, S1, is OK.  */
      else if ((section->lma + (offset + bytes_to_do) / opb - 1) <= 0xffffff
	       && tdata->type <= 2)
	tdata->type = 2;
      else
	tdata->type = 3;
 
      entry->data = data;
      entry->where = section->lma + offset / opb;
      entry->size = bytes_to_do;
 
      /* Sort the records by address.  Optimize for the common case of
	 adding a record to the end of the list.  */
      if (tdata->tail != NULL
	  && entry->where >= tdata->tail->where)
	{
	  tdata->tail->next = entry;
	  entry->next = NULL;
	  tdata->tail = entry;
	}
      else
	{
	  srec_data_list_type **look;
 
	  for (look = &tdata->head;
	       *look != NULL && (*look)->where < entry->where;
	       look = &(*look)->next)
	    ;
	  entry->next = *look;
	  *look = entry;
	  if (entry->next == NULL)
	    tdata->tail = entry;
	}
    }
  return TRUE;
}
 
/* 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 bfd_boolean
srec_write_record (bfd *abfd,
		   unsigned int type,
		   bfd_vma address,
		   const bfd_byte *data,
		   const bfd_byte *end)
{
  char buffer[2 * MAXCHUNK + 6];
  unsigned int check_sum = 0;
  const bfd_byte *src = data;
  char *dst = buffer;
  char *length;
  bfd_size_type wrlen;
 
  *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;
 
    }
  for (src = data; src < end; src++)
    {
      TOHEX (dst, *src, check_sum);
      dst += 2;
    }
 
  /* 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++ = '\r';
  *dst++ = '\n';
  wrlen = dst - buffer;
 
  return bfd_bwrite ((void *) buffer, wrlen, abfd) == wrlen;
}
 
static bfd_boolean
srec_write_header (bfd *abfd)
{
  unsigned int len = strlen (abfd->filename);
 
  /* I'll put an arbitrary 40 char limit on header size.  */
  if (len > 40)
    len = 40;
 
  return srec_write_record (abfd, 0, (bfd_vma) 0,
			    (bfd_byte *) abfd->filename,
			    (bfd_byte *) abfd->filename + len);
}
 
static bfd_boolean
srec_write_section (bfd *abfd,
		    tdata_type *tdata,
		    srec_data_list_type *list)
{
  unsigned int octets_written = 0;
  bfd_byte *location = list->data;
 
  /* Validate number of data bytes to write.  The srec length byte
     counts the address, data and crc bytes.  S1 (tdata->type == 1)
     records have two address bytes, S2 (tdata->type == 2) records
     have three, and S3 (tdata->type == 3) records have four.
     The total length can't exceed 255, and a zero data length will
     spin for a long time.  */
  if (Chunk == 0)
    Chunk = 1;
  else if (Chunk > MAXCHUNK - tdata->type - 2)
    Chunk = MAXCHUNK - tdata->type - 2;
 
  while (octets_written < list->size)
    {
      bfd_vma address;
      unsigned int octets_this_chunk = list->size - octets_written;
 
      if (octets_this_chunk > Chunk)
	octets_this_chunk = Chunk;
 
      address = list->where + octets_written / bfd_octets_per_byte (abfd);
 
      if (! srec_write_record (abfd,
			       tdata->type,
			       address,
			       location,
			       location + octets_this_chunk))
	return FALSE;
 
      octets_written += octets_this_chunk;
      location += octets_this_chunk;
    }
 
  return TRUE;
}
 
static bfd_boolean
srec_write_terminator (bfd *abfd, tdata_type *tdata)
{
  return srec_write_record (abfd, 10 - tdata->type,
			    abfd->start_address, NULL, NULL);
}
 
static bfd_boolean
srec_write_symbols (bfd *abfd)
{
  /* Dump out the symbols of a bfd.  */
  int i;
  int count = bfd_get_symcount (abfd);
 
  if (count)
    {
      bfd_size_type len;
      asymbol **table = bfd_get_outsymbols (abfd);
 
      len = strlen (abfd->filename);
      if (bfd_bwrite ("$$ ", (bfd_size_type) 3, abfd) != 3
	  || bfd_bwrite (abfd->filename, len, abfd) != len
	  || bfd_bwrite ("\r\n", (bfd_size_type) 2, abfd) != 2)
	return FALSE;
 
      for (i = 0; i < count; i++)
	{
	  asymbol *s = table[i];
	  if (! bfd_is_local_label (abfd, s)
	      && (s->flags & BSF_DEBUGGING) == 0)
	    {
	      /* Just dump out non debug symbols.  */
	      char buf[43], *p;
 
	      len = strlen (s->name);
	      if (bfd_bwrite ("  ", (bfd_size_type) 2, abfd) != 2
		  || bfd_bwrite (s->name, len, abfd) != len)
		return FALSE;
 
	      sprintf_vma (buf + 2, (s->value
				     + s->section->output_section->lma
				     + s->section->output_offset));
	      p = buf + 2;
	      while (p[0] == '0' && p[1] != 0)
		p++;
	      len = strlen (p);
	      p[len] = '\r';
	      p[len + 1] = '\n';
	      *--p = '$';
	      *--p = ' ';
	      len += 4;
	      if (bfd_bwrite (p, len, abfd) != len)
		return FALSE;
	    }
	}
      if (bfd_bwrite ("$$ \r\n", (bfd_size_type) 5, abfd) != 5)
	return FALSE;
    }
 
  return TRUE;
}
 
static bfd_boolean
internal_srec_write_object_contents (bfd *abfd, int symbols)
{
  tdata_type *tdata = abfd->tdata.srec_data;
  srec_data_list_type *list;
 
  if (symbols)
    {
      if (! srec_write_symbols (abfd))
	return FALSE;
    }
 
  if (! srec_write_header (abfd))
    return FALSE;
 
  /* Now wander though all the sections provided and output them.  */
  list = tdata->head;
 
  while (list != (srec_data_list_type *) NULL)
    {
      if (! srec_write_section (abfd, tdata, list))
	return FALSE;
      list = list->next;
    }
  return srec_write_terminator (abfd, tdata);
}
 
static bfd_boolean
srec_write_object_contents (bfd *abfd)
{
  return internal_srec_write_object_contents (abfd, 0);
}
 
static bfd_boolean
symbolsrec_write_object_contents (bfd *abfd)
{
  return internal_srec_write_object_contents (abfd, 1);
}
 
static int
srec_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
		     struct bfd_link_info *info ATTRIBUTE_UNUSED)
{
  return 0;
}
 
/* Return the amount of memory needed to read the symbol table.  */
 
static long
srec_get_symtab_upper_bound (bfd *abfd)
{
  return (bfd_get_symcount (abfd) + 1) * sizeof (asymbol *);
}
 
/* Return the symbol table.  */
 
static long
srec_canonicalize_symtab (bfd *abfd, asymbol **alocation)
{
  bfd_size_type symcount = bfd_get_symcount (abfd);
  asymbol *csymbols;
  unsigned int i;
 
  csymbols = abfd->tdata.srec_data->csymbols;
  if (csymbols == NULL && symcount != 0)
    {
      asymbol *c;
      struct srec_symbol *s;
 
      csymbols = (asymbol *) bfd_alloc (abfd, symcount * sizeof (asymbol));
      if (csymbols == NULL)
	return -1;
      abfd->tdata.srec_data->csymbols = csymbols;
 
      for (s = abfd->tdata.srec_data->symbols, c = csymbols;
	   s != NULL;
	   s = s->next, ++c)
	{
	  c->the_bfd = abfd;
	  c->name = s->name;
	  c->value = s->val;
	  c->flags = BSF_GLOBAL;
	  c->section = bfd_abs_section_ptr;
	  c->udata.p = NULL;
	}
    }
 
  for (i = 0; i < symcount; i++)
    *alocation++ = csymbols++;
  *alocation = NULL;
 
  return symcount;
}
 
static void
srec_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED,
		      asymbol *symbol,
		      symbol_info *ret)
{
  bfd_symbol_info (symbol, ret);
}
 
static void
srec_print_symbol (bfd *abfd,
		   void * afile,
		   asymbol *symbol,
		   bfd_print_symbol_type how)
{
  FILE *file = (FILE *) afile;
 
  switch (how)
    {
    case bfd_print_symbol_name:
      fprintf (file, "%s", symbol->name);
      break;
    default:
      bfd_print_symbol_vandf (abfd, (void *) file, symbol);
      fprintf (file, " %-5s %s",
	       symbol->section->name,
	       symbol->name);
    }
}
 
#define	srec_close_and_cleanup                    _bfd_generic_close_and_cleanup
#define srec_bfd_free_cached_info                 _bfd_generic_bfd_free_cached_info
#define srec_new_section_hook                     _bfd_generic_new_section_hook
#define srec_bfd_is_target_special_symbol         ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
#define srec_bfd_is_local_label_name              bfd_generic_is_local_label_name
#define srec_get_lineno                           _bfd_nosymbols_get_lineno
#define srec_find_nearest_line                    _bfd_nosymbols_find_nearest_line
#define srec_find_line                            _bfd_nosymbols_find_line
#define srec_find_inliner_info                    _bfd_nosymbols_find_inliner_info
#define srec_make_empty_symbol                    _bfd_generic_make_empty_symbol
#define srec_get_symbol_version_string		  _bfd_nosymbols_get_symbol_version_string
#define srec_bfd_make_debug_symbol                _bfd_nosymbols_bfd_make_debug_symbol
#define srec_read_minisymbols                     _bfd_generic_read_minisymbols
#define srec_minisymbol_to_symbol                 _bfd_generic_minisymbol_to_symbol
#define srec_get_section_contents_in_window       _bfd_generic_get_section_contents_in_window
#define srec_bfd_get_relocated_section_contents   bfd_generic_get_relocated_section_contents
#define srec_bfd_relax_section                    bfd_generic_relax_section
#define srec_bfd_gc_sections                      bfd_generic_gc_sections
#define srec_bfd_lookup_section_flags             bfd_generic_lookup_section_flags
#define srec_bfd_merge_sections                   bfd_generic_merge_sections
#define srec_bfd_is_group_section                 bfd_generic_is_group_section
#define srec_bfd_discard_group                    bfd_generic_discard_group
#define srec_section_already_linked               _bfd_generic_section_already_linked
#define srec_bfd_define_common_symbol             bfd_generic_define_common_symbol
#define srec_bfd_link_hash_table_create           _bfd_generic_link_hash_table_create
 
#define srec_bfd_link_add_symbols                 _bfd_generic_link_add_symbols
#define srec_bfd_link_just_syms                   _bfd_generic_link_just_syms
#define srec_bfd_copy_link_hash_symbol_type \
  _bfd_generic_copy_link_hash_symbol_type
#define srec_bfd_final_link                       _bfd_generic_final_link
#define srec_bfd_link_split_section               _bfd_generic_link_split_section
 
const bfd_target srec_vec =
{
  "srec",			/* Name.  */
  bfd_target_srec_flavour,
  BFD_ENDIAN_UNKNOWN,		/* Target byte order.  */
  BFD_ENDIAN_UNKNOWN,		/* Target headers byte order.  */
  (HAS_RELOC | EXEC_P |		/* Object flags.  */
   HAS_LINENO | HAS_DEBUG |
   HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
  (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
   | SEC_ALLOC | SEC_LOAD | SEC_RELOC),	/* Section flags.  */
  0,				/* Leading underscore.  */
  ' ',				/* AR_pad_char.  */
  16,				/* AR_max_namelen.  */
  0,				/* match priority.  */
  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,
    srec_object_p,		/* bfd_check_format.  */
    _bfd_dummy_target,
    _bfd_dummy_target,
  },
  {
    bfd_false,
    srec_mkobject,
    _bfd_generic_mkarchive,
    bfd_false,
  },
  {				/* bfd_write_contents.  */
    bfd_false,
    srec_write_object_contents,
    _bfd_write_archive_contents,
    bfd_false,
  },
 
  BFD_JUMP_TABLE_GENERIC (srec),
  BFD_JUMP_TABLE_COPY (_bfd_generic),
  BFD_JUMP_TABLE_CORE (_bfd_nocore),
  BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
  BFD_JUMP_TABLE_SYMBOLS (srec),
  BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
  BFD_JUMP_TABLE_WRITE (srec),
  BFD_JUMP_TABLE_LINK (srec),
  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 
  NULL,
 
  NULL
};
 
const bfd_target symbolsrec_vec =
{
  "symbolsrec",			/* Name.  */
  bfd_target_srec_flavour,
  BFD_ENDIAN_UNKNOWN,		/* Target byte order.  */
  BFD_ENDIAN_UNKNOWN,		/* Target headers byte order.  */
  (HAS_RELOC | EXEC_P |		/* Object flags.  */
   HAS_LINENO | HAS_DEBUG |
   HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
  (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
   | SEC_ALLOC | SEC_LOAD | SEC_RELOC),	/* Section flags.  */
  0,				/* Leading underscore.  */
  ' ',				/* AR_pad_char.  */
  16,				/* AR_max_namelen.  */
  0,				/* match priority.  */
  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,	/* Headers.  */
 
  {
    _bfd_dummy_target,
    symbolsrec_object_p,	/* bfd_check_format.  */
    _bfd_dummy_target,
    _bfd_dummy_target,
  },
  {
    bfd_false,
    srec_mkobject,
    _bfd_generic_mkarchive,
    bfd_false,
  },
  {				/* bfd_write_contents.  */
    bfd_false,
    symbolsrec_write_object_contents,
    _bfd_write_archive_contents,
    bfd_false,
  },
 
  BFD_JUMP_TABLE_GENERIC (srec),
  BFD_JUMP_TABLE_COPY (_bfd_generic),
  BFD_JUMP_TABLE_CORE (_bfd_nocore),
  BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
  BFD_JUMP_TABLE_SYMBOLS (srec),
  BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
  BFD_JUMP_TABLE_WRITE (srec),
  BFD_JUMP_TABLE_LINK (srec),
  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 
  NULL,
 
  NULL
};

Rev 5197	Rev 6324
1	/* BFD back-end for s-record objects.	1	/* BFD back-end for s-record objects.
2	Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,	-
3	2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2011	-
4	Free Software Foundation, Inc.	2	Copyright (C) 1990-2015 Free Software Foundation, Inc.
5	Written by Steve Chamberlain of Cygnus Support .	3	Written by Steve Chamberlain of Cygnus Support .
6		4
7	This file is part of BFD, the Binary File Descriptor library.	5	This file is part of BFD, the Binary File Descriptor library.
8		6
9	This program is free software; you can redistribute it and/or modify	7	This program is free software; you can redistribute it and/or modify
10	it under the terms of the GNU General Public License as published by	8	it under the terms of the GNU General Public License as published by
11	the Free Software Foundation; either version 3 of the License, or	9	the Free Software Foundation; either version 3 of the License, or
12	(at your option) any later version.	10	(at your option) any later version.
13		11
14	This program is distributed in the hope that it will be useful,	12	This program is distributed in the hope that it will be useful,
15	but WITHOUT ANY WARRANTY; without even the implied warranty of	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	GNU General Public License for more details.	15	GNU General Public License for more details.
18		16
19	You should have received a copy of the GNU General Public License	17	You should have received a copy of the GNU General Public License
20	along with this program; if not, write to the Free Software	18	along with this program; if not, write to the Free Software
21	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,	19	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22	MA 02110-1301, USA. */	20	MA 02110-1301, USA. */
23		21
24		22
25	/* SUBSECTION	23	/* SUBSECTION
26	S-Record handling	24	S-Record handling
27		25
28	DESCRIPTION	26	DESCRIPTION
29		27
30	Ordinary S-Records cannot hold anything but addresses and	28	Ordinary S-Records cannot hold anything but addresses and
31	data, so that's all that we implement.	29	data, so that's all that we implement.
32		30
33	The only interesting thing is that S-Records may come out of	31	The only interesting thing is that S-Records may come out of
34	order and there is no header, so an initial scan is required	32	order and there is no header, so an initial scan is required
35	to discover the minimum and maximum addresses used to create	33	to discover the minimum and maximum addresses used to create
36	the vma and size of the only section we create. We	34	the vma and size of the only section we create. We
37	arbitrarily call this section ".text".	35	arbitrarily call this section ".text".
38		36
39	When bfd_get_section_contents is called the file is read	37	When bfd_get_section_contents is called the file is read
40	again, and this time the data is placed into a bfd_alloc'd	38	again, and this time the data is placed into a bfd_alloc'd
41	area.	39	area.
42		40
43	Any number of sections may be created for output, we save them	41	Any number of sections may be created for output, we save them
44	up and output them when it's time to close the bfd.	42	up and output them when it's time to close the bfd.
45		43
46	An s record looks like:	44	An s record looks like:
47		45
48	EXAMPLE	46	EXAMPLE
49	S	47	S
50		48
51	DESCRIPTION	49	DESCRIPTION
52	Where	50	Where
53	o length	51	o length
54	is the number of bytes following upto the checksum. Note that	52	is the number of bytes following upto the checksum. Note that
55	this is not the number of chars following, since it takes two	53	this is not the number of chars following, since it takes two
56	chars to represent a byte.	54	chars to represent a byte.
57	o type	55	o type
58	is one of:	56	is one of:
59	0) header record	57	0) header record
60	1) two byte address data record	58	1) two byte address data record
61	2) three byte address data record	59	2) three byte address data record
62	3) four byte address data record	60	3) four byte address data record
63	7) four byte address termination record	61	7) four byte address termination record
64	8) three byte address termination record	62	8) three byte address termination record
65	9) two byte address termination record	63	9) two byte address termination record
66		64
67	o address	65	o address
68	is the start address of the data following, or in the case of	66	is the start address of the data following, or in the case of
69	a termination record, the start address of the image	67	a termination record, the start address of the image
70	o data	68	o data
71	is the data.	69	is the data.
72	o checksum	70	o checksum
73	is the sum of all the raw byte data in the record, from the length	71	is the sum of all the raw byte data in the record, from the length
74	upwards, modulo 256 and subtracted from 255.	72	upwards, modulo 256 and subtracted from 255.
75		73
76	SUBSECTION	74	SUBSECTION
77	Symbol S-Record handling	75	Symbol S-Record handling
78		76
79	DESCRIPTION	77	DESCRIPTION
80	Some ICE equipment understands an addition to the standard	78	Some ICE equipment understands an addition to the standard
81	S-Record format; symbols and their addresses can be sent	79	S-Record format; symbols and their addresses can be sent
82	before the data.	80	before the data.
83		81
84	The format of this is:	82	The format of this is:
85	($$	83	($$
86	( )*)	84	( )*)
87	$$	85	$$
88		86
89	so a short symbol table could look like:	87	so a short symbol table could look like:
90		88
91	EXAMPLE	89	EXAMPLE
92	$$ flash.x	90	$$ flash.x
93	$$ flash.c	91	$$ flash.c
94	_port6 $0	92	_port6 $0
95	_delay $4	93	_delay $4
96	_start $14	94	_start $14
97	_etext $8036	95	_etext $8036
98	_edata $8036	96	_edata $8036
99	_end $8036	97	_end $8036
100	$$	98	$$
101		99
102	DESCRIPTION	100	DESCRIPTION
103	We allow symbols to be anywhere in the data stream - the module names	101	We allow symbols to be anywhere in the data stream - the module names
104	are always ignored. */	102	are always ignored. */
105		103
106	#include "sysdep.h"	104	#include "sysdep.h"
107	#include "bfd.h"	105	#include "bfd.h"
108	#include "libbfd.h"	106	#include "libbfd.h"
109	#include "libiberty.h"	107	#include "libiberty.h"
110	#include "safe-ctype.h"	108	#include "safe-ctype.h"
111		109
112		110
113	/* Macros for converting between hex and binary. */	111	/* Macros for converting between hex and binary. */
114		112
115	static const char digs[] = "0123456789ABCDEF";	113	static const char digs[] = "0123456789ABCDEF";
116		114
117	#define NIBBLE(x) hex_value(x)	115	#define NIBBLE(x) hex_value(x)
118	#define HEX(buffer) ((NIBBLE ((buffer)[0])<<4) + NIBBLE ((buffer)[1]))	116	#define HEX(buffer) ((NIBBLE ((buffer)[0])<<4) + NIBBLE ((buffer)[1]))
119	#define TOHEX(d, x, ch) \	117	#define TOHEX(d, x, ch) \
120	d[1] = digs[(x) & 0xf]; \	118	d[1] = digs[(x) & 0xf]; \
121	d[0] = digs[((x)>>4)&0xf]; \	119	d[0] = digs[((x)>>4)&0xf]; \
122	ch += ((x) & 0xff);	120	ch += ((x) & 0xff);
123	#define ISHEX(x) hex_p(x)	121	#define ISHEX(x) hex_p(x)
124		122
125	/* The maximum number of address+data+crc bytes on a line is FF. */	123	/* The maximum number of address+data+crc bytes on a line is FF. */
126	#define MAXCHUNK 0xff	124	#define MAXCHUNK 0xff
127		125
128	/* Default size for a CHUNK. */	126	/* Default size for a CHUNK. */
129	#define DEFAULT_CHUNK 16	127	#define DEFAULT_CHUNK 16
130		128
131	/* The number of data bytes we actually fit onto a line on output.	129	/* The number of data bytes we actually fit onto a line on output.
132	This variable can be modified by objcopy's --srec-len parameter.	130	This variable can be modified by objcopy's --srec-len parameter.
133	For a 0x75 byte record you should set --srec-len=0x70. */	131	For a 0x75 byte record you should set --srec-len=0x70. */
134	unsigned int Chunk = DEFAULT_CHUNK;	132	unsigned int Chunk = DEFAULT_CHUNK;
135		133
136	/* The type of srec output (free or forced to S3).	134	/* The type of srec output (free or forced to S3).
137	This variable can be modified by objcopy's --srec-forceS3	135	This variable can be modified by objcopy's --srec-forceS3
138	parameter. */	136	parameter. */
139	bfd_boolean S3Forced = FALSE;	137	bfd_boolean S3Forced = FALSE;
140		138
141	/* When writing an S-record file, the S-records can not be output as	139	/* When writing an S-record file, the S-records can not be output as
142	they are seen. This structure is used to hold them in memory. */	140	they are seen. This structure is used to hold them in memory. */
143		141
144	struct srec_data_list_struct	142	struct srec_data_list_struct
145	{	143	{
146	struct srec_data_list_struct *next;	144	struct srec_data_list_struct *next;
147	bfd_byte *data;	145	bfd_byte *data;
148	bfd_vma where;	146	bfd_vma where;
149	bfd_size_type size;	147	bfd_size_type size;
150	};	148	};
151		149
152	typedef struct srec_data_list_struct srec_data_list_type;	150	typedef struct srec_data_list_struct srec_data_list_type;
153		151
154	/* When scanning the S-record file, a linked list of srec_symbol	152	/* When scanning the S-record file, a linked list of srec_symbol
155	structures is built to represent the symbol table (if there is	153	structures is built to represent the symbol table (if there is
156	one). */	154	one). */
157		155
158	struct srec_symbol	156	struct srec_symbol
159	{	157	{
160	struct srec_symbol *next;	158	struct srec_symbol *next;
161	const char *name;	159	const char *name;
162	bfd_vma val;	160	bfd_vma val;
163	};	161	};
164		162
165	/* The S-record tdata information. */	163	/* The S-record tdata information. */
166		164
167	typedef struct srec_data_struct	165	typedef struct srec_data_struct
168	{	166	{
169	srec_data_list_type *head;	167	srec_data_list_type *head;
170	srec_data_list_type *tail;	168	srec_data_list_type *tail;
171	unsigned int type;	169	unsigned int type;
172	struct srec_symbol *symbols;	170	struct srec_symbol *symbols;
173	struct srec_symbol *symtail;	171	struct srec_symbol *symtail;
174	asymbol *csymbols;	172	asymbol *csymbols;
175	}	173	}
176	tdata_type;	174	tdata_type;
177		175
178	/* Initialize by filling in the hex conversion array. */	176	/* Initialize by filling in the hex conversion array. */
179		177
180	static void	178	static void
181	srec_init (void)	179	srec_init (void)
182	{	180	{
183	static bfd_boolean inited = FALSE;	181	static bfd_boolean inited = FALSE;
184		182
185	if (! inited)	183	if (! inited)
186	{	184	{
187	inited = TRUE;	185	inited = TRUE;
188	hex_init ();	186	hex_init ();
189	}	187	}
190	}	188	}
191		189
192	/* Set up the S-record tdata information. */	190	/* Set up the S-record tdata information. */
193		191
194	static bfd_boolean	192	static bfd_boolean
195	srec_mkobject (bfd *abfd)	193	srec_mkobject (bfd *abfd)
196	{	194	{
197	tdata_type *tdata;	195	tdata_type *tdata;
198		196
199	srec_init ();	197	srec_init ();
200		198
201	tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type));	199	tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type));
202	if (tdata == NULL)	200	if (tdata == NULL)
203	return FALSE;	201	return FALSE;
204		202
205	abfd->tdata.srec_data = tdata;	203	abfd->tdata.srec_data = tdata;
206	tdata->type = 1;	204	tdata->type = 1;
207	tdata->head = NULL;	205	tdata->head = NULL;
208	tdata->tail = NULL;	206	tdata->tail = NULL;
209	tdata->symbols = NULL;	207	tdata->symbols = NULL;
210	tdata->symtail = NULL;	208	tdata->symtail = NULL;
211	tdata->csymbols = NULL;	209	tdata->csymbols = NULL;
212		210
213	return TRUE;	211	return TRUE;
214	}	212	}
215		213
216	/* Read a byte from an S record file. Set *ERRORPTR if an error	214	/* Read a byte from an S record file. Set *ERRORPTR if an error
217	occurred. Return EOF on error or end of file. */	215	occurred. Return EOF on error or end of file. */
218		216
219	static int	217	static int
220	srec_get_byte (bfd abfd, bfd_boolean errorptr)	218	srec_get_byte (bfd abfd, bfd_boolean errorptr)
221	{	219	{
222	bfd_byte c;	220	bfd_byte c;
223		221
224	if (bfd_bread (&c, (bfd_size_type) 1, abfd) != 1)	222	if (bfd_bread (&c, (bfd_size_type) 1, abfd) != 1)
225	{	223	{
226	if (bfd_get_error () != bfd_error_file_truncated)	224	if (bfd_get_error () != bfd_error_file_truncated)
227	*errorptr = TRUE;	225	*errorptr = TRUE;
228	return EOF;	226	return EOF;
229	}	227	}
230		228
231	return (int) (c & 0xff);	229	return (int) (c & 0xff);
232	}	230	}
233		231
234	/* Report a problem in an S record file. FIXME: This probably should	232	/* Report a problem in an S record file. FIXME: This probably should
235	not call fprintf, but we really do need some mechanism for printing	233	not call fprintf, but we really do need some mechanism for printing
236	error messages. */	234	error messages. */
237		235
238	static void	236	static void
239	srec_bad_byte (bfd *abfd,	237	srec_bad_byte (bfd *abfd,
240	unsigned int lineno,	238	unsigned int lineno,
241	int c,	239	int c,
242	bfd_boolean error)	240	bfd_boolean error)
243	{	241	{
244	if (c == EOF)	242	if (c == EOF)
245	{	243	{
246	if (! error)	244	if (! error)
247	bfd_set_error (bfd_error_file_truncated);	245	bfd_set_error (bfd_error_file_truncated);
248	}	246	}
249	else	247	else
250	{	248	{
251	char buf[10];	249	char buf[40];
252		250
253	if (! ISPRINT (c))	251	if (! ISPRINT (c))
254	sprintf (buf, "\\%03o", (unsigned int) c);	252	sprintf (buf, "\\%03o", (unsigned int) c & 0xff);
255	else	253	else
256	{	254	{
257	buf[0] = c;	255	buf[0] = c;
258	buf[1] = '\0';	256	buf[1] = '\0';
259	}	257	}
260	(*_bfd_error_handler)	258	(*_bfd_error_handler)
261	(_("%B:%d: Unexpected character `%s' in S-record file\n"),	259	(_("%B:%d: Unexpected character `%s' in S-record file\n"),
262	abfd, lineno, buf);	260	abfd, lineno, buf);
263	bfd_set_error (bfd_error_bad_value);	261	bfd_set_error (bfd_error_bad_value);
264	}	262	}
265	}	263	}
266		264
267	/* Add a new symbol found in an S-record file. */	265	/* Add a new symbol found in an S-record file. */
268		266
269	static bfd_boolean	267	static bfd_boolean
270	srec_new_symbol (bfd abfd, const char name, bfd_vma val)	268	srec_new_symbol (bfd abfd, const char name, bfd_vma val)
271	{	269	{
272	struct srec_symbol *n;	270	struct srec_symbol *n;
273		271
274	n = (struct srec_symbol ) bfd_alloc (abfd, sizeof ( n));	272	n = (struct srec_symbol ) bfd_alloc (abfd, sizeof ( n));
275	if (n == NULL)	273	if (n == NULL)
276	return FALSE;	274	return FALSE;
277		275
278	n->name = name;	276	n->name = name;
279	n->val = val;	277	n->val = val;
280		278
281	if (abfd->tdata.srec_data->symbols == NULL)	279	if (abfd->tdata.srec_data->symbols == NULL)
282	abfd->tdata.srec_data->symbols = n;	280	abfd->tdata.srec_data->symbols = n;
283	else	281	else
284	abfd->tdata.srec_data->symtail->next = n;	282	abfd->tdata.srec_data->symtail->next = n;
285	abfd->tdata.srec_data->symtail = n;	283	abfd->tdata.srec_data->symtail = n;
286	n->next = NULL;	284	n->next = NULL;
287		285
288	++abfd->symcount;	286	++abfd->symcount;
289		287
290	return TRUE;	288	return TRUE;
291	}	289	}
292		290
293	/* Read the S record file and turn it into sections. We create a new	291	/* Read the S record file and turn it into sections. We create a new
294	section for each contiguous set of bytes. */	292	section for each contiguous set of bytes. */
295		293
296	static bfd_boolean	294	static bfd_boolean
297	srec_scan (bfd *abfd)	295	srec_scan (bfd *abfd)
298	{	296	{
299	int c;	297	int c;
300	unsigned int lineno = 1;	298	unsigned int lineno = 1;
301	bfd_boolean error = FALSE;	299	bfd_boolean error = FALSE;
302	bfd_byte *buf = NULL;	300	bfd_byte *buf = NULL;
303	size_t bufsize = 0;	301	size_t bufsize = 0;
304	asection *sec = NULL;	302	asection *sec = NULL;
305	char *symbuf = NULL;	303	char *symbuf = NULL;
306		304
307	if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)	305	if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
308	goto error_return;	306	goto error_return;
309		307
310	while ((c = srec_get_byte (abfd, &error)) != EOF)	308	while ((c = srec_get_byte (abfd, &error)) != EOF)
311	{	309	{
312	/* We only build sections from contiguous S-records, so if this	310	/* We only build sections from contiguous S-records, so if this
313	is not an S-record, then stop building a section. */	311	is not an S-record, then stop building a section. */
314	if (c != 'S' && c != '\r' && c != '\n')	312	if (c != 'S' && c != '\r' && c != '\n')
315	sec = NULL;	313	sec = NULL;
316		314
317	switch (c)	315	switch (c)
318	{	316	{
319	default:	317	default:
320	srec_bad_byte (abfd, lineno, c, error);	318	srec_bad_byte (abfd, lineno, c, error);
321	goto error_return;	319	goto error_return;
322		320
323	case '\n':	321	case '\n':
324	++lineno;	322	++lineno;
325	break;	323	break;
326		324
327	case '\r':	325	case '\r':
328	break;	326	break;
329		327
330	case '$':	328	case '$':
331	/* Starting a module name, which we ignore. */	329	/* Starting a module name, which we ignore. */
332	while ((c = srec_get_byte (abfd, &error)) != '\n'	330	while ((c = srec_get_byte (abfd, &error)) != '\n'
333	&& c != EOF)	331	&& c != EOF)
334	;	332	;
335	if (c == EOF)	333	if (c == EOF)
336	{	334	{
337	srec_bad_byte (abfd, lineno, c, error);	335	srec_bad_byte (abfd, lineno, c, error);
338	goto error_return;	336	goto error_return;
339	}	337	}
340		338
341	++lineno;	339	++lineno;
342	break;	340	break;
343		341
344	case ' ':	342	case ' ':
345	do	343	do
346	{	344	{
347	bfd_size_type alc;	345	bfd_size_type alc;
348	char p, symname;	346	char p, symname;
349	bfd_vma symval;	347	bfd_vma symval;
350		348
351	/* Starting a symbol definition. */	349	/* Starting a symbol definition. */
352	while ((c = srec_get_byte (abfd, &error)) != EOF	350	while ((c = srec_get_byte (abfd, &error)) != EOF
353	&& (c == ' ' \|\| c == '\t'))	351	&& (c == ' ' \|\| c == '\t'))
354	;	352	;
355		353
356	if (c == '\n' \|\| c == '\r')	354	if (c == '\n' \|\| c == '\r')
357	break;	355	break;
358		356
359	if (c == EOF)	357	if (c == EOF)
360	{	358	{
361	srec_bad_byte (abfd, lineno, c, error);	359	srec_bad_byte (abfd, lineno, c, error);
362	goto error_return;	360	goto error_return;
363	}	361	}
364		362
365	alc = 10;	363	alc = 10;
366	symbuf = (char *) bfd_malloc (alc + 1);	364	symbuf = (char *) bfd_malloc (alc + 1);
367	if (symbuf == NULL)	365	if (symbuf == NULL)
368	goto error_return;	366	goto error_return;
369		367
370	p = symbuf;	368	p = symbuf;
371		369
372	*p++ = c;	370	*p++ = c;
373	while ((c = srec_get_byte (abfd, &error)) != EOF	371	while ((c = srec_get_byte (abfd, &error)) != EOF
374	&& ! ISSPACE (c))	372	&& ! ISSPACE (c))
375	{	373	{
376	if ((bfd_size_type) (p - symbuf) >= alc)	374	if ((bfd_size_type) (p - symbuf) >= alc)
377	{	375	{
378	char *n;	376	char *n;
379		377
380	alc *= 2;	378	alc *= 2;
381	n = (char *) bfd_realloc (symbuf, alc + 1);	379	n = (char *) bfd_realloc (symbuf, alc + 1);
382	if (n == NULL)	380	if (n == NULL)
383	goto error_return;	381	goto error_return;
384	p = n + (p - symbuf);	382	p = n + (p - symbuf);
385	symbuf = n;	383	symbuf = n;
386	}	384	}
387		385
388	*p++ = c;	386	*p++ = c;
389	}	387	}
390		388
391	if (c == EOF)	389	if (c == EOF)
392	{	390	{
393	srec_bad_byte (abfd, lineno, c, error);	391	srec_bad_byte (abfd, lineno, c, error);
394	goto error_return;	392	goto error_return;
395	}	393	}
396		394
397	*p++ = '\0';	395	*p++ = '\0';
398	symname = (char *) bfd_alloc (abfd, (bfd_size_type) (p - symbuf));	396	symname = (char *) bfd_alloc (abfd, (bfd_size_type) (p - symbuf));
399	if (symname == NULL)	397	if (symname == NULL)
400	goto error_return;	398	goto error_return;
401	strcpy (symname, symbuf);	399	strcpy (symname, symbuf);
402	free (symbuf);	400	free (symbuf);
403	symbuf = NULL;	401	symbuf = NULL;
404		402
405	while ((c = srec_get_byte (abfd, &error)) != EOF	403	while ((c = srec_get_byte (abfd, &error)) != EOF
406	&& (c == ' ' \|\| c == '\t'))	404	&& (c == ' ' \|\| c == '\t'))
407	;	405	;
408	if (c == EOF)	406	if (c == EOF)
409	{	407	{
410	srec_bad_byte (abfd, lineno, c, error);	408	srec_bad_byte (abfd, lineno, c, error);
411	goto error_return;	409	goto error_return;
412	}	410	}
413		411
414	/* Skip a dollar sign before the hex value. */	412	/* Skip a dollar sign before the hex value. */
415	if (c == '$')	413	if (c == '$')
416	{	414	{
417	c = srec_get_byte (abfd, &error);	415	c = srec_get_byte (abfd, &error);
418	if (c == EOF)	416	if (c == EOF)
419	{	417	{
420	srec_bad_byte (abfd, lineno, c, error);	418	srec_bad_byte (abfd, lineno, c, error);
421	goto error_return;	419	goto error_return;
422	}	420	}
423	}	421	}
424		422
425	symval = 0;	423	symval = 0;
426	while (ISHEX (c))	424	while (ISHEX (c))
427	{	425	{
428	symval <<= 4;	426	symval <<= 4;
429	symval += NIBBLE (c);	427	symval += NIBBLE (c);
430	c = srec_get_byte (abfd, &error);	428	c = srec_get_byte (abfd, &error);
431	if (c == EOF)	429	if (c == EOF)
432	{	430	{
433	srec_bad_byte (abfd, lineno, c, error);	431	srec_bad_byte (abfd, lineno, c, error);
434	goto error_return;	432	goto error_return;
435	}	433	}
436	}	434	}
437		435
438	if (! srec_new_symbol (abfd, symname, symval))	436	if (! srec_new_symbol (abfd, symname, symval))
439	goto error_return;	437	goto error_return;
440	}	438	}
441	while (c == ' ' \|\| c == '\t')	439	while (c == ' ' \|\| c == '\t')
442	;	440	;
443		441
444	if (c == '\n')	442	if (c == '\n')
445	++lineno;	443	++lineno;
446	else if (c != '\r')	444	else if (c != '\r')
447	{	445	{
448	srec_bad_byte (abfd, lineno, c, error);	446	srec_bad_byte (abfd, lineno, c, error);
449	goto error_return;	447	goto error_return;
450	}	448	}
451		449
452	break;	450	break;
453		451
454	case 'S':	452	case 'S':
455	{	453	{
456	file_ptr pos;	454	file_ptr pos;
457	char hdr[3];	455	unsigned char hdr[3];
458	unsigned int bytes;	456	unsigned int bytes, min_bytes;
459	bfd_vma address;	457	bfd_vma address;
460	bfd_byte *data;	458	bfd_byte *data;
461	unsigned char check_sum;	459	unsigned char check_sum;
462		460
463	/* Starting an S-record. */	461	/* Starting an S-record. */
464		462
465	pos = bfd_tell (abfd) - 1;	463	pos = bfd_tell (abfd) - 1;
466		464
467	if (bfd_bread (hdr, (bfd_size_type) 3, abfd) != 3)	465	if (bfd_bread (hdr, (bfd_size_type) 3, abfd) != 3)
468	goto error_return;	466	goto error_return;
469		467
470	if (! ISHEX (hdr[1]) \|\| ! ISHEX (hdr[2]))	468	if (! ISHEX (hdr[1]) \|\| ! ISHEX (hdr[2]))
471	{	469	{
472	if (! ISHEX (hdr[1]))	470	if (! ISHEX (hdr[1]))
473	c = hdr[1];	471	c = hdr[1];
474	else	472	else
475	c = hdr[2];	473	c = hdr[2];
476	srec_bad_byte (abfd, lineno, c, error);	474	srec_bad_byte (abfd, lineno, c, error);
477	goto error_return;	475	goto error_return;
478	}	476	}
479		477
480	check_sum = bytes = HEX (hdr + 1);	478	check_sum = bytes = HEX (hdr + 1);
-		479	min_bytes = 3;
-		480	if (hdr[0] == '2' \|\| hdr[0] == '8')
-		481	min_bytes = 4;
-		482	else if (hdr[0] == '3' \|\| hdr[0] == '7')
-		483	min_bytes = 5;
-		484	if (bytes < min_bytes)
-		485	{
-		486	(*_bfd_error_handler) (_("%B:%d: byte count %d too small\n"),
-		487	abfd, lineno, bytes);
-		488	bfd_set_error (bfd_error_bad_value);
-		489	goto error_return;
-		490	}
-		491
481	if (bytes * 2 > bufsize)	492	if (bytes * 2 > bufsize)
482	{	493	{
483	if (buf != NULL)	494	if (buf != NULL)
484	free (buf);	495	free (buf);
485	buf = (bfd_byte ) bfd_malloc ((bfd_size_type) bytes 2);	496	buf = (bfd_byte ) bfd_malloc ((bfd_size_type) bytes 2);
486	if (buf == NULL)	497	if (buf == NULL)
487	goto error_return;	498	goto error_return;

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/bfd/srec.c – Rev 5197 → 6324