* "objcopy -O binary" warning tweak, suggested by dmoseley
[binutils-gdb.git] / bfd / ihex.c
blob3f995fb552de6d63ec205850e0d1f733691f024b
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:
23 1. INTEL FORMATS
25 A. Intel 1
27 16-bit address-field format, for files 64k bytes in length or less.
29 DATA RECORD
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
40 END RECORD
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
49 B. INTEL 2
51 MCS-86 format, using a 20-bit address for files larger than 64K bytes.
53 DATA RECORD
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
76 record type.
78 START ADDRESS RECORD
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"
83 10..13 8086 CS value
84 14..17 8086 IP value
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
108 The MRI compiler uses this, which is a repeat of type 5:
110 EXTENDED START RECORD
111 Byte 1 Header = colon (:)
112 2..3 The byte count, must be "04"
113 4..7 Load address, must be "0000"
114 8..9 Record type, must be "05"
115 10..13 Upper 16 bits of start address
116 14..17 Lower 16 bits of start address
117 18..19 Checksum in hex notation
118 20..21 Carriage return, line feed
121 #include "bfd.h"
122 #include "sysdep.h"
123 #include "libbfd.h"
124 #include "libiberty.h"
126 #include <ctype.h>
128 static void ihex_init PARAMS ((void));
129 static boolean ihex_mkobject PARAMS ((bfd *));
130 static INLINE int ihex_get_byte PARAMS ((bfd *, boolean *));
131 static void ihex_bad_byte PARAMS ((bfd *, unsigned int, int, boolean));
132 static boolean ihex_scan PARAMS ((bfd *));
133 static const bfd_target *ihex_object_p PARAMS ((bfd *));
134 static boolean ihex_read_section PARAMS ((bfd *, asection *, bfd_byte *));
135 static boolean ihex_get_section_contents
136 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
137 static boolean ihex_set_section_contents
138 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
139 static boolean ihex_write_record
140 PARAMS ((bfd *, bfd_size_type, bfd_vma, unsigned int, bfd_byte *));
141 static boolean ihex_write_object_contents PARAMS ((bfd *));
142 static asymbol *ihex_make_empty_symbol PARAMS ((bfd *));
143 static boolean ihex_set_arch_mach
144 PARAMS ((bfd *, enum bfd_architecture, unsigned long));
146 /* The number of bytes we put on one line during output. */
148 #define CHUNK (21)
150 /* Macros for converting between hex and binary. */
152 #define NIBBLE(x) (hex_value (x))
153 #define HEX2(buffer) ((NIBBLE ((buffer)[0]) << 4) + NIBBLE ((buffer)[1]))
154 #define HEX4(buffer) ((HEX2 (buffer) << 8) + HEX2 ((buffer) + 2))
155 #define ISHEX(x) (hex_p (x))
157 /* When we write out an ihex value, the values can not be output as
158 they are seen. Instead, we hold them in memory in this structure. */
160 struct ihex_data_list
162 struct ihex_data_list *next;
163 bfd_byte *data;
164 bfd_vma where;
165 bfd_size_type size;
168 /* The ihex tdata information. */
170 struct ihex_data_struct
172 struct ihex_data_list *head;
173 struct ihex_data_list *tail;
176 /* Initialize by filling in the hex conversion array. */
178 static void
179 ihex_init ()
181 static boolean inited;
183 if (! inited)
185 inited = true;
186 hex_init ();
190 /* Create an ihex object. */
192 static boolean
193 ihex_mkobject (abfd)
194 bfd *abfd;
196 if (abfd->tdata.ihex_data == NULL)
198 struct ihex_data_struct *tdata;
200 tdata = ((struct ihex_data_struct *)
201 bfd_alloc (abfd, sizeof (struct ihex_data_struct)));
202 if (tdata == NULL)
203 return false;
204 abfd->tdata.ihex_data = tdata;
205 tdata->head = NULL;
206 tdata->tail = NULL;
209 return true;
212 /* Read a byte from a BFD. Set *ERRORPTR if an error occurred.
213 Return EOF on error or end of file. */
215 static INLINE int
216 ihex_get_byte (abfd, errorptr)
217 bfd *abfd;
218 boolean *errorptr;
220 bfd_byte c;
222 if (bfd_read (&c, 1, 1, abfd) != 1)
224 if (bfd_get_error () != bfd_error_file_truncated)
225 *errorptr = true;
226 return EOF;
229 return (int) (c & 0xff);
232 /* Report a problem in an Intel Hex file. */
234 static void
235 ihex_bad_byte (abfd, lineno, c, error)
236 bfd *abfd;
237 unsigned int lineno;
238 int c;
239 boolean error;
241 if (c == EOF)
243 if (! error)
244 bfd_set_error (bfd_error_file_truncated);
246 else
248 char buf[10];
250 if (! isprint (c))
251 sprintf (buf, "\\%03o", (unsigned int) c);
252 else
254 buf[0] = c;
255 buf[1] = '\0';
257 (*_bfd_error_handler)
258 ("%s:%d: unexpected character `%s' in Intel Hex file\n",
259 bfd_get_filename (abfd), lineno, buf);
260 bfd_set_error (bfd_error_bad_value);
264 /* Read an Intel hex file and turn it into sections. We create a new
265 section for each contiguous set of bytes. */
267 static boolean
268 ihex_scan (abfd)
269 bfd *abfd;
271 bfd_vma segbase;
272 asection *sec;
273 int lineno;
274 boolean error;
275 bfd_byte *buf;
276 size_t bufsize;
277 int c;
279 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
280 goto error_return;
282 abfd->start_address = 0;
284 segbase = 0;
285 sec = NULL;
286 lineno = 1;
287 error = false;
288 buf = NULL;
289 bufsize = 0;
290 while ((c = ihex_get_byte (abfd, &error)) != EOF)
292 if (c == '\r')
293 continue;
294 else if (c == '\n')
296 ++lineno;
297 continue;
299 else if (c != ':')
301 ihex_bad_byte (abfd, lineno, c, error);
302 goto error_return;
304 else
306 file_ptr pos;
307 char hdr[8];
308 unsigned int i;
309 unsigned int len;
310 bfd_vma addr;
311 unsigned int type;
312 unsigned int chars;
313 unsigned int chksum;
315 /* This is a data record. */
317 pos = bfd_tell (abfd) - 1;
319 /* Read the header bytes. */
321 if (bfd_read (hdr, 1, 8, abfd) != 8)
322 goto error_return;
324 for (i = 0; i < 8; i++)
326 if (! ISHEX (hdr[i]))
328 ihex_bad_byte (abfd, lineno, hdr[i], error);
329 goto error_return;
333 len = HEX2 (hdr);
334 addr = HEX4 (hdr + 2);
335 type = HEX2 (hdr + 6);
337 /* Read the data bytes. */
339 chars = len * 2 + 2;
340 if (chars >= bufsize)
342 buf = (bfd_byte *) bfd_realloc (buf, chars);
343 if (buf == NULL)
344 goto error_return;
345 bufsize = chars;
348 if (bfd_read (buf, 1, chars, abfd) != chars)
349 goto error_return;
351 for (i = 0; i < chars; i++)
353 if (! ISHEX (buf[i]))
355 ihex_bad_byte (abfd, lineno, hdr[i], error);
356 goto error_return;
360 /* Check the checksum. */
361 chksum = len + addr + (addr >> 8) + type;
362 for (i = 0; i < len; i++)
363 chksum += HEX2 (buf + 2 * i);
364 if (((- chksum) & 0xff) != (unsigned int) HEX2 (buf + 2 * i))
366 (*_bfd_error_handler)
367 ("%s:%d: bad checksum in Intel Hex file (expected %u, found %u)",
368 bfd_get_filename (abfd), lineno,
369 (- chksum) & 0xff, (unsigned int) HEX2 (buf + 2 * i));
370 bfd_set_error (bfd_error_bad_value);
371 goto error_return;
374 switch (type)
376 case 0:
377 /* This is a data record. */
378 if (sec != NULL
379 && sec->vma + sec->_raw_size == segbase + addr)
381 /* This data goes at the end of the section we are
382 currently building. */
383 sec->_raw_size += len;
385 else if (len > 0)
387 char secbuf[20];
388 char *secname;
390 sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
391 secname = (char *) bfd_alloc (abfd, strlen (secbuf) + 1);
392 if (secname == NULL)
393 goto error_return;
394 strcpy (secname, secbuf);
395 sec = bfd_make_section (abfd, secname);
396 if (sec == NULL)
397 goto error_return;
398 sec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
399 sec->vma = segbase + addr;
400 sec->lma = segbase + addr;
401 sec->_raw_size = len;
402 sec->filepos = pos;
404 break;
406 case 1:
407 /* An end record. */
408 if (abfd->start_address == 0)
409 abfd->start_address = addr;
410 if (buf != NULL)
411 free (buf);
412 return true;
414 case 2:
415 /* An extended address record. */
416 if (len != 2)
418 (*_bfd_error_handler)
419 ("%s:%d: bad extended address record length in Intel Hex file",
420 bfd_get_filename (abfd), lineno);
421 bfd_set_error (bfd_error_bad_value);
422 goto error_return;
425 segbase = HEX4 (buf) << 4;
427 sec = NULL;
429 break;
431 case 3:
432 /* An extended start address record. */
433 if (len != 4)
435 (*_bfd_error_handler)
436 ("%s:%d: bad extended start address length in Intel Hex file",
437 bfd_get_filename (abfd), lineno);
438 bfd_set_error (bfd_error_bad_value);
439 goto error_return;
442 abfd->start_address += (HEX4 (buf) << 4) + HEX4 (buf + 4);
444 sec = NULL;
446 break;
448 case 4:
449 /* An extended linear address record. */
450 if (len != 2)
452 (*_bfd_error_handler)
453 ("%s:%d: bad extended linear address record length in Intel Hex file",
454 bfd_get_filename (abfd), lineno);
455 bfd_set_error (bfd_error_bad_value);
456 goto error_return;
459 segbase = HEX4 (buf) << 16;
461 sec = NULL;
463 break;
465 case 5:
466 /* An extended linear start address record. */
467 if (len != 2 && len != 4)
469 (*_bfd_error_handler)
470 ("%s:%d: bad extended linear start address length in Intel Hex file",
471 bfd_get_filename (abfd), lineno);
472 bfd_set_error (bfd_error_bad_value);
473 goto error_return;
476 if (len == 2)
477 abfd->start_address += HEX4 (buf) << 16;
478 else
479 abfd->start_address = (HEX4 (buf) << 16) + HEX4 (buf + 4);
481 sec = NULL;
483 break;
485 default:
486 (*_bfd_error_handler)
487 ("%s:%d: unrecognized ihex type %u in Intel Hex file\n",
488 bfd_get_filename (abfd), lineno, type);
489 bfd_set_error (bfd_error_bad_value);
490 goto error_return;
495 if (error)
496 goto error_return;
498 if (buf != NULL)
499 free (buf);
501 return true;
503 error_return:
504 if (buf != NULL)
505 free (buf);
506 return false;
509 /* Try to recognize an Intel Hex file. */
511 static const bfd_target *
512 ihex_object_p (abfd)
513 bfd *abfd;
515 bfd_byte b[9];
516 unsigned int i;
517 unsigned int type;
519 ihex_init ();
521 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
522 return NULL;
523 if (bfd_read (b, 1, 9, abfd) != 9)
525 if (bfd_get_error () == bfd_error_file_truncated)
526 bfd_set_error (bfd_error_wrong_format);
527 return NULL;
530 if (b[0] != ':')
532 bfd_set_error (bfd_error_wrong_format);
533 return NULL;
536 for (i = 1; i < 9; i++)
538 if (! ISHEX (b[i]))
540 bfd_set_error (bfd_error_wrong_format);
541 return NULL;
545 type = HEX2 (b + 7);
546 if (type > 5)
548 bfd_set_error (bfd_error_wrong_format);
549 return NULL;
552 /* OK, it looks like it really is an Intel Hex file. */
554 if (! ihex_mkobject (abfd)
555 || ! ihex_scan (abfd))
556 return NULL;
558 return abfd->xvec;
561 /* Read the contents of a section in an Intel Hex file. */
563 static boolean
564 ihex_read_section (abfd, section, contents)
565 bfd *abfd;
566 asection *section;
567 bfd_byte *contents;
569 int c;
570 bfd_byte *p;
571 bfd_byte *buf;
572 size_t bufsize;
573 boolean error;
575 if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0)
576 goto error_return;
578 p = contents;
579 buf = NULL;
580 bufsize = 0;
581 error = false;
582 while ((c = ihex_get_byte (abfd, &error)) != EOF)
584 char hdr[8];
585 unsigned int len;
586 bfd_vma addr;
587 unsigned int type;
588 unsigned int i;
590 if (c == '\r' || c == '\n')
591 continue;
593 /* This is called after ihex_scan has succeeded, so we ought to
594 know the exact format. */
595 BFD_ASSERT (c == ':');
597 if (bfd_read (hdr, 1, 8, abfd) != 8)
598 goto error_return;
600 len = HEX2 (hdr);
601 addr = HEX4 (hdr + 2);
602 type = HEX2 (hdr + 6);
604 /* We should only see type 0 records here. */
605 if (type != 0)
607 (*_bfd_error_handler)
608 ("%s: internal error in ihex_read_section",
609 bfd_get_filename (abfd));
610 bfd_set_error (bfd_error_bad_value);
611 goto error_return;
614 if (len * 2 > bufsize)
616 buf = (bfd_byte *) bfd_realloc (buf, len * 2);
617 if (buf == NULL)
618 goto error_return;
619 bufsize = len * 2;
622 if (bfd_read (buf, 1, len * 2, abfd) != len * 2)
623 goto error_return;
625 for (i = 0; i < len; i++)
626 *p++ = HEX2 (buf + 2 * i);
627 if ((bfd_size_type) (p - contents) >= section->_raw_size)
629 /* We've read everything in the section. */
630 if (buf != NULL)
631 free (buf);
632 return true;
635 /* Skip the checksum. */
636 if (bfd_read (buf, 1, 2, abfd) != 2)
637 goto error_return;
640 if ((bfd_size_type) (p - contents) < section->_raw_size)
642 (*_bfd_error_handler)
643 ("%s: bad section length in ihex_read_section",
644 bfd_get_filename (abfd));
645 bfd_set_error (bfd_error_bad_value);
646 goto error_return;
649 if (buf != NULL)
650 free (buf);
652 return true;
654 error_return:
655 if (buf != NULL)
656 free (buf);
657 return false;
660 /* Get the contents of a section in an Intel Hex file. */
662 static boolean
663 ihex_get_section_contents (abfd, section, location, offset, count)
664 bfd *abfd;
665 asection *section;
666 PTR location;
667 file_ptr offset;
668 bfd_size_type count;
670 if (section->used_by_bfd == NULL)
672 section->used_by_bfd = bfd_alloc (abfd, section->_raw_size);
673 if (section->used_by_bfd == NULL)
674 return false;
675 if (! ihex_read_section (abfd, section, section->used_by_bfd))
676 return false;
679 memcpy (location, (bfd_byte *) section->used_by_bfd + offset,
680 (size_t) count);
682 return true;
685 /* Set the contents of a section in an Intel Hex file. */
687 static boolean
688 ihex_set_section_contents (abfd, section, location, offset, count)
689 bfd *abfd;
690 asection *section;
691 PTR location;
692 file_ptr offset;
693 bfd_size_type count;
695 struct ihex_data_list *n;
696 bfd_byte *data;
697 struct ihex_data_struct *tdata;
699 if (count == 0
700 || (section->flags & SEC_ALLOC) == 0
701 || (section->flags & SEC_LOAD) == 0)
702 return true;
704 n = ((struct ihex_data_list *)
705 bfd_alloc (abfd, sizeof (struct ihex_data_list)));
706 if (n == NULL)
707 return false;
709 data = (bfd_byte *) bfd_alloc (abfd, count);
710 if (data == NULL)
711 return false;
712 memcpy (data, location, (size_t) count);
714 n->data = data;
715 n->where = section->lma + offset;
716 n->size = count;
718 /* Sort the records by address. Optimize for the common case of
719 adding a record to the end of the list. */
720 tdata = abfd->tdata.ihex_data;
721 if (tdata->tail != NULL
722 && n->where >= tdata->tail->where)
724 tdata->tail->next = n;
725 n->next = NULL;
726 tdata->tail = n;
728 else
730 register struct ihex_data_list **pp;
732 for (pp = &tdata->head;
733 *pp != NULL && (*pp)->where < n->where;
734 pp = &(*pp)->next)
736 n->next = *pp;
737 *pp = n;
738 if (n->next == NULL)
739 tdata->tail = n;
742 return true;
745 /* Write a record out to an Intel Hex file. */
747 static boolean
748 ihex_write_record (abfd, count, addr, type, data)
749 bfd *abfd;
750 bfd_size_type count;
751 bfd_vma addr;
752 unsigned int type;
753 bfd_byte *data;
755 static const char digs[] = "0123456789ABCDEF";
756 char buf[9 + CHUNK * 2 + 4];
757 char *p;
758 unsigned int chksum;
759 unsigned int i;
761 #define TOHEX(buf, v) \
762 ((buf)[0] = digs[((v) >> 4) & 0xf], (buf)[1] = digs[(v) & 0xf])
764 buf[0] = ':';
765 TOHEX (buf + 1, count);
766 TOHEX (buf + 3, (addr >> 8) & 0xff);
767 TOHEX (buf + 5, addr & 0xff);
768 TOHEX (buf + 7, type);
770 chksum = count + addr + (addr >> 8) + type;
772 for (i = 0, p = buf + 9; i < count; i++, p += 2, data++)
774 TOHEX (p, *data);
775 chksum += *data;
778 TOHEX (p, (- chksum) & 0xff);
779 p[2] = '\r';
780 p[3] = '\n';
782 if (bfd_write (buf, 1, 9 + count * 2 + 4, abfd) != 9 + count * 2 + 4)
783 return false;
785 return true;
788 /* Write out an Intel Hex file. */
790 static boolean
791 ihex_write_object_contents (abfd)
792 bfd *abfd;
794 bfd_vma segbase;
795 struct ihex_data_list *l;
797 segbase = 0;
798 for (l = abfd->tdata.ihex_data->head; l != NULL; l = l->next)
800 bfd_vma where;
801 bfd_byte *p;
802 bfd_size_type count;
804 where = l->where;
805 p = l->data;
806 count = l->size;
807 while (count > 0)
809 bfd_size_type now;
811 now = count;
812 if (now > CHUNK)
813 now = CHUNK;
815 if (where > segbase + 0xffff)
817 bfd_byte addr[2];
819 /* We need a new base address. */
820 if (where <= 0xfffff)
822 segbase = where & 0xf0000;
823 addr[0] = (segbase >> 12) & 0xff;
824 addr[1] = (segbase >> 4) & 0xff;
825 if (! ihex_write_record (abfd, 2, 0, 2, addr))
826 return false;
828 else
830 segbase = where & 0xffff0000;
831 if (where > segbase + 0xffff)
833 char buf[20];
835 sprintf_vma (buf, where);
836 (*_bfd_error_handler)
837 ("%s: address 0x%s out of range for Intex Hex file",
838 bfd_get_filename (abfd), buf);
839 bfd_set_error (bfd_error_bad_value);
840 return false;
842 addr[0] = (segbase >> 24) & 0xff;
843 addr[1] = (segbase >> 16) & 0xff;
844 if (! ihex_write_record (abfd, 2, 0, 4, addr))
845 return false;
849 if (! ihex_write_record (abfd, now, where - segbase, 0, p))
850 return false;
852 where += now;
853 p += now;
854 count -= now;
858 if (abfd->start_address != 0)
860 bfd_vma start;
861 bfd_byte startbuf[4];
863 start = abfd->start_address;
865 if (start <= 0xfffff)
867 startbuf[0] = ((start & 0xf0000) >> 12) & 0xff;
868 startbuf[1] = 0;
869 startbuf[2] = (start >> 8) & 0xff;
870 startbuf[3] = start & 0xff;
871 if (! ihex_write_record (abfd, 4, 0, 3, startbuf))
872 return false;
874 else
876 startbuf[0] = (start >> 24) & 0xff;
877 startbuf[1] = (start >> 16) & 0xff;
878 startbuf[2] = (start >> 8) & 0xff;
879 startbuf[3] = start & 0xff;
880 if (! ihex_write_record (abfd, 4, 0, 5, startbuf))
881 return false;
885 if (! ihex_write_record (abfd, 0, 0, 1, NULL))
886 return false;
888 return true;
891 /* Make an empty symbol. This is required only because
892 bfd_make_section_anyway wants to create a symbol for the section. */
894 static asymbol *
895 ihex_make_empty_symbol (abfd)
896 bfd *abfd;
898 asymbol *new;
900 new = (asymbol *) bfd_zalloc (abfd, sizeof (asymbol));
901 if (new != NULL)
902 new->the_bfd = abfd;
903 return new;
906 /* Set the architecture for the output file. The architecture is
907 irrelevant, so we ignore errors about unknown architectures. */
909 static boolean
910 ihex_set_arch_mach (abfd, arch, mach)
911 bfd *abfd;
912 enum bfd_architecture arch;
913 unsigned long mach;
915 if (! bfd_default_set_arch_mach (abfd, arch, mach))
917 if (arch != bfd_arch_unknown)
918 return false;
920 return true;
923 /* Get the size of the headers, for the linker. */
925 /*ARGSUSED*/
926 static int
927 ihex_sizeof_headers (abfd, exec)
928 bfd *abfd;
929 boolean exec;
931 return 0;
934 /* Some random definitions for the target vector. */
936 #define ihex_close_and_cleanup _bfd_generic_close_and_cleanup
937 #define ihex_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
938 #define ihex_new_section_hook _bfd_generic_new_section_hook
939 #define ihex_get_section_contents_in_window \
940 _bfd_generic_get_section_contents_in_window
942 #define ihex_get_symtab_upper_bound bfd_0l
943 #define ihex_get_symtab \
944 ((long (*) PARAMS ((bfd *, asymbol **))) bfd_0l)
945 #define ihex_print_symbol _bfd_nosymbols_print_symbol
946 #define ihex_get_symbol_info _bfd_nosymbols_get_symbol_info
947 #define ihex_bfd_is_local_label _bfd_nosymbols_bfd_is_local_label
948 #define ihex_get_lineno _bfd_nosymbols_get_lineno
949 #define ihex_find_nearest_line _bfd_nosymbols_find_nearest_line
950 #define ihex_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
951 #define ihex_read_minisymbols _bfd_nosymbols_read_minisymbols
952 #define ihex_minisymbol_to_symbol _bfd_nosymbols_minisymbol_to_symbol
954 #define ihex_get_reloc_upper_bound \
955 ((long (*) PARAMS ((bfd *, asection *))) bfd_0l)
956 #define ihex_canonicalize_reloc \
957 ((long (*) PARAMS ((bfd *, asection *, arelent **, asymbol **))) bfd_0l)
958 #define ihex_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
960 #define ihex_bfd_get_relocated_section_contents \
961 bfd_generic_get_relocated_section_contents
962 #define ihex_bfd_relax_section bfd_generic_relax_section
963 #define ihex_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
964 #define ihex_bfd_link_add_symbols _bfd_generic_link_add_symbols
965 #define ihex_bfd_final_link _bfd_generic_final_link
966 #define ihex_bfd_link_split_section _bfd_generic_link_split_section
968 /* The Intel Hex target vector. */
970 const bfd_target ihex_vec =
972 "ihex", /* name */
973 bfd_target_ihex_flavour,
974 BFD_ENDIAN_UNKNOWN, /* target byte order */
975 BFD_ENDIAN_UNKNOWN, /* target headers byte order */
976 0, /* object flags */
977 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD), /* section flags */
978 0, /* leading underscore */
979 ' ', /* ar_pad_char */
980 16, /* ar_max_namelen */
981 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
982 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
983 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
984 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
985 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
986 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
989 _bfd_dummy_target,
990 ihex_object_p, /* bfd_check_format */
991 _bfd_dummy_target,
992 _bfd_dummy_target,
995 bfd_false,
996 ihex_mkobject,
997 _bfd_generic_mkarchive,
998 bfd_false,
1000 { /* bfd_write_contents */
1001 bfd_false,
1002 ihex_write_object_contents,
1003 _bfd_write_archive_contents,
1004 bfd_false,
1007 BFD_JUMP_TABLE_GENERIC (ihex),
1008 BFD_JUMP_TABLE_COPY (_bfd_generic),
1009 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1010 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1011 BFD_JUMP_TABLE_SYMBOLS (ihex),
1012 BFD_JUMP_TABLE_RELOCS (ihex),
1013 BFD_JUMP_TABLE_WRITE (ihex),
1014 BFD_JUMP_TABLE_LINK (ihex),
1015 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1017 (PTR) 0