bfd/ihex.c

   1 /* BFD back-end for Intel Hex objects.
   2    Copyright 1995 Free Software Foundation, Inc.
   3    Written by Ian Lance Taylor of Cygnus Support <ian@cygnus.com>.
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 /* This is what Intel Hex files look like:
  22
  23 1. INTEL FORMATS
  24
  25 A. Intel 1
  26
  27    16-bit address-field format, for files 64k bytes in length or less.
  28
  29    DATA RECORD
  30    Byte 1       Header = colon(:)
  31    2..3         The number of data bytes in hex notation
  32    4..5         High byte of the record load address
  33    6..7         Low byte of the record load address
  34    8..9         Record type, must be "00"
  35    10..x        Data bytes in hex notation:
  36         x = (number of bytes - 1) * 2 + 11
  37    x+1..x+2     Checksum in hex notation
  38    x+3..x+4     Carriage return, line feed
  39
  40    END RECORD
  41    Byte 1       Header = colon (:)
  42    2..3         The byte count, must be "00"
  43    4..7         Transfer-address (usually "0000")
  44                 the jump-to address, execution start address
  45    8..9         Record type, must be "01"
  46    10..11       Checksum, in hex notation
  47    12..13       Carriage return, line feed
  48
  49 B. INTEL 2
  50
  51    MCS-86 format, using a 20-bit address for files larger than 64K bytes.
  52
  53    DATA RECORD
  54    Byte 1       Header = colon (:)
  55    2..3         The byte count of this record, hex notation
  56    4..5         High byte of the record load address
  57    6..7         Low byte of the record load address
  58    8..9         Record type, must be "00"
  59    10..x        The data bytes in hex notation:
  60         x = (number of data bytes - 1) * 2 + 11
  61    x+1..x+2     Checksum in hex notation
  62    x+3..x+4     Carriage return, line feed
  63
  64    EXTENDED ADDRESS RECORD
  65    Byte 1       Header = colon(:)
  66    2..3         The byte count, must be "02"
  67    4..7         Load address, must be "0000"
  68    8..9         Record type, must be "02"
  69    10..11       High byte of the offset address
  70    12..13       Low byte of the offset address
  71    14..15       Checksum in hex notation
  72    16..17       Carriage return, line feed
  73
  74    The checksums are the two's complement of the 8-bit sum
  75    without carry of the byte count, offset address, and the
  76    record type.
  77
  78    START ADDRESS RECORD
  79    Byte 1       Header = colon (:)
  80    2..3         The byte count, must be "04"
  81    4..7         Load address, must be "0000"
  82    8..9         Record type, must be "03"
  83    10..13       8086 CS value
  84    14..17       8086 IP value
  85    18..19       Checksum in hex notation
  86    20..21       Carriage return, line feed
  87
  88 Another document reports these additional types:
  89
  90    EXTENDED LINEAR ADDRESS RECORD
  91    Byte 1       Header = colon (:)
  92    2..3         The byte count, must be "02"
  93    4..7         Load address, must be "0000"
  94    8..9         Record type, must be "04"
  95    10..13       Upper 16 bits of address of subsequent records
  96    14..15       Checksum in hex notation
  97    16..17       Carriage return, line feed
  98
  99    START LINEAR ADDRESS RECORD
 100    Byte 1       Header = colon (:)
 101    2..3         The byte count, must be "02"
 102    4..7         Load address, must be "0000"
 103    8..9         Record type, must be "05"
 104    10..13       Upper 16 bits of start address
 105    14..15       Checksum in hex notation
 106    16..17       Carriage return, line feed
 107
 108 The MRI compiler uses this, which is a repeat of type 5:
 109
 110   EXTENDED START RECORD
 111    Byte 1       Header = colon (:)
 112    2..3         The byte count, must be "04"
 113    4..7         Load address, must be "0000"
 114    8..9         Record type, must be "05"
 115    10..13       Upper 16 bits of start address
 116    14..17       Lower 16 bits of start address
 117    18..19       Checksum in hex notation
 118    20..21       Carriage return, line feed
 119 */
 120
 121 #include "bfd.h"
 122 #include "sysdep.h"
 123 #include "libbfd.h"
 124 #include "libiberty.h"
 125
 126 #include <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 *, bfd_size_type, bfd_vma, unsigned int, bfd_byte *));
 141 static boolean ihex_write_object_contents PARAMS ((bfd *));
 142 static asymbol *ihex_make_empty_symbol PARAMS ((bfd *));
 143 static boolean ihex_set_arch_mach
 144   PARAMS ((bfd *, enum bfd_architecture, unsigned long));
 145
 146 /* The number of bytes we put on one line during output.  */
 147
 148 #define CHUNK (21)
 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
 200       tdata = ((struct ihex_data_struct *)
 201                bfd_alloc (abfd, sizeof (struct ihex_data_struct)));
 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_read (&c, 1, 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_get_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   asection *sec;
 273   int lineno;
 274   boolean error;
 275   bfd_byte *buf;
 276   size_t bufsize;
 277   int c;
 278
 279   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 280     goto error_return;
 281
 282   abfd->start_address = 0;
 283
 284   segbase = 0;
 285   sec = NULL;
 286   lineno = 1;
 287   error = false;
 288   buf = NULL;
 289   bufsize = 0;
 290   while ((c = ihex_get_byte (abfd, &error)) != EOF)
 291     {
 292       if (c == '\r')
 293         continue;
 294       else if (c == '\n')
 295         {
 296           ++lineno;
 297           continue;
 298         }
 299       else if (c != ':')
 300         {
 301           ihex_bad_byte (abfd, lineno, c, error);
 302           goto error_return;
 303         }
 304       else
 305         {
 306           file_ptr pos;
 307           char hdr[8];
 308           unsigned int i;
 309           unsigned int len;
 310           bfd_vma addr;
 311           unsigned int type;
 312           unsigned int chars;
 313           unsigned int chksum;
 314
 315           /* This is a data record.  */
 316
 317           pos = bfd_tell (abfd) - 1;
 318
 319           /* Read the header bytes.  */
 320
 321           if (bfd_read (hdr, 1, 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
 339           chars = len * 2 + 2;
 340           if (chars >= bufsize)
 341             {
 342               buf = (bfd_byte *) bfd_realloc (buf, chars);
 343               if (buf == NULL)
 344                 goto error_return;
 345               bufsize = chars;
 346             }
 347
 348           if (bfd_read (buf, 1, chars, abfd) != chars)
 349             goto error_return;
 350
 351           for (i = 0; i < chars; i++)
 352             {
 353               if (! ISHEX (buf[i]))
 354                 {
 355                   ihex_bad_byte (abfd, lineno, hdr[i], error);
 356                   goto error_return;
 357                 }
 358             }
 359
 360           /* Check the checksum.  */
 361           chksum = len + addr + (addr >> 8) + type;
 362           for (i = 0; i < len; i++)
 363             chksum += HEX2 (buf + 2 * i);
 364           if (((- chksum) & 0xff) != (unsigned int) HEX2 (buf + 2 * i))
 365             {
 366               (*_bfd_error_handler)
 367                 ("%s:%d: bad checksum in Intel Hex file (expected %u, found %u)",
 368                  bfd_get_filename (abfd), lineno,
 369                  (- chksum) & 0xff, (unsigned int) HEX2 (buf + 2 * i));
 370               bfd_set_error (bfd_error_bad_value);
 371               goto error_return;
 372             }
 373
 374           switch (type)
 375             {
 376             case 0:
 377               /* This is a data record.  */
 378               if (sec != NULL
 379                   && sec->vma + sec->_raw_size == segbase + addr)
 380                 {
 381                   /* This data goes at the end of the section we are
 382                      currently building.  */
 383                   sec->_raw_size += len;
 384                 }
 385               else if (len > 0)
 386                 {
 387                   char secbuf[20];
 388                   char *secname;
 389
 390                   sprintf (secbuf, ".sec%d", bfd_count_sections (abfd) + 1);
 391                   secname = (char *) bfd_alloc (abfd, strlen (secbuf) + 1);
 392                   if (secname == NULL)
 393                     goto error_return;
 394                   strcpy (secname, secbuf);
 395                   sec = bfd_make_section (abfd, secname);
 396                   if (sec == NULL)
 397                     goto error_return;
 398                   sec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
 399                   sec->vma = segbase + addr;
 400                   sec->lma = segbase + addr;
 401                   sec->_raw_size = len;
 402                   sec->filepos = pos;
 403                 }
 404               break;
 405
 406             case 1:
 407               /* An end record.  */
 408               if (abfd->start_address == 0)
 409                 abfd->start_address = addr;
 410               if (buf != NULL)
 411                 free (buf);
 412               return true;
 413
 414             case 2:
 415               /* An extended address record.  */
 416               if (len != 2)
 417                 {
 418                   (*_bfd_error_handler)
 419                     ("%s:%d: bad extended address record length in Intel Hex file",
 420                      bfd_get_filename (abfd), lineno);
 421                   bfd_set_error (bfd_error_bad_value);
 422                   goto error_return;
 423                 }
 424
 425               segbase = HEX4 (buf) << 4;
 426
 427               sec = NULL;
 428
 429               break;
 430
 431             case 3:
 432               /* An extended start address record.  */
 433               if (len != 4)
 434                 {
 435                   (*_bfd_error_handler)
 436                     ("%s:%d: bad extended start address length in Intel Hex file",
 437                      bfd_get_filename (abfd), lineno);
 438                   bfd_set_error (bfd_error_bad_value);
 439                   goto error_return;
 440                 }
 441
 442               abfd->start_address += (HEX4 (buf) << 4) + HEX4 (buf + 4);
 443
 444               sec = NULL;
 445
 446               break;
 447
 448             case 4:
 449               /* An extended linear address record.  */
 450               if (len != 2)
 451                 {
 452                   (*_bfd_error_handler)
 453                     ("%s:%d: bad extended linear address record length in Intel Hex file",
 454                      bfd_get_filename (abfd), lineno);
 455                   bfd_set_error (bfd_error_bad_value);
 456                   goto error_return;
 457                 }
 458
 459               segbase = HEX4 (buf) << 16;
 460
 461               sec = NULL;
 462
 463               break;
 464
 465             case 5:
 466               /* An extended linear start address record.  */
 467               if (len != 2 && len != 4)
 468                 {
 469                   (*_bfd_error_handler)
 470                     ("%s:%d: bad extended linear start address length in Intel Hex file",
 471                      bfd_get_filename (abfd), lineno);
 472                   bfd_set_error (bfd_error_bad_value);
 473                   goto error_return;
 474                 }
 475
 476               if (len == 2)
 477                 abfd->start_address += HEX4 (buf) << 16;
 478               else
 479                 abfd->start_address = (HEX4 (buf) << 16) + HEX4 (buf + 4);
 480
 481               sec = NULL;
 482
 483               break;
 484
 485             default:
 486               (*_bfd_error_handler)
 487                 ("%s:%d: unrecognized ihex type %u in Intel Hex file\n",
 488                  bfd_get_filename (abfd), lineno, type);
 489               bfd_set_error (bfd_error_bad_value);
 490               goto error_return;
 491             }
 492         }
 493     }
 494
 495   if (error)
 496     goto error_return;
 497
 498   if (buf != NULL)
 499     free (buf);
 500
 501   return true;
 502
 503  error_return:
 504   if (buf != NULL)
 505     free (buf);
 506   return false;
 507 }
 508
 509 /* Try to recognize an Intel Hex file.  */
 510
 511 static const bfd_target *
 512 ihex_object_p (abfd)
 513      bfd *abfd;
 514 {
 515   bfd_byte b[9];
 516   unsigned int i;
 517   unsigned int type;
 518
 519   ihex_init ();
 520
 521   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 522     return NULL;
 523   if (bfd_read (b, 1, 9, abfd) != 9)
 524     {
 525       if (bfd_get_error () == bfd_error_file_truncated)
 526         bfd_set_error (bfd_error_wrong_format);
 527       return NULL;
 528     }
 529
 530   if (b[0] != ':')
 531     {
 532       bfd_set_error (bfd_error_wrong_format);
 533       return NULL;
 534     }
 535
 536   for (i = 1; i < 9; i++)
 537     {
 538       if (! ISHEX (b[i]))
 539         {
 540           bfd_set_error (bfd_error_wrong_format);
 541           return NULL;
 542         }
 543     }
 544
 545   type = HEX2 (b + 7);
 546   if (type > 5)
 547     {
 548       bfd_set_error (bfd_error_wrong_format);
 549       return NULL;
 550     }
 551
 552   /* OK, it looks like it really is an Intel Hex file.  */
 553
 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;
 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   buf = NULL;
 580   bufsize = 0;
 581   error = false;
 582   while ((c = ihex_get_byte (abfd, &error)) != EOF)
 583     {
 584       char hdr[8];
 585       unsigned int len;
 586       bfd_vma addr;
 587       unsigned int type;
 588       unsigned int i;
 589
 590       if (c == '\r' || c == '\n')
 591         continue;
 592
 593       /* This is called after ihex_scan has succeeded, so we ought to
 594          know the exact format.  */
 595       BFD_ASSERT (c == ':');
 596
 597       if (bfd_read (hdr, 1, 8, abfd) != 8)
 598         goto error_return;
 599
 600       len = HEX2 (hdr);
 601       addr = HEX4 (hdr + 2);
 602       type = HEX2 (hdr + 6);
 603
 604       /* We should only see type 0 records here.  */
 605       if (type != 0)
 606         {
 607           (*_bfd_error_handler)
 608             ("%s: internal error in ihex_read_section",
 609              bfd_get_filename (abfd));
 610           bfd_set_error (bfd_error_bad_value);
 611           goto error_return;
 612         }
 613
 614       if (len * 2 > bufsize)
 615         {
 616           buf = (bfd_byte *) bfd_realloc (buf, len * 2);
 617           if (buf == NULL)
 618             goto error_return;
 619           bufsize = len * 2;
 620         }
 621
 622       if (bfd_read (buf, 1, len * 2, abfd) != len * 2)
 623         goto error_return;
 624
 625       for (i = 0; i < len; i++)
 626         *p++ = HEX2 (buf + 2 * i);
 627       if ((bfd_size_type) (p - contents) >= section->_raw_size)
 628         {
 629           /* We've read everything in the section.  */
 630           if (buf != NULL)
 631             free (buf);
 632           return true;
 633         }
 634
 635       /* Skip the checksum.  */
 636       if (bfd_read (buf, 1, 2, abfd) != 2)
 637         goto error_return;
 638     }
 639
 640   if ((bfd_size_type) (p - contents) < section->_raw_size)
 641     {
 642       (*_bfd_error_handler)
 643         ("%s: bad section length in ihex_read_section",
 644          bfd_get_filename (abfd));
 645       bfd_set_error (bfd_error_bad_value);
 646       goto error_return;
 647     }
 648
 649   if (buf != NULL)
 650     free (buf);
 651
 652   return true;
 653
 654  error_return:
 655   if (buf != NULL)
 656     free (buf);
 657   return false;
 658 }
 659
 660 /* Get the contents of a section in an Intel Hex file.  */
 661
 662 static boolean
 663 ihex_get_section_contents (abfd, section, location, offset, count)
 664      bfd *abfd;
 665      asection *section;
 666      PTR location;
 667      file_ptr offset;
 668      bfd_size_type count;
 669 {
 670   if (section->used_by_bfd == NULL)
 671     {
 672       section->used_by_bfd = bfd_alloc (abfd, section->_raw_size);
 673       if (section->used_by_bfd == NULL)
 674         return false;
 675       if (! ihex_read_section (abfd, section, section->used_by_bfd))
 676         return false;
 677     }
 678
 679   memcpy (location, (bfd_byte *) section->used_by_bfd + offset,
 680           (size_t) count);
 681
 682   return true;
 683 }
 684
 685 /* Set the contents of a section in an Intel Hex file.  */
 686
 687 static boolean
 688 ihex_set_section_contents (abfd, section, location, offset, count)
 689      bfd *abfd;
 690      asection *section;
 691      PTR location;
 692      file_ptr offset;
 693      bfd_size_type count;
 694 {
 695   struct ihex_data_list *n;
 696   bfd_byte *data;
 697   struct ihex_data_struct *tdata;
 698
 699   if (count == 0
 700       || (section->flags & SEC_ALLOC) == 0
 701       || (section->flags & SEC_LOAD) == 0)
 702     return true;
 703
 704   n = ((struct ihex_data_list *)
 705        bfd_alloc (abfd, sizeof (struct ihex_data_list)));
 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      bfd_size_type count;
 751      bfd_vma 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
 761 #define TOHEX(buf, v) \
 762   ((buf)[0] = digs[((v) >> 4) & 0xf], (buf)[1] = digs[(v) & 0xf])
 763
 764   buf[0] = ':';
 765   TOHEX (buf + 1, count);
 766   TOHEX (buf + 3, (addr >> 8) & 0xff);
 767   TOHEX (buf + 5, addr & 0xff);
 768   TOHEX (buf + 7, type);
 769
 770   chksum = count + addr + (addr >> 8) + type;
 771
 772   for (i = 0, p = buf + 9; i < count; i++, p += 2, data++)
 773     {
 774       TOHEX (p, *data);
 775       chksum += *data;
 776     }
 777
 778   TOHEX (p, (- chksum) & 0xff);
 779   p[2] = '\r';
 780   p[3] = '\n';
 781
 782   if (bfd_write (buf, 1, 9 + count * 2 + 4, abfd) != 9 + count * 2 + 4)
 783     return false;
 784
 785   return true;
 786 }
 787
 788 /* Write out an Intel Hex file.  */
 789
 790 static boolean
 791 ihex_write_object_contents (abfd)
 792      bfd *abfd;
 793 {
 794   bfd_vma segbase;
 795   struct ihex_data_list *l;
 796
 797   segbase = 0;
 798   for (l = abfd->tdata.ihex_data->head; l != NULL; l = l->next)
 799     {
 800       bfd_vma where;
 801       bfd_byte *p;
 802       bfd_size_type count;
 803
 804       where = l->where;
 805       p = l->data;
 806       count = l->size;
 807       while (count > 0)
 808         {
 809           bfd_size_type now;
 810
 811           now = count;
 812           if (now > CHUNK)
 813             now = CHUNK;
 814
 815           if (where > segbase + 0xffff)
 816             {
 817               bfd_byte addr[2];
 818
 819               /* We need a new base address.  */
 820               if (where <= 0xfffff)
 821                 {
 822                   segbase = where & 0xf0000;
 823                   addr[0] = (segbase >> 12) & 0xff;
 824                   addr[1] = (segbase >> 4) & 0xff;
 825                   if (! ihex_write_record (abfd, 2, 0, 2, addr))
 826                     return false;
 827                 }
 828               else
 829                 {
 830                   segbase = where & 0xffff0000;
 831                   if (where > segbase + 0xffff)
 832                     {
 833                       char buf[20];
 834
 835                       sprintf_vma (buf, where);
 836                       (*_bfd_error_handler)
 837                         ("%s: address 0x%s out of range for Intex Hex file",
 838                          bfd_get_filename (abfd), buf);
 839                       bfd_set_error (bfd_error_bad_value);
 840                       return false;
 841                     }
 842                   addr[0] = (segbase >> 24) & 0xff;
 843                   addr[1] = (segbase >> 16) & 0xff;
 844                   if (! ihex_write_record (abfd, 2, 0, 4, addr))
 845                     return false;
 846                 }
 847             }
 848
 849           if (! ihex_write_record (abfd, now, where - segbase, 0, p))
 850             return false;
 851
 852           where += now;
 853           p += now;
 854           count -= now;
 855         }
 856     }
 857
 858   if (abfd->start_address != 0)
 859     {
 860       bfd_vma start;
 861       bfd_byte startbuf[4];
 862
 863       start = abfd->start_address;
 864
 865       if (start <= 0xfffff)
 866         {
 867           startbuf[0] = ((start & 0xf0000) >> 12) & 0xff;
 868           startbuf[1] = 0;
 869           startbuf[2] = (start >> 8) & 0xff;
 870           startbuf[3] = start & 0xff;
 871           if (! ihex_write_record (abfd, 4, 0, 3, startbuf))
 872             return false;
 873         }
 874       else
 875         {
 876           startbuf[0] = (start >> 24) & 0xff;
 877           startbuf[1] = (start >> 16) & 0xff;
 878           startbuf[2] = (start >> 8) & 0xff;
 879           startbuf[3] = start & 0xff;
 880           if (! ihex_write_record (abfd, 4, 0, 5, startbuf))
 881             return false;
 882         }
 883     }
 884
 885   if (! ihex_write_record (abfd, 0, 0, 1, NULL))
 886     return false;
 887
 888   return true;
 889 }
 890
 891 /* Make an empty symbol.  This is required only because
 892    bfd_make_section_anyway wants to create a symbol for the section.  */
 893
 894 static asymbol *
 895 ihex_make_empty_symbol (abfd)
 896      bfd *abfd;
 897 {
 898   asymbol *new;
 899
 900   new = (asymbol *) bfd_zalloc (abfd, sizeof (asymbol));
 901   if (new != NULL)
 902     new->the_bfd = abfd;
 903   return new;
 904 }
 905
 906 /* Set the architecture for the output file.  The architecture is
 907    irrelevant, so we ignore errors about unknown architectures.  */
 908
 909 static boolean
 910 ihex_set_arch_mach (abfd, arch, mach)
 911      bfd *abfd;
 912      enum bfd_architecture arch;
 913      unsigned long mach;
 914 {
 915   if (! bfd_default_set_arch_mach (abfd, arch, mach))
 916     {
 917       if (arch != bfd_arch_unknown)
 918         return false;
 919     }
 920   return true;
 921 }
 922
 923 /* Get the size of the headers, for the linker.  */
 924
 925 /*ARGSUSED*/
 926 static int
 927 ihex_sizeof_headers (abfd, exec)
 928      bfd *abfd;
 929      boolean exec;
 930 {
 931   return 0;
 932 }
 933
 934 /* Some random definitions for the target vector.  */
 935
 936 #define ihex_close_and_cleanup _bfd_generic_close_and_cleanup
 937 #define ihex_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
 938 #define ihex_new_section_hook _bfd_generic_new_section_hook
 939 #define ihex_get_section_contents_in_window \
 940   _bfd_generic_get_section_contents_in_window
 941
 942 #define ihex_get_symtab_upper_bound bfd_0l
 943 #define ihex_get_symtab \
 944   ((long (*) PARAMS ((bfd *, asymbol **))) bfd_0l)
 945 #define ihex_print_symbol _bfd_nosymbols_print_symbol
 946 #define ihex_get_symbol_info _bfd_nosymbols_get_symbol_info
 947 #define ihex_bfd_is_local_label _bfd_nosymbols_bfd_is_local_label
 948 #define ihex_get_lineno _bfd_nosymbols_get_lineno
 949 #define ihex_find_nearest_line _bfd_nosymbols_find_nearest_line
 950 #define ihex_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
 951 #define ihex_read_minisymbols _bfd_nosymbols_read_minisymbols
 952 #define ihex_minisymbol_to_symbol _bfd_nosymbols_minisymbol_to_symbol
 953
 954 #define ihex_get_reloc_upper_bound \
 955   ((long (*) PARAMS ((bfd *, asection *))) bfd_0l)
 956 #define ihex_canonicalize_reloc \
 957   ((long (*) PARAMS ((bfd *, asection *, arelent **, asymbol **))) bfd_0l)
 958 #define ihex_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
 959
 960 #define ihex_bfd_get_relocated_section_contents \
 961   bfd_generic_get_relocated_section_contents
 962 #define ihex_bfd_relax_section bfd_generic_relax_section
 963 #define ihex_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
 964 #define ihex_bfd_link_add_symbols _bfd_generic_link_add_symbols
 965 #define ihex_bfd_final_link _bfd_generic_final_link
 966 #define ihex_bfd_link_split_section _bfd_generic_link_split_section
 967
 968 /* The Intel Hex target vector.  */
 969
 970 const bfd_target ihex_vec =
 971 {
 972   "ihex",                       /* name */
 973   bfd_target_ihex_flavour,
 974   BFD_ENDIAN_UNKNOWN,           /* target byte order */
 975   BFD_ENDIAN_UNKNOWN,           /* target headers byte order */
 976   0,                            /* object flags */
 977   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD),    /* section flags */
 978   0,                            /* leading underscore */
 979   ' ',                          /* ar_pad_char */
 980   16,                           /* ar_max_namelen */
 981   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
 982   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
 983   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* data */
 984   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
 985   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
 986   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* hdrs */
 987
 988   {
 989     _bfd_dummy_target,
 990     ihex_object_p,              /* bfd_check_format */
 991     _bfd_dummy_target,
 992     _bfd_dummy_target,
 993   },
 994   {
 995     bfd_false,
 996     ihex_mkobject,
 997     _bfd_generic_mkarchive,
 998     bfd_false,
 999   },
1000   {                             /* bfd_write_contents */
1001     bfd_false,
1002     ihex_write_object_contents,
1003     _bfd_write_archive_contents,
1004     bfd_false,
1005   },
1006
1007   BFD_JUMP_TABLE_GENERIC (ihex),
1008   BFD_JUMP_TABLE_COPY (_bfd_generic),
1009   BFD_JUMP_TABLE_CORE (_bfd_nocore),
1010   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1011   BFD_JUMP_TABLE_SYMBOLS (ihex),
1012   BFD_JUMP_TABLE_RELOCS (ihex),
1013   BFD_JUMP_TABLE_WRITE (ihex),
1014   BFD_JUMP_TABLE_LINK (ihex),
1015   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1016
1017   (PTR) 0
1018 };