2002-04-04 Daniel Jacobowitz <drow@mvista.com>
[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   if (abfd->tdata.ihex_data == NULL)
197     {
198       struct ihex_data_struct *tdata;
199       bfd_size_type amt = sizeof (struct ihex_data_struct);
200
201       tdata = (struct ihex_data_struct *) bfd_alloc (abfd, amt);
202       if (tdata == NULL)
203         return false;
204       abfd->tdata.ihex_data = tdata;
205       tdata->head = NULL;
206       tdata->tail = NULL;
207     }
208
209   return true;
210 }
211
212 /* Read a byte from a BFD.  Set *ERRORPTR if an error occurred.
213    Return EOF on error or end of file.  */
214
215 static INLINE int
216 ihex_get_byte (abfd, errorptr)
217      bfd *abfd;
218      boolean *errorptr;
219 {
220   bfd_byte c;
221
222   if (bfd_bread (&c, (bfd_size_type) 1, abfd) != 1)
223     {
224       if (bfd_get_error () != bfd_error_file_truncated)
225         *errorptr = true;
226       return EOF;
227     }
228
229   return (int) (c & 0xff);
230 }
231
232 /* Report a problem in an Intel Hex file.  */
233
234 static void
235 ihex_bad_byte (abfd, lineno, c, error)
236      bfd *abfd;
237      unsigned int lineno;
238      int c;
239      boolean error;
240 {
241   if (c == EOF)
242     {
243       if (! error)
244         bfd_set_error (bfd_error_file_truncated);
245     }
246   else
247     {
248       char buf[10];
249
250       if (! ISPRINT (c))
251         sprintf (buf, "\\%03o", (unsigned int) c);
252       else
253         {
254           buf[0] = c;
255           buf[1] = '\0';
256         }
257       (*_bfd_error_handler)
258         (_("%s:%d: unexpected character `%s' in Intel Hex file\n"),
259          bfd_archive_filename (abfd), lineno, buf);
260       bfd_set_error (bfd_error_bad_value);
261     }
262 }
263
264 /* Read an Intel hex file and turn it into sections.  We create a new
265    section for each contiguous set of bytes.  */
266
267 static boolean
268 ihex_scan (abfd)
269      bfd *abfd;
270 {
271   bfd_vma segbase;
272   bfd_vma extbase;
273   asection *sec;
274   unsigned int lineno;
275   boolean error;
276   bfd_byte *buf = NULL;
277   size_t bufsize;
278   int c;
279
280   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
281     goto error_return;
282
283   abfd->start_address = 0;
284
285   segbase = 0;
286   extbase = 0;
287   sec = NULL;
288   lineno = 1;
289   error = false;
290   bufsize = 0;
291   while ((c = ihex_get_byte (abfd, &error)) != EOF)
292     {
293       if (c == '\r')
294         continue;
295       else if (c == '\n')
296         {
297           ++lineno;
298           continue;
299         }
300       else if (c != ':')
301         {
302           ihex_bad_byte (abfd, lineno, c, error);
303           goto error_return;
304         }
305       else
306         {
307           file_ptr pos;
308           char hdr[8];
309           unsigned int i;
310           unsigned int len;
311           bfd_vma addr;
312           unsigned int type;
313           unsigned int chars;
314           unsigned int chksum;
315
316           /* This is a data record.  */
317
318           pos = bfd_tell (abfd) - 1;
319
320           /* Read the header bytes.  */
321
322           if (bfd_bread (hdr, (bfd_size_type) 8, abfd) != 8)
323             goto error_return;
324
325           for (i = 0; i < 8; i++)
326             {
327               if (! ISHEX (hdr[i]))
328                 {
329                   ihex_bad_byte (abfd, lineno, hdr[i], error);
330                   goto error_return;
331                 }
332             }
333
334           len = HEX2 (hdr);
335           addr = HEX4 (hdr + 2);
336           type = HEX2 (hdr + 6);
337
338           /* Read the data bytes.  */
339
340           chars = len * 2 + 2;
341           if (chars >= bufsize)
342             {
343               buf = (bfd_byte *) bfd_realloc (buf, (bfd_size_type) chars);
344               if (buf == NULL)
345                 goto error_return;
346               bufsize = chars;
347             }
348
349           if (bfd_bread (buf, (bfd_size_type) chars, abfd) != chars)
350             goto error_return;
351
352           for (i = 0; i < chars; i++)
353             {
354               if (! ISHEX (buf[i]))
355                 {
356                   ihex_bad_byte (abfd, lineno, hdr[i], error);
357                   goto error_return;
358                 }
359             }
360
361           /* Check the checksum.  */
362           chksum = len + addr + (addr >> 8) + type;
363           for (i = 0; i < len; i++)
364             chksum += HEX2 (buf + 2 * i);
365           if (((- chksum) & 0xff) != (unsigned int) HEX2 (buf + 2 * i))
366             {
367               (*_bfd_error_handler)
368                 (_("%s:%u: bad checksum in Intel Hex file (expected %u, found %u)"),
369                  bfd_archive_filename (abfd), lineno,
370                  (- chksum) & 0xff, (unsigned int) HEX2 (buf + 2 * i));
371               bfd_set_error (bfd_error_bad_value);
372               goto error_return;
373             }
374
375           switch (type)
376             {
377             case 0:
378               /* This is a data record.  */
379               if (sec != NULL
380                   && sec->vma + sec->_raw_size == extbase + segbase + addr)
381                 {
382                   /* This data goes at the end of the section we are
383                      currently building.  */
384                   sec->_raw_size += len;
385                 }
386               else if (len > 0)
387                 {
388                   char secbuf[20];
389                   char *secname;
390                   bfd_size_type amt;
391
392                   sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
393                   amt = strlen (secbuf) + 1;
394                   secname = (char *) bfd_alloc (abfd, amt);
395                   if (secname == NULL)
396                     goto error_return;
397                   strcpy (secname, secbuf);
398                   sec = bfd_make_section (abfd, secname);
399                   if (sec == NULL)
400                     goto error_return;
401                   sec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
402                   sec->vma = extbase + segbase + addr;
403                   sec->lma = extbase + segbase + addr;
404                   sec->_raw_size = len;
405                   sec->filepos = pos;
406                 }
407               break;
408
409             case 1:
410               /* An end record.  */
411               if (abfd->start_address == 0)
412                 abfd->start_address = addr;
413               if (buf != NULL)
414                 free (buf);
415               return true;
416
417             case 2:
418               /* An extended address record.  */
419               if (len != 2)
420                 {
421                   (*_bfd_error_handler)
422                     (_("%s:%u: bad extended address record length in Intel Hex file"),
423                      bfd_archive_filename (abfd), lineno);
424                   bfd_set_error (bfd_error_bad_value);
425                   goto error_return;
426                 }
427
428               segbase = HEX4 (buf) << 4;
429
430               sec = NULL;
431
432               break;
433
434             case 3:
435               /* An extended start address record.  */
436               if (len != 4)
437                 {
438                   (*_bfd_error_handler)
439                     (_("%s:%u: bad extended start address length in Intel Hex file"),
440                      bfd_archive_filename (abfd), lineno);
441                   bfd_set_error (bfd_error_bad_value);
442                   goto error_return;
443                 }
444
445               abfd->start_address += (HEX4 (buf) << 4) + HEX4 (buf + 4);
446
447               sec = NULL;
448
449               break;
450
451             case 4:
452               /* An extended linear address record.  */
453               if (len != 2)
454                 {
455                   (*_bfd_error_handler)
456                     (_("%s:%u: bad extended linear address record length in Intel Hex file"),
457                      bfd_archive_filename (abfd), lineno);
458                   bfd_set_error (bfd_error_bad_value);
459                   goto error_return;
460                 }
461
462               extbase = HEX4 (buf) << 16;
463
464               sec = NULL;
465
466               break;
467
468             case 5:
469               /* An extended linear start address record.  */
470               if (len != 2 && len != 4)
471                 {
472                   (*_bfd_error_handler)
473                     (_("%s:%u: bad extended linear start address length in Intel Hex file"),
474                      bfd_archive_filename (abfd), lineno);
475                   bfd_set_error (bfd_error_bad_value);
476                   goto error_return;
477                 }
478
479               if (len == 2)
480                 abfd->start_address += HEX4 (buf) << 16;
481               else
482                 abfd->start_address = (HEX4 (buf) << 16) + HEX4 (buf + 4);
483
484               sec = NULL;
485
486               break;
487
488             default:
489               (*_bfd_error_handler)
490                 (_("%s:%u: unrecognized ihex type %u in Intel Hex file\n"),
491                  bfd_archive_filename (abfd), lineno, type);
492               bfd_set_error (bfd_error_bad_value);
493               goto error_return;
494             }
495         }
496     }
497
498   if (error)
499     goto error_return;
500
501   if (buf != NULL)
502     free (buf);
503
504   return true;
505
506  error_return:
507   if (buf != NULL)
508     free (buf);
509   return false;
510 }
511
512 /* Try to recognize an Intel Hex file.  */
513
514 static const bfd_target *
515 ihex_object_p (abfd)
516      bfd *abfd;
517 {
518   bfd_byte b[9];
519   unsigned int i;
520   unsigned int type;
521
522   ihex_init ();
523
524   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
525     return NULL;
526   if (bfd_bread (b, (bfd_size_type) 9, abfd) != 9)
527     {
528       if (bfd_get_error () == bfd_error_file_truncated)
529         bfd_set_error (bfd_error_wrong_format);
530       return NULL;
531     }
532
533   if (b[0] != ':')
534     {
535       bfd_set_error (bfd_error_wrong_format);
536       return NULL;
537     }
538
539   for (i = 1; i < 9; i++)
540     {
541       if (! ISHEX (b[i]))
542         {
543           bfd_set_error (bfd_error_wrong_format);
544           return NULL;
545         }
546     }
547
548   type = HEX2 (b + 7);
549   if (type > 5)
550     {
551       bfd_set_error (bfd_error_wrong_format);
552       return NULL;
553     }
554
555   /* OK, it looks like it really is an Intel Hex file.  */
556
557   if (! ihex_mkobject (abfd)
558       || ! ihex_scan (abfd))
559     return NULL;
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 > 0xfffff)
879             now = 0xffff - 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_link_hash_table_create _bfd_generic_link_hash_table_create
984 #define ihex_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
985 #define ihex_bfd_link_add_symbols _bfd_generic_link_add_symbols
986 #define ihex_bfd_final_link _bfd_generic_final_link
987 #define ihex_bfd_link_split_section _bfd_generic_link_split_section
988
989 /* The Intel Hex target vector.  */
990
991 const bfd_target ihex_vec =
992 {
993   "ihex",                       /* name */
994   bfd_target_ihex_flavour,
995   BFD_ENDIAN_UNKNOWN,           /* target byte order */
996   BFD_ENDIAN_UNKNOWN,           /* target headers byte order */
997   0,                            /* object flags */
998   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD),    /* section flags */
999   0,                            /* leading underscore */
1000   ' ',                          /* ar_pad_char */
1001   16,                           /* ar_max_namelen */
1002   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1003   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1004   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* data */
1005   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1006   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1007   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* hdrs */
1008
1009   {
1010     _bfd_dummy_target,
1011     ihex_object_p,              /* bfd_check_format */
1012     _bfd_dummy_target,
1013     _bfd_dummy_target,
1014   },
1015   {
1016     bfd_false,
1017     ihex_mkobject,
1018     _bfd_generic_mkarchive,
1019     bfd_false,
1020   },
1021   {                             /* bfd_write_contents */
1022     bfd_false,
1023     ihex_write_object_contents,
1024     _bfd_write_archive_contents,
1025     bfd_false,
1026   },
1027
1028   BFD_JUMP_TABLE_GENERIC (ihex),
1029   BFD_JUMP_TABLE_COPY (_bfd_generic),
1030   BFD_JUMP_TABLE_CORE (_bfd_nocore),
1031   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1032   BFD_JUMP_TABLE_SYMBOLS (ihex),
1033   BFD_JUMP_TABLE_RELOCS (ihex),
1034   BFD_JUMP_TABLE_WRITE (ihex),
1035   BFD_JUMP_TABLE_LINK (ihex),
1036   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1037
1038   NULL,
1039
1040   (PTR) 0
1041 };