/* BFD back-end for Intel Hex objects.
- Copyright 1995 Free Software Foundation, Inc.
+ Copyright 1995, 1996, 1998, 1999, 2000, 2001, 2002
+ Free Software Foundation, Inc.
-This file is part of BFD, the Binary File Descriptor library.
+ 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 2 of the License, or
-(at your option) any later version.
+ 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 2 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.
+ 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+ 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* This is what Intel Hex files look like:
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 "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
#include "libiberty.h"
-
-#include <ctype.h>
+#include "safe-ctype.h"
static void ihex_init PARAMS ((void));
static boolean ihex_mkobject PARAMS ((bfd *));
static boolean ihex_set_section_contents
PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
static boolean ihex_write_record
- PARAMS ((bfd *, bfd_size_type, bfd_vma, unsigned int, bfd_byte *));
+ PARAMS ((bfd *, size_t, unsigned int, unsigned int, bfd_byte *));
static boolean ihex_write_object_contents PARAMS ((bfd *));
-static asymbol *ihex_make_empty_symbol PARAMS ((bfd *));
static boolean ihex_set_arch_mach
PARAMS ((bfd *, enum bfd_architecture, unsigned long));
+static int ihex_sizeof_headers PARAMS ((bfd *, boolean));
/* The number of bytes we put on one line during output. */
-#define CHUNK (21)
+#define CHUNK 16
-/* Macros for converting between hex and binary. */
+/* Macros for converting between hex and binary. */
-#define NIBBLE(x) (hex_value (x))
+#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))
+#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. */
ihex_mkobject (abfd)
bfd *abfd;
{
- if (abfd->tdata.ihex_data == NULL)
- {
- struct ihex_data_struct *tdata;
+ struct ihex_data_struct *tdata;
+ bfd_size_type amt = sizeof (struct ihex_data_struct);
- tdata = ((struct ihex_data_struct *)
- bfd_alloc (abfd, sizeof (struct ihex_data_struct)));
- if (tdata == NULL)
- return false;
- abfd->tdata.ihex_data = tdata;
- tdata->head = NULL;
- tdata->tail = NULL;
- }
+ tdata = (struct ihex_data_struct *) bfd_alloc (abfd, amt);
+ if (tdata == NULL)
+ return false;
+ abfd->tdata.ihex_data = tdata;
+ tdata->head = NULL;
+ tdata->tail = NULL;
return true;
}
{
bfd_byte c;
- if (bfd_read (&c, 1, 1, abfd) != 1)
+ if (bfd_bread (&c, (bfd_size_type) 1, abfd) != 1)
{
if (bfd_get_error () != bfd_error_file_truncated)
*errorptr = true;
{
char buf[10];
- if (! isprint (c))
+ if (! ISPRINT (c))
sprintf (buf, "\\%03o", (unsigned int) c);
else
{
buf[1] = '\0';
}
(*_bfd_error_handler)
- ("%s:%d: unexpected character `%s' in Intel Hex file\n",
- bfd_get_filename (abfd), lineno, buf);
+ (_("%s:%d: unexpected character `%s' in Intel Hex file\n"),
+ bfd_archive_filename (abfd), lineno, buf);
bfd_set_error (bfd_error_bad_value);
}
}
bfd_vma segbase;
bfd_vma extbase;
asection *sec;
- int lineno;
+ unsigned int lineno;
boolean error;
- bfd_byte *buf;
+ bfd_byte *buf = NULL;
size_t bufsize;
int c;
abfd->start_address = 0;
- extbase = 0;
segbase = 0;
+ extbase = 0;
sec = NULL;
lineno = 1;
error = false;
- buf = NULL;
bufsize = 0;
+
while ((c = ihex_get_byte (abfd, &error)) != EOF)
{
if (c == '\r')
unsigned int chksum;
/* This is a data record. */
-
pos = bfd_tell (abfd) - 1;
/* Read the header bytes. */
-
- if (bfd_read (hdr, 1, 8, abfd) != 8)
+ if (bfd_bread (hdr, (bfd_size_type) 8, abfd) != 8)
goto error_return;
for (i = 0; i < 8; i++)
type = HEX2 (hdr + 6);
/* Read the data bytes. */
-
chars = len * 2 + 2;
if (chars >= bufsize)
{
- buf = (bfd_byte *) bfd_realloc (buf, chars);
+ buf = (bfd_byte *) bfd_realloc (buf, (bfd_size_type) chars);
if (buf == NULL)
goto error_return;
bufsize = chars;
}
- if (bfd_read (buf, 1, chars, abfd) != chars)
+ if (bfd_bread (buf, (bfd_size_type) chars, abfd) != chars)
goto error_return;
for (i = 0; i < chars; i++)
if (((- chksum) & 0xff) != (unsigned int) HEX2 (buf + 2 * i))
{
(*_bfd_error_handler)
- ("%s:%d: bad checksum in Intel Hex file (expected %u, found %u)",
- bfd_get_filename (abfd), lineno,
+ (_("%s:%u: bad checksum in Intel Hex file (expected %u, found %u)"),
+ bfd_archive_filename (abfd), lineno,
(- chksum) & 0xff, (unsigned int) HEX2 (buf + 2 * i));
bfd_set_error (bfd_error_bad_value);
goto error_return;
{
char secbuf[20];
char *secname;
+ bfd_size_type amt;
sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
- secname = (char *) bfd_alloc (abfd, strlen (secbuf) + 1);
+ amt = strlen (secbuf) + 1;
+ secname = (char *) bfd_alloc (abfd, amt);
if (secname == NULL)
goto error_return;
strcpy (secname, secbuf);
if (len != 2)
{
(*_bfd_error_handler)
- ("%s:%d: bad extended address record length in Intel Hex file",
- bfd_get_filename (abfd), lineno);
+ (_("%s:%u: bad extended address record length in Intel Hex file"),
+ bfd_archive_filename (abfd), lineno);
bfd_set_error (bfd_error_bad_value);
goto error_return;
}
if (len != 4)
{
(*_bfd_error_handler)
- ("%s:%d: bad extended start address length in Intel Hex file",
- bfd_get_filename (abfd), lineno);
+ (_("%s:%u: bad extended start address length in Intel Hex file"),
+ bfd_archive_filename (abfd), lineno);
bfd_set_error (bfd_error_bad_value);
goto error_return;
}
if (len != 2)
{
(*_bfd_error_handler)
- ("%s:%d: bad extended linear address record length in Intel Hex file",
- bfd_get_filename (abfd), lineno);
+ (_("%s:%u: bad extended linear address record length in Intel Hex file"),
+ bfd_archive_filename (abfd), lineno);
bfd_set_error (bfd_error_bad_value);
goto error_return;
}
- segbase = HEX4 (buf) << 16;
+ extbase = HEX4 (buf) << 16;
sec = NULL;
case 5:
/* An extended linear start address record. */
- if (len != 2)
+ if (len != 2 && len != 4)
{
(*_bfd_error_handler)
- ("%s:%d: bad extended linear start address length in Intel Hex file",
- bfd_get_filename (abfd), lineno);
+ (_("%s:%u: bad extended linear start address length in Intel Hex file"),
+ bfd_archive_filename (abfd), lineno);
bfd_set_error (bfd_error_bad_value);
goto error_return;
}
- abfd->start_address += HEX4 (buf) << 16;
+ if (len == 2)
+ abfd->start_address += HEX4 (buf) << 16;
+ else
+ abfd->start_address = (HEX4 (buf) << 16) + HEX4 (buf + 4);
sec = NULL;
default:
(*_bfd_error_handler)
- ("%s:%d: unrecognized ihex type %u in Intel Hex file\n",
- bfd_get_filename (abfd), lineno, type);
+ (_("%s:%u: unrecognized ihex type %u in Intel Hex file\n"),
+ bfd_archive_filename (abfd), lineno, type);
bfd_set_error (bfd_error_bad_value);
goto error_return;
}
ihex_object_p (abfd)
bfd *abfd;
{
+ PTR tdata_save;
bfd_byte b[9];
unsigned int i;
unsigned int type;
if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
return NULL;
- if (bfd_read (b, 1, 9, abfd) != 9)
+ 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);
}
/* OK, it looks like it really is an Intel Hex file. */
-
- if (! ihex_mkobject (abfd)
- || ! ihex_scan (abfd))
- return NULL;
+ 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;
}
{
int c;
bfd_byte *p;
- bfd_byte *buf;
+ bfd_byte *buf = NULL;
size_t bufsize;
boolean error;
goto error_return;
p = contents;
- buf = NULL;
bufsize = 0;
error = false;
while ((c = ihex_get_byte (abfd, &error)) != EOF)
know the exact format. */
BFD_ASSERT (c == ':');
- if (bfd_read (hdr, 1, 8, abfd) != 8)
+ if (bfd_bread (hdr, (bfd_size_type) 8, abfd) != 8)
goto error_return;
len = HEX2 (hdr);
if (type != 0)
{
(*_bfd_error_handler)
- ("%s: internal error in ihex_read_section",
- bfd_get_filename (abfd));
+ (_("%s: internal error in ihex_read_section"),
+ bfd_archive_filename (abfd));
bfd_set_error (bfd_error_bad_value);
goto error_return;
}
if (len * 2 > bufsize)
{
- buf = (bfd_byte *) bfd_realloc (buf, len * 2);
+ buf = (bfd_byte *) bfd_realloc (buf, (bfd_size_type) len * 2);
if (buf == NULL)
goto error_return;
bufsize = len * 2;
}
- if (bfd_read (buf, 1, len * 2, abfd) != len * 2)
+ if (bfd_bread (buf, (bfd_size_type) len * 2, abfd) != len * 2)
goto error_return;
for (i = 0; i < len; i++)
}
/* Skip the checksum. */
- if (bfd_read (buf, 1, 2, abfd) != 2)
+ if (bfd_bread (buf, (bfd_size_type) 2, abfd) != 2)
goto error_return;
}
if ((bfd_size_type) (p - contents) < section->_raw_size)
{
(*_bfd_error_handler)
- ("%s: bad section length in ihex_read_section",
- bfd_get_filename (abfd));
+ (_("%s: bad section length in ihex_read_section"),
+ bfd_archive_filename (abfd));
bfd_set_error (bfd_error_bad_value);
goto error_return;
}
struct ihex_data_list *n;
bfd_byte *data;
struct ihex_data_struct *tdata;
+ bfd_size_type amt;
if (count == 0
|| (section->flags & SEC_ALLOC) == 0
|| (section->flags & SEC_LOAD) == 0)
return true;
- n = ((struct ihex_data_list *)
- bfd_alloc (abfd, sizeof (struct ihex_data_list)));
+ amt = sizeof (struct ihex_data_list);
+ n = (struct ihex_data_list *) bfd_alloc (abfd, amt);
if (n == NULL)
return false;
static boolean
ihex_write_record (abfd, count, addr, type, data)
bfd *abfd;
- bfd_size_type count;
- bfd_vma addr;
+ size_t count;
+ unsigned int addr;
unsigned int type;
bfd_byte *data;
{
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])
p[2] = '\r';
p[3] = '\n';
- if (bfd_write (buf, 1, 9 + count * 2 + 4, abfd) != 9 + count * 2 + 4)
+ total = 9 + count * 2 + 4;
+ if (bfd_bwrite (buf, (bfd_size_type) total, abfd) != total)
return false;
return true;
ihex_write_object_contents (abfd)
bfd *abfd;
{
- bfd_vma extbase;
bfd_vma segbase;
+ bfd_vma extbase;
struct ihex_data_list *l;
- extbase = 0;
segbase = 0;
+ extbase = 0;
for (l = abfd->tdata.ihex_data->head; l != NULL; l = l->next)
{
bfd_vma where;
count = l->size;
while (count > 0)
{
- bfd_size_type now;
+ size_t now;
+ unsigned int rec_addr;
now = count;
- if (now > CHUNK)
+ if (count > CHUNK)
now = CHUNK;
- if (where > extbase + segbase + 0xffff)
+ 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] = (segbase >> 12) & 0xff;
- addr[1] = (segbase >> 4) & 0xff;
+ 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)
{
sprintf_vma (buf, where);
(*_bfd_error_handler)
- ("%s: address 0x%s out of range for Intex Hex file",
+ (_("%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] = (extbase >> 24) & 0xff;
- addr[1] = (extbase >> 16) & 0xff;
+ 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;
}
}
- if (! ihex_write_record (abfd, now, where - (extbase + segbase),
- 0, p))
+ 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;
start = abfd->start_address;
- if (start > 0xfffff)
+ if (start <= 0xfffff)
{
- startbuf[0] = (start >> 24) & 0xff;
- startbuf[1] = (start >> 16) & 0xff;
- if (! ihex_write_record (abfd, 2, 0, 5, startbuf))
+ 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;
- start &= 0xffff;
}
-
- startbuf[0] = ((start & 0xf0000) >> 12) & 0xff;
- startbuf[1] = 0;
- startbuf[2] = (start >> 8) & 0xff;
- startbuf[3] = start & 0xff;
- if (! ihex_write_record (abfd, 4, 0, 3, startbuf))
- return false;
}
if (! ihex_write_record (abfd, 0, 0, 1, NULL))
return true;
}
-/* Make an empty symbol. This is required only because
- bfd_make_section_anyway wants to create a symbol for the section. */
-
-static asymbol *
-ihex_make_empty_symbol (abfd)
- bfd *abfd;
-{
- asymbol *new;
-
- new = (asymbol *) bfd_zalloc (abfd, sizeof (asymbol));
- if (new != NULL)
- new->the_bfd = abfd;
- return new;
-}
-
/* Set the architecture for the output file. The architecture is
irrelevant, so we ignore errors about unknown architectures. */
/*ARGSUSED*/
static int
ihex_sizeof_headers (abfd, exec)
- bfd *abfd;
- boolean exec;
+ bfd *abfd ATTRIBUTE_UNUSED;
+ boolean exec ATTRIBUTE_UNUSED;
{
return 0;
}
#define ihex_get_symtab_upper_bound bfd_0l
#define ihex_get_symtab \
((long (*) PARAMS ((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_bfd_is_local_label _bfd_nosymbols_bfd_is_local_label
+#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_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_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_merge_sections bfd_generic_merge_sections
+#define ihex_bfd_discard_group bfd_generic_discard_group
#define ihex_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
+#define ihex_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
#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_final_link _bfd_generic_final_link
#define ihex_bfd_link_split_section _bfd_generic_link_split_section
{
"ihex", /* name */
bfd_target_ihex_flavour,
- true, /* target byte order */
- true, /* target headers byte order */
+ 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 */
BFD_JUMP_TABLE_LINK (ihex),
BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
+ NULL,
+
(PTR) 0
};
projects / binutils.git / blobdiff