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