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


/* BFD back-end for Intel Hex objects.
 
   Copyright (C) 1995-2015 Free Software Foundation, Inc.
   Written by Ian Lance Taylor 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.  */
 
 
/* This is what Intel Hex files look like:
 
1. INTEL FORMATS
 
A. Intel 1
 
   16-bit address-field format, for files 64k bytes in length or less.
 
   DATA RECORD
   Byte 1	Header = colon(:)
   2..3		The number of data bytes in hex notation
   4..5		High byte of the record load address
   6..7		Low byte of the record load address
   8..9		Record type, must be "00"
   10..x	Data bytes in hex notation:
	x = (number of bytes - 1) * 2 + 11
   x+1..x+2	Checksum in hex notation
   x+3..x+4	Carriage return, line feed
 
   END RECORD
   Byte 1	Header = colon (:)
   2..3		The byte count, must be "00"
   4..7		Transfer-address (usually "0000")
		the jump-to address, execution start address
   8..9		Record type, must be "01"
   10..11	Checksum, in hex notation
   12..13	Carriage return, line feed
 
B. INTEL 2
 
   MCS-86 format, using a 20-bit address for files larger than 64K bytes.
 
   DATA RECORD
   Byte 1	Header = colon (:)
   2..3		The byte count of this record, hex notation
   4..5		High byte of the record load address
   6..7		Low byte of the record load address
   8..9		Record type, must be "00"
   10..x	The data bytes in hex notation:
	x = (number of data bytes - 1) * 2 + 11
   x+1..x+2	Checksum in hex notation
   x+3..x+4	Carriage return, line feed
 
   EXTENDED ADDRESS RECORD
   Byte 1	Header = colon(:)
   2..3		The byte count, must be "02"
   4..7		Load address, must be "0000"
   8..9		Record type, must be "02"
   10..11	High byte of the offset address
   12..13	Low byte of the offset address
   14..15	Checksum in hex notation
   16..17	Carriage return, line feed
 
   The checksums are the two's complement of the 8-bit sum
   without carry of the byte count, offset address, and the
   record type.
 
   START ADDRESS RECORD
   Byte 1	Header = colon (:)
   2..3		The byte count, must be "04"
   4..7		Load address, must be "0000"
   8..9		Record type, must be "03"
   10..13	8086 CS value
   14..17	8086 IP value
   18..19	Checksum in hex notation
   20..21	Carriage return, line feed
 
Another document reports these additional types:
 
   EXTENDED LINEAR ADDRESS RECORD
   Byte 1	Header = colon (:)
   2..3		The byte count, must be "02"
   4..7		Load address, must be "0000"
   8..9		Record type, must be "04"
   10..13	Upper 16 bits of address of subsequent records
   14..15	Checksum in hex notation
   16..17	Carriage return, line feed
 
   START LINEAR ADDRESS RECORD
   Byte 1	Header = colon (:)
   2..3		The byte count, must be "02"
   4..7		Load address, must be "0000"
   8..9		Record type, must be "05"
   10..13	Upper 16 bits of start address
   14..15	Checksum in hex notation
   16..17	Carriage return, line feed
 
The MRI compiler uses this, which is a repeat of type 5:
 
  EXTENDED START RECORD
   Byte 1	Header = colon (:)
   2..3		The byte count, must be "04"
   4..7		Load address, must be "0000"
   8..9		Record type, must be "05"
   10..13	Upper 16 bits of start address
   14..17	Lower 16 bits of start address
   18..19	Checksum in hex notation
   20..21	Carriage return, line feed.  */
 
#include "sysdep.h"
#include "bfd.h"
#include "libbfd.h"
#include "libiberty.h"
#include "safe-ctype.h"
 
/* The number of bytes we put on one line during output.  */
 
#define CHUNK 16
 
/* Macros for converting between hex and binary.  */
 
#define NIBBLE(x)    (hex_value (x))
#define HEX2(buffer) ((NIBBLE ((buffer)[0]) << 4) + NIBBLE ((buffer)[1]))
#define HEX4(buffer) ((HEX2 (buffer) << 8) + HEX2 ((buffer) + 2))
#define ISHEX(x)     (hex_p (x))
 
/* When we write out an ihex value, the values can not be output as
   they are seen.  Instead, we hold them in memory in this structure.  */
 
struct ihex_data_list
{
  struct ihex_data_list *next;
  bfd_byte *data;
  bfd_vma where;
  bfd_size_type size;
};
 
/* The ihex tdata information.  */
 
struct ihex_data_struct
{
  struct ihex_data_list *head;
  struct ihex_data_list *tail;
};
 
/* Initialize by filling in the hex conversion array.  */
 
static void
ihex_init (void)
{
  static bfd_boolean inited;
 
  if (! inited)
    {
      inited = TRUE;
      hex_init ();
    }
}
 
/* Create an ihex object.  */
 
static bfd_boolean
ihex_mkobject (bfd *abfd)
{
  struct ihex_data_struct *tdata;
 
  tdata = (struct ihex_data_struct *) bfd_alloc (abfd, sizeof (* tdata));
  if (tdata == NULL)
    return FALSE;
 
  abfd->tdata.ihex_data = tdata;
  tdata->head = NULL;
  tdata->tail = NULL;
  return TRUE;
}
 
/* Read a byte from a BFD.  Set *ERRORPTR if an error occurred.
   Return EOF on error or end of file.  */
 
static INLINE int
ihex_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 Intel Hex file.  */
 
static void
ihex_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 & 0xff);
      else
	{
	  buf[0] = c;
	  buf[1] = '\0';
	}
      (*_bfd_error_handler)
	(_("%B:%d: unexpected character `%s' in Intel Hex file"),
	 abfd, lineno, buf);
      bfd_set_error (bfd_error_bad_value);
    }
}
 
/* Read an Intel hex file and turn it into sections.  We create a new
   section for each contiguous set of bytes.  */
 
static bfd_boolean
ihex_scan (bfd *abfd)
{
  bfd_vma segbase;
  bfd_vma extbase;
  asection *sec;
  unsigned int lineno;
  bfd_boolean error;
  bfd_byte *buf = NULL;
  size_t bufsize;
  int c;
 
  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
    goto error_return;
 
  abfd->start_address = 0;
 
  segbase = 0;
  extbase = 0;
  sec = NULL;
  lineno = 1;
  error = FALSE;
  bufsize = 0;
 
  while ((c = ihex_get_byte (abfd, &error)) != EOF)
    {
      if (c == '\r')
	continue;
      else if (c == '\n')
	{
	  ++lineno;
	  continue;
	}
      else if (c != ':')
	{
	  ihex_bad_byte (abfd, lineno, c, error);
	  goto error_return;
	}
      else
	{
	  file_ptr pos;
	  unsigned char hdr[8];
	  unsigned int i;
	  unsigned int len;
	  bfd_vma addr;
	  unsigned int type;
	  unsigned int chars;
	  unsigned int chksum;
 
	  /* This is a data record.  */
	  pos = bfd_tell (abfd) - 1;
 
	  /* Read the header bytes.  */
	  if (bfd_bread (hdr, (bfd_size_type) 8, abfd) != 8)
	    goto error_return;
 
	  for (i = 0; i < 8; i++)
	    {
	      if (! ISHEX (hdr[i]))
		{
		  ihex_bad_byte (abfd, lineno, hdr[i], error);
		  goto error_return;
		}
	    }
 
	  len = HEX2 (hdr);
	  addr = HEX4 (hdr + 2);
	  type = HEX2 (hdr + 6);
 
	  /* Read the data bytes.  */
	  chars = len * 2 + 2;
	  if (chars >= bufsize)
	    {
	      buf = (bfd_byte *) bfd_realloc (buf, (bfd_size_type) chars);
	      if (buf == NULL)
		goto error_return;
	      bufsize = chars;
	    }
 
	  if (bfd_bread (buf, (bfd_size_type) chars, abfd) != chars)
	    goto error_return;
 
	  for (i = 0; i < chars; i++)
	    {
	      if (! ISHEX (buf[i]))
		{
		  ihex_bad_byte (abfd, lineno, buf[i], error);
		  goto error_return;
		}
	    }
 
	  /* Check the checksum.  */
	  chksum = len + addr + (addr >> 8) + type;
	  for (i = 0; i < len; i++)
	    chksum += HEX2 (buf + 2 * i);
	  if (((- chksum) & 0xff) != (unsigned int) HEX2 (buf + 2 * i))
	    {
	      (*_bfd_error_handler)
		(_("%B:%u: bad checksum in Intel Hex file (expected %u, found %u)"),
		 abfd, lineno,
		 (- chksum) & 0xff, (unsigned int) HEX2 (buf + 2 * i));
	      bfd_set_error (bfd_error_bad_value);
	      goto error_return;
	    }
 
	  switch (type)
	    {
	    case 0:
	      /* This is a data record.  */
	      if (sec != NULL
		  && sec->vma + sec->size == extbase + segbase + addr)
		{
		  /* This data goes at the end of the section we are
                     currently building.  */
		  sec->size += len;
		}
	      else if (len > 0)
		{
		  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);
		  if (secname == NULL)
		    goto error_return;
		  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 = extbase + segbase + addr;
		  sec->lma = extbase + segbase + addr;
		  sec->size = len;
		  sec->filepos = pos;
		}
	      break;
 
	    case 1:
	      /* An end record.  */
	      if (abfd->start_address == 0)
		abfd->start_address = addr;
	      if (buf != NULL)
		free (buf);
	      return TRUE;
 
	    case 2:
	      /* An extended address record.  */
	      if (len != 2)
		{
		  (*_bfd_error_handler)
		    (_("%B:%u: bad extended address record length in Intel Hex file"),
		     abfd, lineno);
		  bfd_set_error (bfd_error_bad_value);
		  goto error_return;
		}
 
	      segbase = HEX4 (buf) << 4;
 
	      sec = NULL;
 
	      break;
 
	    case 3:
	      /* An extended start address record.  */
	      if (len != 4)
		{
		  (*_bfd_error_handler)
		    (_("%B:%u: bad extended start address length in Intel Hex file"),
		     abfd, lineno);
		  bfd_set_error (bfd_error_bad_value);
		  goto error_return;
		}
 
	      abfd->start_address += (HEX4 (buf) << 4) + HEX4 (buf + 4);
 
	      sec = NULL;
 
	      break;
 
	    case 4:
	      /* An extended linear address record.  */
	      if (len != 2)
		{
		  (*_bfd_error_handler)
		    (_("%B:%u: bad extended linear address record length in Intel Hex file"),
		     abfd, lineno);
		  bfd_set_error (bfd_error_bad_value);
		  goto error_return;
		}
 
	      extbase = HEX4 (buf) << 16;
 
	      sec = NULL;
 
	      break;
 
	    case 5:
	      /* An extended linear start address record.  */
	      if (len != 2 && len != 4)
		{
		  (*_bfd_error_handler)
		    (_("%B:%u: bad extended linear start address length in Intel Hex file"),
		     abfd, lineno);
		  bfd_set_error (bfd_error_bad_value);
		  goto error_return;
		}
 
	      if (len == 2)
		abfd->start_address += HEX4 (buf) << 16;
	      else
		abfd->start_address = (HEX4 (buf) << 16) + HEX4 (buf + 4);
 
	      sec = NULL;
 
	      break;
 
	    default:
	      (*_bfd_error_handler)
		(_("%B:%u: unrecognized ihex type %u in Intel Hex file"),
		 abfd, lineno, type);
	      bfd_set_error (bfd_error_bad_value);
	      goto error_return;
	    }
	}
    }
 
  if (error)
    goto error_return;
 
  if (buf != NULL)
    free (buf);
 
  return TRUE;
 
 error_return:
  if (buf != NULL)
    free (buf);
  return FALSE;
}
 
/* Try to recognize an Intel Hex file.  */
 
static const bfd_target *
ihex_object_p (bfd *abfd)
{
  void * tdata_save;
  bfd_byte b[9];
  unsigned int i;
  unsigned int type;
 
  ihex_init ();
 
  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
    return NULL;
  if (bfd_bread (b, (bfd_size_type) 9, abfd) != 9)
    {
      if (bfd_get_error () == bfd_error_file_truncated)
	bfd_set_error (bfd_error_wrong_format);
      return NULL;
    }
 
  if (b[0] != ':')
    {
      bfd_set_error (bfd_error_wrong_format);
      return NULL;
    }
 
  for (i = 1; i < 9; i++)
    {
      if (! ISHEX (b[i]))
	{
	  bfd_set_error (bfd_error_wrong_format);
	  return NULL;
	}
    }
 
  type = HEX2 (b + 7);
  if (type > 5)
    {
      bfd_set_error (bfd_error_wrong_format);
      return NULL;
    }
 
  /* OK, it looks like it really is an Intel Hex file.  */
  tdata_save = abfd->tdata.any;
  if (! ihex_mkobject (abfd) || ! ihex_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;
    }
 
  return abfd->xvec;
}
 
/* Read the contents of a section in an Intel Hex file.  */
 
static bfd_boolean
ihex_read_section (bfd *abfd, asection *section, bfd_byte *contents)
{
  int c;
  bfd_byte *p;
  bfd_byte *buf = NULL;
  size_t bufsize;
  bfd_boolean error;
 
  if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0)
    goto error_return;
 
  p = contents;
  bufsize = 0;
  error = FALSE;
  while ((c = ihex_get_byte (abfd, &error)) != EOF)
    {
      unsigned char hdr[8];
      unsigned int len;
      unsigned int type;
      unsigned int i;
 
      if (c == '\r' || c == '\n')
	continue;
 
      /* This is called after ihex_scan has succeeded, so we ought to
         know the exact format.  */
      BFD_ASSERT (c == ':');
 
      if (bfd_bread (hdr, (bfd_size_type) 8, abfd) != 8)
	goto error_return;
 
      len = HEX2 (hdr);
      type = HEX2 (hdr + 6);
 
      /* We should only see type 0 records here.  */
      if (type != 0)
	{
	  (*_bfd_error_handler)
	    (_("%B: internal error in ihex_read_section"), abfd);
	  bfd_set_error (bfd_error_bad_value);
	  goto error_return;
	}
 
      if (len * 2 > bufsize)
	{
	  buf = (bfd_byte *) bfd_realloc (buf, (bfd_size_type) len * 2);
	  if (buf == NULL)
	    goto error_return;
	  bufsize = len * 2;
	}
 
      if (bfd_bread (buf, (bfd_size_type) len * 2, abfd) != len * 2)
	goto error_return;
 
      for (i = 0; i < len; i++)
	*p++ = HEX2 (buf + 2 * i);
      if ((bfd_size_type) (p - contents) >= section->size)
	{
	  /* We've read everything in the section.  */
	  if (buf != NULL)
	    free (buf);
	  return TRUE;
	}
 
      /* Skip the checksum.  */
      if (bfd_bread (buf, (bfd_size_type) 2, abfd) != 2)
	goto error_return;
    }
 
  if ((bfd_size_type) (p - contents) < section->size)
    {
      (*_bfd_error_handler)
	(_("%B: bad section length in ihex_read_section"), abfd);
      bfd_set_error (bfd_error_bad_value);
      goto error_return;
    }
 
  if (buf != NULL)
    free (buf);
 
  return TRUE;
 
 error_return:
  if (buf != NULL)
    free (buf);
  return FALSE;
}
 
/* Get the contents of a section in an Intel Hex file.  */
 
static bfd_boolean
ihex_get_section_contents (bfd *abfd,
			   asection *section,
			   void * location,
			   file_ptr offset,
			   bfd_size_type count)
{
  if (section->used_by_bfd == NULL)
    {
      section->used_by_bfd = bfd_alloc (abfd, section->size);
      if (section->used_by_bfd == NULL)
	return FALSE;
      if (! ihex_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 contents of a section in an Intel Hex file.  */
 
static bfd_boolean
ihex_set_section_contents (bfd *abfd,
			   asection *section,
			   const void * location,
			   file_ptr offset,
			   bfd_size_type count)
{
  struct ihex_data_list *n;
  bfd_byte *data;
  struct ihex_data_struct *tdata;
 
  if (count == 0
      || (section->flags & SEC_ALLOC) == 0
      || (section->flags & SEC_LOAD) == 0)
    return TRUE;
 
  n = (struct ihex_data_list *) bfd_alloc (abfd, sizeof (* n));
  if (n == NULL)
    return FALSE;
 
  data = (bfd_byte *) bfd_alloc (abfd, count);
  if (data == NULL)
    return FALSE;
  memcpy (data, location, (size_t) count);
 
  n->data = data;
  n->where = section->lma + offset;
  n->size = count;
 
  /* Sort the records by address.  Optimize for the common case of
     adding a record to the end of the list.  */
  tdata = abfd->tdata.ihex_data;
  if (tdata->tail != NULL
      && n->where >= tdata->tail->where)
    {
      tdata->tail->next = n;
      n->next = NULL;
      tdata->tail = n;
    }
  else
    {
      struct ihex_data_list **pp;
 
      for (pp = &tdata->head;
	   *pp != NULL && (*pp)->where < n->where;
	   pp = &(*pp)->next)
	;
      n->next = *pp;
      *pp = n;
      if (n->next == NULL)
	tdata->tail = n;
    }
 
  return TRUE;
}
 
/* Write a record out to an Intel Hex file.  */
 
static bfd_boolean
ihex_write_record (bfd *abfd,
		   size_t count,
		   unsigned int addr,
		   unsigned int type,
		   bfd_byte *data)
{
  static const char digs[] = "0123456789ABCDEF";
  char buf[9 + CHUNK * 2 + 4];
  char *p;
  unsigned int chksum;
  unsigned int i;
  size_t total;
 
#define TOHEX(buf, v) \
  ((buf)[0] = digs[((v) >> 4) & 0xf], (buf)[1] = digs[(v) & 0xf])
 
  buf[0] = ':';
  TOHEX (buf + 1, count);
  TOHEX (buf + 3, (addr >> 8) & 0xff);
  TOHEX (buf + 5, addr & 0xff);
  TOHEX (buf + 7, type);
 
  chksum = count + addr + (addr >> 8) + type;
 
  for (i = 0, p = buf + 9; i < count; i++, p += 2, data++)
    {
      TOHEX (p, *data);
      chksum += *data;
    }
 
  TOHEX (p, (- chksum) & 0xff);
  p[2] = '\r';
  p[3] = '\n';
 
  total = 9 + count * 2 + 4;
  if (bfd_bwrite (buf, (bfd_size_type) total, abfd) != total)
    return FALSE;
 
  return TRUE;
}
 
/* Write out an Intel Hex file.  */
 
static bfd_boolean
ihex_write_object_contents (bfd *abfd)
{
  bfd_vma segbase;
  bfd_vma extbase;
  struct ihex_data_list *l;
 
  segbase = 0;
  extbase = 0;
  for (l = abfd->tdata.ihex_data->head; l != NULL; l = l->next)
    {
      bfd_vma where;
      bfd_byte *p;
      bfd_size_type count;
 
      where = l->where;
      p = l->data;
      count = l->size;
 
      while (count > 0)
	{
	  size_t now;
	  unsigned int rec_addr;
 
	  now = count;
	  if (count > CHUNK)
	    now = CHUNK;
 
	  if (where > segbase + extbase + 0xffff)
	    {
	      bfd_byte addr[2];
 
	      /* We need a new base address.  */
	      if (where <= 0xfffff)
		{
		  /* The addresses should be sorted.  */
		  BFD_ASSERT (extbase == 0);
 
		  segbase = where & 0xf0000;
		  addr[0] = (bfd_byte)(segbase >> 12) & 0xff;
		  addr[1] = (bfd_byte)(segbase >> 4) & 0xff;
		  if (! ihex_write_record (abfd, 2, 0, 2, addr))
		    return FALSE;
		}
	      else
		{
		  /* The extended address record and the extended
                     linear address record are combined, at least by
                     some readers.  We need an extended linear address
                     record here, so if we've already written out an
                     extended address record, zero it out to avoid
                     confusion.  */
		  if (segbase != 0)
		    {
		      addr[0] = 0;
		      addr[1] = 0;
		      if (! ihex_write_record (abfd, 2, 0, 2, addr))
			return FALSE;
		      segbase = 0;
		    }
 
		  extbase = where & 0xffff0000;
		  if (where > extbase + 0xffff)
		    {
		      char buf[20];
 
		      sprintf_vma (buf, where);
		      (*_bfd_error_handler)
			(_("%s: address 0x%s out of range for Intel Hex file"),
			 bfd_get_filename (abfd), buf);
		      bfd_set_error (bfd_error_bad_value);
		      return FALSE;
		    }
		  addr[0] = (bfd_byte)(extbase >> 24) & 0xff;
		  addr[1] = (bfd_byte)(extbase >> 16) & 0xff;
		  if (! ihex_write_record (abfd, 2, 0, 4, addr))
		    return FALSE;
		}
	    }
 
	  rec_addr = where - (extbase + segbase);
 
          /* Output records shouldn't cross 64K boundaries.  */
          if (rec_addr + now > 0xffff)
            now = 0x10000 - rec_addr;
 
	  if (! ihex_write_record (abfd, now, rec_addr, 0, p))
	    return FALSE;
 
	  where += now;
	  p += now;
	  count -= now;
	}
    }
 
  if (abfd->start_address != 0)
    {
      bfd_vma start;
      bfd_byte startbuf[4];
 
      start = abfd->start_address;
 
      if (start <= 0xfffff)
	{
	  startbuf[0] = (bfd_byte)((start & 0xf0000) >> 12) & 0xff;
	  startbuf[1] = 0;
	  startbuf[2] = (bfd_byte)(start >> 8) & 0xff;
	  startbuf[3] = (bfd_byte)start & 0xff;
	  if (! ihex_write_record (abfd, 4, 0, 3, startbuf))
	    return FALSE;
	}
      else
	{
	  startbuf[0] = (bfd_byte)(start >> 24) & 0xff;
	  startbuf[1] = (bfd_byte)(start >> 16) & 0xff;
	  startbuf[2] = (bfd_byte)(start >> 8) & 0xff;
	  startbuf[3] = (bfd_byte)start & 0xff;
	  if (! ihex_write_record (abfd, 4, 0, 5, startbuf))
	    return FALSE;
	}
    }
 
  if (! ihex_write_record (abfd, 0, 0, 1, NULL))
    return FALSE;
 
  return TRUE;
}
 
/* Set the architecture for the output file.  The architecture is
   irrelevant, so we ignore errors about unknown architectures.  */
 
static bfd_boolean
ihex_set_arch_mach (bfd *abfd,
		    enum bfd_architecture arch,
		    unsigned long mach)
{
  if (! bfd_default_set_arch_mach (abfd, arch, mach))
    {
      if (arch != bfd_arch_unknown)
	return FALSE;
    }
  return TRUE;
}
 
/* Get the size of the headers, for the linker.  */
 
static int
ihex_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
		     struct bfd_link_info *info ATTRIBUTE_UNUSED)
{
  return 0;
}
 
/* Some random definitions for the target vector.  */
 
#define	ihex_close_and_cleanup                    _bfd_generic_close_and_cleanup
#define ihex_bfd_free_cached_info                 _bfd_generic_bfd_free_cached_info
#define ihex_new_section_hook                     _bfd_generic_new_section_hook
#define ihex_get_section_contents_in_window       _bfd_generic_get_section_contents_in_window
#define ihex_get_symtab_upper_bound               bfd_0l
#define ihex_canonicalize_symtab                  ((long (*) (bfd *, asymbol **)) bfd_0l)
#define ihex_make_empty_symbol                    _bfd_generic_make_empty_symbol
#define ihex_print_symbol                         _bfd_nosymbols_print_symbol
#define ihex_get_symbol_info                      _bfd_nosymbols_get_symbol_info
#define ihex_get_symbol_version_string		  _bfd_nosymbols_get_symbol_version_string
#define ihex_bfd_is_target_special_symbol         ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
#define ihex_bfd_is_local_label_name              _bfd_nosymbols_bfd_is_local_label_name
#define ihex_get_lineno                           _bfd_nosymbols_get_lineno
#define ihex_find_nearest_line                    _bfd_nosymbols_find_nearest_line
#define ihex_find_line                            _bfd_nosymbols_find_line
#define ihex_find_inliner_info                    _bfd_nosymbols_find_inliner_info
#define ihex_bfd_make_debug_symbol                _bfd_nosymbols_bfd_make_debug_symbol
#define ihex_read_minisymbols                     _bfd_nosymbols_read_minisymbols
#define ihex_minisymbol_to_symbol                 _bfd_nosymbols_minisymbol_to_symbol
#define ihex_bfd_get_relocated_section_contents   bfd_generic_get_relocated_section_contents
#define ihex_bfd_relax_section                    bfd_generic_relax_section
#define ihex_bfd_gc_sections                      bfd_generic_gc_sections
#define ihex_bfd_lookup_section_flags             bfd_generic_lookup_section_flags
#define ihex_bfd_merge_sections                   bfd_generic_merge_sections
#define ihex_bfd_is_group_section                 bfd_generic_is_group_section
#define ihex_bfd_discard_group                    bfd_generic_discard_group
#define ihex_section_already_linked               _bfd_generic_section_already_linked
#define ihex_bfd_define_common_symbol             bfd_generic_define_common_symbol
#define ihex_bfd_link_hash_table_create           _bfd_generic_link_hash_table_create
 
#define ihex_bfd_link_add_symbols                 _bfd_generic_link_add_symbols
#define ihex_bfd_link_just_syms                   _bfd_generic_link_just_syms
#define ihex_bfd_copy_link_hash_symbol_type \
  _bfd_generic_copy_link_hash_symbol_type
#define ihex_bfd_final_link                       _bfd_generic_final_link
#define ihex_bfd_link_split_section               _bfd_generic_link_split_section
 
/* The Intel Hex target vector.  */
 
const bfd_target ihex_vec =
{
  "ihex",			/* Name.  */
  bfd_target_ihex_flavour,
  BFD_ENDIAN_UNKNOWN,		/* Target byte order.  */
  BFD_ENDIAN_UNKNOWN,		/* Target headers byte order.  */
  0,				/* Object flags.  */
  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD),	/* 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,
    ihex_object_p,		/* bfd_check_format.  */
    _bfd_dummy_target,
    _bfd_dummy_target,
  },
  {
    bfd_false,
    ihex_mkobject,
    _bfd_generic_mkarchive,
    bfd_false,
  },
  {				/* bfd_write_contents.  */
    bfd_false,
    ihex_write_object_contents,
    _bfd_write_archive_contents,
    bfd_false,
  },
 
  BFD_JUMP_TABLE_GENERIC (ihex),
  BFD_JUMP_TABLE_COPY (_bfd_generic),
  BFD_JUMP_TABLE_CORE (_bfd_nocore),
  BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
  BFD_JUMP_TABLE_SYMBOLS (ihex),
  BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
  BFD_JUMP_TABLE_WRITE (ihex),
  BFD_JUMP_TABLE_LINK (ihex),
  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 
  NULL,
 
  NULL
};

Rev 5197	Rev 6324
1	/* BFD back-end for Intel Hex objects.	1	/* BFD back-end for Intel Hex objects.
2	Copyright 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,	-
3	2006, 2007, 2009, 2011 Free Software Foundation, Inc.	2	Copyright (C) 1995-2015 Free Software Foundation, Inc.
4	Written by Ian Lance Taylor of Cygnus Support .	3	Written by Ian Lance Taylor of Cygnus Support .
5		4
6	This file is part of BFD, the Binary File Descriptor library.	5	This file is part of BFD, the Binary File Descriptor library.
7		6
8	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
9	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
10	the Free Software Foundation; either version 3 of the License, or	9	the Free Software Foundation; either version 3 of the License, or
11	(at your option) any later version.	10	(at your option) any later version.
12		11
13	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,
14	but WITHOUT ANY WARRANTY; without even the implied warranty of	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	GNU General Public License for more details.	15	GNU General Public License for more details.
17		16
18	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
19	along with this program; if not, write to the Free Software	18	along with this program; if not, write to the Free Software
20	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,	19	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21	MA 02110-1301, USA. */	20	MA 02110-1301, USA. */
22		21
23		22
24	/* This is what Intel Hex files look like:	23	/* This is what Intel Hex files look like:
25		24
26	1. INTEL FORMATS	25	1. INTEL FORMATS
27		26
28	A. Intel 1	27	A. Intel 1
29		28
30	16-bit address-field format, for files 64k bytes in length or less.	29	16-bit address-field format, for files 64k bytes in length or less.
31		30
32	DATA RECORD	31	DATA RECORD
33	Byte 1 Header = colon(:)	32	Byte 1 Header = colon(:)
34	2..3 The number of data bytes in hex notation	33	2..3 The number of data bytes in hex notation
35	4..5 High byte of the record load address	34	4..5 High byte of the record load address
36	6..7 Low byte of the record load address	35	6..7 Low byte of the record load address
37	8..9 Record type, must be "00"	36	8..9 Record type, must be "00"
38	10..x Data bytes in hex notation:	37	10..x Data bytes in hex notation:
39	x = (number of bytes - 1) * 2 + 11	38	x = (number of bytes - 1) * 2 + 11
40	x+1..x+2 Checksum in hex notation	39	x+1..x+2 Checksum in hex notation
41	x+3..x+4 Carriage return, line feed	40	x+3..x+4 Carriage return, line feed
42		41
43	END RECORD	42	END RECORD
44	Byte 1 Header = colon (:)	43	Byte 1 Header = colon (:)
45	2..3 The byte count, must be "00"	44	2..3 The byte count, must be "00"
46	4..7 Transfer-address (usually "0000")	45	4..7 Transfer-address (usually "0000")
47	the jump-to address, execution start address	46	the jump-to address, execution start address
48	8..9 Record type, must be "01"	47	8..9 Record type, must be "01"
49	10..11 Checksum, in hex notation	48	10..11 Checksum, in hex notation
50	12..13 Carriage return, line feed	49	12..13 Carriage return, line feed
51		50
52	B. INTEL 2	51	B. INTEL 2
53		52
54	MCS-86 format, using a 20-bit address for files larger than 64K bytes.	53	MCS-86 format, using a 20-bit address for files larger than 64K bytes.
55		54
56	DATA RECORD	55	DATA RECORD
57	Byte 1 Header = colon (:)	56	Byte 1 Header = colon (:)
58	2..3 The byte count of this record, hex notation	57	2..3 The byte count of this record, hex notation
59	4..5 High byte of the record load address	58	4..5 High byte of the record load address
60	6..7 Low byte of the record load address	59	6..7 Low byte of the record load address
61	8..9 Record type, must be "00"	60	8..9 Record type, must be "00"
62	10..x The data bytes in hex notation:	61	10..x The data bytes in hex notation:
63	x = (number of data bytes - 1) * 2 + 11	62	x = (number of data bytes - 1) * 2 + 11
64	x+1..x+2 Checksum in hex notation	63	x+1..x+2 Checksum in hex notation
65	x+3..x+4 Carriage return, line feed	64	x+3..x+4 Carriage return, line feed
66		65
67	EXTENDED ADDRESS RECORD	66	EXTENDED ADDRESS RECORD
68	Byte 1 Header = colon(:)	67	Byte 1 Header = colon(:)
69	2..3 The byte count, must be "02"	68	2..3 The byte count, must be "02"
70	4..7 Load address, must be "0000"	69	4..7 Load address, must be "0000"
71	8..9 Record type, must be "02"	70	8..9 Record type, must be "02"
72	10..11 High byte of the offset address	71	10..11 High byte of the offset address
73	12..13 Low byte of the offset address	72	12..13 Low byte of the offset address
74	14..15 Checksum in hex notation	73	14..15 Checksum in hex notation
75	16..17 Carriage return, line feed	74	16..17 Carriage return, line feed
76		75
77	The checksums are the two's complement of the 8-bit sum	76	The checksums are the two's complement of the 8-bit sum
78	without carry of the byte count, offset address, and the	77	without carry of the byte count, offset address, and the
79	record type.	78	record type.
80		79
81	START ADDRESS RECORD	80	START ADDRESS RECORD
82	Byte 1 Header = colon (:)	81	Byte 1 Header = colon (:)
83	2..3 The byte count, must be "04"	82	2..3 The byte count, must be "04"
84	4..7 Load address, must be "0000"	83	4..7 Load address, must be "0000"
85	8..9 Record type, must be "03"	84	8..9 Record type, must be "03"
86	10..13 8086 CS value	85	10..13 8086 CS value
87	14..17 8086 IP value	86	14..17 8086 IP value
88	18..19 Checksum in hex notation	87	18..19 Checksum in hex notation
89	20..21 Carriage return, line feed	88	20..21 Carriage return, line feed
90		89
91	Another document reports these additional types:	90	Another document reports these additional types:
92		91
93	EXTENDED LINEAR ADDRESS RECORD	92	EXTENDED LINEAR ADDRESS RECORD
94	Byte 1 Header = colon (:)	93	Byte 1 Header = colon (:)
95	2..3 The byte count, must be "02"	94	2..3 The byte count, must be "02"
96	4..7 Load address, must be "0000"	95	4..7 Load address, must be "0000"
97	8..9 Record type, must be "04"	96	8..9 Record type, must be "04"
98	10..13 Upper 16 bits of address of subsequent records	97	10..13 Upper 16 bits of address of subsequent records
99	14..15 Checksum in hex notation	98	14..15 Checksum in hex notation
100	16..17 Carriage return, line feed	99	16..17 Carriage return, line feed
101		100
102	START LINEAR ADDRESS RECORD	101	START LINEAR ADDRESS RECORD
103	Byte 1 Header = colon (:)	102	Byte 1 Header = colon (:)
104	2..3 The byte count, must be "02"	103	2..3 The byte count, must be "02"
105	4..7 Load address, must be "0000"	104	4..7 Load address, must be "0000"
106	8..9 Record type, must be "05"	105	8..9 Record type, must be "05"
107	10..13 Upper 16 bits of start address	106	10..13 Upper 16 bits of start address
108	14..15 Checksum in hex notation	107	14..15 Checksum in hex notation
109	16..17 Carriage return, line feed	108	16..17 Carriage return, line feed
110		109
111	The MRI compiler uses this, which is a repeat of type 5:	110	The MRI compiler uses this, which is a repeat of type 5:
112		111
113	EXTENDED START RECORD	112	EXTENDED START RECORD
114	Byte 1 Header = colon (:)	113	Byte 1 Header = colon (:)
115	2..3 The byte count, must be "04"	114	2..3 The byte count, must be "04"
116	4..7 Load address, must be "0000"	115	4..7 Load address, must be "0000"
117	8..9 Record type, must be "05"	116	8..9 Record type, must be "05"
118	10..13 Upper 16 bits of start address	117	10..13 Upper 16 bits of start address
119	14..17 Lower 16 bits of start address	118	14..17 Lower 16 bits of start address
120	18..19 Checksum in hex notation	119	18..19 Checksum in hex notation
121	20..21 Carriage return, line feed. */	120	20..21 Carriage return, line feed. */
122		121
123	#include "sysdep.h"	122	#include "sysdep.h"
124	#include "bfd.h"	123	#include "bfd.h"
125	#include "libbfd.h"	124	#include "libbfd.h"
126	#include "libiberty.h"	125	#include "libiberty.h"
127	#include "safe-ctype.h"	126	#include "safe-ctype.h"
128		127
129	/* The number of bytes we put on one line during output. */	128	/* The number of bytes we put on one line during output. */
130		129
131	#define CHUNK 16	130	#define CHUNK 16
132		131
133	/* Macros for converting between hex and binary. */	132	/* Macros for converting between hex and binary. */
134		133
135	#define NIBBLE(x) (hex_value (x))	134	#define NIBBLE(x) (hex_value (x))
136	#define HEX2(buffer) ((NIBBLE ((buffer)[0]) << 4) + NIBBLE ((buffer)[1]))	135	#define HEX2(buffer) ((NIBBLE ((buffer)[0]) << 4) + NIBBLE ((buffer)[1]))
137	#define HEX4(buffer) ((HEX2 (buffer) << 8) + HEX2 ((buffer) + 2))	136	#define HEX4(buffer) ((HEX2 (buffer) << 8) + HEX2 ((buffer) + 2))
138	#define ISHEX(x) (hex_p (x))	137	#define ISHEX(x) (hex_p (x))
139		138
140	/* When we write out an ihex value, the values can not be output as	139	/* When we write out an ihex value, the values can not be output as
141	they are seen. Instead, we hold them in memory in this structure. */	140	they are seen. Instead, we hold them in memory in this structure. */
142		141
143	struct ihex_data_list	142	struct ihex_data_list
144	{	143	{
145	struct ihex_data_list *next;	144	struct ihex_data_list *next;
146	bfd_byte *data;	145	bfd_byte *data;
147	bfd_vma where;	146	bfd_vma where;
148	bfd_size_type size;	147	bfd_size_type size;
149	};	148	};
150		149
151	/* The ihex tdata information. */	150	/* The ihex tdata information. */
152		151
153	struct ihex_data_struct	152	struct ihex_data_struct
154	{	153	{
155	struct ihex_data_list *head;	154	struct ihex_data_list *head;
156	struct ihex_data_list *tail;	155	struct ihex_data_list *tail;
157	};	156	};
158		157
159	/* Initialize by filling in the hex conversion array. */	158	/* Initialize by filling in the hex conversion array. */
160		159
161	static void	160	static void
162	ihex_init (void)	161	ihex_init (void)
163	{	162	{
164	static bfd_boolean inited;	163	static bfd_boolean inited;
165		164
166	if (! inited)	165	if (! inited)
167	{	166	{
168	inited = TRUE;	167	inited = TRUE;
169	hex_init ();	168	hex_init ();
170	}	169	}
171	}	170	}
172		171
173	/* Create an ihex object. */	172	/* Create an ihex object. */
174		173
175	static bfd_boolean	174	static bfd_boolean
176	ihex_mkobject (bfd *abfd)	175	ihex_mkobject (bfd *abfd)
177	{	176	{
178	struct ihex_data_struct *tdata;	177	struct ihex_data_struct *tdata;
179		178
180	tdata = (struct ihex_data_struct ) bfd_alloc (abfd, sizeof ( tdata));	179	tdata = (struct ihex_data_struct ) bfd_alloc (abfd, sizeof ( tdata));
181	if (tdata == NULL)	180	if (tdata == NULL)
182	return FALSE;	181	return FALSE;
183		182
184	abfd->tdata.ihex_data = tdata;	183	abfd->tdata.ihex_data = tdata;
185	tdata->head = NULL;	184	tdata->head = NULL;
186	tdata->tail = NULL;	185	tdata->tail = NULL;
187	return TRUE;	186	return TRUE;
188	}	187	}
189		188
190	/* Read a byte from a BFD. Set *ERRORPTR if an error occurred.	189	/* Read a byte from a BFD. Set *ERRORPTR if an error occurred.
191	Return EOF on error or end of file. */	190	Return EOF on error or end of file. */
192		191
193	static INLINE int	192	static INLINE int
194	ihex_get_byte (bfd abfd, bfd_boolean errorptr)	193	ihex_get_byte (bfd abfd, bfd_boolean errorptr)
195	{	194	{
196	bfd_byte c;	195	bfd_byte c;
197		196
198	if (bfd_bread (&c, (bfd_size_type) 1, abfd) != 1)	197	if (bfd_bread (&c, (bfd_size_type) 1, abfd) != 1)
199	{	198	{
200	if (bfd_get_error () != bfd_error_file_truncated)	199	if (bfd_get_error () != bfd_error_file_truncated)
201	*errorptr = TRUE;	200	*errorptr = TRUE;
202	return EOF;	201	return EOF;
203	}	202	}
204		203
205	return (int) (c & 0xff);	204	return (int) (c & 0xff);
206	}	205	}
207		206
208	/* Report a problem in an Intel Hex file. */	207	/* Report a problem in an Intel Hex file. */
209		208
210	static void	209	static void
211	ihex_bad_byte (bfd *abfd, unsigned int lineno, int c, bfd_boolean error)	210	ihex_bad_byte (bfd *abfd, unsigned int lineno, int c, bfd_boolean error)
212	{	211	{
213	if (c == EOF)	212	if (c == EOF)
214	{	213	{
215	if (! error)	214	if (! error)
216	bfd_set_error (bfd_error_file_truncated);	215	bfd_set_error (bfd_error_file_truncated);
217	}	216	}
218	else	217	else
219	{	218	{
220	char buf[10];	219	char buf[10];
221		220
222	if (! ISPRINT (c))	221	if (! ISPRINT (c))
223	sprintf (buf, "\\%03o", (unsigned int) c);	222	sprintf (buf, "\\%03o", (unsigned int) c & 0xff);
224	else	223	else
225	{	224	{
226	buf[0] = c;	225	buf[0] = c;
227	buf[1] = '\0';	226	buf[1] = '\0';
228	}	227	}
229	(*_bfd_error_handler)	228	(*_bfd_error_handler)
230	(_("%B:%d: unexpected character `%s' in Intel Hex file"),	229	(_("%B:%d: unexpected character `%s' in Intel Hex file"),
231	abfd, lineno, buf);	230	abfd, lineno, buf);
232	bfd_set_error (bfd_error_bad_value);	231	bfd_set_error (bfd_error_bad_value);
233	}	232	}
234	}	233	}
235		234
236	/* Read an Intel hex file and turn it into sections. We create a new	235	/* Read an Intel hex file and turn it into sections. We create a new
237	section for each contiguous set of bytes. */	236	section for each contiguous set of bytes. */
238		237
239	static bfd_boolean	238	static bfd_boolean
240	ihex_scan (bfd *abfd)	239	ihex_scan (bfd *abfd)
241	{	240	{
242	bfd_vma segbase;	241	bfd_vma segbase;
243	bfd_vma extbase;	242	bfd_vma extbase;
244	asection *sec;	243	asection *sec;
245	unsigned int lineno;	244	unsigned int lineno;
246	bfd_boolean error;	245	bfd_boolean error;
247	bfd_byte *buf = NULL;	246	bfd_byte *buf = NULL;
248	size_t bufsize;	247	size_t bufsize;
249	int c;	248	int c;
250		249
251	if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)	250	if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
252	goto error_return;	251	goto error_return;
253		252
254	abfd->start_address = 0;	253	abfd->start_address = 0;
255		254
256	segbase = 0;	255	segbase = 0;
257	extbase = 0;	256	extbase = 0;
258	sec = NULL;	257	sec = NULL;
259	lineno = 1;	258	lineno = 1;
260	error = FALSE;	259	error = FALSE;
261	bufsize = 0;	260	bufsize = 0;
262		261
263	while ((c = ihex_get_byte (abfd, &error)) != EOF)	262	while ((c = ihex_get_byte (abfd, &error)) != EOF)
264	{	263	{
265	if (c == '\r')	264	if (c == '\r')
266	continue;	265	continue;
267	else if (c == '\n')	266	else if (c == '\n')
268	{	267	{
269	++lineno;	268	++lineno;
270	continue;	269	continue;
271	}	270	}
272	else if (c != ':')	271	else if (c != ':')
273	{	272	{
274	ihex_bad_byte (abfd, lineno, c, error);	273	ihex_bad_byte (abfd, lineno, c, error);
275	goto error_return;	274	goto error_return;
276	}	275	}
277	else	276	else
278	{	277	{
279	file_ptr pos;	278	file_ptr pos;
280	char hdr[8];	279	unsigned char hdr[8];
281	unsigned int i;	280	unsigned int i;
282	unsigned int len;	281	unsigned int len;
283	bfd_vma addr;	282	bfd_vma addr;
284	unsigned int type;	283	unsigned int type;
285	unsigned int chars;	284	unsigned int chars;
286	unsigned int chksum;	285	unsigned int chksum;
287		286
288	/* This is a data record. */	287	/* This is a data record. */
289	pos = bfd_tell (abfd) - 1;	288	pos = bfd_tell (abfd) - 1;
290		289
291	/* Read the header bytes. */	290	/* Read the header bytes. */
292	if (bfd_bread (hdr, (bfd_size_type) 8, abfd) != 8)	291	if (bfd_bread (hdr, (bfd_size_type) 8, abfd) != 8)
293	goto error_return;	292	goto error_return;
294		293
295	for (i = 0; i < 8; i++)	294	for (i = 0; i < 8; i++)
296	{	295	{
297	if (! ISHEX (hdr[i]))	296	if (! ISHEX (hdr[i]))
298	{	297	{
299	ihex_bad_byte (abfd, lineno, hdr[i], error);	298	ihex_bad_byte (abfd, lineno, hdr[i], error);
300	goto error_return;	299	goto error_return;
301	}	300	}
302	}	301	}
303		302
304	len = HEX2 (hdr);	303	len = HEX2 (hdr);
305	addr = HEX4 (hdr + 2);	304	addr = HEX4 (hdr + 2);
306	type = HEX2 (hdr + 6);	305	type = HEX2 (hdr + 6);
307		306
308	/* Read the data bytes. */	307	/* Read the data bytes. */
309	chars = len * 2 + 2;	308	chars = len * 2 + 2;
310	if (chars >= bufsize)	309	if (chars >= bufsize)
311	{	310	{
312	buf = (bfd_byte *) bfd_realloc (buf, (bfd_size_type) chars);	311	buf = (bfd_byte *) bfd_realloc (buf, (bfd_size_type) chars);
313	if (buf == NULL)	312	if (buf == NULL)
314	goto error_return;	313	goto error_return;
315	bufsize = chars;	314	bufsize = chars;
316	}	315	}
317		316
318	if (bfd_bread (buf, (bfd_size_type) chars, abfd) != chars)	317	if (bfd_bread (buf, (bfd_size_type) chars, abfd) != chars)
319	goto error_return;	318	goto error_return;
320		319
321	for (i = 0; i < chars; i++)	320	for (i = 0; i < chars; i++)
322	{	321	{
323	if (! ISHEX (buf[i]))	322	if (! ISHEX (buf[i]))
324	{	323	{
325	ihex_bad_byte (abfd, lineno, hdr[i], error);	324	ihex_bad_byte (abfd, lineno, buf[i], error);
326	goto error_return;	325	goto error_return;
327	}	326	}
328	}	327	}
329		328
330	/* Check the checksum. */	329	/* Check the checksum. */
331	chksum = len + addr + (addr >> 8) + type;	330	chksum = len + addr + (addr >> 8) + type;
332	for (i = 0; i < len; i++)	331	for (i = 0; i < len; i++)
333	chksum += HEX2 (buf + 2 * i);	332	chksum += HEX2 (buf + 2 * i);
334	if (((- chksum) & 0xff) != (unsigned int) HEX2 (buf + 2 * i))	333	if (((- chksum) & 0xff) != (unsigned int) HEX2 (buf + 2 * i))
335	{	334	{
336	(*_bfd_error_handler)	335	(*_bfd_error_handler)
337	(_("%B:%u: bad checksum in Intel Hex file (expected %u, found %u)"),	336	(_("%B:%u: bad checksum in Intel Hex file (expected %u, found %u)"),
338	abfd, lineno,	337	abfd, lineno,
339	(- chksum) & 0xff, (unsigned int) HEX2 (buf + 2 * i));	338	(- chksum) & 0xff, (unsigned int) HEX2 (buf + 2 * i));
340	bfd_set_error (bfd_error_bad_value);	339	bfd_set_error (bfd_error_bad_value);
341	goto error_return;	340	goto error_return;
342	}	341	}
343		342
344	switch (type)	343	switch (type)
345	{	344	{
346	case 0:	345	case 0:
347	/* This is a data record. */	346	/* This is a data record. */
348	if (sec != NULL	347	if (sec != NULL
349	&& sec->vma + sec->size == extbase + segbase + addr)	348	&& sec->vma + sec->size == extbase + segbase + addr)
350	{	349	{
351	/* This data goes at the end of the section we are	350	/* This data goes at the end of the section we are
352	currently building. */	351	currently building. */
353	sec->size += len;	352	sec->size += len;
354	}	353	}
355	else if (len > 0)	354	else if (len > 0)
356	{	355	{
357	char secbuf[20];	356	char secbuf[20];
358	char *secname;	357	char *secname;
359	bfd_size_type amt;	358	bfd_size_type amt;
360	flagword flags;	359	flagword flags;
361		360
362	sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);	361	sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
363	amt = strlen (secbuf) + 1;	362	amt = strlen (secbuf) + 1;
364	secname = (char *) bfd_alloc (abfd, amt);	363	secname = (char *) bfd_alloc (abfd, amt);
365	if (secname == NULL)	364	if (secname == NULL)
366	goto error_return;	365	goto error_return;
367	strcpy (secname, secbuf);	366	strcpy (secname, secbuf);
368	flags = SEC_HAS_CONTENTS \| SEC_LOAD \| SEC_ALLOC;	367	flags = SEC_HAS_CONTENTS \| SEC_LOAD \| SEC_ALLOC;
369	sec = bfd_make_section_with_flags (abfd, secname, flags);	368	sec = bfd_make_section_with_flags (abfd, secname, flags);
370	if (sec == NULL)	369	if (sec == NULL)
371	goto error_return;	370	goto error_return;
372	sec->vma = extbase + segbase + addr;	371	sec->vma = extbase + segbase + addr;
373	sec->lma = extbase + segbase + addr;	372	sec->lma = extbase + segbase + addr;
374	sec->size = len;	373	sec->size = len;
375	sec->filepos = pos;	374	sec->filepos = pos;
376	}	375	}
377	break;	376	break;
378		377
379	case 1:	378	case 1:
380	/* An end record. */	379	/* An end record. */
381	if (abfd->start_address == 0)	380	if (abfd->start_address == 0)
382	abfd->start_address = addr;	381	abfd->start_address = addr;
383	if (buf != NULL)	382	if (buf != NULL)
384	free (buf);	383	free (buf);
385	return TRUE;	384	return TRUE;
386		385
387	case 2:	386	case 2:
388	/* An extended address record. */	387	/* An extended address record. */
389	if (len != 2)	388	if (len != 2)
390	{	389	{
391	(*_bfd_error_handler)	390	(*_bfd_error_handler)
392	(_("%B:%u: bad extended address record length in Intel Hex file"),	391	(_("%B:%u: bad extended address record length in Intel Hex file"),
393	abfd, lineno);	392	abfd, lineno);
394	bfd_set_error (bfd_error_bad_value);	393	bfd_set_error (bfd_error_bad_value);
395	goto error_return;	394	goto error_return;
396	}	395	}
397		396
398	segbase = HEX4 (buf) << 4;	397	segbase = HEX4 (buf) << 4;
399		398
400	sec = NULL;	399	sec = NULL;
401		400
402	break;	401	break;
403		402
404	case 3:	403	case 3:
405	/* An extended start address record. */	404	/* An extended start address record. */
406	if (len != 4)	405	if (len != 4)
407	{	406	{
408	(*_bfd_error_handler)	407	(*_bfd_error_handler)
409	(_("%B:%u: bad extended start address length in Intel Hex file"),	408	(_("%B:%u: bad extended start address length in Intel Hex file"),
410	abfd, lineno);	409	abfd, lineno);
411	bfd_set_error (bfd_error_bad_value);	410	bfd_set_error (bfd_error_bad_value);
412	goto error_return;	411	goto error_return;
413	}	412	}
414		413
415	abfd->start_address += (HEX4 (buf) << 4) + HEX4 (buf + 4);	414	abfd->start_address += (HEX4 (buf) << 4) + HEX4 (buf + 4);
416		415
417	sec = NULL;	416	sec = NULL;
418		417
419	break;	418	break;
420		419
421	case 4:	420	case 4:
422	/* An extended linear address record. */	421	/* An extended linear address record. */
423	if (len != 2)	422	if (len != 2)
424	{	423	{
425	(*_bfd_error_handler)	424	(*_bfd_error_handler)
426	(_("%B:%u: bad extended linear address record length in Intel Hex file"),	425	(_("%B:%u: bad extended linear address record length in Intel Hex file"),
427	abfd, lineno);	426	abfd, lineno);
428	bfd_set_error (bfd_error_bad_value);	427	bfd_set_error (bfd_error_bad_value);
429	goto error_return;	428	goto error_return;
430	}	429	}
431		430
432	extbase = HEX4 (buf) << 16;	431	extbase = HEX4 (buf) << 16;
433		432
434	sec = NULL;	433	sec = NULL;
435		434
436	break;	435	break;
437		436
438	case 5:	437	case 5:
439	/* An extended linear start address record. */	438	/* An extended linear start address record. */
440	if (len != 2 && len != 4)	439	if (len != 2 && len != 4)
441	{	440	{
442	(*_bfd_error_handler)	441	(*_bfd_error_handler)
443	(_("%B:%u: bad extended linear start address length in Intel Hex file"),	442	(_("%B:%u: bad extended linear start address length in Intel Hex file"),
444	abfd, lineno);	443	abfd, lineno);
445	bfd_set_error (bfd_error_bad_value);	444	bfd_set_error (bfd_error_bad_value);
446	goto error_return;	445	goto error_return;
447	}	446	}
448		447
449	if (len == 2)	448	if (len == 2)
450	abfd->start_address += HEX4 (buf) << 16;	449	abfd->start_address += HEX4 (buf) << 16;
451	else	450	else
452	abfd->start_address = (HEX4 (buf) << 16) + HEX4 (buf + 4);	451	abfd->start_address = (HEX4 (buf) << 16) + HEX4 (buf + 4);
453		452
454	sec = NULL;	453	sec = NULL;
455		454
456	break;	455	break;
457		456
458	default:	457	default:
459	(*_bfd_error_handler)	458	(*_bfd_error_handler)
460	(_("%B:%u: unrecognized ihex type %u in Intel Hex file"),	459	(_("%B:%u: unrecognized ihex type %u in Intel Hex file"),
461	abfd, lineno, type);	460	abfd, lineno, type);
462	bfd_set_error (bfd_error_bad_value);	461	bfd_set_error (bfd_error_bad_value);
463	goto error_return;	462	goto error_return;
464	}	463	}
465	}	464	}
466	}	465	}
467		466
468	if (error)	467	if (error)
469	goto error_return;	468	goto error_return;
470		469
471	if (buf != NULL)	470	if (buf != NULL)
472	free (buf);	471	free (buf);
473		472
474	return TRUE;	473	return TRUE;
475		474
476	error_return:	475	error_return:
477	if (buf != NULL)	476	if (buf != NULL)
478	free (buf);	477	free (buf);
479	return FALSE;	478	return FALSE;
480	}	479	}
481		480
482	/* Try to recognize an Intel Hex file. */	481	/* Try to recognize an Intel Hex file. */
483		482
484	static const bfd_target *	483	static const bfd_target *
485	ihex_object_p (bfd *abfd)	484	ihex_object_p (bfd *abfd)
486	{	485	{
487	void * tdata_save;	486	void * tdata_save;
488	bfd_byte b[9];	487	bfd_byte b[9];
489	unsigned int i;	488	unsigned int i;
490	unsigned int type;	489	unsigned int type;
491		490
492	ihex_init ();	491	ihex_init ();
493		492
494	if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)	493	if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
495	return NULL;	494	return NULL;
496	if (bfd_bread (b, (bfd_size_type) 9, abfd) != 9)	495	if (bfd_bread (b, (bfd_size_type) 9, abfd) != 9)
497	{	496	{
498	if (bfd_get_error () == bfd_error_file_truncated)	497	if (bfd_get_error () == bfd_error_file_truncated)
499	bfd_set_error (bfd_error_wrong_format);	498	bfd_set_error (bfd_error_wrong_format);
500	return NULL;	499	return NULL;

Subversion Repositories Kolibri OS

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