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