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