Automatic date update in version.in
[external/binutils.git] / bfd / ihex.c
1 /* BFD back-end for Intel Hex objects.
2    Copyright (C) 1995-2019 Free Software Foundation, Inc.
3    Written by Ian Lance Taylor of Cygnus Support <ian@cygnus.com>.
4
5    This file is part of BFD, the Binary File Descriptor library.
6
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 3 of the License, or
10    (at your option) any later version.
11
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.
16
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., 51 Franklin Street - Fifth Floor, Boston,
20    MA 02110-1301, USA.  */
21
22
23 /* This is what Intel Hex files look like:
24
25 1. INTEL FORMATS
26
27 A. Intel 1
28
29    16-bit address-field format, for files 64k bytes in length or less.
30
31    DATA RECORD
32    Byte 1       Header = colon(:)
33    2..3         The number of data bytes in hex notation
34    4..5         High byte of the record load address
35    6..7         Low byte of the record load address
36    8..9         Record type, must be "00"
37    10..x        Data bytes in hex notation:
38         x = (number of bytes - 1) * 2 + 11
39    x+1..x+2     Checksum in hex notation
40    x+3..x+4     Carriage return, line feed
41
42    END RECORD
43    Byte 1       Header = colon (:)
44    2..3         The byte count, must be "00"
45    4..7         Transfer-address (usually "0000")
46                 the jump-to address, execution start address
47    8..9         Record type, must be "01"
48    10..11       Checksum, in hex notation
49    12..13       Carriage return, line feed
50
51 B. INTEL 2
52
53    MCS-86 format, using a 20-bit address for files larger than 64K bytes.
54
55    DATA RECORD
56    Byte 1       Header = colon (:)
57    2..3         The byte count of this record, hex notation
58    4..5         High byte of the record load address
59    6..7         Low byte of the record load address
60    8..9         Record type, must be "00"
61    10..x        The data bytes in hex notation:
62         x = (number of data bytes - 1) * 2 + 11
63    x+1..x+2     Checksum in hex notation
64    x+3..x+4     Carriage return, line feed
65
66    EXTENDED ADDRESS RECORD
67    Byte 1       Header = colon(:)
68    2..3         The byte count, must be "02"
69    4..7         Load address, must be "0000"
70    8..9         Record type, must be "02"
71    10..11       High byte of the offset address
72    12..13       Low byte of the offset address
73    14..15       Checksum in hex notation
74    16..17       Carriage return, line feed
75
76    The checksums are the two's complement of the 8-bit sum
77    without carry of the byte count, offset address, and the
78    record type.
79
80    START ADDRESS RECORD
81    Byte 1       Header = colon (:)
82    2..3         The byte count, must be "04"
83    4..7         Load address, must be "0000"
84    8..9         Record type, must be "03"
85    10..13       8086 CS value
86    14..17       8086 IP value
87    18..19       Checksum in hex notation
88    20..21       Carriage return, line feed
89
90 Another document reports these additional types:
91
92    EXTENDED LINEAR ADDRESS RECORD
93    Byte 1       Header = colon (:)
94    2..3         The byte count, must be "02"
95    4..7         Load address, must be "0000"
96    8..9         Record type, must be "04"
97    10..13       Upper 16 bits of address of subsequent records
98    14..15       Checksum in hex notation
99    16..17       Carriage return, line feed
100
101    START LINEAR ADDRESS RECORD
102    Byte 1       Header = colon (:)
103    2..3         The byte count, must be "02"
104    4..7         Load address, must be "0000"
105    8..9         Record type, must be "05"
106    10..13       Upper 16 bits of start address
107    14..15       Checksum in hex notation
108    16..17       Carriage return, line feed
109
110 The MRI compiler uses this, which is a repeat of type 5:
111
112   EXTENDED START RECORD
113    Byte 1       Header = colon (:)
114    2..3         The byte count, must be "04"
115    4..7         Load address, must be "0000"
116    8..9         Record type, must be "05"
117    10..13       Upper 16 bits of start address
118    14..17       Lower 16 bits of start address
119    18..19       Checksum in hex notation
120    20..21       Carriage return, line feed.  */
121
122 #include "sysdep.h"
123 #include "bfd.h"
124 #include "libbfd.h"
125 #include "libiberty.h"
126 #include "safe-ctype.h"
127
128 /* The number of bytes we put on one line during output.  */
129
130 #define CHUNK 16
131
132 /* Macros for converting between hex and binary.  */
133
134 #define NIBBLE(x)    (hex_value (x))
135 #define HEX2(buffer) ((NIBBLE ((buffer)[0]) << 4) + NIBBLE ((buffer)[1]))
136 #define HEX4(buffer) ((HEX2 (buffer) << 8) + HEX2 ((buffer) + 2))
137 #define ISHEX(x)     (hex_p (x))
138
139 /* When we write out an ihex value, the values can not be output as
140    they are seen.  Instead, we hold them in memory in this structure.  */
141
142 struct ihex_data_list
143 {
144   struct ihex_data_list *next;
145   bfd_byte *data;
146   bfd_vma where;
147   bfd_size_type size;
148 };
149
150 /* The ihex tdata information.  */
151
152 struct ihex_data_struct
153 {
154   struct ihex_data_list *head;
155   struct ihex_data_list *tail;
156 };
157
158 /* Initialize by filling in the hex conversion array.  */
159
160 static void
161 ihex_init (void)
162 {
163   static bfd_boolean inited;
164
165   if (! inited)
166     {
167       inited = TRUE;
168       hex_init ();
169     }
170 }
171
172 /* Create an ihex object.  */
173
174 static bfd_boolean
175 ihex_mkobject (bfd *abfd)
176 {
177   struct ihex_data_struct *tdata;
178
179   tdata = (struct ihex_data_struct *) bfd_alloc (abfd, sizeof (* tdata));
180   if (tdata == NULL)
181     return FALSE;
182
183   abfd->tdata.ihex_data = tdata;
184   tdata->head = NULL;
185   tdata->tail = NULL;
186   return TRUE;
187 }
188
189 /* Read a byte from a BFD.  Set *ERRORPTR if an error occurred.
190    Return EOF on error or end of file.  */
191
192 static INLINE int
193 ihex_get_byte (bfd *abfd, bfd_boolean *errorptr)
194 {
195   bfd_byte c;
196
197   if (bfd_bread (&c, (bfd_size_type) 1, abfd) != 1)
198     {
199       if (bfd_get_error () != bfd_error_file_truncated)
200         *errorptr = TRUE;
201       return EOF;
202     }
203
204   return (int) (c & 0xff);
205 }
206
207 /* Report a problem in an Intel Hex file.  */
208
209 static void
210 ihex_bad_byte (bfd *abfd, unsigned int lineno, int c, bfd_boolean error)
211 {
212   if (c == EOF)
213     {
214       if (! error)
215         bfd_set_error (bfd_error_file_truncated);
216     }
217   else
218     {
219       char buf[10];
220
221       if (! ISPRINT (c))
222         sprintf (buf, "\\%03o", (unsigned int) c & 0xff);
223       else
224         {
225           buf[0] = c;
226           buf[1] = '\0';
227         }
228       _bfd_error_handler
229         /* xgettext:c-format */
230         (_("%pB:%d: unexpected character `%s' in Intel Hex file"),
231          abfd, lineno, buf);
232       bfd_set_error (bfd_error_bad_value);
233     }
234 }
235
236 /* Read an Intel hex file and turn it into sections.  We create a new
237    section for each contiguous set of bytes.  */
238
239 static bfd_boolean
240 ihex_scan (bfd *abfd)
241 {
242   bfd_vma segbase;
243   bfd_vma extbase;
244   asection *sec;
245   unsigned int lineno;
246   bfd_boolean error;
247   bfd_byte *buf = NULL;
248   size_t bufsize;
249   int c;
250
251   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
252     goto error_return;
253
254   abfd->start_address = 0;
255
256   segbase = 0;
257   extbase = 0;
258   sec = NULL;
259   lineno = 1;
260   error = FALSE;
261   bufsize = 0;
262
263   while ((c = ihex_get_byte (abfd, &error)) != EOF)
264     {
265       if (c == '\r')
266         continue;
267       else if (c == '\n')
268         {
269           ++lineno;
270           continue;
271         }
272       else if (c != ':')
273         {
274           ihex_bad_byte (abfd, lineno, c, error);
275           goto error_return;
276         }
277       else
278         {
279           file_ptr pos;
280           unsigned char hdr[8];
281           unsigned int i;
282           unsigned int len;
283           bfd_vma addr;
284           unsigned int type;
285           unsigned int chars;
286           unsigned int chksum;
287
288           /* This is a data record.  */
289           pos = bfd_tell (abfd) - 1;
290
291           /* Read the header bytes.  */
292           if (bfd_bread (hdr, (bfd_size_type) 8, abfd) != 8)
293             goto error_return;
294
295           for (i = 0; i < 8; i++)
296             {
297               if (! ISHEX (hdr[i]))
298                 {
299                   ihex_bad_byte (abfd, lineno, hdr[i], error);
300                   goto error_return;
301                 }
302             }
303
304           len = HEX2 (hdr);
305           addr = HEX4 (hdr + 2);
306           type = HEX2 (hdr + 6);
307
308           /* Read the data bytes.  */
309           chars = len * 2 + 2;
310           if (chars >= bufsize)
311             {
312               buf = (bfd_byte *) bfd_realloc (buf, (bfd_size_type) chars);
313               if (buf == NULL)
314                 goto error_return;
315               bufsize = chars;
316             }
317
318           if (bfd_bread (buf, (bfd_size_type) chars, abfd) != chars)
319             goto error_return;
320
321           for (i = 0; i < chars; i++)
322             {
323               if (! ISHEX (buf[i]))
324                 {
325                   ihex_bad_byte (abfd, lineno, buf[i], error);
326                   goto error_return;
327                 }
328             }
329
330           /* Check the checksum.  */
331           chksum = len + addr + (addr >> 8) + type;
332           for (i = 0; i < len; i++)
333             chksum += HEX2 (buf + 2 * i);
334           if (((- chksum) & 0xff) != (unsigned int) HEX2 (buf + 2 * i))
335             {
336               _bfd_error_handler
337                 /* xgettext:c-format */
338                 (_("%pB:%u: bad checksum in Intel Hex file (expected %u, found %u)"),
339                  abfd, lineno,
340                  (- chksum) & 0xff, (unsigned int) HEX2 (buf + 2 * i));
341               bfd_set_error (bfd_error_bad_value);
342               goto error_return;
343             }
344
345           switch (type)
346             {
347             case 0:
348               /* This is a data record.  */
349               if (sec != NULL
350                   && sec->vma + sec->size == extbase + segbase + addr)
351                 {
352                   /* This data goes at the end of the section we are
353                      currently building.  */
354                   sec->size += len;
355                 }
356               else if (len > 0)
357                 {
358                   char secbuf[20];
359                   char *secname;
360                   bfd_size_type amt;
361                   flagword flags;
362
363                   sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
364                   amt = strlen (secbuf) + 1;
365                   secname = (char *) bfd_alloc (abfd, amt);
366                   if (secname == NULL)
367                     goto error_return;
368                   strcpy (secname, secbuf);
369                   flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
370                   sec = bfd_make_section_with_flags (abfd, secname, flags);
371                   if (sec == NULL)
372                     goto error_return;
373                   sec->vma = extbase + segbase + addr;
374                   sec->lma = extbase + segbase + addr;
375                   sec->size = len;
376                   sec->filepos = pos;
377                 }
378               break;
379
380             case 1:
381               /* An end record.  */
382               if (abfd->start_address == 0)
383                 abfd->start_address = addr;
384               if (buf != NULL)
385                 free (buf);
386               return TRUE;
387
388             case 2:
389               /* An extended address record.  */
390               if (len != 2)
391                 {
392                   _bfd_error_handler
393                     /* xgettext:c-format */
394                     (_("%pB:%u: bad extended address record length in Intel Hex file"),
395                      abfd, lineno);
396                   bfd_set_error (bfd_error_bad_value);
397                   goto error_return;
398                 }
399
400               segbase = HEX4 (buf) << 4;
401
402               sec = NULL;
403
404               break;
405
406             case 3:
407               /* An extended start address record.  */
408               if (len != 4)
409                 {
410                   _bfd_error_handler
411                     /* xgettext:c-format */
412                     (_("%pB:%u: bad extended start address length in Intel Hex file"),
413                      abfd, lineno);
414                   bfd_set_error (bfd_error_bad_value);
415                   goto error_return;
416                 }
417
418               abfd->start_address += (HEX4 (buf) << 4) + HEX4 (buf + 4);
419
420               sec = NULL;
421
422               break;
423
424             case 4:
425               /* An extended linear address record.  */
426               if (len != 2)
427                 {
428                   _bfd_error_handler
429                     /* xgettext:c-format */
430                     (_("%pB:%u: bad extended linear address record length in Intel Hex file"),
431                      abfd, lineno);
432                   bfd_set_error (bfd_error_bad_value);
433                   goto error_return;
434                 }
435
436               extbase = HEX4 (buf) << 16;
437
438               sec = NULL;
439
440               break;
441
442             case 5:
443               /* An extended linear start address record.  */
444               if (len != 2 && len != 4)
445                 {
446                   _bfd_error_handler
447                     /* xgettext:c-format */
448                     (_("%pB:%u: bad extended linear start address length in Intel Hex file"),
449                      abfd, lineno);
450                   bfd_set_error (bfd_error_bad_value);
451                   goto error_return;
452                 }
453
454               if (len == 2)
455                 abfd->start_address += HEX4 (buf) << 16;
456               else
457                 abfd->start_address = (HEX4 (buf) << 16) + HEX4 (buf + 4);
458
459               sec = NULL;
460
461               break;
462
463             default:
464               _bfd_error_handler
465                 /* xgettext:c-format */
466                 (_("%pB:%u: unrecognized ihex type %u in Intel Hex file"),
467                  abfd, lineno, type);
468               bfd_set_error (bfd_error_bad_value);
469               goto error_return;
470             }
471         }
472     }
473
474   if (error)
475     goto error_return;
476
477   if (buf != NULL)
478     free (buf);
479
480   return TRUE;
481
482  error_return:
483   if (buf != NULL)
484     free (buf);
485   return FALSE;
486 }
487
488 /* Try to recognize an Intel Hex file.  */
489
490 static const bfd_target *
491 ihex_object_p (bfd *abfd)
492 {
493   void * tdata_save;
494   bfd_byte b[9];
495   unsigned int i;
496   unsigned int type;
497
498   ihex_init ();
499
500   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
501     return NULL;
502   if (bfd_bread (b, (bfd_size_type) 9, abfd) != 9)
503     {
504       if (bfd_get_error () == bfd_error_file_truncated)
505         bfd_set_error (bfd_error_wrong_format);
506       return NULL;
507     }
508
509   if (b[0] != ':')
510     {
511       bfd_set_error (bfd_error_wrong_format);
512       return NULL;
513     }
514
515   for (i = 1; i < 9; i++)
516     {
517       if (! ISHEX (b[i]))
518         {
519           bfd_set_error (bfd_error_wrong_format);
520           return NULL;
521         }
522     }
523
524   type = HEX2 (b + 7);
525   if (type > 5)
526     {
527       bfd_set_error (bfd_error_wrong_format);
528       return NULL;
529     }
530
531   /* OK, it looks like it really is an Intel Hex file.  */
532   tdata_save = abfd->tdata.any;
533   if (! ihex_mkobject (abfd) || ! ihex_scan (abfd))
534     {
535       if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
536         bfd_release (abfd, abfd->tdata.any);
537       abfd->tdata.any = tdata_save;
538       return NULL;
539     }
540
541   return abfd->xvec;
542 }
543
544 /* Read the contents of a section in an Intel Hex file.  */
545
546 static bfd_boolean
547 ihex_read_section (bfd *abfd, asection *section, bfd_byte *contents)
548 {
549   int c;
550   bfd_byte *p;
551   bfd_byte *buf = NULL;
552   size_t bufsize;
553   bfd_boolean error;
554
555   if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0)
556     goto error_return;
557
558   p = contents;
559   bufsize = 0;
560   error = FALSE;
561   while ((c = ihex_get_byte (abfd, &error)) != EOF)
562     {
563       unsigned char hdr[8];
564       unsigned int len;
565       unsigned int type;
566       unsigned int i;
567
568       if (c == '\r' || c == '\n')
569         continue;
570
571       /* This is called after ihex_scan has succeeded, so we ought to
572          know the exact format.  */
573       BFD_ASSERT (c == ':');
574
575       if (bfd_bread (hdr, (bfd_size_type) 8, abfd) != 8)
576         goto error_return;
577
578       len = HEX2 (hdr);
579       type = HEX2 (hdr + 6);
580
581       /* We should only see type 0 records here.  */
582       if (type != 0)
583         {
584           _bfd_error_handler
585             (_("%pB: internal error in ihex_read_section"), abfd);
586           bfd_set_error (bfd_error_bad_value);
587           goto error_return;
588         }
589
590       if (len * 2 > bufsize)
591         {
592           buf = (bfd_byte *) bfd_realloc (buf, (bfd_size_type) len * 2);
593           if (buf == NULL)
594             goto error_return;
595           bufsize = len * 2;
596         }
597
598       if (bfd_bread (buf, (bfd_size_type) len * 2, abfd) != len * 2)
599         goto error_return;
600
601       for (i = 0; i < len; i++)
602         *p++ = HEX2 (buf + 2 * i);
603       if ((bfd_size_type) (p - contents) >= section->size)
604         {
605           /* We've read everything in the section.  */
606           if (buf != NULL)
607             free (buf);
608           return TRUE;
609         }
610
611       /* Skip the checksum.  */
612       if (bfd_bread (buf, (bfd_size_type) 2, abfd) != 2)
613         goto error_return;
614     }
615
616   if ((bfd_size_type) (p - contents) < section->size)
617     {
618       _bfd_error_handler
619         (_("%pB: bad section length in ihex_read_section"), abfd);
620       bfd_set_error (bfd_error_bad_value);
621       goto error_return;
622     }
623
624   if (buf != NULL)
625     free (buf);
626
627   return TRUE;
628
629  error_return:
630   if (buf != NULL)
631     free (buf);
632   return FALSE;
633 }
634
635 /* Get the contents of a section in an Intel Hex file.  */
636
637 static bfd_boolean
638 ihex_get_section_contents (bfd *abfd,
639                            asection *section,
640                            void * location,
641                            file_ptr offset,
642                            bfd_size_type count)
643 {
644   if (section->used_by_bfd == NULL)
645     {
646       section->used_by_bfd = bfd_alloc (abfd, section->size);
647       if (section->used_by_bfd == NULL)
648         return FALSE;
649       if (! ihex_read_section (abfd, section,
650                                (bfd_byte *) section->used_by_bfd))
651         return FALSE;
652     }
653
654   memcpy (location, (bfd_byte *) section->used_by_bfd + offset,
655           (size_t) count);
656
657   return TRUE;
658 }
659
660 /* Set the contents of a section in an Intel Hex file.  */
661
662 static bfd_boolean
663 ihex_set_section_contents (bfd *abfd,
664                            asection *section,
665                            const void * location,
666                            file_ptr offset,
667                            bfd_size_type count)
668 {
669   struct ihex_data_list *n;
670   bfd_byte *data;
671   struct ihex_data_struct *tdata;
672
673   if (count == 0
674       || (section->flags & SEC_ALLOC) == 0
675       || (section->flags & SEC_LOAD) == 0)
676     return TRUE;
677
678   n = (struct ihex_data_list *) bfd_alloc (abfd, sizeof (* n));
679   if (n == NULL)
680     return FALSE;
681
682   data = (bfd_byte *) bfd_alloc (abfd, count);
683   if (data == NULL)
684     return FALSE;
685   memcpy (data, location, (size_t) count);
686
687   n->data = data;
688   n->where = section->lma + offset;
689   n->size = count;
690
691   /* Sort the records by address.  Optimize for the common case of
692      adding a record to the end of the list.  */
693   tdata = abfd->tdata.ihex_data;
694   if (tdata->tail != NULL
695       && n->where >= tdata->tail->where)
696     {
697       tdata->tail->next = n;
698       n->next = NULL;
699       tdata->tail = n;
700     }
701   else
702     {
703       struct ihex_data_list **pp;
704
705       for (pp = &tdata->head;
706            *pp != NULL && (*pp)->where < n->where;
707            pp = &(*pp)->next)
708         ;
709       n->next = *pp;
710       *pp = n;
711       if (n->next == NULL)
712         tdata->tail = n;
713     }
714
715   return TRUE;
716 }
717
718 /* Write a record out to an Intel Hex file.  */
719
720 static bfd_boolean
721 ihex_write_record (bfd *abfd,
722                    size_t count,
723                    unsigned int addr,
724                    unsigned int type,
725                    bfd_byte *data)
726 {
727   static const char digs[] = "0123456789ABCDEF";
728   char buf[9 + CHUNK * 2 + 4];
729   char *p;
730   unsigned int chksum;
731   unsigned int i;
732   size_t total;
733
734 #define TOHEX(buf, v) \
735   ((buf)[0] = digs[((v) >> 4) & 0xf], (buf)[1] = digs[(v) & 0xf])
736
737   buf[0] = ':';
738   TOHEX (buf + 1, count);
739   TOHEX (buf + 3, (addr >> 8) & 0xff);
740   TOHEX (buf + 5, addr & 0xff);
741   TOHEX (buf + 7, type);
742
743   chksum = count + addr + (addr >> 8) + type;
744
745   for (i = 0, p = buf + 9; i < count; i++, p += 2, data++)
746     {
747       TOHEX (p, *data);
748       chksum += *data;
749     }
750
751   TOHEX (p, (- chksum) & 0xff);
752   p[2] = '\r';
753   p[3] = '\n';
754
755   total = 9 + count * 2 + 4;
756   if (bfd_bwrite (buf, (bfd_size_type) total, abfd) != total)
757     return FALSE;
758
759   return TRUE;
760 }
761
762 /* Write out an Intel Hex file.  */
763
764 static bfd_boolean
765 ihex_write_object_contents (bfd *abfd)
766 {
767   bfd_vma segbase;
768   bfd_vma extbase;
769   struct ihex_data_list *l;
770
771   segbase = 0;
772   extbase = 0;
773   for (l = abfd->tdata.ihex_data->head; l != NULL; l = l->next)
774     {
775       bfd_vma where;
776       bfd_byte *p;
777       bfd_size_type count;
778
779       where = l->where;
780
781 #ifdef BFD64
782       /* IHex only supports 32-bit addresses, and we want to check
783          that 64-bit addresses are in range.  This isn't quite as
784          obvious as it may seem, since some targets have 32-bit
785          addresses that are sign extended to 64 bits.  So complain
786          only if addresses overflow both unsigned and signed 32-bit
787          integers.  */
788       if (where > 0xffffffff
789           && where + 0x80000000 > 0xffffffff)
790         {
791           _bfd_error_handler
792             /* xgettext:c-format */
793             (_("%pB 64-bit address %#" PRIx64
794                " out of range for Intel Hex file"),
795              abfd, (uint64_t) where);
796           bfd_set_error (bfd_error_bad_value);
797           return FALSE;
798         }
799       where &= 0xffffffff;
800 #endif
801
802       p = l->data;
803       count = l->size;
804
805       while (count > 0)
806         {
807           size_t now;
808           unsigned int rec_addr;
809
810           now = count;
811           if (count > CHUNK)
812             now = CHUNK;
813
814           if (where > segbase + extbase + 0xffff)
815             {
816               bfd_byte addr[2];
817
818               /* We need a new base address.  */
819               if (where <= 0xfffff)
820                 {
821                   /* The addresses should be sorted.  */
822                   BFD_ASSERT (extbase == 0);
823
824                   segbase = where & 0xf0000;
825                   addr[0] = (bfd_byte)(segbase >> 12) & 0xff;
826                   addr[1] = (bfd_byte)(segbase >> 4) & 0xff;
827                   if (! ihex_write_record (abfd, 2, 0, 2, addr))
828                     return FALSE;
829                 }
830               else
831                 {
832                   /* The extended address record and the extended
833                      linear address record are combined, at least by
834                      some readers.  We need an extended linear address
835                      record here, so if we've already written out an
836                      extended address record, zero it out to avoid
837                      confusion.  */
838                   if (segbase != 0)
839                     {
840                       addr[0] = 0;
841                       addr[1] = 0;
842                       if (! ihex_write_record (abfd, 2, 0, 2, addr))
843                         return FALSE;
844                       segbase = 0;
845                     }
846
847                   extbase = where & 0xffff0000;
848                   if (where > extbase + 0xffff)
849                     {
850                       _bfd_error_handler
851                         /* xgettext:c-format */
852                         (_("%pB: address %#" PRIx64
853                            " out of range for Intel Hex file"),
854                          abfd, (uint64_t) where);
855                       bfd_set_error (bfd_error_bad_value);
856                       return FALSE;
857                     }
858                   addr[0] = (bfd_byte)(extbase >> 24) & 0xff;
859                   addr[1] = (bfd_byte)(extbase >> 16) & 0xff;
860                   if (! ihex_write_record (abfd, 2, 0, 4, addr))
861                     return FALSE;
862                 }
863             }
864
865           rec_addr = where - (extbase + segbase);
866
867           /* Output records shouldn't cross 64K boundaries.  */
868           if (rec_addr + now > 0xffff)
869             now = 0x10000 - rec_addr;
870
871           if (! ihex_write_record (abfd, now, rec_addr, 0, p))
872             return FALSE;
873
874           where += now;
875           p += now;
876           count -= now;
877         }
878     }
879
880   if (abfd->start_address != 0)
881     {
882       bfd_vma start;
883       bfd_byte startbuf[4];
884
885       start = abfd->start_address;
886
887       if (start <= 0xfffff)
888         {
889           startbuf[0] = (bfd_byte)((start & 0xf0000) >> 12) & 0xff;
890           startbuf[1] = 0;
891           startbuf[2] = (bfd_byte)(start >> 8) & 0xff;
892           startbuf[3] = (bfd_byte)start & 0xff;
893           if (! ihex_write_record (abfd, 4, 0, 3, startbuf))
894             return FALSE;
895         }
896       else
897         {
898           startbuf[0] = (bfd_byte)(start >> 24) & 0xff;
899           startbuf[1] = (bfd_byte)(start >> 16) & 0xff;
900           startbuf[2] = (bfd_byte)(start >> 8) & 0xff;
901           startbuf[3] = (bfd_byte)start & 0xff;
902           if (! ihex_write_record (abfd, 4, 0, 5, startbuf))
903             return FALSE;
904         }
905     }
906
907   if (! ihex_write_record (abfd, 0, 0, 1, NULL))
908     return FALSE;
909
910   return TRUE;
911 }
912
913 /* Set the architecture for the output file.  The architecture is
914    irrelevant, so we ignore errors about unknown architectures.  */
915
916 static bfd_boolean
917 ihex_set_arch_mach (bfd *abfd,
918                     enum bfd_architecture arch,
919                     unsigned long mach)
920 {
921   if (! bfd_default_set_arch_mach (abfd, arch, mach))
922     {
923       if (arch != bfd_arch_unknown)
924         return FALSE;
925     }
926   return TRUE;
927 }
928
929 /* Get the size of the headers, for the linker.  */
930
931 static int
932 ihex_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
933                      struct bfd_link_info *info ATTRIBUTE_UNUSED)
934 {
935   return 0;
936 }
937
938 /* Some random definitions for the target vector.  */
939
940 #define ihex_close_and_cleanup                    _bfd_generic_close_and_cleanup
941 #define ihex_bfd_free_cached_info                 _bfd_generic_bfd_free_cached_info
942 #define ihex_new_section_hook                     _bfd_generic_new_section_hook
943 #define ihex_get_section_contents_in_window       _bfd_generic_get_section_contents_in_window
944 #define ihex_get_symtab_upper_bound               _bfd_long_bfd_0
945 #define ihex_canonicalize_symtab                  _bfd_nosymbols_canonicalize_symtab
946 #define ihex_make_empty_symbol                    _bfd_generic_make_empty_symbol
947 #define ihex_print_symbol                         _bfd_nosymbols_print_symbol
948 #define ihex_get_symbol_info                      _bfd_nosymbols_get_symbol_info
949 #define ihex_get_symbol_version_string            _bfd_nosymbols_get_symbol_version_string
950 #define ihex_bfd_is_target_special_symbol         _bfd_bool_bfd_asymbol_false
951 #define ihex_bfd_is_local_label_name              _bfd_nosymbols_bfd_is_local_label_name
952 #define ihex_get_lineno                           _bfd_nosymbols_get_lineno
953 #define ihex_find_nearest_line                    _bfd_nosymbols_find_nearest_line
954 #define ihex_find_line                            _bfd_nosymbols_find_line
955 #define ihex_find_inliner_info                    _bfd_nosymbols_find_inliner_info
956 #define ihex_bfd_make_debug_symbol                _bfd_nosymbols_bfd_make_debug_symbol
957 #define ihex_read_minisymbols                     _bfd_nosymbols_read_minisymbols
958 #define ihex_minisymbol_to_symbol                 _bfd_nosymbols_minisymbol_to_symbol
959 #define ihex_bfd_get_relocated_section_contents   bfd_generic_get_relocated_section_contents
960 #define ihex_bfd_relax_section                    bfd_generic_relax_section
961 #define ihex_bfd_gc_sections                      bfd_generic_gc_sections
962 #define ihex_bfd_lookup_section_flags             bfd_generic_lookup_section_flags
963 #define ihex_bfd_merge_sections                   bfd_generic_merge_sections
964 #define ihex_bfd_is_group_section                 bfd_generic_is_group_section
965 #define ihex_bfd_discard_group                    bfd_generic_discard_group
966 #define ihex_section_already_linked               _bfd_generic_section_already_linked
967 #define ihex_bfd_define_common_symbol             bfd_generic_define_common_symbol
968 #define ihex_bfd_link_hide_symbol                 _bfd_generic_link_hide_symbol
969 #define ihex_bfd_define_start_stop                bfd_generic_define_start_stop
970 #define ihex_bfd_link_hash_table_create           _bfd_generic_link_hash_table_create
971 #define ihex_bfd_link_add_symbols                 _bfd_generic_link_add_symbols
972 #define ihex_bfd_link_just_syms                   _bfd_generic_link_just_syms
973 #define ihex_bfd_copy_link_hash_symbol_type       _bfd_generic_copy_link_hash_symbol_type
974 #define ihex_bfd_final_link                       _bfd_generic_final_link
975 #define ihex_bfd_link_split_section               _bfd_generic_link_split_section
976 #define ihex_bfd_link_check_relocs                _bfd_generic_link_check_relocs
977
978 /* The Intel Hex target vector.  */
979
980 const bfd_target ihex_vec =
981 {
982   "ihex",                       /* Name.  */
983   bfd_target_ihex_flavour,
984   BFD_ENDIAN_UNKNOWN,           /* Target byte order.  */
985   BFD_ENDIAN_UNKNOWN,           /* Target headers byte order.  */
986   0,                            /* Object flags.  */
987   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD),    /* Section flags.  */
988   0,                            /* Leading underscore.  */
989   ' ',                          /* AR_pad_char.  */
990   16,                           /* AR_max_namelen.  */
991   0,                            /* match priority.  */
992   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
993   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
994   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Data.  */
995   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
996   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
997   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Headers. */
998
999   {
1000     _bfd_dummy_target,
1001     ihex_object_p,              /* bfd_check_format.  */
1002     _bfd_dummy_target,
1003     _bfd_dummy_target,
1004   },
1005   {
1006     _bfd_bool_bfd_false_error,
1007     ihex_mkobject,
1008     _bfd_generic_mkarchive,
1009     _bfd_bool_bfd_false_error,
1010   },
1011   {                             /* bfd_write_contents.  */
1012     _bfd_bool_bfd_false_error,
1013     ihex_write_object_contents,
1014     _bfd_write_archive_contents,
1015     _bfd_bool_bfd_false_error,
1016   },
1017
1018   BFD_JUMP_TABLE_GENERIC (ihex),
1019   BFD_JUMP_TABLE_COPY (_bfd_generic),
1020   BFD_JUMP_TABLE_CORE (_bfd_nocore),
1021   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1022   BFD_JUMP_TABLE_SYMBOLS (ihex),
1023   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
1024   BFD_JUMP_TABLE_WRITE (ihex),
1025   BFD_JUMP_TABLE_LINK (ihex),
1026   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1027
1028   NULL,
1029
1030   NULL
1031 };