Subversion Repositories open8_urisc

/* BFD back-end for s-record objects.

   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,

   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2011

   Free Software Foundation, Inc.

   Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.

   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<type><length><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.

   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:

        ($$ <modulename>

                (<space> <symbol> <address>)*)

        $$

        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[10];

      if (! ISPRINT (c))

        sprintf (buf, "\\%03o", (unsigned int) c);

      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;

            char hdr[3];

            unsigned int 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);

            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;