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