1 /* BFD back-end for Intel Hex objects.
2 Copyright 1995, 1996, 1998, 1999, 2000, 2001
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"
129 static void ihex_init PARAMS ((void));
130 static boolean ihex_mkobject PARAMS ((bfd *));
131 static INLINE int ihex_get_byte PARAMS ((bfd *, boolean *));
132 static void ihex_bad_byte PARAMS ((bfd *, unsigned int, int, boolean));
133 static boolean ihex_scan PARAMS ((bfd *));
134 static const bfd_target *ihex_object_p PARAMS ((bfd *));
135 static boolean ihex_read_section PARAMS ((bfd *, asection *, bfd_byte *));
136 static boolean ihex_get_section_contents
137 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
138 static boolean ihex_set_section_contents
139 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
140 static boolean ihex_write_record
141 PARAMS ((bfd *, size_t, unsigned int, unsigned int, bfd_byte *));
142 static boolean ihex_write_object_contents PARAMS ((bfd *));
143 static asymbol *ihex_make_empty_symbol PARAMS ((bfd *));
144 static boolean ihex_set_arch_mach
145 PARAMS ((bfd *, enum bfd_architecture, unsigned long));
146 static int ihex_sizeof_headers PARAMS ((bfd *, boolean));
148 /* The number of bytes we put on one line during output. */
152 /* Macros for converting between hex and binary. */
154 #define NIBBLE(x) (hex_value (x))
155 #define HEX2(buffer) ((NIBBLE ((buffer)[0]) << 4) + NIBBLE ((buffer)[1]))
156 #define HEX4(buffer) ((HEX2 (buffer) << 8) + HEX2 ((buffer) + 2))
157 #define ISHEX(x) (hex_p (x))
159 /* When we write out an ihex value, the values can not be output as
160 they are seen. Instead, we hold them in memory in this structure. */
162 struct ihex_data_list
164 struct ihex_data_list *next;
170 /* The ihex tdata information. */
172 struct ihex_data_struct
174 struct ihex_data_list *head;
175 struct ihex_data_list *tail;
178 /* Initialize by filling in the hex conversion array. */
183 static boolean inited;
192 /* Create an ihex object. */
198 if (abfd->tdata.ihex_data == NULL)
200 struct ihex_data_struct *tdata;
201 bfd_size_type amt = sizeof (struct ihex_data_struct);
203 tdata = (struct ihex_data_struct *) bfd_alloc (abfd, amt);
206 abfd->tdata.ihex_data = tdata;
214 /* Read a byte from a BFD. Set *ERRORPTR if an error occurred.
215 Return EOF on error or end of file. */
218 ihex_get_byte (abfd, errorptr)
224 if (bfd_bread (&c, (bfd_size_type) 1, abfd) != 1)
226 if (bfd_get_error () != bfd_error_file_truncated)
231 return (int) (c & 0xff);
234 /* Report a problem in an Intel Hex file. */
237 ihex_bad_byte (abfd, lineno, c, error)
246 bfd_set_error (bfd_error_file_truncated);
253 sprintf (buf, "\\%03o", (unsigned int) c);
259 (*_bfd_error_handler)
260 (_("%s:%d: unexpected character `%s' in Intel Hex file\n"),
261 bfd_get_filename (abfd), lineno, buf);
262 bfd_set_error (bfd_error_bad_value);
266 /* Read an Intel hex file and turn it into sections. We create a new
267 section for each contiguous set of bytes. */
278 bfd_byte *buf = NULL;
282 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
285 abfd->start_address = 0;
293 while ((c = ihex_get_byte (abfd, &error)) != EOF)
304 ihex_bad_byte (abfd, lineno, c, error);
318 /* This is a data record. */
320 pos = bfd_tell (abfd) - 1;
322 /* Read the header bytes. */
324 if (bfd_bread (hdr, (bfd_size_type) 8, abfd) != 8)
327 for (i = 0; i < 8; i++)
329 if (! ISHEX (hdr[i]))
331 ihex_bad_byte (abfd, lineno, hdr[i], error);
337 addr = HEX4 (hdr + 2);
338 type = HEX2 (hdr + 6);
340 /* Read the data bytes. */
343 if (chars >= bufsize)
345 buf = (bfd_byte *) bfd_realloc (buf, (bfd_size_type) chars);
351 if (bfd_bread (buf, (bfd_size_type) chars, abfd) != chars)
354 for (i = 0; i < chars; i++)
356 if (! ISHEX (buf[i]))
358 ihex_bad_byte (abfd, lineno, hdr[i], error);
363 /* Check the checksum. */
364 chksum = len + addr + (addr >> 8) + type;
365 for (i = 0; i < len; i++)
366 chksum += HEX2 (buf + 2 * i);
367 if (((- chksum) & 0xff) != (unsigned int) HEX2 (buf + 2 * i))
369 (*_bfd_error_handler)
370 (_("%s:%u: bad checksum in Intel Hex file (expected %u, found %u)"),
371 bfd_get_filename (abfd), lineno,
372 (- chksum) & 0xff, (unsigned int) HEX2 (buf + 2 * i));
373 bfd_set_error (bfd_error_bad_value);
380 /* This is a data record. */
382 && sec->vma + sec->_raw_size == extbase + segbase + addr)
384 /* This data goes at the end of the section we are
385 currently building. */
386 sec->_raw_size += len;
394 sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
395 amt = strlen (secbuf) + 1;
396 secname = (char *) bfd_alloc (abfd, amt);
399 strcpy (secname, secbuf);
400 sec = bfd_make_section (abfd, secname);
403 sec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
404 sec->vma = extbase + segbase + addr;
405 sec->lma = extbase + segbase + addr;
406 sec->_raw_size = len;
413 if (abfd->start_address == 0)
414 abfd->start_address = addr;
420 /* An extended address record. */
423 (*_bfd_error_handler)
424 (_("%s:%u: bad extended address record length in Intel Hex file"),
425 bfd_get_filename (abfd), lineno);
426 bfd_set_error (bfd_error_bad_value);
430 segbase = HEX4 (buf) << 4;
437 /* An extended start address record. */
440 (*_bfd_error_handler)
441 (_("%s:%u: bad extended start address length in Intel Hex file"),
442 bfd_get_filename (abfd), lineno);
443 bfd_set_error (bfd_error_bad_value);
447 abfd->start_address += (HEX4 (buf) << 4) + HEX4 (buf + 4);
454 /* An extended linear address record. */
457 (*_bfd_error_handler)
458 (_("%s:%u: bad extended linear address record length in Intel Hex file"),
459 bfd_get_filename (abfd), lineno);
460 bfd_set_error (bfd_error_bad_value);
464 extbase = HEX4 (buf) << 16;
471 /* An extended linear start address record. */
472 if (len != 2 && len != 4)
474 (*_bfd_error_handler)
475 (_("%s:%u: bad extended linear start address length in Intel Hex file"),
476 bfd_get_filename (abfd), lineno);
477 bfd_set_error (bfd_error_bad_value);
482 abfd->start_address += HEX4 (buf) << 16;
484 abfd->start_address = (HEX4 (buf) << 16) + HEX4 (buf + 4);
491 (*_bfd_error_handler)
492 (_("%s:%u: unrecognized ihex type %u in Intel Hex file\n"),
493 bfd_get_filename (abfd), lineno, type);
494 bfd_set_error (bfd_error_bad_value);
514 /* Try to recognize an Intel Hex file. */
516 static const bfd_target *
526 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
528 if (bfd_bread (b, (bfd_size_type) 9, abfd) != 9)
530 if (bfd_get_error () == bfd_error_file_truncated)
531 bfd_set_error (bfd_error_wrong_format);
537 bfd_set_error (bfd_error_wrong_format);
541 for (i = 1; i < 9; i++)
545 bfd_set_error (bfd_error_wrong_format);
553 bfd_set_error (bfd_error_wrong_format);
557 /* OK, it looks like it really is an Intel Hex file. */
559 if (! ihex_mkobject (abfd)
560 || ! ihex_scan (abfd))
566 /* Read the contents of a section in an Intel Hex file. */
569 ihex_read_section (abfd, section, contents)
576 bfd_byte *buf = NULL;
580 if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0)
586 while ((c = ihex_get_byte (abfd, &error)) != EOF)
594 if (c == '\r' || c == '\n')
597 /* This is called after ihex_scan has succeeded, so we ought to
598 know the exact format. */
599 BFD_ASSERT (c == ':');
601 if (bfd_bread (hdr, (bfd_size_type) 8, abfd) != 8)
605 addr = HEX4 (hdr + 2);
606 type = HEX2 (hdr + 6);
608 /* We should only see type 0 records here. */
611 (*_bfd_error_handler)
612 (_("%s: internal error in ihex_read_section"),
613 bfd_get_filename (abfd));
614 bfd_set_error (bfd_error_bad_value);
618 if (len * 2 > bufsize)
620 buf = (bfd_byte *) bfd_realloc (buf, (bfd_size_type) len * 2);
626 if (bfd_bread (buf, (bfd_size_type) len * 2, abfd) != len * 2)
629 for (i = 0; i < len; i++)
630 *p++ = HEX2 (buf + 2 * i);
631 if ((bfd_size_type) (p - contents) >= section->_raw_size)
633 /* We've read everything in the section. */
639 /* Skip the checksum. */
640 if (bfd_bread (buf, (bfd_size_type) 2, abfd) != 2)
644 if ((bfd_size_type) (p - contents) < section->_raw_size)
646 (*_bfd_error_handler)
647 (_("%s: bad section length in ihex_read_section"),
648 bfd_get_filename (abfd));
649 bfd_set_error (bfd_error_bad_value);
664 /* Get the contents of a section in an Intel Hex file. */
667 ihex_get_section_contents (abfd, section, location, offset, count)
674 if (section->used_by_bfd == NULL)
676 section->used_by_bfd = bfd_alloc (abfd, section->_raw_size);
677 if (section->used_by_bfd == NULL)
679 if (! ihex_read_section (abfd, section, section->used_by_bfd))
683 memcpy (location, (bfd_byte *) section->used_by_bfd + offset,
689 /* Set the contents of a section in an Intel Hex file. */
692 ihex_set_section_contents (abfd, section, location, offset, count)
699 struct ihex_data_list *n;
701 struct ihex_data_struct *tdata;
705 || (section->flags & SEC_ALLOC) == 0
706 || (section->flags & SEC_LOAD) == 0)
709 amt = sizeof (struct ihex_data_list);
710 n = (struct ihex_data_list *) bfd_alloc (abfd, amt);
714 data = (bfd_byte *) bfd_alloc (abfd, count);
717 memcpy (data, location, (size_t) count);
720 n->where = section->lma + offset;
723 /* Sort the records by address. Optimize for the common case of
724 adding a record to the end of the list. */
725 tdata = abfd->tdata.ihex_data;
726 if (tdata->tail != NULL
727 && n->where >= tdata->tail->where)
729 tdata->tail->next = n;
735 register struct ihex_data_list **pp;
737 for (pp = &tdata->head;
738 *pp != NULL && (*pp)->where < n->where;
750 /* Write a record out to an Intel Hex file. */
753 ihex_write_record (abfd, count, addr, type, data)
760 static const char digs[] = "0123456789ABCDEF";
761 char buf[9 + CHUNK * 2 + 4];
767 #define TOHEX(buf, v) \
768 ((buf)[0] = digs[((v) >> 4) & 0xf], (buf)[1] = digs[(v) & 0xf])
771 TOHEX (buf + 1, count);
772 TOHEX (buf + 3, (addr >> 8) & 0xff);
773 TOHEX (buf + 5, addr & 0xff);
774 TOHEX (buf + 7, type);
776 chksum = count + addr + (addr >> 8) + type;
778 for (i = 0, p = buf + 9; i < count; i++, p += 2, data++)
784 TOHEX (p, (- chksum) & 0xff);
788 total = 9 + count * 2 + 4;
789 if (bfd_bwrite (buf, (bfd_size_type) total, abfd) != total)
795 /* Write out an Intel Hex file. */
798 ihex_write_object_contents (abfd)
803 struct ihex_data_list *l;
807 for (l = abfd->tdata.ihex_data->head; l != NULL; l = l->next)
819 unsigned int rec_addr;
825 if (where > segbase + extbase + 0xffff)
829 /* We need a new base address. */
830 if (where <= 0xfffff)
832 /* The addresses should be sorted. */
833 BFD_ASSERT (extbase == 0);
835 segbase = where & 0xf0000;
836 addr[0] = (bfd_byte)(segbase >> 12) & 0xff;
837 addr[1] = (bfd_byte)(segbase >> 4) & 0xff;
838 if (! ihex_write_record (abfd, 2, 0, 2, addr))
843 /* The extended address record and the extended
844 linear address record are combined, at least by
845 some readers. We need an extended linear address
846 record here, so if we've already written out an
847 extended address record, zero it out to avoid
853 if (! ihex_write_record (abfd, 2, 0, 2, addr))
858 extbase = where & 0xffff0000;
859 if (where > extbase + 0xffff)
863 sprintf_vma (buf, where);
864 (*_bfd_error_handler)
865 (_("%s: address 0x%s out of range for Intex Hex file"),
866 bfd_get_filename (abfd), buf);
867 bfd_set_error (bfd_error_bad_value);
870 addr[0] = (bfd_byte)(extbase >> 24) & 0xff;
871 addr[1] = (bfd_byte)(extbase >> 16) & 0xff;
872 if (! ihex_write_record (abfd, 2, 0, 4, addr))
877 rec_addr = where - (extbase + segbase);
878 if (! ihex_write_record (abfd, now, rec_addr, 0, p))
887 if (abfd->start_address != 0)
890 bfd_byte startbuf[4];
892 start = abfd->start_address;
894 if (start <= 0xfffff)
896 startbuf[0] = (bfd_byte)((start & 0xf0000) >> 12) & 0xff;
898 startbuf[2] = (bfd_byte)(start >> 8) & 0xff;
899 startbuf[3] = (bfd_byte)start & 0xff;
900 if (! ihex_write_record (abfd, 4, 0, 3, startbuf))
905 startbuf[0] = (bfd_byte)(start >> 24) & 0xff;
906 startbuf[1] = (bfd_byte)(start >> 16) & 0xff;
907 startbuf[2] = (bfd_byte)(start >> 8) & 0xff;
908 startbuf[3] = (bfd_byte)start & 0xff;
909 if (! ihex_write_record (abfd, 4, 0, 5, startbuf))
914 if (! ihex_write_record (abfd, 0, 0, 1, NULL))
920 /* Make an empty symbol. This is required only because
921 bfd_make_section_anyway wants to create a symbol for the section. */
924 ihex_make_empty_symbol (abfd)
929 new = (asymbol *) bfd_zalloc (abfd, (bfd_size_type) sizeof (asymbol));
935 /* Set the architecture for the output file. The architecture is
936 irrelevant, so we ignore errors about unknown architectures. */
939 ihex_set_arch_mach (abfd, arch, mach)
941 enum bfd_architecture arch;
944 if (! bfd_default_set_arch_mach (abfd, arch, mach))
946 if (arch != bfd_arch_unknown)
952 /* Get the size of the headers, for the linker. */
956 ihex_sizeof_headers (abfd, exec)
957 bfd *abfd ATTRIBUTE_UNUSED;
958 boolean exec ATTRIBUTE_UNUSED;
963 /* Some random definitions for the target vector. */
965 #define ihex_close_and_cleanup _bfd_generic_close_and_cleanup
966 #define ihex_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
967 #define ihex_new_section_hook _bfd_generic_new_section_hook
968 #define ihex_get_section_contents_in_window \
969 _bfd_generic_get_section_contents_in_window
971 #define ihex_get_symtab_upper_bound bfd_0l
972 #define ihex_get_symtab \
973 ((long (*) PARAMS ((bfd *, asymbol **))) bfd_0l)
974 #define ihex_print_symbol _bfd_nosymbols_print_symbol
975 #define ihex_get_symbol_info _bfd_nosymbols_get_symbol_info
976 #define ihex_bfd_is_local_label_name _bfd_nosymbols_bfd_is_local_label_name
977 #define ihex_get_lineno _bfd_nosymbols_get_lineno
978 #define ihex_find_nearest_line _bfd_nosymbols_find_nearest_line
979 #define ihex_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
980 #define ihex_read_minisymbols _bfd_nosymbols_read_minisymbols
981 #define ihex_minisymbol_to_symbol _bfd_nosymbols_minisymbol_to_symbol
983 #define ihex_get_reloc_upper_bound \
984 ((long (*) PARAMS ((bfd *, asection *))) bfd_0l)
985 #define ihex_canonicalize_reloc \
986 ((long (*) PARAMS ((bfd *, asection *, arelent **, asymbol **))) bfd_0l)
987 #define ihex_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
989 #define ihex_bfd_get_relocated_section_contents \
990 bfd_generic_get_relocated_section_contents
991 #define ihex_bfd_relax_section bfd_generic_relax_section
992 #define ihex_bfd_gc_sections bfd_generic_gc_sections
993 #define ihex_bfd_merge_sections bfd_generic_merge_sections
994 #define ihex_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
995 #define ihex_bfd_link_add_symbols _bfd_generic_link_add_symbols
996 #define ihex_bfd_final_link _bfd_generic_final_link
997 #define ihex_bfd_link_split_section _bfd_generic_link_split_section
999 /* The Intel Hex target vector. */
1001 const bfd_target ihex_vec =
1004 bfd_target_ihex_flavour,
1005 BFD_ENDIAN_UNKNOWN, /* target byte order */
1006 BFD_ENDIAN_UNKNOWN, /* target headers byte order */
1007 0, /* object flags */
1008 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD), /* section flags */
1009 0, /* leading underscore */
1010 ' ', /* ar_pad_char */
1011 16, /* ar_max_namelen */
1012 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1013 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1014 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
1015 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1016 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1017 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1021 ihex_object_p, /* bfd_check_format */
1028 _bfd_generic_mkarchive,
1031 { /* bfd_write_contents */
1033 ihex_write_object_contents,
1034 _bfd_write_archive_contents,
1038 BFD_JUMP_TABLE_GENERIC (ihex),
1039 BFD_JUMP_TABLE_COPY (_bfd_generic),
1040 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1041 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1042 BFD_JUMP_TABLE_SYMBOLS (ihex),
1043 BFD_JUMP_TABLE_RELOCS (ihex),
1044 BFD_JUMP_TABLE_WRITE (ihex),
1045 BFD_JUMP_TABLE_LINK (ihex),
1046 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),