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