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