contrib/binutils/bfd/ihex.c

   1 /* BFD back-end for Intel Hex objects.
   2    Copyright 1995, 1996, 1997 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 static int ihex_sizeof_headers PARAMS ((bfd *, boolean));
 146
 147 /* The number of bytes we put on one line during output.  */
 148
 149 #define CHUNK (21)
 150
 151 /* Macros for converting between hex and binary. */
 152
 153 #define NIBBLE(x) (hex_value (x))
 154 #define HEX2(buffer) ((NIBBLE ((buffer)[0]) << 4) + NIBBLE ((buffer)[1]))
 155 #define HEX4(buffer) ((HEX2 (buffer) << 8) + HEX2 ((buffer) + 2))
 156 #define ISHEX(x) (hex_p (x))
 157
 158 /* When we write out an ihex value, the values can not be output as
 159    they are seen.  Instead, we hold them in memory in this structure.  */
 160
 161 struct ihex_data_list
 162 {
 163   struct ihex_data_list *next;
 164   bfd_byte *data;
 165   bfd_vma where;
 166   bfd_size_type size;
 167 };
 168
 169 /* The ihex tdata information.  */
 170
 171 struct ihex_data_struct
 172 {
 173   struct ihex_data_list *head;
 174   struct ihex_data_list *tail;
 175 };
 176
 177 /* Initialize by filling in the hex conversion array.  */
 178
 179 static void
 180 ihex_init ()
 181 {
 182   static boolean inited;
 183
 184   if (! inited)
 185     {
 186       inited = true;
 187       hex_init ();
 188     }
 189 }
 190
 191 /* Create an ihex object.  */
 192
 193 static boolean
 194 ihex_mkobject (abfd)
 195      bfd *abfd;
 196 {
 197   if (abfd->tdata.ihex_data == NULL)
 198     {
 199       struct ihex_data_struct *tdata;
 200
 201       tdata = ((struct ihex_data_struct *)
 202                bfd_alloc (abfd, sizeof (struct ihex_data_struct)));
 203       if (tdata == NULL)
 204         return false;
 205       abfd->tdata.ihex_data = tdata;
 206       tdata->head = NULL;
 207       tdata->tail = NULL;
 208     }
 209
 210   return true;
 211 }
 212
 213 /* Read a byte from a BFD.  Set *ERRORPTR if an error occurred.
 214    Return EOF on error or end of file.  */
 215
 216 static INLINE int
 217 ihex_get_byte (abfd, errorptr)
 218      bfd *abfd;
 219      boolean *errorptr;
 220 {
 221   bfd_byte c;
 222
 223   if (bfd_read (&c, 1, 1, abfd) != 1)
 224     {
 225       if (bfd_get_error () != bfd_error_file_truncated)
 226         *errorptr = true;
 227       return EOF;
 228     }
 229
 230   return (int) (c & 0xff);
 231 }
 232
 233 /* Report a problem in an Intel Hex file.  */
 234
 235 static void
 236 ihex_bad_byte (abfd, lineno, c, error)
 237      bfd *abfd;
 238      unsigned int lineno;
 239      int c;
 240      boolean error;
 241 {
 242   if (c == EOF)
 243     {
 244       if (! error)
 245         bfd_set_error (bfd_error_file_truncated);
 246     }
 247   else
 248     {
 249       char buf[10];
 250
 251       if (! isprint (c))
 252         sprintf (buf, "\\%03o", (unsigned int) c);
 253       else
 254         {
 255           buf[0] = c;
 256           buf[1] = '\0';
 257         }
 258       (*_bfd_error_handler)
 259         ("%s:%d: unexpected character `%s' in Intel Hex file\n",
 260          bfd_get_filename (abfd), lineno, buf);
 261       bfd_set_error (bfd_error_bad_value);
 262     }
 263 }
 264
 265 /* Read an Intel hex file and turn it into sections.  We create a new
 266    section for each contiguous set of bytes.  */
 267
 268 static boolean
 269 ihex_scan (abfd)
 270      bfd *abfd;
 271 {
 272   bfd_vma segbase;
 273   asection *sec;
 274   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   sec = NULL;
 287   lineno = 1;
 288   error = false;
 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 = 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_read (hdr, 1, 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_get_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, len * 2);
 616           if (buf == NULL)
 617             goto error_return;
 618           bufsize = len * 2;
 619         }
 620
 621       if (bfd_read (buf, 1, 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_read (buf, 1, 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_get_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
 698   if (count == 0
 699       || (section->flags & SEC_ALLOC) == 0
 700       || (section->flags & SEC_LOAD) == 0)
 701     return true;
 702
 703   n = ((struct ihex_data_list *)
 704        bfd_alloc (abfd, sizeof (struct ihex_data_list)));
 705   if (n == NULL)
 706     return false;
 707
 708   data = (bfd_byte *) bfd_alloc (abfd, count);
 709   if (data == NULL)
 710     return false;
 711   memcpy (data, location, (size_t) count);
 712
 713   n->data = data;
 714   n->where = section->lma + offset;
 715   n->size = count;
 716
 717   /* Sort the records by address.  Optimize for the common case of
 718      adding a record to the end of the list.  */
 719   tdata = abfd->tdata.ihex_data;
 720   if (tdata->tail != NULL
 721       && n->where >= tdata->tail->where)
 722     {
 723       tdata->tail->next = n;
 724       n->next = NULL;
 725       tdata->tail = n;
 726     }
 727   else
 728     {
 729       register struct ihex_data_list **pp;
 730
 731       for (pp = &tdata->head;
 732            *pp != NULL && (*pp)->where < n->where;
 733            pp = &(*pp)->next)
 734         ;
 735       n->next = *pp;
 736       *pp = n;
 737       if (n->next == NULL)
 738         tdata->tail = n;
 739     }
 740
 741   return true;
 742 }
 743
 744 /* Write a record out to an Intel Hex file.  */
 745
 746 static boolean
 747 ihex_write_record (abfd, count, addr, type, data)
 748      bfd *abfd;
 749      bfd_size_type count;
 750      bfd_vma addr;
 751      unsigned int type;
 752      bfd_byte *data;
 753 {
 754   static const char digs[] = "0123456789ABCDEF";
 755   char buf[9 + CHUNK * 2 + 4];
 756   char *p;
 757   unsigned int chksum;
 758   unsigned int i;
 759
 760 #define TOHEX(buf, v) \
 761   ((buf)[0] = digs[((v) >> 4) & 0xf], (buf)[1] = digs[(v) & 0xf])
 762
 763   buf[0] = ':';
 764   TOHEX (buf + 1, count);
 765   TOHEX (buf + 3, (addr >> 8) & 0xff);
 766   TOHEX (buf + 5, addr & 0xff);
 767   TOHEX (buf + 7, type);
 768
 769   chksum = count + addr + (addr >> 8) + type;
 770
 771   for (i = 0, p = buf + 9; i < count; i++, p += 2, data++)
 772     {
 773       TOHEX (p, *data);
 774       chksum += *data;
 775     }
 776
 777   TOHEX (p, (- chksum) & 0xff);
 778   p[2] = '\r';
 779   p[3] = '\n';
 780
 781   if (bfd_write (buf, 1, 9 + count * 2 + 4, abfd) != 9 + count * 2 + 4)
 782     return false;
 783
 784   return true;
 785 }
 786
 787 /* Write out an Intel Hex file.  */
 788
 789 static boolean
 790 ihex_write_object_contents (abfd)
 791      bfd *abfd;
 792 {
 793   bfd_vma segbase;
 794   struct ihex_data_list *l;
 795
 796   segbase = 0;
 797   for (l = abfd->tdata.ihex_data->head; l != NULL; l = l->next)
 798     {
 799       bfd_vma where;
 800       bfd_byte *p;
 801       bfd_size_type count;
 802
 803       where = l->where;
 804       p = l->data;
 805       count = l->size;
 806       while (count > 0)
 807         {
 808           bfd_size_type now;
 809
 810           now = count;
 811           if (now > CHUNK)
 812             now = CHUNK;
 813
 814           if (where > segbase + 0xffff)
 815             {
 816               bfd_byte addr[2];
 817
 818               /* We need a new base address.  */
 819               if (where <= 0xfffff)
 820                 {
 821                   segbase = where & 0xf0000;
 822                   addr[0] = (bfd_byte)(segbase >> 12) & 0xff;
 823                   addr[1] = (bfd_byte)(segbase >> 4) & 0xff;
 824                   if (! ihex_write_record (abfd, 2, 0, 2, addr))
 825                     return false;
 826                 }
 827               else
 828                 {
 829                   segbase = where & 0xffff0000;
 830                   if (where > segbase + 0xffff)
 831                     {
 832                       char buf[20];
 833
 834                       sprintf_vma (buf, where);
 835                       (*_bfd_error_handler)
 836                         ("%s: address 0x%s out of range for Intex Hex file",
 837                          bfd_get_filename (abfd), buf);
 838                       bfd_set_error (bfd_error_bad_value);
 839                       return false;
 840                     }
 841                   addr[0] = (bfd_byte)(segbase >> 24) & 0xff;
 842                   addr[1] = (bfd_byte)(segbase >> 16) & 0xff;
 843                   if (! ihex_write_record (abfd, 2, 0, 4, addr))
 844                     return false;
 845                 }
 846             }
 847
 848           if (! ihex_write_record (abfd, now, where - segbase, 0, p))
 849             return false;
 850
 851           where += now;
 852           p += now;
 853           count -= now;
 854         }
 855     }
 856
 857   if (abfd->start_address != 0)
 858     {
 859       bfd_vma start;
 860       bfd_byte startbuf[4];
 861
 862       start = abfd->start_address;
 863
 864       if (start <= 0xfffff)
 865         {
 866           startbuf[0] = (bfd_byte)((start & 0xf0000) >> 12) & 0xff;
 867           startbuf[1] = 0;
 868           startbuf[2] = (bfd_byte)(start >> 8) & 0xff;
 869           startbuf[3] = (bfd_byte)start & 0xff;
 870           if (! ihex_write_record (abfd, 4, 0, 3, startbuf))
 871             return false;
 872         }
 873       else
 874         {
 875           startbuf[0] = (bfd_byte)(start >> 24) & 0xff;
 876           startbuf[1] = (bfd_byte)(start >> 16) & 0xff;
 877           startbuf[2] = (bfd_byte)(start >> 8) & 0xff;
 878           startbuf[3] = (bfd_byte)start & 0xff;
 879           if (! ihex_write_record (abfd, 4, 0, 5, startbuf))
 880             return false;
 881         }
 882     }
 883
 884   if (! ihex_write_record (abfd, 0, 0, 1, NULL))
 885     return false;
 886
 887   return true;
 888 }
 889
 890 /* Make an empty symbol.  This is required only because
 891    bfd_make_section_anyway wants to create a symbol for the section.  */
 892
 893 static asymbol *
 894 ihex_make_empty_symbol (abfd)
 895      bfd *abfd;
 896 {
 897   asymbol *new;
 898
 899   new = (asymbol *) bfd_zalloc (abfd, sizeof (asymbol));
 900   if (new != NULL)
 901     new->the_bfd = abfd;
 902   return new;
 903 }
 904
 905 /* Set the architecture for the output file.  The architecture is
 906    irrelevant, so we ignore errors about unknown architectures.  */
 907
 908 static boolean
 909 ihex_set_arch_mach (abfd, arch, mach)
 910      bfd *abfd;
 911      enum bfd_architecture arch;
 912      unsigned long mach;
 913 {
 914   if (! bfd_default_set_arch_mach (abfd, arch, mach))
 915     {
 916       if (arch != bfd_arch_unknown)
 917         return false;
 918     }
 919   return true;
 920 }
 921
 922 /* Get the size of the headers, for the linker.  */
 923
 924 /*ARGSUSED*/
 925 static int
 926 ihex_sizeof_headers (abfd, exec)
 927      bfd *abfd;
 928      boolean exec;
 929 {
 930   return 0;
 931 }
 932
 933 /* Some random definitions for the target vector.  */
 934
 935 #define ihex_close_and_cleanup _bfd_generic_close_and_cleanup
 936 #define ihex_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
 937 #define ihex_new_section_hook _bfd_generic_new_section_hook
 938 #define ihex_get_section_contents_in_window \
 939   _bfd_generic_get_section_contents_in_window
 940
 941 #define ihex_get_symtab_upper_bound bfd_0l
 942 #define ihex_get_symtab \
 943   ((long (*) PARAMS ((bfd *, asymbol **))) bfd_0l)
 944 #define ihex_print_symbol _bfd_nosymbols_print_symbol
 945 #define ihex_get_symbol_info _bfd_nosymbols_get_symbol_info
 946 #define ihex_bfd_is_local_label_name _bfd_nosymbols_bfd_is_local_label_name
 947 #define ihex_get_lineno _bfd_nosymbols_get_lineno
 948 #define ihex_find_nearest_line _bfd_nosymbols_find_nearest_line
 949 #define ihex_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
 950 #define ihex_read_minisymbols _bfd_nosymbols_read_minisymbols
 951 #define ihex_minisymbol_to_symbol _bfd_nosymbols_minisymbol_to_symbol
 952
 953 #define ihex_get_reloc_upper_bound \
 954   ((long (*) PARAMS ((bfd *, asection *))) bfd_0l)
 955 #define ihex_canonicalize_reloc \
 956   ((long (*) PARAMS ((bfd *, asection *, arelent **, asymbol **))) bfd_0l)
 957 #define ihex_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
 958
 959 #define ihex_bfd_get_relocated_section_contents \
 960   bfd_generic_get_relocated_section_contents
 961 #define ihex_bfd_relax_section bfd_generic_relax_section
 962 #define ihex_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
 963 #define ihex_bfd_link_add_symbols _bfd_generic_link_add_symbols
 964 #define ihex_bfd_final_link _bfd_generic_final_link
 965 #define ihex_bfd_link_split_section _bfd_generic_link_split_section
 966
 967 /* The Intel Hex target vector.  */
 968
 969 const bfd_target ihex_vec =
 970 {
 971   "ihex",                       /* name */
 972   bfd_target_ihex_flavour,
 973   BFD_ENDIAN_UNKNOWN,           /* target byte order */
 974   BFD_ENDIAN_UNKNOWN,           /* target headers byte order */
 975   0,                            /* object flags */
 976   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD),    /* section flags */
 977   0,                            /* leading underscore */
 978   ' ',                          /* ar_pad_char */
 979   16,                           /* ar_max_namelen */
 980   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
 981   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
 982   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* data */
 983   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
 984   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
 985   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* hdrs */
 986
 987   {
 988     _bfd_dummy_target,
 989     ihex_object_p,              /* bfd_check_format */
 990     _bfd_dummy_target,
 991     _bfd_dummy_target,
 992   },
 993   {
 994     bfd_false,
 995     ihex_mkobject,
 996     _bfd_generic_mkarchive,
 997     bfd_false,
 998   },
 999   {                             /* bfd_write_contents */
1000     bfd_false,
1001     ihex_write_object_contents,
1002     _bfd_write_archive_contents,
1003     bfd_false,
1004   },
1005
1006   BFD_JUMP_TABLE_GENERIC (ihex),
1007   BFD_JUMP_TABLE_COPY (_bfd_generic),
1008   BFD_JUMP_TABLE_CORE (_bfd_nocore),
1009   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1010   BFD_JUMP_TABLE_SYMBOLS (ihex),
1011   BFD_JUMP_TABLE_RELOCS (ihex),
1012   BFD_JUMP_TABLE_WRITE (ihex),
1013   BFD_JUMP_TABLE_LINK (ihex),
1014   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1015
1016   (PTR) 0
1017 };