bfd/ihex.c

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