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