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