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