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