bfd/ihex.c

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