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