1 /* BFD back-end for Intel Hex objects.
2 Copyright 1995 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor of Cygnus Support <ian@cygnus.com>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 /* This is what Intel Hex files look like:
27 16-bit address-field format, for files 64k bytes in length or less.
30 Byte 1 Header = colon(:)
31 2..3 The number of data bytes in hex notation
32 4..5 High byte of the record load address
33 6..7 Low byte of the record load address
34 8..9 Record type, must be "00"
35 10..x Data bytes in hex notation:
36 x = (number of bytes - 1) * 2 + 11
37 x+1..x+2 Checksum in hex notation
38 x+3..x+4 Carriage return, line feed
41 Byte 1 Header = colon (:)
42 2..3 The byte count, must be "00"
43 4..7 Transfer-address (usually "0000")
44 the jump-to address, execution start address
45 8..9 Record type, must be "01"
46 10..11 Checksum, in hex notation
47 12..13 Carriage return, line feed
51 MCS-86 format, using a 20-bit address for files larger than 64K bytes.
54 Byte 1 Header = colon (:)
55 2..3 The byte count of this record, hex notation
56 4..5 High byte of the record load address
57 6..7 Low byte of the record load address
58 8..9 Record type, must be "00"
59 10..x The data bytes in hex notation:
60 x = (number of data bytes - 1) * 2 + 11
61 x+1..x+2 Checksum in hex notation
62 x+3..x+4 Carriage return, line feed
64 EXTENDED ADDRESS RECORD
65 Byte 1 Header = colon(:)
66 2..3 The byte count, must be "02"
67 4..7 Load address, must be "0000"
68 8..9 Record type, must be "02"
69 10..11 High byte of the offset address
70 12..13 Low byte of the offset address
71 14..15 Checksum in hex notation
72 16..17 Carriage return, line feed
74 The checksums are the two's complement of the 8-bit sum
75 without carry of the byte count, offset address, and the
79 Byte 1 Header = colon (:)
80 2..3 The byte count, must be "04"
81 4..7 Load address, must be "0000"
82 8..9 Record type, must be "03"
85 18..19 Checksum in hex notation
86 20..21 Carriage return, line feed
88 Another document reports these additional types:
90 EXTENDED LINEAR ADDRESS RECORD
91 Byte 1 Header = colon (:)
92 2..3 The byte count, must be "02"
93 4..7 Load address, must be "0000"
94 8..9 Record type, must be "04"
95 10..13 Upper 16 bits of address of subsequent records
96 14..15 Checksum in hex notation
97 16..17 Carriage return, line feed
99 START LINEAR ADDRESS RECORD
100 Byte 1 Header = colon (:)
101 2..3 The byte count, must be "02"
102 4..7 Load address, must be "0000"
103 8..9 Record type, must be "05"
104 10..13 Upper 16 bits of start address
105 14..15 Checksum in hex notation
106 16..17 Carriage return, line feed
112 #include "libiberty.h"
116 static void ihex_init PARAMS ((void));
117 static boolean ihex_mkobject PARAMS ((bfd *));
118 static INLINE int ihex_get_byte PARAMS ((bfd *, boolean *));
119 static void ihex_bad_byte PARAMS ((bfd *, unsigned int, int, boolean));
120 static boolean ihex_scan PARAMS ((bfd *));
121 static const bfd_target *ihex_object_p PARAMS ((bfd *));
122 static boolean ihex_read_section PARAMS ((bfd *, asection *, bfd_byte *));
123 static boolean ihex_get_section_contents
124 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
125 static boolean ihex_set_section_contents
126 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
127 static boolean ihex_write_record
128 PARAMS ((bfd *, bfd_size_type, bfd_vma, unsigned int, bfd_byte *));
129 static boolean ihex_write_object_contents PARAMS ((bfd *));
130 static asymbol *ihex_make_empty_symbol PARAMS ((bfd *));
131 static boolean ihex_set_arch_mach
132 PARAMS ((bfd *, enum bfd_architecture, unsigned long));
134 /* The number of bytes we put on one line during output. */
138 /* Macros for converting between hex and binary. */
140 #define NIBBLE(x) (hex_value (x))
141 #define HEX2(buffer) ((NIBBLE ((buffer)[0]) << 4) + NIBBLE ((buffer)[1]))
142 #define HEX4(buffer) ((HEX2 (buffer) << 8) + HEX2 ((buffer) + 2))
143 #define ISHEX(x) (hex_p (x))
145 /* When we write out an ihex value, the values can not be output as
146 they are seen. Instead, we hold them in memory in this structure. */
148 struct ihex_data_list
150 struct ihex_data_list *next;
156 /* The ihex tdata information. */
158 struct ihex_data_struct
160 struct ihex_data_list *head;
161 struct ihex_data_list *tail;
164 /* Initialize by filling in the hex conversion array. */
169 static boolean inited;
178 /* Create an ihex object. */
184 if (abfd->tdata.ihex_data == NULL)
186 struct ihex_data_struct *tdata;
188 tdata = ((struct ihex_data_struct *)
189 bfd_alloc (abfd, sizeof (struct ihex_data_struct)));
192 abfd->tdata.ihex_data = tdata;
200 /* Read a byte from a BFD. Set *ERRORPTR if an error occurred.
201 Return EOF on error or end of file. */
204 ihex_get_byte (abfd, errorptr)
210 if (bfd_read (&c, 1, 1, abfd) != 1)
212 if (bfd_get_error () != bfd_error_file_truncated)
217 return (int) (c & 0xff);
220 /* Report a problem in an Intel Hex file. */
223 ihex_bad_byte (abfd, lineno, c, error)
232 bfd_set_error (bfd_error_file_truncated);
239 sprintf (buf, "\\%03o", (unsigned int) c);
245 (*_bfd_error_handler)
246 ("%s:%d: unexpected character `%s' in Intel Hex file\n",
247 bfd_get_filename (abfd), lineno, buf);
248 bfd_set_error (bfd_error_bad_value);
252 /* Read an Intel hex file and turn it into sections. We create a new
253 section for each contiguous set of bytes. */
268 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
271 abfd->start_address = 0;
280 while ((c = ihex_get_byte (abfd, &error)) != EOF)
291 ihex_bad_byte (abfd, lineno, c, error);
305 /* This is a data record. */
307 pos = bfd_tell (abfd) - 1;
309 /* Read the header bytes. */
311 if (bfd_read (hdr, 1, 8, abfd) != 8)
314 for (i = 0; i < 8; i++)
316 if (! ISHEX (hdr[i]))
318 ihex_bad_byte (abfd, lineno, hdr[i], error);
324 addr = HEX4 (hdr + 2);
325 type = HEX2 (hdr + 6);
327 /* Read the data bytes. */
330 if (chars >= bufsize)
332 buf = (bfd_byte *) bfd_realloc (buf, chars);
338 if (bfd_read (buf, 1, chars, abfd) != chars)
341 for (i = 0; i < chars; i++)
343 if (! ISHEX (buf[i]))
345 ihex_bad_byte (abfd, lineno, hdr[i], error);
350 /* Check the checksum. */
351 chksum = len + addr + (addr >> 8) + type;
352 for (i = 0; i < len; i++)
353 chksum += HEX2 (buf + 2 * i);
354 if (((- chksum) & 0xff) != (unsigned int) HEX2 (buf + 2 * i))
356 (*_bfd_error_handler)
357 ("%s:%d: bad checksum in Intel Hex file (expected %u, found %u)",
358 bfd_get_filename (abfd), lineno,
359 (- chksum) & 0xff, (unsigned int) HEX2 (buf + 2 * i));
360 bfd_set_error (bfd_error_bad_value);
367 /* This is a data record. */
369 && sec->vma + sec->_raw_size == extbase + segbase + addr)
371 /* This data goes at the end of the section we are
372 currently building. */
373 sec->_raw_size += len;
380 sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
381 secname = (char *) bfd_alloc (abfd, strlen (secbuf) + 1);
384 strcpy (secname, secbuf);
385 sec = bfd_make_section (abfd, secname);
388 sec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
389 sec->vma = extbase + segbase + addr;
390 sec->lma = extbase + segbase + addr;
391 sec->_raw_size = len;
398 if (abfd->start_address == 0)
399 abfd->start_address = addr;
405 /* An extended address record. */
408 (*_bfd_error_handler)
409 ("%s:%d: bad extended address record length in Intel Hex file",
410 bfd_get_filename (abfd), lineno);
411 bfd_set_error (bfd_error_bad_value);
415 segbase = HEX4 (buf) << 4;
422 /* An extended start address record. */
425 (*_bfd_error_handler)
426 ("%s:%d: bad extended start address length in Intel Hex file",
427 bfd_get_filename (abfd), lineno);
428 bfd_set_error (bfd_error_bad_value);
432 abfd->start_address += (HEX4 (buf) << 4) + HEX4 (buf + 4);
439 /* An extended linear address record. */
442 (*_bfd_error_handler)
443 ("%s:%d: bad extended linear address record length in Intel Hex file",
444 bfd_get_filename (abfd), lineno);
445 bfd_set_error (bfd_error_bad_value);
449 segbase = HEX4 (buf) << 16;
456 /* An extended linear start address record. */
459 (*_bfd_error_handler)
460 ("%s:%d: bad extended linear start address length in Intel Hex file",
461 bfd_get_filename (abfd), lineno);
462 bfd_set_error (bfd_error_bad_value);
466 abfd->start_address += HEX4 (buf) << 16;
473 (*_bfd_error_handler)
474 ("%s:%d: unrecognized ihex type %u in Intel Hex file\n",
475 bfd_get_filename (abfd), lineno, type);
476 bfd_set_error (bfd_error_bad_value);
496 /* Try to recognize an Intel Hex file. */
498 static const bfd_target *
508 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
510 if (bfd_read (b, 1, 9, abfd) != 9)
512 if (bfd_get_error () == bfd_error_file_truncated)
513 bfd_set_error (bfd_error_wrong_format);
519 bfd_set_error (bfd_error_wrong_format);
523 for (i = 1; i < 9; i++)
527 bfd_set_error (bfd_error_wrong_format);
535 bfd_set_error (bfd_error_wrong_format);
539 /* OK, it looks like it really is an Intel Hex file. */
541 if (! ihex_mkobject (abfd)
542 || ! ihex_scan (abfd))
548 /* Read the contents of a section in an Intel Hex file. */
551 ihex_read_section (abfd, section, contents)
562 if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0)
569 while ((c = ihex_get_byte (abfd, &error)) != EOF)
577 if (c == '\r' || c == '\n')
580 /* This is called after ihex_scan has succeeded, so we ought to
581 know the exact format. */
582 BFD_ASSERT (c == ':');
584 if (bfd_read (hdr, 1, 8, abfd) != 8)
588 addr = HEX4 (hdr + 2);
589 type = HEX2 (hdr + 6);
591 /* We should only see type 0 records here. */
594 (*_bfd_error_handler)
595 ("%s: internal error in ihex_read_section",
596 bfd_get_filename (abfd));
597 bfd_set_error (bfd_error_bad_value);
601 if (len * 2 > bufsize)
603 buf = (bfd_byte *) bfd_realloc (buf, len * 2);
609 if (bfd_read (buf, 1, len * 2, abfd) != len * 2)
612 for (i = 0; i < len; i++)
613 *p++ = HEX2 (buf + 2 * i);
614 if ((bfd_size_type) (p - contents) >= section->_raw_size)
616 /* We've read everything in the section. */
622 /* Skip the checksum. */
623 if (bfd_read (buf, 1, 2, abfd) != 2)
627 if ((bfd_size_type) (p - contents) < section->_raw_size)
629 (*_bfd_error_handler)
630 ("%s: bad section length in ihex_read_section",
631 bfd_get_filename (abfd));
632 bfd_set_error (bfd_error_bad_value);
647 /* Get the contents of a section in an Intel Hex file. */
650 ihex_get_section_contents (abfd, section, location, offset, count)
657 if (section->used_by_bfd == NULL)
659 section->used_by_bfd = bfd_alloc (abfd, section->_raw_size);
660 if (section->used_by_bfd == NULL)
662 if (! ihex_read_section (abfd, section, section->used_by_bfd))
666 memcpy (location, (bfd_byte *) section->used_by_bfd + offset,
672 /* Set the contents of a section in an Intel Hex file. */
675 ihex_set_section_contents (abfd, section, location, offset, count)
682 struct ihex_data_list *n;
684 struct ihex_data_struct *tdata;
687 || (section->flags & SEC_ALLOC) == 0
688 || (section->flags & SEC_LOAD) == 0)
691 n = ((struct ihex_data_list *)
692 bfd_alloc (abfd, sizeof (struct ihex_data_list)));
696 data = (bfd_byte *) bfd_alloc (abfd, count);
699 memcpy (data, location, (size_t) count);
702 n->where = section->lma + offset;
705 /* Sort the records by address. Optimize for the common case of
706 adding a record to the end of the list. */
707 tdata = abfd->tdata.ihex_data;
708 if (tdata->tail != NULL
709 && n->where >= tdata->tail->where)
711 tdata->tail->next = n;
717 register struct ihex_data_list **pp;
719 for (pp = &tdata->head;
720 *pp != NULL && (*pp)->where < n->where;
732 /* Write a record out to an Intel Hex file. */
735 ihex_write_record (abfd, count, addr, type, data)
742 static const char digs[] = "0123456789ABCDEF";
743 char buf[9 + CHUNK * 2 + 4];
748 #define TOHEX(buf, v) \
749 ((buf)[0] = digs[((v) >> 4) & 0xf], (buf)[1] = digs[(v) & 0xf])
752 TOHEX (buf + 1, count);
753 TOHEX (buf + 3, (addr >> 8) & 0xff);
754 TOHEX (buf + 5, addr & 0xff);
755 TOHEX (buf + 7, type);
757 chksum = count + addr + (addr >> 8) + type;
759 for (i = 0, p = buf + 9; i < count; i++, p += 2, data++)
765 TOHEX (p, (- chksum) & 0xff);
769 if (bfd_write (buf, 1, 9 + count * 2 + 4, abfd) != 9 + count * 2 + 4)
775 /* Write out an Intel Hex file. */
778 ihex_write_object_contents (abfd)
783 struct ihex_data_list *l;
787 for (l = abfd->tdata.ihex_data->head; l != NULL; l = l->next)
804 if (where > extbase + segbase + 0xffff)
808 /* We need a new base address. */
809 if (where <= 0xfffff)
811 segbase = where & 0xf0000;
812 addr[0] = (segbase >> 12) & 0xff;
813 addr[1] = (segbase >> 4) & 0xff;
814 if (! ihex_write_record (abfd, 2, 0, 2, addr))
819 extbase = where & 0xffff0000;
820 if (where > extbase + 0xffff)
824 sprintf_vma (buf, where);
825 (*_bfd_error_handler)
826 ("%s: address 0x%s out of range for Intex Hex file",
827 bfd_get_filename (abfd), buf);
828 bfd_set_error (bfd_error_bad_value);
831 addr[0] = (extbase >> 24) & 0xff;
832 addr[1] = (extbase >> 16) & 0xff;
833 if (! ihex_write_record (abfd, 2, 0, 4, addr))
838 if (! ihex_write_record (abfd, now, where - (extbase + segbase),
848 if (abfd->start_address != 0)
851 bfd_byte startbuf[4];
853 start = abfd->start_address;
857 startbuf[0] = (start >> 24) & 0xff;
858 startbuf[1] = (start >> 16) & 0xff;
859 if (! ihex_write_record (abfd, 2, 0, 5, startbuf))
864 startbuf[0] = ((start & 0xf0000) >> 12) & 0xff;
866 startbuf[2] = (start >> 8) & 0xff;
867 startbuf[3] = start & 0xff;
868 if (! ihex_write_record (abfd, 4, 0, 3, startbuf))
872 if (! ihex_write_record (abfd, 0, 0, 1, NULL))
878 /* Make an empty symbol. This is required only because
879 bfd_make_section_anyway wants to create a symbol for the section. */
882 ihex_make_empty_symbol (abfd)
887 new = (asymbol *) bfd_zalloc (abfd, sizeof (asymbol));
893 /* Set the architecture for the output file. The architecture is
894 irrelevant, so we ignore errors about unknown architectures. */
897 ihex_set_arch_mach (abfd, arch, mach)
899 enum bfd_architecture arch;
902 if (! bfd_default_set_arch_mach (abfd, arch, mach))
904 if (arch != bfd_arch_unknown)
910 /* Get the size of the headers, for the linker. */
914 ihex_sizeof_headers (abfd, exec)
921 /* Some random definitions for the target vector. */
923 #define ihex_close_and_cleanup _bfd_generic_close_and_cleanup
924 #define ihex_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
925 #define ihex_new_section_hook _bfd_generic_new_section_hook
926 #define ihex_get_section_contents_in_window \
927 _bfd_generic_get_section_contents_in_window
929 #define ihex_get_symtab_upper_bound bfd_0l
930 #define ihex_get_symtab \
931 ((long (*) PARAMS ((bfd *, asymbol **))) bfd_0l)
932 #define ihex_print_symbol _bfd_nosymbols_print_symbol
933 #define ihex_get_symbol_info _bfd_nosymbols_get_symbol_info
934 #define ihex_bfd_is_local_label _bfd_nosymbols_bfd_is_local_label
935 #define ihex_get_lineno _bfd_nosymbols_get_lineno
936 #define ihex_find_nearest_line _bfd_nosymbols_find_nearest_line
937 #define ihex_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
938 #define ihex_read_minisymbols _bfd_nosymbols_read_minisymbols
939 #define ihex_minisymbol_to_symbol _bfd_nosymbols_minisymbol_to_symbol
941 #define ihex_get_reloc_upper_bound \
942 ((long (*) PARAMS ((bfd *, asection *))) bfd_0l)
943 #define ihex_canonicalize_reloc \
944 ((long (*) PARAMS ((bfd *, asection *, arelent **, asymbol **))) bfd_0l)
945 #define ihex_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
947 #define ihex_bfd_get_relocated_section_contents \
948 bfd_generic_get_relocated_section_contents
949 #define ihex_bfd_relax_section bfd_generic_relax_section
950 #define ihex_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
951 #define ihex_bfd_link_add_symbols _bfd_generic_link_add_symbols
952 #define ihex_bfd_final_link _bfd_generic_final_link
953 #define ihex_bfd_link_split_section _bfd_generic_link_split_section
955 /* The Intel Hex target vector. */
957 const bfd_target ihex_vec =
960 bfd_target_ihex_flavour,
961 true, /* target byte order */
962 true, /* target headers byte order */
963 0, /* object flags */
964 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD), /* section flags */
965 0, /* leading underscore */
966 ' ', /* ar_pad_char */
967 16, /* ar_max_namelen */
968 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
969 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
970 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
971 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
972 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
973 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
977 ihex_object_p, /* bfd_check_format */
984 _bfd_generic_mkarchive,
987 { /* bfd_write_contents */
989 ihex_write_object_contents,
990 _bfd_write_archive_contents,
994 BFD_JUMP_TABLE_GENERIC (ihex),
995 BFD_JUMP_TABLE_COPY (_bfd_generic),
996 BFD_JUMP_TABLE_CORE (_bfd_nocore),
997 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
998 BFD_JUMP_TABLE_SYMBOLS (ihex),
999 BFD_JUMP_TABLE_RELOCS (ihex),
1000 BFD_JUMP_TABLE_WRITE (ihex),
1001 BFD_JUMP_TABLE_LINK (ihex),
1002 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),