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