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