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