1 /* BFD back-end for PDP-11 a.out binaries. 2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011 3 Free Software Foundation, Inc. 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 20 MA 02110-1301, USA. */ 21 22 23 /* BFD backend for PDP-11, running 2.11BSD in particular. 24 25 This file was hacked up by looking hard at the existing vaxnetbsd 26 back end and the header files in 2.11BSD. 27 28 TODO 29 * support for V7 file formats 30 * support for overlay object files (see 2.11 a.out(5)) 31 * support for old and very old archives 32 (see 2.11 ar(5), historical section) 33 34 Search for TODO to find other areas needing more work. */ 35 36 #define BYTES_IN_WORD 2 37 #define BYTES_IN_LONG 4 38 #define ARCH_SIZE 16 39 #undef TARGET_IS_BIG_ENDIAN_P 40 41 #define TARGET_PAGE_SIZE 1024 42 #define SEGMENT__SIZE TARGET_PAGE_SIZE 43 44 #define DEFAULT_ARCH bfd_arch_pdp11 45 #define DEFAULT_MID M_PDP11 46 47 /* Do not "beautify" the CONCAT* macro args. Traditional C will not 48 remove whitespace added here, and thus will fail to concatenate 49 the tokens. */ 50 #define MY(OP) CONCAT2 (pdp11_aout_,OP) 51 52 /* This needs to start with a.out so GDB knows it is an a.out variant. */ 53 #define TARGETNAME "a.out-pdp11" 54 55 /* This is the normal load address for executables. */ 56 #define TEXT_START_ADDR 0 57 58 /* The header is not included in the text segment. */ 59 #define N_HEADER_IN_TEXT(x) 0 60 61 /* There is no flags field. */ 62 #define N_FLAGS(exec) 0 63 64 #define N_SET_FLAGS(exec, flags) do { } while (0) 65 #define N_BADMAG(x) (N_MAGIC(x) != OMAGIC \ 66 && N_MAGIC(x) != NMAGIC \ 67 && N_MAGIC(x) != ZMAGIC) 68 69 #include "sysdep.h" 70 #include "bfd.h" 71 72 #define external_exec pdp11_external_exec 73 struct pdp11_external_exec 74 { 75 bfd_byte e_info[2]; /* Magic number. */ 76 bfd_byte e_text[2]; /* Length of text section in bytes. */ 77 bfd_byte e_data[2]; /* Length of data section in bytes. */ 78 bfd_byte e_bss[2]; /* Length of bss area in bytes. */ 79 bfd_byte e_syms[2]; /* Length of symbol table in bytes. */ 80 bfd_byte e_entry[2]; /* Start address. */ 81 bfd_byte e_unused[2]; /* Not used. */ 82 bfd_byte e_flag[2]; /* Relocation info stripped. */ 83 bfd_byte e_relocatable; /* Ugly hack. */ 84 }; 85 86 #define EXEC_BYTES_SIZE (8 * 2) 87 88 #define A_MAGIC1 OMAGIC 89 #define OMAGIC 0407 /* ...object file or impure executable. */ 90 #define A_MAGIC2 NMAGIC 91 #define NMAGIC 0410 /* Pure executable. */ 92 #define ZMAGIC 0413 /* Demand-paged executable. */ 93 #define A_MAGIC3 0411 /* Separated I&D. */ 94 #define A_MAGIC4 0405 /* Overlay. */ 95 #define A_MAGIC5 0430 /* Auto-overlay (nonseparate). */ 96 #define A_MAGIC6 0431 /* Auto-overlay (separate). */ 97 #define QMAGIC 0 98 #define BMAGIC 0 99 100 #define A_FLAG_RELOC_STRIPPED 0x0001 101 102 #define external_nlist pdp11_external_nlist 103 struct pdp11_external_nlist 104 { 105 bfd_byte e_unused[2]; /* Unused. */ 106 bfd_byte e_strx[2]; /* Index into string table of name. */ 107 bfd_byte e_type[1]; /* Type of symbol. */ 108 bfd_byte e_ovly[1]; /* Overlay number. */ 109 bfd_byte e_value[2]; /* Value of symbol. */ 110 }; 111 112 #define EXTERNAL_NLIST_SIZE 8 113 114 #define N_TXTOFF(x) (EXEC_BYTES_SIZE) 115 #define N_DATOFF(x) (N_TXTOFF(x) + (x).a_text) 116 #define N_TRELOFF(x) (N_DATOFF(x) + (x).a_data) 117 #define N_DRELOFF(x) (N_TRELOFF(x) + (x).a_trsize) 118 #define N_SYMOFF(x) (N_DRELOFF(x) + (x).a_drsize) 119 #define N_STROFF(x) (N_SYMOFF(x) + (x).a_syms) 120 121 #define WRITE_HEADERS(abfd, execp) pdp11_aout_write_headers (abfd, execp) 122 123 #include "libbfd.h" 124 #include "libaout.h" 125 126 #define SWAP_MAGIC(ext) bfd_getl16 (ext) 127 128 #define MY_entry_is_text_address 1 129 130 #define MY_write_object_contents MY(write_object_contents) 131 static bfd_boolean MY(write_object_contents) (bfd *); 132 #define MY_text_includes_header 1 133 134 #define MY_BFD_TARGET 135 136 #include "aout-target.h" 137 138 /* Start of modified aoutx.h. */ 139 #define KEEPIT udata.i 140 141 #include <string.h> /* For strchr and friends. */ 142 #include "bfd.h" 143 #include "sysdep.h" 144 #include "safe-ctype.h" 145 #include "bfdlink.h" 146 147 #include "libaout.h" 148 #include "aout/aout64.h" 149 #include "aout/stab_gnu.h" 150 #include "aout/ar.h" 151 152 #undef N_TYPE 153 #undef N_UNDF 154 #undef N_ABS 155 #undef N_TEXT 156 #undef N_DATA 157 #undef N_BSS 158 #undef N_REG 159 #undef N_FN 160 #undef N_EXT 161 #define N_TYPE 0x1f /* Type mask. */ 162 #define N_UNDF 0x00 /* Undefined. */ 163 #define N_ABS 0x01 /* Absolute. */ 164 #define N_TEXT 0x02 /* Text segment. */ 165 #define N_DATA 0x03 /* Data segment. */ 166 #define N_BSS 0x04 /* Bss segment. */ 167 #define N_REG 0x14 /* Register symbol. */ 168 #define N_FN 0x1f /* File name. */ 169 #define N_EXT 0x20 /* External flag. */ 170 171 #define RELOC_SIZE 2 172 173 #define RELFLG 0x0001 /* PC-relative flag. */ 174 #define RTYPE 0x000e /* Type mask. */ 175 #define RIDXMASK 0xfff0 /* Index mask. */ 176 177 #define RABS 0x00 /* Absolute. */ 178 #define RTEXT 0x02 /* Text. */ 179 #define RDATA 0x04 /* Data. */ 180 #define RBSS 0x06 /* Bss. */ 181 #define REXT 0x08 /* External. */ 182 183 #define RINDEX(x) (((x) & 0xfff0) >> 4) 184 185 #ifndef MY_final_link_relocate 186 #define MY_final_link_relocate _bfd_final_link_relocate 187 #endif 188 189 #ifndef MY_relocate_contents 190 #define MY_relocate_contents _bfd_relocate_contents 191 #endif 192 193 /* A hash table used for header files with N_BINCL entries. */ 194 195 struct aout_link_includes_table 196 { 197 struct bfd_hash_table root; 198 }; 199 200 /* A linked list of totals that we have found for a particular header 201 file. */ 202 203 struct aout_link_includes_totals 204 { 205 struct aout_link_includes_totals *next; 206 bfd_vma total; 207 }; 208 209 /* An entry in the header file hash table. */ 210 211 struct aout_link_includes_entry 212 { 213 struct bfd_hash_entry root; 214 /* List of totals we have found for this file. */ 215 struct aout_link_includes_totals *totals; 216 }; 217 218 /* During the final link step we need to pass around a bunch of 219 information, so we do it in an instance of this structure. */ 220 221 struct aout_final_link_info 222 { 223 /* General link information. */ 224 struct bfd_link_info *info; 225 /* Output bfd. */ 226 bfd *output_bfd; 227 /* Reloc file positions. */ 228 file_ptr treloff, dreloff; 229 /* File position of symbols. */ 230 file_ptr symoff; 231 /* String table. */ 232 struct bfd_strtab_hash *strtab; 233 /* Header file hash table. */ 234 struct aout_link_includes_table includes; 235 /* A buffer large enough to hold the contents of any section. */ 236 bfd_byte *contents; 237 /* A buffer large enough to hold the relocs of any section. */ 238 void * relocs; 239 /* A buffer large enough to hold the symbol map of any input BFD. */ 240 int *symbol_map; 241 /* A buffer large enough to hold output symbols of any input BFD. */ 242 struct external_nlist *output_syms; 243 }; 244 245 reloc_howto_type howto_table_pdp11[] = 246 { 247 /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */ 248 HOWTO( 0, 0, 1, 16, FALSE, 0, complain_overflow_signed,0,"16", TRUE, 0x0000ffff,0x0000ffff, FALSE), 249 HOWTO( 1, 0, 1, 16, TRUE, 0, complain_overflow_signed,0,"DISP16", TRUE, 0x0000ffff,0x0000ffff, FALSE), 250 }; 251 252 #define TABLE_SIZE(TABLE) (sizeof(TABLE)/sizeof(TABLE[0])) 253 254 255 static bfd_boolean aout_link_check_archive_element (bfd *, struct bfd_link_info *, bfd_boolean *); 256 static bfd_boolean aout_link_add_object_symbols (bfd *, struct bfd_link_info *); 257 static bfd_boolean aout_link_add_symbols (bfd *, struct bfd_link_info *); 258 static bfd_boolean aout_link_write_symbols (struct aout_final_link_info *, bfd *); 259 260 261 reloc_howto_type * 262 NAME (aout, reloc_type_lookup) (bfd * abfd ATTRIBUTE_UNUSED, 263 bfd_reloc_code_real_type code) 264 { 265 switch (code) 266 { 267 case BFD_RELOC_16: 268 return &howto_table_pdp11[0]; 269 case BFD_RELOC_16_PCREL: 270 return &howto_table_pdp11[1]; 271 default: 272 return NULL; 273 } 274 } 275 276 reloc_howto_type * 277 NAME (aout, reloc_name_lookup) (bfd *abfd ATTRIBUTE_UNUSED, 278 const char *r_name) 279 { 280 unsigned int i; 281 282 for (i = 0; 283 i < sizeof (howto_table_pdp11) / sizeof (howto_table_pdp11[0]); 284 i++) 285 if (howto_table_pdp11[i].name != NULL 286 && strcasecmp (howto_table_pdp11[i].name, r_name) == 0) 287 return &howto_table_pdp11[i]; 288 289 return NULL; 290 } 291 292 static int 293 pdp11_aout_write_headers (bfd *abfd, struct internal_exec *execp) 294 { 295 struct external_exec exec_bytes; 296 bfd_size_type text_size; 297 file_ptr text_end; 298 299 if (adata(abfd).magic == undecided_magic) 300 NAME (aout, adjust_sizes_and_vmas) (abfd, &text_size, &text_end); 301 302 execp->a_syms = bfd_get_symcount (abfd) * EXTERNAL_NLIST_SIZE; 303 execp->a_entry = bfd_get_start_address (abfd); 304 305 if (obj_textsec (abfd)->reloc_count > 0 306 || obj_datasec (abfd)->reloc_count > 0) 307 { 308 execp->a_trsize = execp->a_text; 309 execp->a_drsize = execp->a_data; 310 } 311 else 312 { 313 execp->a_trsize = 0; 314 execp->a_drsize = 0; 315 } 316 317 NAME (aout, swap_exec_header_out) (abfd, execp, & exec_bytes); 318 319 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) 320 return FALSE; 321 322 if (bfd_bwrite ((void *) &exec_bytes, (bfd_size_type) EXEC_BYTES_SIZE, abfd) 323 != EXEC_BYTES_SIZE) 324 return FALSE; 325 326 /* Now write out reloc info, followed by syms and strings. */ 327 if (bfd_get_outsymbols (abfd) != NULL 328 && bfd_get_symcount (abfd) != 0) 329 { 330 if (bfd_seek (abfd, (file_ptr) (N_SYMOFF(*execp)), SEEK_SET) != 0) 331 return FALSE; 332 333 if (! NAME (aout, write_syms) (abfd)) 334 return FALSE; 335 } 336 337 if (obj_textsec (abfd)->reloc_count > 0 338 || obj_datasec (abfd)->reloc_count > 0) 339 { 340 if (bfd_seek (abfd, (file_ptr) (N_TRELOFF(*execp)), SEEK_SET) != 0 341 || !NAME (aout, squirt_out_relocs) (abfd, obj_textsec (abfd)) 342 || bfd_seek (abfd, (file_ptr) (N_DRELOFF(*execp)), SEEK_SET) != 0 343 || !NAME (aout, squirt_out_relocs) (abfd, obj_datasec (abfd))) 344 return FALSE; 345 } 346 347 return TRUE; 348 } 349 350 /* Write an object file. 351 Section contents have already been written. We write the 352 file header, symbols, and relocation. */ 353 354 static bfd_boolean 355 MY(write_object_contents) (bfd *abfd) 356 { 357 struct internal_exec *execp = exec_hdr (abfd); 358 359 /* We must make certain that the magic number has been set. This 360 will normally have been done by set_section_contents, but only if 361 there actually are some section contents. */ 362 if (! abfd->output_has_begun) 363 { 364 bfd_size_type text_size; 365 file_ptr text_end; 366 367 NAME (aout, adjust_sizes_and_vmas) (abfd, &text_size, &text_end); 368 } 369 370 obj_reloc_entry_size (abfd) = RELOC_SIZE; 371 372 return WRITE_HEADERS (abfd, execp); 373 } 374 375 /* Swap the information in an executable header @var{raw_bytes} taken 376 from a raw byte stream memory image into the internal exec header 377 structure "execp". */ 378 379 #ifndef NAME_swap_exec_header_in 380 void 381 NAME (aout, swap_exec_header_in) (bfd *abfd, 382 struct external_exec *bytes, 383 struct internal_exec *execp) 384 { 385 /* The internal_exec structure has some fields that are unused in this 386 configuration (IE for i960), so ensure that all such uninitialized 387 fields are zero'd out. There are places where two of these structs 388 are memcmp'd, and thus the contents do matter. */ 389 memset ((void *) execp, 0, sizeof (struct internal_exec)); 390 /* Now fill in fields in the execp, from the bytes in the raw data. */ 391 execp->a_info = GET_MAGIC (abfd, bytes->e_info); 392 execp->a_text = GET_WORD (abfd, bytes->e_text); 393 execp->a_data = GET_WORD (abfd, bytes->e_data); 394 execp->a_bss = GET_WORD (abfd, bytes->e_bss); 395 execp->a_syms = GET_WORD (abfd, bytes->e_syms); 396 execp->a_entry = GET_WORD (abfd, bytes->e_entry); 397 398 if (GET_WORD (abfd, bytes->e_flag) & A_FLAG_RELOC_STRIPPED) 399 { 400 execp->a_trsize = 0; 401 execp->a_drsize = 0; 402 } 403 else 404 { 405 execp->a_trsize = execp->a_text; 406 execp->a_drsize = execp->a_data; 407 } 408 } 409 #define NAME_swap_exec_header_in NAME (aout, swap_exec_header_in) 410 #endif 411 412 /* Swap the information in an internal exec header structure 413 "execp" into the buffer "bytes" ready for writing to disk. */ 414 void 415 NAME (aout, swap_exec_header_out) (bfd *abfd, 416 struct internal_exec *execp, 417 struct external_exec *bytes) 418 { 419 /* Now fill in fields in the raw data, from the fields in the exec struct. */ 420 PUT_MAGIC (abfd, execp->a_info, bytes->e_info); 421 PUT_WORD (abfd, execp->a_text, bytes->e_text); 422 PUT_WORD (abfd, execp->a_data, bytes->e_data); 423 PUT_WORD (abfd, execp->a_bss, bytes->e_bss); 424 PUT_WORD (abfd, execp->a_syms, bytes->e_syms); 425 PUT_WORD (abfd, execp->a_entry, bytes->e_entry); 426 PUT_WORD (abfd, 0, bytes->e_unused); 427 428 if ((execp->a_trsize == 0 || execp->a_text == 0) 429 && (execp->a_drsize == 0 || execp->a_data == 0)) 430 PUT_WORD (abfd, A_FLAG_RELOC_STRIPPED, bytes->e_flag); 431 else if (execp->a_trsize == execp->a_text 432 && execp->a_drsize == execp->a_data) 433 PUT_WORD (abfd, 0, bytes->e_flag); 434 else 435 { 436 /* TODO: print a proper warning message. */ 437 fprintf (stderr, "BFD:%s:%d: internal error\n", __FILE__, __LINE__); 438 PUT_WORD (abfd, 0, bytes->e_flag); 439 } 440 } 441 442 /* Make all the section for an a.out file. */ 443 444 bfd_boolean 445 NAME (aout, make_sections) (bfd *abfd) 446 { 447 if (obj_textsec (abfd) == NULL && bfd_make_section (abfd, ".text") == NULL) 448 return FALSE; 449 if (obj_datasec (abfd) == NULL && bfd_make_section (abfd, ".data") == NULL) 450 return FALSE; 451 if (obj_bsssec (abfd) == NULL && bfd_make_section (abfd, ".bss") == NULL) 452 return FALSE; 453 return TRUE; 454 } 455 456 /* Some a.out variant thinks that the file open in ABFD 457 checking is an a.out file. Do some more checking, and set up 458 for access if it really is. Call back to the calling 459 environment's "finish up" function just before returning, to 460 handle any last-minute setup. */ 461 462 const bfd_target * 463 NAME (aout, some_aout_object_p) (bfd *abfd, 464 struct internal_exec *execp, 465 const bfd_target *(*callback_to_real_object_p) (bfd *)) 466 { 467 struct aout_data_struct *rawptr, *oldrawptr; 468 const bfd_target *result; 469 bfd_size_type amt = sizeof (struct aout_data_struct); 470 471 rawptr = bfd_zalloc (abfd, amt); 472 if (rawptr == NULL) 473 return 0; 474 475 oldrawptr = abfd->tdata.aout_data; 476 abfd->tdata.aout_data = rawptr; 477 478 /* Copy the contents of the old tdata struct. 479 In particular, we want the subformat, since for hpux it was set in 480 hp300hpux.c:swap_exec_header_in and will be used in 481 hp300hpux.c:callback. */ 482 if (oldrawptr != NULL) 483 *abfd->tdata.aout_data = *oldrawptr; 484 485 abfd->tdata.aout_data->a.hdr = &rawptr->e; 486 *(abfd->tdata.aout_data->a.hdr) = *execp; /* Copy in the internal_exec struct. */ 487 execp = abfd->tdata.aout_data->a.hdr; 488 489 /* Set the file flags. */ 490 abfd->flags = BFD_NO_FLAGS; 491 if (execp->a_drsize || execp->a_trsize) 492 abfd->flags |= HAS_RELOC; 493 /* Setting of EXEC_P has been deferred to the bottom of this function. */ 494 if (execp->a_syms) 495 abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS; 496 if (N_DYNAMIC(*execp)) 497 abfd->flags |= DYNAMIC; 498 499 if (N_MAGIC (*execp) == ZMAGIC) 500 { 501 abfd->flags |= D_PAGED | WP_TEXT; 502 adata (abfd).magic = z_magic; 503 } 504 else if (N_MAGIC (*execp) == NMAGIC) 505 { 506 abfd->flags |= WP_TEXT; 507 adata (abfd).magic = n_magic; 508 } 509 else if (N_MAGIC (*execp) == OMAGIC) 510 adata (abfd).magic = o_magic; 511 else 512 { 513 /* Should have been checked with N_BADMAG before this routine 514 was called. */ 515 abort (); 516 } 517 518 bfd_get_start_address (abfd) = execp->a_entry; 519 520 obj_aout_symbols (abfd) = NULL; 521 bfd_get_symcount (abfd) = execp->a_syms / sizeof (struct external_nlist); 522 523 /* The default relocation entry size is that of traditional V7 Unix. */ 524 obj_reloc_entry_size (abfd) = RELOC_SIZE; 525 526 /* The default symbol entry size is that of traditional Unix. */ 527 obj_symbol_entry_size (abfd) = EXTERNAL_NLIST_SIZE; 528 529 #ifdef USE_MMAP 530 bfd_init_window (&obj_aout_sym_window (abfd)); 531 bfd_init_window (&obj_aout_string_window (abfd)); 532 #endif 533 534 obj_aout_external_syms (abfd) = NULL; 535 obj_aout_external_strings (abfd) = NULL; 536 obj_aout_sym_hashes (abfd) = NULL; 537 538 if (! NAME (aout, make_sections) (abfd)) 539 return NULL; 540 541 obj_datasec (abfd)->size = execp->a_data; 542 obj_bsssec (abfd)->size = execp->a_bss; 543 544 obj_textsec (abfd)->flags = 545 (execp->a_trsize != 0 546 ? (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_RELOC) 547 : (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS)); 548 obj_datasec (abfd)->flags = 549 (execp->a_drsize != 0 550 ? (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS | SEC_RELOC) 551 : (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS)); 552 obj_bsssec (abfd)->flags = SEC_ALLOC; 553 554 #ifdef THIS_IS_ONLY_DOCUMENTATION 555 /* The common code can't fill in these things because they depend 556 on either the start address of the text segment, the rounding 557 up of virtual addresses between segments, or the starting file 558 position of the text segment -- all of which varies among different 559 versions of a.out. */ 560 561 /* Call back to the format-dependent code to fill in the rest of the 562 fields and do any further cleanup. Things that should be filled 563 in by the callback: */ 564 struct exec *execp = exec_hdr (abfd); 565 566 obj_textsec (abfd)->size = N_TXTSIZE(*execp); 567 /* Data and bss are already filled in since they're so standard. */ 568 569 /* The virtual memory addresses of the sections. */ 570 obj_textsec (abfd)->vma = N_TXTADDR(*execp); 571 obj_datasec (abfd)->vma = N_DATADDR(*execp); 572 obj_bsssec (abfd)->vma = N_BSSADDR(*execp); 573 574 /* The file offsets of the sections. */ 575 obj_textsec (abfd)->filepos = N_TXTOFF(*execp); 576 obj_datasec (abfd)->filepos = N_DATOFF(*execp); 577 578 /* The file offsets of the relocation info. */ 579 obj_textsec (abfd)->rel_filepos = N_TRELOFF(*execp); 580 obj_datasec (abfd)->rel_filepos = N_DRELOFF(*execp); 581 582 /* The file offsets of the string table and symbol table. */ 583 obj_str_filepos (abfd) = N_STROFF (*execp); 584 obj_sym_filepos (abfd) = N_SYMOFF (*execp); 585 586 /* Determine the architecture and machine type of the object file. */ 587 abfd->obj_arch = bfd_arch_obscure; 588 589 adata(abfd)->page_size = TARGET_PAGE_SIZE; 590 adata(abfd)->segment_size = SEGMENT_SIZE; 591 adata(abfd)->exec_bytes_size = EXEC_BYTES_SIZE; 592 593 return abfd->xvec; 594 595 /* The architecture is encoded in various ways in various a.out variants, 596 or is not encoded at all in some of them. The relocation size depends 597 on the architecture and the a.out variant. Finally, the return value 598 is the bfd_target vector in use. If an error occurs, return zero and 599 set bfd_error to the appropriate error code. 600 601 Formats such as b.out, which have additional fields in the a.out 602 header, should cope with them in this callback as well. */ 603 #endif /* DOCUMENTATION */ 604 605 result = (*callback_to_real_object_p)(abfd); 606 607 /* Now that the segment addresses have been worked out, take a better 608 guess at whether the file is executable. If the entry point 609 is within the text segment, assume it is. (This makes files 610 executable even if their entry point address is 0, as long as 611 their text starts at zero.). 612 613 This test had to be changed to deal with systems where the text segment 614 runs at a different location than the default. The problem is that the 615 entry address can appear to be outside the text segment, thus causing an 616 erroneous conclusion that the file isn't executable. 617 618 To fix this, we now accept any non-zero entry point as an indication of 619 executability. This will work most of the time, since only the linker 620 sets the entry point, and that is likely to be non-zero for most systems. */ 621 622 if (execp->a_entry != 0 623 || (execp->a_entry >= obj_textsec(abfd)->vma 624 && execp->a_entry < obj_textsec(abfd)->vma + obj_textsec(abfd)->size)) 625 abfd->flags |= EXEC_P; 626 #ifdef STAT_FOR_EXEC 627 else 628 { 629 struct stat stat_buf; 630 631 /* The original heuristic doesn't work in some important cases. 632 The a.out file has no information about the text start 633 address. For files (like kernels) linked to non-standard 634 addresses (ld -Ttext nnn) the entry point may not be between 635 the default text start (obj_textsec(abfd)->vma) and 636 (obj_textsec(abfd)->vma) + text size. This is not just a mach 637 issue. Many kernels are loaded at non standard addresses. */ 638 if (abfd->iostream != NULL 639 && (abfd->flags & BFD_IN_MEMORY) == 0 640 && (fstat(fileno((FILE *) (abfd->iostream)), &stat_buf) == 0) 641 && ((stat_buf.st_mode & 0111) != 0)) 642 abfd->flags |= EXEC_P; 643 } 644 #endif /* STAT_FOR_EXEC */ 645 646 if (!result) 647 { 648 free (rawptr); 649 abfd->tdata.aout_data = oldrawptr; 650 } 651 return result; 652 } 653 654 /* Initialize ABFD for use with a.out files. */ 655 656 bfd_boolean 657 NAME (aout, mkobject) (bfd *abfd) 658 { 659 struct aout_data_struct *rawptr; 660 bfd_size_type amt = sizeof (struct aout_data_struct); 661 662 bfd_set_error (bfd_error_system_call); 663 664 /* Use an intermediate variable for clarity. */ 665 rawptr = bfd_zalloc (abfd, amt); 666 667 if (rawptr == NULL) 668 return FALSE; 669 670 abfd->tdata.aout_data = rawptr; 671 exec_hdr (abfd) = &(rawptr->e); 672 673 obj_textsec (abfd) = NULL; 674 obj_datasec (abfd) = NULL; 675 obj_bsssec (abfd) = NULL; 676 677 return TRUE; 678 } 679 680 /* Keep track of machine architecture and machine type for 681 a.out's. Return the <<machine_type>> for a particular 682 architecture and machine, or <<M_UNKNOWN>> if that exact architecture 683 and machine can't be represented in a.out format. 684 685 If the architecture is understood, machine type 0 (default) 686 is always understood. */ 687 688 enum machine_type 689 NAME (aout, machine_type) (enum bfd_architecture arch, 690 unsigned long machine, 691 bfd_boolean *unknown) 692 { 693 enum machine_type arch_flags; 694 695 arch_flags = M_UNKNOWN; 696 *unknown = TRUE; 697 698 switch (arch) 699 { 700 case bfd_arch_sparc: 701 if (machine == 0 702 || machine == bfd_mach_sparc 703 || machine == bfd_mach_sparc_sparclite 704 || machine == bfd_mach_sparc_v9) 705 arch_flags = M_SPARC; 706 else if (machine == bfd_mach_sparc_sparclet) 707 arch_flags = M_SPARCLET; 708 break; 709 710 case bfd_arch_m68k: 711 switch (machine) 712 { 713 case 0: arch_flags = M_68010; break; 714 case bfd_mach_m68000: arch_flags = M_UNKNOWN; *unknown = FALSE; break; 715 case bfd_mach_m68010: arch_flags = M_68010; break; 716 case bfd_mach_m68020: arch_flags = M_68020; break; 717 default: arch_flags = M_UNKNOWN; break; 718 } 719 break; 720 721 case bfd_arch_i386: 722 if (machine == 0 723 || machine == bfd_mach_i386_i386 724 || machine == bfd_mach_i386_i386_intel_syntax) 725 arch_flags = M_386; 726 break; 727 728 case bfd_arch_arm: 729 if (machine == 0) arch_flags = M_ARM; 730 break; 731 732 case bfd_arch_mips: 733 switch (machine) 734 { 735 case 0: 736 case 2000: 737 case bfd_mach_mips3000: 738 arch_flags = M_MIPS1; 739 break; 740 case bfd_mach_mips4000: /* MIPS3 */ 741 case bfd_mach_mips4400: 742 case bfd_mach_mips8000: /* MIPS4 */ 743 case bfd_mach_mips6000: /* Real MIPS2: */ 744 arch_flags = M_MIPS2; 745 break; 746 default: 747 arch_flags = M_UNKNOWN; 748 break; 749 } 750 break; 751 752 case bfd_arch_ns32k: 753 switch (machine) 754 { 755 case 0: arch_flags = M_NS32532; break; 756 case 32032: arch_flags = M_NS32032; break; 757 case 32532: arch_flags = M_NS32532; break; 758 default: arch_flags = M_UNKNOWN; break; 759 } 760 break; 761 762 case bfd_arch_pdp11: 763 /* TODO: arch_flags = M_PDP11; */ 764 *unknown = FALSE; 765 break; 766 767 case bfd_arch_vax: 768 *unknown = FALSE; 769 break; 770 771 default: 772 arch_flags = M_UNKNOWN; 773 } 774 775 if (arch_flags != M_UNKNOWN) 776 *unknown = FALSE; 777 778 return arch_flags; 779 } 780 781 /* Set the architecture and the machine of the ABFD to the 782 values ARCH and MACHINE. Verify that @ABFD's format 783 can support the architecture required. */ 784 785 bfd_boolean 786 NAME (aout, set_arch_mach) (bfd *abfd, 787 enum bfd_architecture arch, 788 unsigned long machine) 789 { 790 if (! bfd_default_set_arch_mach (abfd, arch, machine)) 791 return FALSE; 792 793 if (arch != bfd_arch_unknown) 794 { 795 bfd_boolean unknown; 796 797 NAME (aout, machine_type) (arch, machine, &unknown); 798 if (unknown) 799 return FALSE; 800 } 801 802 obj_reloc_entry_size (abfd) = RELOC_SIZE; 803 804 return (*aout_backend_info(abfd)->set_sizes) (abfd); 805 } 806 807 static void 808 adjust_o_magic (bfd *abfd, struct internal_exec *execp) 809 { 810 file_ptr pos = adata (abfd).exec_bytes_size; 811 bfd_vma vma = 0; 812 int pad = 0; 813 814 /* Text. */ 815 obj_textsec (abfd)->filepos = pos; 816 if (! obj_textsec (abfd)->user_set_vma) 817 obj_textsec (abfd)->vma = vma; 818 else 819 vma = obj_textsec (abfd)->vma; 820 821 pos += obj_textsec (abfd)->size; 822 vma += obj_textsec (abfd)->size; 823 824 /* Data. */ 825 if (!obj_datasec (abfd)->user_set_vma) 826 { 827 obj_textsec (abfd)->size += pad; 828 pos += pad; 829 vma += pad; 830 obj_datasec (abfd)->vma = vma; 831 } 832 else 833 vma = obj_datasec (abfd)->vma; 834 obj_datasec (abfd)->filepos = pos; 835 pos += obj_datasec (abfd)->size; 836 vma += obj_datasec (abfd)->size; 837 838 /* BSS. */ 839 if (! obj_bsssec (abfd)->user_set_vma) 840 { 841 obj_datasec (abfd)->size += pad; 842 pos += pad; 843 vma += pad; 844 obj_bsssec (abfd)->vma = vma; 845 } 846 else 847 { 848 /* The VMA of the .bss section is set by the VMA of the 849 .data section plus the size of the .data section. We may 850 need to add padding bytes to make this true. */ 851 pad = obj_bsssec (abfd)->vma - vma; 852 if (pad > 0) 853 { 854 obj_datasec (abfd)->size += pad; 855 pos += pad; 856 } 857 } 858 obj_bsssec (abfd)->filepos = pos; 859 860 /* Fix up the exec header. */ 861 execp->a_text = obj_textsec (abfd)->size; 862 execp->a_data = obj_datasec (abfd)->size; 863 execp->a_bss = obj_bsssec (abfd)->size; 864 N_SET_MAGIC (*execp, OMAGIC); 865 } 866 867 static void 868 adjust_z_magic (bfd *abfd, struct internal_exec *execp) 869 { 870 bfd_size_type data_pad, text_pad; 871 file_ptr text_end; 872 const struct aout_backend_data *abdp; 873 int ztih; /* Nonzero if text includes exec header. */ 874 875 abdp = aout_backend_info (abfd); 876 877 /* Text. */ 878 ztih = (abdp != NULL 879 && (abdp->text_includes_header 880 || obj_aout_subformat (abfd) == q_magic_format)); 881 obj_textsec(abfd)->filepos = (ztih 882 ? adata(abfd).exec_bytes_size 883 : adata(abfd).zmagic_disk_block_size); 884 if (! obj_textsec(abfd)->user_set_vma) 885 { 886 /* ?? Do we really need to check for relocs here? */ 887 obj_textsec(abfd)->vma = ((abfd->flags & HAS_RELOC) 888 ? 0 889 : (ztih 890 ? (abdp->default_text_vma 891 + adata (abfd).exec_bytes_size) 892 : abdp->default_text_vma)); 893 text_pad = 0; 894 } 895 else 896 { 897 /* The .text section is being loaded at an unusual address. We 898 may need to pad it such that the .data section starts at a page 899 boundary. */ 900 if (ztih) 901 text_pad = ((obj_textsec (abfd)->filepos - obj_textsec (abfd)->vma) 902 & (adata (abfd).page_size - 1)); 903 else 904 text_pad = ((- obj_textsec (abfd)->vma) 905 & (adata (abfd).page_size - 1)); 906 } 907 908 /* Find start of data. */ 909 if (ztih) 910 { 911 text_end = obj_textsec (abfd)->filepos + obj_textsec (abfd)->size; 912 text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end; 913 } 914 else 915 { 916 /* Note that if page_size == zmagic_disk_block_size, then 917 filepos == page_size, and this case is the same as the ztih 918 case. */ 919 text_end = obj_textsec (abfd)->size; 920 text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end; 921 text_end += obj_textsec (abfd)->filepos; 922 } 923 924 obj_textsec (abfd)->size += text_pad; 925 text_end += text_pad; 926 927 /* Data. */ 928 if (!obj_datasec(abfd)->user_set_vma) 929 { 930 bfd_vma vma; 931 vma = obj_textsec(abfd)->vma + obj_textsec(abfd)->size; 932 obj_datasec(abfd)->vma = BFD_ALIGN (vma, adata(abfd).segment_size); 933 } 934 if (abdp && abdp->zmagic_mapped_contiguous) 935 { 936 text_pad = (obj_datasec(abfd)->vma 937 - obj_textsec(abfd)->vma 938 - obj_textsec(abfd)->size); 939 obj_textsec(abfd)->size += text_pad; 940 } 941 obj_datasec (abfd)->filepos = (obj_textsec (abfd)->filepos 942 + obj_textsec (abfd)->size); 943 944 /* Fix up exec header while we're at it. */ 945 execp->a_text = obj_textsec(abfd)->size; 946 if (ztih && (!abdp || (abdp && !abdp->exec_header_not_counted))) 947 execp->a_text += adata(abfd).exec_bytes_size; 948 N_SET_MAGIC (*execp, ZMAGIC); 949 950 /* Spec says data section should be rounded up to page boundary. */ 951 obj_datasec(abfd)->size 952 = align_power (obj_datasec(abfd)->size, 953 obj_bsssec(abfd)->alignment_power); 954 execp->a_data = BFD_ALIGN (obj_datasec(abfd)->size, 955 adata(abfd).page_size); 956 data_pad = execp->a_data - obj_datasec(abfd)->size; 957 958 /* BSS. */ 959 if (!obj_bsssec(abfd)->user_set_vma) 960 obj_bsssec(abfd)->vma = (obj_datasec(abfd)->vma 961 + obj_datasec(abfd)->size); 962 /* If the BSS immediately follows the data section and extra space 963 in the page is left after the data section, fudge data 964 in the header so that the bss section looks smaller by that 965 amount. We'll start the bss section there, and lie to the OS. 966 (Note that a linker script, as well as the above assignment, 967 could have explicitly set the BSS vma to immediately follow 968 the data section.) */ 969 if (align_power (obj_bsssec(abfd)->vma, obj_bsssec(abfd)->alignment_power) 970 == obj_datasec(abfd)->vma + obj_datasec(abfd)->size) 971 execp->a_bss = (data_pad > obj_bsssec(abfd)->size) ? 0 : 972 obj_bsssec(abfd)->size - data_pad; 973 else 974 execp->a_bss = obj_bsssec(abfd)->size; 975 } 976 977 static void 978 adjust_n_magic (bfd *abfd, struct internal_exec *execp) 979 { 980 file_ptr pos = adata(abfd).exec_bytes_size; 981 bfd_vma vma = 0; 982 int pad; 983 984 /* Text. */ 985 obj_textsec(abfd)->filepos = pos; 986 if (!obj_textsec(abfd)->user_set_vma) 987 obj_textsec(abfd)->vma = vma; 988 else 989 vma = obj_textsec(abfd)->vma; 990 pos += obj_textsec(abfd)->size; 991 vma += obj_textsec(abfd)->size; 992 993 /* Data. */ 994 obj_datasec(abfd)->filepos = pos; 995 if (!obj_datasec(abfd)->user_set_vma) 996 obj_datasec(abfd)->vma = BFD_ALIGN (vma, adata(abfd).segment_size); 997 vma = obj_datasec(abfd)->vma; 998 999 /* Since BSS follows data immediately, see if it needs alignment. */ 1000 vma += obj_datasec(abfd)->size; 1001 pad = align_power (vma, obj_bsssec(abfd)->alignment_power) - vma; 1002 obj_datasec(abfd)->size += pad; 1003 pos += obj_datasec(abfd)->size; 1004 1005 /* BSS. */ 1006 if (!obj_bsssec(abfd)->user_set_vma) 1007 obj_bsssec(abfd)->vma = vma; 1008 else 1009 vma = obj_bsssec(abfd)->vma; 1010 1011 /* Fix up exec header. */ 1012 execp->a_text = obj_textsec(abfd)->size; 1013 execp->a_data = obj_datasec(abfd)->size; 1014 execp->a_bss = obj_bsssec(abfd)->size; 1015 N_SET_MAGIC (*execp, NMAGIC); 1016 } 1017 1018 bfd_boolean 1019 NAME (aout, adjust_sizes_and_vmas) (bfd *abfd, 1020 bfd_size_type *text_size, 1021 file_ptr * text_end ATTRIBUTE_UNUSED) 1022 { 1023 struct internal_exec *execp = exec_hdr (abfd); 1024 1025 if (! NAME (aout, make_sections) (abfd)) 1026 return FALSE; 1027 1028 if (adata(abfd).magic != undecided_magic) 1029 return TRUE; 1030 1031 obj_textsec(abfd)->size = 1032 align_power(obj_textsec(abfd)->size, 1033 obj_textsec(abfd)->alignment_power); 1034 1035 *text_size = obj_textsec (abfd)->size; 1036 /* Rule (heuristic) for when to pad to a new page. Note that there 1037 are (at least) two ways demand-paged (ZMAGIC) files have been 1038 handled. Most Berkeley-based systems start the text segment at 1039 (TARGET_PAGE_SIZE). However, newer versions of SUNOS start the text 1040 segment right after the exec header; the latter is counted in the 1041 text segment size, and is paged in by the kernel with the rest of 1042 the text. */ 1043 1044 /* This perhaps isn't the right way to do this, but made it simpler for me 1045 to understand enough to implement it. Better would probably be to go 1046 right from BFD flags to alignment/positioning characteristics. But the 1047 old code was sloppy enough about handling the flags, and had enough 1048 other magic, that it was a little hard for me to understand. I think 1049 I understand it better now, but I haven't time to do the cleanup this 1050 minute. */ 1051 1052 if (abfd->flags & WP_TEXT) 1053 adata(abfd).magic = n_magic; 1054 else 1055 adata(abfd).magic = o_magic; 1056 1057 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */ 1058 #if __GNUC__ >= 2 1059 fprintf (stderr, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n", 1060 ({ char *str; 1061 switch (adata(abfd).magic) { 1062 case n_magic: str = "NMAGIC"; break; 1063 case o_magic: str = "OMAGIC"; break; 1064 case z_magic: str = "ZMAGIC"; break; 1065 default: abort (); 1066 } 1067 str; 1068 }), 1069 obj_textsec(abfd)->vma, obj_textsec(abfd)->size, 1070 obj_textsec(abfd)->alignment_power, 1071 obj_datasec(abfd)->vma, obj_datasec(abfd)->size, 1072 obj_datasec(abfd)->alignment_power, 1073 obj_bsssec(abfd)->vma, obj_bsssec(abfd)->size, 1074 obj_bsssec(abfd)->alignment_power); 1075 #endif 1076 #endif 1077 1078 switch (adata(abfd).magic) 1079 { 1080 case o_magic: 1081 adjust_o_magic (abfd, execp); 1082 break; 1083 case z_magic: 1084 adjust_z_magic (abfd, execp); 1085 break; 1086 case n_magic: 1087 adjust_n_magic (abfd, execp); 1088 break; 1089 default: 1090 abort (); 1091 } 1092 1093 #ifdef BFD_AOUT_DEBUG 1094 fprintf (stderr, " text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n", 1095 obj_textsec(abfd)->vma, obj_textsec(abfd)->size, 1096 obj_textsec(abfd)->filepos, 1097 obj_datasec(abfd)->vma, obj_datasec(abfd)->size, 1098 obj_datasec(abfd)->filepos, 1099 obj_bsssec(abfd)->vma, obj_bsssec(abfd)->size); 1100 #endif 1101 1102 return TRUE; 1103 } 1104 1105 /* Called by the BFD in response to a bfd_make_section request. */ 1106 1107 bfd_boolean 1108 NAME (aout, new_section_hook) (bfd *abfd, asection *newsect) 1109 { 1110 /* Align to double at least. */ 1111 newsect->alignment_power = bfd_get_arch_info(abfd)->section_align_power; 1112 1113 if (bfd_get_format (abfd) == bfd_object) 1114 { 1115 if (obj_textsec (abfd) == NULL 1116 && !strcmp (newsect->name, ".text")) 1117 { 1118 obj_textsec(abfd)= newsect; 1119 newsect->target_index = N_TEXT; 1120 } 1121 else if (obj_datasec (abfd) == NULL 1122 && !strcmp (newsect->name, ".data")) 1123 { 1124 obj_datasec (abfd) = newsect; 1125 newsect->target_index = N_DATA; 1126 } 1127 else if (obj_bsssec (abfd) == NULL 1128 && !strcmp (newsect->name, ".bss")) 1129 { 1130 obj_bsssec (abfd) = newsect; 1131 newsect->target_index = N_BSS; 1132 } 1133 } 1134 1135 /* We allow more than three sections internally. */ 1136 return _bfd_generic_new_section_hook (abfd, newsect); 1137 } 1138 1139 bfd_boolean 1140 NAME (aout, set_section_contents) (bfd *abfd, 1141 sec_ptr section, 1142 const void * location, 1143 file_ptr offset, 1144 bfd_size_type count) 1145 { 1146 file_ptr text_end; 1147 bfd_size_type text_size; 1148 1149 if (! abfd->output_has_begun) 1150 { 1151 if (! NAME (aout, adjust_sizes_and_vmas) (abfd, & text_size, & text_end)) 1152 return FALSE; 1153 } 1154 1155 if (section == obj_bsssec (abfd)) 1156 { 1157 bfd_set_error (bfd_error_no_contents); 1158 return FALSE; 1159 } 1160 1161 if (section != obj_textsec (abfd) 1162 && section != obj_datasec (abfd)) 1163 { 1164 (*_bfd_error_handler) 1165 ("%s: can not represent section `%s' in a.out object file format", 1166 bfd_get_filename (abfd), bfd_get_section_name (abfd, section)); 1167 bfd_set_error (bfd_error_nonrepresentable_section); 1168 return FALSE; 1169 } 1170 1171 if (count != 0) 1172 { 1173 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0 1174 || bfd_bwrite (location, count, abfd) != count) 1175 return FALSE; 1176 } 1177 1178 return TRUE; 1179 } 1180 1181 /* Read the external symbols from an a.out file. */ 1182 1183 static bfd_boolean 1184 aout_get_external_symbols (bfd *abfd) 1185 { 1186 if (obj_aout_external_syms (abfd) == NULL) 1187 { 1188 bfd_size_type count; 1189 struct external_nlist *syms; 1190 1191 count = exec_hdr (abfd)->a_syms / EXTERNAL_NLIST_SIZE; 1192 1193 #ifdef USE_MMAP 1194 if (! bfd_get_file_window (abfd, obj_sym_filepos (abfd), 1195 exec_hdr (abfd)->a_syms, 1196 &obj_aout_sym_window (abfd), TRUE)) 1197 return FALSE; 1198 syms = (struct external_nlist *) obj_aout_sym_window (abfd).data; 1199 #else 1200 /* We allocate using malloc to make the values easy to free 1201 later on. If we put them on the objalloc it might not be 1202 possible to free them. */ 1203 syms = bfd_malloc (count * EXTERNAL_NLIST_SIZE); 1204 if (syms == NULL && count != 0) 1205 return FALSE; 1206 1207 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0 1208 || (bfd_bread (syms, exec_hdr (abfd)->a_syms, abfd) 1209 != exec_hdr (abfd)->a_syms)) 1210 { 1211 free (syms); 1212 return FALSE; 1213 } 1214 #endif 1215 1216 obj_aout_external_syms (abfd) = syms; 1217 obj_aout_external_sym_count (abfd) = count; 1218 } 1219 1220 if (obj_aout_external_strings (abfd) == NULL 1221 && exec_hdr (abfd)->a_syms != 0) 1222 { 1223 unsigned char string_chars[BYTES_IN_LONG]; 1224 bfd_size_type stringsize; 1225 char *strings; 1226 1227 /* Get the size of the strings. */ 1228 if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0 1229 || (bfd_bread ((void *) string_chars, (bfd_size_type) BYTES_IN_LONG, 1230 abfd) != BYTES_IN_LONG)) 1231 return FALSE; 1232 stringsize = H_GET_32 (abfd, string_chars); 1233 1234 #ifdef USE_MMAP 1235 if (! bfd_get_file_window (abfd, obj_str_filepos (abfd), stringsize, 1236 &obj_aout_string_window (abfd), TRUE)) 1237 return FALSE; 1238 strings = (char *) obj_aout_string_window (abfd).data; 1239 #else 1240 strings = bfd_malloc (stringsize + 1); 1241 if (strings == NULL) 1242 return FALSE; 1243 1244 /* Skip space for the string count in the buffer for convenience 1245 when using indexes. */ 1246 if (bfd_bread (strings + 4, stringsize - 4, abfd) != stringsize - 4) 1247 { 1248 free (strings); 1249 return FALSE; 1250 } 1251 #endif 1252 /* Ensure that a zero index yields an empty string. */ 1253 strings[0] = '\0'; 1254 1255 strings[stringsize - 1] = 0; 1256 1257 obj_aout_external_strings (abfd) = strings; 1258 obj_aout_external_string_size (abfd) = stringsize; 1259 } 1260 1261 return TRUE; 1262 } 1263 1264 /* Translate an a.out symbol into a BFD symbol. The desc, other, type 1265 and symbol->value fields of CACHE_PTR will be set from the a.out 1266 nlist structure. This function is responsible for setting 1267 symbol->flags and symbol->section, and adjusting symbol->value. */ 1268 1269 static bfd_boolean 1270 translate_from_native_sym_flags (bfd *abfd, 1271 aout_symbol_type *cache_ptr) 1272 { 1273 flagword visible; 1274 1275 if (cache_ptr->type == N_FN) 1276 { 1277 asection *sec; 1278 1279 /* This is a debugging symbol. */ 1280 cache_ptr->symbol.flags = BSF_DEBUGGING; 1281 1282 /* Work out the symbol section. */ 1283 switch (cache_ptr->type & N_TYPE) 1284 { 1285 case N_TEXT: 1286 case N_FN: 1287 sec = obj_textsec (abfd); 1288 break; 1289 case N_DATA: 1290 sec = obj_datasec (abfd); 1291 break; 1292 case N_BSS: 1293 sec = obj_bsssec (abfd); 1294 break; 1295 default: 1296 case N_ABS: 1297 sec = bfd_abs_section_ptr; 1298 break; 1299 } 1300 1301 cache_ptr->symbol.section = sec; 1302 cache_ptr->symbol.value -= sec->vma; 1303 1304 return TRUE; 1305 } 1306 1307 /* Get the default visibility. This does not apply to all types, so 1308 we just hold it in a local variable to use if wanted. */ 1309 if ((cache_ptr->type & N_EXT) == 0) 1310 visible = BSF_LOCAL; 1311 else 1312 visible = BSF_GLOBAL; 1313 1314 switch (cache_ptr->type) 1315 { 1316 default: 1317 case N_ABS: case N_ABS | N_EXT: 1318 cache_ptr->symbol.section = bfd_abs_section_ptr; 1319 cache_ptr->symbol.flags = visible; 1320 break; 1321 1322 case N_UNDF | N_EXT: 1323 if (cache_ptr->symbol.value != 0) 1324 { 1325 /* This is a common symbol. */ 1326 cache_ptr->symbol.flags = BSF_GLOBAL; 1327 cache_ptr->symbol.section = bfd_com_section_ptr; 1328 } 1329 else 1330 { 1331 cache_ptr->symbol.flags = 0; 1332 cache_ptr->symbol.section = bfd_und_section_ptr; 1333 } 1334 break; 1335 1336 case N_TEXT: case N_TEXT | N_EXT: 1337 cache_ptr->symbol.section = obj_textsec (abfd); 1338 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma; 1339 cache_ptr->symbol.flags = visible; 1340 break; 1341 1342 case N_DATA: case N_DATA | N_EXT: 1343 cache_ptr->symbol.section = obj_datasec (abfd); 1344 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma; 1345 cache_ptr->symbol.flags = visible; 1346 break; 1347 1348 case N_BSS: case N_BSS | N_EXT: 1349 cache_ptr->symbol.section = obj_bsssec (abfd); 1350 cache_ptr->symbol.value -= cache_ptr->symbol.section->vma; 1351 cache_ptr->symbol.flags = visible; 1352 break; 1353 } 1354 1355 return TRUE; 1356 } 1357 1358 /* Set the fields of SYM_POINTER according to CACHE_PTR. */ 1359 1360 static bfd_boolean 1361 translate_to_native_sym_flags (bfd *abfd, 1362 asymbol *cache_ptr, 1363 struct external_nlist *sym_pointer) 1364 { 1365 bfd_vma value = cache_ptr->value; 1366 asection *sec; 1367 bfd_vma off; 1368 1369 /* Mask out any existing type bits in case copying from one section 1370 to another. */ 1371 sym_pointer->e_type[0] &= ~N_TYPE; 1372 1373 sec = bfd_get_section (cache_ptr); 1374 off = 0; 1375 1376 if (sec == NULL) 1377 { 1378 /* This case occurs, e.g., for the *DEBUG* section of a COFF 1379 file. */ 1380 (*_bfd_error_handler) 1381 ("%B: can not represent section for symbol `%s' in a.out object file format", 1382 abfd, cache_ptr->name != NULL ? cache_ptr->name : "*unknown*"); 1383 bfd_set_error (bfd_error_nonrepresentable_section); 1384 return FALSE; 1385 } 1386 1387 if (sec->output_section != NULL) 1388 { 1389 off = sec->output_offset; 1390 sec = sec->output_section; 1391 } 1392 1393 if (bfd_is_abs_section (sec)) 1394 sym_pointer->e_type[0] |= N_ABS; 1395 else if (sec == obj_textsec (abfd)) 1396 sym_pointer->e_type[0] |= N_TEXT; 1397 else if (sec == obj_datasec (abfd)) 1398 sym_pointer->e_type[0] |= N_DATA; 1399 else if (sec == obj_bsssec (abfd)) 1400 sym_pointer->e_type[0] |= N_BSS; 1401 else if (bfd_is_und_section (sec)) 1402 sym_pointer->e_type[0] = N_UNDF | N_EXT; 1403 else if (bfd_is_com_section (sec)) 1404 sym_pointer->e_type[0] = N_UNDF | N_EXT; 1405 else 1406 { 1407 (*_bfd_error_handler) 1408 ("%B: can not represent section `%A' in a.out object file format", 1409 abfd, sec); 1410 bfd_set_error (bfd_error_nonrepresentable_section); 1411 return FALSE; 1412 } 1413 1414 /* Turn the symbol from section relative to absolute again */ 1415 value += sec->vma + off; 1416 1417 if ((cache_ptr->flags & BSF_DEBUGGING) != 0) 1418 sym_pointer->e_type[0] = ((aout_symbol_type *) cache_ptr)->type; 1419 else if ((cache_ptr->flags & BSF_GLOBAL) != 0) 1420 sym_pointer->e_type[0] |= N_EXT; 1421 1422 PUT_WORD(abfd, value, sym_pointer->e_value); 1423 1424 return TRUE; 1425 } 1426 1427 /* Native-level interface to symbols. */ 1428 1429 asymbol * 1430 NAME (aout, make_empty_symbol) (bfd *abfd) 1431 { 1432 bfd_size_type amt = sizeof (aout_symbol_type); 1433 aout_symbol_type *new_symbol_type = bfd_zalloc (abfd, amt); 1434 1435 if (!new_symbol_type) 1436 return NULL; 1437 new_symbol_type->symbol.the_bfd = abfd; 1438 1439 return &new_symbol_type->symbol; 1440 } 1441 1442 /* Translate a set of internal symbols into external symbols. */ 1443 1444 bfd_boolean 1445 NAME (aout, translate_symbol_table) (bfd *abfd, 1446 aout_symbol_type *in, 1447 struct external_nlist *ext, 1448 bfd_size_type count, 1449 char *str, 1450 bfd_size_type strsize, 1451 bfd_boolean dynamic) 1452 { 1453 struct external_nlist *ext_end; 1454 1455 ext_end = ext + count; 1456 for (; ext < ext_end; ext++, in++) 1457 { 1458 bfd_vma x; 1459 1460 x = GET_WORD (abfd, ext->e_strx); 1461 in->symbol.the_bfd = abfd; 1462 1463 /* For the normal symbols, the zero index points at the number 1464 of bytes in the string table but is to be interpreted as the 1465 null string. For the dynamic symbols, the number of bytes in 1466 the string table is stored in the __DYNAMIC structure and the 1467 zero index points at an actual string. */ 1468 if (x == 0 && ! dynamic) 1469 in->symbol.name = ""; 1470 else if (x < strsize) 1471 in->symbol.name = str + x; 1472 else 1473 return FALSE; 1474 1475 in->symbol.value = GET_SWORD (abfd, ext->e_value); 1476 /* TODO: is 0 a safe value here? */ 1477 in->desc = 0; 1478 in->other = 0; 1479 in->type = H_GET_8 (abfd, ext->e_type); 1480 in->symbol.udata.p = NULL; 1481 1482 if (! translate_from_native_sym_flags (abfd, in)) 1483 return FALSE; 1484 1485 if (dynamic) 1486 in->symbol.flags |= BSF_DYNAMIC; 1487 } 1488 1489 return TRUE; 1490 } 1491 1492 /* We read the symbols into a buffer, which is discarded when this 1493 function exits. We read the strings into a buffer large enough to 1494 hold them all plus all the cached symbol entries. */ 1495 1496 bfd_boolean 1497 NAME (aout, slurp_symbol_table) (bfd *abfd) 1498 { 1499 struct external_nlist *old_external_syms; 1500 aout_symbol_type *cached; 1501 bfd_size_type cached_size; 1502 1503 /* If there's no work to be done, don't do any. */ 1504 if (obj_aout_symbols (abfd) != NULL) 1505 return TRUE; 1506 1507 old_external_syms = obj_aout_external_syms (abfd); 1508 1509 if (! aout_get_external_symbols (abfd)) 1510 return FALSE; 1511 1512 cached_size = obj_aout_external_sym_count (abfd); 1513 cached_size *= sizeof (aout_symbol_type); 1514 cached = bfd_zmalloc (cached_size); 1515 if (cached == NULL && cached_size != 0) 1516 return FALSE; 1517 1518 /* Convert from external symbol information to internal. */ 1519 if (! (NAME (aout, translate_symbol_table) 1520 (abfd, cached, 1521 obj_aout_external_syms (abfd), 1522 obj_aout_external_sym_count (abfd), 1523 obj_aout_external_strings (abfd), 1524 obj_aout_external_string_size (abfd), 1525 FALSE))) 1526 { 1527 free (cached); 1528 return FALSE; 1529 } 1530 1531 bfd_get_symcount (abfd) = obj_aout_external_sym_count (abfd); 1532 1533 obj_aout_symbols (abfd) = cached; 1534 1535 /* It is very likely that anybody who calls this function will not 1536 want the external symbol information, so if it was allocated 1537 because of our call to aout_get_external_symbols, we free it up 1538 right away to save space. */ 1539 if (old_external_syms == NULL 1540 && obj_aout_external_syms (abfd) != NULL) 1541 { 1542 #ifdef USE_MMAP 1543 bfd_free_window (&obj_aout_sym_window (abfd)); 1544 #else 1545 free (obj_aout_external_syms (abfd)); 1546 #endif 1547 obj_aout_external_syms (abfd) = NULL; 1548 } 1549 1550 return TRUE; 1551 } 1552 1553 /* We use a hash table when writing out symbols so that we only write 1554 out a particular string once. This helps particularly when the 1555 linker writes out stabs debugging entries, because each different 1556 contributing object file tends to have many duplicate stabs 1557 strings. 1558 1559 This hash table code breaks dbx on SunOS 4.1.3, so we don't do it 1560 if BFD_TRADITIONAL_FORMAT is set. */ 1561 1562 /* Get the index of a string in a strtab, adding it if it is not 1563 already present. */ 1564 1565 static INLINE bfd_size_type 1566 add_to_stringtab (bfd *abfd, 1567 struct bfd_strtab_hash *tab, 1568 const char *str, 1569 bfd_boolean copy) 1570 { 1571 bfd_boolean hash; 1572 bfd_size_type str_index; 1573 1574 /* An index of 0 always means the empty string. */ 1575 if (str == 0 || *str == '\0') 1576 return 0; 1577 1578 /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx 1579 doesn't understand a hashed string table. */ 1580 hash = TRUE; 1581 if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0) 1582 hash = FALSE; 1583 1584 str_index = _bfd_stringtab_add (tab, str, hash, copy); 1585 1586 if (str_index != (bfd_size_type) -1) 1587 /* Add BYTES_IN_LONG to the return value to account for the 1588 space taken up by the string table size. */ 1589 str_index += BYTES_IN_LONG; 1590 1591 return str_index; 1592 } 1593 1594 /* Write out a strtab. ABFD is already at the right location in the 1595 file. */ 1596 1597 static bfd_boolean 1598 emit_stringtab (bfd *abfd, struct bfd_strtab_hash *tab) 1599 { 1600 bfd_byte buffer[BYTES_IN_LONG]; 1601 1602 /* The string table starts with the size. */ 1603 H_PUT_32 (abfd, _bfd_stringtab_size (tab) + BYTES_IN_LONG, buffer); 1604 if (bfd_bwrite ((void *) buffer, (bfd_size_type) BYTES_IN_LONG, abfd) 1605 != BYTES_IN_LONG) 1606 return FALSE; 1607 1608 return _bfd_stringtab_emit (abfd, tab); 1609 } 1610 1611 bfd_boolean 1612 NAME (aout, write_syms) (bfd *abfd) 1613 { 1614 unsigned int count ; 1615 asymbol **generic = bfd_get_outsymbols (abfd); 1616 struct bfd_strtab_hash *strtab; 1617 1618 strtab = _bfd_stringtab_init (); 1619 if (strtab == NULL) 1620 return FALSE; 1621 1622 for (count = 0; count < bfd_get_symcount (abfd); count++) 1623 { 1624 asymbol *g = generic[count]; 1625 bfd_size_type indx; 1626 struct external_nlist nsp; 1627 1628 PUT_WORD (abfd, 0, nsp.e_unused); 1629 1630 indx = add_to_stringtab (abfd, strtab, g->name, FALSE); 1631 if (indx == (bfd_size_type) -1) 1632 goto error_return; 1633 PUT_WORD (abfd, indx, nsp.e_strx); 1634 1635 if (bfd_asymbol_flavour(g) == abfd->xvec->flavour) 1636 H_PUT_8 (abfd, aout_symbol(g)->type, nsp.e_type); 1637 else 1638 H_PUT_8 (abfd, 0, nsp.e_type); 1639 1640 if (! translate_to_native_sym_flags (abfd, g, &nsp)) 1641 goto error_return; 1642 1643 H_PUT_8 (abfd, 0, nsp.e_ovly); 1644 1645 if (bfd_bwrite ((void *)&nsp, (bfd_size_type) EXTERNAL_NLIST_SIZE, abfd) 1646 != EXTERNAL_NLIST_SIZE) 1647 goto error_return; 1648 1649 /* NB: `KEEPIT' currently overlays `udata.p', so set this only 1650 here, at the end. */ 1651 g->KEEPIT = count; 1652 } 1653 1654 if (! emit_stringtab (abfd, strtab)) 1655 goto error_return; 1656 1657 _bfd_stringtab_free (strtab); 1658 1659 return TRUE; 1660 1661 error_return: 1662 _bfd_stringtab_free (strtab); 1663 return FALSE; 1664 } 1665 1666 1667 long 1668 NAME (aout, canonicalize_symtab) (bfd *abfd, asymbol **location) 1669 { 1670 unsigned int counter = 0; 1671 aout_symbol_type *symbase; 1672 1673 if (!NAME (aout, slurp_symbol_table) (abfd)) 1674 return -1; 1675 1676 for (symbase = obj_aout_symbols (abfd); counter++ < bfd_get_symcount (abfd);) 1677 *(location++) = (asymbol *)(symbase++); 1678 *location++ =0; 1679 return bfd_get_symcount (abfd); 1680 } 1681 1682 1683 /* Output extended relocation information to a file in target byte order. */ 1684 1685 static void 1686 pdp11_aout_swap_reloc_out (bfd *abfd, arelent *g, bfd_byte *natptr) 1687 { 1688 int r_index; 1689 int r_pcrel; 1690 int reloc_entry; 1691 int r_type; 1692 asymbol *sym = *(g->sym_ptr_ptr); 1693 asection *output_section = sym->section->output_section; 1694 1695 if (g->addend != 0) 1696 fprintf (stderr, "BFD: can't do this reloc addend stuff\n"); 1697 1698 r_pcrel = g->howto->pc_relative; 1699 1700 if (bfd_is_abs_section (output_section)) 1701 r_type = RABS; 1702 else if (output_section == obj_textsec (abfd)) 1703 r_type = RTEXT; 1704 else if (output_section == obj_datasec (abfd)) 1705 r_type = RDATA; 1706 else if (output_section == obj_bsssec (abfd)) 1707 r_type = RBSS; 1708 else if (bfd_is_und_section (output_section)) 1709 r_type = REXT; 1710 else if (bfd_is_com_section (output_section)) 1711 r_type = REXT; 1712 else 1713 r_type = -1; 1714 1715 BFD_ASSERT (r_type != -1); 1716 1717 if (r_type == RABS) 1718 r_index = 0; 1719 else 1720 r_index = (*(g->sym_ptr_ptr))->KEEPIT; 1721 1722 reloc_entry = r_index << 4 | r_type | r_pcrel; 1723 1724 PUT_WORD (abfd, reloc_entry, natptr); 1725 } 1726 1727 /* BFD deals internally with all things based from the section they're 1728 in. so, something in 10 bytes into a text section with a base of 1729 50 would have a symbol (.text+10) and know .text vma was 50. 1730 1731 Aout keeps all it's symbols based from zero, so the symbol would 1732 contain 60. This macro subs the base of each section from the value 1733 to give the true offset from the section */ 1734 1735 1736 #define MOVE_ADDRESS(ad) \ 1737 if (r_extern) \ 1738 { \ 1739 /* Undefined symbol. */ \ 1740 cache_ptr->sym_ptr_ptr = symbols + r_index; \ 1741 cache_ptr->addend = ad; \ 1742 } \ 1743 else \ 1744 { \ 1745 /* Defined, section relative. replace symbol with pointer to \ 1746 symbol which points to section. */ \ 1747 switch (r_index) \ 1748 { \ 1749 case N_TEXT: \ 1750 case N_TEXT | N_EXT: \ 1751 cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr; \ 1752 cache_ptr->addend = ad - su->textsec->vma; \ 1753 break; \ 1754 case N_DATA: \ 1755 case N_DATA | N_EXT: \ 1756 cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr; \ 1757 cache_ptr->addend = ad - su->datasec->vma; \ 1758 break; \ 1759 case N_BSS: \ 1760 case N_BSS | N_EXT: \ 1761 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr; \ 1762 cache_ptr->addend = ad - su->bsssec->vma; \ 1763 break; \ 1764 default: \ 1765 case N_ABS: \ 1766 case N_ABS | N_EXT: \ 1767 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \ 1768 cache_ptr->addend = ad; \ 1769 break; \ 1770 } \ 1771 } 1772 1773 static void 1774 pdp11_aout_swap_reloc_in (bfd * abfd, 1775 bfd_byte * bytes, 1776 arelent * cache_ptr, 1777 bfd_size_type offset, 1778 asymbol ** symbols, 1779 bfd_size_type symcount) 1780 { 1781 struct aoutdata *su = &(abfd->tdata.aout_data->a); 1782 unsigned int r_index; 1783 int reloc_entry; 1784 int r_extern; 1785 int r_pcrel; 1786 1787 reloc_entry = GET_WORD (abfd, (void *) bytes); 1788 1789 r_pcrel = reloc_entry & RELFLG; 1790 1791 cache_ptr->address = offset; 1792 cache_ptr->howto = howto_table_pdp11 + (r_pcrel ? 1 : 0); 1793 1794 if ((reloc_entry & RTYPE) == RABS) 1795 r_index = N_ABS; 1796 else 1797 r_index = RINDEX (reloc_entry); 1798 1799 /* r_extern reflects whether the symbol the reloc is against is 1800 local or global. */ 1801 r_extern = (reloc_entry & RTYPE) == REXT; 1802 1803 if (r_extern && r_index > symcount) 1804 { 1805 /* We could arrange to return an error, but it might be useful 1806 to see the file even if it is bad. */ 1807 r_extern = 0; 1808 r_index = N_ABS; 1809 } 1810 1811 MOVE_ADDRESS(0); 1812 } 1813 1814 /* Read and swap the relocs for a section. */ 1815 1816 bfd_boolean 1817 NAME (aout, slurp_reloc_table) (bfd *abfd, sec_ptr asect, asymbol **symbols) 1818 { 1819 bfd_byte *rptr; 1820 bfd_size_type count; 1821 bfd_size_type reloc_size; 1822 void * relocs; 1823 arelent *reloc_cache; 1824 size_t each_size; 1825 unsigned int counter = 0; 1826 arelent *cache_ptr; 1827 1828 if (asect->relocation) 1829 return TRUE; 1830 1831 if (asect->flags & SEC_CONSTRUCTOR) 1832 return TRUE; 1833 1834 if (asect == obj_datasec (abfd)) 1835 reloc_size = exec_hdr(abfd)->a_drsize; 1836 else if (asect == obj_textsec (abfd)) 1837 reloc_size = exec_hdr(abfd)->a_trsize; 1838 else if (asect == obj_bsssec (abfd)) 1839 reloc_size = 0; 1840 else 1841 { 1842 bfd_set_error (bfd_error_invalid_operation); 1843 return FALSE; 1844 } 1845 1846 if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0) 1847 return FALSE; 1848 1849 each_size = obj_reloc_entry_size (abfd); 1850 1851 relocs = bfd_malloc (reloc_size); 1852 if (relocs == NULL && reloc_size != 0) 1853 return FALSE; 1854 1855 if (bfd_bread (relocs, reloc_size, abfd) != reloc_size) 1856 { 1857 free (relocs); 1858 return FALSE; 1859 } 1860 1861 count = reloc_size / each_size; 1862 1863 /* Count the number of NON-ZERO relocs, this is the count we want. */ 1864 { 1865 unsigned int real_count = 0; 1866 1867 for (counter = 0; counter < count; counter++) 1868 { 1869 int x; 1870 1871 x = GET_WORD (abfd, (char *) relocs + each_size * counter); 1872 if (x != 0) 1873 real_count++; 1874 } 1875 1876 count = real_count; 1877 } 1878 1879 reloc_cache = bfd_zmalloc (count * sizeof (arelent)); 1880 if (reloc_cache == NULL && count != 0) 1881 return FALSE; 1882 1883 cache_ptr = reloc_cache; 1884 1885 rptr = relocs; 1886 for (counter = 0; 1887 counter < count; 1888 counter++, rptr += RELOC_SIZE, cache_ptr++) 1889 { 1890 while (GET_WORD (abfd, (void *) rptr) == 0) 1891 { 1892 rptr += RELOC_SIZE; 1893 if ((char *) rptr >= (char *) relocs + reloc_size) 1894 goto done; 1895 } 1896 1897 pdp11_aout_swap_reloc_in (abfd, rptr, cache_ptr, 1898 (bfd_size_type) ((char *) rptr - (char *) relocs), 1899 symbols, 1900 (bfd_size_type) bfd_get_symcount (abfd)); 1901 } 1902 done: 1903 /* Just in case, if rptr >= relocs + reloc_size should happen 1904 too early. */ 1905 BFD_ASSERT (counter == count); 1906 1907 free (relocs); 1908 1909 asect->relocation = reloc_cache; 1910 asect->reloc_count = cache_ptr - reloc_cache; 1911 1912 return TRUE; 1913 } 1914 1915 /* Write out a relocation section into an object file. */ 1916 1917 bfd_boolean 1918 NAME (aout, squirt_out_relocs) (bfd *abfd, asection *section) 1919 { 1920 arelent **generic; 1921 unsigned char *native; 1922 unsigned int count = section->reloc_count; 1923 bfd_size_type natsize; 1924 1925 natsize = section->size; 1926 native = bfd_zalloc (abfd, natsize); 1927 if (!native) 1928 return FALSE; 1929 1930 generic = section->orelocation; 1931 if (generic != NULL) 1932 { 1933 while (count > 0) 1934 { 1935 bfd_byte *r; 1936 1937 r = native + (*generic)->address; 1938 pdp11_aout_swap_reloc_out (abfd, *generic, r); 1939 count--; 1940 generic++; 1941 } 1942 } 1943 1944 if (bfd_bwrite ((void *) native, natsize, abfd) != natsize) 1945 { 1946 bfd_release (abfd, native); 1947 return FALSE; 1948 } 1949 1950 bfd_release (abfd, native); 1951 return TRUE; 1952 } 1953 1954 /* This is stupid. This function should be a boolean predicate. */ 1955 1956 long 1957 NAME (aout, canonicalize_reloc) (bfd *abfd, 1958 sec_ptr section, 1959 arelent **relptr, 1960 asymbol **symbols) 1961 { 1962 arelent *tblptr = section->relocation; 1963 unsigned int count; 1964 1965 if (section == obj_bsssec (abfd)) 1966 { 1967 *relptr = NULL; 1968 return 0; 1969 } 1970 1971 if (!(tblptr || NAME (aout, slurp_reloc_table)(abfd, section, symbols))) 1972 return -1; 1973 1974 if (section->flags & SEC_CONSTRUCTOR) 1975 { 1976 arelent_chain *chain = section->constructor_chain; 1977 1978 for (count = 0; count < section->reloc_count; count ++) 1979 { 1980 *relptr ++ = &chain->relent; 1981 chain = chain->next; 1982 } 1983 } 1984 else 1985 { 1986 tblptr = section->relocation; 1987 1988 for (count = 0; count++ < section->reloc_count;) 1989 *relptr++ = tblptr++; 1990 } 1991 1992 *relptr = 0; 1993 1994 return section->reloc_count; 1995 } 1996 1997 long 1998 NAME (aout, get_reloc_upper_bound) (bfd *abfd, sec_ptr asect) 1999 { 2000 if (bfd_get_format (abfd) != bfd_object) 2001 { 2002 bfd_set_error (bfd_error_invalid_operation); 2003 return -1; 2004 } 2005 2006 if (asect->flags & SEC_CONSTRUCTOR) 2007 return (sizeof (arelent *) * (asect->reloc_count + 1)); 2008 2009 if (asect == obj_datasec (abfd)) 2010 return (sizeof (arelent *) 2011 * ((exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd)) 2012 + 1)); 2013 2014 if (asect == obj_textsec (abfd)) 2015 return (sizeof (arelent *) 2016 * ((exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd)) 2017 + 1)); 2018 2019 /* TODO: why are there two if statements for obj_bsssec()? */ 2020 2021 if (asect == obj_bsssec (abfd)) 2022 return sizeof (arelent *); 2023 2024 if (asect == obj_bsssec (abfd)) 2025 return 0; 2026 2027 bfd_set_error (bfd_error_invalid_operation); 2028 return -1; 2029 } 2030 2031 2032 long 2033 NAME (aout, get_symtab_upper_bound) (bfd *abfd) 2034 { 2035 if (!NAME (aout, slurp_symbol_table) (abfd)) 2036 return -1; 2037 2038 return (bfd_get_symcount (abfd) + 1) * (sizeof (aout_symbol_type *)); 2039 } 2040 2041 alent * 2042 NAME (aout, get_lineno) (bfd * abfd ATTRIBUTE_UNUSED, 2043 asymbol * symbol ATTRIBUTE_UNUSED) 2044 { 2045 return NULL; 2046 } 2047 2048 void 2049 NAME (aout, get_symbol_info) (bfd * abfd ATTRIBUTE_UNUSED, 2050 asymbol *symbol, 2051 symbol_info *ret) 2052 { 2053 bfd_symbol_info (symbol, ret); 2054 2055 if (ret->type == '?') 2056 { 2057 int type_code = aout_symbol(symbol)->type & 0xff; 2058 const char *stab_name = bfd_get_stab_name (type_code); 2059 static char buf[10]; 2060 2061 if (stab_name == NULL) 2062 { 2063 sprintf(buf, "(%d)", type_code); 2064 stab_name = buf; 2065 } 2066 ret->type = '-'; 2067 ret->stab_type = type_code; 2068 ret->stab_other = (unsigned) (aout_symbol(symbol)->other & 0xff); 2069 ret->stab_desc = (unsigned) (aout_symbol(symbol)->desc & 0xffff); 2070 ret->stab_name = stab_name; 2071 } 2072 } 2073 2074 void 2075 NAME (aout, print_symbol) (bfd * abfd, 2076 void * afile, 2077 asymbol *symbol, 2078 bfd_print_symbol_type how) 2079 { 2080 FILE *file = (FILE *) afile; 2081 2082 switch (how) 2083 { 2084 case bfd_print_symbol_name: 2085 if (symbol->name) 2086 fprintf(file,"%s", symbol->name); 2087 break; 2088 case bfd_print_symbol_more: 2089 fprintf(file,"%4x %2x %2x", 2090 (unsigned) (aout_symbol (symbol)->desc & 0xffff), 2091 (unsigned) (aout_symbol (symbol)->other & 0xff), 2092 (unsigned) (aout_symbol (symbol)->type)); 2093 break; 2094 case bfd_print_symbol_all: 2095 { 2096 const char *section_name = symbol->section->name; 2097 2098 bfd_print_symbol_vandf (abfd, (void *) file, symbol); 2099 2100 fprintf (file," %-5s %04x %02x %02x", 2101 section_name, 2102 (unsigned) (aout_symbol (symbol)->desc & 0xffff), 2103 (unsigned) (aout_symbol (symbol)->other & 0xff), 2104 (unsigned) (aout_symbol (symbol)->type & 0xff)); 2105 if (symbol->name) 2106 fprintf(file," %s", symbol->name); 2107 } 2108 break; 2109 } 2110 } 2111 2112 /* If we don't have to allocate more than 1MB to hold the generic 2113 symbols, we use the generic minisymbol method: it's faster, since 2114 it only translates the symbols once, not multiple times. */ 2115 #define MINISYM_THRESHOLD (1000000 / sizeof (asymbol)) 2116 2117 /* Read minisymbols. For minisymbols, we use the unmodified a.out 2118 symbols. The minisymbol_to_symbol function translates these into 2119 BFD asymbol structures. */ 2120 2121 long 2122 NAME (aout, read_minisymbols) (bfd *abfd, 2123 bfd_boolean dynamic, 2124 void * *minisymsp, 2125 unsigned int *sizep) 2126 { 2127 if (dynamic) 2128 /* We could handle the dynamic symbols here as well, but it's 2129 easier to hand them off. */ 2130 return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep); 2131 2132 if (! aout_get_external_symbols (abfd)) 2133 return -1; 2134 2135 if (obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD) 2136 return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep); 2137 2138 *minisymsp = (void *) obj_aout_external_syms (abfd); 2139 2140 /* By passing the external symbols back from this routine, we are 2141 giving up control over the memory block. Clear 2142 obj_aout_external_syms, so that we do not try to free it 2143 ourselves. */ 2144 obj_aout_external_syms (abfd) = NULL; 2145 2146 *sizep = EXTERNAL_NLIST_SIZE; 2147 return obj_aout_external_sym_count (abfd); 2148 } 2149 2150 /* Convert a minisymbol to a BFD asymbol. A minisymbol is just an 2151 unmodified a.out symbol. The SYM argument is a structure returned 2152 by bfd_make_empty_symbol, which we fill in here. */ 2153 2154 asymbol * 2155 NAME (aout, minisymbol_to_symbol) (bfd *abfd, 2156 bfd_boolean dynamic, 2157 const void * minisym, 2158 asymbol *sym) 2159 { 2160 if (dynamic 2161 || obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD) 2162 return _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym); 2163 2164 memset (sym, 0, sizeof (aout_symbol_type)); 2165 2166 /* We call translate_symbol_table to translate a single symbol. */ 2167 if (! (NAME (aout, translate_symbol_table) 2168 (abfd, 2169 (aout_symbol_type *) sym, 2170 (struct external_nlist *) minisym, 2171 (bfd_size_type) 1, 2172 obj_aout_external_strings (abfd), 2173 obj_aout_external_string_size (abfd), 2174 FALSE))) 2175 return NULL; 2176 2177 return sym; 2178 } 2179 2180 /* Provided a BFD, a section and an offset into the section, calculate 2181 and return the name of the source file and the line nearest to the 2182 wanted location. */ 2183 2184 bfd_boolean 2185 NAME (aout, find_nearest_line) (bfd *abfd, 2186 asection *section, 2187 asymbol **symbols, 2188 bfd_vma offset, 2189 const char **filename_ptr, 2190 const char **functionname_ptr, 2191 unsigned int *line_ptr) 2192 { 2193 /* Run down the file looking for the filename, function and linenumber. */ 2194 asymbol **p; 2195 const char *directory_name = NULL; 2196 const char *main_file_name = NULL; 2197 const char *current_file_name = NULL; 2198 const char *line_file_name = NULL; /* Value of current_file_name at line number. */ 2199 bfd_vma low_line_vma = 0; 2200 bfd_vma low_func_vma = 0; 2201 asymbol *func = 0; 2202 size_t filelen, funclen; 2203 char *buf; 2204 2205 *filename_ptr = abfd->filename; 2206 *functionname_ptr = 0; 2207 *line_ptr = 0; 2208 2209 if (symbols != NULL) 2210 { 2211 for (p = symbols; *p; p++) 2212 { 2213 aout_symbol_type *q = (aout_symbol_type *)(*p); 2214 next: 2215 switch (q->type) 2216 { 2217 case N_TEXT: 2218 /* If this looks like a file name symbol, and it comes after 2219 the line number we have found so far, but before the 2220 offset, then we have probably not found the right line 2221 number. */ 2222 if (q->symbol.value <= offset 2223 && ((q->symbol.value > low_line_vma 2224 && (line_file_name != NULL 2225 || *line_ptr != 0)) 2226 || (q->symbol.value > low_func_vma 2227 && func != NULL))) 2228 { 2229 const char * symname; 2230 2231 symname = q->symbol.name; 2232 if (strcmp (symname + strlen (symname) - 2, ".o") == 0) 2233 { 2234 if (q->symbol.value > low_line_vma) 2235 { 2236 *line_ptr = 0; 2237 line_file_name = NULL; 2238 } 2239 if (q->symbol.value > low_func_vma) 2240 func = NULL; 2241 } 2242 } 2243 break; 2244 2245 case N_SO: 2246 /* If this symbol is less than the offset, but greater than 2247 the line number we have found so far, then we have not 2248 found the right line number. */ 2249 if (q->symbol.value <= offset) 2250 { 2251 if (q->symbol.value > low_line_vma) 2252 { 2253 *line_ptr = 0; 2254 line_file_name = NULL; 2255 } 2256 if (q->symbol.value > low_func_vma) 2257 func = NULL; 2258 } 2259 2260 main_file_name = current_file_name = q->symbol.name; 2261 /* Look ahead to next symbol to check if that too is an N_SO. */ 2262 p++; 2263 if (*p == NULL) 2264 break; 2265 q = (aout_symbol_type *)(*p); 2266 if (q->type != (int) N_SO) 2267 goto next; 2268 2269 /* Found a second N_SO First is directory; second is filename. */ 2270 directory_name = current_file_name; 2271 main_file_name = current_file_name = q->symbol.name; 2272 if (obj_textsec(abfd) != section) 2273 goto done; 2274 break; 2275 case N_SOL: 2276 current_file_name = q->symbol.name; 2277 break; 2278 2279 case N_SLINE: 2280 case N_DSLINE: 2281 case N_BSLINE: 2282 /* We'll keep this if it resolves nearer than the one we have 2283 already. */ 2284 if (q->symbol.value >= low_line_vma 2285 && q->symbol.value <= offset) 2286 { 2287 *line_ptr = q->desc; 2288 low_line_vma = q->symbol.value; 2289 line_file_name = current_file_name; 2290 } 2291 break; 2292 2293 case N_FUN: 2294 { 2295 /* We'll keep this if it is nearer than the one we have already. */ 2296 if (q->symbol.value >= low_func_vma && 2297 q->symbol.value <= offset) 2298 { 2299 low_func_vma = q->symbol.value; 2300 func = (asymbol *) q; 2301 } 2302 else if (q->symbol.value > offset) 2303 goto done; 2304 } 2305 break; 2306 } 2307 } 2308 } 2309 2310 done: 2311 if (*line_ptr != 0) 2312 main_file_name = line_file_name; 2313 2314 if (main_file_name == NULL 2315 || main_file_name[0] == '/' 2316 || directory_name == NULL) 2317 filelen = 0; 2318 else 2319 filelen = strlen (directory_name) + strlen (main_file_name); 2320 if (func == NULL) 2321 funclen = 0; 2322 else 2323 funclen = strlen (bfd_asymbol_name (func)); 2324 2325 if (adata (abfd).line_buf != NULL) 2326 free (adata (abfd).line_buf); 2327 if (filelen + funclen == 0) 2328 adata (abfd).line_buf = buf = NULL; 2329 else 2330 { 2331 buf = bfd_malloc ((bfd_size_type) filelen + funclen + 3); 2332 adata (abfd).line_buf = buf; 2333 if (buf == NULL) 2334 return FALSE; 2335 } 2336 2337 if (main_file_name != NULL) 2338 { 2339 if (main_file_name[0] == '/' || directory_name == NULL) 2340 *filename_ptr = main_file_name; 2341 else 2342 { 2343 sprintf (buf, "%s%s", directory_name, main_file_name); 2344 *filename_ptr = buf; 2345 buf += filelen + 1; 2346 } 2347 } 2348 2349 if (func) 2350 { 2351 const char *function = func->name; 2352 char *colon; 2353 2354 /* The caller expects a symbol name. We actually have a 2355 function name, without the leading underscore. Put the 2356 underscore back in, so that the caller gets a symbol name. */ 2357 if (bfd_get_symbol_leading_char (abfd) == '\0') 2358 strcpy (buf, function); 2359 else 2360 { 2361 buf[0] = bfd_get_symbol_leading_char (abfd); 2362 strcpy (buf + 1, function); 2363 } 2364 2365 /* Have to remove : stuff. */ 2366 colon = strchr (buf, ':'); 2367 if (colon != NULL) 2368 *colon = '\0'; 2369 *functionname_ptr = buf; 2370 } 2371 2372 return TRUE; 2373 } 2374 2375 int 2376 NAME (aout, sizeof_headers) (bfd *abfd, 2377 struct bfd_link_info *info ATTRIBUTE_UNUSED) 2378 { 2379 return adata (abfd).exec_bytes_size; 2380 } 2381 2382 /* Free all information we have cached for this BFD. We can always 2383 read it again later if we need it. */ 2384 2385 bfd_boolean 2386 NAME (aout, bfd_free_cached_info) (bfd *abfd) 2387 { 2388 asection *o; 2389 2390 if (bfd_get_format (abfd) != bfd_object) 2391 return TRUE; 2392 2393 #define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; } 2394 BFCI_FREE (obj_aout_symbols (abfd)); 2395 2396 #ifdef USE_MMAP 2397 obj_aout_external_syms (abfd) = 0; 2398 bfd_free_window (&obj_aout_sym_window (abfd)); 2399 bfd_free_window (&obj_aout_string_window (abfd)); 2400 obj_aout_external_strings (abfd) = 0; 2401 #else 2402 BFCI_FREE (obj_aout_external_syms (abfd)); 2403 BFCI_FREE (obj_aout_external_strings (abfd)); 2404 #endif 2405 for (o = abfd->sections; o != NULL; o = o->next) 2406 BFCI_FREE (o->relocation); 2407 #undef BFCI_FREE 2408 2409 return TRUE; 2410 } 2411 2412 /* Routine to create an entry in an a.out link hash table. */ 2413 2414 struct bfd_hash_entry * 2415 NAME (aout, link_hash_newfunc) (struct bfd_hash_entry *entry, 2416 struct bfd_hash_table *table, 2417 const char *string) 2418 { 2419 struct aout_link_hash_entry *ret = (struct aout_link_hash_entry *) entry; 2420 2421 /* Allocate the structure if it has not already been allocated by a 2422 subclass. */ 2423 if (ret == NULL) 2424 ret = bfd_hash_allocate (table, sizeof (* ret)); 2425 if (ret == NULL) 2426 return NULL; 2427 2428 /* Call the allocation method of the superclass. */ 2429 ret = (struct aout_link_hash_entry *) 2430 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret, table, string); 2431 if (ret) 2432 { 2433 /* Set local fields. */ 2434 ret->written = FALSE; 2435 ret->indx = -1; 2436 } 2437 2438 return (struct bfd_hash_entry *) ret; 2439 } 2440 2441 /* Initialize an a.out link hash table. */ 2442 2443 bfd_boolean 2444 NAME (aout, link_hash_table_init) (struct aout_link_hash_table *table, 2445 bfd *abfd, 2446 struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *, 2447 struct bfd_hash_table *, 2448 const char *), 2449 unsigned int entsize) 2450 { 2451 return _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize); 2452 } 2453 2454 /* Create an a.out link hash table. */ 2455 2456 struct bfd_link_hash_table * 2457 NAME (aout, link_hash_table_create) (bfd *abfd) 2458 { 2459 struct aout_link_hash_table *ret; 2460 bfd_size_type amt = sizeof (struct aout_link_hash_table); 2461 2462 ret = bfd_malloc (amt); 2463 if (ret == NULL) 2464 return NULL; 2465 if (! NAME (aout, link_hash_table_init) (ret, abfd, 2466 NAME (aout, link_hash_newfunc), 2467 sizeof (struct aout_link_hash_entry))) 2468 { 2469 free (ret); 2470 return NULL; 2471 } 2472 return &ret->root; 2473 } 2474 2475 /* Free up the internal symbols read from an a.out file. */ 2476 2477 static bfd_boolean 2478 aout_link_free_symbols (bfd *abfd) 2479 { 2480 if (obj_aout_external_syms (abfd) != NULL) 2481 { 2482 #ifdef USE_MMAP 2483 bfd_free_window (&obj_aout_sym_window (abfd)); 2484 #else 2485 free ((void *) obj_aout_external_syms (abfd)); 2486 #endif 2487 obj_aout_external_syms (abfd) = NULL; 2488 } 2489 2490 if (obj_aout_external_strings (abfd) != NULL) 2491 { 2492 #ifdef USE_MMAP 2493 bfd_free_window (&obj_aout_string_window (abfd)); 2494 #else 2495 free ((void *) obj_aout_external_strings (abfd)); 2496 #endif 2497 obj_aout_external_strings (abfd) = NULL; 2498 } 2499 return TRUE; 2500 } 2501 2502 /* Given an a.out BFD, add symbols to the global hash table as 2503 appropriate. */ 2504 2505 bfd_boolean 2506 NAME (aout, link_add_symbols) (bfd *abfd, struct bfd_link_info *info) 2507 { 2508 switch (bfd_get_format (abfd)) 2509 { 2510 case bfd_object: 2511 return aout_link_add_object_symbols (abfd, info); 2512 case bfd_archive: 2513 return _bfd_generic_link_add_archive_symbols 2514 (abfd, info, aout_link_check_archive_element); 2515 default: 2516 bfd_set_error (bfd_error_wrong_format); 2517 return FALSE; 2518 } 2519 } 2520 2521 /* Add symbols from an a.out object file. */ 2522 2523 static bfd_boolean 2524 aout_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info) 2525 { 2526 if (! aout_get_external_symbols (abfd)) 2527 return FALSE; 2528 if (! aout_link_add_symbols (abfd, info)) 2529 return FALSE; 2530 if (! info->keep_memory) 2531 { 2532 if (! aout_link_free_symbols (abfd)) 2533 return FALSE; 2534 } 2535 return TRUE; 2536 } 2537 2538 /* Look through the internal symbols to see if this object file should 2539 be included in the link. We should include this object file if it 2540 defines any symbols which are currently undefined. If this object 2541 file defines a common symbol, then we may adjust the size of the 2542 known symbol but we do not include the object file in the link 2543 (unless there is some other reason to include it). */ 2544 2545 static bfd_boolean 2546 aout_link_check_ar_symbols (bfd *abfd, 2547 struct bfd_link_info *info, 2548 bfd_boolean *pneeded, 2549 bfd **subsbfd) 2550 { 2551 struct external_nlist *p; 2552 struct external_nlist *pend; 2553 char *strings; 2554 2555 *pneeded = FALSE; 2556 2557 /* Look through all the symbols. */ 2558 p = obj_aout_external_syms (abfd); 2559 pend = p + obj_aout_external_sym_count (abfd); 2560 strings = obj_aout_external_strings (abfd); 2561 for (; p < pend; p++) 2562 { 2563 int type = H_GET_8 (abfd, p->e_type); 2564 const char *name; 2565 struct bfd_link_hash_entry *h; 2566 2567 /* Ignore symbols that are not externally visible. This is an 2568 optimization only, as we check the type more thoroughly 2569 below. */ 2570 if ((type & N_EXT) == 0 2571 || type == N_FN) 2572 continue; 2573 2574 name = strings + GET_WORD (abfd, p->e_strx); 2575 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE); 2576 2577 /* We are only interested in symbols that are currently 2578 undefined or common. */ 2579 if (h == NULL 2580 || (h->type != bfd_link_hash_undefined 2581 && h->type != bfd_link_hash_common)) 2582 continue; 2583 2584 if (type == (N_TEXT | N_EXT) 2585 || type == (N_DATA | N_EXT) 2586 || type == (N_BSS | N_EXT) 2587 || type == (N_ABS | N_EXT)) 2588 { 2589 /* This object file defines this symbol. We must link it 2590 in. This is true regardless of whether the current 2591 definition of the symbol is undefined or common. If the 2592 current definition is common, we have a case in which we 2593 have already seen an object file including 2594 int a; 2595 and this object file from the archive includes 2596 int a = 5; 2597 In such a case we must include this object file. 2598 2599 FIXME: The SunOS 4.1.3 linker will pull in the archive 2600 element if the symbol is defined in the .data section, 2601 but not if it is defined in the .text section. That 2602 seems a bit crazy to me, and I haven't implemented it. 2603 However, it might be correct. */ 2604 if (!(*info->callbacks 2605 ->add_archive_element) (info, abfd, name, subsbfd)) 2606 return FALSE; 2607 *pneeded = TRUE; 2608 return TRUE; 2609 } 2610 2611 if (type == (N_UNDF | N_EXT)) 2612 { 2613 bfd_vma value; 2614 2615 value = GET_WORD (abfd, p->e_value); 2616 if (value != 0) 2617 { 2618 /* This symbol is common in the object from the archive 2619 file. */ 2620 if (h->type == bfd_link_hash_undefined) 2621 { 2622 bfd *symbfd; 2623 unsigned int power; 2624 2625 symbfd = h->u.undef.abfd; 2626 if (symbfd == NULL) 2627 { 2628 /* This symbol was created as undefined from 2629 outside BFD. We assume that we should link 2630 in the object file. This is done for the -u 2631 option in the linker. */ 2632 if (!(*info->callbacks 2633 ->add_archive_element) (info, abfd, name, subsbfd)) 2634 return FALSE; 2635 *pneeded = TRUE; 2636 return TRUE; 2637 } 2638 /* Turn the current link symbol into a common 2639 symbol. It is already on the undefs list. */ 2640 h->type = bfd_link_hash_common; 2641 h->u.c.p = bfd_hash_allocate (&info->hash->table, 2642 sizeof (struct bfd_link_hash_common_entry)); 2643 if (h->u.c.p == NULL) 2644 return FALSE; 2645 2646 h->u.c.size = value; 2647 2648 /* FIXME: This isn't quite right. The maximum 2649 alignment of a common symbol should be set by the 2650 architecture of the output file, not of the input 2651 file. */ 2652 power = bfd_log2 (value); 2653 if (power > bfd_get_arch_info (abfd)->section_align_power) 2654 power = bfd_get_arch_info (abfd)->section_align_power; 2655 h->u.c.p->alignment_power = power; 2656 2657 h->u.c.p->section = bfd_make_section_old_way (symbfd, 2658 "COMMON"); 2659 } 2660 else 2661 { 2662 /* Adjust the size of the common symbol if 2663 necessary. */ 2664 if (value > h->u.c.size) 2665 h->u.c.size = value; 2666 } 2667 } 2668 } 2669 } 2670 2671 /* We do not need this object file. */ 2672 return TRUE; 2673 } 2674 2675 /* Check a single archive element to see if we need to include it in 2676 the link. *PNEEDED is set according to whether this element is 2677 needed in the link or not. This is called from 2678 _bfd_generic_link_add_archive_symbols. */ 2679 2680 static bfd_boolean 2681 aout_link_check_archive_element (bfd *abfd, 2682 struct bfd_link_info *info, 2683 bfd_boolean *pneeded) 2684 { 2685 bfd *oldbfd; 2686 bfd_boolean needed; 2687 2688 if (!aout_get_external_symbols (abfd)) 2689 return FALSE; 2690 2691 oldbfd = abfd; 2692 if (!aout_link_check_ar_symbols (abfd, info, pneeded, &abfd)) 2693 return FALSE; 2694 2695 needed = *pneeded; 2696 if (needed) 2697 { 2698 /* Potentially, the add_archive_element hook may have set a 2699 substitute BFD for us. */ 2700 if (abfd != oldbfd) 2701 { 2702 if (!info->keep_memory 2703 && !aout_link_free_symbols (oldbfd)) 2704 return FALSE; 2705 if (!aout_get_external_symbols (abfd)) 2706 return FALSE; 2707 } 2708 if (!aout_link_add_symbols (abfd, info)) 2709 return FALSE; 2710 } 2711 2712 if (!info->keep_memory || !needed) 2713 { 2714 if (!aout_link_free_symbols (abfd)) 2715 return FALSE; 2716 } 2717 2718 return TRUE; 2719 } 2720 2721 /* Add all symbols from an object file to the hash table. */ 2722 2723 static bfd_boolean 2724 aout_link_add_symbols (bfd *abfd, struct bfd_link_info *info) 2725 { 2726 bfd_boolean (*add_one_symbol) 2727 (struct bfd_link_info *, bfd *, const char *, flagword, asection *, 2728 bfd_vma, const char *, bfd_boolean, bfd_boolean, 2729 struct bfd_link_hash_entry **); 2730 struct external_nlist *syms; 2731 bfd_size_type sym_count; 2732 char *strings; 2733 bfd_boolean copy; 2734 struct aout_link_hash_entry **sym_hash; 2735 struct external_nlist *p; 2736 struct external_nlist *pend; 2737 2738 syms = obj_aout_external_syms (abfd); 2739 sym_count = obj_aout_external_sym_count (abfd); 2740 strings = obj_aout_external_strings (abfd); 2741 if (info->keep_memory) 2742 copy = FALSE; 2743 else 2744 copy = TRUE; 2745 2746 if (aout_backend_info (abfd)->add_dynamic_symbols != NULL) 2747 { 2748 if (! ((*aout_backend_info (abfd)->add_dynamic_symbols) 2749 (abfd, info, &syms, &sym_count, &strings))) 2750 return FALSE; 2751 } 2752 2753 /* We keep a list of the linker hash table entries that correspond 2754 to particular symbols. We could just look them up in the hash 2755 table, but keeping the list is more efficient. Perhaps this 2756 should be conditional on info->keep_memory. */ 2757 sym_hash = bfd_alloc (abfd, 2758 sym_count * sizeof (struct aout_link_hash_entry *)); 2759 if (sym_hash == NULL && sym_count != 0) 2760 return FALSE; 2761 obj_aout_sym_hashes (abfd) = sym_hash; 2762 2763 add_one_symbol = aout_backend_info (abfd)->add_one_symbol; 2764 if (add_one_symbol == NULL) 2765 add_one_symbol = _bfd_generic_link_add_one_symbol; 2766 2767 p = syms; 2768 pend = p + sym_count; 2769 for (; p < pend; p++, sym_hash++) 2770 { 2771 int type; 2772 const char *name; 2773 bfd_vma value; 2774 asection *section; 2775 flagword flags; 2776 const char *string; 2777 2778 *sym_hash = NULL; 2779 2780 type = H_GET_8 (abfd, p->e_type); 2781 2782 name = strings + GET_WORD (abfd, p->e_strx); 2783 value = GET_WORD (abfd, p->e_value); 2784 flags = BSF_GLOBAL; 2785 string = NULL; 2786 switch (type) 2787 { 2788 default: 2789 /* Anything else should be a debugging symbol. */ 2790 BFD_ASSERT ((type & N_STAB) != 0); 2791 continue; 2792 2793 case N_UNDF: 2794 case N_ABS: 2795 case N_TEXT: 2796 case N_DATA: 2797 case N_BSS: 2798 case N_REG: 2799 case N_FN: 2800 /* Ignore symbols that are not externally visible. */ 2801 continue; 2802 2803 case N_UNDF | N_EXT: 2804 if (value == 0) 2805 { 2806 section = bfd_und_section_ptr; 2807 flags = 0; 2808 } 2809 else 2810 section = bfd_com_section_ptr; 2811 break; 2812 case N_ABS | N_EXT: 2813 section = bfd_abs_section_ptr; 2814 break; 2815 case N_TEXT | N_EXT: 2816 section = obj_textsec (abfd); 2817 value -= bfd_get_section_vma (abfd, section); 2818 break; 2819 case N_DATA | N_EXT: 2820 /* Treat N_SETV symbols as N_DATA symbol; see comment in 2821 translate_from_native_sym_flags. */ 2822 section = obj_datasec (abfd); 2823 value -= bfd_get_section_vma (abfd, section); 2824 break; 2825 case N_BSS | N_EXT: 2826 section = obj_bsssec (abfd); 2827 value -= bfd_get_section_vma (abfd, section); 2828 break; 2829 } 2830 2831 if (! ((*add_one_symbol) 2832 (info, abfd, name, flags, section, value, string, copy, FALSE, 2833 (struct bfd_link_hash_entry **) sym_hash))) 2834 return FALSE; 2835 2836 /* Restrict the maximum alignment of a common symbol based on 2837 the architecture, since a.out has no way to represent 2838 alignment requirements of a section in a .o file. FIXME: 2839 This isn't quite right: it should use the architecture of the 2840 output file, not the input files. */ 2841 if ((*sym_hash)->root.type == bfd_link_hash_common 2842 && ((*sym_hash)->root.u.c.p->alignment_power > 2843 bfd_get_arch_info (abfd)->section_align_power)) 2844 (*sym_hash)->root.u.c.p->alignment_power = 2845 bfd_get_arch_info (abfd)->section_align_power; 2846 2847 /* If this is a set symbol, and we are not building sets, then 2848 it is possible for the hash entry to not have been set. In 2849 such a case, treat the symbol as not globally defined. */ 2850 if ((*sym_hash)->root.type == bfd_link_hash_new) 2851 { 2852 BFD_ASSERT ((flags & BSF_CONSTRUCTOR) != 0); 2853 *sym_hash = NULL; 2854 } 2855 } 2856 2857 return TRUE; 2858 } 2859 2860 /* Look up an entry in an the header file hash table. */ 2861 2862 #define aout_link_includes_lookup(table, string, create, copy) \ 2863 ((struct aout_link_includes_entry *) \ 2864 bfd_hash_lookup (&(table)->root, (string), (create), (copy))) 2865 2866 /* The function to create a new entry in the header file hash table. */ 2867 2868 static struct bfd_hash_entry * 2869 aout_link_includes_newfunc (struct bfd_hash_entry *entry, 2870 struct bfd_hash_table *table, 2871 const char *string) 2872 { 2873 struct aout_link_includes_entry * ret = 2874 (struct aout_link_includes_entry *) entry; 2875 2876 /* Allocate the structure if it has not already been allocated by a 2877 subclass. */ 2878 if (ret == NULL) 2879 ret = bfd_hash_allocate (table, 2880 sizeof (struct aout_link_includes_entry)); 2881 if (ret == NULL) 2882 return NULL; 2883 2884 /* Call the allocation method of the superclass. */ 2885 ret = ((struct aout_link_includes_entry *) 2886 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string)); 2887 if (ret) 2888 /* Set local fields. */ 2889 ret->totals = NULL; 2890 2891 return (struct bfd_hash_entry *) ret; 2892 } 2893 2894 static bfd_boolean 2895 aout_link_write_other_symbol (struct bfd_hash_entry *bh, void *data) 2896 { 2897 struct aout_link_hash_entry *h = (struct aout_link_hash_entry *) bh; 2898 struct aout_final_link_info *flaginfo = (struct aout_final_link_info *) data; 2899 bfd *output_bfd; 2900 int type; 2901 bfd_vma val; 2902 struct external_nlist outsym; 2903 bfd_size_type indx; 2904 bfd_size_type amt; 2905 2906 if (h->root.type == bfd_link_hash_warning) 2907 { 2908 h = (struct aout_link_hash_entry *) h->root.u.i.link; 2909 if (h->root.type == bfd_link_hash_new) 2910 return TRUE; 2911 } 2912 2913 output_bfd = flaginfo->output_bfd; 2914 2915 if (aout_backend_info (output_bfd)->write_dynamic_symbol != NULL) 2916 { 2917 if (! ((*aout_backend_info (output_bfd)->write_dynamic_symbol) 2918 (output_bfd, flaginfo->info, h))) 2919 { 2920 /* FIXME: No way to handle errors. */ 2921 abort (); 2922 } 2923 } 2924 2925 if (h->written) 2926 return TRUE; 2927 2928 h->written = TRUE; 2929 2930 /* An indx of -2 means the symbol must be written. */ 2931 if (h->indx != -2 2932 && (flaginfo->info->strip == strip_all 2933 || (flaginfo->info->strip == strip_some 2934 && bfd_hash_lookup (flaginfo->info->keep_hash, h->root.root.string, 2935 FALSE, FALSE) == NULL))) 2936 return TRUE; 2937 2938 switch (h->root.type) 2939 { 2940 default: 2941 abort (); 2942 /* Avoid variable not initialized warnings. */ 2943 return TRUE; 2944 case bfd_link_hash_new: 2945 /* This can happen for set symbols when sets are not being 2946 built. */ 2947 return TRUE; 2948 case bfd_link_hash_undefined: 2949 type = N_UNDF | N_EXT; 2950 val = 0; 2951 break; 2952 case bfd_link_hash_defined: 2953 case bfd_link_hash_defweak: 2954 { 2955 asection *sec; 2956 2957 sec = h->root.u.def.section->output_section; 2958 BFD_ASSERT (bfd_is_abs_section (sec) 2959 || sec->owner == output_bfd); 2960 if (sec == obj_textsec (output_bfd)) 2961 type = h->root.type == bfd_link_hash_defined ? N_TEXT : N_WEAKT; 2962 else if (sec == obj_datasec (output_bfd)) 2963 type = h->root.type == bfd_link_hash_defined ? N_DATA : N_WEAKD; 2964 else if (sec == obj_bsssec (output_bfd)) 2965 type = h->root.type == bfd_link_hash_defined ? N_BSS : N_WEAKB; 2966 else 2967 type = h->root.type == bfd_link_hash_defined ? N_ABS : N_WEAKA; 2968 type |= N_EXT; 2969 val = (h->root.u.def.value 2970 + sec->vma 2971 + h->root.u.def.section->output_offset); 2972 } 2973 break; 2974 case bfd_link_hash_common: 2975 type = N_UNDF | N_EXT; 2976 val = h->root.u.c.size; 2977 break; 2978 case bfd_link_hash_undefweak: 2979 type = N_WEAKU; 2980 val = 0; 2981 case bfd_link_hash_indirect: 2982 case bfd_link_hash_warning: 2983 /* FIXME: Ignore these for now. The circumstances under which 2984 they should be written out are not clear to me. */ 2985 return TRUE; 2986 } 2987 2988 H_PUT_8 (output_bfd, type, outsym.e_type); 2989 indx = add_to_stringtab (output_bfd, flaginfo->strtab, h->root.root.string, 2990 FALSE); 2991 if (indx == (bfd_size_type) -1) 2992 /* FIXME: No way to handle errors. */ 2993 abort (); 2994 2995 PUT_WORD (output_bfd, indx, outsym.e_strx); 2996 PUT_WORD (output_bfd, val, outsym.e_value); 2997 2998 amt = EXTERNAL_NLIST_SIZE; 2999 if (bfd_seek (output_bfd, flaginfo->symoff, SEEK_SET) != 0 3000 || bfd_bwrite ((void *) &outsym, amt, output_bfd) != amt) 3001 /* FIXME: No way to handle errors. */ 3002 abort (); 3003 3004 flaginfo->symoff += amt; 3005 h->indx = obj_aout_external_sym_count (output_bfd); 3006 ++obj_aout_external_sym_count (output_bfd); 3007 3008 return TRUE; 3009 } 3010 3011 /* Handle a link order which is supposed to generate a reloc. */ 3012 3013 static bfd_boolean 3014 aout_link_reloc_link_order (struct aout_final_link_info *flaginfo, 3015 asection *o, 3016 struct bfd_link_order *p) 3017 { 3018 struct bfd_link_order_reloc *pr; 3019 int r_index; 3020 int r_extern; 3021 reloc_howto_type *howto; 3022 file_ptr *reloff_ptr; 3023 struct reloc_std_external srel; 3024 void * rel_ptr; 3025 bfd_size_type rel_size; 3026 3027 pr = p->u.reloc.p; 3028 3029 if (p->type == bfd_section_reloc_link_order) 3030 { 3031 r_extern = 0; 3032 if (bfd_is_abs_section (pr->u.section)) 3033 r_index = N_ABS | N_EXT; 3034 else 3035 { 3036 BFD_ASSERT (pr->u.section->owner == flaginfo->output_bfd); 3037 r_index = pr->u.section->target_index; 3038 } 3039 } 3040 else 3041 { 3042 struct aout_link_hash_entry *h; 3043 3044 BFD_ASSERT (p->type == bfd_symbol_reloc_link_order); 3045 r_extern = 1; 3046 h = ((struct aout_link_hash_entry *) 3047 bfd_wrapped_link_hash_lookup (flaginfo->output_bfd, flaginfo->info, 3048 pr->u.name, FALSE, FALSE, TRUE)); 3049 if (h != NULL 3050 && h->indx >= 0) 3051 r_index = h->indx; 3052 else if (h != NULL) 3053 { 3054 /* We decided to strip this symbol, but it turns out that we 3055 can't. Note that we lose the other and desc information 3056 here. I don't think that will ever matter for a global 3057 symbol. */ 3058 h->indx = -2; 3059 h->written = FALSE; 3060 if (!aout_link_write_other_symbol (&h->root.root, flaginfo)) 3061 return FALSE; 3062 r_index = h->indx; 3063 } 3064 else 3065 { 3066 if (! ((*flaginfo->info->callbacks->unattached_reloc) 3067 (flaginfo->info, pr->u.name, NULL, NULL, (bfd_vma) 0))) 3068 return FALSE; 3069 r_index = 0; 3070 } 3071 } 3072 3073 howto = bfd_reloc_type_lookup (flaginfo->output_bfd, pr->reloc); 3074 if (howto == 0) 3075 { 3076 bfd_set_error (bfd_error_bad_value); 3077 return FALSE; 3078 } 3079 3080 if (o == obj_textsec (flaginfo->output_bfd)) 3081 reloff_ptr = &flaginfo->treloff; 3082 else if (o == obj_datasec (flaginfo->output_bfd)) 3083 reloff_ptr = &flaginfo->dreloff; 3084 else 3085 abort (); 3086 3087 #ifdef MY_put_reloc 3088 MY_put_reloc(flaginfo->output_bfd, r_extern, r_index, p->offset, howto, 3089 &srel); 3090 #else 3091 { 3092 int r_pcrel; 3093 int r_baserel; 3094 int r_jmptable; 3095 int r_relative; 3096 int r_length; 3097 3098 fprintf (stderr, "TODO: line %d in bfd/pdp11.c\n", __LINE__); 3099 3100 r_pcrel = howto->pc_relative; 3101 r_baserel = (howto->type & 8) != 0; 3102 r_jmptable = (howto->type & 16) != 0; 3103 r_relative = (howto->type & 32) != 0; 3104 r_length = howto->size; 3105 3106 PUT_WORD (flaginfo->output_bfd, p->offset, srel.r_address); 3107 if (bfd_header_big_endian (flaginfo->output_bfd)) 3108 { 3109 srel.r_index[0] = r_index >> 16; 3110 srel.r_index[1] = r_index >> 8; 3111 srel.r_index[2] = r_index; 3112 srel.r_type[0] = 3113 ((r_extern ? RELOC_STD_BITS_EXTERN_BIG : 0) 3114 | (r_pcrel ? RELOC_STD_BITS_PCREL_BIG : 0) 3115 | (r_baserel ? RELOC_STD_BITS_BASEREL_BIG : 0) 3116 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0) 3117 | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0) 3118 | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG)); 3119 } 3120 else 3121 { 3122 srel.r_index[2] = r_index >> 16; 3123 srel.r_index[1] = r_index >> 8; 3124 srel.r_index[0] = r_index; 3125 srel.r_type[0] = 3126 ((r_extern ? RELOC_STD_BITS_EXTERN_LITTLE : 0) 3127 | (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE : 0) 3128 | (r_baserel ? RELOC_STD_BITS_BASEREL_LITTLE : 0) 3129 | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0) 3130 | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0) 3131 | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE)); 3132 } 3133 } 3134 #endif 3135 rel_ptr = (void *) &srel; 3136 3137 /* We have to write the addend into the object file, since 3138 standard a.out relocs are in place. It would be more 3139 reliable if we had the current contents of the file here, 3140 rather than assuming zeroes, but we can't read the file since 3141 it was opened using bfd_openw. */ 3142 if (pr->addend != 0) 3143 { 3144 bfd_size_type size; 3145 bfd_reloc_status_type r; 3146 bfd_byte *buf; 3147 bfd_boolean ok; 3148 3149 size = bfd_get_reloc_size (howto); 3150 buf = bfd_zmalloc (size); 3151 if (buf == NULL) 3152 return FALSE; 3153 r = MY_relocate_contents (howto, flaginfo->output_bfd, 3154 pr->addend, buf); 3155 switch (r) 3156 { 3157 case bfd_reloc_ok: 3158 break; 3159 default: 3160 case bfd_reloc_outofrange: 3161 abort (); 3162 case bfd_reloc_overflow: 3163 if (! ((*flaginfo->info->callbacks->reloc_overflow) 3164 (flaginfo->info, NULL, 3165 (p->type == bfd_section_reloc_link_order 3166 ? bfd_section_name (flaginfo->output_bfd, 3167 pr->u.section) 3168 : pr->u.name), 3169 howto->name, pr->addend, NULL, 3170 (asection *) NULL, (bfd_vma) 0))) 3171 { 3172 free (buf); 3173 return FALSE; 3174 } 3175 break; 3176 } 3177 ok = bfd_set_section_contents (flaginfo->output_bfd, o, 3178 (void *) buf, 3179 (file_ptr) p->offset, 3180 size); 3181 free (buf); 3182 if (! ok) 3183 return FALSE; 3184 } 3185 3186 rel_size = obj_reloc_entry_size (flaginfo->output_bfd); 3187 if (bfd_seek (flaginfo->output_bfd, *reloff_ptr, SEEK_SET) != 0 3188 || bfd_bwrite (rel_ptr, rel_size, flaginfo->output_bfd) != rel_size) 3189 return FALSE; 3190 3191 *reloff_ptr += rel_size; 3192 3193 /* Assert that the relocs have not run into the symbols, and that n 3194 the text relocs have not run into the data relocs. */ 3195 BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (flaginfo->output_bfd) 3196 && (reloff_ptr != &flaginfo->treloff 3197 || (*reloff_ptr 3198 <= obj_datasec (flaginfo->output_bfd)->rel_filepos))); 3199 3200 return TRUE; 3201 } 3202 3203 /* Get the section corresponding to a reloc index. */ 3204 3205 static inline asection * 3206 aout_reloc_type_to_section (bfd *abfd, int type) 3207 { 3208 switch (type) 3209 { 3210 case RTEXT: return obj_textsec (abfd); 3211 case RDATA: return obj_datasec (abfd); 3212 case RBSS: return obj_bsssec (abfd); 3213 case RABS: return bfd_abs_section_ptr; 3214 case REXT: return bfd_und_section_ptr; 3215 default: abort (); 3216 } 3217 } 3218 3219 static bfd_boolean 3220 pdp11_aout_link_input_section (struct aout_final_link_info *flaginfo, 3221 bfd *input_bfd, 3222 asection *input_section, 3223 bfd_byte *relocs, 3224 bfd_size_type rel_size, 3225 bfd_byte *contents) 3226 { 3227 bfd_boolean (*check_dynamic_reloc) 3228 (struct bfd_link_info *, bfd *, asection *, 3229 struct aout_link_hash_entry *, void *, bfd_byte *, bfd_boolean *, 3230 bfd_vma *); 3231 bfd *output_bfd; 3232 bfd_boolean relocatable; 3233 struct external_nlist *syms; 3234 char *strings; 3235 struct aout_link_hash_entry **sym_hashes; 3236 int *symbol_map; 3237 bfd_byte *rel; 3238 bfd_byte *rel_end; 3239 3240 output_bfd = flaginfo->output_bfd; 3241 check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc; 3242 3243 BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_SIZE); 3244 BFD_ASSERT (input_bfd->xvec->header_byteorder 3245 == output_bfd->xvec->header_byteorder); 3246 3247 relocatable = flaginfo->info->relocatable; 3248 syms = obj_aout_external_syms (input_bfd); 3249 strings = obj_aout_external_strings (input_bfd); 3250 sym_hashes = obj_aout_sym_hashes (input_bfd); 3251 symbol_map = flaginfo->symbol_map; 3252 3253 rel = relocs; 3254 rel_end = rel + rel_size; 3255 for (; rel < rel_end; rel += RELOC_SIZE) 3256 { 3257 bfd_vma r_addr; 3258 int r_index; 3259 int r_type; 3260 int r_pcrel; 3261 int r_extern; 3262 reloc_howto_type *howto; 3263 struct aout_link_hash_entry *h = NULL; 3264 bfd_vma relocation; 3265 bfd_reloc_status_type r; 3266 int reloc_entry; 3267 3268 reloc_entry = GET_WORD (input_bfd, (void *) rel); 3269 if (reloc_entry == 0) 3270 continue; 3271 3272 { 3273 unsigned int howto_idx; 3274 3275 r_index = (reloc_entry & RIDXMASK) >> 4; 3276 r_type = reloc_entry & RTYPE; 3277 r_pcrel = reloc_entry & RELFLG; 3278 r_addr = (char *) rel - (char *) relocs; 3279 3280 r_extern = (r_type == REXT); 3281 3282 howto_idx = r_pcrel; 3283 BFD_ASSERT (howto_idx < TABLE_SIZE (howto_table_pdp11)); 3284 howto = howto_table_pdp11 + howto_idx; 3285 } 3286 3287 if (relocatable) 3288 { 3289 /* We are generating a relocatable output file, and must 3290 modify the reloc accordingly. */ 3291 if (r_extern) 3292 { 3293 /* If we know the symbol this relocation is against, 3294 convert it into a relocation against a section. This 3295 is what the native linker does. */ 3296 h = sym_hashes[r_index]; 3297 if (h != NULL 3298 && (h->root.type == bfd_link_hash_defined 3299 || h->root.type == bfd_link_hash_defweak)) 3300 { 3301 asection *output_section; 3302 3303 /* Compute a new r_index. */ 3304 output_section = h->root.u.def.section->output_section; 3305 if (output_section == obj_textsec (output_bfd)) 3306 r_type = N_TEXT; 3307 else if (output_section == obj_datasec (output_bfd)) 3308 r_type = N_DATA; 3309 else if (output_section == obj_bsssec (output_bfd)) 3310 r_type = N_BSS; 3311 else 3312 r_type = N_ABS; 3313 3314 /* Add the symbol value and the section VMA to the 3315 addend stored in the contents. */ 3316 relocation = (h->root.u.def.value 3317 + output_section->vma 3318 + h->root.u.def.section->output_offset); 3319 } 3320 else 3321 { 3322 /* We must change r_index according to the symbol 3323 map. */ 3324 r_index = symbol_map[r_index]; 3325 3326 if (r_index == -1) 3327 { 3328 if (h != NULL) 3329 { 3330 /* We decided to strip this symbol, but it 3331 turns out that we can't. Note that we 3332 lose the other and desc information here. 3333 I don't think that will ever matter for a 3334 global symbol. */ 3335 if (h->indx < 0) 3336 { 3337 h->indx = -2; 3338 h->written = FALSE; 3339 if (!aout_link_write_other_symbol (&h->root.root, 3340 flaginfo)) 3341 return FALSE; 3342 } 3343 r_index = h->indx; 3344 } 3345 else 3346 { 3347 const char *name; 3348 3349 name = strings + GET_WORD (input_bfd, 3350 syms[r_index].e_strx); 3351 if (! ((*flaginfo->info->callbacks->unattached_reloc) 3352 (flaginfo->info, name, input_bfd, input_section, 3353 r_addr))) 3354 return FALSE; 3355 r_index = 0; 3356 } 3357 } 3358 3359 relocation = 0; 3360 } 3361 3362 /* Write out the new r_index value. */ 3363 reloc_entry = GET_WORD (input_bfd, rel); 3364 reloc_entry &= RIDXMASK; 3365 reloc_entry |= r_index << 4; 3366 PUT_WORD (input_bfd, reloc_entry, rel); 3367 } 3368 else 3369 { 3370 asection *section; 3371 3372 /* This is a relocation against a section. We must 3373 adjust by the amount that the section moved. */ 3374 section = aout_reloc_type_to_section (input_bfd, r_type); 3375 relocation = (section->output_section->vma 3376 + section->output_offset 3377 - section->vma); 3378 } 3379 3380 /* Change the address of the relocation. */ 3381 fprintf (stderr, "TODO: change the address of the relocation\n"); 3382 3383 /* Adjust a PC relative relocation by removing the reference 3384 to the original address in the section and including the 3385 reference to the new address. */ 3386 if (r_pcrel) 3387 relocation -= (input_section->output_section->vma 3388 + input_section->output_offset 3389 - input_section->vma); 3390 3391 #ifdef MY_relocatable_reloc 3392 MY_relocatable_reloc (howto, output_bfd, rel, relocation, r_addr); 3393 #endif 3394 3395 if (relocation == 0) 3396 r = bfd_reloc_ok; 3397 else 3398 r = MY_relocate_contents (howto, 3399 input_bfd, relocation, 3400 contents + r_addr); 3401 } 3402 else 3403 { 3404 bfd_boolean hundef; 3405 3406 /* We are generating an executable, and must do a full 3407 relocation. */ 3408 hundef = FALSE; 3409 if (r_extern) 3410 { 3411 h = sym_hashes[r_index]; 3412 3413 if (h != NULL 3414 && (h->root.type == bfd_link_hash_defined 3415 || h->root.type == bfd_link_hash_defweak)) 3416 { 3417 relocation = (h->root.u.def.value 3418 + h->root.u.def.section->output_section->vma 3419 + h->root.u.def.section->output_offset); 3420 } 3421 else if (h != NULL 3422 && h->root.type == bfd_link_hash_undefweak) 3423 relocation = 0; 3424 else 3425 { 3426 hundef = TRUE; 3427 relocation = 0; 3428 } 3429 } 3430 else 3431 { 3432 asection *section; 3433 3434 section = aout_reloc_type_to_section (input_bfd, r_type); 3435 relocation = (section->output_section->vma 3436 + section->output_offset 3437 - section->vma); 3438 if (r_pcrel) 3439 relocation += input_section->vma; 3440 } 3441 3442 if (check_dynamic_reloc != NULL) 3443 { 3444 bfd_boolean skip; 3445 3446 if (! ((*check_dynamic_reloc) 3447 (flaginfo->info, input_bfd, input_section, h, 3448 (void *) rel, contents, &skip, &relocation))) 3449 return FALSE; 3450 if (skip) 3451 continue; 3452 } 3453 3454 /* Now warn if a global symbol is undefined. We could not 3455 do this earlier, because check_dynamic_reloc might want 3456 to skip this reloc. */ 3457 if (hundef && ! flaginfo->info->shared) 3458 { 3459 const char *name; 3460 3461 if (h != NULL) 3462 name = h->root.root.string; 3463 else 3464 name = strings + GET_WORD (input_bfd, syms[r_index].e_strx); 3465 if (! ((*flaginfo->info->callbacks->undefined_symbol) 3466 (flaginfo->info, name, input_bfd, input_section, 3467 r_addr, TRUE))) 3468 return FALSE; 3469 } 3470 3471 r = MY_final_link_relocate (howto, 3472 input_bfd, input_section, 3473 contents, r_addr, relocation, 3474 (bfd_vma) 0); 3475 } 3476 3477 if (r != bfd_reloc_ok) 3478 { 3479 switch (r) 3480 { 3481 default: 3482 case bfd_reloc_outofrange: 3483 abort (); 3484 case bfd_reloc_overflow: 3485 { 3486 const char *name; 3487 3488 if (h != NULL) 3489 name = NULL; 3490 else if (r_extern) 3491 name = strings + GET_WORD (input_bfd, 3492 syms[r_index].e_strx); 3493 else 3494 { 3495 asection *s; 3496 3497 s = aout_reloc_type_to_section (input_bfd, r_type); 3498 name = bfd_section_name (input_bfd, s); 3499 } 3500 if (! ((*flaginfo->info->callbacks->reloc_overflow) 3501 (flaginfo->info, (h ? &h->root : NULL), name, 3502 howto->name, (bfd_vma) 0, input_bfd, 3503 input_section, r_addr))) 3504 return FALSE; 3505 } 3506 break; 3507 } 3508 } 3509 } 3510 3511 return TRUE; 3512 } 3513 3514 /* Link an a.out section into the output file. */ 3515 3516 static bfd_boolean 3517 aout_link_input_section (struct aout_final_link_info *flaginfo, 3518 bfd *input_bfd, 3519 asection *input_section, 3520 file_ptr *reloff_ptr, 3521 bfd_size_type rel_size) 3522 { 3523 bfd_size_type input_size; 3524 void * relocs; 3525 3526 /* Get the section contents. */ 3527 input_size = input_section->size; 3528 if (! bfd_get_section_contents (input_bfd, input_section, 3529 (void *) flaginfo->contents, 3530 (file_ptr) 0, input_size)) 3531 return FALSE; 3532 3533 /* Read in the relocs if we haven't already done it. */ 3534 if (aout_section_data (input_section) != NULL 3535 && aout_section_data (input_section)->relocs != NULL) 3536 relocs = aout_section_data (input_section)->relocs; 3537 else 3538 { 3539 relocs = flaginfo->relocs; 3540 if (rel_size > 0) 3541 { 3542 if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0 3543 || bfd_bread (relocs, rel_size, input_bfd) != rel_size) 3544 return FALSE; 3545 } 3546 } 3547 3548 /* Relocate the section contents. */ 3549 if (! pdp11_aout_link_input_section (flaginfo, input_bfd, input_section, 3550 (bfd_byte *) relocs, 3551 rel_size, flaginfo->contents)) 3552 return FALSE; 3553 3554 /* Write out the section contents. */ 3555 if (! bfd_set_section_contents (flaginfo->output_bfd, 3556 input_section->output_section, 3557 (void *) flaginfo->contents, 3558 (file_ptr) input_section->output_offset, 3559 input_size)) 3560 return FALSE; 3561 3562 /* If we are producing relocatable output, the relocs were 3563 modified, and we now write them out. */ 3564 if (flaginfo->info->relocatable && rel_size > 0) 3565 { 3566 if (bfd_seek (flaginfo->output_bfd, *reloff_ptr, SEEK_SET) != 0) 3567 return FALSE; 3568 if (bfd_bwrite (relocs, rel_size, flaginfo->output_bfd) != rel_size) 3569 return FALSE; 3570 *reloff_ptr += rel_size; 3571 3572 /* Assert that the relocs have not run into the symbols, and 3573 that if these are the text relocs they have not run into the 3574 data relocs. */ 3575 BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (flaginfo->output_bfd) 3576 && (reloff_ptr != &flaginfo->treloff 3577 || (*reloff_ptr 3578 <= obj_datasec (flaginfo->output_bfd)->rel_filepos))); 3579 } 3580 3581 return TRUE; 3582 } 3583 3584 /* Link an a.out input BFD into the output file. */ 3585 3586 static bfd_boolean 3587 aout_link_input_bfd (struct aout_final_link_info *flaginfo, bfd *input_bfd) 3588 { 3589 BFD_ASSERT (bfd_get_format (input_bfd) == bfd_object); 3590 3591 /* If this is a dynamic object, it may need special handling. */ 3592 if ((input_bfd->flags & DYNAMIC) != 0 3593 && aout_backend_info (input_bfd)->link_dynamic_object != NULL) 3594 return ((*aout_backend_info (input_bfd)->link_dynamic_object) 3595 (flaginfo->info, input_bfd)); 3596 3597 /* Get the symbols. We probably have them already, unless 3598 flaginfo->info->keep_memory is FALSE. */ 3599 if (! aout_get_external_symbols (input_bfd)) 3600 return FALSE; 3601 3602 /* Write out the symbols and get a map of the new indices. The map 3603 is placed into flaginfo->symbol_map. */ 3604 if (! aout_link_write_symbols (flaginfo, input_bfd)) 3605 return FALSE; 3606 3607 /* Relocate and write out the sections. These functions use the 3608 symbol map created by aout_link_write_symbols. The linker_mark 3609 field will be set if these sections are to be included in the 3610 link, which will normally be the case. */ 3611 if (obj_textsec (input_bfd)->linker_mark) 3612 { 3613 if (! aout_link_input_section (flaginfo, input_bfd, 3614 obj_textsec (input_bfd), 3615 &flaginfo->treloff, 3616 exec_hdr (input_bfd)->a_trsize)) 3617 return FALSE; 3618 } 3619 if (obj_datasec (input_bfd)->linker_mark) 3620 { 3621 if (! aout_link_input_section (flaginfo, input_bfd, 3622 obj_datasec (input_bfd), 3623 &flaginfo->dreloff, 3624 exec_hdr (input_bfd)->a_drsize)) 3625 return FALSE; 3626 } 3627 3628 /* If we are not keeping memory, we don't need the symbols any 3629 longer. We still need them if we are keeping memory, because the 3630 strings in the hash table point into them. */ 3631 if (! flaginfo->info->keep_memory) 3632 { 3633 if (! aout_link_free_symbols (input_bfd)) 3634 return FALSE; 3635 } 3636 3637 return TRUE; 3638 } 3639 3640 /* Do the final link step. This is called on the output BFD. The 3641 INFO structure should point to a list of BFDs linked through the 3642 link_next field which can be used to find each BFD which takes part 3643 in the output. Also, each section in ABFD should point to a list 3644 of bfd_link_order structures which list all the input sections for 3645 the output section. */ 3646 3647 bfd_boolean 3648 NAME (aout, final_link) (bfd *abfd, 3649 struct bfd_link_info *info, 3650 void (*callback) (bfd *, file_ptr *, file_ptr *, file_ptr *)) 3651 { 3652 struct aout_final_link_info aout_info; 3653 bfd_boolean includes_hash_initialized = FALSE; 3654 bfd *sub; 3655 bfd_size_type trsize, drsize; 3656 bfd_size_type max_contents_size; 3657 bfd_size_type max_relocs_size; 3658 bfd_size_type max_sym_count; 3659 bfd_size_type text_size; 3660 file_ptr text_end; 3661 struct bfd_link_order *p; 3662 asection *o; 3663 bfd_boolean have_link_order_relocs; 3664 3665 if (info->shared) 3666 abfd->flags |= DYNAMIC; 3667 3668 aout_info.info = info; 3669 aout_info.output_bfd = abfd; 3670 aout_info.contents = NULL; 3671 aout_info.relocs = NULL; 3672 aout_info.symbol_map = NULL; 3673 aout_info.output_syms = NULL; 3674 3675 if (!bfd_hash_table_init_n (&aout_info.includes.root, 3676 aout_link_includes_newfunc, 3677 sizeof (struct aout_link_includes_entry), 3678 251)) 3679 goto error_return; 3680 includes_hash_initialized = TRUE; 3681 3682 /* Figure out the largest section size. Also, if generating 3683 relocatable output, count the relocs. */ 3684 trsize = 0; 3685 drsize = 0; 3686 max_contents_size = 0; 3687 max_relocs_size = 0; 3688 max_sym_count = 0; 3689 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next) 3690 { 3691 size_t sz; 3692 3693 if (info->relocatable) 3694 { 3695 if (bfd_get_flavour (sub) == bfd_target_aout_flavour) 3696 { 3697 trsize += exec_hdr (sub)->a_trsize; 3698 drsize += exec_hdr (sub)->a_drsize; 3699 } 3700 else 3701 { 3702 /* FIXME: We need to identify the .text and .data sections 3703 and call get_reloc_upper_bound and canonicalize_reloc to 3704 work out the number of relocs needed, and then multiply 3705 by the reloc size. */ 3706 (*_bfd_error_handler) 3707 ("%s: relocatable link from %s to %s not supported", 3708 bfd_get_filename (abfd), 3709 sub->xvec->name, abfd->xvec->name); 3710 bfd_set_error (bfd_error_invalid_operation); 3711 goto error_return; 3712 } 3713 } 3714 3715 if (bfd_get_flavour (sub) == bfd_target_aout_flavour) 3716 { 3717 sz = obj_textsec (sub)->size; 3718 if (sz > max_contents_size) 3719 max_contents_size = sz; 3720 sz = obj_datasec (sub)->size; 3721 if (sz > max_contents_size) 3722 max_contents_size = sz; 3723 3724 sz = exec_hdr (sub)->a_trsize; 3725 if (sz > max_relocs_size) 3726 max_relocs_size = sz; 3727 sz = exec_hdr (sub)->a_drsize; 3728 if (sz > max_relocs_size) 3729 max_relocs_size = sz; 3730 3731 sz = obj_aout_external_sym_count (sub); 3732 if (sz > max_sym_count) 3733 max_sym_count = sz; 3734 } 3735 } 3736 3737 if (info->relocatable) 3738 { 3739 if (obj_textsec (abfd) != NULL) 3740 trsize += (_bfd_count_link_order_relocs (obj_textsec (abfd) 3741 ->map_head.link_order) 3742 * obj_reloc_entry_size (abfd)); 3743 if (obj_datasec (abfd) != NULL) 3744 drsize += (_bfd_count_link_order_relocs (obj_datasec (abfd) 3745 ->map_head.link_order) 3746 * obj_reloc_entry_size (abfd)); 3747 } 3748 3749 exec_hdr (abfd)->a_trsize = trsize; 3750 exec_hdr (abfd)->a_drsize = drsize; 3751 exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd); 3752 3753 /* Adjust the section sizes and vmas according to the magic number. 3754 This sets a_text, a_data and a_bss in the exec_hdr and sets the 3755 filepos for each section. */ 3756 if (! NAME (aout, adjust_sizes_and_vmas) (abfd, &text_size, &text_end)) 3757 goto error_return; 3758 3759 /* The relocation and symbol file positions differ among a.out 3760 targets. We are passed a callback routine from the backend 3761 specific code to handle this. 3762 FIXME: At this point we do not know how much space the symbol 3763 table will require. This will not work for any (nonstandard) 3764 a.out target that needs to know the symbol table size before it 3765 can compute the relocation file positions. This may or may not 3766 be the case for the hp300hpux target, for example. */ 3767 (*callback) (abfd, &aout_info.treloff, &aout_info.dreloff, 3768 &aout_info.symoff); 3769 obj_textsec (abfd)->rel_filepos = aout_info.treloff; 3770 obj_datasec (abfd)->rel_filepos = aout_info.dreloff; 3771 obj_sym_filepos (abfd) = aout_info.symoff; 3772 3773 /* We keep a count of the symbols as we output them. */ 3774 obj_aout_external_sym_count (abfd) = 0; 3775 3776 /* We accumulate the string table as we write out the symbols. */ 3777 aout_info.strtab = _bfd_stringtab_init (); 3778 if (aout_info.strtab == NULL) 3779 goto error_return; 3780 3781 /* Allocate buffers to hold section contents and relocs. */ 3782 aout_info.contents = bfd_malloc (max_contents_size); 3783 aout_info.relocs = bfd_malloc (max_relocs_size); 3784 aout_info.symbol_map = bfd_malloc (max_sym_count * sizeof (int *)); 3785 aout_info.output_syms = bfd_malloc ((max_sym_count + 1) 3786 * sizeof (struct external_nlist)); 3787 if ((aout_info.contents == NULL && max_contents_size != 0) 3788 || (aout_info.relocs == NULL && max_relocs_size != 0) 3789 || (aout_info.symbol_map == NULL && max_sym_count != 0) 3790 || aout_info.output_syms == NULL) 3791 goto error_return; 3792 3793 /* If we have a symbol named __DYNAMIC, force it out now. This is 3794 required by SunOS. Doing this here rather than in sunos.c is a 3795 hack, but it's easier than exporting everything which would be 3796 needed. */ 3797 { 3798 struct aout_link_hash_entry *h; 3799 3800 h = aout_link_hash_lookup (aout_hash_table (info), "__DYNAMIC", 3801 FALSE, FALSE, FALSE); 3802 if (h != NULL) 3803 aout_link_write_other_symbol (&h->root.root, &aout_info); 3804 } 3805 3806 /* The most time efficient way to do the link would be to read all 3807 the input object files into memory and then sort out the 3808 information into the output file. Unfortunately, that will 3809 probably use too much memory. Another method would be to step 3810 through everything that composes the text section and write it 3811 out, and then everything that composes the data section and write 3812 it out, and then write out the relocs, and then write out the 3813 symbols. Unfortunately, that requires reading stuff from each 3814 input file several times, and we will not be able to keep all the 3815 input files open simultaneously, and reopening them will be slow. 3816 3817 What we do is basically process one input file at a time. We do 3818 everything we need to do with an input file once--copy over the 3819 section contents, handle the relocation information, and write 3820 out the symbols--and then we throw away the information we read 3821 from it. This approach requires a lot of lseeks of the output 3822 file, which is unfortunate but still faster than reopening a lot 3823 of files. 3824 3825 We use the output_has_begun field of the input BFDs to see 3826 whether we have already handled it. */ 3827 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next) 3828 sub->output_has_begun = FALSE; 3829 3830 /* Mark all sections which are to be included in the link. This 3831 will normally be every section. We need to do this so that we 3832 can identify any sections which the linker has decided to not 3833 include. */ 3834 for (o = abfd->sections; o != NULL; o = o->next) 3835 { 3836 for (p = o->map_head.link_order; p != NULL; p = p->next) 3837 if (p->type == bfd_indirect_link_order) 3838 p->u.indirect.section->linker_mark = TRUE; 3839 } 3840 3841 have_link_order_relocs = FALSE; 3842 for (o = abfd->sections; o != NULL; o = o->next) 3843 { 3844 for (p = o->map_head.link_order; 3845 p != NULL; 3846 p = p->next) 3847 { 3848 if (p->type == bfd_indirect_link_order 3849 && (bfd_get_flavour (p->u.indirect.section->owner) 3850 == bfd_target_aout_flavour)) 3851 { 3852 bfd *input_bfd; 3853 3854 input_bfd = p->u.indirect.section->owner; 3855 if (! input_bfd->output_has_begun) 3856 { 3857 if (! aout_link_input_bfd (&aout_info, input_bfd)) 3858 goto error_return; 3859 input_bfd->output_has_begun = TRUE; 3860 } 3861 } 3862 else if (p->type == bfd_section_reloc_link_order 3863 || p->type == bfd_symbol_reloc_link_order) 3864 /* These are handled below. */ 3865 have_link_order_relocs = TRUE; 3866 else 3867 { 3868 if (! _bfd_default_link_order (abfd, info, o, p)) 3869 goto error_return; 3870 } 3871 } 3872 } 3873 3874 /* Write out any symbols that we have not already written out. */ 3875 bfd_hash_traverse (&info->hash->table, 3876 aout_link_write_other_symbol, 3877 &aout_info); 3878 3879 /* Now handle any relocs we were asked to create by the linker. 3880 These did not come from any input file. We must do these after 3881 we have written out all the symbols, so that we know the symbol 3882 indices to use. */ 3883 if (have_link_order_relocs) 3884 { 3885 for (o = abfd->sections; o != NULL; o = o->next) 3886 { 3887 for (p = o->map_head.link_order; 3888 p != NULL; 3889 p = p->next) 3890 { 3891 if (p->type == bfd_section_reloc_link_order 3892 || p->type == bfd_symbol_reloc_link_order) 3893 { 3894 if (! aout_link_reloc_link_order (&aout_info, o, p)) 3895 goto error_return; 3896 } 3897 } 3898 } 3899 } 3900 3901 if (aout_info.contents != NULL) 3902 { 3903 free (aout_info.contents); 3904 aout_info.contents = NULL; 3905 } 3906 if (aout_info.relocs != NULL) 3907 { 3908 free (aout_info.relocs); 3909 aout_info.relocs = NULL; 3910 } 3911 if (aout_info.symbol_map != NULL) 3912 { 3913 free (aout_info.symbol_map); 3914 aout_info.symbol_map = NULL; 3915 } 3916 if (aout_info.output_syms != NULL) 3917 { 3918 free (aout_info.output_syms); 3919 aout_info.output_syms = NULL; 3920 } 3921 if (includes_hash_initialized) 3922 { 3923 bfd_hash_table_free (&aout_info.includes.root); 3924 includes_hash_initialized = FALSE; 3925 } 3926 3927 /* Finish up any dynamic linking we may be doing. */ 3928 if (aout_backend_info (abfd)->finish_dynamic_link != NULL) 3929 { 3930 if (! (*aout_backend_info (abfd)->finish_dynamic_link) (abfd, info)) 3931 goto error_return; 3932 } 3933 3934 /* Update the header information. */ 3935 abfd->symcount = obj_aout_external_sym_count (abfd); 3936 exec_hdr (abfd)->a_syms = abfd->symcount * EXTERNAL_NLIST_SIZE; 3937 obj_str_filepos (abfd) = obj_sym_filepos (abfd) + exec_hdr (abfd)->a_syms; 3938 obj_textsec (abfd)->reloc_count = 3939 exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd); 3940 obj_datasec (abfd)->reloc_count = 3941 exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd); 3942 3943 /* Write out the string table, unless there are no symbols. */ 3944 if (abfd->symcount > 0) 3945 { 3946 if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0 3947 || ! emit_stringtab (abfd, aout_info.strtab)) 3948 goto error_return; 3949 } 3950 else if (obj_textsec (abfd)->reloc_count == 0 3951 && obj_datasec (abfd)->reloc_count == 0) 3952 { 3953 bfd_byte b; 3954 3955 b = 0; 3956 if (bfd_seek (abfd, 3957 (file_ptr) (obj_datasec (abfd)->filepos 3958 + exec_hdr (abfd)->a_data 3959 - 1), 3960 SEEK_SET) != 0 3961 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1) 3962 goto error_return; 3963 } 3964 3965 return TRUE; 3966 3967 error_return: 3968 if (aout_info.contents != NULL) 3969 free (aout_info.contents); 3970 if (aout_info.relocs != NULL) 3971 free (aout_info.relocs); 3972 if (aout_info.symbol_map != NULL) 3973 free (aout_info.symbol_map); 3974 if (aout_info.output_syms != NULL) 3975 free (aout_info.output_syms); 3976 if (includes_hash_initialized) 3977 bfd_hash_table_free (&aout_info.includes.root); 3978 return FALSE; 3979 } 3980 3981 /* Adjust and write out the symbols for an a.out file. Set the new 3982 symbol indices into a symbol_map. */ 3983 3984 static bfd_boolean 3985 aout_link_write_symbols (struct aout_final_link_info *flaginfo, bfd *input_bfd) 3986 { 3987 bfd *output_bfd; 3988 bfd_size_type sym_count; 3989 char *strings; 3990 enum bfd_link_strip strip; 3991 enum bfd_link_discard discard; 3992 struct external_nlist *outsym; 3993 bfd_size_type strtab_index; 3994 struct external_nlist *sym; 3995 struct external_nlist *sym_end; 3996 struct aout_link_hash_entry **sym_hash; 3997 int *symbol_map; 3998 bfd_boolean pass; 3999 bfd_boolean skip_next; 4000 4001 output_bfd = flaginfo->output_bfd; 4002 sym_count = obj_aout_external_sym_count (input_bfd); 4003 strings = obj_aout_external_strings (input_bfd); 4004 strip = flaginfo->info->strip; 4005 discard = flaginfo->info->discard; 4006 outsym = flaginfo->output_syms; 4007 4008 /* First write out a symbol for this object file, unless we are 4009 discarding such symbols. */ 4010 if (strip != strip_all 4011 && (strip != strip_some 4012 || bfd_hash_lookup (flaginfo->info->keep_hash, input_bfd->filename, 4013 FALSE, FALSE) != NULL) 4014 && discard != discard_all) 4015 { 4016 H_PUT_8 (output_bfd, N_TEXT, outsym->e_type); 4017 strtab_index = add_to_stringtab (output_bfd, flaginfo->strtab, 4018 input_bfd->filename, FALSE); 4019 if (strtab_index == (bfd_size_type) -1) 4020 return FALSE; 4021 PUT_WORD (output_bfd, strtab_index, outsym->e_strx); 4022 PUT_WORD (output_bfd, 4023 (bfd_get_section_vma (output_bfd, 4024 obj_textsec (input_bfd)->output_section) 4025 + obj_textsec (input_bfd)->output_offset), 4026 outsym->e_value); 4027 ++obj_aout_external_sym_count (output_bfd); 4028 ++outsym; 4029 } 4030 4031 pass = FALSE; 4032 skip_next = FALSE; 4033 sym = obj_aout_external_syms (input_bfd); 4034 sym_end = sym + sym_count; 4035 sym_hash = obj_aout_sym_hashes (input_bfd); 4036 symbol_map = flaginfo->symbol_map; 4037 memset (symbol_map, 0, (size_t) sym_count * sizeof *symbol_map); 4038 for (; sym < sym_end; sym++, sym_hash++, symbol_map++) 4039 { 4040 const char *name; 4041 int type; 4042 struct aout_link_hash_entry *h; 4043 bfd_boolean skip; 4044 asection *symsec; 4045 bfd_vma val = 0; 4046 bfd_boolean copy; 4047 4048 /* We set *symbol_map to 0 above for all symbols. If it has 4049 already been set to -1 for this symbol, it means that we are 4050 discarding it because it appears in a duplicate header file. 4051 See the N_BINCL code below. */ 4052 if (*symbol_map == -1) 4053 continue; 4054 4055 /* Initialize *symbol_map to -1, which means that the symbol was 4056 not copied into the output file. We will change it later if 4057 we do copy the symbol over. */ 4058 *symbol_map = -1; 4059 4060 type = H_GET_8 (input_bfd, sym->e_type); 4061 name = strings + GET_WORD (input_bfd, sym->e_strx); 4062 4063 h = NULL; 4064 4065 if (pass) 4066 { 4067 /* Pass this symbol through. It is the target of an 4068 indirect or warning symbol. */ 4069 val = GET_WORD (input_bfd, sym->e_value); 4070 pass = FALSE; 4071 } 4072 else if (skip_next) 4073 { 4074 /* Skip this symbol, which is the target of an indirect 4075 symbol that we have changed to no longer be an indirect 4076 symbol. */ 4077 skip_next = FALSE; 4078 continue; 4079 } 4080 else 4081 { 4082 struct aout_link_hash_entry *hresolve; 4083 4084 /* We have saved the hash table entry for this symbol, if 4085 there is one. Note that we could just look it up again 4086 in the hash table, provided we first check that it is an 4087 external symbol. */ 4088 h = *sym_hash; 4089 4090 /* Use the name from the hash table, in case the symbol was 4091 wrapped. */ 4092 if (h != NULL) 4093 name = h->root.root.string; 4094 4095 /* If this is an indirect or warning symbol, then change 4096 hresolve to the base symbol. We also change *sym_hash so 4097 that the relocation routines relocate against the real 4098 symbol. */ 4099 hresolve = h; 4100 if (h != NULL 4101 && (h->root.type == bfd_link_hash_indirect 4102 || h->root.type == bfd_link_hash_warning)) 4103 { 4104 hresolve = (struct aout_link_hash_entry *) h->root.u.i.link; 4105 while (hresolve->root.type == bfd_link_hash_indirect 4106 || hresolve->root.type == bfd_link_hash_warning) 4107 hresolve = ((struct aout_link_hash_entry *) 4108 hresolve->root.u.i.link); 4109 *sym_hash = hresolve; 4110 } 4111 4112 /* If the symbol has already been written out, skip it. */ 4113 if (h != NULL 4114 && h->root.type != bfd_link_hash_warning 4115 && h->written) 4116 { 4117 if ((type & N_TYPE) == N_INDR 4118 || type == N_WARNING) 4119 skip_next = TRUE; 4120 *symbol_map = h->indx; 4121 continue; 4122 } 4123 4124 /* See if we are stripping this symbol. */ 4125 skip = FALSE; 4126 switch (strip) 4127 { 4128 case strip_none: 4129 break; 4130 case strip_debugger: 4131 if ((type & N_STAB) != 0) 4132 skip = TRUE; 4133 break; 4134 case strip_some: 4135 if (bfd_hash_lookup (flaginfo->info->keep_hash, name, FALSE, FALSE) 4136 == NULL) 4137 skip = TRUE; 4138 break; 4139 case strip_all: 4140 skip = TRUE; 4141 break; 4142 } 4143 if (skip) 4144 { 4145 if (h != NULL) 4146 h->written = TRUE; 4147 continue; 4148 } 4149 4150 /* Get the value of the symbol. */ 4151 if ((type & N_TYPE) == N_TEXT 4152 || type == N_WEAKT) 4153 symsec = obj_textsec (input_bfd); 4154 else if ((type & N_TYPE) == N_DATA 4155 || type == N_WEAKD) 4156 symsec = obj_datasec (input_bfd); 4157 else if ((type & N_TYPE) == N_BSS 4158 || type == N_WEAKB) 4159 symsec = obj_bsssec (input_bfd); 4160 else if ((type & N_TYPE) == N_ABS 4161 || type == N_WEAKA) 4162 symsec = bfd_abs_section_ptr; 4163 else if (((type & N_TYPE) == N_INDR 4164 && (hresolve == NULL 4165 || (hresolve->root.type != bfd_link_hash_defined 4166 && hresolve->root.type != bfd_link_hash_defweak 4167 && hresolve->root.type != bfd_link_hash_common))) 4168 || type == N_WARNING) 4169 { 4170 /* Pass the next symbol through unchanged. The 4171 condition above for indirect symbols is so that if 4172 the indirect symbol was defined, we output it with 4173 the correct definition so the debugger will 4174 understand it. */ 4175 pass = TRUE; 4176 val = GET_WORD (input_bfd, sym->e_value); 4177 symsec = NULL; 4178 } 4179 else if ((type & N_STAB) != 0) 4180 { 4181 val = GET_WORD (input_bfd, sym->e_value); 4182 symsec = NULL; 4183 } 4184 else 4185 { 4186 /* If we get here with an indirect symbol, it means that 4187 we are outputting it with a real definition. In such 4188 a case we do not want to output the next symbol, 4189 which is the target of the indirection. */ 4190 if ((type & N_TYPE) == N_INDR) 4191 skip_next = TRUE; 4192 4193 symsec = NULL; 4194 4195 /* We need to get the value from the hash table. We use 4196 hresolve so that if we have defined an indirect 4197 symbol we output the final definition. */ 4198 if (h == NULL) 4199 { 4200 switch (type & N_TYPE) 4201 { 4202 case N_SETT: 4203 symsec = obj_textsec (input_bfd); 4204 break; 4205 case N_SETD: 4206 symsec = obj_datasec (input_bfd); 4207 break; 4208 case N_SETB: 4209 symsec = obj_bsssec (input_bfd); 4210 break; 4211 case N_SETA: 4212 symsec = bfd_abs_section_ptr; 4213 break; 4214 default: 4215 val = 0; 4216 break; 4217 } 4218 } 4219 else if (hresolve->root.type == bfd_link_hash_defined 4220 || hresolve->root.type == bfd_link_hash_defweak) 4221 { 4222 asection *input_section; 4223 asection *output_section; 4224 4225 /* This case usually means a common symbol which was 4226 turned into a defined symbol. */ 4227 input_section = hresolve->root.u.def.section; 4228 output_section = input_section->output_section; 4229 BFD_ASSERT (bfd_is_abs_section (output_section) 4230 || output_section->owner == output_bfd); 4231 val = (hresolve->root.u.def.value 4232 + bfd_get_section_vma (output_bfd, output_section) 4233 + input_section->output_offset); 4234 4235 /* Get the correct type based on the section. If 4236 this is a constructed set, force it to be 4237 globally visible. */ 4238 if (type == N_SETT 4239 || type == N_SETD 4240 || type == N_SETB 4241 || type == N_SETA) 4242 type |= N_EXT; 4243 4244 type &=~ N_TYPE; 4245 4246 if (output_section == obj_textsec (output_bfd)) 4247 type |= (hresolve->root.type == bfd_link_hash_defined 4248 ? N_TEXT 4249 : N_WEAKT); 4250 else if (output_section == obj_datasec (output_bfd)) 4251 type |= (hresolve->root.type == bfd_link_hash_defined 4252 ? N_DATA 4253 : N_WEAKD); 4254 else if (output_section == obj_bsssec (output_bfd)) 4255 type |= (hresolve->root.type == bfd_link_hash_defined 4256 ? N_BSS 4257 : N_WEAKB); 4258 else 4259 type |= (hresolve->root.type == bfd_link_hash_defined 4260 ? N_ABS 4261 : N_WEAKA); 4262 } 4263 else if (hresolve->root.type == bfd_link_hash_common) 4264 val = hresolve->root.u.c.size; 4265 else if (hresolve->root.type == bfd_link_hash_undefweak) 4266 { 4267 val = 0; 4268 type = N_WEAKU; 4269 } 4270 else 4271 val = 0; 4272 } 4273 if (symsec != NULL) 4274 val = (symsec->output_section->vma 4275 + symsec->output_offset 4276 + (GET_WORD (input_bfd, sym->e_value) 4277 - symsec->vma)); 4278 4279 /* If this is a global symbol set the written flag, and if 4280 it is a local symbol see if we should discard it. */ 4281 if (h != NULL) 4282 { 4283 h->written = TRUE; 4284 h->indx = obj_aout_external_sym_count (output_bfd); 4285 } 4286 else if ((type & N_TYPE) != N_SETT 4287 && (type & N_TYPE) != N_SETD 4288 && (type & N_TYPE) != N_SETB 4289 && (type & N_TYPE) != N_SETA) 4290 { 4291 switch (discard) 4292 { 4293 case discard_none: 4294 case discard_sec_merge: 4295 break; 4296 case discard_l: 4297 if ((type & N_STAB) == 0 4298 && bfd_is_local_label_name (input_bfd, name)) 4299 skip = TRUE; 4300 break; 4301 case discard_all: 4302 skip = TRUE; 4303 break; 4304 } 4305 if (skip) 4306 { 4307 pass = FALSE; 4308 continue; 4309 } 4310 } 4311 4312 /* An N_BINCL symbol indicates the start of the stabs 4313 entries for a header file. We need to scan ahead to the 4314 next N_EINCL symbol, ignoring nesting, adding up all the 4315 characters in the symbol names, not including the file 4316 numbers in types (the first number after an open 4317 parenthesis). */ 4318 if (type == N_BINCL) 4319 { 4320 struct external_nlist *incl_sym; 4321 int nest; 4322 struct aout_link_includes_entry *incl_entry; 4323 struct aout_link_includes_totals *t; 4324 4325 val = 0; 4326 nest = 0; 4327 for (incl_sym = sym + 1; incl_sym < sym_end; incl_sym++) 4328 { 4329 int incl_type; 4330 4331 incl_type = H_GET_8 (input_bfd, incl_sym->e_type); 4332 if (incl_type == N_EINCL) 4333 { 4334 if (nest == 0) 4335 break; 4336 --nest; 4337 } 4338 else if (incl_type == N_BINCL) 4339 ++nest; 4340 else if (nest == 0) 4341 { 4342 const char *s; 4343 4344 s = strings + GET_WORD (input_bfd, incl_sym->e_strx); 4345 for (; *s != '\0'; s++) 4346 { 4347 val += *s; 4348 if (*s == '(') 4349 { 4350 /* Skip the file number. */ 4351 ++s; 4352 while (ISDIGIT (*s)) 4353 ++s; 4354 --s; 4355 } 4356 } 4357 } 4358 } 4359 4360 /* If we have already included a header file with the 4361 same value, then replace this one with an N_EXCL 4362 symbol. */ 4363 copy = ! flaginfo->info->keep_memory; 4364 incl_entry = aout_link_includes_lookup (&flaginfo->includes, 4365 name, TRUE, copy); 4366 if (incl_entry == NULL) 4367 return FALSE; 4368 for (t = incl_entry->totals; t != NULL; t = t->next) 4369 if (t->total == val) 4370 break; 4371 if (t == NULL) 4372 { 4373 /* This is the first time we have seen this header 4374 file with this set of stabs strings. */ 4375 t = bfd_hash_allocate (&flaginfo->includes.root, 4376 sizeof *t); 4377 if (t == NULL) 4378 return FALSE; 4379 t->total = val; 4380 t->next = incl_entry->totals; 4381 incl_entry->totals = t; 4382 } 4383 else 4384 { 4385 int *incl_map; 4386 4387 /* This is a duplicate header file. We must change 4388 it to be an N_EXCL entry, and mark all the 4389 included symbols to prevent outputting them. */ 4390 type = N_EXCL; 4391 4392 nest = 0; 4393 for (incl_sym = sym + 1, incl_map = symbol_map + 1; 4394 incl_sym < sym_end; 4395 incl_sym++, incl_map++) 4396 { 4397 int incl_type; 4398 4399 incl_type = H_GET_8 (input_bfd, incl_sym->e_type); 4400 if (incl_type == N_EINCL) 4401 { 4402 if (nest == 0) 4403 { 4404 *incl_map = -1; 4405 break; 4406 } 4407 --nest; 4408 } 4409 else if (incl_type == N_BINCL) 4410 ++nest; 4411 else if (nest == 0) 4412 *incl_map = -1; 4413 } 4414 } 4415 } 4416 } 4417 4418 /* Copy this symbol into the list of symbols we are going to 4419 write out. */ 4420 H_PUT_8 (output_bfd, type, outsym->e_type); 4421 copy = FALSE; 4422 if (! flaginfo->info->keep_memory) 4423 { 4424 /* name points into a string table which we are going to 4425 free. If there is a hash table entry, use that string. 4426 Otherwise, copy name into memory. */ 4427 if (h != NULL) 4428 name = h->root.root.string; 4429 else 4430 copy = TRUE; 4431 } 4432 strtab_index = add_to_stringtab (output_bfd, flaginfo->strtab, 4433 name, copy); 4434 if (strtab_index == (bfd_size_type) -1) 4435 return FALSE; 4436 PUT_WORD (output_bfd, strtab_index, outsym->e_strx); 4437 PUT_WORD (output_bfd, val, outsym->e_value); 4438 *symbol_map = obj_aout_external_sym_count (output_bfd); 4439 ++obj_aout_external_sym_count (output_bfd); 4440 ++outsym; 4441 } 4442 4443 /* Write out the output symbols we have just constructed. */ 4444 if (outsym > flaginfo->output_syms) 4445 { 4446 bfd_size_type size; 4447 4448 if (bfd_seek (output_bfd, flaginfo->symoff, SEEK_SET) != 0) 4449 return FALSE; 4450 size = outsym - flaginfo->output_syms; 4451 size *= EXTERNAL_NLIST_SIZE; 4452 if (bfd_bwrite ((void *) flaginfo->output_syms, size, output_bfd) != size) 4453 return FALSE; 4454 flaginfo->symoff += size; 4455 } 4456 4457 return TRUE; 4458 } 4459 4460 /* Write out a symbol that was not associated with an a.out input 4461 object. */ 4462 4463 static bfd_vma 4464 bfd_getp32 (const void *p) 4465 { 4466 const bfd_byte *addr = p; 4467 unsigned long v; 4468 4469 v = (unsigned long) addr[1] << 24; 4470 v |= (unsigned long) addr[0] << 16; 4471 v |= (unsigned long) addr[3] << 8; 4472 v |= (unsigned long) addr[2]; 4473 return v; 4474 } 4475 4476 #define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000) 4477 4478 static bfd_signed_vma 4479 bfd_getp_signed_32 (const void *p) 4480 { 4481 const bfd_byte *addr = p; 4482 unsigned long v; 4483 4484 v = (unsigned long) addr[1] << 24; 4485 v |= (unsigned long) addr[0] << 16; 4486 v |= (unsigned long) addr[3] << 8; 4487 v |= (unsigned long) addr[2]; 4488 return COERCE32 (v); 4489 } 4490 4491 static void 4492 bfd_putp32 (bfd_vma data, void *p) 4493 { 4494 bfd_byte *addr = p; 4495 4496 addr[0] = (data >> 16) & 0xff; 4497 addr[1] = (data >> 24) & 0xff; 4498 addr[2] = (data >> 0) & 0xff; 4499 addr[3] = (data >> 8) & 0xff; 4500 } 4501 4502 const bfd_target MY (vec) = 4503 { 4504 TARGETNAME, /* Name. */ 4505 bfd_target_aout_flavour, 4506 BFD_ENDIAN_LITTLE, /* Target byte order (little). */ 4507 BFD_ENDIAN_LITTLE, /* Target headers byte order (little). */ 4508 (HAS_RELOC | EXEC_P | /* Object flags. */ 4509 HAS_LINENO | HAS_DEBUG | 4510 HAS_SYMS | HAS_LOCALS | WP_TEXT), 4511 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA), 4512 MY_symbol_leading_char, 4513 AR_PAD_CHAR, /* AR_pad_char. */ 4514 15, /* AR_max_namelen. */ 4515 0, /* match priority. */ 4516 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 4517 bfd_getp32, bfd_getp_signed_32, bfd_putp32, 4518 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data. */ 4519 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 4520 bfd_getp32, bfd_getp_signed_32, bfd_putp32, 4521 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Headers. */ 4522 {_bfd_dummy_target, MY_object_p, /* bfd_check_format. */ 4523 bfd_generic_archive_p, MY_core_file_p}, 4524 {bfd_false, MY_mkobject, /* bfd_set_format. */ 4525 _bfd_generic_mkarchive, bfd_false}, 4526 {bfd_false, MY_write_object_contents, /* bfd_write_contents. */ 4527 _bfd_write_archive_contents, bfd_false}, 4528 4529 BFD_JUMP_TABLE_GENERIC (MY), 4530 BFD_JUMP_TABLE_COPY (MY), 4531 BFD_JUMP_TABLE_CORE (MY), 4532 BFD_JUMP_TABLE_ARCHIVE (MY), 4533 BFD_JUMP_TABLE_SYMBOLS (MY), 4534 BFD_JUMP_TABLE_RELOCS (MY), 4535 BFD_JUMP_TABLE_WRITE (MY), 4536 BFD_JUMP_TABLE_LINK (MY), 4537 BFD_JUMP_TABLE_DYNAMIC (MY), 4538 4539 /* Alternative_target. */ 4540 NULL, 4541 4542 (void *) MY_backend_data 4543 }; 4544