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
 292   while ((c = ihex_get_byte (abfd, &error)) != EOF)
 293     {
 294       if (c == '\r')
 295         continue;
 296       else if (c == '\n')
 297         {
 298           ++lineno;
 299           continue;
 300         }
 301       else if (c != ':')
 302         {
 303           ihex_bad_byte (abfd, lineno, c, error);
 304           goto error_return;
 305         }
 306       else
 307         {
 308           file_ptr pos;
 309           char hdr[8];
 310           unsigned int i;
 311           unsigned int len;
 312           bfd_vma addr;
 313           unsigned int type;
 314           unsigned int chars;
 315           unsigned int chksum;
 316
 317           /* This is a data record.  */
 318           pos = bfd_tell (abfd) - 1;
 319
 320           /* Read the header bytes.  */
 321           if (bfd_bread (hdr, (bfd_size_type) 8, abfd) != 8)
 322             goto error_return;
 323
 324           for (i = 0; i < 8; i++)
 325             {
 326               if (! ISHEX (hdr[i]))
 327                 {
 328                   ihex_bad_byte (abfd, lineno, hdr[i], error);
 329                   goto error_return;
 330                 }
 331             }
 332
 333           len = HEX2 (hdr);
 334           addr = HEX4 (hdr + 2);
 335           type = HEX2 (hdr + 6);
 336
 337           /* Read the data bytes.  */
 338           chars = len * 2 + 2;
 339           if (chars >= bufsize)
 340             {
 341               buf = (bfd_byte *) bfd_realloc (buf, (bfd_size_type) chars);
 342               if (buf == NULL)
 343                 goto error_return;
 344               bufsize = chars;
 345             }
 346
 347           if (bfd_bread (buf, (bfd_size_type) chars, abfd) != chars)
 348             goto error_return;
 349
 350           for (i = 0; i < chars; i++)
 351             {
 352               if (! ISHEX (buf[i]))
 353                 {
 354                   ihex_bad_byte (abfd, lineno, hdr[i], error);
 355                   goto error_return;
 356                 }
 357             }
 358
 359           /* Check the checksum.  */
 360           chksum = len + addr + (addr >> 8) + type;
 361           for (i = 0; i < len; i++)
 362             chksum += HEX2 (buf + 2 * i);
 363           if (((- chksum) & 0xff) != (unsigned int) HEX2 (buf + 2 * i))
 364             {
 365               (*_bfd_error_handler)
 366                 (_("%s:%u: bad checksum in Intel Hex file (expected %u, found %u)"),
 367                  bfd_archive_filename (abfd), lineno,
 368                  (- chksum) & 0xff, (unsigned int) HEX2 (buf + 2 * i));
 369               bfd_set_error (bfd_error_bad_value);
 370               goto error_return;
 371             }
 372
 373           switch (type)
 374             {
 375             case 0:
 376               /* This is a data record.  */
 377               if (sec != NULL
 378                   && sec->vma + sec->_raw_size == extbase + segbase + addr)
 379                 {
 380                   /* This data goes at the end of the section we are
 381                      currently building.  */
 382                   sec->_raw_size += len;
 383                 }
 384               else if (len > 0)
 385                 {
 386                   char secbuf[20];
 387                   char *secname;
 388                   bfd_size_type amt;
 389
 390                   sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
 391                   amt = strlen (secbuf) + 1;
 392                   secname = (char *) bfd_alloc (abfd, amt);
 393                   if (secname == NULL)
 394                     goto error_return;
 395                   strcpy (secname, secbuf);
 396                   sec = bfd_make_section (abfd, secname);
 397                   if (sec == NULL)
 398                     goto error_return;
 399                   sec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
 400                   sec->vma = extbase + segbase + addr;
 401                   sec->lma = extbase + segbase + addr;
 402                   sec->_raw_size = len;
 403                   sec->filepos = pos;
 404                 }
 405               break;
 406
 407             case 1:
 408               /* An end record.  */
 409               if (abfd->start_address == 0)
 410                 abfd->start_address = addr;
 411               if (buf != NULL)
 412                 free (buf);
 413               return true;
 414
 415             case 2:
 416               /* An extended address record.  */
 417               if (len != 2)
 418                 {
 419                   (*_bfd_error_handler)
 420                     (_("%s:%u: bad extended address record length in Intel Hex file"),
 421                      bfd_archive_filename (abfd), lineno);
 422                   bfd_set_error (bfd_error_bad_value);
 423                   goto error_return;
 424                 }
 425
 426               segbase = HEX4 (buf) << 4;
 427
 428               sec = NULL;
 429
 430               break;
 431
 432             case 3:
 433               /* An extended start address record.  */
 434               if (len != 4)
 435                 {
 436                   (*_bfd_error_handler)
 437                     (_("%s:%u: bad extended start address length in Intel Hex file"),
 438                      bfd_archive_filename (abfd), lineno);
 439                   bfd_set_error (bfd_error_bad_value);
 440                   goto error_return;
 441                 }
 442
 443               abfd->start_address += (HEX4 (buf) << 4) + HEX4 (buf + 4);
 444
 445               sec = NULL;
 446
 447               break;
 448
 449             case 4:
 450               /* An extended linear address record.  */
 451               if (len != 2)
 452                 {
 453                   (*_bfd_error_handler)
 454                     (_("%s:%u: bad extended linear address record length in Intel Hex file"),
 455                      bfd_archive_filename (abfd), lineno);
 456                   bfd_set_error (bfd_error_bad_value);
 457                   goto error_return;
 458                 }
 459
 460               extbase = HEX4 (buf) << 16;
 461
 462               sec = NULL;
 463
 464               break;
 465
 466             case 5:
 467               /* An extended linear start address record.  */
 468               if (len != 2 && len != 4)
 469                 {
 470                   (*_bfd_error_handler)
 471                     (_("%s:%u: bad extended linear start address length in Intel Hex file"),
 472                      bfd_archive_filename (abfd), lineno);
 473                   bfd_set_error (bfd_error_bad_value);
 474                   goto error_return;
 475                 }
 476
 477               if (len == 2)
 478                 abfd->start_address += HEX4 (buf) << 16;
 479               else
 480                 abfd->start_address = (HEX4 (buf) << 16) + HEX4 (buf + 4);
 481
 482               sec = NULL;
 483
 484               break;
 485
 486             default:
 487               (*_bfd_error_handler)
 488                 (_("%s:%u: unrecognized ihex type %u in Intel Hex file\n"),
 489                  bfd_archive_filename (abfd), lineno, type);
 490               bfd_set_error (bfd_error_bad_value);
 491               goto error_return;
 492             }
 493         }
 494     }
 495
 496   if (error)
 497     goto error_return;
 498
 499   if (buf != NULL)
 500     free (buf);
 501
 502   return true;
 503
 504  error_return:
 505   if (buf != NULL)
 506     free (buf);
 507   return false;
 508 }
 509
 510 /* Try to recognize an Intel Hex file.  */
 511
 512 static const bfd_target *
 513 ihex_object_p (abfd)
 514      bfd *abfd;
 515 {
 516   bfd_byte b[9];
 517   unsigned int i;
 518   unsigned int type;
 519
 520   ihex_init ();
 521
 522   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 523     return NULL;
 524   if (bfd_bread (b, (bfd_size_type) 9, abfd) != 9)
 525     {
 526       if (bfd_get_error () == bfd_error_file_truncated)
 527         bfd_set_error (bfd_error_wrong_format);
 528       return NULL;
 529     }
 530
 531   if (b[0] != ':')
 532     {
 533       bfd_set_error (bfd_error_wrong_format);
 534       return NULL;
 535     }
 536
 537   for (i = 1; i < 9; i++)
 538     {
 539       if (! ISHEX (b[i]))
 540         {
 541           bfd_set_error (bfd_error_wrong_format);
 542           return NULL;
 543         }
 544     }
 545
 546   type = HEX2 (b + 7);
 547   if (type > 5)
 548     {
 549       bfd_set_error (bfd_error_wrong_format);
 550       return NULL;
 551     }
 552
 553   /* OK, it looks like it really is an Intel Hex file.  */
 554   if (! ihex_mkobject (abfd)
 555       || ! ihex_scan (abfd))
 556     return NULL;
 557
 558   return abfd->xvec;
 559 }
 560
 561 /* Read the contents of a section in an Intel Hex file.  */
 562
 563 static boolean
 564 ihex_read_section (abfd, section, contents)
 565      bfd *abfd;
 566      asection *section;
 567      bfd_byte *contents;
 568 {
 569   int c;
 570   bfd_byte *p;
 571   bfd_byte *buf = NULL;
 572   size_t bufsize;
 573   boolean error;
 574
 575   if (bfd_seek (abfd, section->filepos, SEEK_SET) != 0)
 576     goto error_return;
 577
 578   p = contents;
 579   bufsize = 0;
 580   error = false;
 581   while ((c = ihex_get_byte (abfd, &error)) != EOF)
 582     {
 583       char hdr[8];
 584       unsigned int len;
 585       bfd_vma addr;
 586       unsigned int type;
 587       unsigned int i;
 588
 589       if (c == '\r' || c == '\n')
 590         continue;
 591
 592       /* This is called after ihex_scan has succeeded, so we ought to
 593          know the exact format.  */
 594       BFD_ASSERT (c == ':');
 595
 596       if (bfd_bread (hdr, (bfd_size_type) 8, abfd) != 8)
 597         goto error_return;
 598
 599       len = HEX2 (hdr);
 600       addr = HEX4 (hdr + 2);
 601       type = HEX2 (hdr + 6);
 602
 603       /* We should only see type 0 records here.  */
 604       if (type != 0)
 605         {
 606           (*_bfd_error_handler)
 607             (_("%s: internal error in ihex_read_section"),
 608              bfd_archive_filename (abfd));
 609           bfd_set_error (bfd_error_bad_value);
 610           goto error_return;
 611         }
 612
 613       if (len * 2 > bufsize)
 614         {
 615           buf = (bfd_byte *) bfd_realloc (buf, (bfd_size_type) len * 2);
 616           if (buf == NULL)
 617             goto error_return;
 618           bufsize = len * 2;
 619         }
 620
 621       if (bfd_bread (buf, (bfd_size_type) len * 2, abfd) != len * 2)
 622         goto error_return;
 623
 624       for (i = 0; i < len; i++)
 625         *p++ = HEX2 (buf + 2 * i);
 626       if ((bfd_size_type) (p - contents) >= section->_raw_size)
 627         {
 628           /* We've read everything in the section.  */
 629           if (buf != NULL)
 630             free (buf);
 631           return true;
 632         }
 633
 634       /* Skip the checksum.  */
 635       if (bfd_bread (buf, (bfd_size_type) 2, abfd) != 2)
 636         goto error_return;
 637     }
 638
 639   if ((bfd_size_type) (p - contents) < section->_raw_size)
 640     {
 641       (*_bfd_error_handler)
 642         (_("%s: bad section length in ihex_read_section"),
 643          bfd_archive_filename (abfd));
 644       bfd_set_error (bfd_error_bad_value);
 645       goto error_return;
 646     }
 647
 648   if (buf != NULL)
 649     free (buf);
 650
 651   return true;
 652
 653  error_return:
 654   if (buf != NULL)
 655     free (buf);
 656   return false;
 657 }
 658
 659 /* Get the contents of a section in an Intel Hex file.  */
 660
 661 static boolean
 662 ihex_get_section_contents (abfd, section, location, offset, count)
 663      bfd *abfd;
 664      asection *section;
 665      PTR location;
 666      file_ptr offset;
 667      bfd_size_type count;
 668 {
 669   if (section->used_by_bfd == NULL)
 670     {
 671       section->used_by_bfd = bfd_alloc (abfd, section->_raw_size);
 672       if (section->used_by_bfd == NULL)
 673         return false;
 674       if (! ihex_read_section (abfd, section, section->used_by_bfd))
 675         return false;
 676     }
 677
 678   memcpy (location, (bfd_byte *) section->used_by_bfd + offset,
 679           (size_t) count);
 680
 681   return true;
 682 }
 683
 684 /* Set the contents of a section in an Intel Hex file.  */
 685
 686 static boolean
 687 ihex_set_section_contents (abfd, section, location, offset, count)
 688      bfd *abfd;
 689      asection *section;
 690      PTR location;
 691      file_ptr offset;
 692      bfd_size_type count;
 693 {
 694   struct ihex_data_list *n;
 695   bfd_byte *data;
 696   struct ihex_data_struct *tdata;
 697   bfd_size_type amt;
 698
 699   if (count == 0
 700       || (section->flags & SEC_ALLOC) == 0
 701       || (section->flags & SEC_LOAD) == 0)
 702     return true;
 703
 704   amt = sizeof (struct ihex_data_list);
 705   n = (struct ihex_data_list *) bfd_alloc (abfd, amt);
 706   if (n == NULL)
 707     return false;
 708
 709   data = (bfd_byte *) bfd_alloc (abfd, count);
 710   if (data == NULL)
 711     return false;
 712   memcpy (data, location, (size_t) count);
 713
 714   n->data = data;
 715   n->where = section->lma + offset;
 716   n->size = count;
 717
 718   /* Sort the records by address.  Optimize for the common case of
 719      adding a record to the end of the list.  */
 720   tdata = abfd->tdata.ihex_data;
 721   if (tdata->tail != NULL
 722       && n->where >= tdata->tail->where)
 723     {
 724       tdata->tail->next = n;
 725       n->next = NULL;
 726       tdata->tail = n;
 727     }
 728   else
 729     {
 730       register struct ihex_data_list **pp;
 731
 732       for (pp = &tdata->head;
 733            *pp != NULL && (*pp)->where < n->where;
 734            pp = &(*pp)->next)
 735         ;
 736       n->next = *pp;
 737       *pp = n;
 738       if (n->next == NULL)
 739         tdata->tail = n;
 740     }
 741
 742   return true;
 743 }
 744
 745 /* Write a record out to an Intel Hex file.  */
 746
 747 static boolean
 748 ihex_write_record (abfd, count, addr, type, data)
 749      bfd *abfd;
 750      size_t count;
 751      unsigned int addr;
 752      unsigned int type;
 753      bfd_byte *data;
 754 {
 755   static const char digs[] = "0123456789ABCDEF";
 756   char buf[9 + CHUNK * 2 + 4];
 757   char *p;
 758   unsigned int chksum;
 759   unsigned int i;
 760   size_t total;
 761
 762 #define TOHEX(buf, v) \
 763   ((buf)[0] = digs[((v) >> 4) & 0xf], (buf)[1] = digs[(v) & 0xf])
 764
 765   buf[0] = ':';
 766   TOHEX (buf + 1, count);
 767   TOHEX (buf + 3, (addr >> 8) & 0xff);
 768   TOHEX (buf + 5, addr & 0xff);
 769   TOHEX (buf + 7, type);
 770
 771   chksum = count + addr + (addr >> 8) + type;
 772
 773   for (i = 0, p = buf + 9; i < count; i++, p += 2, data++)
 774     {
 775       TOHEX (p, *data);
 776       chksum += *data;
 777     }
 778
 779   TOHEX (p, (- chksum) & 0xff);
 780   p[2] = '\r';
 781   p[3] = '\n';
 782
 783   total = 9 + count * 2 + 4;
 784   if (bfd_bwrite (buf, (bfd_size_type) total, abfd) != total)
 785     return false;
 786
 787   return true;
 788 }
 789
 790 /* Write out an Intel Hex file.  */
 791
 792 static boolean
 793 ihex_write_object_contents (abfd)
 794      bfd *abfd;
 795 {
 796   bfd_vma segbase;
 797   bfd_vma extbase;
 798   struct ihex_data_list *l;
 799
 800   segbase = 0;
 801   extbase = 0;
 802   for (l = abfd->tdata.ihex_data->head; l != NULL; l = l->next)
 803     {
 804       bfd_vma where;
 805       bfd_byte *p;
 806       bfd_size_type count;
 807
 808       where = l->where;
 809       p = l->data;
 810       count = l->size;
 811       while (count > 0)
 812         {
 813           size_t now;
 814           unsigned int rec_addr;
 815
 816           now = count;
 817           if (count > CHUNK)
 818             now = CHUNK;
 819
 820           if (where > segbase + extbase + 0xffff)
 821             {
 822               bfd_byte addr[2];
 823
 824               /* We need a new base address.  */
 825               if (where <= 0xfffff)
 826                 {
 827                   /* The addresses should be sorted.  */
 828                   BFD_ASSERT (extbase == 0);
 829
 830                   segbase = where & 0xf0000;
 831                   addr[0] = (bfd_byte)(segbase >> 12) & 0xff;
 832                   addr[1] = (bfd_byte)(segbase >> 4) & 0xff;
 833                   if (! ihex_write_record (abfd, 2, 0, 2, addr))
 834                     return false;
 835                 }
 836               else
 837                 {
 838                   /* The extended address record and the extended
 839                      linear address record are combined, at least by
 840                      some readers.  We need an extended linear address
 841                      record here, so if we've already written out an
 842                      extended address record, zero it out to avoid
 843                      confusion.  */
 844                   if (segbase != 0)
 845                     {
 846                       addr[0] = 0;
 847                       addr[1] = 0;
 848                       if (! ihex_write_record (abfd, 2, 0, 2, addr))
 849                         return false;
 850                       segbase = 0;
 851                     }
 852
 853                   extbase = where & 0xffff0000;
 854                   if (where > extbase + 0xffff)
 855                     {
 856                       char buf[20];
 857
 858                       sprintf_vma (buf, where);
 859                       (*_bfd_error_handler)
 860                         (_("%s: address 0x%s out of range for Intel Hex file"),
 861                          bfd_get_filename (abfd), buf);
 862                       bfd_set_error (bfd_error_bad_value);
 863                       return false;
 864                     }
 865                   addr[0] = (bfd_byte)(extbase >> 24) & 0xff;
 866                   addr[1] = (bfd_byte)(extbase >> 16) & 0xff;
 867                   if (! ihex_write_record (abfd, 2, 0, 4, addr))
 868                     return false;
 869                 }
 870             }
 871
 872           rec_addr = where - (extbase + segbase);
 873
 874           /* Output records shouldn't cross 64K boundaries.  */
 875           if (rec_addr + now > 0xffff)
 876             now = 0x10000 - rec_addr;
 877
 878           if (! ihex_write_record (abfd, now, rec_addr, 0, p))
 879             return false;
 880
 881           where += now;
 882           p += now;
 883           count -= now;
 884         }
 885     }
 886
 887   if (abfd->start_address != 0)
 888     {
 889       bfd_vma start;
 890       bfd_byte startbuf[4];
 891
 892       start = abfd->start_address;
 893
 894       if (start <= 0xfffff)
 895         {
 896           startbuf[0] = (bfd_byte)((start & 0xf0000) >> 12) & 0xff;
 897           startbuf[1] = 0;
 898           startbuf[2] = (bfd_byte)(start >> 8) & 0xff;
 899           startbuf[3] = (bfd_byte)start & 0xff;
 900           if (! ihex_write_record (abfd, 4, 0, 3, startbuf))
 901             return false;
 902         }
 903       else
 904         {
 905           startbuf[0] = (bfd_byte)(start >> 24) & 0xff;
 906           startbuf[1] = (bfd_byte)(start >> 16) & 0xff;
 907           startbuf[2] = (bfd_byte)(start >> 8) & 0xff;
 908           startbuf[3] = (bfd_byte)start & 0xff;
 909           if (! ihex_write_record (abfd, 4, 0, 5, startbuf))
 910             return false;
 911         }
 912     }
 913
 914   if (! ihex_write_record (abfd, 0, 0, 1, NULL))
 915     return false;
 916
 917   return true;
 918 }
 919
 920 /* Set the architecture for the output file.  The architecture is
 921    irrelevant, so we ignore errors about unknown architectures.  */
 922
 923 static boolean
 924 ihex_set_arch_mach (abfd, arch, mach)
 925      bfd *abfd;
 926      enum bfd_architecture arch;
 927      unsigned long mach;
 928 {
 929   if (! bfd_default_set_arch_mach (abfd, arch, mach))
 930     {
 931       if (arch != bfd_arch_unknown)
 932         return false;
 933     }
 934   return true;
 935 }
 936
 937 /* Get the size of the headers, for the linker.  */
 938
 939 /*ARGSUSED*/
 940 static int
 941 ihex_sizeof_headers (abfd, exec)
 942      bfd *abfd ATTRIBUTE_UNUSED;
 943      boolean exec ATTRIBUTE_UNUSED;
 944 {
 945   return 0;
 946 }
 947
 948 /* Some random definitions for the target vector.  */
 949
 950 #define ihex_close_and_cleanup _bfd_generic_close_and_cleanup
 951 #define ihex_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
 952 #define ihex_new_section_hook _bfd_generic_new_section_hook
 953 #define ihex_get_section_contents_in_window \
 954   _bfd_generic_get_section_contents_in_window
 955
 956 #define ihex_get_symtab_upper_bound bfd_0l
 957 #define ihex_get_symtab \
 958   ((long (*) PARAMS ((bfd *, asymbol **))) bfd_0l)
 959 #define ihex_make_empty_symbol _bfd_generic_make_empty_symbol
 960 #define ihex_print_symbol _bfd_nosymbols_print_symbol
 961 #define ihex_get_symbol_info _bfd_nosymbols_get_symbol_info
 962 #define ihex_bfd_is_local_label_name _bfd_nosymbols_bfd_is_local_label_name
 963 #define ihex_get_lineno _bfd_nosymbols_get_lineno
 964 #define ihex_find_nearest_line _bfd_nosymbols_find_nearest_line
 965 #define ihex_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
 966 #define ihex_read_minisymbols _bfd_nosymbols_read_minisymbols
 967 #define ihex_minisymbol_to_symbol _bfd_nosymbols_minisymbol_to_symbol
 968
 969 #define ihex_get_reloc_upper_bound \
 970   ((long (*) PARAMS ((bfd *, asection *))) bfd_0l)
 971 #define ihex_canonicalize_reloc \
 972   ((long (*) PARAMS ((bfd *, asection *, arelent **, asymbol **))) bfd_0l)
 973 #define ihex_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
 974
 975 #define ihex_bfd_get_relocated_section_contents \
 976   bfd_generic_get_relocated_section_contents
 977 #define ihex_bfd_relax_section bfd_generic_relax_section
 978 #define ihex_bfd_gc_sections bfd_generic_gc_sections
 979 #define ihex_bfd_merge_sections bfd_generic_merge_sections
 980 #define ihex_bfd_discard_group bfd_generic_discard_group
 981 #define ihex_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
 982 #define ihex_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
 983 #define ihex_bfd_link_add_symbols _bfd_generic_link_add_symbols
 984 #define ihex_bfd_link_just_syms _bfd_generic_link_just_syms
 985 #define ihex_bfd_final_link _bfd_generic_final_link
 986 #define ihex_bfd_link_split_section _bfd_generic_link_split_section
 987
 988 /* The Intel Hex target vector.  */
 989
 990 const bfd_target ihex_vec =
 991 {
 992   "ihex",                       /* name */
 993   bfd_target_ihex_flavour,
 994   BFD_ENDIAN_UNKNOWN,           /* target byte order */
 995   BFD_ENDIAN_UNKNOWN,           /* target headers byte order */
 996   0,                            /* object flags */
 997   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD),    /* section flags */
 998   0,                            /* leading underscore */
 999   ' ',                          /* ar_pad_char */
1000   16,                           /* ar_max_namelen */
1001   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1002   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1003   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* data */
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,   /* hdrs */
1007
1008   {
1009     _bfd_dummy_target,
1010     ihex_object_p,              /* bfd_check_format */
1011     _bfd_dummy_target,
1012     _bfd_dummy_target,
1013   },
1014   {
1015     bfd_false,
1016     ihex_mkobject,
1017     _bfd_generic_mkarchive,
1018     bfd_false,
1019   },
1020   {                             /* bfd_write_contents */
1021     bfd_false,
1022     ihex_write_object_contents,
1023     _bfd_write_archive_contents,
1024     bfd_false,
1025   },
1026
1027   BFD_JUMP_TABLE_GENERIC (ihex),
1028   BFD_JUMP_TABLE_COPY (_bfd_generic),
1029   BFD_JUMP_TABLE_CORE (_bfd_nocore),
1030   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1031   BFD_JUMP_TABLE_SYMBOLS (ihex),
1032   BFD_JUMP_TABLE_RELOCS (ihex),
1033   BFD_JUMP_TABLE_WRITE (ihex),
1034   BFD_JUMP_TABLE_LINK (ihex),
1035   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1036
1037   NULL,
1038
1039   (PTR) 0
1040 };