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