bfd/ihex.c

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