1/* BFD backend for SunOS binaries. 2 Copyright 1990, 1991, 1992, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 3 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. 4 Written by Cygnus Support. 5 6 This file is part of BFD, the Binary File Descriptor library. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 21 22#define TARGETNAME "a.out-sunos-big" 23 24/* Do not "beautify" the CONCAT* macro args. Traditional C will not 25 remove whitespace added here, and thus will fail to concatenate 26 the tokens. */ 27#define MY(OP) CONCAT2 (sunos_big_,OP) 28 29#include "bfd.h" 30#include "bfdlink.h" 31#include "libaout.h" 32 33/* ??? Where should this go? */ 34#define MACHTYPE_OK(mtype) \ 35 (((mtype) == M_SPARC && bfd_lookup_arch (bfd_arch_sparc, 0) != NULL) \ 36 || ((mtype) == M_SPARCLET \ 37 && bfd_lookup_arch (bfd_arch_sparc, bfd_mach_sparc_sparclet) != NULL) \ 38 || ((mtype) == M_SPARCLITE_LE \ 39 && bfd_lookup_arch (bfd_arch_sparc, bfd_mach_sparc_sparclet) != NULL) \ 40 || (((mtype) == M_UNKNOWN || (mtype) == M_68010 || (mtype) == M_68020) \ 41 && bfd_lookup_arch (bfd_arch_m68k, 0) != NULL)) 42 43#define MY_get_dynamic_symtab_upper_bound sunos_get_dynamic_symtab_upper_bound 44#define MY_canonicalize_dynamic_symtab sunos_canonicalize_dynamic_symtab 45#define MY_get_synthetic_symtab _bfd_nodynamic_get_synthetic_symtab 46#define MY_get_dynamic_reloc_upper_bound sunos_get_dynamic_reloc_upper_bound 47#define MY_canonicalize_dynamic_reloc sunos_canonicalize_dynamic_reloc 48#define MY_bfd_link_hash_table_create sunos_link_hash_table_create 49#define MY_add_dynamic_symbols sunos_add_dynamic_symbols 50#define MY_add_one_symbol sunos_add_one_symbol 51#define MY_link_dynamic_object sunos_link_dynamic_object 52#define MY_write_dynamic_symbol sunos_write_dynamic_symbol 53#define MY_check_dynamic_reloc sunos_check_dynamic_reloc 54#define MY_finish_dynamic_link sunos_finish_dynamic_link 55 56static bfd_boolean sunos_add_dynamic_symbols (bfd *, struct bfd_link_info *, struct external_nlist **, bfd_size_type *, char **); 57static bfd_boolean sunos_add_one_symbol (struct bfd_link_info *, bfd *, const char *, flagword, asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean, struct bfd_link_hash_entry **); 58static bfd_boolean sunos_link_dynamic_object (struct bfd_link_info *, bfd *); 59static bfd_boolean sunos_write_dynamic_symbol (bfd *, struct bfd_link_info *, struct aout_link_hash_entry *); 60static bfd_boolean sunos_check_dynamic_reloc (struct bfd_link_info *, bfd *, asection *, struct aout_link_hash_entry *, void *, bfd_byte *, bfd_boolean *, bfd_vma *); 61static bfd_boolean sunos_finish_dynamic_link (bfd *, struct bfd_link_info *); 62static struct bfd_link_hash_table *sunos_link_hash_table_create (bfd *); 63static long sunos_get_dynamic_symtab_upper_bound (bfd *); 64static long sunos_canonicalize_dynamic_symtab (bfd *, asymbol **); 65static long sunos_get_dynamic_reloc_upper_bound (bfd *); 66static long sunos_canonicalize_dynamic_reloc (bfd *, arelent **, asymbol **); 67 68/* Include the usual a.out support. */ 69#include "aoutf1.h" 70 71/* The SunOS 4.1.4 /usr/include/locale.h defines valid as a macro. */ 72#undef valid 73 74/* SunOS shared library support. We store a pointer to this structure 75 in obj_aout_dynamic_info (abfd). */ 76 77struct sunos_dynamic_info 78{ 79 /* Whether we found any dynamic information. */ 80 bfd_boolean valid; 81 /* Dynamic information. */ 82 struct internal_sun4_dynamic_link dyninfo; 83 /* Number of dynamic symbols. */ 84 unsigned long dynsym_count; 85 /* Read in nlists for dynamic symbols. */ 86 struct external_nlist *dynsym; 87 /* asymbol structures for dynamic symbols. */ 88 aout_symbol_type *canonical_dynsym; 89 /* Read in dynamic string table. */ 90 char *dynstr; 91 /* Number of dynamic relocs. */ 92 unsigned long dynrel_count; 93 /* Read in dynamic relocs. This may be reloc_std_external or 94 reloc_ext_external. */ 95 void * dynrel; 96 /* arelent structures for dynamic relocs. */ 97 arelent *canonical_dynrel; 98}; 99 100/* The hash table of dynamic symbols is composed of two word entries. 101 See include/aout/sun4.h for details. */ 102 103#define HASH_ENTRY_SIZE (2 * BYTES_IN_WORD) 104 105/* Read in the basic dynamic information. This locates the __DYNAMIC 106 structure and uses it to find the dynamic_link structure. It 107 creates and saves a sunos_dynamic_info structure. If it can't find 108 __DYNAMIC, it sets the valid field of the sunos_dynamic_info 109 structure to FALSE to avoid doing this work again. */ 110 111static bfd_boolean 112sunos_read_dynamic_info (bfd *abfd) 113{ 114 struct sunos_dynamic_info *info; 115 asection *dynsec; 116 bfd_vma dynoff; 117 struct external_sun4_dynamic dyninfo; 118 unsigned long dynver; 119 struct external_sun4_dynamic_link linkinfo; 120 bfd_size_type amt; 121 122 if (obj_aout_dynamic_info (abfd) != NULL) 123 return TRUE; 124 125 if ((abfd->flags & DYNAMIC) == 0) 126 { 127 bfd_set_error (bfd_error_invalid_operation); 128 return FALSE; 129 } 130 131 amt = sizeof (struct sunos_dynamic_info); 132 info = bfd_zalloc (abfd, amt); 133 if (!info) 134 return FALSE; 135 info->valid = FALSE; 136 info->dynsym = NULL; 137 info->dynstr = NULL; 138 info->canonical_dynsym = NULL; 139 info->dynrel = NULL; 140 info->canonical_dynrel = NULL; 141 obj_aout_dynamic_info (abfd) = (void *) info; 142 143 /* This code used to look for the __DYNAMIC symbol to locate the dynamic 144 linking information. 145 However this inhibits recovering the dynamic symbols from a 146 stripped object file, so blindly assume that the dynamic linking 147 information is located at the start of the data section. 148 We could verify this assumption later by looking through the dynamic 149 symbols for the __DYNAMIC symbol. */ 150 if ((abfd->flags & DYNAMIC) == 0) 151 return TRUE; 152 if (! bfd_get_section_contents (abfd, obj_datasec (abfd), (void *) &dyninfo, 153 (file_ptr) 0, 154 (bfd_size_type) sizeof dyninfo)) 155 return TRUE; 156 157 dynver = GET_WORD (abfd, dyninfo.ld_version); 158 if (dynver != 2 && dynver != 3) 159 return TRUE; 160 161 dynoff = GET_WORD (abfd, dyninfo.ld); 162 163 /* dynoff is a virtual address. It is probably always in the .data 164 section, but this code should work even if it moves. */ 165 if (dynoff < bfd_get_section_vma (abfd, obj_datasec (abfd))) 166 dynsec = obj_textsec (abfd); 167 else 168 dynsec = obj_datasec (abfd); 169 dynoff -= bfd_get_section_vma (abfd, dynsec); 170 if (dynoff > dynsec->size) 171 return TRUE; 172 173 /* This executable appears to be dynamically linked in a way that we 174 can understand. */ 175 if (! bfd_get_section_contents (abfd, dynsec, (void *) &linkinfo, 176 (file_ptr) dynoff, 177 (bfd_size_type) sizeof linkinfo)) 178 return TRUE; 179 180 /* Swap in the dynamic link information. */ 181 info->dyninfo.ld_loaded = GET_WORD (abfd, linkinfo.ld_loaded); 182 info->dyninfo.ld_need = GET_WORD (abfd, linkinfo.ld_need); 183 info->dyninfo.ld_rules = GET_WORD (abfd, linkinfo.ld_rules); 184 info->dyninfo.ld_got = GET_WORD (abfd, linkinfo.ld_got); 185 info->dyninfo.ld_plt = GET_WORD (abfd, linkinfo.ld_plt); 186 info->dyninfo.ld_rel = GET_WORD (abfd, linkinfo.ld_rel); 187 info->dyninfo.ld_hash = GET_WORD (abfd, linkinfo.ld_hash); 188 info->dyninfo.ld_stab = GET_WORD (abfd, linkinfo.ld_stab); 189 info->dyninfo.ld_stab_hash = GET_WORD (abfd, linkinfo.ld_stab_hash); 190 info->dyninfo.ld_buckets = GET_WORD (abfd, linkinfo.ld_buckets); 191 info->dyninfo.ld_symbols = GET_WORD (abfd, linkinfo.ld_symbols); 192 info->dyninfo.ld_symb_size = GET_WORD (abfd, linkinfo.ld_symb_size); 193 info->dyninfo.ld_text = GET_WORD (abfd, linkinfo.ld_text); 194 info->dyninfo.ld_plt_sz = GET_WORD (abfd, linkinfo.ld_plt_sz); 195 196 /* Reportedly the addresses need to be offset by the size of the 197 exec header in an NMAGIC file. */ 198 if (adata (abfd).magic == n_magic) 199 { 200 unsigned long exec_bytes_size = adata (abfd).exec_bytes_size; 201 202 info->dyninfo.ld_need += exec_bytes_size; 203 info->dyninfo.ld_rules += exec_bytes_size; 204 info->dyninfo.ld_rel += exec_bytes_size; 205 info->dyninfo.ld_hash += exec_bytes_size; 206 info->dyninfo.ld_stab += exec_bytes_size; 207 info->dyninfo.ld_symbols += exec_bytes_size; 208 } 209 210 /* The only way to get the size of the symbol information appears to 211 be to determine the distance between it and the string table. */ 212 info->dynsym_count = ((info->dyninfo.ld_symbols - info->dyninfo.ld_stab) 213 / EXTERNAL_NLIST_SIZE); 214 BFD_ASSERT (info->dynsym_count * EXTERNAL_NLIST_SIZE 215 == (unsigned long) (info->dyninfo.ld_symbols 216 - info->dyninfo.ld_stab)); 217 218 /* Similarly, the relocs end at the hash table. */ 219 info->dynrel_count = ((info->dyninfo.ld_hash - info->dyninfo.ld_rel) 220 / obj_reloc_entry_size (abfd)); 221 BFD_ASSERT (info->dynrel_count * obj_reloc_entry_size (abfd) 222 == (unsigned long) (info->dyninfo.ld_hash 223 - info->dyninfo.ld_rel)); 224 225 info->valid = TRUE; 226 227 return TRUE; 228} 229 230/* Return the amount of memory required for the dynamic symbols. */ 231 232static long 233sunos_get_dynamic_symtab_upper_bound (bfd *abfd) 234{ 235 struct sunos_dynamic_info *info; 236 237 if (! sunos_read_dynamic_info (abfd)) 238 return -1; 239 240 info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd); 241 if (! info->valid) 242 { 243 bfd_set_error (bfd_error_no_symbols); 244 return -1; 245 } 246 247 return (info->dynsym_count + 1) * sizeof (asymbol *); 248} 249 250/* Read the external dynamic symbols. */ 251 252static bfd_boolean 253sunos_slurp_dynamic_symtab (bfd *abfd) 254{ 255 struct sunos_dynamic_info *info; 256 bfd_size_type amt; 257 258 /* Get the general dynamic information. */ 259 if (obj_aout_dynamic_info (abfd) == NULL) 260 { 261 if (! sunos_read_dynamic_info (abfd)) 262 return FALSE; 263 } 264 265 info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd); 266 if (! info->valid) 267 { 268 bfd_set_error (bfd_error_no_symbols); 269 return FALSE; 270 } 271 272 /* Get the dynamic nlist structures. */ 273 if (info->dynsym == NULL) 274 { 275 amt = (bfd_size_type) info->dynsym_count * EXTERNAL_NLIST_SIZE; 276 info->dynsym = bfd_alloc (abfd, amt); 277 if (info->dynsym == NULL && info->dynsym_count != 0) 278 return FALSE; 279 if (bfd_seek (abfd, (file_ptr) info->dyninfo.ld_stab, SEEK_SET) != 0 280 || bfd_bread ((void *) info->dynsym, amt, abfd) != amt) 281 { 282 if (info->dynsym != NULL) 283 { 284 bfd_release (abfd, info->dynsym); 285 info->dynsym = NULL; 286 } 287 return FALSE; 288 } 289 } 290 291 /* Get the dynamic strings. */ 292 if (info->dynstr == NULL) 293 { 294 amt = info->dyninfo.ld_symb_size; 295 info->dynstr = bfd_alloc (abfd, amt); 296 if (info->dynstr == NULL && info->dyninfo.ld_symb_size != 0) 297 return FALSE; 298 if (bfd_seek (abfd, (file_ptr) info->dyninfo.ld_symbols, SEEK_SET) != 0 299 || bfd_bread ((void *) info->dynstr, amt, abfd) != amt) 300 { 301 if (info->dynstr != NULL) 302 { 303 bfd_release (abfd, info->dynstr); 304 info->dynstr = NULL; 305 } 306 return FALSE; 307 } 308 } 309 310 return TRUE; 311} 312 313/* Read in the dynamic symbols. */ 314 315static long 316sunos_canonicalize_dynamic_symtab (bfd *abfd, asymbol **storage) 317{ 318 struct sunos_dynamic_info *info; 319 unsigned long i; 320 321 if (! sunos_slurp_dynamic_symtab (abfd)) 322 return -1; 323 324 info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd); 325 326#ifdef CHECK_DYNAMIC_HASH 327 /* Check my understanding of the dynamic hash table by making sure 328 that each symbol can be located in the hash table. */ 329 { 330 bfd_size_type table_size; 331 bfd_byte *table; 332 bfd_size_type i; 333 334 if (info->dyninfo.ld_buckets > info->dynsym_count) 335 abort (); 336 table_size = info->dyninfo.ld_stab - info->dyninfo.ld_hash; 337 table = bfd_malloc (table_size); 338 if (table == NULL && table_size != 0) 339 abort (); 340 if (bfd_seek (abfd, (file_ptr) info->dyninfo.ld_hash, SEEK_SET) != 0 341 || bfd_bread ((void *) table, table_size, abfd) != table_size) 342 abort (); 343 for (i = 0; i < info->dynsym_count; i++) 344 { 345 unsigned char *name; 346 unsigned long hash; 347 348 name = ((unsigned char *) info->dynstr 349 + GET_WORD (abfd, info->dynsym[i].e_strx)); 350 hash = 0; 351 while (*name != '\0') 352 hash = (hash << 1) + *name++; 353 hash &= 0x7fffffff; 354 hash %= info->dyninfo.ld_buckets; 355 while (GET_WORD (abfd, table + hash * HASH_ENTRY_SIZE) != i) 356 { 357 hash = GET_WORD (abfd, 358 table + hash * HASH_ENTRY_SIZE + BYTES_IN_WORD); 359 if (hash == 0 || hash >= table_size / HASH_ENTRY_SIZE) 360 abort (); 361 } 362 } 363 free (table); 364 } 365#endif /* CHECK_DYNAMIC_HASH */ 366 367 /* Get the asymbol structures corresponding to the dynamic nlist 368 structures. */ 369 if (info->canonical_dynsym == NULL) 370 { 371 bfd_size_type size; 372 bfd_size_type strsize = info->dyninfo.ld_symb_size; 373 374 size = (bfd_size_type) info->dynsym_count * sizeof (aout_symbol_type); 375 info->canonical_dynsym = bfd_alloc (abfd, size); 376 if (info->canonical_dynsym == NULL && info->dynsym_count != 0) 377 return -1; 378 379 if (! aout_32_translate_symbol_table (abfd, info->canonical_dynsym, 380 info->dynsym, 381 (bfd_size_type) info->dynsym_count, 382 info->dynstr, strsize, TRUE)) 383 { 384 if (info->canonical_dynsym != NULL) 385 { 386 bfd_release (abfd, info->canonical_dynsym); 387 info->canonical_dynsym = NULL; 388 } 389 return -1; 390 } 391 } 392 393 /* Return pointers to the dynamic asymbol structures. */ 394 for (i = 0; i < info->dynsym_count; i++) 395 *storage++ = (asymbol *) (info->canonical_dynsym + i); 396 *storage = NULL; 397 398 return info->dynsym_count; 399} 400 401/* Return the amount of memory required for the dynamic relocs. */ 402 403static long 404sunos_get_dynamic_reloc_upper_bound (bfd *abfd) 405{ 406 struct sunos_dynamic_info *info; 407 408 if (! sunos_read_dynamic_info (abfd)) 409 return -1; 410 411 info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd); 412 if (! info->valid) 413 { 414 bfd_set_error (bfd_error_no_symbols); 415 return -1; 416 } 417 418 return (info->dynrel_count + 1) * sizeof (arelent *); 419} 420 421/* Read in the dynamic relocs. */ 422 423static long 424sunos_canonicalize_dynamic_reloc (bfd *abfd, arelent **storage, asymbol **syms) 425{ 426 struct sunos_dynamic_info *info; 427 unsigned long i; 428 bfd_size_type size; 429 430 /* Get the general dynamic information. */ 431 if (obj_aout_dynamic_info (abfd) == NULL) 432 { 433 if (! sunos_read_dynamic_info (abfd)) 434 return -1; 435 } 436 437 info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd); 438 if (! info->valid) 439 { 440 bfd_set_error (bfd_error_no_symbols); 441 return -1; 442 } 443 444 /* Get the dynamic reloc information. */ 445 if (info->dynrel == NULL) 446 { 447 size = (bfd_size_type) info->dynrel_count * obj_reloc_entry_size (abfd); 448 info->dynrel = bfd_alloc (abfd, size); 449 if (info->dynrel == NULL && size != 0) 450 return -1; 451 if (bfd_seek (abfd, (file_ptr) info->dyninfo.ld_rel, SEEK_SET) != 0 452 || bfd_bread ((void *) info->dynrel, size, abfd) != size) 453 { 454 if (info->dynrel != NULL) 455 { 456 bfd_release (abfd, info->dynrel); 457 info->dynrel = NULL; 458 } 459 return -1; 460 } 461 } 462 463 /* Get the arelent structures corresponding to the dynamic reloc 464 information. */ 465 if (info->canonical_dynrel == NULL) 466 { 467 arelent *to; 468 469 size = (bfd_size_type) info->dynrel_count * sizeof (arelent); 470 info->canonical_dynrel = bfd_alloc (abfd, size); 471 if (info->canonical_dynrel == NULL && info->dynrel_count != 0) 472 return -1; 473 474 to = info->canonical_dynrel; 475 476 if (obj_reloc_entry_size (abfd) == RELOC_EXT_SIZE) 477 { 478 struct reloc_ext_external *p; 479 struct reloc_ext_external *pend; 480 481 p = (struct reloc_ext_external *) info->dynrel; 482 pend = p + info->dynrel_count; 483 for (; p < pend; p++, to++) 484 NAME (aout, swap_ext_reloc_in) (abfd, p, to, syms, 485 (bfd_size_type) info->dynsym_count); 486 } 487 else 488 { 489 struct reloc_std_external *p; 490 struct reloc_std_external *pend; 491 492 p = (struct reloc_std_external *) info->dynrel; 493 pend = p + info->dynrel_count; 494 for (; p < pend; p++, to++) 495 NAME (aout, swap_std_reloc_in) (abfd, p, to, syms, 496 (bfd_size_type) info->dynsym_count); 497 } 498 } 499 500 /* Return pointers to the dynamic arelent structures. */ 501 for (i = 0; i < info->dynrel_count; i++) 502 *storage++ = info->canonical_dynrel + i; 503 *storage = NULL; 504 505 return info->dynrel_count; 506} 507 508/* Code to handle linking of SunOS shared libraries. */ 509 510/* A SPARC procedure linkage table entry is 12 bytes. The first entry 511 in the table is a jump which is filled in by the runtime linker. 512 The remaining entries are branches back to the first entry, 513 followed by an index into the relocation table encoded to look like 514 a sethi of %g0. */ 515 516#define SPARC_PLT_ENTRY_SIZE (12) 517 518static const bfd_byte sparc_plt_first_entry[SPARC_PLT_ENTRY_SIZE] = 519{ 520 /* sethi %hi(0),%g1; address filled in by runtime linker. */ 521 0x3, 0, 0, 0, 522 /* jmp %g1; offset filled in by runtime linker. */ 523 0x81, 0xc0, 0x60, 0, 524 /* nop */ 525 0x1, 0, 0, 0 526}; 527 528/* save %sp, -96, %sp */ 529#define SPARC_PLT_ENTRY_WORD0 ((bfd_vma) 0x9de3bfa0) 530/* call; address filled in later. */ 531#define SPARC_PLT_ENTRY_WORD1 ((bfd_vma) 0x40000000) 532/* sethi; reloc index filled in later. */ 533#define SPARC_PLT_ENTRY_WORD2 ((bfd_vma) 0x01000000) 534 535/* This sequence is used when for the jump table entry to a defined 536 symbol in a complete executable. It is used when linking PIC 537 compiled code which is not being put into a shared library. */ 538/* sethi <address to be filled in later>, %g1 */ 539#define SPARC_PLT_PIC_WORD0 ((bfd_vma) 0x03000000) 540/* jmp %g1 + <address to be filled in later> */ 541#define SPARC_PLT_PIC_WORD1 ((bfd_vma) 0x81c06000) 542/* nop */ 543#define SPARC_PLT_PIC_WORD2 ((bfd_vma) 0x01000000) 544 545/* An m68k procedure linkage table entry is 8 bytes. The first entry 546 in the table is a jump which is filled in the by the runtime 547 linker. The remaining entries are branches back to the first 548 entry, followed by a two byte index into the relocation table. */ 549 550#define M68K_PLT_ENTRY_SIZE (8) 551 552static const bfd_byte m68k_plt_first_entry[M68K_PLT_ENTRY_SIZE] = 553{ 554 /* jmps @# */ 555 0x4e, 0xf9, 556 /* Filled in by runtime linker with a magic address. */ 557 0, 0, 0, 0, 558 /* Not used? */ 559 0, 0 560}; 561 562/* bsrl */ 563#define M68K_PLT_ENTRY_WORD0 ((bfd_vma) 0x61ff) 564/* Remaining words filled in later. */ 565 566/* An entry in the SunOS linker hash table. */ 567 568struct sunos_link_hash_entry 569{ 570 struct aout_link_hash_entry root; 571 572 /* If this is a dynamic symbol, this is its index into the dynamic 573 symbol table. This is initialized to -1. As the linker looks at 574 the input files, it changes this to -2 if it will be added to the 575 dynamic symbol table. After all the input files have been seen, 576 the linker will know whether to build a dynamic symbol table; if 577 it does build one, this becomes the index into the table. */ 578 long dynindx; 579 580 /* If this is a dynamic symbol, this is the index of the name in the 581 dynamic symbol string table. */ 582 long dynstr_index; 583 584 /* The offset into the global offset table used for this symbol. If 585 the symbol does not require a GOT entry, this is 0. */ 586 bfd_vma got_offset; 587 588 /* The offset into the procedure linkage table used for this symbol. 589 If the symbol does not require a PLT entry, this is 0. */ 590 bfd_vma plt_offset; 591 592 /* Some linker flags. */ 593 unsigned char flags; 594 /* Symbol is referenced by a regular object. */ 595#define SUNOS_REF_REGULAR 01 596 /* Symbol is defined by a regular object. */ 597#define SUNOS_DEF_REGULAR 02 598 /* Symbol is referenced by a dynamic object. */ 599#define SUNOS_REF_DYNAMIC 04 600 /* Symbol is defined by a dynamic object. */ 601#define SUNOS_DEF_DYNAMIC 010 602 /* Symbol is a constructor symbol in a regular object. */ 603#define SUNOS_CONSTRUCTOR 020 604}; 605 606/* The SunOS linker hash table. */ 607 608struct sunos_link_hash_table 609{ 610 struct aout_link_hash_table root; 611 612 /* The object which holds the dynamic sections. */ 613 bfd *dynobj; 614 615 /* Whether we have created the dynamic sections. */ 616 bfd_boolean dynamic_sections_created; 617 618 /* Whether we need the dynamic sections. */ 619 bfd_boolean dynamic_sections_needed; 620 621 /* Whether we need the .got table. */ 622 bfd_boolean got_needed; 623 624 /* The number of dynamic symbols. */ 625 size_t dynsymcount; 626 627 /* The number of buckets in the hash table. */ 628 size_t bucketcount; 629 630 /* The list of dynamic objects needed by dynamic objects included in 631 the link. */ 632 struct bfd_link_needed_list *needed; 633 634 /* The offset of __GLOBAL_OFFSET_TABLE_ into the .got section. */ 635 bfd_vma got_base; 636}; 637 638/* Routine to create an entry in an SunOS link hash table. */ 639 640static struct bfd_hash_entry * 641sunos_link_hash_newfunc (struct bfd_hash_entry *entry, 642 struct bfd_hash_table *table, 643 const char *string) 644{ 645 struct sunos_link_hash_entry *ret = (struct sunos_link_hash_entry *) entry; 646 647 /* Allocate the structure if it has not already been allocated by a 648 subclass. */ 649 if (ret == NULL) 650 ret = bfd_hash_allocate (table, sizeof (* ret)); 651 if (ret == NULL) 652 return NULL; 653 654 /* Call the allocation method of the superclass. */ 655 ret = ((struct sunos_link_hash_entry *) 656 NAME (aout, link_hash_newfunc) ((struct bfd_hash_entry *) ret, 657 table, string)); 658 if (ret != NULL) 659 { 660 /* Set local fields. */ 661 ret->dynindx = -1; 662 ret->dynstr_index = -1; 663 ret->got_offset = 0; 664 ret->plt_offset = 0; 665 ret->flags = 0; 666 } 667 668 return (struct bfd_hash_entry *) ret; 669} 670 671/* Create a SunOS link hash table. */ 672 673static struct bfd_link_hash_table * 674sunos_link_hash_table_create (bfd *abfd) 675{ 676 struct sunos_link_hash_table *ret; 677 bfd_size_type amt = sizeof (struct sunos_link_hash_table); 678 679 ret = bfd_malloc (amt); 680 if (ret == NULL) 681 return NULL; 682 if (!NAME (aout, link_hash_table_init) (&ret->root, abfd, 683 sunos_link_hash_newfunc, 684 sizeof (struct sunos_link_hash_entry))) 685 { 686 free (ret); 687 return NULL; 688 } 689 690 ret->dynobj = NULL; 691 ret->dynamic_sections_created = FALSE; 692 ret->dynamic_sections_needed = FALSE; 693 ret->got_needed = FALSE; 694 ret->dynsymcount = 0; 695 ret->bucketcount = 0; 696 ret->needed = NULL; 697 ret->got_base = 0; 698 699 return &ret->root.root; 700} 701 702/* Look up an entry in an SunOS link hash table. */ 703 704#define sunos_link_hash_lookup(table, string, create, copy, follow) \ 705 ((struct sunos_link_hash_entry *) \ 706 aout_link_hash_lookup (&(table)->root, (string), (create), (copy),\ 707 (follow))) 708 709/* Traverse a SunOS link hash table. */ 710 711#define sunos_link_hash_traverse(table, func, info) \ 712 (aout_link_hash_traverse \ 713 (&(table)->root, \ 714 (bfd_boolean (*) (struct aout_link_hash_entry *, void *)) (func), \ 715 (info))) 716 717/* Get the SunOS link hash table from the info structure. This is 718 just a cast. */ 719 720#define sunos_hash_table(p) ((struct sunos_link_hash_table *) ((p)->hash)) 721 722/* Create the dynamic sections needed if we are linking against a 723 dynamic object, or if we are linking PIC compiled code. ABFD is a 724 bfd we can attach the dynamic sections to. The linker script will 725 look for these special sections names and put them in the right 726 place in the output file. See include/aout/sun4.h for more details 727 of the dynamic linking information. */ 728 729static bfd_boolean 730sunos_create_dynamic_sections (bfd *abfd, 731 struct bfd_link_info *info, 732 bfd_boolean needed) 733{ 734 asection *s; 735 736 if (! sunos_hash_table (info)->dynamic_sections_created) 737 { 738 flagword flags; 739 740 sunos_hash_table (info)->dynobj = abfd; 741 742 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 743 | SEC_LINKER_CREATED); 744 745 /* The .dynamic section holds the basic dynamic information: the 746 sun4_dynamic structure, the dynamic debugger information, and 747 the sun4_dynamic_link structure. */ 748 s = bfd_make_section_with_flags (abfd, ".dynamic", flags); 749 if (s == NULL 750 || ! bfd_set_section_alignment (abfd, s, 2)) 751 return FALSE; 752 753 /* The .got section holds the global offset table. The address 754 is put in the ld_got field. */ 755 s = bfd_make_section_with_flags (abfd, ".got", flags); 756 if (s == NULL 757 || ! bfd_set_section_alignment (abfd, s, 2)) 758 return FALSE; 759 760 /* The .plt section holds the procedure linkage table. The 761 address is put in the ld_plt field. */ 762 s = bfd_make_section_with_flags (abfd, ".plt", flags | SEC_CODE); 763 if (s == NULL 764 || ! bfd_set_section_alignment (abfd, s, 2)) 765 return FALSE; 766 767 /* The .dynrel section holds the dynamic relocs. The address is 768 put in the ld_rel field. */ 769 s = bfd_make_section_with_flags (abfd, ".dynrel", flags | SEC_READONLY); 770 if (s == NULL 771 || ! bfd_set_section_alignment (abfd, s, 2)) 772 return FALSE; 773 774 /* The .hash section holds the dynamic hash table. The address 775 is put in the ld_hash field. */ 776 s = bfd_make_section_with_flags (abfd, ".hash", flags | SEC_READONLY); 777 if (s == NULL 778 || ! bfd_set_section_alignment (abfd, s, 2)) 779 return FALSE; 780 781 /* The .dynsym section holds the dynamic symbols. The address 782 is put in the ld_stab field. */ 783 s = bfd_make_section_with_flags (abfd, ".dynsym", flags | SEC_READONLY); 784 if (s == NULL 785 || ! bfd_set_section_alignment (abfd, s, 2)) 786 return FALSE; 787 788 /* The .dynstr section holds the dynamic symbol string table. 789 The address is put in the ld_symbols field. */ 790 s = bfd_make_section_with_flags (abfd, ".dynstr", flags | SEC_READONLY); 791 if (s == NULL 792 || ! bfd_set_section_alignment (abfd, s, 2)) 793 return FALSE; 794 795 sunos_hash_table (info)->dynamic_sections_created = TRUE; 796 } 797 798 if ((needed && ! sunos_hash_table (info)->dynamic_sections_needed) 799 || info->shared) 800 { 801 bfd *dynobj; 802 803 dynobj = sunos_hash_table (info)->dynobj; 804 805 s = bfd_get_section_by_name (dynobj, ".got"); 806 if (s->size == 0) 807 s->size = BYTES_IN_WORD; 808 809 sunos_hash_table (info)->dynamic_sections_needed = TRUE; 810 sunos_hash_table (info)->got_needed = TRUE; 811 } 812 813 return TRUE; 814} 815 816/* Add dynamic symbols during a link. This is called by the a.out 817 backend linker for each object it encounters. */ 818 819static bfd_boolean 820sunos_add_dynamic_symbols (bfd *abfd, 821 struct bfd_link_info *info, 822 struct external_nlist **symsp, 823 bfd_size_type *sym_countp, 824 char **stringsp) 825{ 826 bfd *dynobj; 827 struct sunos_dynamic_info *dinfo; 828 unsigned long need; 829 830 /* Make sure we have all the required sections. */ 831 if (info->hash->creator == abfd->xvec) 832 { 833 if (! sunos_create_dynamic_sections (abfd, info, 834 ((abfd->flags & DYNAMIC) != 0 835 && !info->relocatable))) 836 return FALSE; 837 } 838 839 /* There is nothing else to do for a normal object. */ 840 if ((abfd->flags & DYNAMIC) == 0) 841 return TRUE; 842 843 dynobj = sunos_hash_table (info)->dynobj; 844 845 /* We do not want to include the sections in a dynamic object in the 846 output file. We hack by simply clobbering the list of sections 847 in the BFD. This could be handled more cleanly by, say, a new 848 section flag; the existing SEC_NEVER_LOAD flag is not the one we 849 want, because that one still implies that the section takes up 850 space in the output file. If this is the first object we have 851 seen, we must preserve the dynamic sections we just created. */ 852 if (abfd != dynobj) 853 abfd->sections = NULL; 854 else 855 { 856 asection *s; 857 858 for (s = abfd->sections; s != NULL; s = s->next) 859 { 860 if ((s->flags & SEC_LINKER_CREATED) == 0) 861 bfd_section_list_remove (abfd, s); 862 } 863 } 864 865 /* The native linker seems to just ignore dynamic objects when -r is 866 used. */ 867 if (info->relocatable) 868 return TRUE; 869 870 /* There's no hope of using a dynamic object which does not exactly 871 match the format of the output file. */ 872 if (info->hash->creator != abfd->xvec) 873 { 874 bfd_set_error (bfd_error_invalid_operation); 875 return FALSE; 876 } 877 878 /* Make sure we have a .need and a .rules sections. These are only 879 needed if there really is a dynamic object in the link, so they 880 are not added by sunos_create_dynamic_sections. */ 881 if (bfd_get_section_by_name (dynobj, ".need") == NULL) 882 { 883 /* The .need section holds the list of names of shared objets 884 which must be included at runtime. The address of this 885 section is put in the ld_need field. */ 886 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS 887 | SEC_IN_MEMORY | SEC_READONLY); 888 asection *s = bfd_make_section_with_flags (dynobj, ".need", flags); 889 if (s == NULL 890 || ! bfd_set_section_alignment (dynobj, s, 2)) 891 return FALSE; 892 } 893 894 if (bfd_get_section_by_name (dynobj, ".rules") == NULL) 895 { 896 /* The .rules section holds the path to search for shared 897 objects. The address of this section is put in the ld_rules 898 field. */ 899 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS 900 | SEC_IN_MEMORY | SEC_READONLY); 901 asection *s = bfd_make_section_with_flags (dynobj, ".rules", flags); 902 if (s == NULL 903 || ! bfd_set_section_alignment (dynobj, s, 2)) 904 return FALSE; 905 } 906 907 /* Pick up the dynamic symbols and return them to the caller. */ 908 if (! sunos_slurp_dynamic_symtab (abfd)) 909 return FALSE; 910 911 dinfo = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd); 912 *symsp = dinfo->dynsym; 913 *sym_countp = dinfo->dynsym_count; 914 *stringsp = dinfo->dynstr; 915 916 /* Record information about any other objects needed by this one. */ 917 need = dinfo->dyninfo.ld_need; 918 while (need != 0) 919 { 920 bfd_byte buf[16]; 921 unsigned long name, flags; 922 unsigned short major_vno, minor_vno; 923 struct bfd_link_needed_list *needed, **pp; 924 char *namebuf, *p; 925 bfd_size_type alc; 926 bfd_byte b; 927 char *namecopy; 928 929 if (bfd_seek (abfd, (file_ptr) need, SEEK_SET) != 0 930 || bfd_bread (buf, (bfd_size_type) 16, abfd) != 16) 931 return FALSE; 932 933 /* For the format of an ld_need entry, see aout/sun4.h. We 934 should probably define structs for this manipulation. */ 935 name = bfd_get_32 (abfd, buf); 936 flags = bfd_get_32 (abfd, buf + 4); 937 major_vno = (unsigned short) bfd_get_16 (abfd, buf + 8); 938 minor_vno = (unsigned short) bfd_get_16 (abfd, buf + 10); 939 need = bfd_get_32 (abfd, buf + 12); 940 941 alc = sizeof (struct bfd_link_needed_list); 942 needed = bfd_alloc (abfd, alc); 943 if (needed == NULL) 944 return FALSE; 945 needed->by = abfd; 946 947 /* We return the name as [-l]name[.maj][.min]. */ 948 alc = 30; 949 namebuf = bfd_malloc (alc + 1); 950 if (namebuf == NULL) 951 return FALSE; 952 p = namebuf; 953 954 if ((flags & 0x80000000) != 0) 955 { 956 *p++ = '-'; 957 *p++ = 'l'; 958 } 959 if (bfd_seek (abfd, (file_ptr) name, SEEK_SET) != 0) 960 { 961 free (namebuf); 962 return FALSE; 963 } 964 965 do 966 { 967 if (bfd_bread (&b, (bfd_size_type) 1, abfd) != 1) 968 { 969 free (namebuf); 970 return FALSE; 971 } 972 973 if ((bfd_size_type) (p - namebuf) >= alc) 974 { 975 char *n; 976 977 alc *= 2; 978 n = bfd_realloc (namebuf, alc + 1); 979 if (n == NULL) 980 { 981 free (namebuf); 982 return FALSE; 983 } 984 p = n + (p - namebuf); 985 namebuf = n; 986 } 987 988 *p++ = b; 989 } 990 while (b != '\0'); 991 992 if (major_vno == 0) 993 *p = '\0'; 994 else 995 { 996 char majbuf[30]; 997 char minbuf[30]; 998 999 sprintf (majbuf, ".%d", major_vno); 1000 if (minor_vno == 0) 1001 minbuf[0] = '\0'; 1002 else 1003 sprintf (minbuf, ".%d", minor_vno); 1004 1005 if ((p - namebuf) + strlen (majbuf) + strlen (minbuf) >= alc) 1006 { 1007 char *n; 1008 1009 alc = (p - namebuf) + strlen (majbuf) + strlen (minbuf); 1010 n = bfd_realloc (namebuf, alc + 1); 1011 if (n == NULL) 1012 { 1013 free (namebuf); 1014 return FALSE; 1015 } 1016 p = n + (p - namebuf); 1017 namebuf = n; 1018 } 1019 1020 strcpy (p, majbuf); 1021 strcat (p, minbuf); 1022 } 1023 1024 namecopy = bfd_alloc (abfd, (bfd_size_type) strlen (namebuf) + 1); 1025 if (namecopy == NULL) 1026 { 1027 free (namebuf); 1028 return FALSE; 1029 } 1030 strcpy (namecopy, namebuf); 1031 free (namebuf); 1032 needed->name = namecopy; 1033 1034 needed->next = NULL; 1035 1036 for (pp = &sunos_hash_table (info)->needed; 1037 *pp != NULL; 1038 pp = &(*pp)->next) 1039 ; 1040 *pp = needed; 1041 } 1042 1043 return TRUE; 1044} 1045 1046/* Function to add a single symbol to the linker hash table. This is 1047 a wrapper around _bfd_generic_link_add_one_symbol which handles the 1048 tweaking needed for dynamic linking support. */ 1049 1050static bfd_boolean 1051sunos_add_one_symbol (struct bfd_link_info *info, 1052 bfd *abfd, 1053 const char *name, 1054 flagword flags, 1055 asection *section, 1056 bfd_vma value, 1057 const char *string, 1058 bfd_boolean copy, 1059 bfd_boolean collect, 1060 struct bfd_link_hash_entry **hashp) 1061{ 1062 struct sunos_link_hash_entry *h; 1063 int new_flag; 1064 1065 if ((flags & (BSF_INDIRECT | BSF_WARNING | BSF_CONSTRUCTOR)) != 0 1066 || ! bfd_is_und_section (section)) 1067 h = sunos_link_hash_lookup (sunos_hash_table (info), name, TRUE, copy, 1068 FALSE); 1069 else 1070 h = ((struct sunos_link_hash_entry *) 1071 bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, copy, FALSE)); 1072 if (h == NULL) 1073 return FALSE; 1074 1075 if (hashp != NULL) 1076 *hashp = (struct bfd_link_hash_entry *) h; 1077 1078 /* Treat a common symbol in a dynamic object as defined in the .bss 1079 section of the dynamic object. We don't want to allocate space 1080 for it in our process image. */ 1081 if ((abfd->flags & DYNAMIC) != 0 1082 && bfd_is_com_section (section)) 1083 section = obj_bsssec (abfd); 1084 1085 if (! bfd_is_und_section (section) 1086 && h->root.root.type != bfd_link_hash_new 1087 && h->root.root.type != bfd_link_hash_undefined 1088 && h->root.root.type != bfd_link_hash_defweak) 1089 { 1090 /* We are defining the symbol, and it is already defined. This 1091 is a potential multiple definition error. */ 1092 if ((abfd->flags & DYNAMIC) != 0) 1093 { 1094 /* The definition we are adding is from a dynamic object. 1095 We do not want this new definition to override the 1096 existing definition, so we pretend it is just a 1097 reference. */ 1098 section = bfd_und_section_ptr; 1099 } 1100 else if (h->root.root.type == bfd_link_hash_defined 1101 && h->root.root.u.def.section->owner != NULL 1102 && (h->root.root.u.def.section->owner->flags & DYNAMIC) != 0) 1103 { 1104 /* The existing definition is from a dynamic object. We 1105 want to override it with the definition we just found. 1106 Clobber the existing definition. */ 1107 h->root.root.type = bfd_link_hash_undefined; 1108 h->root.root.u.undef.abfd = h->root.root.u.def.section->owner; 1109 } 1110 else if (h->root.root.type == bfd_link_hash_common 1111 && (h->root.root.u.c.p->section->owner->flags & DYNAMIC) != 0) 1112 { 1113 /* The existing definition is from a dynamic object. We 1114 want to override it with the definition we just found. 1115 Clobber the existing definition. We can't set it to new, 1116 because it is on the undefined list. */ 1117 h->root.root.type = bfd_link_hash_undefined; 1118 h->root.root.u.undef.abfd = h->root.root.u.c.p->section->owner; 1119 } 1120 } 1121 1122 if ((abfd->flags & DYNAMIC) != 0 1123 && abfd->xvec == info->hash->creator 1124 && (h->flags & SUNOS_CONSTRUCTOR) != 0) 1125 /* The existing symbol is a constructor symbol, and this symbol 1126 is from a dynamic object. A constructor symbol is actually a 1127 definition, although the type will be bfd_link_hash_undefined 1128 at this point. We want to ignore the definition from the 1129 dynamic object. */ 1130 section = bfd_und_section_ptr; 1131 else if ((flags & BSF_CONSTRUCTOR) != 0 1132 && (abfd->flags & DYNAMIC) == 0 1133 && h->root.root.type == bfd_link_hash_defined 1134 && h->root.root.u.def.section->owner != NULL 1135 && (h->root.root.u.def.section->owner->flags & DYNAMIC) != 0) 1136 /* The existing symbol is defined by a dynamic object, and this 1137 is a constructor symbol. As above, we want to force the use 1138 of the constructor symbol from the regular object. */ 1139 h->root.root.type = bfd_link_hash_new; 1140 1141 /* Do the usual procedure for adding a symbol. */ 1142 if (! _bfd_generic_link_add_one_symbol (info, abfd, name, flags, section, 1143 value, string, copy, collect, 1144 hashp)) 1145 return FALSE; 1146 1147 if (abfd->xvec == info->hash->creator) 1148 { 1149 /* Set a flag in the hash table entry indicating the type of 1150 reference or definition we just found. Keep a count of the 1151 number of dynamic symbols we find. A dynamic symbol is one 1152 which is referenced or defined by both a regular object and a 1153 shared object. */ 1154 if ((abfd->flags & DYNAMIC) == 0) 1155 { 1156 if (bfd_is_und_section (section)) 1157 new_flag = SUNOS_REF_REGULAR; 1158 else 1159 new_flag = SUNOS_DEF_REGULAR; 1160 } 1161 else 1162 { 1163 if (bfd_is_und_section (section)) 1164 new_flag = SUNOS_REF_DYNAMIC; 1165 else 1166 new_flag = SUNOS_DEF_DYNAMIC; 1167 } 1168 h->flags |= new_flag; 1169 1170 if (h->dynindx == -1 1171 && (h->flags & (SUNOS_DEF_REGULAR | SUNOS_REF_REGULAR)) != 0) 1172 { 1173 ++sunos_hash_table (info)->dynsymcount; 1174 h->dynindx = -2; 1175 } 1176 1177 if ((flags & BSF_CONSTRUCTOR) != 0 1178 && (abfd->flags & DYNAMIC) == 0) 1179 h->flags |= SUNOS_CONSTRUCTOR; 1180 } 1181 1182 return TRUE; 1183} 1184 1185extern const bfd_target MY (vec); 1186 1187/* Return the list of objects needed by BFD. */ 1188 1189struct bfd_link_needed_list * 1190bfd_sunos_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED, 1191 struct bfd_link_info *info) 1192{ 1193 if (info->hash->creator != &MY (vec)) 1194 return NULL; 1195 return sunos_hash_table (info)->needed; 1196} 1197 1198/* Record an assignment made to a symbol by a linker script. We need 1199 this in case some dynamic object refers to this symbol. */ 1200 1201bfd_boolean 1202bfd_sunos_record_link_assignment (bfd *output_bfd, 1203 struct bfd_link_info *info, 1204 const char *name) 1205{ 1206 struct sunos_link_hash_entry *h; 1207 1208 if (output_bfd->xvec != &MY(vec)) 1209 return TRUE; 1210 1211 /* This is called after we have examined all the input objects. If 1212 the symbol does not exist, it merely means that no object refers 1213 to it, and we can just ignore it at this point. */ 1214 h = sunos_link_hash_lookup (sunos_hash_table (info), name, 1215 FALSE, FALSE, FALSE); 1216 if (h == NULL) 1217 return TRUE; 1218 1219 /* In a shared library, the __DYNAMIC symbol does not appear in the 1220 dynamic symbol table. */ 1221 if (! info->shared || strcmp (name, "__DYNAMIC") != 0) 1222 { 1223 h->flags |= SUNOS_DEF_REGULAR; 1224 1225 if (h->dynindx == -1) 1226 { 1227 ++sunos_hash_table (info)->dynsymcount; 1228 h->dynindx = -2; 1229 } 1230 } 1231 1232 return TRUE; 1233} 1234 1235/* Scan the relocs for an input section using standard relocs. We 1236 need to figure out what to do for each reloc against a dynamic 1237 symbol. If the symbol is in the .text section, an entry is made in 1238 the procedure linkage table. Note that this will do the wrong 1239 thing if the symbol is actually data; I don't think the Sun 3 1240 native linker handles this case correctly either. If the symbol is 1241 not in the .text section, we must preserve the reloc as a dynamic 1242 reloc. FIXME: We should also handle the PIC relocs here by 1243 building global offset table entries. */ 1244 1245static bfd_boolean 1246sunos_scan_std_relocs (struct bfd_link_info *info, 1247 bfd *abfd, 1248 asection *sec ATTRIBUTE_UNUSED, 1249 const struct reloc_std_external *relocs, 1250 bfd_size_type rel_size) 1251{ 1252 bfd *dynobj; 1253 asection *splt = NULL; 1254 asection *srel = NULL; 1255 struct sunos_link_hash_entry **sym_hashes; 1256 const struct reloc_std_external *rel, *relend; 1257 1258 /* We only know how to handle m68k plt entries. */ 1259 if (bfd_get_arch (abfd) != bfd_arch_m68k) 1260 { 1261 bfd_set_error (bfd_error_invalid_target); 1262 return FALSE; 1263 } 1264 1265 dynobj = NULL; 1266 1267 sym_hashes = (struct sunos_link_hash_entry **) obj_aout_sym_hashes (abfd); 1268 1269 relend = relocs + rel_size / RELOC_STD_SIZE; 1270 for (rel = relocs; rel < relend; rel++) 1271 { 1272 int r_index; 1273 struct sunos_link_hash_entry *h; 1274 1275 /* We only want relocs against external symbols. */ 1276 if (bfd_header_big_endian (abfd)) 1277 { 1278 if ((rel->r_type[0] & RELOC_STD_BITS_EXTERN_BIG) == 0) 1279 continue; 1280 } 1281 else 1282 { 1283 if ((rel->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE) == 0) 1284 continue; 1285 } 1286 1287 /* Get the symbol index. */ 1288 if (bfd_header_big_endian (abfd)) 1289 r_index = ((rel->r_index[0] << 16) 1290 | (rel->r_index[1] << 8) 1291 | rel->r_index[2]); 1292 else 1293 r_index = ((rel->r_index[2] << 16) 1294 | (rel->r_index[1] << 8) 1295 | rel->r_index[0]); 1296 1297 /* Get the hash table entry. */ 1298 h = sym_hashes[r_index]; 1299 if (h == NULL) 1300 /* This should not normally happen, but it will in any case 1301 be caught in the relocation phase. */ 1302 continue; 1303 1304 /* At this point common symbols have already been allocated, so 1305 we don't have to worry about them. We need to consider that 1306 we may have already seen this symbol and marked it undefined; 1307 if the symbol is really undefined, then SUNOS_DEF_DYNAMIC 1308 will be zero. */ 1309 if (h->root.root.type != bfd_link_hash_defined 1310 && h->root.root.type != bfd_link_hash_defweak 1311 && h->root.root.type != bfd_link_hash_undefined) 1312 continue; 1313 1314 if ((h->flags & SUNOS_DEF_DYNAMIC) == 0 1315 || (h->flags & SUNOS_DEF_REGULAR) != 0) 1316 continue; 1317 1318 if (dynobj == NULL) 1319 { 1320 asection *sgot; 1321 1322 if (! sunos_create_dynamic_sections (abfd, info, FALSE)) 1323 return FALSE; 1324 dynobj = sunos_hash_table (info)->dynobj; 1325 splt = bfd_get_section_by_name (dynobj, ".plt"); 1326 srel = bfd_get_section_by_name (dynobj, ".dynrel"); 1327 BFD_ASSERT (splt != NULL && srel != NULL); 1328 1329 sgot = bfd_get_section_by_name (dynobj, ".got"); 1330 BFD_ASSERT (sgot != NULL); 1331 if (sgot->size == 0) 1332 sgot->size = BYTES_IN_WORD; 1333 sunos_hash_table (info)->got_needed = TRUE; 1334 } 1335 1336 BFD_ASSERT ((h->flags & SUNOS_REF_REGULAR) != 0); 1337 BFD_ASSERT (h->plt_offset != 0 1338 || ((h->root.root.type == bfd_link_hash_defined 1339 || h->root.root.type == bfd_link_hash_defweak) 1340 ? (h->root.root.u.def.section->owner->flags 1341 & DYNAMIC) != 0 1342 : (h->root.root.u.undef.abfd->flags & DYNAMIC) != 0)); 1343 1344 /* This reloc is against a symbol defined only by a dynamic 1345 object. */ 1346 if (h->root.root.type == bfd_link_hash_undefined) 1347 /* Presumably this symbol was marked as being undefined by 1348 an earlier reloc. */ 1349 srel->size += RELOC_STD_SIZE; 1350 else if ((h->root.root.u.def.section->flags & SEC_CODE) == 0) 1351 { 1352 bfd *sub; 1353 1354 /* This reloc is not in the .text section. It must be 1355 copied into the dynamic relocs. We mark the symbol as 1356 being undefined. */ 1357 srel->size += RELOC_STD_SIZE; 1358 sub = h->root.root.u.def.section->owner; 1359 h->root.root.type = bfd_link_hash_undefined; 1360 h->root.root.u.undef.abfd = sub; 1361 } 1362 else 1363 { 1364 /* This symbol is in the .text section. We must give it an 1365 entry in the procedure linkage table, if we have not 1366 already done so. We change the definition of the symbol 1367 to the .plt section; this will cause relocs against it to 1368 be handled correctly. */ 1369 if (h->plt_offset == 0) 1370 { 1371 if (splt->size == 0) 1372 splt->size = M68K_PLT_ENTRY_SIZE; 1373 h->plt_offset = splt->size; 1374 1375 if ((h->flags & SUNOS_DEF_REGULAR) == 0) 1376 { 1377 h->root.root.u.def.section = splt; 1378 h->root.root.u.def.value = splt->size; 1379 } 1380 1381 splt->size += M68K_PLT_ENTRY_SIZE; 1382 1383 /* We may also need a dynamic reloc entry. */ 1384 if ((h->flags & SUNOS_DEF_REGULAR) == 0) 1385 srel->size += RELOC_STD_SIZE; 1386 } 1387 } 1388 } 1389 1390 return TRUE; 1391} 1392 1393/* Scan the relocs for an input section using extended relocs. We 1394 need to figure out what to do for each reloc against a dynamic 1395 symbol. If the reloc is a WDISP30, and the symbol is in the .text 1396 section, an entry is made in the procedure linkage table. 1397 Otherwise, we must preserve the reloc as a dynamic reloc. */ 1398 1399static bfd_boolean 1400sunos_scan_ext_relocs (struct bfd_link_info *info, 1401 bfd *abfd, 1402 asection *sec ATTRIBUTE_UNUSED, 1403 const struct reloc_ext_external *relocs, 1404 bfd_size_type rel_size) 1405{ 1406 bfd *dynobj; 1407 struct sunos_link_hash_entry **sym_hashes; 1408 const struct reloc_ext_external *rel, *relend; 1409 asection *splt = NULL; 1410 asection *sgot = NULL; 1411 asection *srel = NULL; 1412 bfd_size_type amt; 1413 1414 /* We only know how to handle SPARC plt entries. */ 1415 if (bfd_get_arch (abfd) != bfd_arch_sparc) 1416 { 1417 bfd_set_error (bfd_error_invalid_target); 1418 return FALSE; 1419 } 1420 1421 dynobj = NULL; 1422 1423 sym_hashes = (struct sunos_link_hash_entry **) obj_aout_sym_hashes (abfd); 1424 1425 relend = relocs + rel_size / RELOC_EXT_SIZE; 1426 for (rel = relocs; rel < relend; rel++) 1427 { 1428 unsigned int r_index; 1429 int r_extern; 1430 int r_type; 1431 struct sunos_link_hash_entry *h = NULL; 1432 1433 /* Swap in the reloc information. */ 1434 if (bfd_header_big_endian (abfd)) 1435 { 1436 r_index = ((rel->r_index[0] << 16) 1437 | (rel->r_index[1] << 8) 1438 | rel->r_index[2]); 1439 r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG)); 1440 r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_BIG) 1441 >> RELOC_EXT_BITS_TYPE_SH_BIG); 1442 } 1443 else 1444 { 1445 r_index = ((rel->r_index[2] << 16) 1446 | (rel->r_index[1] << 8) 1447 | rel->r_index[0]); 1448 r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE)); 1449 r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE) 1450 >> RELOC_EXT_BITS_TYPE_SH_LITTLE); 1451 } 1452 1453 if (r_extern) 1454 { 1455 h = sym_hashes[r_index]; 1456 if (h == NULL) 1457 { 1458 /* This should not normally happen, but it will in any 1459 case be caught in the relocation phase. */ 1460 continue; 1461 } 1462 } 1463 1464 /* If this is a base relative reloc, we need to make an entry in 1465 the .got section. */ 1466 if (r_type == RELOC_BASE10 1467 || r_type == RELOC_BASE13 1468 || r_type == RELOC_BASE22) 1469 { 1470 if (dynobj == NULL) 1471 { 1472 if (! sunos_create_dynamic_sections (abfd, info, FALSE)) 1473 return FALSE; 1474 dynobj = sunos_hash_table (info)->dynobj; 1475 splt = bfd_get_section_by_name (dynobj, ".plt"); 1476 sgot = bfd_get_section_by_name (dynobj, ".got"); 1477 srel = bfd_get_section_by_name (dynobj, ".dynrel"); 1478 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL); 1479 1480 /* Make sure we have an initial entry in the .got table. */ 1481 if (sgot->size == 0) 1482 sgot->size = BYTES_IN_WORD; 1483 sunos_hash_table (info)->got_needed = TRUE; 1484 } 1485 1486 if (r_extern) 1487 { 1488 if (h->got_offset != 0) 1489 continue; 1490 1491 h->got_offset = sgot->size; 1492 } 1493 else 1494 { 1495 if (r_index >= bfd_get_symcount (abfd)) 1496 /* This is abnormal, but should be caught in the 1497 relocation phase. */ 1498 continue; 1499 1500 if (adata (abfd).local_got_offsets == NULL) 1501 { 1502 amt = bfd_get_symcount (abfd); 1503 amt *= sizeof (bfd_vma); 1504 adata (abfd).local_got_offsets = bfd_zalloc (abfd, amt); 1505 if (adata (abfd).local_got_offsets == NULL) 1506 return FALSE; 1507 } 1508 1509 if (adata (abfd).local_got_offsets[r_index] != 0) 1510 continue; 1511 1512 adata (abfd).local_got_offsets[r_index] = sgot->size; 1513 } 1514 1515 sgot->size += BYTES_IN_WORD; 1516 1517 /* If we are making a shared library, or if the symbol is 1518 defined by a dynamic object, we will need a dynamic reloc 1519 entry. */ 1520 if (info->shared 1521 || (h != NULL 1522 && (h->flags & SUNOS_DEF_DYNAMIC) != 0 1523 && (h->flags & SUNOS_DEF_REGULAR) == 0)) 1524 srel->size += RELOC_EXT_SIZE; 1525 1526 continue; 1527 } 1528 1529 /* Otherwise, we are only interested in relocs against symbols 1530 defined in dynamic objects but not in regular objects. We 1531 only need to consider relocs against external symbols. */ 1532 if (! r_extern) 1533 { 1534 /* But, if we are creating a shared library, we need to 1535 generate an absolute reloc. */ 1536 if (info->shared) 1537 { 1538 if (dynobj == NULL) 1539 { 1540 if (! sunos_create_dynamic_sections (abfd, info, TRUE)) 1541 return FALSE; 1542 dynobj = sunos_hash_table (info)->dynobj; 1543 splt = bfd_get_section_by_name (dynobj, ".plt"); 1544 sgot = bfd_get_section_by_name (dynobj, ".got"); 1545 srel = bfd_get_section_by_name (dynobj, ".dynrel"); 1546 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL); 1547 } 1548 1549 srel->size += RELOC_EXT_SIZE; 1550 } 1551 1552 continue; 1553 } 1554 1555 /* At this point common symbols have already been allocated, so 1556 we don't have to worry about them. We need to consider that 1557 we may have already seen this symbol and marked it undefined; 1558 if the symbol is really undefined, then SUNOS_DEF_DYNAMIC 1559 will be zero. */ 1560 if (h->root.root.type != bfd_link_hash_defined 1561 && h->root.root.type != bfd_link_hash_defweak 1562 && h->root.root.type != bfd_link_hash_undefined) 1563 continue; 1564 1565 if (r_type != RELOC_JMP_TBL 1566 && ! info->shared 1567 && ((h->flags & SUNOS_DEF_DYNAMIC) == 0 1568 || (h->flags & SUNOS_DEF_REGULAR) != 0)) 1569 continue; 1570 1571 if (r_type == RELOC_JMP_TBL 1572 && ! info->shared 1573 && (h->flags & SUNOS_DEF_DYNAMIC) == 0 1574 && (h->flags & SUNOS_DEF_REGULAR) == 0) 1575 { 1576 /* This symbol is apparently undefined. Don't do anything 1577 here; just let the relocation routine report an undefined 1578 symbol. */ 1579 continue; 1580 } 1581 1582 if (strcmp (h->root.root.root.string, "__GLOBAL_OFFSET_TABLE_") == 0) 1583 continue; 1584 1585 if (dynobj == NULL) 1586 { 1587 if (! sunos_create_dynamic_sections (abfd, info, FALSE)) 1588 return FALSE; 1589 dynobj = sunos_hash_table (info)->dynobj; 1590 splt = bfd_get_section_by_name (dynobj, ".plt"); 1591 sgot = bfd_get_section_by_name (dynobj, ".got"); 1592 srel = bfd_get_section_by_name (dynobj, ".dynrel"); 1593 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL); 1594 1595 /* Make sure we have an initial entry in the .got table. */ 1596 if (sgot->size == 0) 1597 sgot->size = BYTES_IN_WORD; 1598 sunos_hash_table (info)->got_needed = TRUE; 1599 } 1600 1601 BFD_ASSERT (r_type == RELOC_JMP_TBL 1602 || info->shared 1603 || (h->flags & SUNOS_REF_REGULAR) != 0); 1604 BFD_ASSERT (r_type == RELOC_JMP_TBL 1605 || info->shared 1606 || h->plt_offset != 0 1607 || ((h->root.root.type == bfd_link_hash_defined 1608 || h->root.root.type == bfd_link_hash_defweak) 1609 ? (h->root.root.u.def.section->owner->flags 1610 & DYNAMIC) != 0 1611 : (h->root.root.u.undef.abfd->flags & DYNAMIC) != 0)); 1612 1613 /* This reloc is against a symbol defined only by a dynamic 1614 object, or it is a jump table reloc from PIC compiled code. */ 1615 1616 if (r_type != RELOC_JMP_TBL 1617 && h->root.root.type == bfd_link_hash_undefined) 1618 /* Presumably this symbol was marked as being undefined by 1619 an earlier reloc. */ 1620 srel->size += RELOC_EXT_SIZE; 1621 1622 else if (r_type != RELOC_JMP_TBL 1623 && (h->root.root.u.def.section->flags & SEC_CODE) == 0) 1624 { 1625 bfd *sub; 1626 1627 /* This reloc is not in the .text section. It must be 1628 copied into the dynamic relocs. We mark the symbol as 1629 being undefined. */ 1630 srel->size += RELOC_EXT_SIZE; 1631 if ((h->flags & SUNOS_DEF_REGULAR) == 0) 1632 { 1633 sub = h->root.root.u.def.section->owner; 1634 h->root.root.type = bfd_link_hash_undefined; 1635 h->root.root.u.undef.abfd = sub; 1636 } 1637 } 1638 else 1639 { 1640 /* This symbol is in the .text section. We must give it an 1641 entry in the procedure linkage table, if we have not 1642 already done so. We change the definition of the symbol 1643 to the .plt section; this will cause relocs against it to 1644 be handled correctly. */ 1645 if (h->plt_offset == 0) 1646 { 1647 if (splt->size == 0) 1648 splt->size = SPARC_PLT_ENTRY_SIZE; 1649 h->plt_offset = splt->size; 1650 1651 if ((h->flags & SUNOS_DEF_REGULAR) == 0) 1652 { 1653 if (h->root.root.type == bfd_link_hash_undefined) 1654 h->root.root.type = bfd_link_hash_defined; 1655 h->root.root.u.def.section = splt; 1656 h->root.root.u.def.value = splt->size; 1657 } 1658 1659 splt->size += SPARC_PLT_ENTRY_SIZE; 1660 1661 /* We will also need a dynamic reloc entry, unless this 1662 is a JMP_TBL reloc produced by linking PIC compiled 1663 code, and we are not making a shared library. */ 1664 if (info->shared || (h->flags & SUNOS_DEF_REGULAR) == 0) 1665 srel->size += RELOC_EXT_SIZE; 1666 } 1667 1668 /* If we are creating a shared library, we need to copy over 1669 any reloc other than a jump table reloc. */ 1670 if (info->shared && r_type != RELOC_JMP_TBL) 1671 srel->size += RELOC_EXT_SIZE; 1672 } 1673 } 1674 1675 return TRUE; 1676} 1677 1678/* Scan the relocs for an input section. */ 1679 1680static bfd_boolean 1681sunos_scan_relocs (struct bfd_link_info *info, 1682 bfd *abfd, 1683 asection *sec, 1684 bfd_size_type rel_size) 1685{ 1686 void * relocs; 1687 void * free_relocs = NULL; 1688 1689 if (rel_size == 0) 1690 return TRUE; 1691 1692 if (! info->keep_memory) 1693 relocs = free_relocs = bfd_malloc (rel_size); 1694 else 1695 { 1696 struct aout_section_data_struct *n; 1697 bfd_size_type amt = sizeof (struct aout_section_data_struct); 1698 1699 n = bfd_alloc (abfd, amt); 1700 if (n == NULL) 1701 relocs = NULL; 1702 else 1703 { 1704 set_aout_section_data (sec, n); 1705 relocs = bfd_malloc (rel_size); 1706 aout_section_data (sec)->relocs = relocs; 1707 } 1708 } 1709 if (relocs == NULL) 1710 return FALSE; 1711 1712 if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0 1713 || bfd_bread (relocs, rel_size, abfd) != rel_size) 1714 goto error_return; 1715 1716 if (obj_reloc_entry_size (abfd) == RELOC_STD_SIZE) 1717 { 1718 if (! sunos_scan_std_relocs (info, abfd, sec, 1719 (struct reloc_std_external *) relocs, 1720 rel_size)) 1721 goto error_return; 1722 } 1723 else 1724 { 1725 if (! sunos_scan_ext_relocs (info, abfd, sec, 1726 (struct reloc_ext_external *) relocs, 1727 rel_size)) 1728 goto error_return; 1729 } 1730 1731 if (free_relocs != NULL) 1732 free (free_relocs); 1733 1734 return TRUE; 1735 1736 error_return: 1737 if (free_relocs != NULL) 1738 free (free_relocs); 1739 return FALSE; 1740} 1741 1742/* Build the hash table of dynamic symbols, and to mark as written all 1743 symbols from dynamic objects which we do not plan to write out. */ 1744 1745static bfd_boolean 1746sunos_scan_dynamic_symbol (struct sunos_link_hash_entry *h, void * data) 1747{ 1748 struct bfd_link_info *info = (struct bfd_link_info *) data; 1749 1750 if (h->root.root.type == bfd_link_hash_warning) 1751 h = (struct sunos_link_hash_entry *) h->root.root.u.i.link; 1752 1753 /* Set the written flag for symbols we do not want to write out as 1754 part of the regular symbol table. This is all symbols which are 1755 not defined in a regular object file. For some reason symbols 1756 which are referenced by a regular object and defined by a dynamic 1757 object do not seem to show up in the regular symbol table. It is 1758 possible for a symbol to have only SUNOS_REF_REGULAR set here, it 1759 is an undefined symbol which was turned into a common symbol 1760 because it was found in an archive object which was not included 1761 in the link. */ 1762 if ((h->flags & SUNOS_DEF_REGULAR) == 0 1763 && (h->flags & SUNOS_DEF_DYNAMIC) != 0 1764 && strcmp (h->root.root.root.string, "__DYNAMIC") != 0) 1765 h->root.written = TRUE; 1766 1767 /* If this symbol is defined by a dynamic object and referenced by a 1768 regular object, see whether we gave it a reasonable value while 1769 scanning the relocs. */ 1770 if ((h->flags & SUNOS_DEF_REGULAR) == 0 1771 && (h->flags & SUNOS_DEF_DYNAMIC) != 0 1772 && (h->flags & SUNOS_REF_REGULAR) != 0) 1773 { 1774 if ((h->root.root.type == bfd_link_hash_defined 1775 || h->root.root.type == bfd_link_hash_defweak) 1776 && ((h->root.root.u.def.section->owner->flags & DYNAMIC) != 0) 1777 && h->root.root.u.def.section->output_section == NULL) 1778 { 1779 bfd *sub; 1780 1781 /* This symbol is currently defined in a dynamic section 1782 which is not being put into the output file. This 1783 implies that there is no reloc against the symbol. I'm 1784 not sure why this case would ever occur. In any case, we 1785 change the symbol to be undefined. */ 1786 sub = h->root.root.u.def.section->owner; 1787 h->root.root.type = bfd_link_hash_undefined; 1788 h->root.root.u.undef.abfd = sub; 1789 } 1790 } 1791 1792 /* If this symbol is defined or referenced by a regular file, add it 1793 to the dynamic symbols. */ 1794 if ((h->flags & (SUNOS_DEF_REGULAR | SUNOS_REF_REGULAR)) != 0) 1795 { 1796 asection *s; 1797 size_t len; 1798 bfd_byte *contents; 1799 unsigned char *name; 1800 unsigned long hash; 1801 bfd *dynobj; 1802 1803 BFD_ASSERT (h->dynindx == -2); 1804 1805 dynobj = sunos_hash_table (info)->dynobj; 1806 1807 h->dynindx = sunos_hash_table (info)->dynsymcount; 1808 ++sunos_hash_table (info)->dynsymcount; 1809 1810 len = strlen (h->root.root.root.string); 1811 1812 /* We don't bother to construct a BFD hash table for the strings 1813 which are the names of the dynamic symbols. Using a hash 1814 table for the regular symbols is beneficial, because the 1815 regular symbols includes the debugging symbols, which have 1816 long names and are often duplicated in several object files. 1817 There are no debugging symbols in the dynamic symbols. */ 1818 s = bfd_get_section_by_name (dynobj, ".dynstr"); 1819 BFD_ASSERT (s != NULL); 1820 contents = bfd_realloc (s->contents, s->size + len + 1); 1821 if (contents == NULL) 1822 return FALSE; 1823 s->contents = contents; 1824 1825 h->dynstr_index = s->size; 1826 strcpy ((char *) contents + s->size, h->root.root.root.string); 1827 s->size += len + 1; 1828 1829 /* Add it to the dynamic hash table. */ 1830 name = (unsigned char *) h->root.root.root.string; 1831 hash = 0; 1832 while (*name != '\0') 1833 hash = (hash << 1) + *name++; 1834 hash &= 0x7fffffff; 1835 hash %= sunos_hash_table (info)->bucketcount; 1836 1837 s = bfd_get_section_by_name (dynobj, ".hash"); 1838 BFD_ASSERT (s != NULL); 1839 1840 if (GET_SWORD (dynobj, s->contents + hash * HASH_ENTRY_SIZE) == -1) 1841 PUT_WORD (dynobj, h->dynindx, s->contents + hash * HASH_ENTRY_SIZE); 1842 else 1843 { 1844 bfd_vma next; 1845 1846 next = GET_WORD (dynobj, 1847 (s->contents 1848 + hash * HASH_ENTRY_SIZE 1849 + BYTES_IN_WORD)); 1850 PUT_WORD (dynobj, s->size / HASH_ENTRY_SIZE, 1851 s->contents + hash * HASH_ENTRY_SIZE + BYTES_IN_WORD); 1852 PUT_WORD (dynobj, h->dynindx, s->contents + s->size); 1853 PUT_WORD (dynobj, next, s->contents + s->size + BYTES_IN_WORD); 1854 s->size += HASH_ENTRY_SIZE; 1855 } 1856 } 1857 1858 return TRUE; 1859} 1860 1861/* Set up the sizes and contents of the dynamic sections created in 1862 sunos_add_dynamic_symbols. This is called by the SunOS linker 1863 emulation before_allocation routine. We must set the sizes of the 1864 sections before the linker sets the addresses of the various 1865 sections. This unfortunately requires reading all the relocs so 1866 that we can work out which ones need to become dynamic relocs. If 1867 info->keep_memory is TRUE, we keep the relocs in memory; otherwise, 1868 we discard them, and will read them again later. */ 1869 1870bfd_boolean 1871bfd_sunos_size_dynamic_sections (bfd *output_bfd, 1872 struct bfd_link_info *info, 1873 asection **sdynptr, 1874 asection **sneedptr, 1875 asection **srulesptr) 1876{ 1877 bfd *dynobj; 1878 bfd_size_type dynsymcount; 1879 struct sunos_link_hash_entry *h; 1880 asection *s; 1881 size_t bucketcount; 1882 bfd_size_type hashalloc; 1883 size_t i; 1884 bfd *sub; 1885 1886 *sdynptr = NULL; 1887 *sneedptr = NULL; 1888 *srulesptr = NULL; 1889 1890 if (info->relocatable) 1891 return TRUE; 1892 1893 if (output_bfd->xvec != &MY(vec)) 1894 return TRUE; 1895 1896 /* Look through all the input BFD's and read their relocs. It would 1897 be better if we didn't have to do this, but there is no other way 1898 to determine the number of dynamic relocs we need, and, more 1899 importantly, there is no other way to know which symbols should 1900 get an entry in the procedure linkage table. */ 1901 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next) 1902 { 1903 if ((sub->flags & DYNAMIC) == 0 1904 && sub->xvec == output_bfd->xvec) 1905 { 1906 if (! sunos_scan_relocs (info, sub, obj_textsec (sub), 1907 exec_hdr (sub)->a_trsize) 1908 || ! sunos_scan_relocs (info, sub, obj_datasec (sub), 1909 exec_hdr (sub)->a_drsize)) 1910 return FALSE; 1911 } 1912 } 1913 1914 dynobj = sunos_hash_table (info)->dynobj; 1915 dynsymcount = sunos_hash_table (info)->dynsymcount; 1916 1917 /* If there were no dynamic objects in the link, and we don't need 1918 to build a global offset table, there is nothing to do here. */ 1919 if (! sunos_hash_table (info)->dynamic_sections_needed 1920 && ! sunos_hash_table (info)->got_needed) 1921 return TRUE; 1922 1923 /* If __GLOBAL_OFFSET_TABLE_ was mentioned, define it. */ 1924 h = sunos_link_hash_lookup (sunos_hash_table (info), 1925 "__GLOBAL_OFFSET_TABLE_", FALSE, FALSE, FALSE); 1926 if (h != NULL && (h->flags & SUNOS_REF_REGULAR) != 0) 1927 { 1928 h->flags |= SUNOS_DEF_REGULAR; 1929 if (h->dynindx == -1) 1930 { 1931 ++sunos_hash_table (info)->dynsymcount; 1932 h->dynindx = -2; 1933 } 1934 h->root.root.type = bfd_link_hash_defined; 1935 h->root.root.u.def.section = bfd_get_section_by_name (dynobj, ".got"); 1936 1937 /* If the .got section is more than 0x1000 bytes, we set 1938 __GLOBAL_OFFSET_TABLE_ to be 0x1000 bytes into the section, 1939 so that 13 bit relocations have a greater chance of working. */ 1940 s = bfd_get_section_by_name (dynobj, ".got"); 1941 BFD_ASSERT (s != NULL); 1942 if (s->size >= 0x1000) 1943 h->root.root.u.def.value = 0x1000; 1944 else 1945 h->root.root.u.def.value = 0; 1946 1947 sunos_hash_table (info)->got_base = h->root.root.u.def.value; 1948 } 1949 1950 /* If there are any shared objects in the link, then we need to set 1951 up the dynamic linking information. */ 1952 if (sunos_hash_table (info)->dynamic_sections_needed) 1953 { 1954 *sdynptr = bfd_get_section_by_name (dynobj, ".dynamic"); 1955 1956 /* The .dynamic section is always the same size. */ 1957 s = *sdynptr; 1958 BFD_ASSERT (s != NULL); 1959 s->size = (sizeof (struct external_sun4_dynamic) 1960 + EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE 1961 + sizeof (struct external_sun4_dynamic_link)); 1962 1963 /* Set the size of the .dynsym and .hash sections. We counted 1964 the number of dynamic symbols as we read the input files. We 1965 will build the dynamic symbol table (.dynsym) and the hash 1966 table (.hash) when we build the final symbol table, because 1967 until then we do not know the correct value to give the 1968 symbols. We build the dynamic symbol string table (.dynstr) 1969 in a traversal of the symbol table using 1970 sunos_scan_dynamic_symbol. */ 1971 s = bfd_get_section_by_name (dynobj, ".dynsym"); 1972 BFD_ASSERT (s != NULL); 1973 s->size = dynsymcount * sizeof (struct external_nlist); 1974 s->contents = bfd_alloc (output_bfd, s->size); 1975 if (s->contents == NULL && s->size != 0) 1976 return FALSE; 1977 1978 /* The number of buckets is just the number of symbols divided 1979 by four. To compute the final size of the hash table, we 1980 must actually compute the hash table. Normally we need 1981 exactly as many entries in the hash table as there are 1982 dynamic symbols, but if some of the buckets are not used we 1983 will need additional entries. In the worst case, every 1984 symbol will hash to the same bucket, and we will need 1985 BUCKETCOUNT - 1 extra entries. */ 1986 if (dynsymcount >= 4) 1987 bucketcount = dynsymcount / 4; 1988 else if (dynsymcount > 0) 1989 bucketcount = dynsymcount; 1990 else 1991 bucketcount = 1; 1992 s = bfd_get_section_by_name (dynobj, ".hash"); 1993 BFD_ASSERT (s != NULL); 1994 hashalloc = (dynsymcount + bucketcount - 1) * HASH_ENTRY_SIZE; 1995 s->contents = bfd_zalloc (dynobj, hashalloc); 1996 if (s->contents == NULL && dynsymcount > 0) 1997 return FALSE; 1998 for (i = 0; i < bucketcount; i++) 1999 PUT_WORD (output_bfd, (bfd_vma) -1, s->contents + i * HASH_ENTRY_SIZE); 2000 s->size = bucketcount * HASH_ENTRY_SIZE; 2001 2002 sunos_hash_table (info)->bucketcount = bucketcount; 2003 2004 /* Scan all the symbols, place them in the dynamic symbol table, 2005 and build the dynamic hash table. We reuse dynsymcount as a 2006 counter for the number of symbols we have added so far. */ 2007 sunos_hash_table (info)->dynsymcount = 0; 2008 sunos_link_hash_traverse (sunos_hash_table (info), 2009 sunos_scan_dynamic_symbol, 2010 (void *) info); 2011 BFD_ASSERT (sunos_hash_table (info)->dynsymcount == dynsymcount); 2012 2013 /* The SunOS native linker seems to align the total size of the 2014 symbol strings to a multiple of 8. I don't know if this is 2015 important, but it can't hurt much. */ 2016 s = bfd_get_section_by_name (dynobj, ".dynstr"); 2017 BFD_ASSERT (s != NULL); 2018 if ((s->size & 7) != 0) 2019 { 2020 bfd_size_type add; 2021 bfd_byte *contents; 2022 2023 add = 8 - (s->size & 7); 2024 contents = bfd_realloc (s->contents, s->size + add); 2025 if (contents == NULL) 2026 return FALSE; 2027 memset (contents + s->size, 0, (size_t) add); 2028 s->contents = contents; 2029 s->size += add; 2030 } 2031 } 2032 2033 /* Now that we have worked out the sizes of the procedure linkage 2034 table and the dynamic relocs, allocate storage for them. */ 2035 s = bfd_get_section_by_name (dynobj, ".plt"); 2036 BFD_ASSERT (s != NULL); 2037 if (s->size != 0) 2038 { 2039 s->contents = bfd_alloc (dynobj, s->size); 2040 if (s->contents == NULL) 2041 return FALSE; 2042 2043 /* Fill in the first entry in the table. */ 2044 switch (bfd_get_arch (dynobj)) 2045 { 2046 case bfd_arch_sparc: 2047 memcpy (s->contents, sparc_plt_first_entry, SPARC_PLT_ENTRY_SIZE); 2048 break; 2049 2050 case bfd_arch_m68k: 2051 memcpy (s->contents, m68k_plt_first_entry, M68K_PLT_ENTRY_SIZE); 2052 break; 2053 2054 default: 2055 abort (); 2056 } 2057 } 2058 2059 s = bfd_get_section_by_name (dynobj, ".dynrel"); 2060 if (s->size != 0) 2061 { 2062 s->contents = bfd_alloc (dynobj, s->size); 2063 if (s->contents == NULL) 2064 return FALSE; 2065 } 2066 /* We use the reloc_count field to keep track of how many of the 2067 relocs we have output so far. */ 2068 s->reloc_count = 0; 2069 2070 /* Make space for the global offset table. */ 2071 s = bfd_get_section_by_name (dynobj, ".got"); 2072 s->contents = bfd_alloc (dynobj, s->size); 2073 if (s->contents == NULL) 2074 return FALSE; 2075 2076 *sneedptr = bfd_get_section_by_name (dynobj, ".need"); 2077 *srulesptr = bfd_get_section_by_name (dynobj, ".rules"); 2078 2079 return TRUE; 2080} 2081 2082/* Link a dynamic object. We actually don't have anything to do at 2083 this point. This entry point exists to prevent the regular linker 2084 code from doing anything with the object. */ 2085 2086static bfd_boolean 2087sunos_link_dynamic_object (struct bfd_link_info *info ATTRIBUTE_UNUSED, 2088 bfd *abfd ATTRIBUTE_UNUSED) 2089{ 2090 return TRUE; 2091} 2092 2093/* Write out a dynamic symbol. This is called by the final traversal 2094 over the symbol table. */ 2095 2096static bfd_boolean 2097sunos_write_dynamic_symbol (bfd *output_bfd, 2098 struct bfd_link_info *info, 2099 struct aout_link_hash_entry *harg) 2100{ 2101 struct sunos_link_hash_entry *h = (struct sunos_link_hash_entry *) harg; 2102 int type; 2103 bfd_vma val; 2104 asection *s; 2105 struct external_nlist *outsym; 2106 2107 /* If this symbol is in the procedure linkage table, fill in the 2108 table entry. */ 2109 if (h->plt_offset != 0) 2110 { 2111 bfd *dynobj; 2112 asection *splt; 2113 bfd_byte *p; 2114 bfd_vma r_address; 2115 2116 dynobj = sunos_hash_table (info)->dynobj; 2117 splt = bfd_get_section_by_name (dynobj, ".plt"); 2118 p = splt->contents + h->plt_offset; 2119 2120 s = bfd_get_section_by_name (dynobj, ".dynrel"); 2121 2122 r_address = (splt->output_section->vma 2123 + splt->output_offset 2124 + h->plt_offset); 2125 2126 switch (bfd_get_arch (output_bfd)) 2127 { 2128 case bfd_arch_sparc: 2129 if (info->shared || (h->flags & SUNOS_DEF_REGULAR) == 0) 2130 { 2131 bfd_put_32 (output_bfd, SPARC_PLT_ENTRY_WORD0, p); 2132 bfd_put_32 (output_bfd, 2133 (SPARC_PLT_ENTRY_WORD1 2134 + (((- (h->plt_offset + 4) >> 2) 2135 & 0x3fffffff))), 2136 p + 4); 2137 bfd_put_32 (output_bfd, SPARC_PLT_ENTRY_WORD2 + s->reloc_count, 2138 p + 8); 2139 } 2140 else 2141 { 2142 val = (h->root.root.u.def.section->output_section->vma 2143 + h->root.root.u.def.section->output_offset 2144 + h->root.root.u.def.value); 2145 bfd_put_32 (output_bfd, 2146 SPARC_PLT_PIC_WORD0 + ((val >> 10) & 0x3fffff), 2147 p); 2148 bfd_put_32 (output_bfd, 2149 SPARC_PLT_PIC_WORD1 + (val & 0x3ff), 2150 p + 4); 2151 bfd_put_32 (output_bfd, SPARC_PLT_PIC_WORD2, p + 8); 2152 } 2153 break; 2154 2155 case bfd_arch_m68k: 2156 if (! info->shared && (h->flags & SUNOS_DEF_REGULAR) != 0) 2157 abort (); 2158 bfd_put_16 (output_bfd, M68K_PLT_ENTRY_WORD0, p); 2159 bfd_put_32 (output_bfd, (- (h->plt_offset + 2)), p + 2); 2160 bfd_put_16 (output_bfd, (bfd_vma) s->reloc_count, p + 6); 2161 r_address += 2; 2162 break; 2163 2164 default: 2165 abort (); 2166 } 2167 2168 /* We also need to add a jump table reloc, unless this is the 2169 result of a JMP_TBL reloc from PIC compiled code. */ 2170 if (info->shared || (h->flags & SUNOS_DEF_REGULAR) == 0) 2171 { 2172 BFD_ASSERT (h->dynindx >= 0); 2173 BFD_ASSERT (s->reloc_count * obj_reloc_entry_size (dynobj) 2174 < s->size); 2175 p = s->contents + s->reloc_count * obj_reloc_entry_size (output_bfd); 2176 if (obj_reloc_entry_size (output_bfd) == RELOC_STD_SIZE) 2177 { 2178 struct reloc_std_external *srel; 2179 2180 srel = (struct reloc_std_external *) p; 2181 PUT_WORD (output_bfd, r_address, srel->r_address); 2182 if (bfd_header_big_endian (output_bfd)) 2183 { 2184 srel->r_index[0] = (bfd_byte) (h->dynindx >> 16); 2185 srel->r_index[1] = (bfd_byte) (h->dynindx >> 8); 2186 srel->r_index[2] = (bfd_byte) (h->dynindx); 2187 srel->r_type[0] = (RELOC_STD_BITS_EXTERN_BIG 2188 | RELOC_STD_BITS_JMPTABLE_BIG); 2189 } 2190 else 2191 { 2192 srel->r_index[2] = (bfd_byte) (h->dynindx >> 16); 2193 srel->r_index[1] = (bfd_byte) (h->dynindx >> 8); 2194 srel->r_index[0] = (bfd_byte)h->dynindx; 2195 srel->r_type[0] = (RELOC_STD_BITS_EXTERN_LITTLE 2196 | RELOC_STD_BITS_JMPTABLE_LITTLE); 2197 } 2198 } 2199 else 2200 { 2201 struct reloc_ext_external *erel; 2202 2203 erel = (struct reloc_ext_external *) p; 2204 PUT_WORD (output_bfd, r_address, erel->r_address); 2205 if (bfd_header_big_endian (output_bfd)) 2206 { 2207 erel->r_index[0] = (bfd_byte) (h->dynindx >> 16); 2208 erel->r_index[1] = (bfd_byte) (h->dynindx >> 8); 2209 erel->r_index[2] = (bfd_byte)h->dynindx; 2210 erel->r_type[0] = 2211 (RELOC_EXT_BITS_EXTERN_BIG 2212 | (RELOC_JMP_SLOT << RELOC_EXT_BITS_TYPE_SH_BIG)); 2213 } 2214 else 2215 { 2216 erel->r_index[2] = (bfd_byte) (h->dynindx >> 16); 2217 erel->r_index[1] = (bfd_byte) (h->dynindx >> 8); 2218 erel->r_index[0] = (bfd_byte)h->dynindx; 2219 erel->r_type[0] = 2220 (RELOC_EXT_BITS_EXTERN_LITTLE 2221 | (RELOC_JMP_SLOT << RELOC_EXT_BITS_TYPE_SH_LITTLE)); 2222 } 2223 PUT_WORD (output_bfd, (bfd_vma) 0, erel->r_addend); 2224 } 2225 2226 ++s->reloc_count; 2227 } 2228 } 2229 2230 /* If this is not a dynamic symbol, we don't have to do anything 2231 else. We only check this after handling the PLT entry, because 2232 we can have a PLT entry for a nondynamic symbol when linking PIC 2233 compiled code from a regular object. */ 2234 if (h->dynindx < 0) 2235 return TRUE; 2236 2237 switch (h->root.root.type) 2238 { 2239 default: 2240 case bfd_link_hash_new: 2241 abort (); 2242 /* Avoid variable not initialized warnings. */ 2243 return TRUE; 2244 case bfd_link_hash_undefined: 2245 type = N_UNDF | N_EXT; 2246 val = 0; 2247 break; 2248 case bfd_link_hash_defined: 2249 case bfd_link_hash_defweak: 2250 { 2251 asection *sec; 2252 asection *output_section; 2253 2254 sec = h->root.root.u.def.section; 2255 output_section = sec->output_section; 2256 BFD_ASSERT (bfd_is_abs_section (output_section) 2257 || output_section->owner == output_bfd); 2258 if (h->plt_offset != 0 2259 && (h->flags & SUNOS_DEF_REGULAR) == 0) 2260 { 2261 type = N_UNDF | N_EXT; 2262 val = 0; 2263 } 2264 else 2265 { 2266 if (output_section == obj_textsec (output_bfd)) 2267 type = (h->root.root.type == bfd_link_hash_defined 2268 ? N_TEXT 2269 : N_WEAKT); 2270 else if (output_section == obj_datasec (output_bfd)) 2271 type = (h->root.root.type == bfd_link_hash_defined 2272 ? N_DATA 2273 : N_WEAKD); 2274 else if (output_section == obj_bsssec (output_bfd)) 2275 type = (h->root.root.type == bfd_link_hash_defined 2276 ? N_BSS 2277 : N_WEAKB); 2278 else 2279 type = (h->root.root.type == bfd_link_hash_defined 2280 ? N_ABS 2281 : N_WEAKA); 2282 type |= N_EXT; 2283 val = (h->root.root.u.def.value 2284 + output_section->vma 2285 + sec->output_offset); 2286 } 2287 } 2288 break; 2289 case bfd_link_hash_common: 2290 type = N_UNDF | N_EXT; 2291 val = h->root.root.u.c.size; 2292 break; 2293 case bfd_link_hash_undefweak: 2294 type = N_WEAKU; 2295 val = 0; 2296 break; 2297 case bfd_link_hash_indirect: 2298 case bfd_link_hash_warning: 2299 /* FIXME: Ignore these for now. The circumstances under which 2300 they should be written out are not clear to me. */ 2301 return TRUE; 2302 } 2303 2304 s = bfd_get_section_by_name (sunos_hash_table (info)->dynobj, ".dynsym"); 2305 BFD_ASSERT (s != NULL); 2306 outsym = ((struct external_nlist *) 2307 (s->contents + h->dynindx * EXTERNAL_NLIST_SIZE)); 2308 2309 H_PUT_8 (output_bfd, type, outsym->e_type); 2310 H_PUT_8 (output_bfd, 0, outsym->e_other); 2311 2312 /* FIXME: The native linker doesn't use 0 for desc. It seems to use 2313 one less than the desc value in the shared library, although that 2314 seems unlikely. */ 2315 H_PUT_16 (output_bfd, 0, outsym->e_desc); 2316 2317 PUT_WORD (output_bfd, h->dynstr_index, outsym->e_strx); 2318 PUT_WORD (output_bfd, val, outsym->e_value); 2319 2320 return TRUE; 2321} 2322 2323/* This is called for each reloc against an external symbol. If this 2324 is a reloc which are are going to copy as a dynamic reloc, then 2325 copy it over, and tell the caller to not bother processing this 2326 reloc. */ 2327 2328static bfd_boolean 2329sunos_check_dynamic_reloc (struct bfd_link_info *info, 2330 bfd *input_bfd, 2331 asection *input_section, 2332 struct aout_link_hash_entry *harg, 2333 void * reloc, 2334 bfd_byte *contents ATTRIBUTE_UNUSED, 2335 bfd_boolean *skip, 2336 bfd_vma *relocationp) 2337{ 2338 struct sunos_link_hash_entry *h = (struct sunos_link_hash_entry *) harg; 2339 bfd *dynobj; 2340 bfd_boolean baserel; 2341 bfd_boolean jmptbl; 2342 bfd_boolean pcrel; 2343 asection *s; 2344 bfd_byte *p; 2345 long indx; 2346 2347 *skip = FALSE; 2348 2349 dynobj = sunos_hash_table (info)->dynobj; 2350 2351 if (h != NULL 2352 && h->plt_offset != 0 2353 && (info->shared 2354 || (h->flags & SUNOS_DEF_REGULAR) == 0)) 2355 { 2356 asection *splt; 2357 2358 /* Redirect the relocation to the PLT entry. */ 2359 splt = bfd_get_section_by_name (dynobj, ".plt"); 2360 *relocationp = (splt->output_section->vma 2361 + splt->output_offset 2362 + h->plt_offset); 2363 } 2364 2365 if (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE) 2366 { 2367 struct reloc_std_external *srel; 2368 2369 srel = (struct reloc_std_external *) reloc; 2370 if (bfd_header_big_endian (input_bfd)) 2371 { 2372 baserel = (0 != (srel->r_type[0] & RELOC_STD_BITS_BASEREL_BIG)); 2373 jmptbl = (0 != (srel->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG)); 2374 pcrel = (0 != (srel->r_type[0] & RELOC_STD_BITS_PCREL_BIG)); 2375 } 2376 else 2377 { 2378 baserel = (0 != (srel->r_type[0] & RELOC_STD_BITS_BASEREL_LITTLE)); 2379 jmptbl = (0 != (srel->r_type[0] & RELOC_STD_BITS_JMPTABLE_LITTLE)); 2380 pcrel = (0 != (srel->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE)); 2381 } 2382 } 2383 else 2384 { 2385 struct reloc_ext_external *erel; 2386 int r_type; 2387 2388 erel = (struct reloc_ext_external *) reloc; 2389 if (bfd_header_big_endian (input_bfd)) 2390 r_type = ((erel->r_type[0] & RELOC_EXT_BITS_TYPE_BIG) 2391 >> RELOC_EXT_BITS_TYPE_SH_BIG); 2392 else 2393 r_type = ((erel->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE) 2394 >> RELOC_EXT_BITS_TYPE_SH_LITTLE); 2395 baserel = (r_type == RELOC_BASE10 2396 || r_type == RELOC_BASE13 2397 || r_type == RELOC_BASE22); 2398 jmptbl = r_type == RELOC_JMP_TBL; 2399 pcrel = (r_type == RELOC_DISP8 2400 || r_type == RELOC_DISP16 2401 || r_type == RELOC_DISP32 2402 || r_type == RELOC_WDISP30 2403 || r_type == RELOC_WDISP22); 2404 /* We don't consider the PC10 and PC22 types to be PC relative, 2405 because they are pcrel_offset. */ 2406 } 2407 2408 if (baserel) 2409 { 2410 bfd_vma *got_offsetp; 2411 asection *sgot; 2412 2413 if (h != NULL) 2414 got_offsetp = &h->got_offset; 2415 else if (adata (input_bfd).local_got_offsets == NULL) 2416 got_offsetp = NULL; 2417 else 2418 { 2419 struct reloc_std_external *srel; 2420 int r_index; 2421 2422 srel = (struct reloc_std_external *) reloc; 2423 if (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE) 2424 { 2425 if (bfd_header_big_endian (input_bfd)) 2426 r_index = ((srel->r_index[0] << 16) 2427 | (srel->r_index[1] << 8) 2428 | srel->r_index[2]); 2429 else 2430 r_index = ((srel->r_index[2] << 16) 2431 | (srel->r_index[1] << 8) 2432 | srel->r_index[0]); 2433 } 2434 else 2435 { 2436 struct reloc_ext_external *erel; 2437 2438 erel = (struct reloc_ext_external *) reloc; 2439 if (bfd_header_big_endian (input_bfd)) 2440 r_index = ((erel->r_index[0] << 16) 2441 | (erel->r_index[1] << 8) 2442 | erel->r_index[2]); 2443 else 2444 r_index = ((erel->r_index[2] << 16) 2445 | (erel->r_index[1] << 8) 2446 | erel->r_index[0]); 2447 } 2448 2449 got_offsetp = adata (input_bfd).local_got_offsets + r_index; 2450 } 2451 2452 BFD_ASSERT (got_offsetp != NULL && *got_offsetp != 0); 2453 2454 sgot = bfd_get_section_by_name (dynobj, ".got"); 2455 2456 /* We set the least significant bit to indicate whether we have 2457 already initialized the GOT entry. */ 2458 if ((*got_offsetp & 1) == 0) 2459 { 2460 if (h == NULL 2461 || (! info->shared 2462 && ((h->flags & SUNOS_DEF_DYNAMIC) == 0 2463 || (h->flags & SUNOS_DEF_REGULAR) != 0))) 2464 PUT_WORD (dynobj, *relocationp, sgot->contents + *got_offsetp); 2465 else 2466 PUT_WORD (dynobj, 0, sgot->contents + *got_offsetp); 2467 2468 if (info->shared 2469 || (h != NULL 2470 && (h->flags & SUNOS_DEF_DYNAMIC) != 0 2471 && (h->flags & SUNOS_DEF_REGULAR) == 0)) 2472 { 2473 /* We need to create a GLOB_DAT or 32 reloc to tell the 2474 dynamic linker to fill in this entry in the table. */ 2475 2476 s = bfd_get_section_by_name (dynobj, ".dynrel"); 2477 BFD_ASSERT (s != NULL); 2478 BFD_ASSERT (s->reloc_count * obj_reloc_entry_size (dynobj) 2479 < s->size); 2480 2481 p = (s->contents 2482 + s->reloc_count * obj_reloc_entry_size (dynobj)); 2483 2484 if (h != NULL) 2485 indx = h->dynindx; 2486 else 2487 indx = 0; 2488 2489 if (obj_reloc_entry_size (dynobj) == RELOC_STD_SIZE) 2490 { 2491 struct reloc_std_external *srel; 2492 2493 srel = (struct reloc_std_external *) p; 2494 PUT_WORD (dynobj, 2495 (*got_offsetp 2496 + sgot->output_section->vma 2497 + sgot->output_offset), 2498 srel->r_address); 2499 if (bfd_header_big_endian (dynobj)) 2500 { 2501 srel->r_index[0] = (bfd_byte) (indx >> 16); 2502 srel->r_index[1] = (bfd_byte) (indx >> 8); 2503 srel->r_index[2] = (bfd_byte)indx; 2504 if (h == NULL) 2505 srel->r_type[0] = 2 << RELOC_STD_BITS_LENGTH_SH_BIG; 2506 else 2507 srel->r_type[0] = 2508 (RELOC_STD_BITS_EXTERN_BIG 2509 | RELOC_STD_BITS_BASEREL_BIG 2510 | RELOC_STD_BITS_RELATIVE_BIG 2511 | (2 << RELOC_STD_BITS_LENGTH_SH_BIG)); 2512 } 2513 else 2514 { 2515 srel->r_index[2] = (bfd_byte) (indx >> 16); 2516 srel->r_index[1] = (bfd_byte) (indx >> 8); 2517 srel->r_index[0] = (bfd_byte)indx; 2518 if (h == NULL) 2519 srel->r_type[0] = 2 << RELOC_STD_BITS_LENGTH_SH_LITTLE; 2520 else 2521 srel->r_type[0] = 2522 (RELOC_STD_BITS_EXTERN_LITTLE 2523 | RELOC_STD_BITS_BASEREL_LITTLE 2524 | RELOC_STD_BITS_RELATIVE_LITTLE 2525 | (2 << RELOC_STD_BITS_LENGTH_SH_LITTLE)); 2526 } 2527 } 2528 else 2529 { 2530 struct reloc_ext_external *erel; 2531 2532 erel = (struct reloc_ext_external *) p; 2533 PUT_WORD (dynobj, 2534 (*got_offsetp 2535 + sgot->output_section->vma 2536 + sgot->output_offset), 2537 erel->r_address); 2538 if (bfd_header_big_endian (dynobj)) 2539 { 2540 erel->r_index[0] = (bfd_byte) (indx >> 16); 2541 erel->r_index[1] = (bfd_byte) (indx >> 8); 2542 erel->r_index[2] = (bfd_byte)indx; 2543 if (h == NULL) 2544 erel->r_type[0] = 2545 RELOC_32 << RELOC_EXT_BITS_TYPE_SH_BIG; 2546 else 2547 erel->r_type[0] = 2548 (RELOC_EXT_BITS_EXTERN_BIG 2549 | (RELOC_GLOB_DAT << RELOC_EXT_BITS_TYPE_SH_BIG)); 2550 } 2551 else 2552 { 2553 erel->r_index[2] = (bfd_byte) (indx >> 16); 2554 erel->r_index[1] = (bfd_byte) (indx >> 8); 2555 erel->r_index[0] = (bfd_byte)indx; 2556 if (h == NULL) 2557 erel->r_type[0] = 2558 RELOC_32 << RELOC_EXT_BITS_TYPE_SH_LITTLE; 2559 else 2560 erel->r_type[0] = 2561 (RELOC_EXT_BITS_EXTERN_LITTLE 2562 | (RELOC_GLOB_DAT 2563 << RELOC_EXT_BITS_TYPE_SH_LITTLE)); 2564 } 2565 PUT_WORD (dynobj, 0, erel->r_addend); 2566 } 2567 2568 ++s->reloc_count; 2569 } 2570 2571 *got_offsetp |= 1; 2572 } 2573 2574 *relocationp = (sgot->vma 2575 + (*got_offsetp &~ (bfd_vma) 1) 2576 - sunos_hash_table (info)->got_base); 2577 2578 /* There is nothing else to do for a base relative reloc. */ 2579 return TRUE; 2580 } 2581 2582 if (! sunos_hash_table (info)->dynamic_sections_needed) 2583 return TRUE; 2584 if (! info->shared) 2585 { 2586 if (h == NULL 2587 || h->dynindx == -1 2588 || h->root.root.type != bfd_link_hash_undefined 2589 || (h->flags & SUNOS_DEF_REGULAR) != 0 2590 || (h->flags & SUNOS_DEF_DYNAMIC) == 0 2591 || (h->root.root.u.undef.abfd->flags & DYNAMIC) == 0) 2592 return TRUE; 2593 } 2594 else 2595 { 2596 if (h != NULL 2597 && (h->dynindx == -1 2598 || jmptbl 2599 || strcmp (h->root.root.root.string, 2600 "__GLOBAL_OFFSET_TABLE_") == 0)) 2601 return TRUE; 2602 } 2603 2604 /* It looks like this is a reloc we are supposed to copy. */ 2605 2606 s = bfd_get_section_by_name (dynobj, ".dynrel"); 2607 BFD_ASSERT (s != NULL); 2608 BFD_ASSERT (s->reloc_count * obj_reloc_entry_size (dynobj) < s->size); 2609 2610 p = s->contents + s->reloc_count * obj_reloc_entry_size (dynobj); 2611 2612 /* Copy the reloc over. */ 2613 memcpy (p, reloc, obj_reloc_entry_size (dynobj)); 2614 2615 if (h != NULL) 2616 indx = h->dynindx; 2617 else 2618 indx = 0; 2619 2620 /* Adjust the address and symbol index. */ 2621 if (obj_reloc_entry_size (dynobj) == RELOC_STD_SIZE) 2622 { 2623 struct reloc_std_external *srel; 2624 2625 srel = (struct reloc_std_external *) p; 2626 PUT_WORD (dynobj, 2627 (GET_WORD (dynobj, srel->r_address) 2628 + input_section->output_section->vma 2629 + input_section->output_offset), 2630 srel->r_address); 2631 if (bfd_header_big_endian (dynobj)) 2632 { 2633 srel->r_index[0] = (bfd_byte) (indx >> 16); 2634 srel->r_index[1] = (bfd_byte) (indx >> 8); 2635 srel->r_index[2] = (bfd_byte)indx; 2636 } 2637 else 2638 { 2639 srel->r_index[2] = (bfd_byte) (indx >> 16); 2640 srel->r_index[1] = (bfd_byte) (indx >> 8); 2641 srel->r_index[0] = (bfd_byte)indx; 2642 } 2643 /* FIXME: We may have to change the addend for a PC relative 2644 reloc. */ 2645 } 2646 else 2647 { 2648 struct reloc_ext_external *erel; 2649 2650 erel = (struct reloc_ext_external *) p; 2651 PUT_WORD (dynobj, 2652 (GET_WORD (dynobj, erel->r_address) 2653 + input_section->output_section->vma 2654 + input_section->output_offset), 2655 erel->r_address); 2656 if (bfd_header_big_endian (dynobj)) 2657 { 2658 erel->r_index[0] = (bfd_byte) (indx >> 16); 2659 erel->r_index[1] = (bfd_byte) (indx >> 8); 2660 erel->r_index[2] = (bfd_byte)indx; 2661 } 2662 else 2663 { 2664 erel->r_index[2] = (bfd_byte) (indx >> 16); 2665 erel->r_index[1] = (bfd_byte) (indx >> 8); 2666 erel->r_index[0] = (bfd_byte)indx; 2667 } 2668 if (pcrel && h != NULL) 2669 { 2670 /* Adjust the addend for the change in address. */ 2671 PUT_WORD (dynobj, 2672 (GET_WORD (dynobj, erel->r_addend) 2673 - (input_section->output_section->vma 2674 + input_section->output_offset 2675 - input_section->vma)), 2676 erel->r_addend); 2677 } 2678 } 2679 2680 ++s->reloc_count; 2681 2682 if (h != NULL) 2683 *skip = TRUE; 2684 2685 return TRUE; 2686} 2687 2688/* Finish up the dynamic linking information. */ 2689 2690static bfd_boolean 2691sunos_finish_dynamic_link (bfd *abfd, struct bfd_link_info *info) 2692{ 2693 bfd *dynobj; 2694 asection *o; 2695 asection *s; 2696 asection *sdyn; 2697 2698 if (! sunos_hash_table (info)->dynamic_sections_needed 2699 && ! sunos_hash_table (info)->got_needed) 2700 return TRUE; 2701 2702 dynobj = sunos_hash_table (info)->dynobj; 2703 2704 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 2705 BFD_ASSERT (sdyn != NULL); 2706 2707 /* Finish up the .need section. The linker emulation code filled it 2708 in, but with offsets from the start of the section instead of 2709 real addresses. Now that we know the section location, we can 2710 fill in the final values. */ 2711 s = bfd_get_section_by_name (dynobj, ".need"); 2712 if (s != NULL && s->size != 0) 2713 { 2714 file_ptr filepos; 2715 bfd_byte *p; 2716 2717 filepos = s->output_section->filepos + s->output_offset; 2718 p = s->contents; 2719 while (1) 2720 { 2721 bfd_vma val; 2722 2723 PUT_WORD (dynobj, GET_WORD (dynobj, p) + filepos, p); 2724 val = GET_WORD (dynobj, p + 12); 2725 if (val == 0) 2726 break; 2727 PUT_WORD (dynobj, val + filepos, p + 12); 2728 p += 16; 2729 } 2730 } 2731 2732 /* The first entry in the .got section is the address of the 2733 dynamic information, unless this is a shared library. */ 2734 s = bfd_get_section_by_name (dynobj, ".got"); 2735 BFD_ASSERT (s != NULL); 2736 if (info->shared || sdyn->size == 0) 2737 PUT_WORD (dynobj, 0, s->contents); 2738 else 2739 PUT_WORD (dynobj, sdyn->output_section->vma + sdyn->output_offset, 2740 s->contents); 2741 2742 for (o = dynobj->sections; o != NULL; o = o->next) 2743 { 2744 if ((o->flags & SEC_HAS_CONTENTS) != 0 2745 && o->contents != NULL) 2746 { 2747 BFD_ASSERT (o->output_section != NULL 2748 && o->output_section->owner == abfd); 2749 if (! bfd_set_section_contents (abfd, o->output_section, 2750 o->contents, 2751 (file_ptr) o->output_offset, 2752 o->size)) 2753 return FALSE; 2754 } 2755 } 2756 2757 if (sdyn->size > 0) 2758 { 2759 struct external_sun4_dynamic esd; 2760 struct external_sun4_dynamic_link esdl; 2761 file_ptr pos; 2762 2763 /* Finish up the dynamic link information. */ 2764 PUT_WORD (dynobj, (bfd_vma) 3, esd.ld_version); 2765 PUT_WORD (dynobj, 2766 sdyn->output_section->vma + sdyn->output_offset + sizeof esd, 2767 esd.ldd); 2768 PUT_WORD (dynobj, 2769 (sdyn->output_section->vma 2770 + sdyn->output_offset 2771 + sizeof esd 2772 + EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE), 2773 esd.ld); 2774 2775 if (! bfd_set_section_contents (abfd, sdyn->output_section, &esd, 2776 (file_ptr) sdyn->output_offset, 2777 (bfd_size_type) sizeof esd)) 2778 return FALSE; 2779 2780 PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_loaded); 2781 2782 s = bfd_get_section_by_name (dynobj, ".need"); 2783 if (s == NULL || s->size == 0) 2784 PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_need); 2785 else 2786 PUT_WORD (dynobj, s->output_section->filepos + s->output_offset, 2787 esdl.ld_need); 2788 2789 s = bfd_get_section_by_name (dynobj, ".rules"); 2790 if (s == NULL || s->size == 0) 2791 PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_rules); 2792 else 2793 PUT_WORD (dynobj, s->output_section->filepos + s->output_offset, 2794 esdl.ld_rules); 2795 2796 s = bfd_get_section_by_name (dynobj, ".got"); 2797 BFD_ASSERT (s != NULL); 2798 PUT_WORD (dynobj, s->output_section->vma + s->output_offset, 2799 esdl.ld_got); 2800 2801 s = bfd_get_section_by_name (dynobj, ".plt"); 2802 BFD_ASSERT (s != NULL); 2803 PUT_WORD (dynobj, s->output_section->vma + s->output_offset, 2804 esdl.ld_plt); 2805 PUT_WORD (dynobj, s->size, esdl.ld_plt_sz); 2806 2807 s = bfd_get_section_by_name (dynobj, ".dynrel"); 2808 BFD_ASSERT (s != NULL); 2809 BFD_ASSERT (s->reloc_count * obj_reloc_entry_size (dynobj) 2810 == s->size); 2811 PUT_WORD (dynobj, s->output_section->filepos + s->output_offset, 2812 esdl.ld_rel); 2813 2814 s = bfd_get_section_by_name (dynobj, ".hash"); 2815 BFD_ASSERT (s != NULL); 2816 PUT_WORD (dynobj, s->output_section->filepos + s->output_offset, 2817 esdl.ld_hash); 2818 2819 s = bfd_get_section_by_name (dynobj, ".dynsym"); 2820 BFD_ASSERT (s != NULL); 2821 PUT_WORD (dynobj, s->output_section->filepos + s->output_offset, 2822 esdl.ld_stab); 2823 2824 PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_stab_hash); 2825 2826 PUT_WORD (dynobj, (bfd_vma) sunos_hash_table (info)->bucketcount, 2827 esdl.ld_buckets); 2828 2829 s = bfd_get_section_by_name (dynobj, ".dynstr"); 2830 BFD_ASSERT (s != NULL); 2831 PUT_WORD (dynobj, s->output_section->filepos + s->output_offset, 2832 esdl.ld_symbols); 2833 PUT_WORD (dynobj, s->size, esdl.ld_symb_size); 2834 2835 /* The size of the text area is the size of the .text section 2836 rounded up to a page boundary. FIXME: Should the page size be 2837 conditional on something? */ 2838 PUT_WORD (dynobj, 2839 BFD_ALIGN (obj_textsec (abfd)->size, 0x2000), 2840 esdl.ld_text); 2841 2842 pos = sdyn->output_offset; 2843 pos += sizeof esd + EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE; 2844 if (! bfd_set_section_contents (abfd, sdyn->output_section, &esdl, 2845 pos, (bfd_size_type) sizeof esdl)) 2846 return FALSE; 2847 2848 abfd->flags |= DYNAMIC; 2849 } 2850 2851 return TRUE; 2852} 2853