bfd/ihex.c

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