1 /* BFD back-end for Intel Hex objects.
2 Copyright 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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
125 #include "libiberty.h"
126 #include "safe-ctype.h"
128 static void ihex_init
130 static bfd_boolean ihex_mkobject
132 static INLINE int ihex_get_byte
133 PARAMS ((bfd *, bfd_boolean *));
134 static void ihex_bad_byte
135 PARAMS ((bfd *, unsigned int, int, bfd_boolean));
136 static bfd_boolean ihex_scan
138 static const bfd_target *ihex_object_p
140 static bfd_boolean ihex_read_section
141 PARAMS ((bfd *, asection *, bfd_byte *));
142 static bfd_boolean ihex_get_section_contents
143 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
144 static bfd_boolean ihex_set_section_contents
145 PARAMS ((bfd *, asection *, const PTR, file_ptr, bfd_size_type));
146 static bfd_boolean ihex_write_record
147 PARAMS ((bfd *, size_t, unsigned int, unsigned int, bfd_byte *));
148 static bfd_boolean ihex_write_object_contents
150 static bfd_boolean ihex_set_arch_mach
151 PARAMS ((bfd *, enum bfd_architecture, unsigned long));
152 static int ihex_sizeof_headers
153 PARAMS ((bfd *, bfd_boolean));
155 /* The number of bytes we put on one line during output. */
159 /* Macros for converting between hex and binary. */
161 #define NIBBLE(x) (hex_value (x))
162 #define HEX2(buffer) ((NIBBLE ((buffer)[0]) << 4) + NIBBLE ((buffer)[1]))
163 #define HEX4(buffer) ((HEX2 (buffer) << 8) + HEX2 ((buffer) + 2))
164 #define ISHEX(x) (hex_p (x))
166 /* When we write out an ihex value, the values can not be output as
167 they are seen. Instead, we hold them in memory in this structure. */
169 struct ihex_data_list
171 struct ihex_data_list *next;
177 /* The ihex tdata information. */
179 struct ihex_data_struct
181 struct ihex_data_list *head;
182 struct ihex_data_list *tail;
185 /* Initialize by filling in the hex conversion array. */
190 static bfd_boolean inited;
199 /* Create an ihex object. */
205 struct ihex_data_struct *tdata;
206 bfd_size_type amt = sizeof (struct ihex_data_struct);
208 tdata = (struct ihex_data_struct *) bfd_alloc (abfd, amt);
212 abfd->tdata.ihex_data = tdata;
218 /* Read a byte from a BFD. Set *ERRORPTR if an error occurred.
219 Return EOF on error or end of file. */
222 ihex_get_byte (abfd, errorptr)
224 bfd_boolean *errorptr;
228 if (bfd_bread (&c, (bfd_size_type) 1, abfd) != 1)
230 if (bfd_get_error () != bfd_error_file_truncated)
235 return (int) (c & 0xff);
238 /* Report a problem in an Intel Hex file. */
241 ihex_bad_byte (abfd, lineno, c, error)
250 bfd_set_error (bfd_error_file_truncated);
257 sprintf (buf, "\\%03o", (unsigned int) c);
263 (*_bfd_error_handler)
264 (_("%s:%d: unexpected character `%s' in Intel Hex file\n"),
265 bfd_archive_filename (abfd), lineno, buf);
266 bfd_set_error (bfd_error_bad_value);
270 /* Read an Intel hex file and turn it into sections. We create a new
271 section for each contiguous set of bytes. */
282 bfd_byte *buf = NULL;
286 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
289 abfd->start_address = 0;
298 while ((c = ihex_get_byte (abfd, &error)) != EOF)
309 ihex_bad_byte (abfd, lineno, c, error);
323 /* This is a data record. */
324 pos = bfd_tell (abfd) - 1;
326 /* Read the header bytes. */
327 if (bfd_bread (hdr, (bfd_size_type) 8, abfd) != 8)
330 for (i = 0; i < 8; i++)
332 if (! ISHEX (hdr[i]))
334 ihex_bad_byte (abfd, lineno, hdr[i], error);
340 addr = HEX4 (hdr + 2);
341 type = HEX2 (hdr + 6);
343 /* Read the data bytes. */
345 if (chars >= bufsize)
347 buf = (bfd_byte *) bfd_realloc (buf, (bfd_size_type) chars);
353 if (bfd_bread (buf, (bfd_size_type) chars, abfd) != chars)
356 for (i = 0; i < chars; i++)
358 if (! ISHEX (buf[i]))
360 ihex_bad_byte (abfd, lineno, hdr[i], error);
365 /* Check the checksum. */
366 chksum = len + addr + (addr >> 8) + type;
367 for (i = 0; i < len; i++)
368 chksum += HEX2 (buf + 2 * i);
369 if (((- chksum) & 0xff) != (unsigned int) HEX2 (buf + 2 * i))
371 (*_bfd_error_handler)
372 (_("%s:%u: bad checksum in Intel Hex file (expected %u, found %u)"),
373 bfd_archive_filename (abfd), lineno,
374 (- chksum) & 0xff, (unsigned int) HEX2 (buf + 2 * i));
375 bfd_set_error (bfd_error_bad_value);
382 /* This is a data record. */
384 && sec->vma + sec->_raw_size == extbase + segbase + addr)
386 /* This data goes at the end of the section we are
387 currently building. */
388 sec->_raw_size += len;
396 sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
397 amt = strlen (secbuf) + 1;
398 secname = (char *) bfd_alloc (abfd, amt);
401 strcpy (secname, secbuf);
402 sec = bfd_make_section (abfd, secname);
405 sec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
406 sec->vma = extbase + segbase + addr;
407 sec->lma = extbase + segbase + addr;
408 sec->_raw_size = len;
415 if (abfd->start_address == 0)
416 abfd->start_address = addr;
422 /* An extended address record. */
425 (*_bfd_error_handler)
426 (_("%s:%u: bad extended address record length in Intel Hex file"),
427 bfd_archive_filename (abfd), lineno);
428 bfd_set_error (bfd_error_bad_value);
432 segbase = HEX4 (buf) << 4;
439 /* An extended start address record. */
442 (*_bfd_error_handler)
443 (_("%s:%u: bad extended start address length in Intel Hex file"),
444 bfd_archive_filename (abfd), lineno);
445 bfd_set_error (bfd_error_bad_value);
449 abfd->start_address += (HEX4 (buf) << 4) + HEX4 (buf + 4);
456 /* An extended linear address record. */
459 (*_bfd_error_handler)
460 (_("%s:%u: bad extended linear address record length in Intel Hex file"),
461 bfd_archive_filename (abfd), lineno);
462 bfd_set_error (bfd_error_bad_value);
466 extbase = HEX4 (buf) << 16;
473 /* An extended linear start address record. */
474 if (len != 2 && len != 4)
476 (*_bfd_error_handler)
477 (_("%s:%u: bad extended linear start address length in Intel Hex file"),
478 bfd_archive_filename (abfd), lineno);
479 bfd_set_error (bfd_error_bad_value);
484 abfd->start_address += HEX4 (buf) << 16;
486 abfd->start_address = (HEX4 (buf) << 16) + HEX4 (buf + 4);
493 (*_bfd_error_handler)
494 (_("%s:%u: unrecognized ihex type %u in Intel Hex file\n"),
495 bfd_archive_filename (abfd), lineno, type);
496 bfd_set_error (bfd_error_bad_value);
516 /* Try to recognize an Intel Hex file. */
518 static const bfd_target *
529 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
531 if (bfd_bread (b, (bfd_size_type) 9, abfd) != 9)
533 if (bfd_get_error () == bfd_error_file_truncated)
534 bfd_set_error (bfd_error_wrong_format);
540 bfd_set_error (bfd_error_wrong_format);
544 for (i = 1; i < 9; i++)
548 bfd_set_error (bfd_error_wrong_format);
556 bfd_set_error (bfd_error_wrong_format);
560 /* OK, it looks like it really is an Intel Hex file. */
561 tdata_save = abfd->tdata.any;
562 if (! ihex_mkobject (abfd) || ! ihex_scan (abfd))
564 if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
565 bfd_release (abfd, abfd->tdata.any);
566 abfd->tdata.any = tdata_save;
573 /* Read the contents of a section in an Intel Hex file. */
576 ihex_read_section (abfd, section, contents)
583 bfd_byte *buf = NULL;
587 if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0)
593 while ((c = ihex_get_byte (abfd, &error)) != EOF)
601 if (c == '\r' || c == '\n')
604 /* This is called after ihex_scan has succeeded, so we ought to
605 know the exact format. */
606 BFD_ASSERT (c == ':');
608 if (bfd_bread (hdr, (bfd_size_type) 8, abfd) != 8)
612 addr = HEX4 (hdr + 2);
613 type = HEX2 (hdr + 6);
615 /* We should only see type 0 records here. */
618 (*_bfd_error_handler)
619 (_("%s: internal error in ihex_read_section"),
620 bfd_archive_filename (abfd));
621 bfd_set_error (bfd_error_bad_value);
625 if (len * 2 > bufsize)
627 buf = (bfd_byte *) bfd_realloc (buf, (bfd_size_type) len * 2);
633 if (bfd_bread (buf, (bfd_size_type) len * 2, abfd) != len * 2)
636 for (i = 0; i < len; i++)
637 *p++ = HEX2 (buf + 2 * i);
638 if ((bfd_size_type) (p - contents) >= section->_raw_size)
640 /* We've read everything in the section. */
646 /* Skip the checksum. */
647 if (bfd_bread (buf, (bfd_size_type) 2, abfd) != 2)
651 if ((bfd_size_type) (p - contents) < section->_raw_size)
653 (*_bfd_error_handler)
654 (_("%s: bad section length in ihex_read_section"),
655 bfd_archive_filename (abfd));
656 bfd_set_error (bfd_error_bad_value);
671 /* Get the contents of a section in an Intel Hex file. */
674 ihex_get_section_contents (abfd, section, location, offset, count)
681 if (section->used_by_bfd == NULL)
683 section->used_by_bfd = bfd_alloc (abfd, section->_raw_size);
684 if (section->used_by_bfd == NULL)
686 if (! ihex_read_section (abfd, section, section->used_by_bfd))
690 memcpy (location, (bfd_byte *) section->used_by_bfd + offset,
696 /* Set the contents of a section in an Intel Hex file. */
699 ihex_set_section_contents (abfd, section, location, offset, count)
706 struct ihex_data_list *n;
708 struct ihex_data_struct *tdata;
712 || (section->flags & SEC_ALLOC) == 0
713 || (section->flags & SEC_LOAD) == 0)
716 amt = sizeof (struct ihex_data_list);
717 n = (struct ihex_data_list *) bfd_alloc (abfd, amt);
721 data = (bfd_byte *) bfd_alloc (abfd, count);
724 memcpy (data, location, (size_t) count);
727 n->where = section->lma + offset;
730 /* Sort the records by address. Optimize for the common case of
731 adding a record to the end of the list. */
732 tdata = abfd->tdata.ihex_data;
733 if (tdata->tail != NULL
734 && n->where >= tdata->tail->where)
736 tdata->tail->next = n;
742 register struct ihex_data_list **pp;
744 for (pp = &tdata->head;
745 *pp != NULL && (*pp)->where < n->where;
757 /* Write a record out to an Intel Hex file. */
760 ihex_write_record (abfd, count, addr, type, data)
767 static const char digs[] = "0123456789ABCDEF";
768 char buf[9 + CHUNK * 2 + 4];
774 #define TOHEX(buf, v) \
775 ((buf)[0] = digs[((v) >> 4) & 0xf], (buf)[1] = digs[(v) & 0xf])
778 TOHEX (buf + 1, count);
779 TOHEX (buf + 3, (addr >> 8) & 0xff);
780 TOHEX (buf + 5, addr & 0xff);
781 TOHEX (buf + 7, type);
783 chksum = count + addr + (addr >> 8) + type;
785 for (i = 0, p = buf + 9; i < count; i++, p += 2, data++)
791 TOHEX (p, (- chksum) & 0xff);
795 total = 9 + count * 2 + 4;
796 if (bfd_bwrite (buf, (bfd_size_type) total, abfd) != total)
802 /* Write out an Intel Hex file. */
805 ihex_write_object_contents (abfd)
810 struct ihex_data_list *l;
814 for (l = abfd->tdata.ihex_data->head; l != NULL; l = l->next)
826 unsigned int rec_addr;
832 if (where > segbase + extbase + 0xffff)
836 /* We need a new base address. */
837 if (where <= 0xfffff)
839 /* The addresses should be sorted. */
840 BFD_ASSERT (extbase == 0);
842 segbase = where & 0xf0000;
843 addr[0] = (bfd_byte)(segbase >> 12) & 0xff;
844 addr[1] = (bfd_byte)(segbase >> 4) & 0xff;
845 if (! ihex_write_record (abfd, 2, 0, 2, addr))
850 /* The extended address record and the extended
851 linear address record are combined, at least by
852 some readers. We need an extended linear address
853 record here, so if we've already written out an
854 extended address record, zero it out to avoid
860 if (! ihex_write_record (abfd, 2, 0, 2, addr))
865 extbase = where & 0xffff0000;
866 if (where > extbase + 0xffff)
870 sprintf_vma (buf, where);
871 (*_bfd_error_handler)
872 (_("%s: address 0x%s out of range for Intel Hex file"),
873 bfd_get_filename (abfd), buf);
874 bfd_set_error (bfd_error_bad_value);
877 addr[0] = (bfd_byte)(extbase >> 24) & 0xff;
878 addr[1] = (bfd_byte)(extbase >> 16) & 0xff;
879 if (! ihex_write_record (abfd, 2, 0, 4, addr))
884 rec_addr = where - (extbase + segbase);
886 /* Output records shouldn't cross 64K boundaries. */
887 if (rec_addr + now > 0xffff)
888 now = 0x10000 - rec_addr;
890 if (! ihex_write_record (abfd, now, rec_addr, 0, p))
899 if (abfd->start_address != 0)
902 bfd_byte startbuf[4];
904 start = abfd->start_address;
906 if (start <= 0xfffff)
908 startbuf[0] = (bfd_byte)((start & 0xf0000) >> 12) & 0xff;
910 startbuf[2] = (bfd_byte)(start >> 8) & 0xff;
911 startbuf[3] = (bfd_byte)start & 0xff;
912 if (! ihex_write_record (abfd, 4, 0, 3, startbuf))
917 startbuf[0] = (bfd_byte)(start >> 24) & 0xff;
918 startbuf[1] = (bfd_byte)(start >> 16) & 0xff;
919 startbuf[2] = (bfd_byte)(start >> 8) & 0xff;
920 startbuf[3] = (bfd_byte)start & 0xff;
921 if (! ihex_write_record (abfd, 4, 0, 5, startbuf))
926 if (! ihex_write_record (abfd, 0, 0, 1, NULL))
932 /* Set the architecture for the output file. The architecture is
933 irrelevant, so we ignore errors about unknown architectures. */
936 ihex_set_arch_mach (abfd, arch, mach)
938 enum bfd_architecture arch;
941 if (! bfd_default_set_arch_mach (abfd, arch, mach))
943 if (arch != bfd_arch_unknown)
949 /* Get the size of the headers, for the linker. */
953 ihex_sizeof_headers (abfd, exec)
954 bfd *abfd ATTRIBUTE_UNUSED;
955 bfd_boolean exec ATTRIBUTE_UNUSED;
960 /* Some random definitions for the target vector. */
962 #define ihex_close_and_cleanup _bfd_generic_close_and_cleanup
963 #define ihex_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
964 #define ihex_new_section_hook _bfd_generic_new_section_hook
965 #define ihex_get_section_contents_in_window \
966 _bfd_generic_get_section_contents_in_window
968 #define ihex_get_symtab_upper_bound bfd_0l
969 #define ihex_canonicalize_symtab \
970 ((long (*) PARAMS ((bfd *, asymbol **))) bfd_0l)
971 #define ihex_make_empty_symbol _bfd_generic_make_empty_symbol
972 #define ihex_print_symbol _bfd_nosymbols_print_symbol
973 #define ihex_get_symbol_info _bfd_nosymbols_get_symbol_info
974 #define ihex_bfd_is_local_label_name _bfd_nosymbols_bfd_is_local_label_name
975 #define ihex_get_lineno _bfd_nosymbols_get_lineno
976 #define ihex_find_nearest_line _bfd_nosymbols_find_nearest_line
977 #define ihex_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
978 #define ihex_read_minisymbols _bfd_nosymbols_read_minisymbols
979 #define ihex_minisymbol_to_symbol _bfd_nosymbols_minisymbol_to_symbol
981 #define ihex_get_reloc_upper_bound \
982 ((long (*) PARAMS ((bfd *, asection *))) bfd_0l)
983 #define ihex_canonicalize_reloc \
984 ((long (*) PARAMS ((bfd *, asection *, arelent **, asymbol **))) bfd_0l)
985 #define ihex_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
987 #define ihex_bfd_get_relocated_section_contents \
988 bfd_generic_get_relocated_section_contents
989 #define ihex_bfd_relax_section bfd_generic_relax_section
990 #define ihex_bfd_gc_sections bfd_generic_gc_sections
991 #define ihex_bfd_merge_sections bfd_generic_merge_sections
992 #define ihex_bfd_discard_group bfd_generic_discard_group
993 #define ihex_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
994 #define ihex_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
995 #define ihex_bfd_link_add_symbols _bfd_generic_link_add_symbols
996 #define ihex_bfd_link_just_syms _bfd_generic_link_just_syms
997 #define ihex_bfd_final_link _bfd_generic_final_link
998 #define ihex_bfd_link_split_section _bfd_generic_link_split_section
1000 /* The Intel Hex target vector. */
1002 const bfd_target ihex_vec =
1005 bfd_target_ihex_flavour,
1006 BFD_ENDIAN_UNKNOWN, /* target byte order */
1007 BFD_ENDIAN_UNKNOWN, /* target headers byte order */
1008 0, /* object flags */
1009 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD), /* section flags */
1010 0, /* leading underscore */
1011 ' ', /* ar_pad_char */
1012 16, /* ar_max_namelen */
1013 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1014 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1015 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
1016 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1017 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1018 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1022 ihex_object_p, /* bfd_check_format */
1029 _bfd_generic_mkarchive,
1032 { /* bfd_write_contents */
1034 ihex_write_object_contents,
1035 _bfd_write_archive_contents,
1039 BFD_JUMP_TABLE_GENERIC (ihex),
1040 BFD_JUMP_TABLE_COPY (_bfd_generic),
1041 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1042 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1043 BFD_JUMP_TABLE_SYMBOLS (ihex),
1044 BFD_JUMP_TABLE_RELOCS (ihex),
1045 BFD_JUMP_TABLE_WRITE (ihex),
1046 BFD_JUMP_TABLE_LINK (ihex),
1047 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),