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