contrib/gdb-6/bfd/ihex.c

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