X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=bfd%2Fihex.c;h=4c8c249032abef789ed3e7e456532dc8cf6f552d;hb=0e1f1593bc441863d0e5dc586ca3dd8945d36782;hp=c356bcb05049f76accbba8392b2f932995a8ae3b;hpb=ffd15489119c7149cc73f0adb4ee80d79d150c92;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/ihex.c b/bfd/ihex.c index c356bcb050..4c8c249032 100644 --- a/bfd/ihex.c +++ b/bfd/ihex.c @@ -1,22 +1,24 @@ /* BFD back-end for Intel Hex objects. - Copyright 1995 Free Software Foundation, Inc. + Copyright (C) 1995-2020 Free Software Foundation, Inc. Written by Ian Lance Taylor of Cygnus Support . -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 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. + 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. */ -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: @@ -85,43 +87,54 @@ B. INTEL 2 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 "bfd.h" #include "sysdep.h" +#include "bfd.h" #include "libbfd.h" #include "libiberty.h" - -#include - -static void ihex_init PARAMS ((void)); -static boolean ihex_mkobject PARAMS ((bfd *)); -static INLINE int ihex_get_byte PARAMS ((bfd *, boolean *)); -static void ihex_bad_byte PARAMS ((bfd *, unsigned int, int, boolean)); -static boolean ihex_scan PARAMS ((bfd *)); -static const bfd_target *ihex_object_p PARAMS ((bfd *)); -static boolean ihex_read_section PARAMS ((bfd *, asection *, bfd_byte *)); -static boolean ihex_get_section_contents - PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type)); -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 *)); -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)); +#include "safe-ctype.h" /* 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. */ @@ -145,53 +158,46 @@ struct ihex_data_struct /* Initialize by filling in the hex conversion array. */ static void -ihex_init () +ihex_init (void) { - static boolean inited; + static bfd_boolean inited; if (! inited) { - inited = true; + inited = TRUE; hex_init (); } } /* Create an ihex object. */ -static boolean -ihex_mkobject (abfd) - bfd *abfd; +static bfd_boolean +ihex_mkobject (bfd *abfd) { - if (abfd->tdata.ihex_data == NULL) - { - struct ihex_data_struct *tdata; - - 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; - } + struct ihex_data_struct *tdata; - return true; + 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 (abfd, errorptr) - bfd *abfd; - boolean *errorptr; +ihex_get_byte (bfd *abfd, bfd_boolean *errorptr) { 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; + *errorptr = TRUE; return EOF; } @@ -201,11 +207,7 @@ ihex_get_byte (abfd, errorptr) /* Report a problem in an Intel Hex file. */ static void -ihex_bad_byte (abfd, lineno, c, error) - bfd *abfd; - unsigned int lineno; - int c; - boolean error; +ihex_bad_byte (bfd *abfd, unsigned int lineno, int c, bfd_boolean error) { if (c == EOF) { @@ -216,16 +218,17 @@ ihex_bad_byte (abfd, lineno, c, error) { char buf[10]; - if (! isprint (c)) - sprintf (buf, "\\%03o", (unsigned int) c); + if (! ISPRINT (c)) + sprintf (buf, "\\%03o", (unsigned int) c & 0xff); else { buf[0] = c; buf[1] = '\0'; } - (*_bfd_error_handler) - ("%s:%d: unexpected character `%s' in Intel Hex file\n", - bfd_get_filename (abfd), lineno, buf); + _bfd_error_handler + /* xgettext:c-format */ + (_("%pB:%d: unexpected character `%s' in Intel Hex file"), + abfd, lineno, buf); bfd_set_error (bfd_error_bad_value); } } @@ -233,27 +236,30 @@ ihex_bad_byte (abfd, lineno, c, error) /* Read an Intel hex file and turn it into sections. We create a new section for each contiguous set of bytes. */ -static boolean -ihex_scan (abfd) - bfd *abfd; +static bfd_boolean +ihex_scan (bfd *abfd) { - bfd_vma base; + bfd_vma segbase; + bfd_vma extbase; asection *sec; - int lineno; - boolean error; - bfd_byte *buf; + 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; - base = 0; + abfd->start_address = 0; + + segbase = 0; + extbase = 0; sec = NULL; lineno = 1; - error = false; - buf = NULL; + error = FALSE; bufsize = 0; + while ((c = ihex_get_byte (abfd, &error)) != EOF) { if (c == '\r') @@ -271,7 +277,7 @@ ihex_scan (abfd) else { file_ptr pos; - char hdr[8]; + unsigned char hdr[8]; unsigned int i; unsigned int len; bfd_vma addr; @@ -280,12 +286,10 @@ ihex_scan (abfd) 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++) @@ -302,24 +306,23 @@ ihex_scan (abfd) 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 (! ISHEX (buf[i])) { - ihex_bad_byte (abfd, lineno, hdr[i], error); + ihex_bad_byte (abfd, lineno, buf[i], error); goto error_return; } } @@ -330,9 +333,10 @@ ihex_scan (abfd) chksum += HEX2 (buf + 2 * 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, + _bfd_error_handler + /* xgettext:c-format */ + (_("%pB:%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; @@ -343,29 +347,32 @@ ihex_scan (abfd) case 0: /* This is a data record. */ if (sec != NULL - && sec->vma + sec->_raw_size == base + addr) + && sec->vma + sec->size == extbase + segbase + addr) { /* This data goes at the end of the section we are - currently building. */ - sec->_raw_size += len; + 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); - 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); - sec = bfd_make_section (abfd, secname); + flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC; + sec = bfd_make_section_with_flags (abfd, secname, flags); if (sec == NULL) goto error_return; - sec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC; - sec->vma = base + addr; - sec->lma = base + addr; - sec->_raw_size = len; + sec->vma = extbase + segbase + addr; + sec->lma = extbase + segbase + addr; + sec->size = len; sec->filepos = pos; } break; @@ -376,20 +383,21 @@ ihex_scan (abfd) abfd->start_address = addr; if (buf != NULL) free (buf); - return true; + return TRUE; case 2: /* An extended address record. */ if (len != 2) { - (*_bfd_error_handler) - ("%s:%d: bad extended address record length in Intel Hex file", - bfd_get_filename (abfd), lineno); + _bfd_error_handler + /* xgettext:c-format */ + (_("%pB:%u: bad extended address record length in Intel Hex file"), + abfd, lineno); bfd_set_error (bfd_error_bad_value); goto error_return; } - base = HEX4 (buf) << 4; + segbase = HEX4 (buf) << 4; sec = NULL; @@ -399,23 +407,64 @@ ihex_scan (abfd) /* An extended start address record. */ if (len != 4) { - (*_bfd_error_handler) - ("%s:%d: bad extended start address length in Intel Hex file", - bfd_get_filename (abfd), lineno); + _bfd_error_handler + /* xgettext:c-format */ + (_("%pB:%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 + /* xgettext:c-format */ + (_("%pB:%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 + /* xgettext:c-format */ + (_("%pB:%u: bad extended linear 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); + 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) - ("%s:%d: unrecognized ihex type %u in Intel Hex file\n", - bfd_get_filename (abfd), lineno, type); + _bfd_error_handler + /* xgettext:c-format */ + (_("%pB:%u: unrecognized ihex type %u in Intel Hex file"), + abfd, lineno, type); bfd_set_error (bfd_error_bad_value); goto error_return; } @@ -428,20 +477,20 @@ ihex_scan (abfd) if (buf != NULL) free (buf); - return true; + return TRUE; error_return: if (buf != NULL) free (buf); - return false; + return FALSE; } /* Try to recognize an Intel Hex file. */ static const bfd_target * -ihex_object_p (abfd) - bfd *abfd; +ihex_object_p (bfd *abfd) { + void * tdata_save; bfd_byte b[9]; unsigned int i; unsigned int type; @@ -450,7 +499,7 @@ ihex_object_p (abfd) 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); @@ -473,47 +522,46 @@ ihex_object_p (abfd) } type = HEX2 (b + 7); - if (type > 3) + if (type > 5) { bfd_set_error (bfd_error_wrong_format); return NULL; } /* 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; } /* Read the contents of a section in an Intel Hex file. */ -static boolean -ihex_read_section (abfd, section, contents) - bfd *abfd; - asection *section; - bfd_byte *contents; +static bfd_boolean +ihex_read_section (bfd *abfd, asection *section, bfd_byte *contents) { int c; bfd_byte *p; - bfd_byte *buf; + bfd_byte *buf = NULL; size_t bufsize; - boolean error; + bfd_boolean error; if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0) goto error_return; p = contents; - buf = NULL; bufsize = 0; - error = false; + error = FALSE; while ((c = ihex_get_byte (abfd, &error)) != EOF) { - char hdr[8]; + unsigned char hdr[8]; unsigned int len; - bfd_vma addr; unsigned int type; unsigned int i; @@ -521,57 +569,54 @@ ihex_read_section (abfd, section, contents) continue; /* This is called after ihex_scan has succeeded, so we ought to - know the exact format. */ + 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); - addr = HEX4 (hdr + 2); type = HEX2 (hdr + 6); /* We should only see type 0 records here. */ if (type != 0) { - (*_bfd_error_handler) - ("%s: internal error in ihex_read_section", - bfd_get_filename (abfd)); + _bfd_error_handler + (_("%pB: 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, 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++) *p++ = HEX2 (buf + 2 * i); - if ((bfd_size_type) (p - contents) >= section->_raw_size) + if ((bfd_size_type) (p - contents) >= section->size) { /* We've read everything in the section. */ if (buf != NULL) free (buf); - return true; + return TRUE; } /* 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) + if ((bfd_size_type) (p - contents) < section->size) { - (*_bfd_error_handler) - ("%s: bad section length in ihex_read_section", - bfd_get_filename (abfd)); + _bfd_error_handler + (_("%pB: bad section length in ihex_read_section"), abfd); bfd_set_error (bfd_error_bad_value); goto error_return; } @@ -579,48 +624,47 @@ ihex_read_section (abfd, section, contents) if (buf != NULL) free (buf); - return true; + return TRUE; error_return: if (buf != NULL) free (buf); - return false; + return FALSE; } /* Get the contents of a section in an Intel Hex file. */ -static boolean -ihex_get_section_contents (abfd, section, location, offset, count) - bfd *abfd; - asection *section; - PTR location; - file_ptr offset; - bfd_size_type count; +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->_raw_size); + section->used_by_bfd = bfd_alloc (abfd, section->size); if (section->used_by_bfd == NULL) - return false; - if (! ihex_read_section (abfd, section, section->used_by_bfd)) - return false; + 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; + return TRUE; } /* Set the contents of a section in an Intel Hex file. */ -static boolean -ihex_set_section_contents (abfd, section, location, offset, count) - bfd *abfd; - asection *section; - PTR location; - file_ptr offset; - bfd_size_type count; +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; @@ -629,29 +673,15 @@ ihex_set_section_contents (abfd, section, location, offset, count) if (count == 0 || (section->flags & SEC_ALLOC) == 0 || (section->flags & SEC_LOAD) == 0) - return true; - - /* Intel Hex files can only represent a limited number of addresses. */ - if (section->lma + offset + count >= ((0xffff) << 4) + 0xffff) - { - char buf[50]; - - sprintf_vma (buf, section->lma + offset + count); - (*_bfd_error_handler) - ("%s: address 0x%s out of range for Intel Hex file", - bfd_get_filename (abfd), buf); - bfd_set_error (bfd_error_invalid_operation); - return false; - } + return TRUE; - n = ((struct ihex_data_list *) - bfd_alloc (abfd, sizeof (struct ihex_data_list))); + n = (struct ihex_data_list *) bfd_alloc (abfd, sizeof (* n)); if (n == NULL) - return false; + return FALSE; data = (bfd_byte *) bfd_alloc (abfd, count); if (data == NULL) - return false; + return FALSE; memcpy (data, location, (size_t) count); n->data = data; @@ -670,7 +700,7 @@ ihex_set_section_contents (abfd, section, location, offset, count) } else { - register struct ihex_data_list **pp; + struct ihex_data_list **pp; for (pp = &tdata->head; *pp != NULL && (*pp)->where < n->where; @@ -682,24 +712,24 @@ ihex_set_section_contents (abfd, section, location, offset, count) tdata->tail = n; } - return true; + return TRUE; } /* Write a record out to an Intel Hex file. */ -static boolean -ihex_write_record (abfd, count, addr, type, data) - bfd *abfd; - bfd_size_type count; - bfd_vma addr; - unsigned int type; - bfd_byte *data; +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]) @@ -722,22 +752,24 @@ ihex_write_record (abfd, count, addr, type, data) p[2] = '\r'; p[3] = '\n'; - if (bfd_write (buf, 1, 9 + count * 2 + 4, abfd) != 9 + count * 2 + 4) - return false; + total = 9 + count * 2 + 4; + if (bfd_bwrite (buf, (bfd_size_type) total, abfd) != total) + return FALSE; - return true; + return TRUE; } /* Write out an Intel Hex file. */ -static boolean -ihex_write_object_contents (abfd) - bfd *abfd; +static bfd_boolean +ihex_write_object_contents (bfd *abfd) { - bfd_vma base; + bfd_vma segbase; + bfd_vma extbase; struct ihex_data_list *l; - base = 0; + segbase = 0; + extbase = 0; for (l = abfd->tdata.ihex_data->head; l != NULL; l = l->next) { bfd_vma where; @@ -745,32 +777,99 @@ ihex_write_object_contents (abfd) bfd_size_type count; where = l->where; + +#ifdef BFD64 + /* IHex only supports 32-bit addresses, and we want to check + that 64-bit addresses are in range. This isn't quite as + obvious as it may seem, since some targets have 32-bit + addresses that are sign extended to 64 bits. So complain + only if addresses overflow both unsigned and signed 32-bit + integers. */ + if (where > 0xffffffff + && where + 0x80000000 > 0xffffffff) + { + _bfd_error_handler + /* xgettext:c-format */ + (_("%pB 64-bit address %#" PRIx64 + " out of range for Intel Hex file"), + abfd, (uint64_t) where); + bfd_set_error (bfd_error_bad_value); + return FALSE; + } + where &= 0xffffffff; +#endif + p = l->data; 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 > base + 0xffff) + if (where > segbase + extbase + 0xffff) { bfd_byte addr[2]; - /* We need a new base address. We've already checked in - set_section_contents to make sure that we can - represent the address. */ - base = where & 0xf0000; - addr[0] = (base >> 12) & 0xff; - addr[1] = (base >> 4) & 0xff; - if (! ihex_write_record (abfd, 2, 0, 2, addr)) - return false; + /* 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) + { + _bfd_error_handler + /* xgettext:c-format */ + (_("%pB: address %#" PRIx64 + " out of range for Intel Hex file"), + abfd, (uint64_t) where); + 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; + } } - if (! ihex_write_record (abfd, now, where - base, 0, p)) - 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; @@ -780,131 +879,141 @@ ihex_write_object_contents (abfd) if (abfd->start_address != 0) { - bfd_byte start[4]; - - start[0] = ((abfd->start_address & 0xf0000) >> 12) & 0xff; - start[1] = 0; - start[2] = (abfd->start_address >> 8) & 0xff; - start[3] = abfd->start_address & 0xff; - if (! ihex_write_record (abfd, 4, 0, 3, start)) - return false; - } + bfd_vma start; + bfd_byte startbuf[4]; - if (! ihex_write_record (abfd, 0, 0, 1, NULL)) - return false; - - return true; -} + start = abfd->start_address; -/* Make an empty symbol. This is required only because - bfd_make_section_anyway wants to create a symbol for the section. */ + 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; + } + } -static asymbol * -ihex_make_empty_symbol (abfd) - bfd *abfd; -{ - asymbol *new; + if (! ihex_write_record (abfd, 0, 0, 1, NULL)) + return FALSE; - new = (asymbol *) bfd_zalloc (abfd, sizeof (asymbol)); - if (new != NULL) - new->the_bfd = abfd; - return new; + return TRUE; } /* Set the architecture for the output file. The architecture is irrelevant, so we ignore errors about unknown architectures. */ -static boolean -ihex_set_arch_mach (abfd, arch, mach) - bfd *abfd; - enum bfd_architecture arch; - unsigned long mach; +static bfd_boolean +ihex_set_arch_mach (bfd *abfd, + enum bfd_architecture arch, + unsigned long mach) { - bfd_default_set_arch_mach (abfd, arch, mach); - return true; + 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. */ -/*ARGSUSED*/ static int -ihex_sizeof_headers (abfd, exec) - bfd *abfd; - boolean exec; +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_nosymbols_get_symtab_upper_bound -#define ihex_get_symtab _bfd_nosymbols_get_symtab -#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_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_read_minisymbols _bfd_nosymbols_read_minisymbols -#define ihex_minisymbol_to_symbol _bfd_nosymbols_minisymbol_to_symbol - -#define ihex_get_reloc_upper_bound \ - ((long (*) PARAMS ((bfd *, asection *))) bfd_0l) -#define ihex_canonicalize_reloc \ - ((long (*) PARAMS ((bfd *, asection *, arelent **, asymbol **))) bfd_0l) -#define ihex_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup - -#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_link_hash_table_create _bfd_generic_link_hash_table_create -#define ihex_bfd_link_add_symbols _bfd_generic_link_add_symbols -#define ihex_bfd_final_link _bfd_generic_final_link -#define ihex_bfd_link_split_section _bfd_generic_link_split_section +#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_long_bfd_0 +#define ihex_canonicalize_symtab _bfd_nosymbols_canonicalize_symtab +#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_bool_bfd_asymbol_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_group_name bfd_generic_group_name +#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_hide_symbol _bfd_generic_link_hide_symbol +#define ihex_bfd_define_start_stop bfd_generic_define_start_stop +#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 +#define ihex_bfd_link_check_relocs _bfd_generic_link_check_relocs /* The Intel Hex target vector. */ const bfd_target ihex_vec = { - "ihex", /* name */ + "ihex", /* Name. */ bfd_target_ihex_flavour, - true, /* target byte order */ - true, /* 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 */ + 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_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_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers. */ { _bfd_dummy_target, - ihex_object_p, /* bfd_check_format */ + ihex_object_p, /* bfd_check_format. */ _bfd_dummy_target, _bfd_dummy_target, }, { - bfd_false, + _bfd_bool_bfd_false_error, ihex_mkobject, _bfd_generic_mkarchive, - bfd_false, + _bfd_bool_bfd_false_error, }, - { /* bfd_write_contents */ - bfd_false, + { /* bfd_write_contents. */ + _bfd_bool_bfd_false_error, ihex_write_object_contents, _bfd_write_archive_contents, - bfd_false, + _bfd_bool_bfd_false_error, }, BFD_JUMP_TABLE_GENERIC (ihex), @@ -912,10 +1021,12 @@ const bfd_target ihex_vec = BFD_JUMP_TABLE_CORE (_bfd_nocore), BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive), BFD_JUMP_TABLE_SYMBOLS (ihex), - BFD_JUMP_TABLE_RELOCS (ihex), + BFD_JUMP_TABLE_RELOCS (_bfd_norelocs), BFD_JUMP_TABLE_WRITE (ihex), BFD_JUMP_TABLE_LINK (ihex), BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), - (PTR) 0 + NULL, + + NULL };