1 /* BFD back-end for Intel Hex objects.
2 Copyright 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
3 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor of Cygnus Support <ian@cygnus.com>.
6 This file is part of BFD, the Binary File Descriptor library.
8 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
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
22 /* This is what Intel Hex files look like:
28 16-bit address-field format, for files 64k bytes in length or less.
31 Byte 1 Header = colon(:)
32 2..3 The number of data bytes in hex notation
33 4..5 High byte of the record load address
34 6..7 Low byte of the record load address
35 8..9 Record type, must be "00"
36 10..x Data bytes in hex notation:
37 x = (number of bytes - 1) * 2 + 11
38 x+1..x+2 Checksum in hex notation
39 x+3..x+4 Carriage return, line feed
42 Byte 1 Header = colon (:)
43 2..3 The byte count, must be "00"
44 4..7 Transfer-address (usually "0000")
45 the jump-to address, execution start address
46 8..9 Record type, must be "01"
47 10..11 Checksum, in hex notation
48 12..13 Carriage return, line feed
52 MCS-86 format, using a 20-bit address for files larger than 64K bytes.
55 Byte 1 Header = colon (:)
56 2..3 The byte count of this record, hex notation
57 4..5 High byte of the record load address
58 6..7 Low byte of the record load address
59 8..9 Record type, must be "00"
60 10..x The data bytes in hex notation:
61 x = (number of data bytes - 1) * 2 + 11
62 x+1..x+2 Checksum in hex notation
63 x+3..x+4 Carriage return, line feed
65 EXTENDED ADDRESS RECORD
66 Byte 1 Header = colon(:)
67 2..3 The byte count, must be "02"
68 4..7 Load address, must be "0000"
69 8..9 Record type, must be "02"
70 10..11 High byte of the offset address
71 12..13 Low byte of the offset address
72 14..15 Checksum in hex notation
73 16..17 Carriage return, line feed
75 The checksums are the two's complement of the 8-bit sum
76 without carry of the byte count, offset address, and the
80 Byte 1 Header = colon (:)
81 2..3 The byte count, must be "04"
82 4..7 Load address, must be "0000"
83 8..9 Record type, must be "03"
86 18..19 Checksum in hex notation
87 20..21 Carriage return, line feed
89 Another document reports these additional types:
91 EXTENDED LINEAR ADDRESS RECORD
92 Byte 1 Header = colon (:)
93 2..3 The byte count, must be "02"
94 4..7 Load address, must be "0000"
95 8..9 Record type, must be "04"
96 10..13 Upper 16 bits of address of subsequent records
97 14..15 Checksum in hex notation
98 16..17 Carriage return, line feed
100 START LINEAR ADDRESS RECORD
101 Byte 1 Header = colon (:)
102 2..3 The byte count, must be "02"
103 4..7 Load address, must be "0000"
104 8..9 Record type, must be "05"
105 10..13 Upper 16 bits of start address
106 14..15 Checksum in hex notation
107 16..17 Carriage return, line feed
109 The MRI compiler uses this, which is a repeat of type 5:
111 EXTENDED START RECORD
112 Byte 1 Header = colon (:)
113 2..3 The byte count, must be "04"
114 4..7 Load address, must be "0000"
115 8..9 Record type, must be "05"
116 10..13 Upper 16 bits of start address
117 14..17 Lower 16 bits of start address
118 18..19 Checksum in hex notation
119 20..21 Carriage return, line feed. */
124 #include "libiberty.h"
125 #include "safe-ctype.h"
127 /* The number of bytes we put on one line during output. */
131 /* Macros for converting between hex and binary. */
133 #define NIBBLE(x) (hex_value (x))
134 #define HEX2(buffer) ((NIBBLE ((buffer)[0]) << 4) + NIBBLE ((buffer)[1]))
135 #define HEX4(buffer) ((HEX2 (buffer) << 8) + HEX2 ((buffer) + 2))
136 #define ISHEX(x) (hex_p (x))
138 /* When we write out an ihex value, the values can not be output as
139 they are seen. Instead, we hold them in memory in this structure. */
141 struct ihex_data_list
143 struct ihex_data_list *next;
149 /* The ihex tdata information. */
151 struct ihex_data_struct
153 struct ihex_data_list *head;
154 struct ihex_data_list *tail;
157 /* Initialize by filling in the hex conversion array. */
162 static bfd_boolean inited;
171 /* Create an ihex object. */
174 ihex_mkobject (bfd *abfd)
176 struct ihex_data_struct *tdata;
178 tdata = bfd_alloc (abfd, sizeof (* tdata));
182 abfd->tdata.ihex_data = tdata;
188 /* Read a byte from a BFD. Set *ERRORPTR if an error occurred.
189 Return EOF on error or end of file. */
192 ihex_get_byte (bfd *abfd, bfd_boolean *errorptr)
196 if (bfd_bread (&c, (bfd_size_type) 1, abfd) != 1)
198 if (bfd_get_error () != bfd_error_file_truncated)
203 return (int) (c & 0xff);
206 /* Report a problem in an Intel Hex file. */
209 ihex_bad_byte (bfd *abfd, unsigned int lineno, int c, bfd_boolean error)
214 bfd_set_error (bfd_error_file_truncated);
221 sprintf (buf, "\\%03o", (unsigned int) c);
227 (*_bfd_error_handler)
228 (_("%B:%d: unexpected character `%s' in Intel Hex file"),
230 bfd_set_error (bfd_error_bad_value);
234 /* Read an Intel hex file and turn it into sections. We create a new
235 section for each contiguous set of bytes. */
238 ihex_scan (bfd *abfd)
245 bfd_byte *buf = NULL;
249 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
252 abfd->start_address = 0;
261 while ((c = ihex_get_byte (abfd, &error)) != EOF)
272 ihex_bad_byte (abfd, lineno, c, error);
286 /* This is a data record. */
287 pos = bfd_tell (abfd) - 1;
289 /* Read the header bytes. */
290 if (bfd_bread (hdr, (bfd_size_type) 8, abfd) != 8)
293 for (i = 0; i < 8; i++)
295 if (! ISHEX (hdr[i]))
297 ihex_bad_byte (abfd, lineno, hdr[i], error);
303 addr = HEX4 (hdr + 2);
304 type = HEX2 (hdr + 6);
306 /* Read the data bytes. */
308 if (chars >= bufsize)
310 buf = bfd_realloc (buf, (bfd_size_type) chars);
316 if (bfd_bread (buf, (bfd_size_type) chars, abfd) != chars)
319 for (i = 0; i < chars; i++)
321 if (! ISHEX (buf[i]))
323 ihex_bad_byte (abfd, lineno, hdr[i], error);
328 /* Check the checksum. */
329 chksum = len + addr + (addr >> 8) + type;
330 for (i = 0; i < len; i++)
331 chksum += HEX2 (buf + 2 * i);
332 if (((- chksum) & 0xff) != (unsigned int) HEX2 (buf + 2 * i))
334 (*_bfd_error_handler)
335 (_("%B:%u: bad checksum in Intel Hex file (expected %u, found %u)"),
337 (- chksum) & 0xff, (unsigned int) HEX2 (buf + 2 * i));
338 bfd_set_error (bfd_error_bad_value);
345 /* This is a data record. */
347 && sec->vma + sec->size == extbase + segbase + addr)
349 /* This data goes at the end of the section we are
350 currently building. */
359 sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
360 amt = strlen (secbuf) + 1;
361 secname = bfd_alloc (abfd, amt);
364 strcpy (secname, secbuf);
365 sec = bfd_make_section (abfd, secname);
368 sec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
369 sec->vma = extbase + segbase + addr;
370 sec->lma = extbase + segbase + addr;
378 if (abfd->start_address == 0)
379 abfd->start_address = addr;
385 /* An extended address record. */
388 (*_bfd_error_handler)
389 (_("%B:%u: bad extended address record length in Intel Hex file"),
391 bfd_set_error (bfd_error_bad_value);
395 segbase = HEX4 (buf) << 4;
402 /* An extended start address record. */
405 (*_bfd_error_handler)
406 (_("%B:%u: bad extended start address length in Intel Hex file"),
408 bfd_set_error (bfd_error_bad_value);
412 abfd->start_address += (HEX4 (buf) << 4) + HEX4 (buf + 4);
419 /* An extended linear address record. */
422 (*_bfd_error_handler)
423 (_("%B:%u: bad extended linear address record length in Intel Hex file"),
425 bfd_set_error (bfd_error_bad_value);
429 extbase = HEX4 (buf) << 16;
436 /* An extended linear start address record. */
437 if (len != 2 && len != 4)
439 (*_bfd_error_handler)
440 (_("%B:%u: bad extended linear start address length in Intel Hex file"),
442 bfd_set_error (bfd_error_bad_value);
447 abfd->start_address += HEX4 (buf) << 16;
449 abfd->start_address = (HEX4 (buf) << 16) + HEX4 (buf + 4);
456 (*_bfd_error_handler)
457 (_("%B:%u: unrecognized ihex type %u in Intel Hex file"),
459 bfd_set_error (bfd_error_bad_value);
479 /* Try to recognize an Intel Hex file. */
481 static const bfd_target *
482 ihex_object_p (bfd *abfd)
491 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
493 if (bfd_bread (b, (bfd_size_type) 9, abfd) != 9)
495 if (bfd_get_error () == bfd_error_file_truncated)
496 bfd_set_error (bfd_error_wrong_format);
502 bfd_set_error (bfd_error_wrong_format);
506 for (i = 1; i < 9; i++)
510 bfd_set_error (bfd_error_wrong_format);
518 bfd_set_error (bfd_error_wrong_format);
522 /* OK, it looks like it really is an Intel Hex file. */
523 tdata_save = abfd->tdata.any;
524 if (! ihex_mkobject (abfd) || ! ihex_scan (abfd))
526 if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
527 bfd_release (abfd, abfd->tdata.any);
528 abfd->tdata.any = tdata_save;
535 /* Read the contents of a section in an Intel Hex file. */
538 ihex_read_section (bfd *abfd, asection *section, bfd_byte *contents)
542 bfd_byte *buf = NULL;
546 if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0)
552 while ((c = ihex_get_byte (abfd, &error)) != EOF)
559 if (c == '\r' || c == '\n')
562 /* This is called after ihex_scan has succeeded, so we ought to
563 know the exact format. */
564 BFD_ASSERT (c == ':');
566 if (bfd_bread (hdr, (bfd_size_type) 8, abfd) != 8)
570 type = HEX2 (hdr + 6);
572 /* We should only see type 0 records here. */
575 (*_bfd_error_handler)
576 (_("%B: internal error in ihex_read_section"), abfd);
577 bfd_set_error (bfd_error_bad_value);
581 if (len * 2 > bufsize)
583 buf = bfd_realloc (buf, (bfd_size_type) len * 2);
589 if (bfd_bread (buf, (bfd_size_type) len * 2, abfd) != len * 2)
592 for (i = 0; i < len; i++)
593 *p++ = HEX2 (buf + 2 * i);
594 if ((bfd_size_type) (p - contents) >= section->size)
596 /* We've read everything in the section. */
602 /* Skip the checksum. */
603 if (bfd_bread (buf, (bfd_size_type) 2, abfd) != 2)
607 if ((bfd_size_type) (p - contents) < section->size)
609 (*_bfd_error_handler)
610 (_("%B: bad section length in ihex_read_section"), abfd);
611 bfd_set_error (bfd_error_bad_value);
626 /* Get the contents of a section in an Intel Hex file. */
629 ihex_get_section_contents (bfd *abfd,
635 if (section->used_by_bfd == NULL)
637 section->used_by_bfd = bfd_alloc (abfd, section->size);
638 if (section->used_by_bfd == NULL)
640 if (! ihex_read_section (abfd, section, section->used_by_bfd))
644 memcpy (location, (bfd_byte *) section->used_by_bfd + offset,
650 /* Set the contents of a section in an Intel Hex file. */
653 ihex_set_section_contents (bfd *abfd,
655 const void * location,
659 struct ihex_data_list *n;
661 struct ihex_data_struct *tdata;
664 || (section->flags & SEC_ALLOC) == 0
665 || (section->flags & SEC_LOAD) == 0)
668 n = bfd_alloc (abfd, sizeof (* n));
672 data = bfd_alloc (abfd, count);
675 memcpy (data, location, (size_t) count);
678 n->where = section->lma + offset;
681 /* Sort the records by address. Optimize for the common case of
682 adding a record to the end of the list. */
683 tdata = abfd->tdata.ihex_data;
684 if (tdata->tail != NULL
685 && n->where >= tdata->tail->where)
687 tdata->tail->next = n;
693 struct ihex_data_list **pp;
695 for (pp = &tdata->head;
696 *pp != NULL && (*pp)->where < n->where;
708 /* Write a record out to an Intel Hex file. */
711 ihex_write_record (bfd *abfd,
717 static const char digs[] = "0123456789ABCDEF";
718 char buf[9 + CHUNK * 2 + 4];
724 #define TOHEX(buf, v) \
725 ((buf)[0] = digs[((v) >> 4) & 0xf], (buf)[1] = digs[(v) & 0xf])
728 TOHEX (buf + 1, count);
729 TOHEX (buf + 3, (addr >> 8) & 0xff);
730 TOHEX (buf + 5, addr & 0xff);
731 TOHEX (buf + 7, type);
733 chksum = count + addr + (addr >> 8) + type;
735 for (i = 0, p = buf + 9; i < count; i++, p += 2, data++)
741 TOHEX (p, (- chksum) & 0xff);
745 total = 9 + count * 2 + 4;
746 if (bfd_bwrite (buf, (bfd_size_type) total, abfd) != total)
752 /* Write out an Intel Hex file. */
755 ihex_write_object_contents (bfd *abfd)
759 struct ihex_data_list *l;
763 for (l = abfd->tdata.ihex_data->head; l != NULL; l = l->next)
776 unsigned int rec_addr;
782 if (where > segbase + extbase + 0xffff)
786 /* We need a new base address. */
787 if (where <= 0xfffff)
789 /* The addresses should be sorted. */
790 BFD_ASSERT (extbase == 0);
792 segbase = where & 0xf0000;
793 addr[0] = (bfd_byte)(segbase >> 12) & 0xff;
794 addr[1] = (bfd_byte)(segbase >> 4) & 0xff;
795 if (! ihex_write_record (abfd, 2, 0, 2, addr))
800 /* The extended address record and the extended
801 linear address record are combined, at least by
802 some readers. We need an extended linear address
803 record here, so if we've already written out an
804 extended address record, zero it out to avoid
810 if (! ihex_write_record (abfd, 2, 0, 2, addr))
815 extbase = where & 0xffff0000;
816 if (where > extbase + 0xffff)
820 sprintf_vma (buf, where);
821 (*_bfd_error_handler)
822 (_("%s: address 0x%s out of range for Intel Hex file"),
823 bfd_get_filename (abfd), buf);
824 bfd_set_error (bfd_error_bad_value);
827 addr[0] = (bfd_byte)(extbase >> 24) & 0xff;
828 addr[1] = (bfd_byte)(extbase >> 16) & 0xff;
829 if (! ihex_write_record (abfd, 2, 0, 4, addr))
834 rec_addr = where - (extbase + segbase);
836 /* Output records shouldn't cross 64K boundaries. */
837 if (rec_addr + now > 0xffff)
838 now = 0x10000 - rec_addr;
840 if (! ihex_write_record (abfd, now, rec_addr, 0, p))
849 if (abfd->start_address != 0)
852 bfd_byte startbuf[4];
854 start = abfd->start_address;
856 if (start <= 0xfffff)
858 startbuf[0] = (bfd_byte)((start & 0xf0000) >> 12) & 0xff;
860 startbuf[2] = (bfd_byte)(start >> 8) & 0xff;
861 startbuf[3] = (bfd_byte)start & 0xff;
862 if (! ihex_write_record (abfd, 4, 0, 3, startbuf))
867 startbuf[0] = (bfd_byte)(start >> 24) & 0xff;
868 startbuf[1] = (bfd_byte)(start >> 16) & 0xff;
869 startbuf[2] = (bfd_byte)(start >> 8) & 0xff;
870 startbuf[3] = (bfd_byte)start & 0xff;
871 if (! ihex_write_record (abfd, 4, 0, 5, startbuf))
876 if (! ihex_write_record (abfd, 0, 0, 1, NULL))
882 /* Set the architecture for the output file. The architecture is
883 irrelevant, so we ignore errors about unknown architectures. */
886 ihex_set_arch_mach (bfd *abfd,
887 enum bfd_architecture arch,
890 if (! bfd_default_set_arch_mach (abfd, arch, mach))
892 if (arch != bfd_arch_unknown)
898 /* Get the size of the headers, for the linker. */
901 ihex_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean exec ATTRIBUTE_UNUSED)
906 /* Some random definitions for the target vector. */
908 #define ihex_close_and_cleanup _bfd_generic_close_and_cleanup
909 #define ihex_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
910 #define ihex_new_section_hook _bfd_generic_new_section_hook
911 #define ihex_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
912 #define ihex_get_symtab_upper_bound bfd_0l
913 #define ihex_canonicalize_symtab ((long (*) (bfd *, asymbol **)) bfd_0l)
914 #define ihex_make_empty_symbol _bfd_generic_make_empty_symbol
915 #define ihex_print_symbol _bfd_nosymbols_print_symbol
916 #define ihex_get_symbol_info _bfd_nosymbols_get_symbol_info
917 #define ihex_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
918 #define ihex_bfd_is_local_label_name _bfd_nosymbols_bfd_is_local_label_name
919 #define ihex_get_lineno _bfd_nosymbols_get_lineno
920 #define ihex_find_nearest_line _bfd_nosymbols_find_nearest_line
921 #define ihex_find_inliner_info _bfd_nosymbols_find_inliner_info
922 #define ihex_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
923 #define ihex_read_minisymbols _bfd_nosymbols_read_minisymbols
924 #define ihex_minisymbol_to_symbol _bfd_nosymbols_minisymbol_to_symbol
925 #define ihex_get_reloc_upper_bound ((long (*) (bfd *, asection *)) bfd_0l)
926 #define ihex_canonicalize_reloc ((long (*) (bfd *, asection *, arelent **, asymbol **)) bfd_0l)
927 #define ihex_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
928 #define ihex_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
929 #define ihex_bfd_relax_section bfd_generic_relax_section
930 #define ihex_bfd_gc_sections bfd_generic_gc_sections
931 #define ihex_bfd_merge_sections bfd_generic_merge_sections
932 #define ihex_bfd_is_group_section bfd_generic_is_group_section
933 #define ihex_bfd_discard_group bfd_generic_discard_group
934 #define ihex_section_already_linked _bfd_generic_section_already_linked
935 #define ihex_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
936 #define ihex_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
937 #define ihex_bfd_link_add_symbols _bfd_generic_link_add_symbols
938 #define ihex_bfd_link_just_syms _bfd_generic_link_just_syms
939 #define ihex_bfd_final_link _bfd_generic_final_link
940 #define ihex_bfd_link_split_section _bfd_generic_link_split_section
942 /* The Intel Hex target vector. */
944 const bfd_target ihex_vec =
947 bfd_target_ihex_flavour,
948 BFD_ENDIAN_UNKNOWN, /* Target byte order. */
949 BFD_ENDIAN_UNKNOWN, /* Target headers byte order. */
950 0, /* Object flags. */
951 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD), /* Section flags. */
952 0, /* Leading underscore. */
953 ' ', /* AR_pad_char. */
954 16, /* AR_max_namelen. */
955 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
956 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
957 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */
958 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
959 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
960 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers. */
964 ihex_object_p, /* bfd_check_format. */
971 _bfd_generic_mkarchive,
974 { /* bfd_write_contents. */
976 ihex_write_object_contents,
977 _bfd_write_archive_contents,
981 BFD_JUMP_TABLE_GENERIC (ihex),
982 BFD_JUMP_TABLE_COPY (_bfd_generic),
983 BFD_JUMP_TABLE_CORE (_bfd_nocore),
984 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
985 BFD_JUMP_TABLE_SYMBOLS (ihex),
986 BFD_JUMP_TABLE_RELOCS (ihex),
987 BFD_JUMP_TABLE_WRITE (ihex),
988 BFD_JUMP_TABLE_LINK (ihex),
989 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),