ieee.c revision 78828
1/* BFD back-end for ieee-695 objects. 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 3 2000, 2001 4 Free Software Foundation, Inc. 5 6 Written by Steve Chamberlain of Cygnus Support. 7 8This file is part of BFD, the Binary File Descriptor library. 9 10This program is free software; you can redistribute it and/or modify 11it under the terms of the GNU General Public License as published by 12the Free Software Foundation; either version 2 of the License, or 13(at your option) any later version. 14 15This program is distributed in the hope that it will be useful, 16but WITHOUT ANY WARRANTY; without even the implied warranty of 17MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18GNU General Public License for more details. 19 20You should have received a copy of the GNU General Public License 21along with this program; if not, write to the Free Software 22Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 23 24#define KEEPMINUSPCININST 0 25 26/* IEEE 695 format is a stream of records, which we parse using a simple one- 27 token (which is one byte in this lexicon) lookahead recursive decent 28 parser. */ 29 30#include "bfd.h" 31#include "sysdep.h" 32#include "libbfd.h" 33#include "ieee.h" 34#include "libieee.h" 35 36#include <ctype.h> 37 38static boolean ieee_write_byte PARAMS ((bfd *, int)); 39static boolean ieee_write_2bytes PARAMS ((bfd *, int)); 40static boolean ieee_write_int PARAMS ((bfd *, bfd_vma)); 41static boolean ieee_write_id PARAMS ((bfd *, const char *)); 42static boolean ieee_write_expression 43 PARAMS ((bfd *, bfd_vma, asymbol *, boolean, unsigned int)); 44static void ieee_write_int5 PARAMS ((bfd_byte *, bfd_vma)); 45static boolean ieee_write_int5_out PARAMS ((bfd *, bfd_vma)); 46static boolean ieee_write_section_part PARAMS ((bfd *)); 47static boolean do_with_relocs PARAMS ((bfd *, asection *)); 48static boolean do_as_repeat PARAMS ((bfd *, asection *)); 49static boolean do_without_relocs PARAMS ((bfd *, asection *)); 50static boolean ieee_write_external_part PARAMS ((bfd *)); 51static boolean ieee_write_data_part PARAMS ((bfd *)); 52static boolean ieee_write_debug_part PARAMS ((bfd *)); 53static boolean ieee_write_me_part PARAMS ((bfd *)); 54static boolean ieee_write_processor PARAMS ((bfd *)); 55 56static boolean ieee_slurp_debug PARAMS ((bfd *)); 57static boolean ieee_slurp_section_data PARAMS ((bfd *)); 58 59/* Functions for writing to ieee files in the strange way that the 60 standard requires. */ 61 62static boolean 63ieee_write_byte (abfd, barg) 64 bfd *abfd; 65 int barg; 66{ 67 bfd_byte byte; 68 69 byte = barg; 70 if (bfd_write ((PTR) &byte, 1, 1, abfd) != 1) 71 return false; 72 return true; 73} 74 75static boolean 76ieee_write_2bytes (abfd, bytes) 77 bfd *abfd; 78 int bytes; 79{ 80 bfd_byte buffer[2]; 81 82 buffer[0] = bytes >> 8; 83 buffer[1] = bytes & 0xff; 84 if (bfd_write ((PTR) buffer, 1, 2, abfd) != 2) 85 return false; 86 return true; 87} 88 89static boolean 90ieee_write_int (abfd, value) 91 bfd *abfd; 92 bfd_vma value; 93{ 94 if (value <= 127) 95 { 96 if (! ieee_write_byte (abfd, (bfd_byte) value)) 97 return false; 98 } 99 else 100 { 101 unsigned int length; 102 103 /* How many significant bytes ? */ 104 /* FIXME FOR LONGER INTS */ 105 if (value & 0xff000000) 106 length = 4; 107 else if (value & 0x00ff0000) 108 length = 3; 109 else if (value & 0x0000ff00) 110 length = 2; 111 else 112 length = 1; 113 114 if (! ieee_write_byte (abfd, 115 (bfd_byte) ((int) ieee_number_repeat_start_enum 116 + length))) 117 return false; 118 switch (length) 119 { 120 case 4: 121 if (! ieee_write_byte (abfd, (bfd_byte) (value >> 24))) 122 return false; 123 /* Fall through. */ 124 case 3: 125 if (! ieee_write_byte (abfd, (bfd_byte) (value >> 16))) 126 return false; 127 /* Fall through. */ 128 case 2: 129 if (! ieee_write_byte (abfd, (bfd_byte) (value >> 8))) 130 return false; 131 /* Fall through. */ 132 case 1: 133 if (! ieee_write_byte (abfd, (bfd_byte) (value))) 134 return false; 135 } 136 } 137 138 return true; 139} 140 141static boolean 142ieee_write_id (abfd, id) 143 bfd *abfd; 144 const char *id; 145{ 146 size_t length = strlen (id); 147 148 if (length <= 127) 149 { 150 if (! ieee_write_byte (abfd, (bfd_byte) length)) 151 return false; 152 } 153 else if (length < 255) 154 { 155 if (! ieee_write_byte (abfd, ieee_extension_length_1_enum) 156 || ! ieee_write_byte (abfd, (bfd_byte) length)) 157 return false; 158 } 159 else if (length < 65535) 160 { 161 if (! ieee_write_byte (abfd, ieee_extension_length_2_enum) 162 || ! ieee_write_2bytes (abfd, (int) length)) 163 return false; 164 } 165 else 166 { 167 (*_bfd_error_handler) 168 (_("%s: string too long (%d chars, max 65535)"), 169 bfd_get_filename (abfd), length); 170 bfd_set_error (bfd_error_invalid_operation); 171 return false; 172 } 173 174 if (bfd_write ((PTR) id, 1, length, abfd) != length) 175 return false; 176 return true; 177} 178 179/*************************************************************************** 180Functions for reading from ieee files in the strange way that the 181standard requires: 182*/ 183 184#define this_byte(ieee) *((ieee)->input_p) 185#define next_byte(ieee) ((ieee)->input_p++) 186#define this_byte_and_next(ieee) (*((ieee)->input_p++)) 187 188static unsigned short 189read_2bytes (ieee) 190 common_header_type *ieee; 191{ 192 unsigned char c1 = this_byte_and_next (ieee); 193 unsigned char c2 = this_byte_and_next (ieee); 194 return (c1 << 8) | c2; 195} 196 197static void 198bfd_get_string (ieee, string, length) 199 common_header_type *ieee; 200 char *string; 201 size_t length; 202{ 203 size_t i; 204 for (i = 0; i < length; i++) 205 { 206 string[i] = this_byte_and_next (ieee); 207 } 208} 209 210static char * 211read_id (ieee) 212 common_header_type *ieee; 213{ 214 size_t length; 215 char *string; 216 length = this_byte_and_next (ieee); 217 if (length <= 0x7f) 218 { 219 /* Simple string of length 0 to 127 */ 220 } 221 else if (length == 0xde) 222 { 223 /* Length is next byte, allowing 0..255 */ 224 length = this_byte_and_next (ieee); 225 } 226 else if (length == 0xdf) 227 { 228 /* Length is next two bytes, allowing 0..65535 */ 229 length = this_byte_and_next (ieee); 230 length = (length * 256) + this_byte_and_next (ieee); 231 } 232 /* Buy memory and read string */ 233 string = bfd_alloc (ieee->abfd, length + 1); 234 if (!string) 235 return NULL; 236 bfd_get_string (ieee, string, length); 237 string[length] = 0; 238 return string; 239} 240 241static boolean 242ieee_write_expression (abfd, value, symbol, pcrel, index) 243 bfd *abfd; 244 bfd_vma value; 245 asymbol *symbol; 246 boolean pcrel; 247 unsigned int index; 248{ 249 unsigned int term_count = 0; 250 251 if (value != 0) 252 { 253 if (! ieee_write_int (abfd, value)) 254 return false; 255 term_count++; 256 } 257 258 if (bfd_is_com_section (symbol->section) 259 || bfd_is_und_section (symbol->section)) 260 { 261 /* Def of a common symbol */ 262 if (! ieee_write_byte (abfd, ieee_variable_X_enum) 263 || ! ieee_write_int (abfd, symbol->value)) 264 return false; 265 term_count++; 266 } 267 else if (! bfd_is_abs_section (symbol->section)) 268 { 269 /* Ref to defined symbol - */ 270 271 if (symbol->flags & BSF_GLOBAL) 272 { 273 if (! ieee_write_byte (abfd, ieee_variable_I_enum) 274 || ! ieee_write_int (abfd, symbol->value)) 275 return false; 276 term_count++; 277 } 278 else if (symbol->flags & (BSF_LOCAL | BSF_SECTION_SYM)) 279 { 280 /* This is a reference to a defined local symbol. We can 281 easily do a local as a section+offset. */ 282 if (! ieee_write_byte (abfd, ieee_variable_R_enum) 283 || ! ieee_write_byte (abfd, 284 (bfd_byte) (symbol->section->index 285 + IEEE_SECTION_NUMBER_BASE))) 286 return false; 287 term_count++; 288 if (symbol->value != 0) 289 { 290 if (! ieee_write_int (abfd, symbol->value)) 291 return false; 292 term_count++; 293 } 294 } 295 else 296 { 297 (*_bfd_error_handler) 298 (_("%s: unrecognized symbol `%s' flags 0x%x"), 299 bfd_get_filename (abfd), bfd_asymbol_name (symbol), 300 symbol->flags); 301 bfd_set_error (bfd_error_invalid_operation); 302 return false; 303 } 304 } 305 306 if (pcrel) 307 { 308 /* subtract the pc from here by asking for PC of this section*/ 309 if (! ieee_write_byte (abfd, ieee_variable_P_enum) 310 || ! ieee_write_byte (abfd, 311 (bfd_byte) (index + IEEE_SECTION_NUMBER_BASE)) 312 || ! ieee_write_byte (abfd, ieee_function_minus_enum)) 313 return false; 314 } 315 316 /* Handle the degenerate case of a 0 address. */ 317 if (term_count == 0) 318 { 319 if (! ieee_write_int (abfd, 0)) 320 return false; 321 } 322 323 while (term_count > 1) 324 { 325 if (! ieee_write_byte (abfd, ieee_function_plus_enum)) 326 return false; 327 term_count--; 328 } 329 330 return true; 331} 332 333/*****************************************************************************/ 334 335/* 336writes any integer into the buffer supplied and always takes 5 bytes 337*/ 338static void 339ieee_write_int5 (buffer, value) 340 bfd_byte *buffer; 341 bfd_vma value; 342{ 343 buffer[0] = (bfd_byte) ieee_number_repeat_4_enum; 344 buffer[1] = (value >> 24) & 0xff; 345 buffer[2] = (value >> 16) & 0xff; 346 buffer[3] = (value >> 8) & 0xff; 347 buffer[4] = (value >> 0) & 0xff; 348} 349 350static boolean 351ieee_write_int5_out (abfd, value) 352 bfd *abfd; 353 bfd_vma value; 354{ 355 bfd_byte b[5]; 356 357 ieee_write_int5 (b, value); 358 if (bfd_write ((PTR) b, 1, 5, abfd) != 5) 359 return false; 360 return true; 361} 362 363static boolean 364parse_int (ieee, value_ptr) 365 common_header_type *ieee; 366 bfd_vma *value_ptr; 367{ 368 int value = this_byte (ieee); 369 int result; 370 if (value >= 0 && value <= 127) 371 { 372 *value_ptr = value; 373 next_byte (ieee); 374 return true; 375 } 376 else if (value >= 0x80 && value <= 0x88) 377 { 378 unsigned int count = value & 0xf; 379 result = 0; 380 next_byte (ieee); 381 while (count) 382 { 383 result = (result << 8) | this_byte_and_next (ieee); 384 count--; 385 } 386 *value_ptr = result; 387 return true; 388 } 389 return false; 390} 391 392static int 393parse_i (ieee, ok) 394 common_header_type *ieee; 395 boolean *ok; 396{ 397 bfd_vma x; 398 *ok = parse_int (ieee, &x); 399 return x; 400} 401 402static bfd_vma 403must_parse_int (ieee) 404 common_header_type *ieee; 405{ 406 bfd_vma result; 407 BFD_ASSERT (parse_int (ieee, &result) == true); 408 return result; 409} 410 411typedef struct 412{ 413 bfd_vma value; 414 asection *section; 415 ieee_symbol_index_type symbol; 416} ieee_value_type; 417 418 419#if KEEPMINUSPCININST 420 421#define SRC_MASK(arg) arg 422#define PCREL_OFFSET false 423 424#else 425 426#define SRC_MASK(arg) 0 427#define PCREL_OFFSET true 428 429#endif 430 431static reloc_howto_type abs32_howto = 432 HOWTO (1, 433 0, 434 2, 435 32, 436 false, 437 0, 438 complain_overflow_bitfield, 439 0, 440 "abs32", 441 true, 442 0xffffffff, 443 0xffffffff, 444 false); 445 446static reloc_howto_type abs16_howto = 447 HOWTO (1, 448 0, 449 1, 450 16, 451 false, 452 0, 453 complain_overflow_bitfield, 454 0, 455 "abs16", 456 true, 457 0x0000ffff, 458 0x0000ffff, 459 false); 460 461static reloc_howto_type abs8_howto = 462 HOWTO (1, 463 0, 464 0, 465 8, 466 false, 467 0, 468 complain_overflow_bitfield, 469 0, 470 "abs8", 471 true, 472 0x000000ff, 473 0x000000ff, 474 false); 475 476static reloc_howto_type rel32_howto = 477 HOWTO (1, 478 0, 479 2, 480 32, 481 true, 482 0, 483 complain_overflow_signed, 484 0, 485 "rel32", 486 true, 487 SRC_MASK (0xffffffff), 488 0xffffffff, 489 PCREL_OFFSET); 490 491static reloc_howto_type rel16_howto = 492 HOWTO (1, 493 0, 494 1, 495 16, 496 true, 497 0, 498 complain_overflow_signed, 499 0, 500 "rel16", 501 true, 502 SRC_MASK (0x0000ffff), 503 0x0000ffff, 504 PCREL_OFFSET); 505 506static reloc_howto_type rel8_howto = 507 HOWTO (1, 508 0, 509 0, 510 8, 511 true, 512 0, 513 complain_overflow_signed, 514 0, 515 "rel8", 516 true, 517 SRC_MASK (0x000000ff), 518 0x000000ff, 519 PCREL_OFFSET); 520 521static ieee_symbol_index_type NOSYMBOL = {0, 0}; 522 523static void 524parse_expression (ieee, value, symbol, pcrel, extra, section) 525 ieee_data_type *ieee; 526 bfd_vma *value; 527 ieee_symbol_index_type *symbol; 528 boolean *pcrel; 529 unsigned int *extra; 530 asection **section; 531 532{ 533#define POS sp[1] 534#define TOS sp[0] 535#define NOS sp[-1] 536#define INC sp++; 537#define DEC sp--; 538 539 boolean loop = true; 540 ieee_value_type stack[10]; 541 542 /* The stack pointer always points to the next unused location */ 543#define PUSH(x,y,z) TOS.symbol=x;TOS.section=y;TOS.value=z;INC; 544#define POP(x,y,z) DEC;x=TOS.symbol;y=TOS.section;z=TOS.value; 545 ieee_value_type *sp = stack; 546 547 while (loop) 548 { 549 switch (this_byte (&(ieee->h))) 550 { 551 case ieee_variable_P_enum: 552 /* P variable, current program counter for section n */ 553 { 554 int section_n; 555 next_byte (&(ieee->h)); 556 *pcrel = true; 557 section_n = must_parse_int (&(ieee->h)); 558 PUSH (NOSYMBOL, bfd_abs_section_ptr, 0); 559 break; 560 } 561 case ieee_variable_L_enum: 562 /* L variable address of section N */ 563 next_byte (&(ieee->h)); 564 PUSH (NOSYMBOL, ieee->section_table[must_parse_int (&(ieee->h))], 0); 565 break; 566 case ieee_variable_R_enum: 567 /* R variable, logical address of section module */ 568 /* FIXME, this should be different to L */ 569 next_byte (&(ieee->h)); 570 PUSH (NOSYMBOL, ieee->section_table[must_parse_int (&(ieee->h))], 0); 571 break; 572 case ieee_variable_S_enum: 573 /* S variable, size in MAUS of section module */ 574 next_byte (&(ieee->h)); 575 PUSH (NOSYMBOL, 576 0, 577 ieee->section_table[must_parse_int (&(ieee->h))]->_raw_size); 578 break; 579 case ieee_variable_I_enum: 580 /* Push the address of variable n */ 581 { 582 ieee_symbol_index_type sy; 583 next_byte (&(ieee->h)); 584 sy.index = (int) must_parse_int (&(ieee->h)); 585 sy.letter = 'I'; 586 587 PUSH (sy, bfd_abs_section_ptr, 0); 588 } 589 break; 590 case ieee_variable_X_enum: 591 /* Push the address of external variable n */ 592 { 593 ieee_symbol_index_type sy; 594 next_byte (&(ieee->h)); 595 sy.index = (int) (must_parse_int (&(ieee->h))); 596 sy.letter = 'X'; 597 598 PUSH (sy, bfd_und_section_ptr, 0); 599 } 600 break; 601 case ieee_function_minus_enum: 602 { 603 bfd_vma value1, value2; 604 asection *section1, *section_dummy; 605 ieee_symbol_index_type sy; 606 next_byte (&(ieee->h)); 607 608 POP (sy, section1, value1); 609 POP (sy, section_dummy, value2); 610 PUSH (sy, section1 ? section1 : section_dummy, value2 - value1); 611 } 612 break; 613 case ieee_function_plus_enum: 614 { 615 bfd_vma value1, value2; 616 asection *section1; 617 asection *section2; 618 ieee_symbol_index_type sy1; 619 ieee_symbol_index_type sy2; 620 next_byte (&(ieee->h)); 621 622 POP (sy1, section1, value1); 623 POP (sy2, section2, value2); 624 PUSH (sy1.letter ? sy1 : sy2, 625 bfd_is_abs_section (section1) ? section2 : section1, 626 value1 + value2); 627 } 628 break; 629 default: 630 { 631 bfd_vma va; 632 BFD_ASSERT (this_byte (&(ieee->h)) < (int) ieee_variable_A_enum 633 || this_byte (&(ieee->h)) > (int) ieee_variable_Z_enum); 634 if (parse_int (&(ieee->h), &va)) 635 { 636 PUSH (NOSYMBOL, bfd_abs_section_ptr, va); 637 } 638 else 639 { 640 /* 641 Thats all that we can understand. As far as I can see 642 there is a bug in the Microtec IEEE output which I'm 643 using to scan, whereby the comma operator is omitted 644 sometimes in an expression, giving expressions with too 645 many terms. We can tell if that's the case by ensuring 646 that sp == stack here. If not, then we've pushed 647 something too far, so we keep adding. */ 648 649 while (sp != stack + 1) 650 { 651 asection *section1; 652 ieee_symbol_index_type sy1; 653 POP (sy1, section1, *extra); 654 } 655 { 656 asection *dummy; 657 658 POP (*symbol, dummy, *value); 659 if (section) 660 *section = dummy; 661 } 662 663 loop = false; 664 } 665 } 666 } 667 } 668} 669 670 671#define ieee_seek(abfd, offset) \ 672 IEEE_DATA(abfd)->h.input_p = IEEE_DATA(abfd)->h.first_byte + offset 673 674#define ieee_pos(abfd) \ 675 (IEEE_DATA(abfd)->h.input_p - IEEE_DATA(abfd)->h.first_byte) 676 677static unsigned int last_index; 678static char last_type; /* is the index for an X or a D */ 679 680static ieee_symbol_type * 681get_symbol (abfd, 682 ieee, 683 last_symbol, 684 symbol_count, 685 pptr, 686 max_index, 687 this_type 688) 689 bfd *abfd ATTRIBUTE_UNUSED; 690 ieee_data_type *ieee; 691 ieee_symbol_type *last_symbol; 692 unsigned int *symbol_count; 693 ieee_symbol_type ***pptr; 694 unsigned int *max_index; 695 char this_type 696 ; 697{ 698 /* Need a new symbol */ 699 unsigned int new_index = must_parse_int (&(ieee->h)); 700 if (new_index != last_index || this_type != last_type) 701 { 702 ieee_symbol_type *new_symbol = (ieee_symbol_type *) bfd_alloc (ieee->h.abfd, 703 sizeof (ieee_symbol_type)); 704 if (!new_symbol) 705 return NULL; 706 707 new_symbol->index = new_index; 708 last_index = new_index; 709 (*symbol_count)++; 710 **pptr = new_symbol; 711 *pptr = &new_symbol->next; 712 if (new_index > *max_index) 713 { 714 *max_index = new_index; 715 } 716 last_type = this_type; 717 new_symbol->symbol.section = bfd_abs_section_ptr; 718 return new_symbol; 719 } 720 return last_symbol; 721} 722 723static boolean 724ieee_slurp_external_symbols (abfd) 725 bfd *abfd; 726{ 727 ieee_data_type *ieee = IEEE_DATA (abfd); 728 file_ptr offset = ieee->w.r.external_part; 729 730 ieee_symbol_type **prev_symbols_ptr = &ieee->external_symbols; 731 ieee_symbol_type **prev_reference_ptr = &ieee->external_reference; 732 ieee_symbol_type *symbol = (ieee_symbol_type *) NULL; 733 unsigned int symbol_count = 0; 734 boolean loop = true; 735 last_index = 0xffffff; 736 ieee->symbol_table_full = true; 737 738 ieee_seek (abfd, offset); 739 740 while (loop) 741 { 742 switch (this_byte (&(ieee->h))) 743 { 744 case ieee_nn_record: 745 next_byte (&(ieee->h)); 746 747 symbol = get_symbol (abfd, ieee, symbol, &symbol_count, 748 &prev_symbols_ptr, 749 &ieee->external_symbol_max_index, 'I'); 750 if (symbol == NULL) 751 return false; 752 753 symbol->symbol.the_bfd = abfd; 754 symbol->symbol.name = read_id (&(ieee->h)); 755 symbol->symbol.udata.p = (PTR) NULL; 756 symbol->symbol.flags = BSF_NO_FLAGS; 757 break; 758 case ieee_external_symbol_enum: 759 next_byte (&(ieee->h)); 760 761 symbol = get_symbol (abfd, ieee, symbol, &symbol_count, 762 &prev_symbols_ptr, 763 &ieee->external_symbol_max_index, 'D'); 764 if (symbol == NULL) 765 return false; 766 767 BFD_ASSERT (symbol->index >= ieee->external_symbol_min_index); 768 769 symbol->symbol.the_bfd = abfd; 770 symbol->symbol.name = read_id (&(ieee->h)); 771 symbol->symbol.udata.p = (PTR) NULL; 772 symbol->symbol.flags = BSF_NO_FLAGS; 773 break; 774 case ieee_attribute_record_enum >> 8: 775 { 776 unsigned int symbol_name_index; 777 unsigned int symbol_type_index; 778 unsigned int symbol_attribute_def; 779 bfd_vma value; 780 switch (read_2bytes (ieee)) 781 { 782 case ieee_attribute_record_enum: 783 symbol_name_index = must_parse_int (&(ieee->h)); 784 symbol_type_index = must_parse_int (&(ieee->h)); 785 symbol_attribute_def = must_parse_int (&(ieee->h)); 786 switch (symbol_attribute_def) 787 { 788 case 8: 789 case 19: 790 parse_int (&ieee->h, &value); 791 break; 792 default: 793 (*_bfd_error_handler) 794 (_("%s: unimplemented ATI record %u for symbol %u"), 795 bfd_get_filename (abfd), symbol_attribute_def, 796 symbol_name_index); 797 bfd_set_error (bfd_error_bad_value); 798 return false; 799 break; 800 } 801 break; 802 case ieee_external_reference_info_record_enum: 803 /* Skip over ATX record. */ 804 parse_int (&(ieee->h), &value); 805 parse_int (&(ieee->h), &value); 806 parse_int (&(ieee->h), &value); 807 parse_int (&(ieee->h), &value); 808 break; 809 case ieee_atn_record_enum: 810 /* We may get call optimization information here, 811 which we just ignore. The format is 812 {$F1}${CE}{index}{$00}{$3F}{$3F}{#_of_ASNs} */ 813 parse_int (&ieee->h, &value); 814 parse_int (&ieee->h, &value); 815 parse_int (&ieee->h, &value); 816 if (value != 0x3f) 817 { 818 (*_bfd_error_handler) 819 (_("%s: unexpected ATN type %d in external part"), 820 bfd_get_filename (abfd), (int) value); 821 bfd_set_error (bfd_error_bad_value); 822 return false; 823 } 824 parse_int (&ieee->h, &value); 825 parse_int (&ieee->h, &value); 826 while (value > 0) 827 { 828 bfd_vma val1; 829 830 --value; 831 832 switch (read_2bytes (ieee)) 833 { 834 case ieee_asn_record_enum: 835 parse_int (&ieee->h, &val1); 836 parse_int (&ieee->h, &val1); 837 break; 838 839 default: 840 (*_bfd_error_handler) 841 (_("%s: unexpected type after ATN"), 842 bfd_get_filename (abfd)); 843 bfd_set_error (bfd_error_bad_value); 844 return false; 845 } 846 } 847 } 848 } 849 break; 850 case ieee_value_record_enum >> 8: 851 { 852 unsigned int symbol_name_index; 853 ieee_symbol_index_type symbol_ignore; 854 boolean pcrel_ignore; 855 unsigned int extra; 856 next_byte (&(ieee->h)); 857 next_byte (&(ieee->h)); 858 859 symbol_name_index = must_parse_int (&(ieee->h)); 860 parse_expression (ieee, 861 &symbol->symbol.value, 862 &symbol_ignore, 863 &pcrel_ignore, 864 &extra, 865 &symbol->symbol.section); 866 867 /* Fully linked IEEE-695 files tend to give every symbol 868 an absolute value. Try to convert that back into a 869 section relative value. FIXME: This won't always to 870 the right thing. */ 871 if (bfd_is_abs_section (symbol->symbol.section) 872 && (abfd->flags & HAS_RELOC) == 0) 873 { 874 bfd_vma val; 875 asection *s; 876 877 val = symbol->symbol.value; 878 for (s = abfd->sections; s != NULL; s = s->next) 879 { 880 if (val >= s->vma && val < s->vma + s->_raw_size) 881 { 882 symbol->symbol.section = s; 883 symbol->symbol.value -= s->vma; 884 break; 885 } 886 } 887 } 888 889 symbol->symbol.flags = BSF_GLOBAL | BSF_EXPORT; 890 891 } 892 break; 893 case ieee_weak_external_reference_enum: 894 { 895 bfd_vma size; 896 bfd_vma value; 897 next_byte (&(ieee->h)); 898 /* Throw away the external reference index */ 899 (void) must_parse_int (&(ieee->h)); 900 /* Fetch the default size if not resolved */ 901 size = must_parse_int (&(ieee->h)); 902 /* Fetch the defautlt value if available */ 903 if (parse_int (&(ieee->h), &value) == false) 904 { 905 value = 0; 906 } 907 /* This turns into a common */ 908 symbol->symbol.section = bfd_com_section_ptr; 909 symbol->symbol.value = size; 910 } 911 break; 912 913 case ieee_external_reference_enum: 914 next_byte (&(ieee->h)); 915 916 symbol = get_symbol (abfd, ieee, symbol, &symbol_count, 917 &prev_reference_ptr, 918 &ieee->external_reference_max_index, 'X'); 919 if (symbol == NULL) 920 return false; 921 922 symbol->symbol.the_bfd = abfd; 923 symbol->symbol.name = read_id (&(ieee->h)); 924 symbol->symbol.udata.p = (PTR) NULL; 925 symbol->symbol.section = bfd_und_section_ptr; 926 symbol->symbol.value = (bfd_vma) 0; 927 symbol->symbol.flags = 0; 928 929 BFD_ASSERT (symbol->index >= ieee->external_reference_min_index); 930 break; 931 932 default: 933 loop = false; 934 } 935 } 936 937 if (ieee->external_symbol_max_index != 0) 938 { 939 ieee->external_symbol_count = 940 ieee->external_symbol_max_index - 941 ieee->external_symbol_min_index + 1; 942 } 943 else 944 { 945 ieee->external_symbol_count = 0; 946 } 947 948 if (ieee->external_reference_max_index != 0) 949 { 950 ieee->external_reference_count = 951 ieee->external_reference_max_index - 952 ieee->external_reference_min_index + 1; 953 } 954 else 955 { 956 ieee->external_reference_count = 0; 957 } 958 959 abfd->symcount = 960 ieee->external_reference_count + ieee->external_symbol_count; 961 962 if (symbol_count != abfd->symcount) 963 { 964 /* There are gaps in the table -- */ 965 ieee->symbol_table_full = false; 966 } 967 968 *prev_symbols_ptr = (ieee_symbol_type *) NULL; 969 *prev_reference_ptr = (ieee_symbol_type *) NULL; 970 971 return true; 972} 973 974static boolean 975ieee_slurp_symbol_table (abfd) 976 bfd *abfd; 977{ 978 if (IEEE_DATA (abfd)->read_symbols == false) 979 { 980 if (! ieee_slurp_external_symbols (abfd)) 981 return false; 982 IEEE_DATA (abfd)->read_symbols = true; 983 } 984 return true; 985} 986 987long 988ieee_get_symtab_upper_bound (abfd) 989 bfd *abfd; 990{ 991 if (! ieee_slurp_symbol_table (abfd)) 992 return -1; 993 994 return (abfd->symcount != 0) ? 995 (abfd->symcount + 1) * (sizeof (ieee_symbol_type *)) : 0; 996} 997 998/* 999Move from our internal lists to the canon table, and insert in 1000symbol index order 1001*/ 1002 1003extern const bfd_target ieee_vec; 1004 1005long 1006ieee_get_symtab (abfd, location) 1007 bfd *abfd; 1008 asymbol **location; 1009{ 1010 ieee_symbol_type *symp; 1011 static bfd dummy_bfd; 1012 static asymbol empty_symbol = 1013 { 1014 &dummy_bfd, 1015 " ieee empty", 1016 (symvalue) 0, 1017 BSF_DEBUGGING, 1018 bfd_abs_section_ptr 1019#ifdef __STDC__ 1020 /* K&R compilers can't initialise unions. */ 1021 , { 0 } 1022#endif 1023 }; 1024 1025 if (abfd->symcount) 1026 { 1027 ieee_data_type *ieee = IEEE_DATA (abfd); 1028 dummy_bfd.xvec = &ieee_vec; 1029 if (! ieee_slurp_symbol_table (abfd)) 1030 return -1; 1031 1032 if (ieee->symbol_table_full == false) 1033 { 1034 /* Arrgh - there are gaps in the table, run through and fill them */ 1035 /* up with pointers to a null place */ 1036 unsigned int i; 1037 for (i = 0; i < abfd->symcount; i++) 1038 { 1039 location[i] = &empty_symbol; 1040 } 1041 } 1042 1043 ieee->external_symbol_base_offset = -ieee->external_symbol_min_index; 1044 for (symp = IEEE_DATA (abfd)->external_symbols; 1045 symp != (ieee_symbol_type *) NULL; 1046 symp = symp->next) 1047 { 1048 /* Place into table at correct index locations */ 1049 location[symp->index + ieee->external_symbol_base_offset] = &symp->symbol; 1050 } 1051 1052 /* The external refs are indexed in a bit */ 1053 ieee->external_reference_base_offset = 1054 -ieee->external_reference_min_index + ieee->external_symbol_count; 1055 1056 for (symp = IEEE_DATA (abfd)->external_reference; 1057 symp != (ieee_symbol_type *) NULL; 1058 symp = symp->next) 1059 { 1060 location[symp->index + ieee->external_reference_base_offset] = 1061 &symp->symbol; 1062 1063 } 1064 } 1065 if (abfd->symcount) 1066 { 1067 location[abfd->symcount] = (asymbol *) NULL; 1068 } 1069 return abfd->symcount; 1070} 1071 1072static asection * 1073get_section_entry (abfd, ieee, index) 1074 bfd *abfd; 1075 ieee_data_type *ieee; 1076 unsigned int index; 1077{ 1078 if (index >= ieee->section_table_size) 1079 { 1080 unsigned int c, i; 1081 asection **n; 1082 1083 c = ieee->section_table_size; 1084 if (c == 0) 1085 c = 20; 1086 while (c <= index) 1087 c *= 2; 1088 1089 n = ((asection **) 1090 bfd_realloc (ieee->section_table, c * sizeof (asection *))); 1091 if (n == NULL) 1092 return NULL; 1093 1094 for (i = ieee->section_table_size; i < c; i++) 1095 n[i] = NULL; 1096 1097 ieee->section_table = n; 1098 ieee->section_table_size = c; 1099 } 1100 1101 if (ieee->section_table[index] == (asection *) NULL) 1102 { 1103 char *tmp = bfd_alloc (abfd, 11); 1104 asection *section; 1105 1106 if (!tmp) 1107 return NULL; 1108 sprintf (tmp, " fsec%4d", index); 1109 section = bfd_make_section (abfd, tmp); 1110 ieee->section_table[index] = section; 1111 section->flags = SEC_NO_FLAGS; 1112 section->target_index = index; 1113 ieee->section_table[index] = section; 1114 } 1115 return ieee->section_table[index]; 1116} 1117 1118static void 1119ieee_slurp_sections (abfd) 1120 bfd *abfd; 1121{ 1122 ieee_data_type *ieee = IEEE_DATA (abfd); 1123 file_ptr offset = ieee->w.r.section_part; 1124 asection *section = (asection *) NULL; 1125 char *name; 1126 1127 if (offset != 0) 1128 { 1129 bfd_byte section_type[3]; 1130 ieee_seek (abfd, offset); 1131 while (true) 1132 { 1133 switch (this_byte (&(ieee->h))) 1134 { 1135 case ieee_section_type_enum: 1136 { 1137 unsigned int section_index; 1138 next_byte (&(ieee->h)); 1139 section_index = must_parse_int (&(ieee->h)); 1140 1141 section = get_section_entry (abfd, ieee, section_index); 1142 1143 section_type[0] = this_byte_and_next (&(ieee->h)); 1144 1145 /* Set minimal section attributes. Attributes are 1146 extended later, based on section contents. */ 1147 1148 switch (section_type[0]) 1149 { 1150 case 0xC1: 1151 /* Normal attributes for absolute sections */ 1152 section_type[1] = this_byte (&(ieee->h)); 1153 section->flags = SEC_ALLOC; 1154 switch (section_type[1]) 1155 { 1156 case 0xD3: /* AS Absolute section attributes */ 1157 next_byte (&(ieee->h)); 1158 section_type[2] = this_byte (&(ieee->h)); 1159 switch (section_type[2]) 1160 { 1161 case 0xD0: 1162 /* Normal code */ 1163 next_byte (&(ieee->h)); 1164 section->flags |= SEC_CODE; 1165 break; 1166 case 0xC4: 1167 /* Normal data */ 1168 next_byte (&(ieee->h)); 1169 section->flags |= SEC_DATA; 1170 break; 1171 case 0xD2: 1172 next_byte (&(ieee->h)); 1173 /* Normal rom data */ 1174 section->flags |= SEC_ROM | SEC_DATA; 1175 break; 1176 default: 1177 break; 1178 } 1179 } 1180 break; 1181 case 0xC3: /* Named relocatable sections (type C) */ 1182 section_type[1] = this_byte (&(ieee->h)); 1183 section->flags = SEC_ALLOC; 1184 switch (section_type[1]) 1185 { 1186 case 0xD0: /* Normal code (CP) */ 1187 next_byte (&(ieee->h)); 1188 section->flags |= SEC_CODE; 1189 break; 1190 case 0xC4: /* Normal data (CD) */ 1191 next_byte (&(ieee->h)); 1192 section->flags |= SEC_DATA; 1193 break; 1194 case 0xD2: /* Normal rom data (CR) */ 1195 next_byte (&(ieee->h)); 1196 section->flags |= SEC_ROM | SEC_DATA; 1197 break; 1198 default: 1199 break; 1200 } 1201 } 1202 1203 /* Read section name, use it if non empty. */ 1204 name = read_id (&ieee->h); 1205 if (name[0]) 1206 section->name = name; 1207 1208 /* Skip these fields, which we don't care about */ 1209 { 1210 bfd_vma parent, brother, context; 1211 parse_int (&(ieee->h), &parent); 1212 parse_int (&(ieee->h), &brother); 1213 parse_int (&(ieee->h), &context); 1214 } 1215 } 1216 break; 1217 case ieee_section_alignment_enum: 1218 { 1219 unsigned int section_index; 1220 bfd_vma value; 1221 asection *section; 1222 next_byte (&(ieee->h)); 1223 section_index = must_parse_int (&ieee->h); 1224 section = get_section_entry (abfd, ieee, section_index); 1225 if (section_index > ieee->section_count) 1226 { 1227 ieee->section_count = section_index; 1228 } 1229 section->alignment_power = 1230 bfd_log2 (must_parse_int (&ieee->h)); 1231 (void) parse_int (&(ieee->h), &value); 1232 } 1233 break; 1234 case ieee_e2_first_byte_enum: 1235 { 1236 ieee_record_enum_type t = (ieee_record_enum_type) (read_2bytes (&(ieee->h))); 1237 1238 switch (t) 1239 { 1240 case ieee_section_size_enum: 1241 section = ieee->section_table[must_parse_int (&(ieee->h))]; 1242 section->_raw_size = must_parse_int (&(ieee->h)); 1243 break; 1244 case ieee_physical_region_size_enum: 1245 section = ieee->section_table[must_parse_int (&(ieee->h))]; 1246 section->_raw_size = must_parse_int (&(ieee->h)); 1247 break; 1248 case ieee_region_base_address_enum: 1249 section = ieee->section_table[must_parse_int (&(ieee->h))]; 1250 section->vma = must_parse_int (&(ieee->h)); 1251 section->lma = section->vma; 1252 break; 1253 case ieee_mau_size_enum: 1254 must_parse_int (&(ieee->h)); 1255 must_parse_int (&(ieee->h)); 1256 break; 1257 case ieee_m_value_enum: 1258 must_parse_int (&(ieee->h)); 1259 must_parse_int (&(ieee->h)); 1260 break; 1261 case ieee_section_base_address_enum: 1262 section = ieee->section_table[must_parse_int (&(ieee->h))]; 1263 section->vma = must_parse_int (&(ieee->h)); 1264 section->lma = section->vma; 1265 break; 1266 case ieee_section_offset_enum: 1267 (void) must_parse_int (&(ieee->h)); 1268 (void) must_parse_int (&(ieee->h)); 1269 break; 1270 default: 1271 return; 1272 } 1273 } 1274 break; 1275 default: 1276 return; 1277 } 1278 } 1279 } 1280} 1281 1282/* Make a section for the debugging information, if any. We don't try 1283 to interpret the debugging information; we just point the section 1284 at the area in the file so that program which understand can dig it 1285 out. */ 1286 1287static boolean 1288ieee_slurp_debug (abfd) 1289 bfd *abfd; 1290{ 1291 ieee_data_type *ieee = IEEE_DATA (abfd); 1292 asection *sec; 1293 file_ptr debug_end; 1294 1295 if (ieee->w.r.debug_information_part == 0) 1296 return true; 1297 1298 sec = bfd_make_section (abfd, ".debug"); 1299 if (sec == NULL) 1300 return false; 1301 sec->flags |= SEC_DEBUGGING | SEC_HAS_CONTENTS; 1302 sec->filepos = ieee->w.r.debug_information_part; 1303 1304 debug_end = ieee->w.r.data_part; 1305 if (debug_end == 0) 1306 debug_end = ieee->w.r.trailer_part; 1307 if (debug_end == 0) 1308 debug_end = ieee->w.r.me_record; 1309 sec->_raw_size = debug_end - ieee->w.r.debug_information_part; 1310 1311 return true; 1312} 1313 1314/*********************************************************************** 1315* archive stuff 1316*/ 1317 1318const bfd_target * 1319ieee_archive_p (abfd) 1320 bfd *abfd; 1321{ 1322 char *library; 1323 unsigned int i; 1324 unsigned char buffer[512]; 1325 file_ptr buffer_offset = 0; 1326 ieee_ar_data_type *save = abfd->tdata.ieee_ar_data; 1327 ieee_ar_data_type *ieee; 1328 unsigned int alc_elts; 1329 ieee_ar_obstack_type *elts = NULL; 1330 1331 abfd->tdata.ieee_ar_data = 1332 (ieee_ar_data_type *) bfd_alloc (abfd, sizeof (ieee_ar_data_type)); 1333 if (!abfd->tdata.ieee_ar_data) 1334 goto error_return; 1335 ieee = IEEE_AR_DATA (abfd); 1336 1337 /* FIXME: Check return value. I'm not sure whether it needs to read 1338 the entire buffer or not. */ 1339 bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd); 1340 1341 ieee->h.first_byte = buffer; 1342 ieee->h.input_p = buffer; 1343 1344 ieee->h.abfd = abfd; 1345 1346 if (this_byte (&(ieee->h)) != Module_Beginning) 1347 goto got_wrong_format_error; 1348 1349 next_byte (&(ieee->h)); 1350 library = read_id (&(ieee->h)); 1351 if (strcmp (library, "LIBRARY") != 0) 1352 goto got_wrong_format_error; 1353 1354 /* Throw away the filename. */ 1355 read_id (&(ieee->h)); 1356 1357 ieee->element_count = 0; 1358 ieee->element_index = 0; 1359 1360 next_byte (&(ieee->h)); /* Drop the ad part. */ 1361 must_parse_int (&(ieee->h)); /* And the two dummy numbers. */ 1362 must_parse_int (&(ieee->h)); 1363 1364 alc_elts = 10; 1365 elts = (ieee_ar_obstack_type *) bfd_malloc (alc_elts * sizeof *elts); 1366 if (elts == NULL) 1367 goto error_return; 1368 1369 /* Read the index of the BB table. */ 1370 while (1) 1371 { 1372 int rec; 1373 ieee_ar_obstack_type *t; 1374 1375 rec = read_2bytes (&(ieee->h)); 1376 if (rec != (int) ieee_assign_value_to_variable_enum) 1377 break; 1378 1379 if (ieee->element_count >= alc_elts) 1380 { 1381 ieee_ar_obstack_type *n; 1382 1383 alc_elts *= 2; 1384 n = ((ieee_ar_obstack_type *) 1385 bfd_realloc (elts, alc_elts * sizeof *elts)); 1386 if (n == NULL) 1387 goto error_return; 1388 elts = n; 1389 } 1390 1391 t = &elts[ieee->element_count]; 1392 ieee->element_count++; 1393 1394 must_parse_int (&(ieee->h)); 1395 t->file_offset = must_parse_int (&(ieee->h)); 1396 t->abfd = (bfd *) NULL; 1397 1398 /* Make sure that we don't go over the end of the buffer. */ 1399 if ((size_t) ieee_pos (abfd) > sizeof (buffer) / 2) 1400 { 1401 /* Past half way, reseek and reprime. */ 1402 buffer_offset += ieee_pos (abfd); 1403 if (bfd_seek (abfd, buffer_offset, SEEK_SET) != 0) 1404 goto error_return; 1405 1406 /* FIXME: Check return value. I'm not sure whether it needs 1407 to read the entire buffer or not. */ 1408 bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd); 1409 ieee->h.first_byte = buffer; 1410 ieee->h.input_p = buffer; 1411 } 1412 } 1413 1414 ieee->elements = ((ieee_ar_obstack_type *) 1415 bfd_alloc (abfd, 1416 ieee->element_count * sizeof *ieee->elements)); 1417 if (ieee->elements == NULL) 1418 goto error_return; 1419 1420 memcpy (ieee->elements, elts, 1421 ieee->element_count * sizeof *ieee->elements); 1422 free (elts); 1423 elts = NULL; 1424 1425 /* Now scan the area again, and replace BB offsets with file offsets. */ 1426 for (i = 2; i < ieee->element_count; i++) 1427 { 1428 if (bfd_seek (abfd, ieee->elements[i].file_offset, SEEK_SET) != 0) 1429 goto error_return; 1430 1431 /* FIXME: Check return value. I'm not sure whether it needs to 1432 read the entire buffer or not. */ 1433 bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd); 1434 ieee->h.first_byte = buffer; 1435 ieee->h.input_p = buffer; 1436 1437 next_byte (&(ieee->h)); /* Drop F8. */ 1438 next_byte (&(ieee->h)); /* Drop 14. */ 1439 must_parse_int (&(ieee->h)); /* Drop size of block. */ 1440 1441 if (must_parse_int (&(ieee->h)) != 0) 1442 /* This object has been deleted. */ 1443 ieee->elements[i].file_offset = 0; 1444 else 1445 ieee->elements[i].file_offset = must_parse_int (&(ieee->h)); 1446 } 1447 1448 /* abfd->has_armap = ;*/ 1449 1450 return abfd->xvec; 1451 1452 got_wrong_format_error: 1453 bfd_release (abfd, ieee); 1454 abfd->tdata.ieee_ar_data = save; 1455 bfd_set_error (bfd_error_wrong_format); 1456 1457 error_return: 1458 if (elts != NULL) 1459 free (elts); 1460 1461 return NULL; 1462} 1463 1464static boolean 1465ieee_mkobject (abfd) 1466 bfd *abfd; 1467{ 1468 abfd->tdata.ieee_data = (ieee_data_type *) bfd_zalloc (abfd, sizeof (ieee_data_type)); 1469 return abfd->tdata.ieee_data ? true : false; 1470} 1471 1472const bfd_target * 1473ieee_object_p (abfd) 1474 bfd *abfd; 1475{ 1476 char *processor; 1477 unsigned int part; 1478 ieee_data_type *ieee; 1479 unsigned char buffer[300]; 1480 ieee_data_type *save = IEEE_DATA (abfd); 1481 1482 abfd->tdata.ieee_data = 0; 1483 ieee_mkobject (abfd); 1484 1485 ieee = IEEE_DATA (abfd); 1486 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) 1487 goto fail; 1488 /* Read the first few bytes in to see if it makes sense */ 1489 /* FIXME: Check return value. I'm not sure whether it needs to read 1490 the entire buffer or not. */ 1491 bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd); 1492 1493 ieee->h.input_p = buffer; 1494 if (this_byte_and_next (&(ieee->h)) != Module_Beginning) 1495 goto got_wrong_format; 1496 1497 ieee->read_symbols = false; 1498 ieee->read_data = false; 1499 ieee->section_count = 0; 1500 ieee->external_symbol_max_index = 0; 1501 ieee->external_symbol_min_index = IEEE_PUBLIC_BASE; 1502 ieee->external_reference_min_index = IEEE_REFERENCE_BASE; 1503 ieee->external_reference_max_index = 0; 1504 ieee->h.abfd = abfd; 1505 ieee->section_table = NULL; 1506 ieee->section_table_size = 0; 1507 1508 processor = ieee->mb.processor = read_id (&(ieee->h)); 1509 if (strcmp (processor, "LIBRARY") == 0) 1510 goto got_wrong_format; 1511 ieee->mb.module_name = read_id (&(ieee->h)); 1512 if (abfd->filename == (CONST char *) NULL) 1513 { 1514 abfd->filename = ieee->mb.module_name; 1515 } 1516 /* Determine the architecture and machine type of the object file. 1517 */ 1518 { 1519 const bfd_arch_info_type *arch; 1520 char family[10]; 1521 1522 /* IEEE does not specify the format of the processor identificaton 1523 string, so the compiler is free to put in it whatever it wants. 1524 We try here to recognize different processors belonging to the 1525 m68k family. Code for other processors can be added here. */ 1526 if ((processor[0] == '6') && (processor[1] == '8')) 1527 { 1528 if (processor[2] == '3') /* 683xx integrated processors */ 1529 { 1530 switch (processor[3]) 1531 { 1532 case '0': /* 68302, 68306, 68307 */ 1533 case '2': /* 68322, 68328 */ 1534 case '5': /* 68356 */ 1535 strcpy (family, "68000"); /* MC68000-based controllers */ 1536 break; 1537 1538 case '3': /* 68330, 68331, 68332, 68333, 1539 68334, 68335, 68336, 68338 */ 1540 case '6': /* 68360 */ 1541 case '7': /* 68376 */ 1542 strcpy (family, "68332"); /* CPU32 and CPU32+ */ 1543 break; 1544 1545 case '4': 1546 if (processor[4] == '9') /* 68349 */ 1547 strcpy (family, "68030"); /* CPU030 */ 1548 else /* 68340, 68341 */ 1549 strcpy (family, "68332"); /* CPU32 and CPU32+ */ 1550 break; 1551 1552 default: /* Does not exist yet */ 1553 strcpy (family, "68332"); /* Guess it will be CPU32 */ 1554 } 1555 } 1556 else if (toupper (processor[3]) == 'F') /* 68F333 */ 1557 strcpy (family, "68332"); /* CPU32 */ 1558 else if ((toupper (processor[3]) == 'C') /* Embedded controllers */ 1559 && ((toupper (processor[2]) == 'E') 1560 || (toupper (processor[2]) == 'H') 1561 || (toupper (processor[2]) == 'L'))) 1562 { 1563 strcpy (family, "68"); 1564 strncat (family, processor + 4, 7); 1565 family[9] = '\0'; 1566 } 1567 else /* "Regular" processors */ 1568 { 1569 strncpy (family, processor, 9); 1570 family[9] = '\0'; 1571 } 1572 } 1573 else if ((strncmp (processor, "cpu32", 5) == 0) /* CPU32 and CPU32+ */ 1574 || (strncmp (processor, "CPU32", 5) == 0)) 1575 strcpy (family, "68332"); 1576 else 1577 { 1578 strncpy (family, processor, 9); 1579 family[9] = '\0'; 1580 } 1581 1582 arch = bfd_scan_arch (family); 1583 if (arch == 0) 1584 goto got_wrong_format; 1585 abfd->arch_info = arch; 1586 } 1587 1588 if (this_byte (&(ieee->h)) != (int) ieee_address_descriptor_enum) 1589 { 1590 goto fail; 1591 } 1592 next_byte (&(ieee->h)); 1593 1594 if (parse_int (&(ieee->h), &ieee->ad.number_of_bits_mau) == false) 1595 { 1596 goto fail; 1597 } 1598 if (parse_int (&(ieee->h), &ieee->ad.number_of_maus_in_address) == false) 1599 { 1600 goto fail; 1601 } 1602 1603 /* If there is a byte order info, take it */ 1604 if (this_byte (&(ieee->h)) == (int) ieee_variable_L_enum || 1605 this_byte (&(ieee->h)) == (int) ieee_variable_M_enum) 1606 next_byte (&(ieee->h)); 1607 1608 for (part = 0; part < N_W_VARIABLES; part++) 1609 { 1610 boolean ok; 1611 if (read_2bytes (&(ieee->h)) != (int) ieee_assign_value_to_variable_enum) 1612 { 1613 goto fail; 1614 } 1615 if (this_byte_and_next (&(ieee->h)) != part) 1616 { 1617 goto fail; 1618 } 1619 1620 ieee->w.offset[part] = parse_i (&(ieee->h), &ok); 1621 if (ok == false) 1622 { 1623 goto fail; 1624 } 1625 1626 } 1627 1628 if (ieee->w.r.external_part != 0) 1629 abfd->flags = HAS_SYMS; 1630 1631 /* By now we know that this is a real IEEE file, we're going to read 1632 the whole thing into memory so that we can run up and down it 1633 quickly. We can work out how big the file is from the trailer 1634 record */ 1635 1636 IEEE_DATA (abfd)->h.first_byte = 1637 (unsigned char *) bfd_alloc (ieee->h.abfd, ieee->w.r.me_record + 1); 1638 if (!IEEE_DATA (abfd)->h.first_byte) 1639 goto fail; 1640 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) 1641 goto fail; 1642 /* FIXME: Check return value. I'm not sure whether it needs to read 1643 the entire buffer or not. */ 1644 bfd_read ((PTR) (IEEE_DATA (abfd)->h.first_byte), 1, 1645 ieee->w.r.me_record + 1, abfd); 1646 1647 ieee_slurp_sections (abfd); 1648 1649 if (! ieee_slurp_debug (abfd)) 1650 goto fail; 1651 1652 /* Parse section data to activate file and section flags implied by 1653 section contents. */ 1654 1655 if (! ieee_slurp_section_data (abfd)) 1656 goto fail; 1657 1658 return abfd->xvec; 1659got_wrong_format: 1660 bfd_set_error (bfd_error_wrong_format); 1661fail: 1662 (void) bfd_release (abfd, ieee); 1663 abfd->tdata.ieee_data = save; 1664 return (const bfd_target *) NULL; 1665} 1666 1667void 1668ieee_get_symbol_info (ignore_abfd, symbol, ret) 1669 bfd *ignore_abfd ATTRIBUTE_UNUSED; 1670 asymbol *symbol; 1671 symbol_info *ret; 1672{ 1673 bfd_symbol_info (symbol, ret); 1674 if (symbol->name[0] == ' ') 1675 ret->name = "* empty table entry "; 1676 if (!symbol->section) 1677 ret->type = (symbol->flags & BSF_LOCAL) ? 'a' : 'A'; 1678} 1679 1680void 1681ieee_print_symbol (ignore_abfd, afile, symbol, how) 1682 bfd *ignore_abfd ATTRIBUTE_UNUSED; 1683 PTR afile; 1684 asymbol *symbol; 1685 bfd_print_symbol_type how; 1686{ 1687 FILE *file = (FILE *) afile; 1688 1689 switch (how) 1690 { 1691 case bfd_print_symbol_name: 1692 fprintf (file, "%s", symbol->name); 1693 break; 1694 case bfd_print_symbol_more: 1695#if 0 1696 fprintf (file, "%4x %2x", aout_symbol (symbol)->desc & 0xffff, 1697 aout_symbol (symbol)->other & 0xff); 1698#endif 1699 BFD_FAIL (); 1700 break; 1701 case bfd_print_symbol_all: 1702 { 1703 const char *section_name = 1704 (symbol->section == (asection *) NULL 1705 ? "*abs" 1706 : symbol->section->name); 1707 if (symbol->name[0] == ' ') 1708 { 1709 fprintf (file, "* empty table entry "); 1710 } 1711 else 1712 { 1713 bfd_print_symbol_vandf ((PTR) file, symbol); 1714 1715 fprintf (file, " %-5s %04x %02x %s", 1716 section_name, 1717 (unsigned) ieee_symbol (symbol)->index, 1718 (unsigned) 0, 1719 symbol->name); 1720 } 1721 } 1722 break; 1723 } 1724} 1725 1726static boolean 1727do_one (ieee, current_map, location_ptr, s, iterations) 1728 ieee_data_type *ieee; 1729 ieee_per_section_type *current_map; 1730 unsigned char *location_ptr; 1731 asection *s; 1732 int iterations; 1733{ 1734 switch (this_byte (&(ieee->h))) 1735 { 1736 case ieee_load_constant_bytes_enum: 1737 { 1738 unsigned int number_of_maus; 1739 unsigned int i; 1740 next_byte (&(ieee->h)); 1741 number_of_maus = must_parse_int (&(ieee->h)); 1742 1743 for (i = 0; i < number_of_maus; i++) 1744 { 1745 location_ptr[current_map->pc++] = this_byte (&(ieee->h)); 1746 next_byte (&(ieee->h)); 1747 } 1748 } 1749 break; 1750 1751 case ieee_load_with_relocation_enum: 1752 { 1753 boolean loop = true; 1754 next_byte (&(ieee->h)); 1755 while (loop) 1756 { 1757 switch (this_byte (&(ieee->h))) 1758 { 1759 case ieee_variable_R_enum: 1760 1761 case ieee_function_signed_open_b_enum: 1762 case ieee_function_unsigned_open_b_enum: 1763 case ieee_function_either_open_b_enum: 1764 { 1765 unsigned int extra = 4; 1766 boolean pcrel = false; 1767 asection *section; 1768 ieee_reloc_type *r = 1769 (ieee_reloc_type *) bfd_alloc (ieee->h.abfd, 1770 sizeof (ieee_reloc_type)); 1771 if (!r) 1772 return false; 1773 1774 *(current_map->reloc_tail_ptr) = r; 1775 current_map->reloc_tail_ptr = &r->next; 1776 r->next = (ieee_reloc_type *) NULL; 1777 next_byte (&(ieee->h)); 1778/* abort();*/ 1779 r->relent.sym_ptr_ptr = 0; 1780 parse_expression (ieee, 1781 &r->relent.addend, 1782 &r->symbol, 1783 &pcrel, &extra, §ion); 1784 r->relent.address = current_map->pc; 1785 s->flags |= SEC_RELOC; 1786 s->owner->flags |= HAS_RELOC; 1787 s->reloc_count++; 1788 if (r->relent.sym_ptr_ptr == NULL && section != NULL) 1789 r->relent.sym_ptr_ptr = section->symbol_ptr_ptr; 1790 1791 if (this_byte (&(ieee->h)) == (int) ieee_comma) 1792 { 1793 next_byte (&(ieee->h)); 1794 /* Fetch number of bytes to pad */ 1795 extra = must_parse_int (&(ieee->h)); 1796 }; 1797 1798 switch (this_byte (&(ieee->h))) 1799 { 1800 case ieee_function_signed_close_b_enum: 1801 next_byte (&(ieee->h)); 1802 break; 1803 case ieee_function_unsigned_close_b_enum: 1804 next_byte (&(ieee->h)); 1805 break; 1806 case ieee_function_either_close_b_enum: 1807 next_byte (&(ieee->h)); 1808 break; 1809 default: 1810 break; 1811 } 1812 /* Build a relocation entry for this type */ 1813 /* If pc rel then stick -ve pc into instruction 1814 and take out of reloc .. 1815 1816 I've changed this. It's all too complicated. I 1817 keep 0 in the instruction now. */ 1818 1819 switch (extra) 1820 { 1821 case 0: 1822 case 4: 1823 1824 if (pcrel == true) 1825 { 1826#if KEEPMINUSPCININST 1827 bfd_put_32 (ieee->h.abfd, -current_map->pc, location_ptr + 1828 current_map->pc); 1829 r->relent.howto = &rel32_howto; 1830 r->relent.addend -= 1831 current_map->pc; 1832#else 1833 bfd_put_32 (ieee->h.abfd, 0, location_ptr + 1834 current_map->pc); 1835 r->relent.howto = &rel32_howto; 1836#endif 1837 } 1838 else 1839 { 1840 bfd_put_32 (ieee->h.abfd, 0, location_ptr + 1841 current_map->pc); 1842 r->relent.howto = &abs32_howto; 1843 } 1844 current_map->pc += 4; 1845 break; 1846 case 2: 1847 if (pcrel == true) 1848 { 1849#if KEEPMINUSPCININST 1850 bfd_put_16 (ieee->h.abfd, (int) (-current_map->pc), location_ptr + current_map->pc); 1851 r->relent.addend -= current_map->pc; 1852 r->relent.howto = &rel16_howto; 1853#else 1854 1855 bfd_put_16 (ieee->h.abfd, 0, location_ptr + current_map->pc); 1856 r->relent.howto = &rel16_howto; 1857#endif 1858 } 1859 1860 else 1861 { 1862 bfd_put_16 (ieee->h.abfd, 0, location_ptr + current_map->pc); 1863 r->relent.howto = &abs16_howto; 1864 } 1865 current_map->pc += 2; 1866 break; 1867 case 1: 1868 if (pcrel == true) 1869 { 1870#if KEEPMINUSPCININST 1871 bfd_put_8 (ieee->h.abfd, (int) (-current_map->pc), location_ptr + current_map->pc); 1872 r->relent.addend -= current_map->pc; 1873 r->relent.howto = &rel8_howto; 1874#else 1875 bfd_put_8 (ieee->h.abfd, 0, location_ptr + current_map->pc); 1876 r->relent.howto = &rel8_howto; 1877#endif 1878 } 1879 else 1880 { 1881 bfd_put_8 (ieee->h.abfd, 0, location_ptr + current_map->pc); 1882 r->relent.howto = &abs8_howto; 1883 } 1884 current_map->pc += 1; 1885 break; 1886 1887 default: 1888 BFD_FAIL (); 1889 return false; 1890 } 1891 } 1892 break; 1893 default: 1894 { 1895 bfd_vma this_size; 1896 if (parse_int (&(ieee->h), &this_size) == true) 1897 { 1898 unsigned int i; 1899 for (i = 0; i < this_size; i++) 1900 { 1901 location_ptr[current_map->pc++] = this_byte (&(ieee->h)); 1902 next_byte (&(ieee->h)); 1903 } 1904 } 1905 else 1906 { 1907 loop = false; 1908 } 1909 } 1910 } 1911 1912 /* Prevent more than the first load-item of an LR record 1913 from being repeated (MRI convention). */ 1914 if (iterations != 1) 1915 loop = false; 1916 } 1917 } 1918 } 1919 return true; 1920} 1921 1922/* Read in all the section data and relocation stuff too */ 1923static boolean 1924ieee_slurp_section_data (abfd) 1925 bfd *abfd; 1926{ 1927 bfd_byte *location_ptr = (bfd_byte *) NULL; 1928 ieee_data_type *ieee = IEEE_DATA (abfd); 1929 unsigned int section_number; 1930 1931 ieee_per_section_type *current_map = (ieee_per_section_type *) NULL; 1932 asection *s; 1933 /* Seek to the start of the data area */ 1934 if (ieee->read_data == true) 1935 return true; 1936 ieee->read_data = true; 1937 ieee_seek (abfd, ieee->w.r.data_part); 1938 1939 /* Allocate enough space for all the section contents */ 1940 1941 for (s = abfd->sections; s != (asection *) NULL; s = s->next) 1942 { 1943 ieee_per_section_type *per = (ieee_per_section_type *) s->used_by_bfd; 1944 if ((s->flags & SEC_DEBUGGING) != 0) 1945 continue; 1946 per->data = (bfd_byte *) bfd_alloc (ieee->h.abfd, s->_raw_size); 1947 if (!per->data) 1948 return false; 1949 /*SUPPRESS 68*/ 1950 per->reloc_tail_ptr = 1951 (ieee_reloc_type **) & (s->relocation); 1952 } 1953 1954 while (true) 1955 { 1956 switch (this_byte (&(ieee->h))) 1957 { 1958 /* IF we see anything strange then quit */ 1959 default: 1960 return true; 1961 1962 case ieee_set_current_section_enum: 1963 next_byte (&(ieee->h)); 1964 section_number = must_parse_int (&(ieee->h)); 1965 s = ieee->section_table[section_number]; 1966 s->flags |= SEC_LOAD | SEC_HAS_CONTENTS; 1967 current_map = (ieee_per_section_type *) s->used_by_bfd; 1968 location_ptr = current_map->data - s->vma; 1969 /* The document I have says that Microtec's compilers reset */ 1970 /* this after a sec section, even though the standard says not */ 1971 /* to. SO .. */ 1972 current_map->pc = s->vma; 1973 break; 1974 1975 case ieee_e2_first_byte_enum: 1976 next_byte (&(ieee->h)); 1977 switch (this_byte (&(ieee->h))) 1978 { 1979 case ieee_set_current_pc_enum & 0xff: 1980 { 1981 bfd_vma value; 1982 ieee_symbol_index_type symbol; 1983 unsigned int extra; 1984 boolean pcrel; 1985 next_byte (&(ieee->h)); 1986 must_parse_int (&(ieee->h)); /* Thow away section #*/ 1987 parse_expression (ieee, &value, 1988 &symbol, 1989 &pcrel, &extra, 1990 0); 1991 current_map->pc = value; 1992 BFD_ASSERT ((unsigned) (value - s->vma) <= s->_raw_size); 1993 } 1994 break; 1995 1996 case ieee_value_starting_address_enum & 0xff: 1997 next_byte (&(ieee->h)); 1998 if (this_byte (&(ieee->h)) == ieee_function_either_open_b_enum) 1999 next_byte (&(ieee->h)); 2000 abfd->start_address = must_parse_int (&(ieee->h)); 2001 /* We've got to the end of the data now - */ 2002 return true; 2003 default: 2004 BFD_FAIL (); 2005 return false; 2006 } 2007 break; 2008 case ieee_repeat_data_enum: 2009 { 2010 /* Repeat the following LD or LR n times - we do this by 2011 remembering the stream pointer before running it and 2012 resetting it and running it n times. We special case 2013 the repetition of a repeat_data/load_constant 2014 */ 2015 2016 unsigned int iterations; 2017 unsigned char *start; 2018 next_byte (&(ieee->h)); 2019 iterations = must_parse_int (&(ieee->h)); 2020 start = ieee->h.input_p; 2021 if (start[0] == (int) ieee_load_constant_bytes_enum && 2022 start[1] == 1) 2023 { 2024 while (iterations != 0) 2025 { 2026 location_ptr[current_map->pc++] = start[2]; 2027 iterations--; 2028 } 2029 next_byte (&(ieee->h)); 2030 next_byte (&(ieee->h)); 2031 next_byte (&(ieee->h)); 2032 } 2033 else 2034 { 2035 while (iterations != 0) 2036 { 2037 ieee->h.input_p = start; 2038 if (!do_one (ieee, current_map, location_ptr, s, 2039 iterations)) 2040 return false; 2041 iterations--; 2042 } 2043 } 2044 } 2045 break; 2046 case ieee_load_constant_bytes_enum: 2047 case ieee_load_with_relocation_enum: 2048 { 2049 if (!do_one (ieee, current_map, location_ptr, s, 1)) 2050 return false; 2051 } 2052 } 2053 } 2054} 2055 2056boolean 2057ieee_new_section_hook (abfd, newsect) 2058 bfd *abfd; 2059 asection *newsect; 2060{ 2061 newsect->used_by_bfd = (PTR) 2062 bfd_alloc (abfd, sizeof (ieee_per_section_type)); 2063 if (!newsect->used_by_bfd) 2064 return false; 2065 ieee_per_section (newsect)->data = (bfd_byte *) NULL; 2066 ieee_per_section (newsect)->section = newsect; 2067 return true; 2068} 2069 2070long 2071ieee_get_reloc_upper_bound (abfd, asect) 2072 bfd *abfd; 2073 sec_ptr asect; 2074{ 2075 if ((asect->flags & SEC_DEBUGGING) != 0) 2076 return 0; 2077 if (! ieee_slurp_section_data (abfd)) 2078 return -1; 2079 return (asect->reloc_count + 1) * sizeof (arelent *); 2080} 2081 2082static boolean 2083ieee_get_section_contents (abfd, section, location, offset, count) 2084 bfd *abfd; 2085 sec_ptr section; 2086 PTR location; 2087 file_ptr offset; 2088 bfd_size_type count; 2089{ 2090 ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd; 2091 if ((section->flags & SEC_DEBUGGING) != 0) 2092 return _bfd_generic_get_section_contents (abfd, section, location, 2093 offset, count); 2094 ieee_slurp_section_data (abfd); 2095 (void) memcpy ((PTR) location, (PTR) (p->data + offset), (unsigned) count); 2096 return true; 2097} 2098 2099long 2100ieee_canonicalize_reloc (abfd, section, relptr, symbols) 2101 bfd *abfd; 2102 sec_ptr section; 2103 arelent **relptr; 2104 asymbol **symbols; 2105{ 2106/* ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;*/ 2107 ieee_reloc_type *src = (ieee_reloc_type *) (section->relocation); 2108 ieee_data_type *ieee = IEEE_DATA (abfd); 2109 2110 if ((section->flags & SEC_DEBUGGING) != 0) 2111 return 0; 2112 2113 while (src != (ieee_reloc_type *) NULL) 2114 { 2115 /* Work out which symbol to attach it this reloc to */ 2116 switch (src->symbol.letter) 2117 { 2118 case 'I': 2119 src->relent.sym_ptr_ptr = 2120 symbols + src->symbol.index + ieee->external_symbol_base_offset; 2121 break; 2122 case 'X': 2123 src->relent.sym_ptr_ptr = 2124 symbols + src->symbol.index + ieee->external_reference_base_offset; 2125 break; 2126 case 0: 2127 if (src->relent.sym_ptr_ptr != NULL) 2128 src->relent.sym_ptr_ptr = 2129 src->relent.sym_ptr_ptr[0]->section->symbol_ptr_ptr; 2130 break; 2131 default: 2132 2133 BFD_FAIL (); 2134 } 2135 *relptr++ = &src->relent; 2136 src = src->next; 2137 } 2138 *relptr = (arelent *) NULL; 2139 return section->reloc_count; 2140} 2141 2142static int 2143comp (ap, bp) 2144 CONST PTR ap; 2145 CONST PTR bp; 2146{ 2147 arelent *a = *((arelent **) ap); 2148 arelent *b = *((arelent **) bp); 2149 return a->address - b->address; 2150} 2151 2152/* Write the section headers. */ 2153 2154static boolean 2155ieee_write_section_part (abfd) 2156 bfd *abfd; 2157{ 2158 ieee_data_type *ieee = IEEE_DATA (abfd); 2159 asection *s; 2160 ieee->w.r.section_part = bfd_tell (abfd); 2161 for (s = abfd->sections; s != (asection *) NULL; s = s->next) 2162 { 2163 if (! bfd_is_abs_section (s) 2164 && (s->flags & SEC_DEBUGGING) == 0) 2165 { 2166 if (! ieee_write_byte (abfd, ieee_section_type_enum) 2167 || ! ieee_write_byte (abfd, 2168 (bfd_byte) (s->index 2169 + IEEE_SECTION_NUMBER_BASE))) 2170 return false; 2171 2172 if (abfd->flags & EXEC_P) 2173 { 2174 /* This image is executable, so output absolute sections */ 2175 if (! ieee_write_byte (abfd, ieee_variable_A_enum) 2176 || ! ieee_write_byte (abfd, ieee_variable_S_enum)) 2177 return false; 2178 } 2179 else 2180 { 2181 if (! ieee_write_byte (abfd, ieee_variable_C_enum)) 2182 return false; 2183 } 2184 2185 switch (s->flags & (SEC_CODE | SEC_DATA | SEC_ROM)) 2186 { 2187 case SEC_CODE | SEC_LOAD: 2188 case SEC_CODE: 2189 if (! ieee_write_byte (abfd, ieee_variable_P_enum)) 2190 return false; 2191 break; 2192 case SEC_DATA: 2193 default: 2194 if (! ieee_write_byte (abfd, ieee_variable_D_enum)) 2195 return false; 2196 break; 2197 case SEC_ROM: 2198 case SEC_ROM | SEC_DATA: 2199 case SEC_ROM | SEC_LOAD: 2200 case SEC_ROM | SEC_DATA | SEC_LOAD: 2201 if (! ieee_write_byte (abfd, ieee_variable_R_enum)) 2202 return false; 2203 } 2204 2205 2206 if (! ieee_write_id (abfd, s->name)) 2207 return false; 2208#if 0 2209 ieee_write_int (abfd, 0); /* Parent */ 2210 ieee_write_int (abfd, 0); /* Brother */ 2211 ieee_write_int (abfd, 0); /* Context */ 2212#endif 2213 /* Alignment */ 2214 if (! ieee_write_byte (abfd, ieee_section_alignment_enum) 2215 || ! ieee_write_byte (abfd, 2216 (bfd_byte) (s->index 2217 + IEEE_SECTION_NUMBER_BASE)) 2218 || ! ieee_write_int (abfd, 1 << s->alignment_power)) 2219 return false; 2220 2221 /* Size */ 2222 if (! ieee_write_2bytes (abfd, ieee_section_size_enum) 2223 || ! ieee_write_byte (abfd, 2224 (bfd_byte) (s->index 2225 + IEEE_SECTION_NUMBER_BASE)) 2226 || ! ieee_write_int (abfd, s->_raw_size)) 2227 return false; 2228 if (abfd->flags & EXEC_P) 2229 { 2230 /* Relocateable sections don't have asl records */ 2231 /* Vma */ 2232 if (! ieee_write_2bytes (abfd, ieee_section_base_address_enum) 2233 || ! ieee_write_byte (abfd, 2234 ((bfd_byte) 2235 (s->index 2236 + IEEE_SECTION_NUMBER_BASE))) 2237 || ! ieee_write_int (abfd, s->lma)) 2238 return false; 2239 } 2240 } 2241 } 2242 2243 return true; 2244} 2245 2246 2247static boolean 2248do_with_relocs (abfd, s) 2249 bfd *abfd; 2250 asection *s; 2251{ 2252 unsigned int number_of_maus_in_address = 2253 bfd_arch_bits_per_address (abfd) / bfd_arch_bits_per_byte (abfd); 2254 unsigned int relocs_to_go = s->reloc_count; 2255 bfd_byte *stream = ieee_per_section (s)->data; 2256 arelent **p = s->orelocation; 2257 bfd_size_type current_byte_index = 0; 2258 2259 qsort (s->orelocation, 2260 relocs_to_go, 2261 sizeof (arelent **), 2262 comp); 2263 2264 /* Output the section preheader */ 2265 if (! ieee_write_byte (abfd, ieee_set_current_section_enum) 2266 || ! ieee_write_byte (abfd, 2267 (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE)) 2268 || ! ieee_write_2bytes (abfd, ieee_set_current_pc_enum) 2269 || ! ieee_write_byte (abfd, 2270 (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE))) 2271 return false; 2272 if ((abfd->flags & EXEC_P) != 0 && relocs_to_go == 0) 2273 { 2274 if (! ieee_write_int (abfd, s->lma)) 2275 return false; 2276 } 2277 else 2278 { 2279 if (! ieee_write_expression (abfd, 0, s->symbol, 0, 0)) 2280 return false; 2281 } 2282 2283 if (relocs_to_go == 0) 2284 { 2285 /* If there aren't any relocations then output the load constant 2286 byte opcode rather than the load with relocation opcode */ 2287 2288 while (current_byte_index < s->_raw_size) 2289 { 2290 bfd_size_type run; 2291 unsigned int MAXRUN = 127; 2292 run = MAXRUN; 2293 if (run > s->_raw_size - current_byte_index) 2294 { 2295 run = s->_raw_size - current_byte_index; 2296 } 2297 2298 if (run != 0) 2299 { 2300 if (! ieee_write_byte (abfd, ieee_load_constant_bytes_enum)) 2301 return false; 2302 /* Output a stream of bytes */ 2303 if (! ieee_write_int (abfd, run)) 2304 return false; 2305 if (bfd_write ((PTR) (stream + current_byte_index), 2306 1, 2307 run, 2308 abfd) 2309 != run) 2310 return false; 2311 current_byte_index += run; 2312 } 2313 } 2314 } 2315 else 2316 { 2317 if (! ieee_write_byte (abfd, ieee_load_with_relocation_enum)) 2318 return false; 2319 2320 /* Output the data stream as the longest sequence of bytes 2321 possible, allowing for the a reasonable packet size and 2322 relocation stuffs. */ 2323 2324 if ((PTR) stream == (PTR) NULL) 2325 { 2326 /* Outputting a section without data, fill it up */ 2327 stream = (unsigned char *) (bfd_alloc (abfd, s->_raw_size)); 2328 if (!stream) 2329 return false; 2330 memset ((PTR) stream, 0, (size_t) s->_raw_size); 2331 } 2332 while (current_byte_index < s->_raw_size) 2333 { 2334 bfd_size_type run; 2335 unsigned int MAXRUN = 127; 2336 if (relocs_to_go) 2337 { 2338 run = (*p)->address - current_byte_index; 2339 if (run > MAXRUN) 2340 run = MAXRUN; 2341 } 2342 else 2343 { 2344 run = MAXRUN; 2345 } 2346 if (run > s->_raw_size - current_byte_index) 2347 { 2348 run = s->_raw_size - current_byte_index; 2349 } 2350 2351 if (run != 0) 2352 { 2353 /* Output a stream of bytes */ 2354 if (! ieee_write_int (abfd, run)) 2355 return false; 2356 if (bfd_write ((PTR) (stream + current_byte_index), 2357 1, 2358 run, 2359 abfd) 2360 != run) 2361 return false; 2362 current_byte_index += run; 2363 } 2364 /* Output any relocations here */ 2365 if (relocs_to_go && (*p) && (*p)->address == current_byte_index) 2366 { 2367 while (relocs_to_go 2368 && (*p) && (*p)->address == current_byte_index) 2369 { 2370 arelent *r = *p; 2371 bfd_signed_vma ov; 2372 2373#if 0 2374 if (r->howto->pc_relative) 2375 { 2376 r->addend += current_byte_index; 2377 } 2378#endif 2379 2380 switch (r->howto->size) 2381 { 2382 case 2: 2383 2384 ov = bfd_get_signed_32 (abfd, 2385 stream + current_byte_index); 2386 current_byte_index += 4; 2387 break; 2388 case 1: 2389 ov = bfd_get_signed_16 (abfd, 2390 stream + current_byte_index); 2391 current_byte_index += 2; 2392 break; 2393 case 0: 2394 ov = bfd_get_signed_8 (abfd, 2395 stream + current_byte_index); 2396 current_byte_index++; 2397 break; 2398 default: 2399 ov = 0; 2400 BFD_FAIL (); 2401 return false; 2402 } 2403 2404 ov &= r->howto->src_mask; 2405 2406 if (r->howto->pc_relative 2407 && ! r->howto->pcrel_offset) 2408 ov += r->address; 2409 2410 if (! ieee_write_byte (abfd, 2411 ieee_function_either_open_b_enum)) 2412 return false; 2413 2414/* abort();*/ 2415 2416 if (r->sym_ptr_ptr != (asymbol **) NULL) 2417 { 2418 if (! ieee_write_expression (abfd, r->addend + ov, 2419 *(r->sym_ptr_ptr), 2420 r->howto->pc_relative, 2421 s->index)) 2422 return false; 2423 } 2424 else 2425 { 2426 if (! ieee_write_expression (abfd, r->addend + ov, 2427 (asymbol *) NULL, 2428 r->howto->pc_relative, 2429 s->index)) 2430 return false; 2431 } 2432 2433 if (number_of_maus_in_address 2434 != bfd_get_reloc_size (r->howto)) 2435 { 2436 if (! ieee_write_int (abfd, 2437 bfd_get_reloc_size (r->howto))) 2438 return false; 2439 } 2440 if (! ieee_write_byte (abfd, 2441 ieee_function_either_close_b_enum)) 2442 return false; 2443 2444 relocs_to_go--; 2445 p++; 2446 } 2447 2448 } 2449 } 2450 } 2451 2452 return true; 2453} 2454 2455/* If there are no relocations in the output section then we can be 2456 clever about how we write. We block items up into a max of 127 2457 bytes. */ 2458 2459static boolean 2460do_as_repeat (abfd, s) 2461 bfd *abfd; 2462 asection *s; 2463{ 2464 if (s->_raw_size) 2465 { 2466 if (! ieee_write_byte (abfd, ieee_set_current_section_enum) 2467 || ! ieee_write_byte (abfd, 2468 (bfd_byte) (s->index 2469 + IEEE_SECTION_NUMBER_BASE)) 2470 || ! ieee_write_byte (abfd, ieee_set_current_pc_enum >> 8) 2471 || ! ieee_write_byte (abfd, ieee_set_current_pc_enum & 0xff) 2472 || ! ieee_write_byte (abfd, 2473 (bfd_byte) (s->index 2474 + IEEE_SECTION_NUMBER_BASE)) 2475 || ! ieee_write_int (abfd, s->lma) 2476 || ! ieee_write_byte (abfd, ieee_repeat_data_enum) 2477 || ! ieee_write_int (abfd, s->_raw_size) 2478 || ! ieee_write_byte (abfd, ieee_load_constant_bytes_enum) 2479 || ! ieee_write_byte (abfd, 1) 2480 || ! ieee_write_byte (abfd, 0)) 2481 return false; 2482 } 2483 2484 return true; 2485} 2486 2487static boolean 2488do_without_relocs (abfd, s) 2489 bfd *abfd; 2490 asection *s; 2491{ 2492 bfd_byte *stream = ieee_per_section (s)->data; 2493 2494 if (stream == 0 || ((s->flags & SEC_LOAD) == 0)) 2495 { 2496 if (! do_as_repeat (abfd, s)) 2497 return false; 2498 } 2499 else 2500 { 2501 unsigned int i; 2502 for (i = 0; i < s->_raw_size; i++) 2503 { 2504 if (stream[i] != 0) 2505 { 2506 if (! do_with_relocs (abfd, s)) 2507 return false; 2508 return true; 2509 } 2510 } 2511 if (! do_as_repeat (abfd, s)) 2512 return false; 2513 } 2514 2515 return true; 2516} 2517 2518 2519static unsigned char *output_ptr_start; 2520static unsigned char *output_ptr; 2521static unsigned char *output_ptr_end; 2522static unsigned char *input_ptr_start; 2523static unsigned char *input_ptr; 2524static unsigned char *input_ptr_end; 2525static bfd *input_bfd; 2526static bfd *output_bfd; 2527static int output_buffer; 2528 2529static void 2530fill () 2531{ 2532 /* FIXME: Check return value. I'm not sure whether it needs to read 2533 the entire buffer or not. */ 2534 bfd_read ((PTR) input_ptr_start, 1, input_ptr_end - input_ptr_start, input_bfd); 2535 input_ptr = input_ptr_start; 2536} 2537static void 2538flush () 2539{ 2540 if (bfd_write ((PTR) (output_ptr_start), 1, output_ptr - output_ptr_start, 2541 output_bfd) 2542 != (bfd_size_type) (output_ptr - output_ptr_start)) 2543 abort (); 2544 output_ptr = output_ptr_start; 2545 output_buffer++; 2546} 2547 2548#define THIS() ( *input_ptr ) 2549#define NEXT() { input_ptr++; if (input_ptr == input_ptr_end) fill(); } 2550#define OUT(x) { *output_ptr++ = (x); if(output_ptr == output_ptr_end) flush(); } 2551 2552static void 2553write_int (value) 2554 int value; 2555{ 2556 if (value >= 0 && value <= 127) 2557 { 2558 OUT (value); 2559 } 2560 else 2561 { 2562 unsigned int length; 2563 /* How many significant bytes ? */ 2564 /* FIXME FOR LONGER INTS */ 2565 if (value & 0xff000000) 2566 { 2567 length = 4; 2568 } 2569 else if (value & 0x00ff0000) 2570 { 2571 length = 3; 2572 } 2573 else if (value & 0x0000ff00) 2574 { 2575 length = 2; 2576 } 2577 else 2578 length = 1; 2579 2580 OUT ((int) ieee_number_repeat_start_enum + length); 2581 switch (length) 2582 { 2583 case 4: 2584 OUT (value >> 24); 2585 case 3: 2586 OUT (value >> 16); 2587 case 2: 2588 OUT (value >> 8); 2589 case 1: 2590 OUT (value); 2591 } 2592 2593 } 2594} 2595 2596static void 2597copy_id () 2598{ 2599 int length = THIS (); 2600 char ch; 2601 OUT (length); 2602 NEXT (); 2603 while (length--) 2604 { 2605 ch = THIS (); 2606 OUT (ch); 2607 NEXT (); 2608 } 2609} 2610 2611#define VAR(x) ((x | 0x80)) 2612static void 2613copy_expression () 2614{ 2615 int stack[10]; 2616 int *tos = stack; 2617 int value = 0; 2618 while (1) 2619 { 2620 switch (THIS ()) 2621 { 2622 case 0x84: 2623 NEXT (); 2624 value = THIS (); 2625 NEXT (); 2626 value = (value << 8) | THIS (); 2627 NEXT (); 2628 value = (value << 8) | THIS (); 2629 NEXT (); 2630 value = (value << 8) | THIS (); 2631 NEXT (); 2632 *tos++ = value; 2633 break; 2634 case 0x83: 2635 NEXT (); 2636 value = THIS (); 2637 NEXT (); 2638 value = (value << 8) | THIS (); 2639 NEXT (); 2640 value = (value << 8) | THIS (); 2641 NEXT (); 2642 *tos++ = value; 2643 break; 2644 case 0x82: 2645 NEXT (); 2646 value = THIS (); 2647 NEXT (); 2648 value = (value << 8) | THIS (); 2649 NEXT (); 2650 *tos++ = value; 2651 break; 2652 case 0x81: 2653 NEXT (); 2654 value = THIS (); 2655 NEXT (); 2656 *tos++ = value; 2657 break; 2658 case 0x80: 2659 NEXT (); 2660 *tos++ = 0; 2661 break; 2662 default: 2663 if (THIS () > 0x84) 2664 { 2665 /* Not a number, just bug out with the answer */ 2666 write_int (*(--tos)); 2667 return; 2668 } 2669 *tos++ = THIS (); 2670 NEXT (); 2671 value = 0; 2672 break; 2673 case 0xa5: 2674 /* PLUS anything */ 2675 { 2676 int value = *(--tos); 2677 value += *(--tos); 2678 *tos++ = value; 2679 NEXT (); 2680 } 2681 break; 2682 case VAR ('R'): 2683 { 2684 int section_number; 2685 ieee_data_type *ieee; 2686 asection *s; 2687 NEXT (); 2688 section_number = THIS (); 2689 2690 NEXT (); 2691 ieee = IEEE_DATA (input_bfd); 2692 s = ieee->section_table[section_number]; 2693 if (s->output_section) 2694 { 2695 value = s->output_section->lma; 2696 } 2697 else 2698 { 2699 value = 0; 2700 } 2701 value += s->output_offset; 2702 *tos++ = value; 2703 value = 0; 2704 } 2705 break; 2706 case 0x90: 2707 { 2708 NEXT (); 2709 write_int (*(--tos)); 2710 OUT (0x90); 2711 return; 2712 2713 } 2714 } 2715 } 2716 2717} 2718 2719/* Drop the int in the buffer, and copy a null into the gap, which we 2720 will overwrite later */ 2721 2722struct output_buffer_struct 2723{ 2724 unsigned char *ptrp; 2725 int buffer; 2726}; 2727 2728static void 2729fill_int (buf) 2730 struct output_buffer_struct *buf; 2731{ 2732 if (buf->buffer == output_buffer) 2733 { 2734 /* Still a chance to output the size */ 2735 int value = output_ptr - buf->ptrp + 3; 2736 buf->ptrp[0] = value >> 24; 2737 buf->ptrp[1] = value >> 16; 2738 buf->ptrp[2] = value >> 8; 2739 buf->ptrp[3] = value >> 0; 2740 } 2741} 2742 2743static void 2744drop_int (buf) 2745 struct output_buffer_struct *buf; 2746{ 2747 int type = THIS (); 2748 int ch; 2749 if (type <= 0x84) 2750 { 2751 NEXT (); 2752 switch (type) 2753 { 2754 case 0x84: 2755 ch = THIS (); 2756 NEXT (); 2757 case 0x83: 2758 ch = THIS (); 2759 NEXT (); 2760 case 0x82: 2761 ch = THIS (); 2762 NEXT (); 2763 case 0x81: 2764 ch = THIS (); 2765 NEXT (); 2766 case 0x80: 2767 break; 2768 } 2769 } 2770 OUT (0x84); 2771 buf->ptrp = output_ptr; 2772 buf->buffer = output_buffer; 2773 OUT (0); 2774 OUT (0); 2775 OUT (0); 2776 OUT (0); 2777} 2778 2779static void 2780copy_int () 2781{ 2782 int type = THIS (); 2783 int ch; 2784 if (type <= 0x84) 2785 { 2786 OUT (type); 2787 NEXT (); 2788 switch (type) 2789 { 2790 case 0x84: 2791 ch = THIS (); 2792 NEXT (); 2793 OUT (ch); 2794 case 0x83: 2795 ch = THIS (); 2796 NEXT (); 2797 OUT (ch); 2798 case 0x82: 2799 ch = THIS (); 2800 NEXT (); 2801 OUT (ch); 2802 case 0x81: 2803 ch = THIS (); 2804 NEXT (); 2805 OUT (ch); 2806 case 0x80: 2807 break; 2808 } 2809 } 2810} 2811 2812#define ID copy_id() 2813#define INT copy_int() 2814#define EXP copy_expression() 2815static void copy_till_end (); 2816#define INTn(q) copy_int() 2817#define EXPn(q) copy_expression() 2818 2819static void 2820f1_record () 2821{ 2822 int ch; 2823 /* ATN record */ 2824 NEXT (); 2825 ch = THIS (); 2826 switch (ch) 2827 { 2828 default: 2829 OUT (0xf1); 2830 OUT (ch); 2831 break; 2832 case 0xc9: 2833 NEXT (); 2834 OUT (0xf1); 2835 OUT (0xc9); 2836 INT; 2837 INT; 2838 ch = THIS (); 2839 switch (ch) 2840 { 2841 case 0x16: 2842 NEXT (); 2843 break; 2844 case 0x01: 2845 NEXT (); 2846 break; 2847 case 0x00: 2848 NEXT (); 2849 INT; 2850 break; 2851 case 0x03: 2852 NEXT (); 2853 INT; 2854 break; 2855 case 0x13: 2856 EXPn (instruction address); 2857 break; 2858 default: 2859 break; 2860 } 2861 break; 2862 case 0xd8: 2863 /* EXternal ref */ 2864 NEXT (); 2865 OUT (0xf1); 2866 OUT (0xd8); 2867 EXP; 2868 EXP; 2869 EXP; 2870 EXP; 2871 break; 2872 case 0xce: 2873 NEXT (); 2874 OUT (0xf1); 2875 OUT (0xce); 2876 INT; 2877 INT; 2878 ch = THIS (); 2879 INT; 2880 switch (ch) 2881 { 2882 case 0x01: 2883 INT; 2884 INT; 2885 break; 2886 case 0x02: 2887 INT; 2888 break; 2889 case 0x04: 2890 EXPn (external function); 2891 break; 2892 case 0x05: 2893 break; 2894 case 0x07: 2895 INTn (line number); 2896 INT; 2897 case 0x08: 2898 break; 2899 case 0x0a: 2900 INTn (locked register); 2901 INT; 2902 break; 2903 case 0x3f: 2904 copy_till_end (); 2905 break; 2906 case 0x3e: 2907 copy_till_end (); 2908 break; 2909 case 0x40: 2910 copy_till_end (); 2911 break; 2912 case 0x41: 2913 ID; 2914 break; 2915 } 2916 } 2917 2918} 2919 2920static void 2921f0_record () 2922{ 2923 /* Attribute record */ 2924 NEXT (); 2925 OUT (0xf0); 2926 INTn (Symbol name); 2927 ID; 2928} 2929 2930static void 2931copy_till_end () 2932{ 2933 int ch = THIS (); 2934 while (1) 2935 { 2936 while (ch <= 0x80) 2937 { 2938 OUT (ch); 2939 NEXT (); 2940 ch = THIS (); 2941 } 2942 switch (ch) 2943 { 2944 case 0x84: 2945 OUT (THIS ()); 2946 NEXT (); 2947 case 0x83: 2948 OUT (THIS ()); 2949 NEXT (); 2950 case 0x82: 2951 OUT (THIS ()); 2952 NEXT (); 2953 case 0x81: 2954 OUT (THIS ()); 2955 NEXT (); 2956 OUT (THIS ()); 2957 NEXT (); 2958 2959 ch = THIS (); 2960 break; 2961 default: 2962 return; 2963 } 2964 } 2965 2966} 2967 2968static void 2969f2_record () 2970{ 2971 NEXT (); 2972 OUT (0xf2); 2973 INT; 2974 NEXT (); 2975 OUT (0xce); 2976 INT; 2977 copy_till_end (); 2978} 2979 2980 2981static void block (); 2982static void 2983f8_record () 2984{ 2985 int ch; 2986 NEXT (); 2987 ch = THIS (); 2988 switch (ch) 2989 { 2990 case 0x01: 2991 case 0x02: 2992 case 0x03: 2993 /* Unique typedefs for module */ 2994 /* GLobal typedefs */ 2995 /* High level module scope beginning */ 2996 { 2997 struct output_buffer_struct ob; 2998 NEXT (); 2999 OUT (0xf8); 3000 OUT (ch); 3001 drop_int (&ob); 3002 ID; 3003 3004 block (); 3005 3006 NEXT (); 3007 fill_int (&ob); 3008 OUT (0xf9); 3009 } 3010 break; 3011 case 0x04: 3012 /* Global function */ 3013 { 3014 struct output_buffer_struct ob; 3015 NEXT (); 3016 OUT (0xf8); 3017 OUT (0x04); 3018 drop_int (&ob); 3019 ID; 3020 INTn (stack size); 3021 INTn (ret val); 3022 EXPn (offset); 3023 3024 block (); 3025 3026 NEXT (); 3027 OUT (0xf9); 3028 EXPn (size of block); 3029 fill_int (&ob); 3030 } 3031 break; 3032 3033 case 0x05: 3034 /* File name for source line numbers */ 3035 { 3036 struct output_buffer_struct ob; 3037 NEXT (); 3038 OUT (0xf8); 3039 OUT (0x05); 3040 drop_int (&ob); 3041 ID; 3042 INTn (year); 3043 INTn (month); 3044 INTn (day); 3045 INTn (hour); 3046 INTn (monute); 3047 INTn (second); 3048 block (); 3049 NEXT (); 3050 OUT (0xf9); 3051 fill_int (&ob); 3052 } 3053 break; 3054 3055 case 0x06: 3056 /* Local function */ 3057 { 3058 struct output_buffer_struct ob; 3059 NEXT (); 3060 OUT (0xf8); 3061 OUT (0x06); 3062 drop_int (&ob); 3063 ID; 3064 INTn (stack size); 3065 INTn (type return); 3066 EXPn (offset); 3067 block (); 3068 NEXT (); 3069 OUT (0xf9); 3070 EXPn (size); 3071 fill_int (&ob); 3072 } 3073 break; 3074 3075 case 0x0a: 3076 /* Assembler module scope beginning -*/ 3077 { 3078 struct output_buffer_struct ob; 3079 3080 NEXT (); 3081 OUT (0xf8); 3082 OUT (0x0a); 3083 drop_int (&ob); 3084 ID; 3085 ID; 3086 INT; 3087 ID; 3088 INT; 3089 INT; 3090 INT; 3091 INT; 3092 INT; 3093 INT; 3094 3095 block (); 3096 3097 NEXT (); 3098 OUT (0xf9); 3099 fill_int (&ob); 3100 } 3101 break; 3102 case 0x0b: 3103 { 3104 struct output_buffer_struct ob; 3105 NEXT (); 3106 OUT (0xf8); 3107 OUT (0x0b); 3108 drop_int (&ob); 3109 ID; 3110 INT; 3111 INTn (section index); 3112 EXPn (offset); 3113 INTn (stuff); 3114 3115 block (); 3116 3117 OUT (0xf9); 3118 NEXT (); 3119 EXPn (Size in Maus); 3120 fill_int (&ob); 3121 } 3122 break; 3123 } 3124} 3125 3126static void 3127e2_record () 3128{ 3129 OUT (0xe2); 3130 NEXT (); 3131 OUT (0xce); 3132 NEXT (); 3133 INT; 3134 EXP; 3135} 3136 3137static void 3138block () 3139{ 3140 int ch; 3141 while (1) 3142 { 3143 ch = THIS (); 3144 switch (ch) 3145 { 3146 case 0xe1: 3147 case 0xe5: 3148 return; 3149 case 0xf9: 3150 return; 3151 case 0xf0: 3152 f0_record (); 3153 break; 3154 case 0xf1: 3155 f1_record (); 3156 break; 3157 case 0xf2: 3158 f2_record (); 3159 break; 3160 case 0xf8: 3161 f8_record (); 3162 break; 3163 case 0xe2: 3164 e2_record (); 3165 break; 3166 3167 } 3168 } 3169} 3170 3171 3172 3173/* relocate_debug, 3174 moves all the debug information from the source bfd to the output 3175 bfd, and relocates any expressions it finds 3176*/ 3177 3178static void 3179relocate_debug (output, input) 3180 bfd *output ATTRIBUTE_UNUSED; 3181 bfd *input; 3182{ 3183#define IBS 400 3184#define OBS 400 3185 unsigned char input_buffer[IBS]; 3186 3187 input_ptr_start = input_ptr = input_buffer; 3188 input_ptr_end = input_buffer + IBS; 3189 input_bfd = input; 3190 /* FIXME: Check return value. I'm not sure whether it needs to read 3191 the entire buffer or not. */ 3192 bfd_read ((PTR) input_ptr_start, 1, IBS, input); 3193 block (); 3194} 3195 3196/* Gather together all the debug information from each input BFD into 3197 one place, relocating it and emitting it as we go. */ 3198 3199static boolean 3200ieee_write_debug_part (abfd) 3201 bfd *abfd; 3202{ 3203 ieee_data_type *ieee = IEEE_DATA (abfd); 3204 bfd_chain_type *chain = ieee->chain_root; 3205 unsigned char output_buffer[OBS]; 3206 boolean some_debug = false; 3207 file_ptr here = bfd_tell (abfd); 3208 3209 output_ptr_start = output_ptr = output_buffer; 3210 output_ptr_end = output_buffer + OBS; 3211 output_ptr = output_buffer; 3212 output_bfd = abfd; 3213 3214 if (chain == (bfd_chain_type *) NULL) 3215 { 3216 asection *s; 3217 3218 for (s = abfd->sections; s != NULL; s = s->next) 3219 if ((s->flags & SEC_DEBUGGING) != 0) 3220 break; 3221 if (s == NULL) 3222 { 3223 ieee->w.r.debug_information_part = 0; 3224 return true; 3225 } 3226 3227 ieee->w.r.debug_information_part = here; 3228 if (bfd_write (s->contents, 1, s->_raw_size, abfd) != s->_raw_size) 3229 return false; 3230 } 3231 else 3232 { 3233 while (chain != (bfd_chain_type *) NULL) 3234 { 3235 bfd *entry = chain->this; 3236 ieee_data_type *entry_ieee = IEEE_DATA (entry); 3237 if (entry_ieee->w.r.debug_information_part) 3238 { 3239 if (bfd_seek (entry, entry_ieee->w.r.debug_information_part, 3240 SEEK_SET) 3241 != 0) 3242 return false; 3243 relocate_debug (abfd, entry); 3244 } 3245 3246 chain = chain->next; 3247 } 3248 if (some_debug) 3249 { 3250 ieee->w.r.debug_information_part = here; 3251 } 3252 else 3253 { 3254 ieee->w.r.debug_information_part = 0; 3255 } 3256 3257 flush (); 3258 } 3259 3260 return true; 3261} 3262 3263/* Write the data in an ieee way. */ 3264 3265static boolean 3266ieee_write_data_part (abfd) 3267 bfd *abfd; 3268{ 3269 asection *s; 3270 ieee_data_type *ieee = IEEE_DATA (abfd); 3271 ieee->w.r.data_part = bfd_tell (abfd); 3272 for (s = abfd->sections; s != (asection *) NULL; s = s->next) 3273 { 3274 /* Skip sections that have no loadable contents (.bss, 3275 debugging, etc.) */ 3276 if ((s->flags & SEC_LOAD) == 0) 3277 continue; 3278 3279 /* Sort the reloc records so we can insert them in the correct 3280 places */ 3281 if (s->reloc_count != 0) 3282 { 3283 if (! do_with_relocs (abfd, s)) 3284 return false; 3285 } 3286 else 3287 { 3288 if (! do_without_relocs (abfd, s)) 3289 return false; 3290 } 3291 } 3292 3293 return true; 3294} 3295 3296 3297static boolean 3298init_for_output (abfd) 3299 bfd *abfd; 3300{ 3301 asection *s; 3302 for (s = abfd->sections; s != (asection *) NULL; s = s->next) 3303 { 3304 if ((s->flags & SEC_DEBUGGING) != 0) 3305 continue; 3306 if (s->_raw_size != 0) 3307 { 3308 ieee_per_section (s)->data = (bfd_byte *) (bfd_alloc (abfd, s->_raw_size)); 3309 if (!ieee_per_section (s)->data) 3310 return false; 3311 } 3312 } 3313 return true; 3314} 3315 3316/** exec and core file sections */ 3317 3318/* set section contents is complicated with IEEE since the format is 3319* not a byte image, but a record stream. 3320*/ 3321boolean 3322ieee_set_section_contents (abfd, section, location, offset, count) 3323 bfd *abfd; 3324 sec_ptr section; 3325 PTR location; 3326 file_ptr offset; 3327 bfd_size_type count; 3328{ 3329 if ((section->flags & SEC_DEBUGGING) != 0) 3330 { 3331 if (section->contents == NULL) 3332 { 3333 section->contents = ((unsigned char *) 3334 bfd_alloc (abfd, section->_raw_size)); 3335 if (section->contents == NULL) 3336 return false; 3337 } 3338 /* bfd_set_section_contents has already checked that everything 3339 is within range. */ 3340 memcpy (section->contents + offset, location, count); 3341 return true; 3342 } 3343 3344 if (ieee_per_section (section)->data == (bfd_byte *) NULL) 3345 { 3346 if (!init_for_output (abfd)) 3347 return false; 3348 } 3349 memcpy ((PTR) (ieee_per_section (section)->data + offset), 3350 (PTR) location, 3351 (unsigned int) count); 3352 return true; 3353} 3354 3355/* Write the external symbols of a file. IEEE considers two sorts of 3356 external symbols, public, and referenced. It uses to internal 3357 forms to index them as well. When we write them out we turn their 3358 symbol values into indexes from the right base. */ 3359 3360static boolean 3361ieee_write_external_part (abfd) 3362 bfd *abfd; 3363{ 3364 asymbol **q; 3365 ieee_data_type *ieee = IEEE_DATA (abfd); 3366 3367 unsigned int reference_index = IEEE_REFERENCE_BASE; 3368 unsigned int public_index = IEEE_PUBLIC_BASE + 2; 3369 file_ptr here = bfd_tell (abfd); 3370 boolean hadone = false; 3371 if (abfd->outsymbols != (asymbol **) NULL) 3372 { 3373 3374 for (q = abfd->outsymbols; *q != (asymbol *) NULL; q++) 3375 { 3376 asymbol *p = *q; 3377 if (bfd_is_und_section (p->section)) 3378 { 3379 /* This must be a symbol reference .. */ 3380 if (! ieee_write_byte (abfd, ieee_external_reference_enum) 3381 || ! ieee_write_int (abfd, reference_index) 3382 || ! ieee_write_id (abfd, p->name)) 3383 return false; 3384 p->value = reference_index; 3385 reference_index++; 3386 hadone = true; 3387 } 3388 else if (bfd_is_com_section (p->section)) 3389 { 3390 /* This is a weak reference */ 3391 if (! ieee_write_byte (abfd, ieee_external_reference_enum) 3392 || ! ieee_write_int (abfd, reference_index) 3393 || ! ieee_write_id (abfd, p->name) 3394 || ! ieee_write_byte (abfd, 3395 ieee_weak_external_reference_enum) 3396 || ! ieee_write_int (abfd, reference_index) 3397 || ! ieee_write_int (abfd, p->value)) 3398 return false; 3399 p->value = reference_index; 3400 reference_index++; 3401 hadone = true; 3402 } 3403 else if (p->flags & BSF_GLOBAL) 3404 { 3405 /* This must be a symbol definition */ 3406 3407 if (! ieee_write_byte (abfd, ieee_external_symbol_enum) 3408 || ! ieee_write_int (abfd, public_index) 3409 || ! ieee_write_id (abfd, p->name) 3410 || ! ieee_write_2bytes (abfd, ieee_attribute_record_enum) 3411 || ! ieee_write_int (abfd, public_index) 3412 || ! ieee_write_byte (abfd, 15) /* instruction address */ 3413 || ! ieee_write_byte (abfd, 19) /* static symbol */ 3414 || ! ieee_write_byte (abfd, 1)) /* one of them */ 3415 return false; 3416 3417 /* Write out the value */ 3418 if (! ieee_write_2bytes (abfd, ieee_value_record_enum) 3419 || ! ieee_write_int (abfd, public_index)) 3420 return false; 3421 if (! bfd_is_abs_section (p->section)) 3422 { 3423 if (abfd->flags & EXEC_P) 3424 { 3425 /* If fully linked, then output all symbols 3426 relocated */ 3427 if (! (ieee_write_int 3428 (abfd, 3429 (p->value 3430 + p->section->output_offset 3431 + p->section->output_section->vma)))) 3432 return false; 3433 } 3434 else 3435 { 3436 if (! (ieee_write_expression 3437 (abfd, 3438 p->value + p->section->output_offset, 3439 p->section->output_section->symbol, 3440 false, 0))) 3441 return false; 3442 } 3443 } 3444 else 3445 { 3446 if (! ieee_write_expression (abfd, 3447 p->value, 3448 bfd_abs_section_ptr->symbol, 3449 false, 0)) 3450 return false; 3451 } 3452 p->value = public_index; 3453 public_index++; 3454 hadone = true; 3455 } 3456 else 3457 { 3458 /* This can happen - when there are gaps in the symbols read */ 3459 /* from an input ieee file */ 3460 } 3461 } 3462 } 3463 if (hadone) 3464 ieee->w.r.external_part = here; 3465 3466 return true; 3467} 3468 3469 3470static CONST unsigned char exten[] = 3471{ 3472 0xf0, 0x20, 0x00, 3473 0xf1, 0xce, 0x20, 0x00, 37, 3, 3, /* Set version 3 rev 3 */ 3474 0xf1, 0xce, 0x20, 0x00, 39, 2,/* keep symbol in original case */ 3475 0xf1, 0xce, 0x20, 0x00, 38 /* set object type relocateable to x */ 3476}; 3477 3478static CONST unsigned char envi[] = 3479{ 3480 0xf0, 0x21, 0x00, 3481 3482/* 0xf1, 0xce, 0x21, 00, 50, 0x82, 0x07, 0xc7, 0x09, 0x11, 0x11, 3483 0x19, 0x2c, 3484*/ 3485 0xf1, 0xce, 0x21, 00, 52, 0x00, /* exec ok */ 3486 3487 0xf1, 0xce, 0x21, 0, 53, 0x03,/* host unix */ 3488/* 0xf1, 0xce, 0x21, 0, 54, 2,1,1 tool & version # */ 3489}; 3490 3491static boolean 3492ieee_write_me_part (abfd) 3493 bfd *abfd; 3494{ 3495 ieee_data_type *ieee = IEEE_DATA (abfd); 3496 ieee->w.r.trailer_part = bfd_tell (abfd); 3497 if (abfd->start_address) 3498 { 3499 if (! ieee_write_2bytes (abfd, ieee_value_starting_address_enum) 3500 || ! ieee_write_byte (abfd, ieee_function_either_open_b_enum) 3501 || ! ieee_write_int (abfd, abfd->start_address) 3502 || ! ieee_write_byte (abfd, ieee_function_either_close_b_enum)) 3503 return false; 3504 } 3505 ieee->w.r.me_record = bfd_tell (abfd); 3506 if (! ieee_write_byte (abfd, ieee_module_end_enum)) 3507 return false; 3508 return true; 3509} 3510 3511/* Write out the IEEE processor ID. */ 3512 3513static boolean 3514ieee_write_processor (abfd) 3515 bfd *abfd; 3516{ 3517 const bfd_arch_info_type *arch; 3518 3519 arch = bfd_get_arch_info (abfd); 3520 switch (arch->arch) 3521 { 3522 default: 3523 if (! ieee_write_id (abfd, bfd_printable_name (abfd))) 3524 return false; 3525 break; 3526 3527 case bfd_arch_a29k: 3528 if (! ieee_write_id (abfd, "29000")) 3529 return false; 3530 break; 3531 3532 case bfd_arch_h8300: 3533 if (! ieee_write_id (abfd, "H8/300")) 3534 return false; 3535 break; 3536 3537 case bfd_arch_h8500: 3538 if (! ieee_write_id (abfd, "H8/500")) 3539 return false; 3540 break; 3541 3542 case bfd_arch_i960: 3543 switch (arch->mach) 3544 { 3545 default: 3546 case bfd_mach_i960_core: 3547 case bfd_mach_i960_ka_sa: 3548 if (! ieee_write_id (abfd, "80960KA")) 3549 return false; 3550 break; 3551 3552 case bfd_mach_i960_kb_sb: 3553 if (! ieee_write_id (abfd, "80960KB")) 3554 return false; 3555 break; 3556 3557 case bfd_mach_i960_ca: 3558 if (! ieee_write_id (abfd, "80960CA")) 3559 return false; 3560 break; 3561 3562 case bfd_mach_i960_mc: 3563 case bfd_mach_i960_xa: 3564 if (! ieee_write_id (abfd, "80960MC")) 3565 return false; 3566 break; 3567 } 3568 break; 3569 3570 case bfd_arch_m68k: 3571 { 3572 const char *id; 3573 3574 switch (arch->mach) 3575 { 3576 default: id = "68020"; break; 3577 case bfd_mach_m68000: id = "68000"; break; 3578 case bfd_mach_m68008: id = "68008"; break; 3579 case bfd_mach_m68010: id = "68010"; break; 3580 case bfd_mach_m68020: id = "68020"; break; 3581 case bfd_mach_m68030: id = "68030"; break; 3582 case bfd_mach_m68040: id = "68040"; break; 3583 case bfd_mach_m68060: id = "68060"; break; 3584 case bfd_mach_cpu32: id = "cpu32"; break; 3585 case bfd_mach_mcf5200:id = "5200"; break; 3586 case bfd_mach_mcf5206e:id = "5206e"; break; 3587 case bfd_mach_mcf5307:id = "5307"; break; 3588 case bfd_mach_mcf5407:id = "5407"; break; 3589 } 3590 3591 if (! ieee_write_id (abfd, id)) 3592 return false; 3593 } 3594 break; 3595 } 3596 3597 return true; 3598} 3599 3600boolean 3601ieee_write_object_contents (abfd) 3602 bfd *abfd; 3603{ 3604 ieee_data_type *ieee = IEEE_DATA (abfd); 3605 unsigned int i; 3606 file_ptr old; 3607 3608 /* Fast forward over the header area */ 3609 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) 3610 return false; 3611 3612 if (! ieee_write_byte (abfd, ieee_module_beginning_enum) 3613 || ! ieee_write_processor (abfd) 3614 || ! ieee_write_id (abfd, abfd->filename)) 3615 return false; 3616 3617 /* Fast forward over the variable bits */ 3618 if (! ieee_write_byte (abfd, ieee_address_descriptor_enum)) 3619 return false; 3620 3621 /* Bits per MAU */ 3622 if (! ieee_write_byte (abfd, (bfd_byte) (bfd_arch_bits_per_byte (abfd)))) 3623 return false; 3624 /* MAU's per address */ 3625 if (! ieee_write_byte (abfd, 3626 (bfd_byte) (bfd_arch_bits_per_address (abfd) 3627 / bfd_arch_bits_per_byte (abfd)))) 3628 return false; 3629 3630 old = bfd_tell (abfd); 3631 if (bfd_seek (abfd, (file_ptr) (8 * N_W_VARIABLES), SEEK_CUR) != 0) 3632 return false; 3633 3634 ieee->w.r.extension_record = bfd_tell (abfd); 3635 if (bfd_write ((char *) exten, 1, sizeof (exten), abfd) != sizeof (exten)) 3636 return false; 3637 if (abfd->flags & EXEC_P) 3638 { 3639 if (! ieee_write_byte (abfd, 0x1)) /* Absolute */ 3640 return false; 3641 } 3642 else 3643 { 3644 if (! ieee_write_byte (abfd, 0x2)) /* Relocateable */ 3645 return false; 3646 } 3647 3648 ieee->w.r.environmental_record = bfd_tell (abfd); 3649 if (bfd_write ((char *) envi, 1, sizeof (envi), abfd) != sizeof (envi)) 3650 return false; 3651 3652 /* The HP emulator database requires a timestamp in the file. */ 3653 { 3654 time_t now; 3655 const struct tm *t; 3656 3657 time (&now); 3658 t = (struct tm *) localtime (&now); 3659 if (! ieee_write_2bytes (abfd, (int) ieee_atn_record_enum) 3660 || ! ieee_write_byte (abfd, 0x21) 3661 || ! ieee_write_byte (abfd, 0) 3662 || ! ieee_write_byte (abfd, 50) 3663 || ! ieee_write_int (abfd, t->tm_year + 1900) 3664 || ! ieee_write_int (abfd, t->tm_mon + 1) 3665 || ! ieee_write_int (abfd, t->tm_mday) 3666 || ! ieee_write_int (abfd, t->tm_hour) 3667 || ! ieee_write_int (abfd, t->tm_min) 3668 || ! ieee_write_int (abfd, t->tm_sec)) 3669 return false; 3670 } 3671 3672 output_bfd = abfd; 3673 3674 flush (); 3675 3676 if (! ieee_write_section_part (abfd)) 3677 return false; 3678 /* First write the symbols. This changes their values into table 3679 indeces so we cant use it after this point. */ 3680 if (! ieee_write_external_part (abfd)) 3681 return false; 3682 3683 /* ieee_write_byte(abfd, ieee_record_seperator_enum);*/ 3684 3685 /* ieee_write_byte(abfd, ieee_record_seperator_enum);*/ 3686 3687 3688 /* Write any debugs we have been told about. */ 3689 if (! ieee_write_debug_part (abfd)) 3690 return false; 3691 3692 /* Can only write the data once the symbols have been written, since 3693 the data contains relocation information which points to the 3694 symbols. */ 3695 if (! ieee_write_data_part (abfd)) 3696 return false; 3697 3698 /* At the end we put the end! */ 3699 if (! ieee_write_me_part (abfd)) 3700 return false; 3701 3702 /* Generate the header */ 3703 if (bfd_seek (abfd, old, SEEK_SET) != 0) 3704 return false; 3705 3706 for (i = 0; i < N_W_VARIABLES; i++) 3707 { 3708 if (! ieee_write_2bytes (abfd, ieee_assign_value_to_variable_enum) 3709 || ! ieee_write_byte (abfd, (bfd_byte) i) 3710 || ! ieee_write_int5_out (abfd, ieee->w.offset[i])) 3711 return false; 3712 } 3713 3714 return true; 3715} 3716 3717/* Native-level interface to symbols. */ 3718 3719/* We read the symbols into a buffer, which is discarded when this 3720 function exits. We read the strings into a buffer large enough to 3721 hold them all plus all the cached symbol entries. */ 3722 3723asymbol * 3724ieee_make_empty_symbol (abfd) 3725 bfd *abfd; 3726{ 3727 ieee_symbol_type *new = 3728 (ieee_symbol_type *) bfd_zalloc (abfd, sizeof (ieee_symbol_type)); 3729 if (!new) 3730 return NULL; 3731 new->symbol.the_bfd = abfd; 3732 return &new->symbol; 3733} 3734 3735static bfd * 3736ieee_openr_next_archived_file (arch, prev) 3737 bfd *arch; 3738 bfd *prev; 3739{ 3740 ieee_ar_data_type *ar = IEEE_AR_DATA (arch); 3741 /* take the next one from the arch state, or reset */ 3742 if (prev == (bfd *) NULL) 3743 { 3744 /* Reset the index - the first two entries are bogus*/ 3745 ar->element_index = 2; 3746 } 3747 while (true) 3748 { 3749 ieee_ar_obstack_type *p = ar->elements + ar->element_index; 3750 ar->element_index++; 3751 if (ar->element_index <= ar->element_count) 3752 { 3753 if (p->file_offset != (file_ptr) 0) 3754 { 3755 if (p->abfd == (bfd *) NULL) 3756 { 3757 p->abfd = _bfd_create_empty_archive_element_shell (arch); 3758 p->abfd->origin = p->file_offset; 3759 } 3760 return p->abfd; 3761 } 3762 } 3763 else 3764 { 3765 bfd_set_error (bfd_error_no_more_archived_files); 3766 return (bfd *) NULL; 3767 } 3768 3769 } 3770} 3771 3772static boolean 3773ieee_find_nearest_line (abfd, 3774 section, 3775 symbols, 3776 offset, 3777 filename_ptr, 3778 functionname_ptr, 3779 line_ptr) 3780 bfd *abfd ATTRIBUTE_UNUSED; 3781 asection *section ATTRIBUTE_UNUSED; 3782 asymbol **symbols ATTRIBUTE_UNUSED; 3783 bfd_vma offset ATTRIBUTE_UNUSED; 3784 const char **filename_ptr ATTRIBUTE_UNUSED; 3785 const char **functionname_ptr ATTRIBUTE_UNUSED; 3786 unsigned int *line_ptr ATTRIBUTE_UNUSED; 3787{ 3788 return false; 3789} 3790 3791static int 3792ieee_generic_stat_arch_elt (abfd, buf) 3793 bfd *abfd; 3794 struct stat *buf; 3795{ 3796 ieee_ar_data_type *ar = (ieee_ar_data_type *) NULL; 3797 ieee_data_type *ieee; 3798 3799 if (abfd->my_archive != NULL) 3800 ar = abfd->my_archive->tdata.ieee_ar_data; 3801 if (ar == (ieee_ar_data_type *) NULL) 3802 { 3803 bfd_set_error (bfd_error_invalid_operation); 3804 return -1; 3805 } 3806 3807 if (IEEE_DATA (abfd) == NULL) 3808 { 3809 if (ieee_object_p (abfd) == NULL) 3810 { 3811 bfd_set_error (bfd_error_wrong_format); 3812 return -1; 3813 } 3814 } 3815 3816 ieee = IEEE_DATA (abfd); 3817 3818 buf->st_size = ieee->w.r.me_record + 1; 3819 buf->st_mode = 0644; 3820 return 0; 3821} 3822 3823static int 3824ieee_sizeof_headers (abfd, x) 3825 bfd *abfd ATTRIBUTE_UNUSED; 3826 boolean x ATTRIBUTE_UNUSED; 3827{ 3828 return 0; 3829} 3830 3831 3832/* The debug info routines are never used. */ 3833#if 0 3834 3835static void 3836ieee_bfd_debug_info_start (abfd) 3837 bfd *abfd; 3838{ 3839 3840} 3841 3842static void 3843ieee_bfd_debug_info_end (abfd) 3844 bfd *abfd; 3845{ 3846 3847} 3848 3849 3850/* Add this section to the list of sections we have debug info for, to 3851 be ready to output it at close time 3852 */ 3853static void 3854ieee_bfd_debug_info_accumulate (abfd, section) 3855 bfd *abfd; 3856 asection *section; 3857{ 3858 ieee_data_type *ieee = IEEE_DATA (section->owner); 3859 ieee_data_type *output_ieee = IEEE_DATA (abfd); 3860 /* can only accumulate data from other ieee bfds */ 3861 if (section->owner->xvec != abfd->xvec) 3862 return; 3863 /* Only bother once per bfd */ 3864 if (ieee->done_debug == true) 3865 return; 3866 ieee->done_debug = true; 3867 3868 /* Don't bother if there is no debug info */ 3869 if (ieee->w.r.debug_information_part == 0) 3870 return; 3871 3872 3873 /* Add to chain */ 3874 { 3875 bfd_chain_type *n = (bfd_chain_type *) bfd_alloc (abfd, sizeof (bfd_chain_type)); 3876 if (!n) 3877 abort (); /* FIXME */ 3878 n->this = section->owner; 3879 n->next = (bfd_chain_type *) NULL; 3880 3881 if (output_ieee->chain_head) 3882 { 3883 output_ieee->chain_head->next = n; 3884 } 3885 else 3886 { 3887 output_ieee->chain_root = n; 3888 3889 } 3890 output_ieee->chain_head = n; 3891 } 3892} 3893 3894#endif 3895 3896#define ieee_close_and_cleanup _bfd_generic_close_and_cleanup 3897#define ieee_bfd_free_cached_info _bfd_generic_bfd_free_cached_info 3898 3899#define ieee_slurp_armap bfd_true 3900#define ieee_slurp_extended_name_table bfd_true 3901#define ieee_construct_extended_name_table \ 3902 ((boolean (*) PARAMS ((bfd *, char **, bfd_size_type *, const char **))) \ 3903 bfd_true) 3904#define ieee_truncate_arname bfd_dont_truncate_arname 3905#define ieee_write_armap \ 3906 ((boolean (*) \ 3907 PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int))) \ 3908 bfd_true) 3909#define ieee_read_ar_hdr bfd_nullvoidptr 3910#define ieee_update_armap_timestamp bfd_true 3911#define ieee_get_elt_at_index _bfd_generic_get_elt_at_index 3912 3913#define ieee_bfd_is_local_label_name bfd_generic_is_local_label_name 3914#define ieee_get_lineno _bfd_nosymbols_get_lineno 3915#define ieee_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol 3916#define ieee_read_minisymbols _bfd_generic_read_minisymbols 3917#define ieee_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol 3918 3919#define ieee_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup 3920 3921#define ieee_set_arch_mach _bfd_generic_set_arch_mach 3922 3923#define ieee_get_section_contents_in_window \ 3924 _bfd_generic_get_section_contents_in_window 3925#define ieee_bfd_get_relocated_section_contents \ 3926 bfd_generic_get_relocated_section_contents 3927#define ieee_bfd_relax_section bfd_generic_relax_section 3928#define ieee_bfd_gc_sections bfd_generic_gc_sections 3929#define ieee_bfd_link_hash_table_create _bfd_generic_link_hash_table_create 3930#define ieee_bfd_link_add_symbols _bfd_generic_link_add_symbols 3931#define ieee_bfd_final_link _bfd_generic_final_link 3932#define ieee_bfd_link_split_section _bfd_generic_link_split_section 3933 3934/*SUPPRESS 460 */ 3935const bfd_target ieee_vec = 3936{ 3937 "ieee", /* name */ 3938 bfd_target_ieee_flavour, 3939 BFD_ENDIAN_UNKNOWN, /* target byte order */ 3940 BFD_ENDIAN_UNKNOWN, /* target headers byte order */ 3941 (HAS_RELOC | EXEC_P | /* object flags */ 3942 HAS_LINENO | HAS_DEBUG | 3943 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED), 3944 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS 3945 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */ 3946 '_', /* leading underscore */ 3947 ' ', /* ar_pad_char */ 3948 16, /* ar_max_namelen */ 3949 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 3950 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 3951 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */ 3952 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 3953 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 3954 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */ 3955 3956 {_bfd_dummy_target, 3957 ieee_object_p, /* bfd_check_format */ 3958 ieee_archive_p, 3959 _bfd_dummy_target, 3960 }, 3961 { 3962 bfd_false, 3963 ieee_mkobject, 3964 _bfd_generic_mkarchive, 3965 bfd_false 3966 }, 3967 { 3968 bfd_false, 3969 ieee_write_object_contents, 3970 _bfd_write_archive_contents, 3971 bfd_false, 3972 }, 3973 3974 BFD_JUMP_TABLE_GENERIC (ieee), 3975 BFD_JUMP_TABLE_COPY (_bfd_generic), 3976 BFD_JUMP_TABLE_CORE (_bfd_nocore), 3977 BFD_JUMP_TABLE_ARCHIVE (ieee), 3978 BFD_JUMP_TABLE_SYMBOLS (ieee), 3979 BFD_JUMP_TABLE_RELOCS (ieee), 3980 BFD_JUMP_TABLE_WRITE (ieee), 3981 BFD_JUMP_TABLE_LINK (ieee), 3982 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 3983 3984 NULL, 3985 3986 (PTR) 0 3987}; 3988