bfd/ihex.c

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