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