1 /* ELF linking support for BFD. 2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 3 2005, 2006, 2007, 2008, 2009 4 Free Software Foundation, Inc. 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 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 21 MA 02110-1301, USA. */ 22 23 #include "sysdep.h" 24 #include "bfd.h" 25 #include "bfdlink.h" 26 #include "libbfd.h" 27 #define ARCH_SIZE 0 28 #include "elf-bfd.h" 29 #include "safe-ctype.h" 30 #include "libiberty.h" 31 #include "objalloc.h" 32 33 /* This struct is used to pass information to routines called via 34 elf_link_hash_traverse which must return failure. */ 35 36 struct elf_info_failed 37 { 38 struct bfd_link_info *info; 39 struct bfd_elf_version_tree *verdefs; 40 bfd_boolean failed; 41 }; 42 43 /* This structure is used to pass information to 44 _bfd_elf_link_find_version_dependencies. */ 45 46 struct elf_find_verdep_info 47 { 48 /* General link information. */ 49 struct bfd_link_info *info; 50 /* The number of dependencies. */ 51 unsigned int vers; 52 /* Whether we had a failure. */ 53 bfd_boolean failed; 54 }; 55 56 static bfd_boolean _bfd_elf_fix_symbol_flags 57 (struct elf_link_hash_entry *, struct elf_info_failed *); 58 59 /* Define a symbol in a dynamic linkage section. */ 60 61 struct elf_link_hash_entry * 62 _bfd_elf_define_linkage_sym (bfd *abfd, 63 struct bfd_link_info *info, 64 asection *sec, 65 const char *name) 66 { 67 struct elf_link_hash_entry *h; 68 struct bfd_link_hash_entry *bh; 69 const struct elf_backend_data *bed; 70 71 h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE); 72 if (h != NULL) 73 { 74 /* Zap symbol defined in an as-needed lib that wasn't linked. 75 This is a symptom of a larger problem: Absolute symbols 76 defined in shared libraries can't be overridden, because we 77 lose the link to the bfd which is via the symbol section. */ 78 h->root.type = bfd_link_hash_new; 79 } 80 81 bh = &h->root; 82 if (!_bfd_generic_link_add_one_symbol (info, abfd, name, BSF_GLOBAL, 83 sec, 0, NULL, FALSE, 84 get_elf_backend_data (abfd)->collect, 85 &bh)) 86 return NULL; 87 h = (struct elf_link_hash_entry *) bh; 88 h->def_regular = 1; 89 h->type = STT_OBJECT; 90 h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN; 91 92 bed = get_elf_backend_data (abfd); 93 (*bed->elf_backend_hide_symbol) (info, h, TRUE); 94 return h; 95 } 96 97 bfd_boolean 98 _bfd_elf_create_got_section (bfd *abfd, struct bfd_link_info *info) 99 { 100 flagword flags; 101 asection *s; 102 struct elf_link_hash_entry *h; 103 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 104 struct elf_link_hash_table *htab = elf_hash_table (info); 105 106 /* This function may be called more than once. */ 107 s = bfd_get_section_by_name (abfd, ".got"); 108 if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0) 109 return TRUE; 110 111 flags = bed->dynamic_sec_flags; 112 113 s = bfd_make_section_with_flags (abfd, 114 (bed->rela_plts_and_copies_p 115 ? ".rela.got" : ".rel.got"), 116 (bed->dynamic_sec_flags 117 | SEC_READONLY)); 118 if (s == NULL 119 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align)) 120 return FALSE; 121 htab->srelgot = s; 122 123 s = bfd_make_section_with_flags (abfd, ".got", flags); 124 if (s == NULL 125 || !bfd_set_section_alignment (abfd, s, bed->s->log_file_align)) 126 return FALSE; 127 htab->sgot = s; 128 129 if (bed->want_got_plt) 130 { 131 s = bfd_make_section_with_flags (abfd, ".got.plt", flags); 132 if (s == NULL 133 || !bfd_set_section_alignment (abfd, s, 134 bed->s->log_file_align)) 135 return FALSE; 136 htab->sgotplt = s; 137 } 138 139 /* The first bit of the global offset table is the header. */ 140 s->size += bed->got_header_size; 141 142 if (bed->want_got_sym) 143 { 144 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got 145 (or .got.plt) section. We don't do this in the linker script 146 because we don't want to define the symbol if we are not creating 147 a global offset table. */ 148 h = _bfd_elf_define_linkage_sym (abfd, info, s, 149 "_GLOBAL_OFFSET_TABLE_"); 150 elf_hash_table (info)->hgot = h; 151 if (h == NULL) 152 return FALSE; 153 } 154 155 return TRUE; 156 } 157 158 /* Create a strtab to hold the dynamic symbol names. */ 159 static bfd_boolean 160 _bfd_elf_link_create_dynstrtab (bfd *abfd, struct bfd_link_info *info) 161 { 162 struct elf_link_hash_table *hash_table; 163 164 hash_table = elf_hash_table (info); 165 if (hash_table->dynobj == NULL) 166 hash_table->dynobj = abfd; 167 168 if (hash_table->dynstr == NULL) 169 { 170 hash_table->dynstr = _bfd_elf_strtab_init (); 171 if (hash_table->dynstr == NULL) 172 return FALSE; 173 } 174 return TRUE; 175 } 176 177 /* Create some sections which will be filled in with dynamic linking 178 information. ABFD is an input file which requires dynamic sections 179 to be created. The dynamic sections take up virtual memory space 180 when the final executable is run, so we need to create them before 181 addresses are assigned to the output sections. We work out the 182 actual contents and size of these sections later. */ 183 184 bfd_boolean 185 _bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) 186 { 187 flagword flags; 188 register asection *s; 189 const struct elf_backend_data *bed; 190 191 if (! is_elf_hash_table (info->hash)) 192 return FALSE; 193 194 if (elf_hash_table (info)->dynamic_sections_created) 195 return TRUE; 196 197 if (!_bfd_elf_link_create_dynstrtab (abfd, info)) 198 return FALSE; 199 200 abfd = elf_hash_table (info)->dynobj; 201 bed = get_elf_backend_data (abfd); 202 203 flags = bed->dynamic_sec_flags; 204 205 /* A dynamically linked executable has a .interp section, but a 206 shared library does not. */ 207 if (info->executable) 208 { 209 s = bfd_make_section_with_flags (abfd, ".interp", 210 flags | SEC_READONLY); 211 if (s == NULL) 212 return FALSE; 213 } 214 215 /* Create sections to hold version informations. These are removed 216 if they are not needed. */ 217 s = bfd_make_section_with_flags (abfd, ".gnu.version_d", 218 flags | SEC_READONLY); 219 if (s == NULL 220 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align)) 221 return FALSE; 222 223 s = bfd_make_section_with_flags (abfd, ".gnu.version", 224 flags | SEC_READONLY); 225 if (s == NULL 226 || ! bfd_set_section_alignment (abfd, s, 1)) 227 return FALSE; 228 229 s = bfd_make_section_with_flags (abfd, ".gnu.version_r", 230 flags | SEC_READONLY); 231 if (s == NULL 232 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align)) 233 return FALSE; 234 235 s = bfd_make_section_with_flags (abfd, ".dynsym", 236 flags | SEC_READONLY); 237 if (s == NULL 238 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align)) 239 return FALSE; 240 241 s = bfd_make_section_with_flags (abfd, ".dynstr", 242 flags | SEC_READONLY); 243 if (s == NULL) 244 return FALSE; 245 246 s = bfd_make_section_with_flags (abfd, ".dynamic", flags); 247 if (s == NULL 248 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align)) 249 return FALSE; 250 251 /* The special symbol _DYNAMIC is always set to the start of the 252 .dynamic section. We could set _DYNAMIC in a linker script, but we 253 only want to define it if we are, in fact, creating a .dynamic 254 section. We don't want to define it if there is no .dynamic 255 section, since on some ELF platforms the start up code examines it 256 to decide how to initialize the process. */ 257 if (!_bfd_elf_define_linkage_sym (abfd, info, s, "_DYNAMIC")) 258 return FALSE; 259 260 if (info->emit_hash) 261 { 262 s = bfd_make_section_with_flags (abfd, ".hash", flags | SEC_READONLY); 263 if (s == NULL 264 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align)) 265 return FALSE; 266 elf_section_data (s)->this_hdr.sh_entsize = bed->s->sizeof_hash_entry; 267 } 268 269 if (info->emit_gnu_hash) 270 { 271 s = bfd_make_section_with_flags (abfd, ".gnu.hash", 272 flags | SEC_READONLY); 273 if (s == NULL 274 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align)) 275 return FALSE; 276 /* For 64-bit ELF, .gnu.hash is a non-uniform entity size section: 277 4 32-bit words followed by variable count of 64-bit words, then 278 variable count of 32-bit words. */ 279 if (bed->s->arch_size == 64) 280 elf_section_data (s)->this_hdr.sh_entsize = 0; 281 else 282 elf_section_data (s)->this_hdr.sh_entsize = 4; 283 } 284 285 /* Let the backend create the rest of the sections. This lets the 286 backend set the right flags. The backend will normally create 287 the .got and .plt sections. */ 288 if (! (*bed->elf_backend_create_dynamic_sections) (abfd, info)) 289 return FALSE; 290 291 elf_hash_table (info)->dynamic_sections_created = TRUE; 292 293 return TRUE; 294 } 295 296 /* Create dynamic sections when linking against a dynamic object. */ 297 298 bfd_boolean 299 _bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) 300 { 301 flagword flags, pltflags; 302 struct elf_link_hash_entry *h; 303 asection *s; 304 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 305 struct elf_link_hash_table *htab = elf_hash_table (info); 306 307 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and 308 .rel[a].bss sections. */ 309 flags = bed->dynamic_sec_flags; 310 311 pltflags = flags; 312 if (bed->plt_not_loaded) 313 /* We do not clear SEC_ALLOC here because we still want the OS to 314 allocate space for the section; it's just that there's nothing 315 to read in from the object file. */ 316 pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS); 317 else 318 pltflags |= SEC_ALLOC | SEC_CODE | SEC_LOAD; 319 if (bed->plt_readonly) 320 pltflags |= SEC_READONLY; 321 322 s = bfd_make_section_with_flags (abfd, ".plt", pltflags); 323 if (s == NULL 324 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment)) 325 return FALSE; 326 htab->splt = s; 327 328 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the 329 .plt section. */ 330 if (bed->want_plt_sym) 331 { 332 h = _bfd_elf_define_linkage_sym (abfd, info, s, 333 "_PROCEDURE_LINKAGE_TABLE_"); 334 elf_hash_table (info)->hplt = h; 335 if (h == NULL) 336 return FALSE; 337 } 338 339 s = bfd_make_section_with_flags (abfd, 340 (bed->rela_plts_and_copies_p 341 ? ".rela.plt" : ".rel.plt"), 342 flags | SEC_READONLY); 343 if (s == NULL 344 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align)) 345 return FALSE; 346 htab->srelplt = s; 347 348 if (! _bfd_elf_create_got_section (abfd, info)) 349 return FALSE; 350 351 if (bed->want_dynbss) 352 { 353 /* The .dynbss section is a place to put symbols which are defined 354 by dynamic objects, are referenced by regular objects, and are 355 not functions. We must allocate space for them in the process 356 image and use a R_*_COPY reloc to tell the dynamic linker to 357 initialize them at run time. The linker script puts the .dynbss 358 section into the .bss section of the final image. */ 359 s = bfd_make_section_with_flags (abfd, ".dynbss", 360 (SEC_ALLOC 361 | SEC_LINKER_CREATED)); 362 if (s == NULL) 363 return FALSE; 364 365 /* The .rel[a].bss section holds copy relocs. This section is not 366 normally needed. We need to create it here, though, so that the 367 linker will map it to an output section. We can't just create it 368 only if we need it, because we will not know whether we need it 369 until we have seen all the input files, and the first time the 370 main linker code calls BFD after examining all the input files 371 (size_dynamic_sections) the input sections have already been 372 mapped to the output sections. If the section turns out not to 373 be needed, we can discard it later. We will never need this 374 section when generating a shared object, since they do not use 375 copy relocs. */ 376 if (! info->shared) 377 { 378 s = bfd_make_section_with_flags (abfd, 379 (bed->rela_plts_and_copies_p 380 ? ".rela.bss" : ".rel.bss"), 381 flags | SEC_READONLY); 382 if (s == NULL 383 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align)) 384 return FALSE; 385 } 386 } 387 388 return TRUE; 389 } 390 391 /* Record a new dynamic symbol. We record the dynamic symbols as we 392 read the input files, since we need to have a list of all of them 393 before we can determine the final sizes of the output sections. 394 Note that we may actually call this function even though we are not 395 going to output any dynamic symbols; in some cases we know that a 396 symbol should be in the dynamic symbol table, but only if there is 397 one. */ 398 399 bfd_boolean 400 bfd_elf_link_record_dynamic_symbol (struct bfd_link_info *info, 401 struct elf_link_hash_entry *h) 402 { 403 if (h->dynindx == -1) 404 { 405 struct elf_strtab_hash *dynstr; 406 char *p; 407 const char *name; 408 bfd_size_type indx; 409 410 /* XXX: The ABI draft says the linker must turn hidden and 411 internal symbols into STB_LOCAL symbols when producing the 412 DSO. However, if ld.so honors st_other in the dynamic table, 413 this would not be necessary. */ 414 switch (ELF_ST_VISIBILITY (h->other)) 415 { 416 case STV_INTERNAL: 417 case STV_HIDDEN: 418 if (h->root.type != bfd_link_hash_undefined 419 && h->root.type != bfd_link_hash_undefweak) 420 { 421 h->forced_local = 1; 422 if (!elf_hash_table (info)->is_relocatable_executable) 423 return TRUE; 424 } 425 426 default: 427 break; 428 } 429 430 h->dynindx = elf_hash_table (info)->dynsymcount; 431 ++elf_hash_table (info)->dynsymcount; 432 433 dynstr = elf_hash_table (info)->dynstr; 434 if (dynstr == NULL) 435 { 436 /* Create a strtab to hold the dynamic symbol names. */ 437 elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init (); 438 if (dynstr == NULL) 439 return FALSE; 440 } 441 442 /* We don't put any version information in the dynamic string 443 table. */ 444 name = h->root.root.string; 445 p = strchr (name, ELF_VER_CHR); 446 if (p != NULL) 447 /* We know that the p points into writable memory. In fact, 448 there are only a few symbols that have read-only names, being 449 those like _GLOBAL_OFFSET_TABLE_ that are created specially 450 by the backends. Most symbols will have names pointing into 451 an ELF string table read from a file, or to objalloc memory. */ 452 *p = 0; 453 454 indx = _bfd_elf_strtab_add (dynstr, name, p != NULL); 455 456 if (p != NULL) 457 *p = ELF_VER_CHR; 458 459 if (indx == (bfd_size_type) -1) 460 return FALSE; 461 h->dynstr_index = indx; 462 } 463 464 return TRUE; 465 } 466 467 /* Mark a symbol dynamic. */ 468 469 static void 470 bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info *info, 471 struct elf_link_hash_entry *h, 472 Elf_Internal_Sym *sym) 473 { 474 struct bfd_elf_dynamic_list *d = info->dynamic_list; 475 476 /* It may be called more than once on the same H. */ 477 if(h->dynamic || info->relocatable) 478 return; 479 480 if ((info->dynamic_data 481 && (h->type == STT_OBJECT 482 || (sym != NULL 483 && ELF_ST_TYPE (sym->st_info) == STT_OBJECT))) 484 || (d != NULL 485 && h->root.type == bfd_link_hash_new 486 && (*d->match) (&d->head, NULL, h->root.root.string))) 487 h->dynamic = 1; 488 } 489 490 /* Record an assignment to a symbol made by a linker script. We need 491 this in case some dynamic object refers to this symbol. */ 492 493 bfd_boolean 494 bfd_elf_record_link_assignment (bfd *output_bfd, 495 struct bfd_link_info *info, 496 const char *name, 497 bfd_boolean provide, 498 bfd_boolean hidden) 499 { 500 struct elf_link_hash_entry *h, *hv; 501 struct elf_link_hash_table *htab; 502 const struct elf_backend_data *bed; 503 504 if (!is_elf_hash_table (info->hash)) 505 return TRUE; 506 507 htab = elf_hash_table (info); 508 h = elf_link_hash_lookup (htab, name, !provide, TRUE, FALSE); 509 if (h == NULL) 510 return provide; 511 512 switch (h->root.type) 513 { 514 case bfd_link_hash_defined: 515 case bfd_link_hash_defweak: 516 case bfd_link_hash_common: 517 break; 518 case bfd_link_hash_undefweak: 519 case bfd_link_hash_undefined: 520 /* Since we're defining the symbol, don't let it seem to have not 521 been defined. record_dynamic_symbol and size_dynamic_sections 522 may depend on this. */ 523 h->root.type = bfd_link_hash_new; 524 if (h->root.u.undef.next != NULL || htab->root.undefs_tail == &h->root) 525 bfd_link_repair_undef_list (&htab->root); 526 break; 527 case bfd_link_hash_new: 528 bfd_elf_link_mark_dynamic_symbol (info, h, NULL); 529 h->non_elf = 0; 530 break; 531 case bfd_link_hash_indirect: 532 /* We had a versioned symbol in a dynamic library. We make the 533 the versioned symbol point to this one. */ 534 bed = get_elf_backend_data (output_bfd); 535 hv = h; 536 while (hv->root.type == bfd_link_hash_indirect 537 || hv->root.type == bfd_link_hash_warning) 538 hv = (struct elf_link_hash_entry *) hv->root.u.i.link; 539 /* We don't need to update h->root.u since linker will set them 540 later. */ 541 h->root.type = bfd_link_hash_undefined; 542 hv->root.type = bfd_link_hash_indirect; 543 hv->root.u.i.link = (struct bfd_link_hash_entry *) h; 544 (*bed->elf_backend_copy_indirect_symbol) (info, h, hv); 545 break; 546 case bfd_link_hash_warning: 547 abort (); 548 break; 549 } 550 551 /* If this symbol is being provided by the linker script, and it is 552 currently defined by a dynamic object, but not by a regular 553 object, then mark it as undefined so that the generic linker will 554 force the correct value. */ 555 if (provide 556 && h->def_dynamic 557 && !h->def_regular) 558 h->root.type = bfd_link_hash_undefined; 559 560 /* If this symbol is not being provided by the linker script, and it is 561 currently defined by a dynamic object, but not by a regular object, 562 then clear out any version information because the symbol will not be 563 associated with the dynamic object any more. */ 564 if (!provide 565 && h->def_dynamic 566 && !h->def_regular) 567 h->verinfo.verdef = NULL; 568 569 h->def_regular = 1; 570 571 if (provide && hidden) 572 { 573 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd); 574 575 h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN; 576 (*bed->elf_backend_hide_symbol) (info, h, TRUE); 577 } 578 579 /* STV_HIDDEN and STV_INTERNAL symbols must be STB_LOCAL in shared objects 580 and executables. */ 581 if (!info->relocatable 582 && h->dynindx != -1 583 && (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN 584 || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)) 585 h->forced_local = 1; 586 587 if ((h->def_dynamic 588 || h->ref_dynamic 589 || info->shared 590 || (info->executable && elf_hash_table (info)->is_relocatable_executable)) 591 && h->dynindx == -1) 592 { 593 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 594 return FALSE; 595 596 /* If this is a weak defined symbol, and we know a corresponding 597 real symbol from the same dynamic object, make sure the real 598 symbol is also made into a dynamic symbol. */ 599 if (h->u.weakdef != NULL 600 && h->u.weakdef->dynindx == -1) 601 { 602 if (! bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef)) 603 return FALSE; 604 } 605 } 606 607 return TRUE; 608 } 609 610 /* Record a new local dynamic symbol. Returns 0 on failure, 1 on 611 success, and 2 on a failure caused by attempting to record a symbol 612 in a discarded section, eg. a discarded link-once section symbol. */ 613 614 int 615 bfd_elf_link_record_local_dynamic_symbol (struct bfd_link_info *info, 616 bfd *input_bfd, 617 long input_indx) 618 { 619 bfd_size_type amt; 620 struct elf_link_local_dynamic_entry *entry; 621 struct elf_link_hash_table *eht; 622 struct elf_strtab_hash *dynstr; 623 unsigned long dynstr_index; 624 char *name; 625 Elf_External_Sym_Shndx eshndx; 626 char esym[sizeof (Elf64_External_Sym)]; 627 628 if (! is_elf_hash_table (info->hash)) 629 return 0; 630 631 /* See if the entry exists already. */ 632 for (entry = elf_hash_table (info)->dynlocal; entry ; entry = entry->next) 633 if (entry->input_bfd == input_bfd && entry->input_indx == input_indx) 634 return 1; 635 636 amt = sizeof (*entry); 637 entry = (struct elf_link_local_dynamic_entry *) bfd_alloc (input_bfd, amt); 638 if (entry == NULL) 639 return 0; 640 641 /* Go find the symbol, so that we can find it's name. */ 642 if (!bfd_elf_get_elf_syms (input_bfd, &elf_tdata (input_bfd)->symtab_hdr, 643 1, input_indx, &entry->isym, esym, &eshndx)) 644 { 645 bfd_release (input_bfd, entry); 646 return 0; 647 } 648 649 if (entry->isym.st_shndx != SHN_UNDEF 650 && entry->isym.st_shndx < SHN_LORESERVE) 651 { 652 asection *s; 653 654 s = bfd_section_from_elf_index (input_bfd, entry->isym.st_shndx); 655 if (s == NULL || bfd_is_abs_section (s->output_section)) 656 { 657 /* We can still bfd_release here as nothing has done another 658 bfd_alloc. We can't do this later in this function. */ 659 bfd_release (input_bfd, entry); 660 return 2; 661 } 662 } 663 664 name = (bfd_elf_string_from_elf_section 665 (input_bfd, elf_tdata (input_bfd)->symtab_hdr.sh_link, 666 entry->isym.st_name)); 667 668 dynstr = elf_hash_table (info)->dynstr; 669 if (dynstr == NULL) 670 { 671 /* Create a strtab to hold the dynamic symbol names. */ 672 elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init (); 673 if (dynstr == NULL) 674 return 0; 675 } 676 677 dynstr_index = _bfd_elf_strtab_add (dynstr, name, FALSE); 678 if (dynstr_index == (unsigned long) -1) 679 return 0; 680 entry->isym.st_name = dynstr_index; 681 682 eht = elf_hash_table (info); 683 684 entry->next = eht->dynlocal; 685 eht->dynlocal = entry; 686 entry->input_bfd = input_bfd; 687 entry->input_indx = input_indx; 688 eht->dynsymcount++; 689 690 /* Whatever binding the symbol had before, it's now local. */ 691 entry->isym.st_info 692 = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (entry->isym.st_info)); 693 694 /* The dynindx will be set at the end of size_dynamic_sections. */ 695 696 return 1; 697 } 698 699 /* Return the dynindex of a local dynamic symbol. */ 700 701 long 702 _bfd_elf_link_lookup_local_dynindx (struct bfd_link_info *info, 703 bfd *input_bfd, 704 long input_indx) 705 { 706 struct elf_link_local_dynamic_entry *e; 707 708 for (e = elf_hash_table (info)->dynlocal; e ; e = e->next) 709 if (e->input_bfd == input_bfd && e->input_indx == input_indx) 710 return e->dynindx; 711 return -1; 712 } 713 714 /* This function is used to renumber the dynamic symbols, if some of 715 them are removed because they are marked as local. This is called 716 via elf_link_hash_traverse. */ 717 718 static bfd_boolean 719 elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry *h, 720 void *data) 721 { 722 size_t *count = (size_t *) data; 723 724 if (h->root.type == bfd_link_hash_warning) 725 h = (struct elf_link_hash_entry *) h->root.u.i.link; 726 727 if (h->forced_local) 728 return TRUE; 729 730 if (h->dynindx != -1) 731 h->dynindx = ++(*count); 732 733 return TRUE; 734 } 735 736 737 /* Like elf_link_renumber_hash_table_dynsyms, but just number symbols with 738 STB_LOCAL binding. */ 739 740 static bfd_boolean 741 elf_link_renumber_local_hash_table_dynsyms (struct elf_link_hash_entry *h, 742 void *data) 743 { 744 size_t *count = (size_t *) data; 745 746 if (h->root.type == bfd_link_hash_warning) 747 h = (struct elf_link_hash_entry *) h->root.u.i.link; 748 749 if (!h->forced_local) 750 return TRUE; 751 752 if (h->dynindx != -1) 753 h->dynindx = ++(*count); 754 755 return TRUE; 756 } 757 758 /* Return true if the dynamic symbol for a given section should be 759 omitted when creating a shared library. */ 760 bfd_boolean 761 _bfd_elf_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED, 762 struct bfd_link_info *info, 763 asection *p) 764 { 765 struct elf_link_hash_table *htab; 766 767 switch (elf_section_data (p)->this_hdr.sh_type) 768 { 769 case SHT_PROGBITS: 770 case SHT_NOBITS: 771 /* If sh_type is yet undecided, assume it could be 772 SHT_PROGBITS/SHT_NOBITS. */ 773 case SHT_NULL: 774 htab = elf_hash_table (info); 775 if (p == htab->tls_sec) 776 return FALSE; 777 778 if (htab->text_index_section != NULL) 779 return p != htab->text_index_section && p != htab->data_index_section; 780 781 if (strcmp (p->name, ".got") == 0 782 || strcmp (p->name, ".got.plt") == 0 783 || strcmp (p->name, ".plt") == 0) 784 { 785 asection *ip; 786 787 if (htab->dynobj != NULL 788 && (ip = bfd_get_section_by_name (htab->dynobj, p->name)) != NULL 789 && (ip->flags & SEC_LINKER_CREATED) 790 && ip->output_section == p) 791 return TRUE; 792 } 793 return FALSE; 794 795 /* There shouldn't be section relative relocations 796 against any other section. */ 797 default: 798 return TRUE; 799 } 800 } 801 802 /* Assign dynsym indices. In a shared library we generate a section 803 symbol for each output section, which come first. Next come symbols 804 which have been forced to local binding. Then all of the back-end 805 allocated local dynamic syms, followed by the rest of the global 806 symbols. */ 807 808 static unsigned long 809 _bfd_elf_link_renumber_dynsyms (bfd *output_bfd, 810 struct bfd_link_info *info, 811 unsigned long *section_sym_count) 812 { 813 unsigned long dynsymcount = 0; 814 815 if (info->shared || elf_hash_table (info)->is_relocatable_executable) 816 { 817 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd); 818 asection *p; 819 for (p = output_bfd->sections; p ; p = p->next) 820 if ((p->flags & SEC_EXCLUDE) == 0 821 && (p->flags & SEC_ALLOC) != 0 822 && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p)) 823 elf_section_data (p)->dynindx = ++dynsymcount; 824 else 825 elf_section_data (p)->dynindx = 0; 826 } 827 *section_sym_count = dynsymcount; 828 829 elf_link_hash_traverse (elf_hash_table (info), 830 elf_link_renumber_local_hash_table_dynsyms, 831 &dynsymcount); 832 833 if (elf_hash_table (info)->dynlocal) 834 { 835 struct elf_link_local_dynamic_entry *p; 836 for (p = elf_hash_table (info)->dynlocal; p ; p = p->next) 837 p->dynindx = ++dynsymcount; 838 } 839 840 elf_link_hash_traverse (elf_hash_table (info), 841 elf_link_renumber_hash_table_dynsyms, 842 &dynsymcount); 843 844 /* There is an unused NULL entry at the head of the table which 845 we must account for in our count. Unless there weren't any 846 symbols, which means we'll have no table at all. */ 847 if (dynsymcount != 0) 848 ++dynsymcount; 849 850 elf_hash_table (info)->dynsymcount = dynsymcount; 851 return dynsymcount; 852 } 853 854 /* Merge st_other field. */ 855 856 static void 857 elf_merge_st_other (bfd *abfd, struct elf_link_hash_entry *h, 858 Elf_Internal_Sym *isym, bfd_boolean definition, 859 bfd_boolean dynamic) 860 { 861 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 862 863 /* If st_other has a processor-specific meaning, specific 864 code might be needed here. We never merge the visibility 865 attribute with the one from a dynamic object. */ 866 if (bed->elf_backend_merge_symbol_attribute) 867 (*bed->elf_backend_merge_symbol_attribute) (h, isym, definition, 868 dynamic); 869 870 /* If this symbol has default visibility and the user has requested 871 we not re-export it, then mark it as hidden. */ 872 if (definition 873 && !dynamic 874 && (abfd->no_export 875 || (abfd->my_archive && abfd->my_archive->no_export)) 876 && ELF_ST_VISIBILITY (isym->st_other) != STV_INTERNAL) 877 isym->st_other = (STV_HIDDEN 878 | (isym->st_other & ~ELF_ST_VISIBILITY (-1))); 879 880 if (!dynamic && ELF_ST_VISIBILITY (isym->st_other) != 0) 881 { 882 unsigned char hvis, symvis, other, nvis; 883 884 /* Only merge the visibility. Leave the remainder of the 885 st_other field to elf_backend_merge_symbol_attribute. */ 886 other = h->other & ~ELF_ST_VISIBILITY (-1); 887 888 /* Combine visibilities, using the most constraining one. */ 889 hvis = ELF_ST_VISIBILITY (h->other); 890 symvis = ELF_ST_VISIBILITY (isym->st_other); 891 if (! hvis) 892 nvis = symvis; 893 else if (! symvis) 894 nvis = hvis; 895 else 896 nvis = hvis < symvis ? hvis : symvis; 897 898 h->other = other | nvis; 899 } 900 } 901 902 /* This function is called when we want to define a new symbol. It 903 handles the various cases which arise when we find a definition in 904 a dynamic object, or when there is already a definition in a 905 dynamic object. The new symbol is described by NAME, SYM, PSEC, 906 and PVALUE. We set SYM_HASH to the hash table entry. We set 907 OVERRIDE if the old symbol is overriding a new definition. We set 908 TYPE_CHANGE_OK if it is OK for the type to change. We set 909 SIZE_CHANGE_OK if it is OK for the size to change. By OK to 910 change, we mean that we shouldn't warn if the type or size does 911 change. We set POLD_ALIGNMENT if an old common symbol in a dynamic 912 object is overridden by a regular object. */ 913 914 bfd_boolean 915 _bfd_elf_merge_symbol (bfd *abfd, 916 struct bfd_link_info *info, 917 const char *name, 918 Elf_Internal_Sym *sym, 919 asection **psec, 920 bfd_vma *pvalue, 921 unsigned int *pold_alignment, 922 struct elf_link_hash_entry **sym_hash, 923 bfd_boolean *skip, 924 bfd_boolean *override, 925 bfd_boolean *type_change_ok, 926 bfd_boolean *size_change_ok) 927 { 928 asection *sec, *oldsec; 929 struct elf_link_hash_entry *h; 930 struct elf_link_hash_entry *flip; 931 int bind; 932 bfd *oldbfd; 933 bfd_boolean newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon; 934 bfd_boolean newweak, oldweak, newfunc, oldfunc; 935 const struct elf_backend_data *bed; 936 937 *skip = FALSE; 938 *override = FALSE; 939 940 sec = *psec; 941 bind = ELF_ST_BIND (sym->st_info); 942 943 /* Silently discard TLS symbols from --just-syms. There's no way to 944 combine a static TLS block with a new TLS block for this executable. */ 945 if (ELF_ST_TYPE (sym->st_info) == STT_TLS 946 && sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS) 947 { 948 *skip = TRUE; 949 return TRUE; 950 } 951 952 if (! bfd_is_und_section (sec)) 953 h = elf_link_hash_lookup (elf_hash_table (info), name, TRUE, FALSE, FALSE); 954 else 955 h = ((struct elf_link_hash_entry *) 956 bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, FALSE, FALSE)); 957 if (h == NULL) 958 return FALSE; 959 *sym_hash = h; 960 961 bed = get_elf_backend_data (abfd); 962 963 /* This code is for coping with dynamic objects, and is only useful 964 if we are doing an ELF link. */ 965 if (!(*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec)) 966 return TRUE; 967 968 /* For merging, we only care about real symbols. */ 969 970 while (h->root.type == bfd_link_hash_indirect 971 || h->root.type == bfd_link_hash_warning) 972 h = (struct elf_link_hash_entry *) h->root.u.i.link; 973 974 /* We have to check it for every instance since the first few may be 975 refereences and not all compilers emit symbol type for undefined 976 symbols. */ 977 bfd_elf_link_mark_dynamic_symbol (info, h, sym); 978 979 /* If we just created the symbol, mark it as being an ELF symbol. 980 Other than that, there is nothing to do--there is no merge issue 981 with a newly defined symbol--so we just return. */ 982 983 if (h->root.type == bfd_link_hash_new) 984 { 985 h->non_elf = 0; 986 return TRUE; 987 } 988 989 /* OLDBFD and OLDSEC are a BFD and an ASECTION associated with the 990 existing symbol. */ 991 992 switch (h->root.type) 993 { 994 default: 995 oldbfd = NULL; 996 oldsec = NULL; 997 break; 998 999 case bfd_link_hash_undefined: 1000 case bfd_link_hash_undefweak: 1001 oldbfd = h->root.u.undef.abfd; 1002 oldsec = NULL; 1003 break; 1004 1005 case bfd_link_hash_defined: 1006 case bfd_link_hash_defweak: 1007 oldbfd = h->root.u.def.section->owner; 1008 oldsec = h->root.u.def.section; 1009 break; 1010 1011 case bfd_link_hash_common: 1012 oldbfd = h->root.u.c.p->section->owner; 1013 oldsec = h->root.u.c.p->section; 1014 break; 1015 } 1016 1017 /* In cases involving weak versioned symbols, we may wind up trying 1018 to merge a symbol with itself. Catch that here, to avoid the 1019 confusion that results if we try to override a symbol with 1020 itself. The additional tests catch cases like 1021 _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a 1022 dynamic object, which we do want to handle here. */ 1023 if (abfd == oldbfd 1024 && ((abfd->flags & DYNAMIC) == 0 1025 || !h->def_regular)) 1026 return TRUE; 1027 1028 /* NEWDYN and OLDDYN indicate whether the new or old symbol, 1029 respectively, is from a dynamic object. */ 1030 1031 newdyn = (abfd->flags & DYNAMIC) != 0; 1032 1033 olddyn = FALSE; 1034 if (oldbfd != NULL) 1035 olddyn = (oldbfd->flags & DYNAMIC) != 0; 1036 else if (oldsec != NULL) 1037 { 1038 /* This handles the special SHN_MIPS_{TEXT,DATA} section 1039 indices used by MIPS ELF. */ 1040 olddyn = (oldsec->symbol->flags & BSF_DYNAMIC) != 0; 1041 } 1042 1043 /* NEWDEF and OLDDEF indicate whether the new or old symbol, 1044 respectively, appear to be a definition rather than reference. */ 1045 1046 newdef = !bfd_is_und_section (sec) && !bfd_is_com_section (sec); 1047 1048 olddef = (h->root.type != bfd_link_hash_undefined 1049 && h->root.type != bfd_link_hash_undefweak 1050 && h->root.type != bfd_link_hash_common); 1051 1052 /* NEWFUNC and OLDFUNC indicate whether the new or old symbol, 1053 respectively, appear to be a function. */ 1054 1055 newfunc = (ELF_ST_TYPE (sym->st_info) != STT_NOTYPE 1056 && bed->is_function_type (ELF_ST_TYPE (sym->st_info))); 1057 1058 oldfunc = (h->type != STT_NOTYPE 1059 && bed->is_function_type (h->type)); 1060 1061 /* When we try to create a default indirect symbol from the dynamic 1062 definition with the default version, we skip it if its type and 1063 the type of existing regular definition mismatch. We only do it 1064 if the existing regular definition won't be dynamic. */ 1065 if (pold_alignment == NULL 1066 && !info->shared 1067 && !info->export_dynamic 1068 && !h->ref_dynamic 1069 && newdyn 1070 && newdef 1071 && !olddyn 1072 && (olddef || h->root.type == bfd_link_hash_common) 1073 && ELF_ST_TYPE (sym->st_info) != h->type 1074 && ELF_ST_TYPE (sym->st_info) != STT_NOTYPE 1075 && h->type != STT_NOTYPE 1076 && !(newfunc && oldfunc)) 1077 { 1078 *skip = TRUE; 1079 return TRUE; 1080 } 1081 1082 /* Check TLS symbol. We don't check undefined symbol introduced by 1083 "ld -u". */ 1084 if ((ELF_ST_TYPE (sym->st_info) == STT_TLS || h->type == STT_TLS) 1085 && ELF_ST_TYPE (sym->st_info) != h->type 1086 && oldbfd != NULL) 1087 { 1088 bfd *ntbfd, *tbfd; 1089 bfd_boolean ntdef, tdef; 1090 asection *ntsec, *tsec; 1091 1092 if (h->type == STT_TLS) 1093 { 1094 ntbfd = abfd; 1095 ntsec = sec; 1096 ntdef = newdef; 1097 tbfd = oldbfd; 1098 tsec = oldsec; 1099 tdef = olddef; 1100 } 1101 else 1102 { 1103 ntbfd = oldbfd; 1104 ntsec = oldsec; 1105 ntdef = olddef; 1106 tbfd = abfd; 1107 tsec = sec; 1108 tdef = newdef; 1109 } 1110 1111 if (tdef && ntdef) 1112 (*_bfd_error_handler) 1113 (_("%s: TLS definition in %B section %A mismatches non-TLS definition in %B section %A"), 1114 tbfd, tsec, ntbfd, ntsec, h->root.root.string); 1115 else if (!tdef && !ntdef) 1116 (*_bfd_error_handler) 1117 (_("%s: TLS reference in %B mismatches non-TLS reference in %B"), 1118 tbfd, ntbfd, h->root.root.string); 1119 else if (tdef) 1120 (*_bfd_error_handler) 1121 (_("%s: TLS definition in %B section %A mismatches non-TLS reference in %B"), 1122 tbfd, tsec, ntbfd, h->root.root.string); 1123 else 1124 (*_bfd_error_handler) 1125 (_("%s: TLS reference in %B mismatches non-TLS definition in %B section %A"), 1126 tbfd, ntbfd, ntsec, h->root.root.string); 1127 1128 bfd_set_error (bfd_error_bad_value); 1129 return FALSE; 1130 } 1131 1132 /* We need to remember if a symbol has a definition in a dynamic 1133 object or is weak in all dynamic objects. Internal and hidden 1134 visibility will make it unavailable to dynamic objects. */ 1135 if (newdyn && !h->dynamic_def) 1136 { 1137 if (!bfd_is_und_section (sec)) 1138 h->dynamic_def = 1; 1139 else 1140 { 1141 /* Check if this symbol is weak in all dynamic objects. If it 1142 is the first time we see it in a dynamic object, we mark 1143 if it is weak. Otherwise, we clear it. */ 1144 if (!h->ref_dynamic) 1145 { 1146 if (bind == STB_WEAK) 1147 h->dynamic_weak = 1; 1148 } 1149 else if (bind != STB_WEAK) 1150 h->dynamic_weak = 0; 1151 } 1152 } 1153 1154 /* If the old symbol has non-default visibility, we ignore the new 1155 definition from a dynamic object. */ 1156 if (newdyn 1157 && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 1158 && !bfd_is_und_section (sec)) 1159 { 1160 *skip = TRUE; 1161 /* Make sure this symbol is dynamic. */ 1162 h->ref_dynamic = 1; 1163 /* A protected symbol has external availability. Make sure it is 1164 recorded as dynamic. 1165 1166 FIXME: Should we check type and size for protected symbol? */ 1167 if (ELF_ST_VISIBILITY (h->other) == STV_PROTECTED) 1168 return bfd_elf_link_record_dynamic_symbol (info, h); 1169 else 1170 return TRUE; 1171 } 1172 else if (!newdyn 1173 && ELF_ST_VISIBILITY (sym->st_other) != STV_DEFAULT 1174 && h->def_dynamic) 1175 { 1176 /* If the new symbol with non-default visibility comes from a 1177 relocatable file and the old definition comes from a dynamic 1178 object, we remove the old definition. */ 1179 if ((*sym_hash)->root.type == bfd_link_hash_indirect) 1180 { 1181 /* Handle the case where the old dynamic definition is 1182 default versioned. We need to copy the symbol info from 1183 the symbol with default version to the normal one if it 1184 was referenced before. */ 1185 if (h->ref_regular) 1186 { 1187 const struct elf_backend_data *bed 1188 = get_elf_backend_data (abfd); 1189 struct elf_link_hash_entry *vh = *sym_hash; 1190 vh->root.type = h->root.type; 1191 h->root.type = bfd_link_hash_indirect; 1192 (*bed->elf_backend_copy_indirect_symbol) (info, vh, h); 1193 /* Protected symbols will override the dynamic definition 1194 with default version. */ 1195 if (ELF_ST_VISIBILITY (sym->st_other) == STV_PROTECTED) 1196 { 1197 h->root.u.i.link = (struct bfd_link_hash_entry *) vh; 1198 vh->dynamic_def = 1; 1199 vh->ref_dynamic = 1; 1200 } 1201 else 1202 { 1203 h->root.type = vh->root.type; 1204 vh->ref_dynamic = 0; 1205 /* We have to hide it here since it was made dynamic 1206 global with extra bits when the symbol info was 1207 copied from the old dynamic definition. */ 1208 (*bed->elf_backend_hide_symbol) (info, vh, TRUE); 1209 } 1210 h = vh; 1211 } 1212 else 1213 h = *sym_hash; 1214 } 1215 1216 if ((h->root.u.undef.next || info->hash->undefs_tail == &h->root) 1217 && bfd_is_und_section (sec)) 1218 { 1219 /* If the new symbol is undefined and the old symbol was 1220 also undefined before, we need to make sure 1221 _bfd_generic_link_add_one_symbol doesn't mess 1222 up the linker hash table undefs list. Since the old 1223 definition came from a dynamic object, it is still on the 1224 undefs list. */ 1225 h->root.type = bfd_link_hash_undefined; 1226 h->root.u.undef.abfd = abfd; 1227 } 1228 else 1229 { 1230 h->root.type = bfd_link_hash_new; 1231 h->root.u.undef.abfd = NULL; 1232 } 1233 1234 if (h->def_dynamic) 1235 { 1236 h->def_dynamic = 0; 1237 h->ref_dynamic = 1; 1238 h->dynamic_def = 1; 1239 } 1240 /* FIXME: Should we check type and size for protected symbol? */ 1241 h->size = 0; 1242 h->type = 0; 1243 return TRUE; 1244 } 1245 1246 /* Differentiate strong and weak symbols. */ 1247 newweak = bind == STB_WEAK; 1248 oldweak = (h->root.type == bfd_link_hash_defweak 1249 || h->root.type == bfd_link_hash_undefweak); 1250 1251 if (bind == STB_GNU_UNIQUE) 1252 h->unique_global = 1; 1253 1254 /* If a new weak symbol definition comes from a regular file and the 1255 old symbol comes from a dynamic library, we treat the new one as 1256 strong. Similarly, an old weak symbol definition from a regular 1257 file is treated as strong when the new symbol comes from a dynamic 1258 library. Further, an old weak symbol from a dynamic library is 1259 treated as strong if the new symbol is from a dynamic library. 1260 This reflects the way glibc's ld.so works. 1261 1262 Do this before setting *type_change_ok or *size_change_ok so that 1263 we warn properly when dynamic library symbols are overridden. */ 1264 1265 if (newdef && !newdyn && olddyn) 1266 newweak = FALSE; 1267 if (olddef && newdyn) 1268 oldweak = FALSE; 1269 1270 /* Allow changes between different types of function symbol. */ 1271 if (newfunc && oldfunc) 1272 *type_change_ok = TRUE; 1273 1274 /* It's OK to change the type if either the existing symbol or the 1275 new symbol is weak. A type change is also OK if the old symbol 1276 is undefined and the new symbol is defined. */ 1277 1278 if (oldweak 1279 || newweak 1280 || (newdef 1281 && h->root.type == bfd_link_hash_undefined)) 1282 *type_change_ok = TRUE; 1283 1284 /* It's OK to change the size if either the existing symbol or the 1285 new symbol is weak, or if the old symbol is undefined. */ 1286 1287 if (*type_change_ok 1288 || h->root.type == bfd_link_hash_undefined) 1289 *size_change_ok = TRUE; 1290 1291 /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old 1292 symbol, respectively, appears to be a common symbol in a dynamic 1293 object. If a symbol appears in an uninitialized section, and is 1294 not weak, and is not a function, then it may be a common symbol 1295 which was resolved when the dynamic object was created. We want 1296 to treat such symbols specially, because they raise special 1297 considerations when setting the symbol size: if the symbol 1298 appears as a common symbol in a regular object, and the size in 1299 the regular object is larger, we must make sure that we use the 1300 larger size. This problematic case can always be avoided in C, 1301 but it must be handled correctly when using Fortran shared 1302 libraries. 1303 1304 Note that if NEWDYNCOMMON is set, NEWDEF will be set, and 1305 likewise for OLDDYNCOMMON and OLDDEF. 1306 1307 Note that this test is just a heuristic, and that it is quite 1308 possible to have an uninitialized symbol in a shared object which 1309 is really a definition, rather than a common symbol. This could 1310 lead to some minor confusion when the symbol really is a common 1311 symbol in some regular object. However, I think it will be 1312 harmless. */ 1313 1314 if (newdyn 1315 && newdef 1316 && !newweak 1317 && (sec->flags & SEC_ALLOC) != 0 1318 && (sec->flags & SEC_LOAD) == 0 1319 && sym->st_size > 0 1320 && !newfunc) 1321 newdyncommon = TRUE; 1322 else 1323 newdyncommon = FALSE; 1324 1325 if (olddyn 1326 && olddef 1327 && h->root.type == bfd_link_hash_defined 1328 && h->def_dynamic 1329 && (h->root.u.def.section->flags & SEC_ALLOC) != 0 1330 && (h->root.u.def.section->flags & SEC_LOAD) == 0 1331 && h->size > 0 1332 && !oldfunc) 1333 olddyncommon = TRUE; 1334 else 1335 olddyncommon = FALSE; 1336 1337 /* We now know everything about the old and new symbols. We ask the 1338 backend to check if we can merge them. */ 1339 if (bed->merge_symbol 1340 && !bed->merge_symbol (info, sym_hash, h, sym, psec, pvalue, 1341 pold_alignment, skip, override, 1342 type_change_ok, size_change_ok, 1343 &newdyn, &newdef, &newdyncommon, &newweak, 1344 abfd, &sec, 1345 &olddyn, &olddef, &olddyncommon, &oldweak, 1346 oldbfd, &oldsec)) 1347 return FALSE; 1348 1349 /* If both the old and the new symbols look like common symbols in a 1350 dynamic object, set the size of the symbol to the larger of the 1351 two. */ 1352 1353 if (olddyncommon 1354 && newdyncommon 1355 && sym->st_size != h->size) 1356 { 1357 /* Since we think we have two common symbols, issue a multiple 1358 common warning if desired. Note that we only warn if the 1359 size is different. If the size is the same, we simply let 1360 the old symbol override the new one as normally happens with 1361 symbols defined in dynamic objects. */ 1362 1363 if (! ((*info->callbacks->multiple_common) 1364 (info, h->root.root.string, oldbfd, bfd_link_hash_common, 1365 h->size, abfd, bfd_link_hash_common, sym->st_size))) 1366 return FALSE; 1367 1368 if (sym->st_size > h->size) 1369 h->size = sym->st_size; 1370 1371 *size_change_ok = TRUE; 1372 } 1373 1374 /* If we are looking at a dynamic object, and we have found a 1375 definition, we need to see if the symbol was already defined by 1376 some other object. If so, we want to use the existing 1377 definition, and we do not want to report a multiple symbol 1378 definition error; we do this by clobbering *PSEC to be 1379 bfd_und_section_ptr. 1380 1381 We treat a common symbol as a definition if the symbol in the 1382 shared library is a function, since common symbols always 1383 represent variables; this can cause confusion in principle, but 1384 any such confusion would seem to indicate an erroneous program or 1385 shared library. We also permit a common symbol in a regular 1386 object to override a weak symbol in a shared object. */ 1387 1388 if (newdyn 1389 && newdef 1390 && (olddef 1391 || (h->root.type == bfd_link_hash_common 1392 && (newweak || newfunc)))) 1393 { 1394 *override = TRUE; 1395 newdef = FALSE; 1396 newdyncommon = FALSE; 1397 1398 *psec = sec = bfd_und_section_ptr; 1399 *size_change_ok = TRUE; 1400 1401 /* If we get here when the old symbol is a common symbol, then 1402 we are explicitly letting it override a weak symbol or 1403 function in a dynamic object, and we don't want to warn about 1404 a type change. If the old symbol is a defined symbol, a type 1405 change warning may still be appropriate. */ 1406 1407 if (h->root.type == bfd_link_hash_common) 1408 *type_change_ok = TRUE; 1409 } 1410 1411 /* Handle the special case of an old common symbol merging with a 1412 new symbol which looks like a common symbol in a shared object. 1413 We change *PSEC and *PVALUE to make the new symbol look like a 1414 common symbol, and let _bfd_generic_link_add_one_symbol do the 1415 right thing. */ 1416 1417 if (newdyncommon 1418 && h->root.type == bfd_link_hash_common) 1419 { 1420 *override = TRUE; 1421 newdef = FALSE; 1422 newdyncommon = FALSE; 1423 *pvalue = sym->st_size; 1424 *psec = sec = bed->common_section (oldsec); 1425 *size_change_ok = TRUE; 1426 } 1427 1428 /* Skip weak definitions of symbols that are already defined. */ 1429 if (newdef && olddef && newweak) 1430 { 1431 *skip = TRUE; 1432 1433 /* Merge st_other. If the symbol already has a dynamic index, 1434 but visibility says it should not be visible, turn it into a 1435 local symbol. */ 1436 elf_merge_st_other (abfd, h, sym, newdef, newdyn); 1437 if (h->dynindx != -1) 1438 switch (ELF_ST_VISIBILITY (h->other)) 1439 { 1440 case STV_INTERNAL: 1441 case STV_HIDDEN: 1442 (*bed->elf_backend_hide_symbol) (info, h, TRUE); 1443 break; 1444 } 1445 } 1446 1447 /* If the old symbol is from a dynamic object, and the new symbol is 1448 a definition which is not from a dynamic object, then the new 1449 symbol overrides the old symbol. Symbols from regular files 1450 always take precedence over symbols from dynamic objects, even if 1451 they are defined after the dynamic object in the link. 1452 1453 As above, we again permit a common symbol in a regular object to 1454 override a definition in a shared object if the shared object 1455 symbol is a function or is weak. */ 1456 1457 flip = NULL; 1458 if (!newdyn 1459 && (newdef 1460 || (bfd_is_com_section (sec) 1461 && (oldweak || oldfunc))) 1462 && olddyn 1463 && olddef 1464 && h->def_dynamic) 1465 { 1466 /* Change the hash table entry to undefined, and let 1467 _bfd_generic_link_add_one_symbol do the right thing with the 1468 new definition. */ 1469 1470 h->root.type = bfd_link_hash_undefined; 1471 h->root.u.undef.abfd = h->root.u.def.section->owner; 1472 *size_change_ok = TRUE; 1473 1474 olddef = FALSE; 1475 olddyncommon = FALSE; 1476 1477 /* We again permit a type change when a common symbol may be 1478 overriding a function. */ 1479 1480 if (bfd_is_com_section (sec)) 1481 { 1482 if (oldfunc) 1483 { 1484 /* If a common symbol overrides a function, make sure 1485 that it isn't defined dynamically nor has type 1486 function. */ 1487 h->def_dynamic = 0; 1488 h->type = STT_NOTYPE; 1489 } 1490 *type_change_ok = TRUE; 1491 } 1492 1493 if ((*sym_hash)->root.type == bfd_link_hash_indirect) 1494 flip = *sym_hash; 1495 else 1496 /* This union may have been set to be non-NULL when this symbol 1497 was seen in a dynamic object. We must force the union to be 1498 NULL, so that it is correct for a regular symbol. */ 1499 h->verinfo.vertree = NULL; 1500 } 1501 1502 /* Handle the special case of a new common symbol merging with an 1503 old symbol that looks like it might be a common symbol defined in 1504 a shared object. Note that we have already handled the case in 1505 which a new common symbol should simply override the definition 1506 in the shared library. */ 1507 1508 if (! newdyn 1509 && bfd_is_com_section (sec) 1510 && olddyncommon) 1511 { 1512 /* It would be best if we could set the hash table entry to a 1513 common symbol, but we don't know what to use for the section 1514 or the alignment. */ 1515 if (! ((*info->callbacks->multiple_common) 1516 (info, h->root.root.string, oldbfd, bfd_link_hash_common, 1517 h->size, abfd, bfd_link_hash_common, sym->st_size))) 1518 return FALSE; 1519 1520 /* If the presumed common symbol in the dynamic object is 1521 larger, pretend that the new symbol has its size. */ 1522 1523 if (h->size > *pvalue) 1524 *pvalue = h->size; 1525 1526 /* We need to remember the alignment required by the symbol 1527 in the dynamic object. */ 1528 BFD_ASSERT (pold_alignment); 1529 *pold_alignment = h->root.u.def.section->alignment_power; 1530 1531 olddef = FALSE; 1532 olddyncommon = FALSE; 1533 1534 h->root.type = bfd_link_hash_undefined; 1535 h->root.u.undef.abfd = h->root.u.def.section->owner; 1536 1537 *size_change_ok = TRUE; 1538 *type_change_ok = TRUE; 1539 1540 if ((*sym_hash)->root.type == bfd_link_hash_indirect) 1541 flip = *sym_hash; 1542 else 1543 h->verinfo.vertree = NULL; 1544 } 1545 1546 if (flip != NULL) 1547 { 1548 /* Handle the case where we had a versioned symbol in a dynamic 1549 library and now find a definition in a normal object. In this 1550 case, we make the versioned symbol point to the normal one. */ 1551 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 1552 flip->root.type = h->root.type; 1553 flip->root.u.undef.abfd = h->root.u.undef.abfd; 1554 h->root.type = bfd_link_hash_indirect; 1555 h->root.u.i.link = (struct bfd_link_hash_entry *) flip; 1556 (*bed->elf_backend_copy_indirect_symbol) (info, flip, h); 1557 if (h->def_dynamic) 1558 { 1559 h->def_dynamic = 0; 1560 flip->ref_dynamic = 1; 1561 } 1562 } 1563 1564 return TRUE; 1565 } 1566 1567 /* This function is called to create an indirect symbol from the 1568 default for the symbol with the default version if needed. The 1569 symbol is described by H, NAME, SYM, PSEC, VALUE, and OVERRIDE. We 1570 set DYNSYM if the new indirect symbol is dynamic. */ 1571 1572 static bfd_boolean 1573 _bfd_elf_add_default_symbol (bfd *abfd, 1574 struct bfd_link_info *info, 1575 struct elf_link_hash_entry *h, 1576 const char *name, 1577 Elf_Internal_Sym *sym, 1578 asection **psec, 1579 bfd_vma *value, 1580 bfd_boolean *dynsym, 1581 bfd_boolean override) 1582 { 1583 bfd_boolean type_change_ok; 1584 bfd_boolean size_change_ok; 1585 bfd_boolean skip; 1586 char *shortname; 1587 struct elf_link_hash_entry *hi; 1588 struct bfd_link_hash_entry *bh; 1589 const struct elf_backend_data *bed; 1590 bfd_boolean collect; 1591 bfd_boolean dynamic; 1592 char *p; 1593 size_t len, shortlen; 1594 asection *sec; 1595 1596 /* If this symbol has a version, and it is the default version, we 1597 create an indirect symbol from the default name to the fully 1598 decorated name. This will cause external references which do not 1599 specify a version to be bound to this version of the symbol. */ 1600 p = strchr (name, ELF_VER_CHR); 1601 if (p == NULL || p[1] != ELF_VER_CHR) 1602 return TRUE; 1603 1604 if (override) 1605 { 1606 /* We are overridden by an old definition. We need to check if we 1607 need to create the indirect symbol from the default name. */ 1608 hi = elf_link_hash_lookup (elf_hash_table (info), name, TRUE, 1609 FALSE, FALSE); 1610 BFD_ASSERT (hi != NULL); 1611 if (hi == h) 1612 return TRUE; 1613 while (hi->root.type == bfd_link_hash_indirect 1614 || hi->root.type == bfd_link_hash_warning) 1615 { 1616 hi = (struct elf_link_hash_entry *) hi->root.u.i.link; 1617 if (hi == h) 1618 return TRUE; 1619 } 1620 } 1621 1622 bed = get_elf_backend_data (abfd); 1623 collect = bed->collect; 1624 dynamic = (abfd->flags & DYNAMIC) != 0; 1625 1626 shortlen = p - name; 1627 shortname = (char *) bfd_hash_allocate (&info->hash->table, shortlen + 1); 1628 if (shortname == NULL) 1629 return FALSE; 1630 memcpy (shortname, name, shortlen); 1631 shortname[shortlen] = '\0'; 1632 1633 /* We are going to create a new symbol. Merge it with any existing 1634 symbol with this name. For the purposes of the merge, act as 1635 though we were defining the symbol we just defined, although we 1636 actually going to define an indirect symbol. */ 1637 type_change_ok = FALSE; 1638 size_change_ok = FALSE; 1639 sec = *psec; 1640 if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &sec, value, 1641 NULL, &hi, &skip, &override, 1642 &type_change_ok, &size_change_ok)) 1643 return FALSE; 1644 1645 if (skip) 1646 goto nondefault; 1647 1648 if (! override) 1649 { 1650 bh = &hi->root; 1651 if (! (_bfd_generic_link_add_one_symbol 1652 (info, abfd, shortname, BSF_INDIRECT, bfd_ind_section_ptr, 1653 0, name, FALSE, collect, &bh))) 1654 return FALSE; 1655 hi = (struct elf_link_hash_entry *) bh; 1656 } 1657 else 1658 { 1659 /* In this case the symbol named SHORTNAME is overriding the 1660 indirect symbol we want to add. We were planning on making 1661 SHORTNAME an indirect symbol referring to NAME. SHORTNAME 1662 is the name without a version. NAME is the fully versioned 1663 name, and it is the default version. 1664 1665 Overriding means that we already saw a definition for the 1666 symbol SHORTNAME in a regular object, and it is overriding 1667 the symbol defined in the dynamic object. 1668 1669 When this happens, we actually want to change NAME, the 1670 symbol we just added, to refer to SHORTNAME. This will cause 1671 references to NAME in the shared object to become references 1672 to SHORTNAME in the regular object. This is what we expect 1673 when we override a function in a shared object: that the 1674 references in the shared object will be mapped to the 1675 definition in the regular object. */ 1676 1677 while (hi->root.type == bfd_link_hash_indirect 1678 || hi->root.type == bfd_link_hash_warning) 1679 hi = (struct elf_link_hash_entry *) hi->root.u.i.link; 1680 1681 h->root.type = bfd_link_hash_indirect; 1682 h->root.u.i.link = (struct bfd_link_hash_entry *) hi; 1683 if (h->def_dynamic) 1684 { 1685 h->def_dynamic = 0; 1686 hi->ref_dynamic = 1; 1687 if (hi->ref_regular 1688 || hi->def_regular) 1689 { 1690 if (! bfd_elf_link_record_dynamic_symbol (info, hi)) 1691 return FALSE; 1692 } 1693 } 1694 1695 /* Now set HI to H, so that the following code will set the 1696 other fields correctly. */ 1697 hi = h; 1698 } 1699 1700 /* Check if HI is a warning symbol. */ 1701 if (hi->root.type == bfd_link_hash_warning) 1702 hi = (struct elf_link_hash_entry *) hi->root.u.i.link; 1703 1704 /* If there is a duplicate definition somewhere, then HI may not 1705 point to an indirect symbol. We will have reported an error to 1706 the user in that case. */ 1707 1708 if (hi->root.type == bfd_link_hash_indirect) 1709 { 1710 struct elf_link_hash_entry *ht; 1711 1712 ht = (struct elf_link_hash_entry *) hi->root.u.i.link; 1713 (*bed->elf_backend_copy_indirect_symbol) (info, ht, hi); 1714 1715 /* See if the new flags lead us to realize that the symbol must 1716 be dynamic. */ 1717 if (! *dynsym) 1718 { 1719 if (! dynamic) 1720 { 1721 if (info->shared 1722 || hi->ref_dynamic) 1723 *dynsym = TRUE; 1724 } 1725 else 1726 { 1727 if (hi->ref_regular) 1728 *dynsym = TRUE; 1729 } 1730 } 1731 } 1732 1733 /* We also need to define an indirection from the nondefault version 1734 of the symbol. */ 1735 1736 nondefault: 1737 len = strlen (name); 1738 shortname = (char *) bfd_hash_allocate (&info->hash->table, len); 1739 if (shortname == NULL) 1740 return FALSE; 1741 memcpy (shortname, name, shortlen); 1742 memcpy (shortname + shortlen, p + 1, len - shortlen); 1743 1744 /* Once again, merge with any existing symbol. */ 1745 type_change_ok = FALSE; 1746 size_change_ok = FALSE; 1747 sec = *psec; 1748 if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &sec, value, 1749 NULL, &hi, &skip, &override, 1750 &type_change_ok, &size_change_ok)) 1751 return FALSE; 1752 1753 if (skip) 1754 return TRUE; 1755 1756 if (override) 1757 { 1758 /* Here SHORTNAME is a versioned name, so we don't expect to see 1759 the type of override we do in the case above unless it is 1760 overridden by a versioned definition. */ 1761 if (hi->root.type != bfd_link_hash_defined 1762 && hi->root.type != bfd_link_hash_defweak) 1763 (*_bfd_error_handler) 1764 (_("%B: unexpected redefinition of indirect versioned symbol `%s'"), 1765 abfd, shortname); 1766 } 1767 else 1768 { 1769 bh = &hi->root; 1770 if (! (_bfd_generic_link_add_one_symbol 1771 (info, abfd, shortname, BSF_INDIRECT, 1772 bfd_ind_section_ptr, 0, name, FALSE, collect, &bh))) 1773 return FALSE; 1774 hi = (struct elf_link_hash_entry *) bh; 1775 1776 /* If there is a duplicate definition somewhere, then HI may not 1777 point to an indirect symbol. We will have reported an error 1778 to the user in that case. */ 1779 1780 if (hi->root.type == bfd_link_hash_indirect) 1781 { 1782 (*bed->elf_backend_copy_indirect_symbol) (info, h, hi); 1783 1784 /* See if the new flags lead us to realize that the symbol 1785 must be dynamic. */ 1786 if (! *dynsym) 1787 { 1788 if (! dynamic) 1789 { 1790 if (info->shared 1791 || hi->ref_dynamic) 1792 *dynsym = TRUE; 1793 } 1794 else 1795 { 1796 if (hi->ref_regular) 1797 *dynsym = TRUE; 1798 } 1799 } 1800 } 1801 } 1802 1803 return TRUE; 1804 } 1805 1806 /* This routine is used to export all defined symbols into the dynamic 1807 symbol table. It is called via elf_link_hash_traverse. */ 1808 1809 static bfd_boolean 1810 _bfd_elf_export_symbol (struct elf_link_hash_entry *h, void *data) 1811 { 1812 struct elf_info_failed *eif = (struct elf_info_failed *) data; 1813 1814 /* Ignore this if we won't export it. */ 1815 if (!eif->info->export_dynamic && !h->dynamic) 1816 return TRUE; 1817 1818 /* Ignore indirect symbols. These are added by the versioning code. */ 1819 if (h->root.type == bfd_link_hash_indirect) 1820 return TRUE; 1821 1822 if (h->root.type == bfd_link_hash_warning) 1823 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1824 1825 if (h->dynindx == -1 1826 && (h->def_regular 1827 || h->ref_regular)) 1828 { 1829 bfd_boolean hide; 1830 1831 if (eif->verdefs == NULL 1832 || (bfd_find_version_for_sym (eif->verdefs, h->root.root.string, &hide) 1833 && !hide)) 1834 { 1835 if (! bfd_elf_link_record_dynamic_symbol (eif->info, h)) 1836 { 1837 eif->failed = TRUE; 1838 return FALSE; 1839 } 1840 } 1841 } 1842 1843 return TRUE; 1844 } 1845 1846 /* Look through the symbols which are defined in other shared 1847 libraries and referenced here. Update the list of version 1848 dependencies. This will be put into the .gnu.version_r section. 1849 This function is called via elf_link_hash_traverse. */ 1850 1851 static bfd_boolean 1852 _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry *h, 1853 void *data) 1854 { 1855 struct elf_find_verdep_info *rinfo = (struct elf_find_verdep_info *) data; 1856 Elf_Internal_Verneed *t; 1857 Elf_Internal_Vernaux *a; 1858 bfd_size_type amt; 1859 1860 if (h->root.type == bfd_link_hash_warning) 1861 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1862 1863 /* We only care about symbols defined in shared objects with version 1864 information. */ 1865 if (!h->def_dynamic 1866 || h->def_regular 1867 || h->dynindx == -1 1868 || h->verinfo.verdef == NULL) 1869 return TRUE; 1870 1871 /* See if we already know about this version. */ 1872 for (t = elf_tdata (rinfo->info->output_bfd)->verref; 1873 t != NULL; 1874 t = t->vn_nextref) 1875 { 1876 if (t->vn_bfd != h->verinfo.verdef->vd_bfd) 1877 continue; 1878 1879 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr) 1880 if (a->vna_nodename == h->verinfo.verdef->vd_nodename) 1881 return TRUE; 1882 1883 break; 1884 } 1885 1886 /* This is a new version. Add it to tree we are building. */ 1887 1888 if (t == NULL) 1889 { 1890 amt = sizeof *t; 1891 t = (Elf_Internal_Verneed *) bfd_zalloc (rinfo->info->output_bfd, amt); 1892 if (t == NULL) 1893 { 1894 rinfo->failed = TRUE; 1895 return FALSE; 1896 } 1897 1898 t->vn_bfd = h->verinfo.verdef->vd_bfd; 1899 t->vn_nextref = elf_tdata (rinfo->info->output_bfd)->verref; 1900 elf_tdata (rinfo->info->output_bfd)->verref = t; 1901 } 1902 1903 amt = sizeof *a; 1904 a = (Elf_Internal_Vernaux *) bfd_zalloc (rinfo->info->output_bfd, amt); 1905 if (a == NULL) 1906 { 1907 rinfo->failed = TRUE; 1908 return FALSE; 1909 } 1910 1911 /* Note that we are copying a string pointer here, and testing it 1912 above. If bfd_elf_string_from_elf_section is ever changed to 1913 discard the string data when low in memory, this will have to be 1914 fixed. */ 1915 a->vna_nodename = h->verinfo.verdef->vd_nodename; 1916 1917 a->vna_flags = h->verinfo.verdef->vd_flags; 1918 a->vna_nextptr = t->vn_auxptr; 1919 1920 h->verinfo.verdef->vd_exp_refno = rinfo->vers; 1921 ++rinfo->vers; 1922 1923 a->vna_other = h->verinfo.verdef->vd_exp_refno + 1; 1924 1925 t->vn_auxptr = a; 1926 1927 return TRUE; 1928 } 1929 1930 /* Figure out appropriate versions for all the symbols. We may not 1931 have the version number script until we have read all of the input 1932 files, so until that point we don't know which symbols should be 1933 local. This function is called via elf_link_hash_traverse. */ 1934 1935 static bfd_boolean 1936 _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data) 1937 { 1938 struct elf_info_failed *sinfo; 1939 struct bfd_link_info *info; 1940 const struct elf_backend_data *bed; 1941 struct elf_info_failed eif; 1942 char *p; 1943 bfd_size_type amt; 1944 1945 sinfo = (struct elf_info_failed *) data; 1946 info = sinfo->info; 1947 1948 if (h->root.type == bfd_link_hash_warning) 1949 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1950 1951 /* Fix the symbol flags. */ 1952 eif.failed = FALSE; 1953 eif.info = info; 1954 if (! _bfd_elf_fix_symbol_flags (h, &eif)) 1955 { 1956 if (eif.failed) 1957 sinfo->failed = TRUE; 1958 return FALSE; 1959 } 1960 1961 /* We only need version numbers for symbols defined in regular 1962 objects. */ 1963 if (!h->def_regular) 1964 return TRUE; 1965 1966 bed = get_elf_backend_data (info->output_bfd); 1967 p = strchr (h->root.root.string, ELF_VER_CHR); 1968 if (p != NULL && h->verinfo.vertree == NULL) 1969 { 1970 struct bfd_elf_version_tree *t; 1971 bfd_boolean hidden; 1972 1973 hidden = TRUE; 1974 1975 /* There are two consecutive ELF_VER_CHR characters if this is 1976 not a hidden symbol. */ 1977 ++p; 1978 if (*p == ELF_VER_CHR) 1979 { 1980 hidden = FALSE; 1981 ++p; 1982 } 1983 1984 /* If there is no version string, we can just return out. */ 1985 if (*p == '\0') 1986 { 1987 if (hidden) 1988 h->hidden = 1; 1989 return TRUE; 1990 } 1991 1992 /* Look for the version. If we find it, it is no longer weak. */ 1993 for (t = sinfo->verdefs; t != NULL; t = t->next) 1994 { 1995 if (strcmp (t->name, p) == 0) 1996 { 1997 size_t len; 1998 char *alc; 1999 struct bfd_elf_version_expr *d; 2000 2001 len = p - h->root.root.string; 2002 alc = (char *) bfd_malloc (len); 2003 if (alc == NULL) 2004 { 2005 sinfo->failed = TRUE; 2006 return FALSE; 2007 } 2008 memcpy (alc, h->root.root.string, len - 1); 2009 alc[len - 1] = '\0'; 2010 if (alc[len - 2] == ELF_VER_CHR) 2011 alc[len - 2] = '\0'; 2012 2013 h->verinfo.vertree = t; 2014 t->used = TRUE; 2015 d = NULL; 2016 2017 if (t->globals.list != NULL) 2018 d = (*t->match) (&t->globals, NULL, alc); 2019 2020 /* See if there is anything to force this symbol to 2021 local scope. */ 2022 if (d == NULL && t->locals.list != NULL) 2023 { 2024 d = (*t->match) (&t->locals, NULL, alc); 2025 if (d != NULL 2026 && h->dynindx != -1 2027 && ! info->export_dynamic) 2028 (*bed->elf_backend_hide_symbol) (info, h, TRUE); 2029 } 2030 2031 free (alc); 2032 break; 2033 } 2034 } 2035 2036 /* If we are building an application, we need to create a 2037 version node for this version. */ 2038 if (t == NULL && info->executable) 2039 { 2040 struct bfd_elf_version_tree **pp; 2041 int version_index; 2042 2043 /* If we aren't going to export this symbol, we don't need 2044 to worry about it. */ 2045 if (h->dynindx == -1) 2046 return TRUE; 2047 2048 amt = sizeof *t; 2049 t = (struct bfd_elf_version_tree *) bfd_zalloc (info->output_bfd, amt); 2050 if (t == NULL) 2051 { 2052 sinfo->failed = TRUE; 2053 return FALSE; 2054 } 2055 2056 t->name = p; 2057 t->name_indx = (unsigned int) -1; 2058 t->used = TRUE; 2059 2060 version_index = 1; 2061 /* Don't count anonymous version tag. */ 2062 if (sinfo->verdefs != NULL && sinfo->verdefs->vernum == 0) 2063 version_index = 0; 2064 for (pp = &sinfo->verdefs; *pp != NULL; pp = &(*pp)->next) 2065 ++version_index; 2066 t->vernum = version_index; 2067 2068 *pp = t; 2069 2070 h->verinfo.vertree = t; 2071 } 2072 else if (t == NULL) 2073 { 2074 /* We could not find the version for a symbol when 2075 generating a shared archive. Return an error. */ 2076 (*_bfd_error_handler) 2077 (_("%B: version node not found for symbol %s"), 2078 info->output_bfd, h->root.root.string); 2079 bfd_set_error (bfd_error_bad_value); 2080 sinfo->failed = TRUE; 2081 return FALSE; 2082 } 2083 2084 if (hidden) 2085 h->hidden = 1; 2086 } 2087 2088 /* If we don't have a version for this symbol, see if we can find 2089 something. */ 2090 if (h->verinfo.vertree == NULL && sinfo->verdefs != NULL) 2091 { 2092 bfd_boolean hide; 2093 2094 h->verinfo.vertree = bfd_find_version_for_sym (sinfo->verdefs, 2095 h->root.root.string, &hide); 2096 if (h->verinfo.vertree != NULL && hide) 2097 (*bed->elf_backend_hide_symbol) (info, h, TRUE); 2098 } 2099 2100 return TRUE; 2101 } 2102 2103 /* Read and swap the relocs from the section indicated by SHDR. This 2104 may be either a REL or a RELA section. The relocations are 2105 translated into RELA relocations and stored in INTERNAL_RELOCS, 2106 which should have already been allocated to contain enough space. 2107 The EXTERNAL_RELOCS are a buffer where the external form of the 2108 relocations should be stored. 2109 2110 Returns FALSE if something goes wrong. */ 2111 2112 static bfd_boolean 2113 elf_link_read_relocs_from_section (bfd *abfd, 2114 asection *sec, 2115 Elf_Internal_Shdr *shdr, 2116 void *external_relocs, 2117 Elf_Internal_Rela *internal_relocs) 2118 { 2119 const struct elf_backend_data *bed; 2120 void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *); 2121 const bfd_byte *erela; 2122 const bfd_byte *erelaend; 2123 Elf_Internal_Rela *irela; 2124 Elf_Internal_Shdr *symtab_hdr; 2125 size_t nsyms; 2126 2127 /* Position ourselves at the start of the section. */ 2128 if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0) 2129 return FALSE; 2130 2131 /* Read the relocations. */ 2132 if (bfd_bread (external_relocs, shdr->sh_size, abfd) != shdr->sh_size) 2133 return FALSE; 2134 2135 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 2136 nsyms = NUM_SHDR_ENTRIES (symtab_hdr); 2137 2138 bed = get_elf_backend_data (abfd); 2139 2140 /* Convert the external relocations to the internal format. */ 2141 if (shdr->sh_entsize == bed->s->sizeof_rel) 2142 swap_in = bed->s->swap_reloc_in; 2143 else if (shdr->sh_entsize == bed->s->sizeof_rela) 2144 swap_in = bed->s->swap_reloca_in; 2145 else 2146 { 2147 bfd_set_error (bfd_error_wrong_format); 2148 return FALSE; 2149 } 2150 2151 erela = (const bfd_byte *) external_relocs; 2152 erelaend = erela + shdr->sh_size; 2153 irela = internal_relocs; 2154 while (erela < erelaend) 2155 { 2156 bfd_vma r_symndx; 2157 2158 (*swap_in) (abfd, erela, irela); 2159 r_symndx = ELF32_R_SYM (irela->r_info); 2160 if (bed->s->arch_size == 64) 2161 r_symndx >>= 24; 2162 if (nsyms > 0) 2163 { 2164 if ((size_t) r_symndx >= nsyms) 2165 { 2166 (*_bfd_error_handler) 2167 (_("%B: bad reloc symbol index (0x%lx >= 0x%lx)" 2168 " for offset 0x%lx in section `%A'"), 2169 abfd, sec, 2170 (unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset); 2171 bfd_set_error (bfd_error_bad_value); 2172 return FALSE; 2173 } 2174 } 2175 else if (r_symndx != 0) 2176 { 2177 (*_bfd_error_handler) 2178 (_("%B: non-zero symbol index (0x%lx) for offset 0x%lx in section `%A'" 2179 " when the object file has no symbol table"), 2180 abfd, sec, 2181 (unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset); 2182 bfd_set_error (bfd_error_bad_value); 2183 return FALSE; 2184 } 2185 irela += bed->s->int_rels_per_ext_rel; 2186 erela += shdr->sh_entsize; 2187 } 2188 2189 return TRUE; 2190 } 2191 2192 /* Read and swap the relocs for a section O. They may have been 2193 cached. If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are 2194 not NULL, they are used as buffers to read into. They are known to 2195 be large enough. If the INTERNAL_RELOCS relocs argument is NULL, 2196 the return value is allocated using either malloc or bfd_alloc, 2197 according to the KEEP_MEMORY argument. If O has two relocation 2198 sections (both REL and RELA relocations), then the REL_HDR 2199 relocations will appear first in INTERNAL_RELOCS, followed by the 2200 REL_HDR2 relocations. */ 2201 2202 Elf_Internal_Rela * 2203 _bfd_elf_link_read_relocs (bfd *abfd, 2204 asection *o, 2205 void *external_relocs, 2206 Elf_Internal_Rela *internal_relocs, 2207 bfd_boolean keep_memory) 2208 { 2209 Elf_Internal_Shdr *rel_hdr; 2210 void *alloc1 = NULL; 2211 Elf_Internal_Rela *alloc2 = NULL; 2212 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 2213 2214 if (elf_section_data (o)->relocs != NULL) 2215 return elf_section_data (o)->relocs; 2216 2217 if (o->reloc_count == 0) 2218 return NULL; 2219 2220 rel_hdr = &elf_section_data (o)->rel_hdr; 2221 2222 if (internal_relocs == NULL) 2223 { 2224 bfd_size_type size; 2225 2226 size = o->reloc_count; 2227 size *= bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rela); 2228 if (keep_memory) 2229 internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_alloc (abfd, size); 2230 else 2231 internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_malloc (size); 2232 if (internal_relocs == NULL) 2233 goto error_return; 2234 } 2235 2236 if (external_relocs == NULL) 2237 { 2238 bfd_size_type size = rel_hdr->sh_size; 2239 2240 if (elf_section_data (o)->rel_hdr2) 2241 size += elf_section_data (o)->rel_hdr2->sh_size; 2242 alloc1 = bfd_malloc (size); 2243 if (alloc1 == NULL) 2244 goto error_return; 2245 external_relocs = alloc1; 2246 } 2247 2248 if (!elf_link_read_relocs_from_section (abfd, o, rel_hdr, 2249 external_relocs, 2250 internal_relocs)) 2251 goto error_return; 2252 if (elf_section_data (o)->rel_hdr2 2253 && (!elf_link_read_relocs_from_section 2254 (abfd, o, 2255 elf_section_data (o)->rel_hdr2, 2256 ((bfd_byte *) external_relocs) + rel_hdr->sh_size, 2257 internal_relocs + (NUM_SHDR_ENTRIES (rel_hdr) 2258 * bed->s->int_rels_per_ext_rel)))) 2259 goto error_return; 2260 2261 /* Cache the results for next time, if we can. */ 2262 if (keep_memory) 2263 elf_section_data (o)->relocs = internal_relocs; 2264 2265 if (alloc1 != NULL) 2266 free (alloc1); 2267 2268 /* Don't free alloc2, since if it was allocated we are passing it 2269 back (under the name of internal_relocs). */ 2270 2271 return internal_relocs; 2272 2273 error_return: 2274 if (alloc1 != NULL) 2275 free (alloc1); 2276 if (alloc2 != NULL) 2277 { 2278 if (keep_memory) 2279 bfd_release (abfd, alloc2); 2280 else 2281 free (alloc2); 2282 } 2283 return NULL; 2284 } 2285 2286 /* Compute the size of, and allocate space for, REL_HDR which is the 2287 section header for a section containing relocations for O. */ 2288 2289 static bfd_boolean 2290 _bfd_elf_link_size_reloc_section (bfd *abfd, 2291 Elf_Internal_Shdr *rel_hdr, 2292 asection *o) 2293 { 2294 bfd_size_type reloc_count; 2295 bfd_size_type num_rel_hashes; 2296 2297 /* Figure out how many relocations there will be. */ 2298 if (rel_hdr == &elf_section_data (o)->rel_hdr) 2299 reloc_count = elf_section_data (o)->rel_count; 2300 else 2301 reloc_count = elf_section_data (o)->rel_count2; 2302 2303 num_rel_hashes = o->reloc_count; 2304 if (num_rel_hashes < reloc_count) 2305 num_rel_hashes = reloc_count; 2306 2307 /* That allows us to calculate the size of the section. */ 2308 rel_hdr->sh_size = rel_hdr->sh_entsize * reloc_count; 2309 2310 /* The contents field must last into write_object_contents, so we 2311 allocate it with bfd_alloc rather than malloc. Also since we 2312 cannot be sure that the contents will actually be filled in, 2313 we zero the allocated space. */ 2314 rel_hdr->contents = (unsigned char *) bfd_zalloc (abfd, rel_hdr->sh_size); 2315 if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0) 2316 return FALSE; 2317 2318 /* We only allocate one set of hash entries, so we only do it the 2319 first time we are called. */ 2320 if (elf_section_data (o)->rel_hashes == NULL 2321 && num_rel_hashes) 2322 { 2323 struct elf_link_hash_entry **p; 2324 2325 p = (struct elf_link_hash_entry **) 2326 bfd_zmalloc (num_rel_hashes * sizeof (struct elf_link_hash_entry *)); 2327 if (p == NULL) 2328 return FALSE; 2329 2330 elf_section_data (o)->rel_hashes = p; 2331 } 2332 2333 return TRUE; 2334 } 2335 2336 /* Copy the relocations indicated by the INTERNAL_RELOCS (which 2337 originated from the section given by INPUT_REL_HDR) to the 2338 OUTPUT_BFD. */ 2339 2340 bfd_boolean 2341 _bfd_elf_link_output_relocs (bfd *output_bfd, 2342 asection *input_section, 2343 Elf_Internal_Shdr *input_rel_hdr, 2344 Elf_Internal_Rela *internal_relocs, 2345 struct elf_link_hash_entry **rel_hash 2346 ATTRIBUTE_UNUSED) 2347 { 2348 Elf_Internal_Rela *irela; 2349 Elf_Internal_Rela *irelaend; 2350 bfd_byte *erel; 2351 Elf_Internal_Shdr *output_rel_hdr; 2352 asection *output_section; 2353 unsigned int *rel_countp = NULL; 2354 const struct elf_backend_data *bed; 2355 void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *); 2356 2357 output_section = input_section->output_section; 2358 output_rel_hdr = NULL; 2359 2360 if (elf_section_data (output_section)->rel_hdr.sh_entsize 2361 == input_rel_hdr->sh_entsize) 2362 { 2363 output_rel_hdr = &elf_section_data (output_section)->rel_hdr; 2364 rel_countp = &elf_section_data (output_section)->rel_count; 2365 } 2366 else if (elf_section_data (output_section)->rel_hdr2 2367 && (elf_section_data (output_section)->rel_hdr2->sh_entsize 2368 == input_rel_hdr->sh_entsize)) 2369 { 2370 output_rel_hdr = elf_section_data (output_section)->rel_hdr2; 2371 rel_countp = &elf_section_data (output_section)->rel_count2; 2372 } 2373 else 2374 { 2375 (*_bfd_error_handler) 2376 (_("%B: relocation size mismatch in %B section %A"), 2377 output_bfd, input_section->owner, input_section); 2378 bfd_set_error (bfd_error_wrong_format); 2379 return FALSE; 2380 } 2381 2382 bed = get_elf_backend_data (output_bfd); 2383 if (input_rel_hdr->sh_entsize == bed->s->sizeof_rel) 2384 swap_out = bed->s->swap_reloc_out; 2385 else if (input_rel_hdr->sh_entsize == bed->s->sizeof_rela) 2386 swap_out = bed->s->swap_reloca_out; 2387 else 2388 abort (); 2389 2390 erel = output_rel_hdr->contents; 2391 erel += *rel_countp * input_rel_hdr->sh_entsize; 2392 irela = internal_relocs; 2393 irelaend = irela + (NUM_SHDR_ENTRIES (input_rel_hdr) 2394 * bed->s->int_rels_per_ext_rel); 2395 while (irela < irelaend) 2396 { 2397 (*swap_out) (output_bfd, irela, erel); 2398 irela += bed->s->int_rels_per_ext_rel; 2399 erel += input_rel_hdr->sh_entsize; 2400 } 2401 2402 /* Bump the counter, so that we know where to add the next set of 2403 relocations. */ 2404 *rel_countp += NUM_SHDR_ENTRIES (input_rel_hdr); 2405 2406 return TRUE; 2407 } 2408 2409 /* Make weak undefined symbols in PIE dynamic. */ 2410 2411 bfd_boolean 2412 _bfd_elf_link_hash_fixup_symbol (struct bfd_link_info *info, 2413 struct elf_link_hash_entry *h) 2414 { 2415 if (info->pie 2416 && h->dynindx == -1 2417 && h->root.type == bfd_link_hash_undefweak) 2418 return bfd_elf_link_record_dynamic_symbol (info, h); 2419 2420 return TRUE; 2421 } 2422 2423 /* Fix up the flags for a symbol. This handles various cases which 2424 can only be fixed after all the input files are seen. This is 2425 currently called by both adjust_dynamic_symbol and 2426 assign_sym_version, which is unnecessary but perhaps more robust in 2427 the face of future changes. */ 2428 2429 static bfd_boolean 2430 _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h, 2431 struct elf_info_failed *eif) 2432 { 2433 const struct elf_backend_data *bed; 2434 2435 /* If this symbol was mentioned in a non-ELF file, try to set 2436 DEF_REGULAR and REF_REGULAR correctly. This is the only way to 2437 permit a non-ELF file to correctly refer to a symbol defined in 2438 an ELF dynamic object. */ 2439 if (h->non_elf) 2440 { 2441 while (h->root.type == bfd_link_hash_indirect) 2442 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2443 2444 if (h->root.type != bfd_link_hash_defined 2445 && h->root.type != bfd_link_hash_defweak) 2446 { 2447 h->ref_regular = 1; 2448 h->ref_regular_nonweak = 1; 2449 } 2450 else 2451 { 2452 if (h->root.u.def.section->owner != NULL 2453 && (bfd_get_flavour (h->root.u.def.section->owner) 2454 == bfd_target_elf_flavour)) 2455 { 2456 h->ref_regular = 1; 2457 h->ref_regular_nonweak = 1; 2458 } 2459 else 2460 h->def_regular = 1; 2461 } 2462 2463 if (h->dynindx == -1 2464 && (h->def_dynamic 2465 || h->ref_dynamic)) 2466 { 2467 if (! bfd_elf_link_record_dynamic_symbol (eif->info, h)) 2468 { 2469 eif->failed = TRUE; 2470 return FALSE; 2471 } 2472 } 2473 } 2474 else 2475 { 2476 /* Unfortunately, NON_ELF is only correct if the symbol 2477 was first seen in a non-ELF file. Fortunately, if the symbol 2478 was first seen in an ELF file, we're probably OK unless the 2479 symbol was defined in a non-ELF file. Catch that case here. 2480 FIXME: We're still in trouble if the symbol was first seen in 2481 a dynamic object, and then later in a non-ELF regular object. */ 2482 if ((h->root.type == bfd_link_hash_defined 2483 || h->root.type == bfd_link_hash_defweak) 2484 && !h->def_regular 2485 && (h->root.u.def.section->owner != NULL 2486 ? (bfd_get_flavour (h->root.u.def.section->owner) 2487 != bfd_target_elf_flavour) 2488 : (bfd_is_abs_section (h->root.u.def.section) 2489 && !h->def_dynamic))) 2490 h->def_regular = 1; 2491 } 2492 2493 /* Backend specific symbol fixup. */ 2494 bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj); 2495 if (bed->elf_backend_fixup_symbol 2496 && !(*bed->elf_backend_fixup_symbol) (eif->info, h)) 2497 return FALSE; 2498 2499 /* If this is a final link, and the symbol was defined as a common 2500 symbol in a regular object file, and there was no definition in 2501 any dynamic object, then the linker will have allocated space for 2502 the symbol in a common section but the DEF_REGULAR 2503 flag will not have been set. */ 2504 if (h->root.type == bfd_link_hash_defined 2505 && !h->def_regular 2506 && h->ref_regular 2507 && !h->def_dynamic 2508 && (h->root.u.def.section->owner->flags & DYNAMIC) == 0) 2509 h->def_regular = 1; 2510 2511 /* If -Bsymbolic was used (which means to bind references to global 2512 symbols to the definition within the shared object), and this 2513 symbol was defined in a regular object, then it actually doesn't 2514 need a PLT entry. Likewise, if the symbol has non-default 2515 visibility. If the symbol has hidden or internal visibility, we 2516 will force it local. */ 2517 if (h->needs_plt 2518 && eif->info->shared 2519 && is_elf_hash_table (eif->info->hash) 2520 && (SYMBOLIC_BIND (eif->info, h) 2521 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) 2522 && h->def_regular) 2523 { 2524 bfd_boolean force_local; 2525 2526 force_local = (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL 2527 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN); 2528 (*bed->elf_backend_hide_symbol) (eif->info, h, force_local); 2529 } 2530 2531 /* If a weak undefined symbol has non-default visibility, we also 2532 hide it from the dynamic linker. */ 2533 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 2534 && h->root.type == bfd_link_hash_undefweak) 2535 (*bed->elf_backend_hide_symbol) (eif->info, h, TRUE); 2536 2537 /* If this is a weak defined symbol in a dynamic object, and we know 2538 the real definition in the dynamic object, copy interesting flags 2539 over to the real definition. */ 2540 if (h->u.weakdef != NULL) 2541 { 2542 struct elf_link_hash_entry *weakdef; 2543 2544 weakdef = h->u.weakdef; 2545 if (h->root.type == bfd_link_hash_indirect) 2546 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2547 2548 BFD_ASSERT (h->root.type == bfd_link_hash_defined 2549 || h->root.type == bfd_link_hash_defweak); 2550 BFD_ASSERT (weakdef->def_dynamic); 2551 2552 /* If the real definition is defined by a regular object file, 2553 don't do anything special. See the longer description in 2554 _bfd_elf_adjust_dynamic_symbol, below. */ 2555 if (weakdef->def_regular) 2556 h->u.weakdef = NULL; 2557 else 2558 { 2559 BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined 2560 || weakdef->root.type == bfd_link_hash_defweak); 2561 (*bed->elf_backend_copy_indirect_symbol) (eif->info, weakdef, h); 2562 } 2563 } 2564 2565 return TRUE; 2566 } 2567 2568 /* Make the backend pick a good value for a dynamic symbol. This is 2569 called via elf_link_hash_traverse, and also calls itself 2570 recursively. */ 2571 2572 static bfd_boolean 2573 _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data) 2574 { 2575 struct elf_info_failed *eif = (struct elf_info_failed *) data; 2576 bfd *dynobj; 2577 const struct elf_backend_data *bed; 2578 2579 if (! is_elf_hash_table (eif->info->hash)) 2580 return FALSE; 2581 2582 if (h->root.type == bfd_link_hash_warning) 2583 { 2584 h->got = elf_hash_table (eif->info)->init_got_offset; 2585 h->plt = elf_hash_table (eif->info)->init_plt_offset; 2586 2587 /* When warning symbols are created, they **replace** the "real" 2588 entry in the hash table, thus we never get to see the real 2589 symbol in a hash traversal. So look at it now. */ 2590 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2591 } 2592 2593 /* Ignore indirect symbols. These are added by the versioning code. */ 2594 if (h->root.type == bfd_link_hash_indirect) 2595 return TRUE; 2596 2597 /* Fix the symbol flags. */ 2598 if (! _bfd_elf_fix_symbol_flags (h, eif)) 2599 return FALSE; 2600 2601 /* If this symbol does not require a PLT entry, and it is not 2602 defined by a dynamic object, or is not referenced by a regular 2603 object, ignore it. We do have to handle a weak defined symbol, 2604 even if no regular object refers to it, if we decided to add it 2605 to the dynamic symbol table. FIXME: Do we normally need to worry 2606 about symbols which are defined by one dynamic object and 2607 referenced by another one? */ 2608 if (!h->needs_plt 2609 && h->type != STT_GNU_IFUNC 2610 && (h->def_regular 2611 || !h->def_dynamic 2612 || (!h->ref_regular 2613 && (h->u.weakdef == NULL || h->u.weakdef->dynindx == -1)))) 2614 { 2615 h->plt = elf_hash_table (eif->info)->init_plt_offset; 2616 return TRUE; 2617 } 2618 2619 /* If we've already adjusted this symbol, don't do it again. This 2620 can happen via a recursive call. */ 2621 if (h->dynamic_adjusted) 2622 return TRUE; 2623 2624 /* Don't look at this symbol again. Note that we must set this 2625 after checking the above conditions, because we may look at a 2626 symbol once, decide not to do anything, and then get called 2627 recursively later after REF_REGULAR is set below. */ 2628 h->dynamic_adjusted = 1; 2629 2630 /* If this is a weak definition, and we know a real definition, and 2631 the real symbol is not itself defined by a regular object file, 2632 then get a good value for the real definition. We handle the 2633 real symbol first, for the convenience of the backend routine. 2634 2635 Note that there is a confusing case here. If the real definition 2636 is defined by a regular object file, we don't get the real symbol 2637 from the dynamic object, but we do get the weak symbol. If the 2638 processor backend uses a COPY reloc, then if some routine in the 2639 dynamic object changes the real symbol, we will not see that 2640 change in the corresponding weak symbol. This is the way other 2641 ELF linkers work as well, and seems to be a result of the shared 2642 library model. 2643 2644 I will clarify this issue. Most SVR4 shared libraries define the 2645 variable _timezone and define timezone as a weak synonym. The 2646 tzset call changes _timezone. If you write 2647 extern int timezone; 2648 int _timezone = 5; 2649 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); } 2650 you might expect that, since timezone is a synonym for _timezone, 2651 the same number will print both times. However, if the processor 2652 backend uses a COPY reloc, then actually timezone will be copied 2653 into your process image, and, since you define _timezone 2654 yourself, _timezone will not. Thus timezone and _timezone will 2655 wind up at different memory locations. The tzset call will set 2656 _timezone, leaving timezone unchanged. */ 2657 2658 if (h->u.weakdef != NULL) 2659 { 2660 /* If we get to this point, we know there is an implicit 2661 reference by a regular object file via the weak symbol H. 2662 FIXME: Is this really true? What if the traversal finds 2663 H->U.WEAKDEF before it finds H? */ 2664 h->u.weakdef->ref_regular = 1; 2665 2666 if (! _bfd_elf_adjust_dynamic_symbol (h->u.weakdef, eif)) 2667 return FALSE; 2668 } 2669 2670 /* If a symbol has no type and no size and does not require a PLT 2671 entry, then we are probably about to do the wrong thing here: we 2672 are probably going to create a COPY reloc for an empty object. 2673 This case can arise when a shared object is built with assembly 2674 code, and the assembly code fails to set the symbol type. */ 2675 if (h->size == 0 2676 && h->type == STT_NOTYPE 2677 && !h->needs_plt) 2678 (*_bfd_error_handler) 2679 (_("warning: type and size of dynamic symbol `%s' are not defined"), 2680 h->root.root.string); 2681 2682 dynobj = elf_hash_table (eif->info)->dynobj; 2683 bed = get_elf_backend_data (dynobj); 2684 2685 if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h)) 2686 { 2687 eif->failed = TRUE; 2688 return FALSE; 2689 } 2690 2691 return TRUE; 2692 } 2693 2694 /* Adjust the dynamic symbol, H, for copy in the dynamic bss section, 2695 DYNBSS. */ 2696 2697 bfd_boolean 2698 _bfd_elf_adjust_dynamic_copy (struct elf_link_hash_entry *h, 2699 asection *dynbss) 2700 { 2701 unsigned int power_of_two; 2702 bfd_vma mask; 2703 asection *sec = h->root.u.def.section; 2704 2705 /* The section aligment of definition is the maximum alignment 2706 requirement of symbols defined in the section. Since we don't 2707 know the symbol alignment requirement, we start with the 2708 maximum alignment and check low bits of the symbol address 2709 for the minimum alignment. */ 2710 power_of_two = bfd_get_section_alignment (sec->owner, sec); 2711 mask = ((bfd_vma) 1 << power_of_two) - 1; 2712 while ((h->root.u.def.value & mask) != 0) 2713 { 2714 mask >>= 1; 2715 --power_of_two; 2716 } 2717 2718 if (power_of_two > bfd_get_section_alignment (dynbss->owner, 2719 dynbss)) 2720 { 2721 /* Adjust the section alignment if needed. */ 2722 if (! bfd_set_section_alignment (dynbss->owner, dynbss, 2723 power_of_two)) 2724 return FALSE; 2725 } 2726 2727 /* We make sure that the symbol will be aligned properly. */ 2728 dynbss->size = BFD_ALIGN (dynbss->size, mask + 1); 2729 2730 /* Define the symbol as being at this point in DYNBSS. */ 2731 h->root.u.def.section = dynbss; 2732 h->root.u.def.value = dynbss->size; 2733 2734 /* Increment the size of DYNBSS to make room for the symbol. */ 2735 dynbss->size += h->size; 2736 2737 return TRUE; 2738 } 2739 2740 /* Adjust all external symbols pointing into SEC_MERGE sections 2741 to reflect the object merging within the sections. */ 2742 2743 static bfd_boolean 2744 _bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry *h, void *data) 2745 { 2746 asection *sec; 2747 2748 if (h->root.type == bfd_link_hash_warning) 2749 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2750 2751 if ((h->root.type == bfd_link_hash_defined 2752 || h->root.type == bfd_link_hash_defweak) 2753 && ((sec = h->root.u.def.section)->flags & SEC_MERGE) 2754 && sec->sec_info_type == ELF_INFO_TYPE_MERGE) 2755 { 2756 bfd *output_bfd = (bfd *) data; 2757 2758 h->root.u.def.value = 2759 _bfd_merged_section_offset (output_bfd, 2760 &h->root.u.def.section, 2761 elf_section_data (sec)->sec_info, 2762 h->root.u.def.value); 2763 } 2764 2765 return TRUE; 2766 } 2767 2768 /* Returns false if the symbol referred to by H should be considered 2769 to resolve local to the current module, and true if it should be 2770 considered to bind dynamically. */ 2771 2772 bfd_boolean 2773 _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h, 2774 struct bfd_link_info *info, 2775 bfd_boolean ignore_protected) 2776 { 2777 bfd_boolean binding_stays_local_p; 2778 const struct elf_backend_data *bed; 2779 struct elf_link_hash_table *hash_table; 2780 2781 if (h == NULL) 2782 return FALSE; 2783 2784 while (h->root.type == bfd_link_hash_indirect 2785 || h->root.type == bfd_link_hash_warning) 2786 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2787 2788 /* If it was forced local, then clearly it's not dynamic. */ 2789 if (h->dynindx == -1) 2790 return FALSE; 2791 if (h->forced_local) 2792 return FALSE; 2793 2794 /* Identify the cases where name binding rules say that a 2795 visible symbol resolves locally. */ 2796 binding_stays_local_p = info->executable || SYMBOLIC_BIND (info, h); 2797 2798 switch (ELF_ST_VISIBILITY (h->other)) 2799 { 2800 case STV_INTERNAL: 2801 case STV_HIDDEN: 2802 return FALSE; 2803 2804 case STV_PROTECTED: 2805 hash_table = elf_hash_table (info); 2806 if (!is_elf_hash_table (hash_table)) 2807 return FALSE; 2808 2809 bed = get_elf_backend_data (hash_table->dynobj); 2810 2811 /* Proper resolution for function pointer equality may require 2812 that these symbols perhaps be resolved dynamically, even though 2813 we should be resolving them to the current module. */ 2814 if (!ignore_protected || !bed->is_function_type (h->type)) 2815 binding_stays_local_p = TRUE; 2816 break; 2817 2818 default: 2819 break; 2820 } 2821 2822 /* If it isn't defined locally, then clearly it's dynamic. */ 2823 if (!h->def_regular) 2824 return TRUE; 2825 2826 /* Otherwise, the symbol is dynamic if binding rules don't tell 2827 us that it remains local. */ 2828 return !binding_stays_local_p; 2829 } 2830 2831 /* Return true if the symbol referred to by H should be considered 2832 to resolve local to the current module, and false otherwise. Differs 2833 from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of 2834 undefined symbols and weak symbols. */ 2835 2836 bfd_boolean 2837 _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry *h, 2838 struct bfd_link_info *info, 2839 bfd_boolean local_protected) 2840 { 2841 const struct elf_backend_data *bed; 2842 struct elf_link_hash_table *hash_table; 2843 2844 /* If it's a local sym, of course we resolve locally. */ 2845 if (h == NULL) 2846 return TRUE; 2847 2848 /* STV_HIDDEN or STV_INTERNAL ones must be local. */ 2849 if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN 2850 || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL) 2851 return TRUE; 2852 2853 /* Common symbols that become definitions don't get the DEF_REGULAR 2854 flag set, so test it first, and don't bail out. */ 2855 if (ELF_COMMON_DEF_P (h)) 2856 /* Do nothing. */; 2857 /* If we don't have a definition in a regular file, then we can't 2858 resolve locally. The sym is either undefined or dynamic. */ 2859 else if (!h->def_regular) 2860 return FALSE; 2861 2862 /* Forced local symbols resolve locally. */ 2863 if (h->forced_local) 2864 return TRUE; 2865 2866 /* As do non-dynamic symbols. */ 2867 if (h->dynindx == -1) 2868 return TRUE; 2869 2870 /* At this point, we know the symbol is defined and dynamic. In an 2871 executable it must resolve locally, likewise when building symbolic 2872 shared libraries. */ 2873 if (info->executable || SYMBOLIC_BIND (info, h)) 2874 return TRUE; 2875 2876 /* Now deal with defined dynamic symbols in shared libraries. Ones 2877 with default visibility might not resolve locally. */ 2878 if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) 2879 return FALSE; 2880 2881 hash_table = elf_hash_table (info); 2882 if (!is_elf_hash_table (hash_table)) 2883 return TRUE; 2884 2885 bed = get_elf_backend_data (hash_table->dynobj); 2886 2887 /* STV_PROTECTED non-function symbols are local. */ 2888 if (!bed->is_function_type (h->type)) 2889 return TRUE; 2890 2891 /* Function pointer equality tests may require that STV_PROTECTED 2892 symbols be treated as dynamic symbols, even when we know that the 2893 dynamic linker will resolve them locally. */ 2894 return local_protected; 2895 } 2896 2897 /* Caches some TLS segment info, and ensures that the TLS segment vma is 2898 aligned. Returns the first TLS output section. */ 2899 2900 struct bfd_section * 2901 _bfd_elf_tls_setup (bfd *obfd, struct bfd_link_info *info) 2902 { 2903 struct bfd_section *sec, *tls; 2904 unsigned int align = 0; 2905 2906 for (sec = obfd->sections; sec != NULL; sec = sec->next) 2907 if ((sec->flags & SEC_THREAD_LOCAL) != 0) 2908 break; 2909 tls = sec; 2910 2911 for (; sec != NULL && (sec->flags & SEC_THREAD_LOCAL) != 0; sec = sec->next) 2912 if (sec->alignment_power > align) 2913 align = sec->alignment_power; 2914 2915 elf_hash_table (info)->tls_sec = tls; 2916 2917 /* Ensure the alignment of the first section is the largest alignment, 2918 so that the tls segment starts aligned. */ 2919 if (tls != NULL) 2920 tls->alignment_power = align; 2921 2922 return tls; 2923 } 2924 2925 /* Return TRUE iff this is a non-common, definition of a non-function symbol. */ 2926 static bfd_boolean 2927 is_global_data_symbol_definition (bfd *abfd ATTRIBUTE_UNUSED, 2928 Elf_Internal_Sym *sym) 2929 { 2930 const struct elf_backend_data *bed; 2931 2932 /* Local symbols do not count, but target specific ones might. */ 2933 if (ELF_ST_BIND (sym->st_info) != STB_GLOBAL 2934 && ELF_ST_BIND (sym->st_info) < STB_LOOS) 2935 return FALSE; 2936 2937 bed = get_elf_backend_data (abfd); 2938 /* Function symbols do not count. */ 2939 if (bed->is_function_type (ELF_ST_TYPE (sym->st_info))) 2940 return FALSE; 2941 2942 /* If the section is undefined, then so is the symbol. */ 2943 if (sym->st_shndx == SHN_UNDEF) 2944 return FALSE; 2945 2946 /* If the symbol is defined in the common section, then 2947 it is a common definition and so does not count. */ 2948 if (bed->common_definition (sym)) 2949 return FALSE; 2950 2951 /* If the symbol is in a target specific section then we 2952 must rely upon the backend to tell us what it is. */ 2953 if (sym->st_shndx >= SHN_LORESERVE && sym->st_shndx < SHN_ABS) 2954 /* FIXME - this function is not coded yet: 2955 2956 return _bfd_is_global_symbol_definition (abfd, sym); 2957 2958 Instead for now assume that the definition is not global, 2959 Even if this is wrong, at least the linker will behave 2960 in the same way that it used to do. */ 2961 return FALSE; 2962 2963 return TRUE; 2964 } 2965 2966 /* Search the symbol table of the archive element of the archive ABFD 2967 whose archive map contains a mention of SYMDEF, and determine if 2968 the symbol is defined in this element. */ 2969 static bfd_boolean 2970 elf_link_is_defined_archive_symbol (bfd * abfd, carsym * symdef) 2971 { 2972 Elf_Internal_Shdr * hdr; 2973 bfd_size_type symcount; 2974 bfd_size_type extsymcount; 2975 bfd_size_type extsymoff; 2976 Elf_Internal_Sym *isymbuf; 2977 Elf_Internal_Sym *isym; 2978 Elf_Internal_Sym *isymend; 2979 bfd_boolean result; 2980 2981 abfd = _bfd_get_elt_at_filepos (abfd, symdef->file_offset); 2982 if (abfd == NULL) 2983 return FALSE; 2984 2985 if (! bfd_check_format (abfd, bfd_object)) 2986 return FALSE; 2987 2988 /* If we have already included the element containing this symbol in the 2989 link then we do not need to include it again. Just claim that any symbol 2990 it contains is not a definition, so that our caller will not decide to 2991 (re)include this element. */ 2992 if (abfd->archive_pass) 2993 return FALSE; 2994 2995 /* Select the appropriate symbol table. */ 2996 if ((abfd->flags & DYNAMIC) == 0 || elf_dynsymtab (abfd) == 0) 2997 hdr = &elf_tdata (abfd)->symtab_hdr; 2998 else 2999 hdr = &elf_tdata (abfd)->dynsymtab_hdr; 3000 3001 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym; 3002 3003 /* The sh_info field of the symtab header tells us where the 3004 external symbols start. We don't care about the local symbols. */ 3005 if (elf_bad_symtab (abfd)) 3006 { 3007 extsymcount = symcount; 3008 extsymoff = 0; 3009 } 3010 else 3011 { 3012 extsymcount = symcount - hdr->sh_info; 3013 extsymoff = hdr->sh_info; 3014 } 3015 3016 if (extsymcount == 0) 3017 return FALSE; 3018 3019 /* Read in the symbol table. */ 3020 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff, 3021 NULL, NULL, NULL); 3022 if (isymbuf == NULL) 3023 return FALSE; 3024 3025 /* Scan the symbol table looking for SYMDEF. */ 3026 result = FALSE; 3027 for (isym = isymbuf, isymend = isymbuf + extsymcount; isym < isymend; isym++) 3028 { 3029 const char *name; 3030 3031 name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link, 3032 isym->st_name); 3033 if (name == NULL) 3034 break; 3035 3036 if (strcmp (name, symdef->name) == 0) 3037 { 3038 result = is_global_data_symbol_definition (abfd, isym); 3039 break; 3040 } 3041 } 3042 3043 free (isymbuf); 3044 3045 return result; 3046 } 3047 3048 /* Add an entry to the .dynamic table. */ 3049 3050 bfd_boolean 3051 _bfd_elf_add_dynamic_entry (struct bfd_link_info *info, 3052 bfd_vma tag, 3053 bfd_vma val) 3054 { 3055 struct elf_link_hash_table *hash_table; 3056 const struct elf_backend_data *bed; 3057 asection *s; 3058 bfd_size_type newsize; 3059 bfd_byte *newcontents; 3060 Elf_Internal_Dyn dyn; 3061 3062 hash_table = elf_hash_table (info); 3063 if (! is_elf_hash_table (hash_table)) 3064 return FALSE; 3065 3066 bed = get_elf_backend_data (hash_table->dynobj); 3067 s = bfd_get_section_by_name (hash_table->dynobj, ".dynamic"); 3068 BFD_ASSERT (s != NULL); 3069 3070 newsize = s->size + bed->s->sizeof_dyn; 3071 newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize); 3072 if (newcontents == NULL) 3073 return FALSE; 3074 3075 dyn.d_tag = tag; 3076 dyn.d_un.d_val = val; 3077 bed->s->swap_dyn_out (hash_table->dynobj, &dyn, newcontents + s->size); 3078 3079 s->size = newsize; 3080 s->contents = newcontents; 3081 3082 return TRUE; 3083 } 3084 3085 /* Add a DT_NEEDED entry for this dynamic object if DO_IT is true, 3086 otherwise just check whether one already exists. Returns -1 on error, 3087 1 if a DT_NEEDED tag already exists, and 0 on success. */ 3088 3089 static int 3090 elf_add_dt_needed_tag (bfd *abfd, 3091 struct bfd_link_info *info, 3092 const char *soname, 3093 bfd_boolean do_it) 3094 { 3095 struct elf_link_hash_table *hash_table; 3096 bfd_size_type oldsize; 3097 bfd_size_type strindex; 3098 3099 if (!_bfd_elf_link_create_dynstrtab (abfd, info)) 3100 return -1; 3101 3102 hash_table = elf_hash_table (info); 3103 oldsize = _bfd_elf_strtab_size (hash_table->dynstr); 3104 strindex = _bfd_elf_strtab_add (hash_table->dynstr, soname, FALSE); 3105 if (strindex == (bfd_size_type) -1) 3106 return -1; 3107 3108 if (oldsize == _bfd_elf_strtab_size (hash_table->dynstr)) 3109 { 3110 asection *sdyn; 3111 const struct elf_backend_data *bed; 3112 bfd_byte *extdyn; 3113 3114 bed = get_elf_backend_data (hash_table->dynobj); 3115 sdyn = bfd_get_section_by_name (hash_table->dynobj, ".dynamic"); 3116 if (sdyn != NULL) 3117 for (extdyn = sdyn->contents; 3118 extdyn < sdyn->contents + sdyn->size; 3119 extdyn += bed->s->sizeof_dyn) 3120 { 3121 Elf_Internal_Dyn dyn; 3122 3123 bed->s->swap_dyn_in (hash_table->dynobj, extdyn, &dyn); 3124 if (dyn.d_tag == DT_NEEDED 3125 && dyn.d_un.d_val == strindex) 3126 { 3127 _bfd_elf_strtab_delref (hash_table->dynstr, strindex); 3128 return 1; 3129 } 3130 } 3131 } 3132 3133 if (do_it) 3134 { 3135 if (!_bfd_elf_link_create_dynamic_sections (hash_table->dynobj, info)) 3136 return -1; 3137 3138 if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex)) 3139 return -1; 3140 } 3141 else 3142 /* We were just checking for existence of the tag. */ 3143 _bfd_elf_strtab_delref (hash_table->dynstr, strindex); 3144 3145 return 0; 3146 } 3147 3148 static bfd_boolean 3149 on_needed_list (const char *soname, struct bfd_link_needed_list *needed) 3150 { 3151 for (; needed != NULL; needed = needed->next) 3152 if (strcmp (soname, needed->name) == 0) 3153 return TRUE; 3154 3155 return FALSE; 3156 } 3157 3158 /* Sort symbol by value and section. */ 3159 static int 3160 elf_sort_symbol (const void *arg1, const void *arg2) 3161 { 3162 const struct elf_link_hash_entry *h1; 3163 const struct elf_link_hash_entry *h2; 3164 bfd_signed_vma vdiff; 3165 3166 h1 = *(const struct elf_link_hash_entry **) arg1; 3167 h2 = *(const struct elf_link_hash_entry **) arg2; 3168 vdiff = h1->root.u.def.value - h2->root.u.def.value; 3169 if (vdiff != 0) 3170 return vdiff > 0 ? 1 : -1; 3171 else 3172 { 3173 long sdiff = h1->root.u.def.section->id - h2->root.u.def.section->id; 3174 if (sdiff != 0) 3175 return sdiff > 0 ? 1 : -1; 3176 } 3177 return 0; 3178 } 3179 3180 /* This function is used to adjust offsets into .dynstr for 3181 dynamic symbols. This is called via elf_link_hash_traverse. */ 3182 3183 static bfd_boolean 3184 elf_adjust_dynstr_offsets (struct elf_link_hash_entry *h, void *data) 3185 { 3186 struct elf_strtab_hash *dynstr = (struct elf_strtab_hash *) data; 3187 3188 if (h->root.type == bfd_link_hash_warning) 3189 h = (struct elf_link_hash_entry *) h->root.u.i.link; 3190 3191 if (h->dynindx != -1) 3192 h->dynstr_index = _bfd_elf_strtab_offset (dynstr, h->dynstr_index); 3193 return TRUE; 3194 } 3195 3196 /* Assign string offsets in .dynstr, update all structures referencing 3197 them. */ 3198 3199 static bfd_boolean 3200 elf_finalize_dynstr (bfd *output_bfd, struct bfd_link_info *info) 3201 { 3202 struct elf_link_hash_table *hash_table = elf_hash_table (info); 3203 struct elf_link_local_dynamic_entry *entry; 3204 struct elf_strtab_hash *dynstr = hash_table->dynstr; 3205 bfd *dynobj = hash_table->dynobj; 3206 asection *sdyn; 3207 bfd_size_type size; 3208 const struct elf_backend_data *bed; 3209 bfd_byte *extdyn; 3210 3211 _bfd_elf_strtab_finalize (dynstr); 3212 size = _bfd_elf_strtab_size (dynstr); 3213 3214 bed = get_elf_backend_data (dynobj); 3215 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 3216 BFD_ASSERT (sdyn != NULL); 3217 3218 /* Update all .dynamic entries referencing .dynstr strings. */ 3219 for (extdyn = sdyn->contents; 3220 extdyn < sdyn->contents + sdyn->size; 3221 extdyn += bed->s->sizeof_dyn) 3222 { 3223 Elf_Internal_Dyn dyn; 3224 3225 bed->s->swap_dyn_in (dynobj, extdyn, &dyn); 3226 switch (dyn.d_tag) 3227 { 3228 case DT_STRSZ: 3229 dyn.d_un.d_val = size; 3230 break; 3231 case DT_NEEDED: 3232 case DT_SONAME: 3233 case DT_RPATH: 3234 case DT_RUNPATH: 3235 case DT_FILTER: 3236 case DT_AUXILIARY: 3237 dyn.d_un.d_val = _bfd_elf_strtab_offset (dynstr, dyn.d_un.d_val); 3238 break; 3239 default: 3240 continue; 3241 } 3242 bed->s->swap_dyn_out (dynobj, &dyn, extdyn); 3243 } 3244 3245 /* Now update local dynamic symbols. */ 3246 for (entry = hash_table->dynlocal; entry ; entry = entry->next) 3247 entry->isym.st_name = _bfd_elf_strtab_offset (dynstr, 3248 entry->isym.st_name); 3249 3250 /* And the rest of dynamic symbols. */ 3251 elf_link_hash_traverse (hash_table, elf_adjust_dynstr_offsets, dynstr); 3252 3253 /* Adjust version definitions. */ 3254 if (elf_tdata (output_bfd)->cverdefs) 3255 { 3256 asection *s; 3257 bfd_byte *p; 3258 bfd_size_type i; 3259 Elf_Internal_Verdef def; 3260 Elf_Internal_Verdaux defaux; 3261 3262 s = bfd_get_section_by_name (dynobj, ".gnu.version_d"); 3263 p = s->contents; 3264 do 3265 { 3266 _bfd_elf_swap_verdef_in (output_bfd, (Elf_External_Verdef *) p, 3267 &def); 3268 p += sizeof (Elf_External_Verdef); 3269 if (def.vd_aux != sizeof (Elf_External_Verdef)) 3270 continue; 3271 for (i = 0; i < def.vd_cnt; ++i) 3272 { 3273 _bfd_elf_swap_verdaux_in (output_bfd, 3274 (Elf_External_Verdaux *) p, &defaux); 3275 defaux.vda_name = _bfd_elf_strtab_offset (dynstr, 3276 defaux.vda_name); 3277 _bfd_elf_swap_verdaux_out (output_bfd, 3278 &defaux, (Elf_External_Verdaux *) p); 3279 p += sizeof (Elf_External_Verdaux); 3280 } 3281 } 3282 while (def.vd_next); 3283 } 3284 3285 /* Adjust version references. */ 3286 if (elf_tdata (output_bfd)->verref) 3287 { 3288 asection *s; 3289 bfd_byte *p; 3290 bfd_size_type i; 3291 Elf_Internal_Verneed need; 3292 Elf_Internal_Vernaux needaux; 3293 3294 s = bfd_get_section_by_name (dynobj, ".gnu.version_r"); 3295 p = s->contents; 3296 do 3297 { 3298 _bfd_elf_swap_verneed_in (output_bfd, (Elf_External_Verneed *) p, 3299 &need); 3300 need.vn_file = _bfd_elf_strtab_offset (dynstr, need.vn_file); 3301 _bfd_elf_swap_verneed_out (output_bfd, &need, 3302 (Elf_External_Verneed *) p); 3303 p += sizeof (Elf_External_Verneed); 3304 for (i = 0; i < need.vn_cnt; ++i) 3305 { 3306 _bfd_elf_swap_vernaux_in (output_bfd, 3307 (Elf_External_Vernaux *) p, &needaux); 3308 needaux.vna_name = _bfd_elf_strtab_offset (dynstr, 3309 needaux.vna_name); 3310 _bfd_elf_swap_vernaux_out (output_bfd, 3311 &needaux, 3312 (Elf_External_Vernaux *) p); 3313 p += sizeof (Elf_External_Vernaux); 3314 } 3315 } 3316 while (need.vn_next); 3317 } 3318 3319 return TRUE; 3320 } 3321 3322 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. 3323 The default is to only match when the INPUT and OUTPUT are exactly 3324 the same target. */ 3325 3326 bfd_boolean 3327 _bfd_elf_default_relocs_compatible (const bfd_target *input, 3328 const bfd_target *output) 3329 { 3330 return input == output; 3331 } 3332 3333 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. 3334 This version is used when different targets for the same architecture 3335 are virtually identical. */ 3336 3337 bfd_boolean 3338 _bfd_elf_relocs_compatible (const bfd_target *input, 3339 const bfd_target *output) 3340 { 3341 const struct elf_backend_data *obed, *ibed; 3342 3343 if (input == output) 3344 return TRUE; 3345 3346 ibed = xvec_get_elf_backend_data (input); 3347 obed = xvec_get_elf_backend_data (output); 3348 3349 if (ibed->arch != obed->arch) 3350 return FALSE; 3351 3352 /* If both backends are using this function, deem them compatible. */ 3353 return ibed->relocs_compatible == obed->relocs_compatible; 3354 } 3355 3356 /* Add symbols from an ELF object file to the linker hash table. */ 3357 3358 static bfd_boolean 3359 elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info) 3360 { 3361 Elf_Internal_Ehdr *ehdr; 3362 Elf_Internal_Shdr *hdr; 3363 bfd_size_type symcount; 3364 bfd_size_type extsymcount; 3365 bfd_size_type extsymoff; 3366 struct elf_link_hash_entry **sym_hash; 3367 bfd_boolean dynamic; 3368 Elf_External_Versym *extversym = NULL; 3369 Elf_External_Versym *ever; 3370 struct elf_link_hash_entry *weaks; 3371 struct elf_link_hash_entry **nondeflt_vers = NULL; 3372 bfd_size_type nondeflt_vers_cnt = 0; 3373 Elf_Internal_Sym *isymbuf = NULL; 3374 Elf_Internal_Sym *isym; 3375 Elf_Internal_Sym *isymend; 3376 const struct elf_backend_data *bed; 3377 bfd_boolean add_needed; 3378 struct elf_link_hash_table *htab; 3379 bfd_size_type amt; 3380 void *alloc_mark = NULL; 3381 struct bfd_hash_entry **old_table = NULL; 3382 unsigned int old_size = 0; 3383 unsigned int old_count = 0; 3384 void *old_tab = NULL; 3385 void *old_hash; 3386 void *old_ent; 3387 struct bfd_link_hash_entry *old_undefs = NULL; 3388 struct bfd_link_hash_entry *old_undefs_tail = NULL; 3389 long old_dynsymcount = 0; 3390 size_t tabsize = 0; 3391 size_t hashsize = 0; 3392 3393 htab = elf_hash_table (info); 3394 bed = get_elf_backend_data (abfd); 3395 3396 if ((abfd->flags & DYNAMIC) == 0) 3397 dynamic = FALSE; 3398 else 3399 { 3400 dynamic = TRUE; 3401 3402 /* You can't use -r against a dynamic object. Also, there's no 3403 hope of using a dynamic object which does not exactly match 3404 the format of the output file. */ 3405 if (info->relocatable 3406 || !is_elf_hash_table (htab) 3407 || info->output_bfd->xvec != abfd->xvec) 3408 { 3409 if (info->relocatable) 3410 bfd_set_error (bfd_error_invalid_operation); 3411 else 3412 bfd_set_error (bfd_error_wrong_format); 3413 goto error_return; 3414 } 3415 } 3416 3417 ehdr = elf_elfheader (abfd); 3418 if (info->warn_alternate_em 3419 && bed->elf_machine_code != ehdr->e_machine 3420 && ((bed->elf_machine_alt1 != 0 3421 && ehdr->e_machine == bed->elf_machine_alt1) 3422 || (bed->elf_machine_alt2 != 0 3423 && ehdr->e_machine == bed->elf_machine_alt2))) 3424 info->callbacks->einfo 3425 (_("%P: alternate ELF machine code found (%d) in %B, expecting %d\n"), 3426 ehdr->e_machine, abfd, bed->elf_machine_code); 3427 3428 /* As a GNU extension, any input sections which are named 3429 .gnu.warning.SYMBOL are treated as warning symbols for the given 3430 symbol. This differs from .gnu.warning sections, which generate 3431 warnings when they are included in an output file. */ 3432 if (info->executable) 3433 { 3434 asection *s; 3435 3436 for (s = abfd->sections; s != NULL; s = s->next) 3437 { 3438 const char *name; 3439 3440 name = bfd_get_section_name (abfd, s); 3441 if (CONST_STRNEQ (name, ".gnu.warning.")) 3442 { 3443 char *msg; 3444 bfd_size_type sz; 3445 3446 name += sizeof ".gnu.warning." - 1; 3447 3448 /* If this is a shared object, then look up the symbol 3449 in the hash table. If it is there, and it is already 3450 been defined, then we will not be using the entry 3451 from this shared object, so we don't need to warn. 3452 FIXME: If we see the definition in a regular object 3453 later on, we will warn, but we shouldn't. The only 3454 fix is to keep track of what warnings we are supposed 3455 to emit, and then handle them all at the end of the 3456 link. */ 3457 if (dynamic) 3458 { 3459 struct elf_link_hash_entry *h; 3460 3461 h = elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE); 3462 3463 /* FIXME: What about bfd_link_hash_common? */ 3464 if (h != NULL 3465 && (h->root.type == bfd_link_hash_defined 3466 || h->root.type == bfd_link_hash_defweak)) 3467 { 3468 /* We don't want to issue this warning. Clobber 3469 the section size so that the warning does not 3470 get copied into the output file. */ 3471 s->size = 0; 3472 continue; 3473 } 3474 } 3475 3476 sz = s->size; 3477 msg = (char *) bfd_alloc (abfd, sz + 1); 3478 if (msg == NULL) 3479 goto error_return; 3480 3481 if (! bfd_get_section_contents (abfd, s, msg, 0, sz)) 3482 goto error_return; 3483 3484 msg[sz] = '\0'; 3485 3486 if (! (_bfd_generic_link_add_one_symbol 3487 (info, abfd, name, BSF_WARNING, s, 0, msg, 3488 FALSE, bed->collect, NULL))) 3489 goto error_return; 3490 3491 if (! info->relocatable) 3492 { 3493 /* Clobber the section size so that the warning does 3494 not get copied into the output file. */ 3495 s->size = 0; 3496 3497 /* Also set SEC_EXCLUDE, so that symbols defined in 3498 the warning section don't get copied to the output. */ 3499 s->flags |= SEC_EXCLUDE; 3500 } 3501 } 3502 } 3503 } 3504 3505 add_needed = TRUE; 3506 if (! dynamic) 3507 { 3508 /* If we are creating a shared library, create all the dynamic 3509 sections immediately. We need to attach them to something, 3510 so we attach them to this BFD, provided it is the right 3511 format. FIXME: If there are no input BFD's of the same 3512 format as the output, we can't make a shared library. */ 3513 if (info->shared 3514 && is_elf_hash_table (htab) 3515 && info->output_bfd->xvec == abfd->xvec 3516 && !htab->dynamic_sections_created) 3517 { 3518 if (! _bfd_elf_link_create_dynamic_sections (abfd, info)) 3519 goto error_return; 3520 } 3521 } 3522 else if (!is_elf_hash_table (htab)) 3523 goto error_return; 3524 else 3525 { 3526 asection *s; 3527 const char *soname = NULL; 3528 struct bfd_link_needed_list *rpath = NULL, *runpath = NULL; 3529 int ret; 3530 3531 /* ld --just-symbols and dynamic objects don't mix very well. 3532 ld shouldn't allow it. */ 3533 if ((s = abfd->sections) != NULL 3534 && s->sec_info_type == ELF_INFO_TYPE_JUST_SYMS) 3535 abort (); 3536 3537 /* If this dynamic lib was specified on the command line with 3538 --as-needed in effect, then we don't want to add a DT_NEEDED 3539 tag unless the lib is actually used. Similary for libs brought 3540 in by another lib's DT_NEEDED. When --no-add-needed is used 3541 on a dynamic lib, we don't want to add a DT_NEEDED entry for 3542 any dynamic library in DT_NEEDED tags in the dynamic lib at 3543 all. */ 3544 add_needed = (elf_dyn_lib_class (abfd) 3545 & (DYN_AS_NEEDED | DYN_DT_NEEDED 3546 | DYN_NO_NEEDED)) == 0; 3547 3548 s = bfd_get_section_by_name (abfd, ".dynamic"); 3549 if (s != NULL) 3550 { 3551 bfd_byte *dynbuf; 3552 bfd_byte *extdyn; 3553 unsigned int elfsec; 3554 unsigned long shlink; 3555 3556 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf)) 3557 { 3558 error_free_dyn: 3559 free (dynbuf); 3560 goto error_return; 3561 } 3562 3563 elfsec = _bfd_elf_section_from_bfd_section (abfd, s); 3564 if (elfsec == SHN_BAD) 3565 goto error_free_dyn; 3566 shlink = elf_elfsections (abfd)[elfsec]->sh_link; 3567 3568 for (extdyn = dynbuf; 3569 extdyn < dynbuf + s->size; 3570 extdyn += bed->s->sizeof_dyn) 3571 { 3572 Elf_Internal_Dyn dyn; 3573 3574 bed->s->swap_dyn_in (abfd, extdyn, &dyn); 3575 if (dyn.d_tag == DT_SONAME) 3576 { 3577 unsigned int tagv = dyn.d_un.d_val; 3578 soname = bfd_elf_string_from_elf_section (abfd, shlink, tagv); 3579 if (soname == NULL) 3580 goto error_free_dyn; 3581 } 3582 if (dyn.d_tag == DT_NEEDED) 3583 { 3584 struct bfd_link_needed_list *n, **pn; 3585 char *fnm, *anm; 3586 unsigned int tagv = dyn.d_un.d_val; 3587 3588 amt = sizeof (struct bfd_link_needed_list); 3589 n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt); 3590 fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv); 3591 if (n == NULL || fnm == NULL) 3592 goto error_free_dyn; 3593 amt = strlen (fnm) + 1; 3594 anm = (char *) bfd_alloc (abfd, amt); 3595 if (anm == NULL) 3596 goto error_free_dyn; 3597 memcpy (anm, fnm, amt); 3598 n->name = anm; 3599 n->by = abfd; 3600 n->next = NULL; 3601 for (pn = &htab->needed; *pn != NULL; pn = &(*pn)->next) 3602 ; 3603 *pn = n; 3604 } 3605 if (dyn.d_tag == DT_RUNPATH) 3606 { 3607 struct bfd_link_needed_list *n, **pn; 3608 char *fnm, *anm; 3609 unsigned int tagv = dyn.d_un.d_val; 3610 3611 amt = sizeof (struct bfd_link_needed_list); 3612 n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt); 3613 fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv); 3614 if (n == NULL || fnm == NULL) 3615 goto error_free_dyn; 3616 amt = strlen (fnm) + 1; 3617 anm = (char *) bfd_alloc (abfd, amt); 3618 if (anm == NULL) 3619 goto error_free_dyn; 3620 memcpy (anm, fnm, amt); 3621 n->name = anm; 3622 n->by = abfd; 3623 n->next = NULL; 3624 for (pn = & runpath; 3625 *pn != NULL; 3626 pn = &(*pn)->next) 3627 ; 3628 *pn = n; 3629 } 3630 /* Ignore DT_RPATH if we have seen DT_RUNPATH. */ 3631 if (!runpath && dyn.d_tag == DT_RPATH) 3632 { 3633 struct bfd_link_needed_list *n, **pn; 3634 char *fnm, *anm; 3635 unsigned int tagv = dyn.d_un.d_val; 3636 3637 amt = sizeof (struct bfd_link_needed_list); 3638 n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt); 3639 fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv); 3640 if (n == NULL || fnm == NULL) 3641 goto error_free_dyn; 3642 amt = strlen (fnm) + 1; 3643 anm = (char *) bfd_alloc (abfd, amt); 3644 if (anm == NULL) 3645 goto error_free_dyn; 3646 memcpy (anm, fnm, amt); 3647 n->name = anm; 3648 n->by = abfd; 3649 n->next = NULL; 3650 for (pn = & rpath; 3651 *pn != NULL; 3652 pn = &(*pn)->next) 3653 ; 3654 *pn = n; 3655 } 3656 } 3657 3658 free (dynbuf); 3659 } 3660 3661 /* DT_RUNPATH overrides DT_RPATH. Do _NOT_ bfd_release, as that 3662 frees all more recently bfd_alloc'd blocks as well. */ 3663 if (runpath) 3664 rpath = runpath; 3665 3666 if (rpath) 3667 { 3668 struct bfd_link_needed_list **pn; 3669 for (pn = &htab->runpath; *pn != NULL; pn = &(*pn)->next) 3670 ; 3671 *pn = rpath; 3672 } 3673 3674 /* We do not want to include any of the sections in a dynamic 3675 object in the output file. We hack by simply clobbering the 3676 list of sections in the BFD. This could be handled more 3677 cleanly by, say, a new section flag; the existing 3678 SEC_NEVER_LOAD flag is not the one we want, because that one 3679 still implies that the section takes up space in the output 3680 file. */ 3681 bfd_section_list_clear (abfd); 3682 3683 /* Find the name to use in a DT_NEEDED entry that refers to this 3684 object. If the object has a DT_SONAME entry, we use it. 3685 Otherwise, if the generic linker stuck something in 3686 elf_dt_name, we use that. Otherwise, we just use the file 3687 name. */ 3688 if (soname == NULL || *soname == '\0') 3689 { 3690 soname = elf_dt_name (abfd); 3691 if (soname == NULL || *soname == '\0') 3692 soname = bfd_get_filename (abfd); 3693 } 3694 3695 /* Save the SONAME because sometimes the linker emulation code 3696 will need to know it. */ 3697 elf_dt_name (abfd) = soname; 3698 3699 ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed); 3700 if (ret < 0) 3701 goto error_return; 3702 3703 /* If we have already included this dynamic object in the 3704 link, just ignore it. There is no reason to include a 3705 particular dynamic object more than once. */ 3706 if (ret > 0) 3707 return TRUE; 3708 } 3709 3710 /* If this is a dynamic object, we always link against the .dynsym 3711 symbol table, not the .symtab symbol table. The dynamic linker 3712 will only see the .dynsym symbol table, so there is no reason to 3713 look at .symtab for a dynamic object. */ 3714 3715 if (! dynamic || elf_dynsymtab (abfd) == 0) 3716 hdr = &elf_tdata (abfd)->symtab_hdr; 3717 else 3718 hdr = &elf_tdata (abfd)->dynsymtab_hdr; 3719 3720 symcount = hdr->sh_size / bed->s->sizeof_sym; 3721 3722 /* The sh_info field of the symtab header tells us where the 3723 external symbols start. We don't care about the local symbols at 3724 this point. */ 3725 if (elf_bad_symtab (abfd)) 3726 { 3727 extsymcount = symcount; 3728 extsymoff = 0; 3729 } 3730 else 3731 { 3732 extsymcount = symcount - hdr->sh_info; 3733 extsymoff = hdr->sh_info; 3734 } 3735 3736 sym_hash = NULL; 3737 if (extsymcount != 0) 3738 { 3739 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff, 3740 NULL, NULL, NULL); 3741 if (isymbuf == NULL) 3742 goto error_return; 3743 3744 /* We store a pointer to the hash table entry for each external 3745 symbol. */ 3746 amt = extsymcount * sizeof (struct elf_link_hash_entry *); 3747 sym_hash = (struct elf_link_hash_entry **) bfd_alloc (abfd, amt); 3748 if (sym_hash == NULL) 3749 goto error_free_sym; 3750 elf_sym_hashes (abfd) = sym_hash; 3751 } 3752 3753 if (dynamic) 3754 { 3755 /* Read in any version definitions. */ 3756 if (!_bfd_elf_slurp_version_tables (abfd, 3757 info->default_imported_symver)) 3758 goto error_free_sym; 3759 3760 /* Read in the symbol versions, but don't bother to convert them 3761 to internal format. */ 3762 if (elf_dynversym (abfd) != 0) 3763 { 3764 Elf_Internal_Shdr *versymhdr; 3765 3766 versymhdr = &elf_tdata (abfd)->dynversym_hdr; 3767 extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size); 3768 if (extversym == NULL) 3769 goto error_free_sym; 3770 amt = versymhdr->sh_size; 3771 if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0 3772 || bfd_bread (extversym, amt, abfd) != amt) 3773 goto error_free_vers; 3774 } 3775 } 3776 3777 /* If we are loading an as-needed shared lib, save the symbol table 3778 state before we start adding symbols. If the lib turns out 3779 to be unneeded, restore the state. */ 3780 if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0) 3781 { 3782 unsigned int i; 3783 size_t entsize; 3784 3785 for (entsize = 0, i = 0; i < htab->root.table.size; i++) 3786 { 3787 struct bfd_hash_entry *p; 3788 struct elf_link_hash_entry *h; 3789 3790 for (p = htab->root.table.table[i]; p != NULL; p = p->next) 3791 { 3792 h = (struct elf_link_hash_entry *) p; 3793 entsize += htab->root.table.entsize; 3794 if (h->root.type == bfd_link_hash_warning) 3795 entsize += htab->root.table.entsize; 3796 } 3797 } 3798 3799 tabsize = htab->root.table.size * sizeof (struct bfd_hash_entry *); 3800 hashsize = extsymcount * sizeof (struct elf_link_hash_entry *); 3801 old_tab = bfd_malloc (tabsize + entsize + hashsize); 3802 if (old_tab == NULL) 3803 goto error_free_vers; 3804 3805 /* Remember the current objalloc pointer, so that all mem for 3806 symbols added can later be reclaimed. */ 3807 alloc_mark = bfd_hash_allocate (&htab->root.table, 1); 3808 if (alloc_mark == NULL) 3809 goto error_free_vers; 3810 3811 /* Make a special call to the linker "notice" function to 3812 tell it that we are about to handle an as-needed lib. */ 3813 if (!(*info->callbacks->notice) (info, NULL, abfd, NULL, 3814 notice_as_needed)) 3815 goto error_free_vers; 3816 3817 /* Clone the symbol table and sym hashes. Remember some 3818 pointers into the symbol table, and dynamic symbol count. */ 3819 old_hash = (char *) old_tab + tabsize; 3820 old_ent = (char *) old_hash + hashsize; 3821 memcpy (old_tab, htab->root.table.table, tabsize); 3822 memcpy (old_hash, sym_hash, hashsize); 3823 old_undefs = htab->root.undefs; 3824 old_undefs_tail = htab->root.undefs_tail; 3825 old_table = htab->root.table.table; 3826 old_size = htab->root.table.size; 3827 old_count = htab->root.table.count; 3828 old_dynsymcount = htab->dynsymcount; 3829 3830 for (i = 0; i < htab->root.table.size; i++) 3831 { 3832 struct bfd_hash_entry *p; 3833 struct elf_link_hash_entry *h; 3834 3835 for (p = htab->root.table.table[i]; p != NULL; p = p->next) 3836 { 3837 memcpy (old_ent, p, htab->root.table.entsize); 3838 old_ent = (char *) old_ent + htab->root.table.entsize; 3839 h = (struct elf_link_hash_entry *) p; 3840 if (h->root.type == bfd_link_hash_warning) 3841 { 3842 memcpy (old_ent, h->root.u.i.link, htab->root.table.entsize); 3843 old_ent = (char *) old_ent + htab->root.table.entsize; 3844 } 3845 } 3846 } 3847 } 3848 3849 weaks = NULL; 3850 ever = extversym != NULL ? extversym + extsymoff : NULL; 3851 for (isym = isymbuf, isymend = isymbuf + extsymcount; 3852 isym < isymend; 3853 isym++, sym_hash++, ever = (ever != NULL ? ever + 1 : NULL)) 3854 { 3855 int bind; 3856 bfd_vma value; 3857 asection *sec, *new_sec; 3858 flagword flags; 3859 const char *name; 3860 struct elf_link_hash_entry *h; 3861 bfd_boolean definition; 3862 bfd_boolean size_change_ok; 3863 bfd_boolean type_change_ok; 3864 bfd_boolean new_weakdef; 3865 bfd_boolean override; 3866 bfd_boolean common; 3867 unsigned int old_alignment; 3868 bfd *old_bfd; 3869 3870 override = FALSE; 3871 3872 flags = BSF_NO_FLAGS; 3873 sec = NULL; 3874 value = isym->st_value; 3875 *sym_hash = NULL; 3876 common = bed->common_definition (isym); 3877 3878 bind = ELF_ST_BIND (isym->st_info); 3879 switch (bind) 3880 { 3881 case STB_LOCAL: 3882 /* This should be impossible, since ELF requires that all 3883 global symbols follow all local symbols, and that sh_info 3884 point to the first global symbol. Unfortunately, Irix 5 3885 screws this up. */ 3886 continue; 3887 3888 case STB_GLOBAL: 3889 if (isym->st_shndx != SHN_UNDEF && !common) 3890 flags = BSF_GLOBAL; 3891 break; 3892 3893 case STB_WEAK: 3894 flags = BSF_WEAK; 3895 break; 3896 3897 case STB_GNU_UNIQUE: 3898 flags = BSF_GNU_UNIQUE; 3899 break; 3900 3901 default: 3902 /* Leave it up to the processor backend. */ 3903 break; 3904 } 3905 3906 if (isym->st_shndx == SHN_UNDEF) 3907 sec = bfd_und_section_ptr; 3908 else if (isym->st_shndx == SHN_ABS) 3909 sec = bfd_abs_section_ptr; 3910 else if (isym->st_shndx == SHN_COMMON) 3911 { 3912 sec = bfd_com_section_ptr; 3913 /* What ELF calls the size we call the value. What ELF 3914 calls the value we call the alignment. */ 3915 value = isym->st_size; 3916 } 3917 else 3918 { 3919 sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 3920 if (sec == NULL) 3921 sec = bfd_abs_section_ptr; 3922 else if (sec->kept_section) 3923 { 3924 /* Symbols from discarded section are undefined. We keep 3925 its visibility. */ 3926 sec = bfd_und_section_ptr; 3927 isym->st_shndx = SHN_UNDEF; 3928 } 3929 else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0) 3930 value -= sec->vma; 3931 } 3932 3933 name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link, 3934 isym->st_name); 3935 if (name == NULL) 3936 goto error_free_vers; 3937 3938 if (isym->st_shndx == SHN_COMMON 3939 && ELF_ST_TYPE (isym->st_info) == STT_TLS 3940 && !info->relocatable) 3941 { 3942 asection *tcomm = bfd_get_section_by_name (abfd, ".tcommon"); 3943 3944 if (tcomm == NULL) 3945 { 3946 tcomm = bfd_make_section_with_flags (abfd, ".tcommon", 3947 (SEC_ALLOC 3948 | SEC_IS_COMMON 3949 | SEC_LINKER_CREATED 3950 | SEC_THREAD_LOCAL)); 3951 if (tcomm == NULL) 3952 goto error_free_vers; 3953 } 3954 sec = tcomm; 3955 } 3956 else if (bed->elf_add_symbol_hook) 3957 { 3958 if (! (*bed->elf_add_symbol_hook) (abfd, info, isym, &name, &flags, 3959 &sec, &value)) 3960 goto error_free_vers; 3961 3962 /* The hook function sets the name to NULL if this symbol 3963 should be skipped for some reason. */ 3964 if (name == NULL) 3965 continue; 3966 } 3967 3968 /* Sanity check that all possibilities were handled. */ 3969 if (sec == NULL) 3970 { 3971 bfd_set_error (bfd_error_bad_value); 3972 goto error_free_vers; 3973 } 3974 3975 if (bfd_is_und_section (sec) 3976 || bfd_is_com_section (sec)) 3977 definition = FALSE; 3978 else 3979 definition = TRUE; 3980 3981 size_change_ok = FALSE; 3982 type_change_ok = bed->type_change_ok; 3983 old_alignment = 0; 3984 old_bfd = NULL; 3985 new_sec = sec; 3986 3987 if (is_elf_hash_table (htab)) 3988 { 3989 Elf_Internal_Versym iver; 3990 unsigned int vernum = 0; 3991 bfd_boolean skip; 3992 3993 if (ever == NULL) 3994 { 3995 if (info->default_imported_symver) 3996 /* Use the default symbol version created earlier. */ 3997 iver.vs_vers = elf_tdata (abfd)->cverdefs; 3998 else 3999 iver.vs_vers = 0; 4000 } 4001 else 4002 _bfd_elf_swap_versym_in (abfd, ever, &iver); 4003 4004 vernum = iver.vs_vers & VERSYM_VERSION; 4005 4006 /* If this is a hidden symbol, or if it is not version 4007 1, we append the version name to the symbol name. 4008 However, we do not modify a non-hidden absolute symbol 4009 if it is not a function, because it might be the version 4010 symbol itself. FIXME: What if it isn't? */ 4011 if ((iver.vs_vers & VERSYM_HIDDEN) != 0 4012 || (vernum > 1 4013 && (!bfd_is_abs_section (sec) 4014 || bed->is_function_type (ELF_ST_TYPE (isym->st_info))))) 4015 { 4016 const char *verstr; 4017 size_t namelen, verlen, newlen; 4018 char *newname, *p; 4019 4020 if (isym->st_shndx != SHN_UNDEF) 4021 { 4022 if (vernum > elf_tdata (abfd)->cverdefs) 4023 verstr = NULL; 4024 else if (vernum > 1) 4025 verstr = 4026 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename; 4027 else 4028 verstr = ""; 4029 4030 if (verstr == NULL) 4031 { 4032 (*_bfd_error_handler) 4033 (_("%B: %s: invalid version %u (max %d)"), 4034 abfd, name, vernum, 4035 elf_tdata (abfd)->cverdefs); 4036 bfd_set_error (bfd_error_bad_value); 4037 goto error_free_vers; 4038 } 4039 } 4040 else 4041 { 4042 /* We cannot simply test for the number of 4043 entries in the VERNEED section since the 4044 numbers for the needed versions do not start 4045 at 0. */ 4046 Elf_Internal_Verneed *t; 4047 4048 verstr = NULL; 4049 for (t = elf_tdata (abfd)->verref; 4050 t != NULL; 4051 t = t->vn_nextref) 4052 { 4053 Elf_Internal_Vernaux *a; 4054 4055 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr) 4056 { 4057 if (a->vna_other == vernum) 4058 { 4059 verstr = a->vna_nodename; 4060 break; 4061 } 4062 } 4063 if (a != NULL) 4064 break; 4065 } 4066 if (verstr == NULL) 4067 { 4068 (*_bfd_error_handler) 4069 (_("%B: %s: invalid needed version %d"), 4070 abfd, name, vernum); 4071 bfd_set_error (bfd_error_bad_value); 4072 goto error_free_vers; 4073 } 4074 } 4075 4076 namelen = strlen (name); 4077 verlen = strlen (verstr); 4078 newlen = namelen + verlen + 2; 4079 if ((iver.vs_vers & VERSYM_HIDDEN) == 0 4080 && isym->st_shndx != SHN_UNDEF) 4081 ++newlen; 4082 4083 newname = (char *) bfd_hash_allocate (&htab->root.table, newlen); 4084 if (newname == NULL) 4085 goto error_free_vers; 4086 memcpy (newname, name, namelen); 4087 p = newname + namelen; 4088 *p++ = ELF_VER_CHR; 4089 /* If this is a defined non-hidden version symbol, 4090 we add another @ to the name. This indicates the 4091 default version of the symbol. */ 4092 if ((iver.vs_vers & VERSYM_HIDDEN) == 0 4093 && isym->st_shndx != SHN_UNDEF) 4094 *p++ = ELF_VER_CHR; 4095 memcpy (p, verstr, verlen + 1); 4096 4097 name = newname; 4098 } 4099 4100 if (!_bfd_elf_merge_symbol (abfd, info, name, isym, &sec, 4101 &value, &old_alignment, 4102 sym_hash, &skip, &override, 4103 &type_change_ok, &size_change_ok)) 4104 goto error_free_vers; 4105 4106 if (skip) 4107 continue; 4108 4109 if (override) 4110 definition = FALSE; 4111 4112 h = *sym_hash; 4113 while (h->root.type == bfd_link_hash_indirect 4114 || h->root.type == bfd_link_hash_warning) 4115 h = (struct elf_link_hash_entry *) h->root.u.i.link; 4116 4117 /* Remember the old alignment if this is a common symbol, so 4118 that we don't reduce the alignment later on. We can't 4119 check later, because _bfd_generic_link_add_one_symbol 4120 will set a default for the alignment which we want to 4121 override. We also remember the old bfd where the existing 4122 definition comes from. */ 4123 switch (h->root.type) 4124 { 4125 default: 4126 break; 4127 4128 case bfd_link_hash_defined: 4129 case bfd_link_hash_defweak: 4130 old_bfd = h->root.u.def.section->owner; 4131 break; 4132 4133 case bfd_link_hash_common: 4134 old_bfd = h->root.u.c.p->section->owner; 4135 old_alignment = h->root.u.c.p->alignment_power; 4136 break; 4137 } 4138 4139 if (elf_tdata (abfd)->verdef != NULL 4140 && ! override 4141 && vernum > 1 4142 && definition) 4143 h->verinfo.verdef = &elf_tdata (abfd)->verdef[vernum - 1]; 4144 } 4145 4146 if (! (_bfd_generic_link_add_one_symbol 4147 (info, abfd, name, flags, sec, value, NULL, FALSE, bed->collect, 4148 (struct bfd_link_hash_entry **) sym_hash))) 4149 goto error_free_vers; 4150 4151 h = *sym_hash; 4152 while (h->root.type == bfd_link_hash_indirect 4153 || h->root.type == bfd_link_hash_warning) 4154 h = (struct elf_link_hash_entry *) h->root.u.i.link; 4155 4156 *sym_hash = h; 4157 h->unique_global = (flags & BSF_GNU_UNIQUE) != 0; 4158 4159 new_weakdef = FALSE; 4160 if (dynamic 4161 && definition 4162 && (flags & BSF_WEAK) != 0 4163 && !bed->is_function_type (ELF_ST_TYPE (isym->st_info)) 4164 && is_elf_hash_table (htab) 4165 && h->u.weakdef == NULL) 4166 { 4167 /* Keep a list of all weak defined non function symbols from 4168 a dynamic object, using the weakdef field. Later in this 4169 function we will set the weakdef field to the correct 4170 value. We only put non-function symbols from dynamic 4171 objects on this list, because that happens to be the only 4172 time we need to know the normal symbol corresponding to a 4173 weak symbol, and the information is time consuming to 4174 figure out. If the weakdef field is not already NULL, 4175 then this symbol was already defined by some previous 4176 dynamic object, and we will be using that previous 4177 definition anyhow. */ 4178 4179 h->u.weakdef = weaks; 4180 weaks = h; 4181 new_weakdef = TRUE; 4182 } 4183 4184 /* Set the alignment of a common symbol. */ 4185 if ((common || bfd_is_com_section (sec)) 4186 && h->root.type == bfd_link_hash_common) 4187 { 4188 unsigned int align; 4189 4190 if (common) 4191 align = bfd_log2 (isym->st_value); 4192 else 4193 { 4194 /* The new symbol is a common symbol in a shared object. 4195 We need to get the alignment from the section. */ 4196 align = new_sec->alignment_power; 4197 } 4198 if (align > old_alignment 4199 /* Permit an alignment power of zero if an alignment of one 4200 is specified and no other alignments have been specified. */ 4201 || (isym->st_value == 1 && old_alignment == 0)) 4202 h->root.u.c.p->alignment_power = align; 4203 else 4204 h->root.u.c.p->alignment_power = old_alignment; 4205 } 4206 4207 if (is_elf_hash_table (htab)) 4208 { 4209 bfd_boolean dynsym; 4210 4211 /* Check the alignment when a common symbol is involved. This 4212 can change when a common symbol is overridden by a normal 4213 definition or a common symbol is ignored due to the old 4214 normal definition. We need to make sure the maximum 4215 alignment is maintained. */ 4216 if ((old_alignment || common) 4217 && h->root.type != bfd_link_hash_common) 4218 { 4219 unsigned int common_align; 4220 unsigned int normal_align; 4221 unsigned int symbol_align; 4222 bfd *normal_bfd; 4223 bfd *common_bfd; 4224 4225 symbol_align = ffs (h->root.u.def.value) - 1; 4226 if (h->root.u.def.section->owner != NULL 4227 && (h->root.u.def.section->owner->flags & DYNAMIC) == 0) 4228 { 4229 normal_align = h->root.u.def.section->alignment_power; 4230 if (normal_align > symbol_align) 4231 normal_align = symbol_align; 4232 } 4233 else 4234 normal_align = symbol_align; 4235 4236 if (old_alignment) 4237 { 4238 common_align = old_alignment; 4239 common_bfd = old_bfd; 4240 normal_bfd = abfd; 4241 } 4242 else 4243 { 4244 common_align = bfd_log2 (isym->st_value); 4245 common_bfd = abfd; 4246 normal_bfd = old_bfd; 4247 } 4248 4249 if (normal_align < common_align) 4250 { 4251 /* PR binutils/2735 */ 4252 if (normal_bfd == NULL) 4253 (*_bfd_error_handler) 4254 (_("Warning: alignment %u of common symbol `%s' in %B" 4255 " is greater than the alignment (%u) of its section %A"), 4256 common_bfd, h->root.u.def.section, 4257 1 << common_align, name, 1 << normal_align); 4258 else 4259 (*_bfd_error_handler) 4260 (_("Warning: alignment %u of symbol `%s' in %B" 4261 " is smaller than %u in %B"), 4262 normal_bfd, common_bfd, 4263 1 << normal_align, name, 1 << common_align); 4264 } 4265 } 4266 4267 /* Remember the symbol size if it isn't undefined. */ 4268 if ((isym->st_size != 0 && isym->st_shndx != SHN_UNDEF) 4269 && (definition || h->size == 0)) 4270 { 4271 if (h->size != 0 4272 && h->size != isym->st_size 4273 && ! size_change_ok) 4274 (*_bfd_error_handler) 4275 (_("Warning: size of symbol `%s' changed" 4276 " from %lu in %B to %lu in %B"), 4277 old_bfd, abfd, 4278 name, (unsigned long) h->size, 4279 (unsigned long) isym->st_size); 4280 4281 h->size = isym->st_size; 4282 } 4283 4284 /* If this is a common symbol, then we always want H->SIZE 4285 to be the size of the common symbol. The code just above 4286 won't fix the size if a common symbol becomes larger. We 4287 don't warn about a size change here, because that is 4288 covered by --warn-common. Allow changed between different 4289 function types. */ 4290 if (h->root.type == bfd_link_hash_common) 4291 h->size = h->root.u.c.size; 4292 4293 if (ELF_ST_TYPE (isym->st_info) != STT_NOTYPE 4294 && (definition || h->type == STT_NOTYPE)) 4295 { 4296 unsigned int type = ELF_ST_TYPE (isym->st_info); 4297 4298 /* Turn an IFUNC symbol from a DSO into a normal FUNC 4299 symbol. */ 4300 if (type == STT_GNU_IFUNC 4301 && (abfd->flags & DYNAMIC) != 0) 4302 type = STT_FUNC; 4303 4304 if (h->type != type) 4305 { 4306 if (h->type != STT_NOTYPE && ! type_change_ok) 4307 (*_bfd_error_handler) 4308 (_("Warning: type of symbol `%s' changed" 4309 " from %d to %d in %B"), 4310 abfd, name, h->type, type); 4311 4312 h->type = type; 4313 } 4314 } 4315 4316 /* Merge st_other field. */ 4317 elf_merge_st_other (abfd, h, isym, definition, dynamic); 4318 4319 /* Set a flag in the hash table entry indicating the type of 4320 reference or definition we just found. Keep a count of 4321 the number of dynamic symbols we find. A dynamic symbol 4322 is one which is referenced or defined by both a regular 4323 object and a shared object. */ 4324 dynsym = FALSE; 4325 if (! dynamic) 4326 { 4327 if (! definition) 4328 { 4329 h->ref_regular = 1; 4330 if (bind != STB_WEAK) 4331 h->ref_regular_nonweak = 1; 4332 } 4333 else 4334 { 4335 h->def_regular = 1; 4336 if (h->def_dynamic) 4337 { 4338 h->def_dynamic = 0; 4339 h->ref_dynamic = 1; 4340 h->dynamic_def = 1; 4341 } 4342 } 4343 if (! info->executable 4344 || h->def_dynamic 4345 || h->ref_dynamic) 4346 dynsym = TRUE; 4347 } 4348 else 4349 { 4350 if (! definition) 4351 h->ref_dynamic = 1; 4352 else 4353 h->def_dynamic = 1; 4354 if (h->def_regular 4355 || h->ref_regular 4356 || (h->u.weakdef != NULL 4357 && ! new_weakdef 4358 && h->u.weakdef->dynindx != -1)) 4359 dynsym = TRUE; 4360 } 4361 4362 if (definition && (sec->flags & SEC_DEBUGGING) && !info->relocatable) 4363 { 4364 /* We don't want to make debug symbol dynamic. */ 4365 (*bed->elf_backend_hide_symbol) (info, h, TRUE); 4366 dynsym = FALSE; 4367 } 4368 4369 /* Check to see if we need to add an indirect symbol for 4370 the default name. */ 4371 if (definition || h->root.type == bfd_link_hash_common) 4372 if (!_bfd_elf_add_default_symbol (abfd, info, h, name, isym, 4373 &sec, &value, &dynsym, 4374 override)) 4375 goto error_free_vers; 4376 4377 if (definition && !dynamic) 4378 { 4379 char *p = strchr (name, ELF_VER_CHR); 4380 if (p != NULL && p[1] != ELF_VER_CHR) 4381 { 4382 /* Queue non-default versions so that .symver x, x@FOO 4383 aliases can be checked. */ 4384 if (!nondeflt_vers) 4385 { 4386 amt = ((isymend - isym + 1) 4387 * sizeof (struct elf_link_hash_entry *)); 4388 nondeflt_vers = 4389 (struct elf_link_hash_entry **) bfd_malloc (amt); 4390 if (!nondeflt_vers) 4391 goto error_free_vers; 4392 } 4393 nondeflt_vers[nondeflt_vers_cnt++] = h; 4394 } 4395 } 4396 4397 if (dynsym && h->dynindx == -1) 4398 { 4399 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 4400 goto error_free_vers; 4401 if (h->u.weakdef != NULL 4402 && ! new_weakdef 4403 && h->u.weakdef->dynindx == -1) 4404 { 4405 if (!bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef)) 4406 goto error_free_vers; 4407 } 4408 } 4409 else if (dynsym && h->dynindx != -1) 4410 /* If the symbol already has a dynamic index, but 4411 visibility says it should not be visible, turn it into 4412 a local symbol. */ 4413 switch (ELF_ST_VISIBILITY (h->other)) 4414 { 4415 case STV_INTERNAL: 4416 case STV_HIDDEN: 4417 (*bed->elf_backend_hide_symbol) (info, h, TRUE); 4418 dynsym = FALSE; 4419 break; 4420 } 4421 4422 if (!add_needed 4423 && definition 4424 && ((dynsym 4425 && h->ref_regular) 4426 || (h->ref_dynamic 4427 && (elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0 4428 && !on_needed_list (elf_dt_name (abfd), htab->needed)))) 4429 { 4430 int ret; 4431 const char *soname = elf_dt_name (abfd); 4432 4433 /* A symbol from a library loaded via DT_NEEDED of some 4434 other library is referenced by a regular object. 4435 Add a DT_NEEDED entry for it. Issue an error if 4436 --no-add-needed is used. */ 4437 if ((elf_dyn_lib_class (abfd) & DYN_NO_NEEDED) != 0) 4438 { 4439 (*_bfd_error_handler) 4440 (_("%s: invalid DSO for symbol `%s' definition"), 4441 abfd, name); 4442 bfd_set_error (bfd_error_bad_value); 4443 goto error_free_vers; 4444 } 4445 4446 elf_dyn_lib_class (abfd) = (enum dynamic_lib_link_class) 4447 (elf_dyn_lib_class (abfd) & ~DYN_AS_NEEDED); 4448 4449 add_needed = TRUE; 4450 ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed); 4451 if (ret < 0) 4452 goto error_free_vers; 4453 4454 BFD_ASSERT (ret == 0); 4455 } 4456 } 4457 } 4458 4459 if (extversym != NULL) 4460 { 4461 free (extversym); 4462 extversym = NULL; 4463 } 4464 4465 if (isymbuf != NULL) 4466 { 4467 free (isymbuf); 4468 isymbuf = NULL; 4469 } 4470 4471 if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0) 4472 { 4473 unsigned int i; 4474 4475 /* Restore the symbol table. */ 4476 if (bed->as_needed_cleanup) 4477 (*bed->as_needed_cleanup) (abfd, info); 4478 old_hash = (char *) old_tab + tabsize; 4479 old_ent = (char *) old_hash + hashsize; 4480 sym_hash = elf_sym_hashes (abfd); 4481 htab->root.table.table = old_table; 4482 htab->root.table.size = old_size; 4483 htab->root.table.count = old_count; 4484 memcpy (htab->root.table.table, old_tab, tabsize); 4485 memcpy (sym_hash, old_hash, hashsize); 4486 htab->root.undefs = old_undefs; 4487 htab->root.undefs_tail = old_undefs_tail; 4488 for (i = 0; i < htab->root.table.size; i++) 4489 { 4490 struct bfd_hash_entry *p; 4491 struct elf_link_hash_entry *h; 4492 4493 for (p = htab->root.table.table[i]; p != NULL; p = p->next) 4494 { 4495 h = (struct elf_link_hash_entry *) p; 4496 if (h->root.type == bfd_link_hash_warning) 4497 h = (struct elf_link_hash_entry *) h->root.u.i.link; 4498 if (h->dynindx >= old_dynsymcount) 4499 _bfd_elf_strtab_delref (htab->dynstr, h->dynstr_index); 4500 4501 memcpy (p, old_ent, htab->root.table.entsize); 4502 old_ent = (char *) old_ent + htab->root.table.entsize; 4503 h = (struct elf_link_hash_entry *) p; 4504 if (h->root.type == bfd_link_hash_warning) 4505 { 4506 memcpy (h->root.u.i.link, old_ent, htab->root.table.entsize); 4507 old_ent = (char *) old_ent + htab->root.table.entsize; 4508 } 4509 } 4510 } 4511 4512 /* Make a special call to the linker "notice" function to 4513 tell it that symbols added for crefs may need to be removed. */ 4514 if (!(*info->callbacks->notice) (info, NULL, abfd, NULL, 4515 notice_not_needed)) 4516 goto error_free_vers; 4517 4518 free (old_tab); 4519 objalloc_free_block ((struct objalloc *) htab->root.table.memory, 4520 alloc_mark); 4521 if (nondeflt_vers != NULL) 4522 free (nondeflt_vers); 4523 return TRUE; 4524 } 4525 4526 if (old_tab != NULL) 4527 { 4528 if (!(*info->callbacks->notice) (info, NULL, abfd, NULL, 4529 notice_needed)) 4530 goto error_free_vers; 4531 free (old_tab); 4532 old_tab = NULL; 4533 } 4534 4535 /* Now that all the symbols from this input file are created, handle 4536 .symver foo, foo@BAR such that any relocs against foo become foo@BAR. */ 4537 if (nondeflt_vers != NULL) 4538 { 4539 bfd_size_type cnt, symidx; 4540 4541 for (cnt = 0; cnt < nondeflt_vers_cnt; ++cnt) 4542 { 4543 struct elf_link_hash_entry *h = nondeflt_vers[cnt], *hi; 4544 char *shortname, *p; 4545 4546 p = strchr (h->root.root.string, ELF_VER_CHR); 4547 if (p == NULL 4548 || (h->root.type != bfd_link_hash_defined 4549 && h->root.type != bfd_link_hash_defweak)) 4550 continue; 4551 4552 amt = p - h->root.root.string; 4553 shortname = (char *) bfd_malloc (amt + 1); 4554 if (!shortname) 4555 goto error_free_vers; 4556 memcpy (shortname, h->root.root.string, amt); 4557 shortname[amt] = '\0'; 4558 4559 hi = (struct elf_link_hash_entry *) 4560 bfd_link_hash_lookup (&htab->root, shortname, 4561 FALSE, FALSE, FALSE); 4562 if (hi != NULL 4563 && hi->root.type == h->root.type 4564 && hi->root.u.def.value == h->root.u.def.value 4565 && hi->root.u.def.section == h->root.u.def.section) 4566 { 4567 (*bed->elf_backend_hide_symbol) (info, hi, TRUE); 4568 hi->root.type = bfd_link_hash_indirect; 4569 hi->root.u.i.link = (struct bfd_link_hash_entry *) h; 4570 (*bed->elf_backend_copy_indirect_symbol) (info, h, hi); 4571 sym_hash = elf_sym_hashes (abfd); 4572 if (sym_hash) 4573 for (symidx = 0; symidx < extsymcount; ++symidx) 4574 if (sym_hash[symidx] == hi) 4575 { 4576 sym_hash[symidx] = h; 4577 break; 4578 } 4579 } 4580 free (shortname); 4581 } 4582 free (nondeflt_vers); 4583 nondeflt_vers = NULL; 4584 } 4585 4586 /* Now set the weakdefs field correctly for all the weak defined 4587 symbols we found. The only way to do this is to search all the 4588 symbols. Since we only need the information for non functions in 4589 dynamic objects, that's the only time we actually put anything on 4590 the list WEAKS. We need this information so that if a regular 4591 object refers to a symbol defined weakly in a dynamic object, the 4592 real symbol in the dynamic object is also put in the dynamic 4593 symbols; we also must arrange for both symbols to point to the 4594 same memory location. We could handle the general case of symbol 4595 aliasing, but a general symbol alias can only be generated in 4596 assembler code, handling it correctly would be very time 4597 consuming, and other ELF linkers don't handle general aliasing 4598 either. */ 4599 if (weaks != NULL) 4600 { 4601 struct elf_link_hash_entry **hpp; 4602 struct elf_link_hash_entry **hppend; 4603 struct elf_link_hash_entry **sorted_sym_hash; 4604 struct elf_link_hash_entry *h; 4605 size_t sym_count; 4606 4607 /* Since we have to search the whole symbol list for each weak 4608 defined symbol, search time for N weak defined symbols will be 4609 O(N^2). Binary search will cut it down to O(NlogN). */ 4610 amt = extsymcount * sizeof (struct elf_link_hash_entry *); 4611 sorted_sym_hash = (struct elf_link_hash_entry **) bfd_malloc (amt); 4612 if (sorted_sym_hash == NULL) 4613 goto error_return; 4614 sym_hash = sorted_sym_hash; 4615 hpp = elf_sym_hashes (abfd); 4616 hppend = hpp + extsymcount; 4617 sym_count = 0; 4618 for (; hpp < hppend; hpp++) 4619 { 4620 h = *hpp; 4621 if (h != NULL 4622 && h->root.type == bfd_link_hash_defined 4623 && !bed->is_function_type (h->type)) 4624 { 4625 *sym_hash = h; 4626 sym_hash++; 4627 sym_count++; 4628 } 4629 } 4630 4631 qsort (sorted_sym_hash, sym_count, 4632 sizeof (struct elf_link_hash_entry *), 4633 elf_sort_symbol); 4634 4635 while (weaks != NULL) 4636 { 4637 struct elf_link_hash_entry *hlook; 4638 asection *slook; 4639 bfd_vma vlook; 4640 long ilook; 4641 size_t i, j, idx; 4642 4643 hlook = weaks; 4644 weaks = hlook->u.weakdef; 4645 hlook->u.weakdef = NULL; 4646 4647 BFD_ASSERT (hlook->root.type == bfd_link_hash_defined 4648 || hlook->root.type == bfd_link_hash_defweak 4649 || hlook->root.type == bfd_link_hash_common 4650 || hlook->root.type == bfd_link_hash_indirect); 4651 slook = hlook->root.u.def.section; 4652 vlook = hlook->root.u.def.value; 4653 4654 ilook = -1; 4655 i = 0; 4656 j = sym_count; 4657 while (i < j) 4658 { 4659 bfd_signed_vma vdiff; 4660 idx = (i + j) / 2; 4661 h = sorted_sym_hash [idx]; 4662 vdiff = vlook - h->root.u.def.value; 4663 if (vdiff < 0) 4664 j = idx; 4665 else if (vdiff > 0) 4666 i = idx + 1; 4667 else 4668 { 4669 long sdiff = slook->id - h->root.u.def.section->id; 4670 if (sdiff < 0) 4671 j = idx; 4672 else if (sdiff > 0) 4673 i = idx + 1; 4674 else 4675 { 4676 ilook = idx; 4677 break; 4678 } 4679 } 4680 } 4681 4682 /* We didn't find a value/section match. */ 4683 if (ilook == -1) 4684 continue; 4685 4686 for (i = ilook; i < sym_count; i++) 4687 { 4688 h = sorted_sym_hash [i]; 4689 4690 /* Stop if value or section doesn't match. */ 4691 if (h->root.u.def.value != vlook 4692 || h->root.u.def.section != slook) 4693 break; 4694 else if (h != hlook) 4695 { 4696 hlook->u.weakdef = h; 4697 4698 /* If the weak definition is in the list of dynamic 4699 symbols, make sure the real definition is put 4700 there as well. */ 4701 if (hlook->dynindx != -1 && h->dynindx == -1) 4702 { 4703 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 4704 { 4705 err_free_sym_hash: 4706 free (sorted_sym_hash); 4707 goto error_return; 4708 } 4709 } 4710 4711 /* If the real definition is in the list of dynamic 4712 symbols, make sure the weak definition is put 4713 there as well. If we don't do this, then the 4714 dynamic loader might not merge the entries for the 4715 real definition and the weak definition. */ 4716 if (h->dynindx != -1 && hlook->dynindx == -1) 4717 { 4718 if (! bfd_elf_link_record_dynamic_symbol (info, hlook)) 4719 goto err_free_sym_hash; 4720 } 4721 break; 4722 } 4723 } 4724 } 4725 4726 free (sorted_sym_hash); 4727 } 4728 4729 if (bed->check_directives 4730 && !(*bed->check_directives) (abfd, info)) 4731 return FALSE; 4732 4733 /* If this object is the same format as the output object, and it is 4734 not a shared library, then let the backend look through the 4735 relocs. 4736 4737 This is required to build global offset table entries and to 4738 arrange for dynamic relocs. It is not required for the 4739 particular common case of linking non PIC code, even when linking 4740 against shared libraries, but unfortunately there is no way of 4741 knowing whether an object file has been compiled PIC or not. 4742 Looking through the relocs is not particularly time consuming. 4743 The problem is that we must either (1) keep the relocs in memory, 4744 which causes the linker to require additional runtime memory or 4745 (2) read the relocs twice from the input file, which wastes time. 4746 This would be a good case for using mmap. 4747 4748 I have no idea how to handle linking PIC code into a file of a 4749 different format. It probably can't be done. */ 4750 if (! dynamic 4751 && is_elf_hash_table (htab) 4752 && bed->check_relocs != NULL 4753 && (*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec)) 4754 { 4755 asection *o; 4756 4757 for (o = abfd->sections; o != NULL; o = o->next) 4758 { 4759 Elf_Internal_Rela *internal_relocs; 4760 bfd_boolean ok; 4761 4762 if ((o->flags & SEC_RELOC) == 0 4763 || o->reloc_count == 0 4764 || ((info->strip == strip_all || info->strip == strip_debugger) 4765 && (o->flags & SEC_DEBUGGING) != 0) 4766 || bfd_is_abs_section (o->output_section)) 4767 continue; 4768 4769 internal_relocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL, 4770 info->keep_memory); 4771 if (internal_relocs == NULL) 4772 goto error_return; 4773 4774 ok = (*bed->check_relocs) (abfd, info, o, internal_relocs); 4775 4776 if (elf_section_data (o)->relocs != internal_relocs) 4777 free (internal_relocs); 4778 4779 if (! ok) 4780 goto error_return; 4781 } 4782 } 4783 4784 /* If this is a non-traditional link, try to optimize the handling 4785 of the .stab/.stabstr sections. */ 4786 if (! dynamic 4787 && ! info->traditional_format 4788 && is_elf_hash_table (htab) 4789 && (info->strip != strip_all && info->strip != strip_debugger)) 4790 { 4791 asection *stabstr; 4792 4793 stabstr = bfd_get_section_by_name (abfd, ".stabstr"); 4794 if (stabstr != NULL) 4795 { 4796 bfd_size_type string_offset = 0; 4797 asection *stab; 4798 4799 for (stab = abfd->sections; stab; stab = stab->next) 4800 if (CONST_STRNEQ (stab->name, ".stab") 4801 && (!stab->name[5] || 4802 (stab->name[5] == '.' && ISDIGIT (stab->name[6]))) 4803 && (stab->flags & SEC_MERGE) == 0 4804 && !bfd_is_abs_section (stab->output_section)) 4805 { 4806 struct bfd_elf_section_data *secdata; 4807 4808 secdata = elf_section_data (stab); 4809 if (! _bfd_link_section_stabs (abfd, &htab->stab_info, stab, 4810 stabstr, &secdata->sec_info, 4811 &string_offset)) 4812 goto error_return; 4813 if (secdata->sec_info) 4814 stab->sec_info_type = ELF_INFO_TYPE_STABS; 4815 } 4816 } 4817 } 4818 4819 if (is_elf_hash_table (htab) && add_needed) 4820 { 4821 /* Add this bfd to the loaded list. */ 4822 struct elf_link_loaded_list *n; 4823 4824 n = (struct elf_link_loaded_list *) 4825 bfd_alloc (abfd, sizeof (struct elf_link_loaded_list)); 4826 if (n == NULL) 4827 goto error_return; 4828 n->abfd = abfd; 4829 n->next = htab->loaded; 4830 htab->loaded = n; 4831 } 4832 4833 return TRUE; 4834 4835 error_free_vers: 4836 if (old_tab != NULL) 4837 free (old_tab); 4838 if (nondeflt_vers != NULL) 4839 free (nondeflt_vers); 4840 if (extversym != NULL) 4841 free (extversym); 4842 error_free_sym: 4843 if (isymbuf != NULL) 4844 free (isymbuf); 4845 error_return: 4846 return FALSE; 4847 } 4848 4849 /* Return the linker hash table entry of a symbol that might be 4850 satisfied by an archive symbol. Return -1 on error. */ 4851 4852 struct elf_link_hash_entry * 4853 _bfd_elf_archive_symbol_lookup (bfd *abfd, 4854 struct bfd_link_info *info, 4855 const char *name) 4856 { 4857 struct elf_link_hash_entry *h; 4858 char *p, *copy; 4859 size_t len, first; 4860 4861 h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE); 4862 if (h != NULL) 4863 return h; 4864 4865 /* If this is a default version (the name contains @@), look up the 4866 symbol again with only one `@' as well as without the version. 4867 The effect is that references to the symbol with and without the 4868 version will be matched by the default symbol in the archive. */ 4869 4870 p = strchr (name, ELF_VER_CHR); 4871 if (p == NULL || p[1] != ELF_VER_CHR) 4872 return h; 4873 4874 /* First check with only one `@'. */ 4875 len = strlen (name); 4876 copy = (char *) bfd_alloc (abfd, len); 4877 if (copy == NULL) 4878 return (struct elf_link_hash_entry *) 0 - 1; 4879 4880 first = p - name + 1; 4881 memcpy (copy, name, first); 4882 memcpy (copy + first, name + first + 1, len - first); 4883 4884 h = elf_link_hash_lookup (elf_hash_table (info), copy, FALSE, FALSE, FALSE); 4885 if (h == NULL) 4886 { 4887 /* We also need to check references to the symbol without the 4888 version. */ 4889 copy[first - 1] = '\0'; 4890 h = elf_link_hash_lookup (elf_hash_table (info), copy, 4891 FALSE, FALSE, FALSE); 4892 } 4893 4894 bfd_release (abfd, copy); 4895 return h; 4896 } 4897 4898 /* Add symbols from an ELF archive file to the linker hash table. We 4899 don't use _bfd_generic_link_add_archive_symbols because of a 4900 problem which arises on UnixWare. The UnixWare libc.so is an 4901 archive which includes an entry libc.so.1 which defines a bunch of 4902 symbols. The libc.so archive also includes a number of other 4903 object files, which also define symbols, some of which are the same 4904 as those defined in libc.so.1. Correct linking requires that we 4905 consider each object file in turn, and include it if it defines any 4906 symbols we need. _bfd_generic_link_add_archive_symbols does not do 4907 this; it looks through the list of undefined symbols, and includes 4908 any object file which defines them. When this algorithm is used on 4909 UnixWare, it winds up pulling in libc.so.1 early and defining a 4910 bunch of symbols. This means that some of the other objects in the 4911 archive are not included in the link, which is incorrect since they 4912 precede libc.so.1 in the archive. 4913 4914 Fortunately, ELF archive handling is simpler than that done by 4915 _bfd_generic_link_add_archive_symbols, which has to allow for a.out 4916 oddities. In ELF, if we find a symbol in the archive map, and the 4917 symbol is currently undefined, we know that we must pull in that 4918 object file. 4919 4920 Unfortunately, we do have to make multiple passes over the symbol 4921 table until nothing further is resolved. */ 4922 4923 static bfd_boolean 4924 elf_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info) 4925 { 4926 symindex c; 4927 bfd_boolean *defined = NULL; 4928 bfd_boolean *included = NULL; 4929 carsym *symdefs; 4930 bfd_boolean loop; 4931 bfd_size_type amt; 4932 const struct elf_backend_data *bed; 4933 struct elf_link_hash_entry * (*archive_symbol_lookup) 4934 (bfd *, struct bfd_link_info *, const char *); 4935 4936 if (! bfd_has_map (abfd)) 4937 { 4938 /* An empty archive is a special case. */ 4939 if (bfd_openr_next_archived_file (abfd, NULL) == NULL) 4940 return TRUE; 4941 bfd_set_error (bfd_error_no_armap); 4942 return FALSE; 4943 } 4944 4945 /* Keep track of all symbols we know to be already defined, and all 4946 files we know to be already included. This is to speed up the 4947 second and subsequent passes. */ 4948 c = bfd_ardata (abfd)->symdef_count; 4949 if (c == 0) 4950 return TRUE; 4951 amt = c; 4952 amt *= sizeof (bfd_boolean); 4953 defined = (bfd_boolean *) bfd_zmalloc (amt); 4954 included = (bfd_boolean *) bfd_zmalloc (amt); 4955 if (defined == NULL || included == NULL) 4956 goto error_return; 4957 4958 symdefs = bfd_ardata (abfd)->symdefs; 4959 bed = get_elf_backend_data (abfd); 4960 archive_symbol_lookup = bed->elf_backend_archive_symbol_lookup; 4961 4962 do 4963 { 4964 file_ptr last; 4965 symindex i; 4966 carsym *symdef; 4967 carsym *symdefend; 4968 4969 loop = FALSE; 4970 last = -1; 4971 4972 symdef = symdefs; 4973 symdefend = symdef + c; 4974 for (i = 0; symdef < symdefend; symdef++, i++) 4975 { 4976 struct elf_link_hash_entry *h; 4977 bfd *element; 4978 struct bfd_link_hash_entry *undefs_tail; 4979 symindex mark; 4980 4981 if (defined[i] || included[i]) 4982 continue; 4983 if (symdef->file_offset == last) 4984 { 4985 included[i] = TRUE; 4986 continue; 4987 } 4988 4989 h = archive_symbol_lookup (abfd, info, symdef->name); 4990 if (h == (struct elf_link_hash_entry *) 0 - 1) 4991 goto error_return; 4992 4993 if (h == NULL) 4994 continue; 4995 4996 if (h->root.type == bfd_link_hash_common) 4997 { 4998 /* We currently have a common symbol. The archive map contains 4999 a reference to this symbol, so we may want to include it. We 5000 only want to include it however, if this archive element 5001 contains a definition of the symbol, not just another common 5002 declaration of it. 5003 5004 Unfortunately some archivers (including GNU ar) will put 5005 declarations of common symbols into their archive maps, as 5006 well as real definitions, so we cannot just go by the archive 5007 map alone. Instead we must read in the element's symbol 5008 table and check that to see what kind of symbol definition 5009 this is. */ 5010 if (! elf_link_is_defined_archive_symbol (abfd, symdef)) 5011 continue; 5012 } 5013 else if (h->root.type != bfd_link_hash_undefined) 5014 { 5015 if (h->root.type != bfd_link_hash_undefweak) 5016 defined[i] = TRUE; 5017 continue; 5018 } 5019 5020 /* We need to include this archive member. */ 5021 element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset); 5022 if (element == NULL) 5023 goto error_return; 5024 5025 if (! bfd_check_format (element, bfd_object)) 5026 goto error_return; 5027 5028 /* Doublecheck that we have not included this object 5029 already--it should be impossible, but there may be 5030 something wrong with the archive. */ 5031 if (element->archive_pass != 0) 5032 { 5033 bfd_set_error (bfd_error_bad_value); 5034 goto error_return; 5035 } 5036 element->archive_pass = 1; 5037 5038 undefs_tail = info->hash->undefs_tail; 5039 5040 if (! (*info->callbacks->add_archive_element) (info, element, 5041 symdef->name)) 5042 goto error_return; 5043 if (! bfd_link_add_symbols (element, info)) 5044 goto error_return; 5045 5046 /* If there are any new undefined symbols, we need to make 5047 another pass through the archive in order to see whether 5048 they can be defined. FIXME: This isn't perfect, because 5049 common symbols wind up on undefs_tail and because an 5050 undefined symbol which is defined later on in this pass 5051 does not require another pass. This isn't a bug, but it 5052 does make the code less efficient than it could be. */ 5053 if (undefs_tail != info->hash->undefs_tail) 5054 loop = TRUE; 5055 5056 /* Look backward to mark all symbols from this object file 5057 which we have already seen in this pass. */ 5058 mark = i; 5059 do 5060 { 5061 included[mark] = TRUE; 5062 if (mark == 0) 5063 break; 5064 --mark; 5065 } 5066 while (symdefs[mark].file_offset == symdef->file_offset); 5067 5068 /* We mark subsequent symbols from this object file as we go 5069 on through the loop. */ 5070 last = symdef->file_offset; 5071 } 5072 } 5073 while (loop); 5074 5075 free (defined); 5076 free (included); 5077 5078 return TRUE; 5079 5080 error_return: 5081 if (defined != NULL) 5082 free (defined); 5083 if (included != NULL) 5084 free (included); 5085 return FALSE; 5086 } 5087 5088 /* Given an ELF BFD, add symbols to the global hash table as 5089 appropriate. */ 5090 5091 bfd_boolean 5092 bfd_elf_link_add_symbols (bfd *abfd, struct bfd_link_info *info) 5093 { 5094 switch (bfd_get_format (abfd)) 5095 { 5096 case bfd_object: 5097 return elf_link_add_object_symbols (abfd, info); 5098 case bfd_archive: 5099 return elf_link_add_archive_symbols (abfd, info); 5100 default: 5101 bfd_set_error (bfd_error_wrong_format); 5102 return FALSE; 5103 } 5104 } 5105 5106 struct hash_codes_info 5107 { 5108 unsigned long *hashcodes; 5109 bfd_boolean error; 5110 }; 5111 5112 /* This function will be called though elf_link_hash_traverse to store 5113 all hash value of the exported symbols in an array. */ 5114 5115 static bfd_boolean 5116 elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data) 5117 { 5118 struct hash_codes_info *inf = (struct hash_codes_info *) data; 5119 const char *name; 5120 char *p; 5121 unsigned long ha; 5122 char *alc = NULL; 5123 5124 if (h->root.type == bfd_link_hash_warning) 5125 h = (struct elf_link_hash_entry *) h->root.u.i.link; 5126 5127 /* Ignore indirect symbols. These are added by the versioning code. */ 5128 if (h->dynindx == -1) 5129 return TRUE; 5130 5131 name = h->root.root.string; 5132 p = strchr (name, ELF_VER_CHR); 5133 if (p != NULL) 5134 { 5135 alc = (char *) bfd_malloc (p - name + 1); 5136 if (alc == NULL) 5137 { 5138 inf->error = TRUE; 5139 return FALSE; 5140 } 5141 memcpy (alc, name, p - name); 5142 alc[p - name] = '\0'; 5143 name = alc; 5144 } 5145 5146 /* Compute the hash value. */ 5147 ha = bfd_elf_hash (name); 5148 5149 /* Store the found hash value in the array given as the argument. */ 5150 *(inf->hashcodes)++ = ha; 5151 5152 /* And store it in the struct so that we can put it in the hash table 5153 later. */ 5154 h->u.elf_hash_value = ha; 5155 5156 if (alc != NULL) 5157 free (alc); 5158 5159 return TRUE; 5160 } 5161 5162 struct collect_gnu_hash_codes 5163 { 5164 bfd *output_bfd; 5165 const struct elf_backend_data *bed; 5166 unsigned long int nsyms; 5167 unsigned long int maskbits; 5168 unsigned long int *hashcodes; 5169 unsigned long int *hashval; 5170 unsigned long int *indx; 5171 unsigned long int *counts; 5172 bfd_vma *bitmask; 5173 bfd_byte *contents; 5174 long int min_dynindx; 5175 unsigned long int bucketcount; 5176 unsigned long int symindx; 5177 long int local_indx; 5178 long int shift1, shift2; 5179 unsigned long int mask; 5180 bfd_boolean error; 5181 }; 5182 5183 /* This function will be called though elf_link_hash_traverse to store 5184 all hash value of the exported symbols in an array. */ 5185 5186 static bfd_boolean 5187 elf_collect_gnu_hash_codes (struct elf_link_hash_entry *h, void *data) 5188 { 5189 struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data; 5190 const char *name; 5191 char *p; 5192 unsigned long ha; 5193 char *alc = NULL; 5194 5195 if (h->root.type == bfd_link_hash_warning) 5196 h = (struct elf_link_hash_entry *) h->root.u.i.link; 5197 5198 /* Ignore indirect symbols. These are added by the versioning code. */ 5199 if (h->dynindx == -1) 5200 return TRUE; 5201 5202 /* Ignore also local symbols and undefined symbols. */ 5203 if (! (*s->bed->elf_hash_symbol) (h)) 5204 return TRUE; 5205 5206 name = h->root.root.string; 5207 p = strchr (name, ELF_VER_CHR); 5208 if (p != NULL) 5209 { 5210 alc = (char *) bfd_malloc (p - name + 1); 5211 if (alc == NULL) 5212 { 5213 s->error = TRUE; 5214 return FALSE; 5215 } 5216 memcpy (alc, name, p - name); 5217 alc[p - name] = '\0'; 5218 name = alc; 5219 } 5220 5221 /* Compute the hash value. */ 5222 ha = bfd_elf_gnu_hash (name); 5223 5224 /* Store the found hash value in the array for compute_bucket_count, 5225 and also for .dynsym reordering purposes. */ 5226 s->hashcodes[s->nsyms] = ha; 5227 s->hashval[h->dynindx] = ha; 5228 ++s->nsyms; 5229 if (s->min_dynindx < 0 || s->min_dynindx > h->dynindx) 5230 s->min_dynindx = h->dynindx; 5231 5232 if (alc != NULL) 5233 free (alc); 5234 5235 return TRUE; 5236 } 5237 5238 /* This function will be called though elf_link_hash_traverse to do 5239 final dynaminc symbol renumbering. */ 5240 5241 static bfd_boolean 5242 elf_renumber_gnu_hash_syms (struct elf_link_hash_entry *h, void *data) 5243 { 5244 struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data; 5245 unsigned long int bucket; 5246 unsigned long int val; 5247 5248 if (h->root.type == bfd_link_hash_warning) 5249 h = (struct elf_link_hash_entry *) h->root.u.i.link; 5250 5251 /* Ignore indirect symbols. */ 5252 if (h->dynindx == -1) 5253 return TRUE; 5254 5255 /* Ignore also local symbols and undefined symbols. */ 5256 if (! (*s->bed->elf_hash_symbol) (h)) 5257 { 5258 if (h->dynindx >= s->min_dynindx) 5259 h->dynindx = s->local_indx++; 5260 return TRUE; 5261 } 5262 5263 bucket = s->hashval[h->dynindx] % s->bucketcount; 5264 val = (s->hashval[h->dynindx] >> s->shift1) 5265 & ((s->maskbits >> s->shift1) - 1); 5266 s->bitmask[val] |= ((bfd_vma) 1) << (s->hashval[h->dynindx] & s->mask); 5267 s->bitmask[val] 5268 |= ((bfd_vma) 1) << ((s->hashval[h->dynindx] >> s->shift2) & s->mask); 5269 val = s->hashval[h->dynindx] & ~(unsigned long int) 1; 5270 if (s->counts[bucket] == 1) 5271 /* Last element terminates the chain. */ 5272 val |= 1; 5273 bfd_put_32 (s->output_bfd, val, 5274 s->contents + (s->indx[bucket] - s->symindx) * 4); 5275 --s->counts[bucket]; 5276 h->dynindx = s->indx[bucket]++; 5277 return TRUE; 5278 } 5279 5280 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */ 5281 5282 bfd_boolean 5283 _bfd_elf_hash_symbol (struct elf_link_hash_entry *h) 5284 { 5285 return !(h->forced_local 5286 || h->root.type == bfd_link_hash_undefined 5287 || h->root.type == bfd_link_hash_undefweak 5288 || ((h->root.type == bfd_link_hash_defined 5289 || h->root.type == bfd_link_hash_defweak) 5290 && h->root.u.def.section->output_section == NULL)); 5291 } 5292 5293 /* Array used to determine the number of hash table buckets to use 5294 based on the number of symbols there are. If there are fewer than 5295 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets, 5296 fewer than 37 we use 17 buckets, and so forth. We never use more 5297 than 32771 buckets. */ 5298 5299 static const size_t elf_buckets[] = 5300 { 5301 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209, 5302 16411, 32771, 0 5303 }; 5304 5305 /* Compute bucket count for hashing table. We do not use a static set 5306 of possible tables sizes anymore. Instead we determine for all 5307 possible reasonable sizes of the table the outcome (i.e., the 5308 number of collisions etc) and choose the best solution. The 5309 weighting functions are not too simple to allow the table to grow 5310 without bounds. Instead one of the weighting factors is the size. 5311 Therefore the result is always a good payoff between few collisions 5312 (= short chain lengths) and table size. */ 5313 static size_t 5314 compute_bucket_count (struct bfd_link_info *info, 5315 unsigned long int *hashcodes ATTRIBUTE_UNUSED, 5316 unsigned long int nsyms, 5317 int gnu_hash) 5318 { 5319 size_t best_size = 0; 5320 unsigned long int i; 5321 5322 /* We have a problem here. The following code to optimize the table 5323 size requires an integer type with more the 32 bits. If 5324 BFD_HOST_U_64_BIT is set we know about such a type. */ 5325 #ifdef BFD_HOST_U_64_BIT 5326 if (info->optimize) 5327 { 5328 size_t minsize; 5329 size_t maxsize; 5330 BFD_HOST_U_64_BIT best_chlen = ~((BFD_HOST_U_64_BIT) 0); 5331 bfd *dynobj = elf_hash_table (info)->dynobj; 5332 size_t dynsymcount = elf_hash_table (info)->dynsymcount; 5333 const struct elf_backend_data *bed = get_elf_backend_data (dynobj); 5334 unsigned long int *counts; 5335 bfd_size_type amt; 5336 5337 /* Possible optimization parameters: if we have NSYMS symbols we say 5338 that the hashing table must at least have NSYMS/4 and at most 5339 2*NSYMS buckets. */ 5340 minsize = nsyms / 4; 5341 if (minsize == 0) 5342 minsize = 1; 5343 best_size = maxsize = nsyms * 2; 5344 if (gnu_hash) 5345 { 5346 if (minsize < 2) 5347 minsize = 2; 5348 if ((best_size & 31) == 0) 5349 ++best_size; 5350 } 5351 5352 /* Create array where we count the collisions in. We must use bfd_malloc 5353 since the size could be large. */ 5354 amt = maxsize; 5355 amt *= sizeof (unsigned long int); 5356 counts = (unsigned long int *) bfd_malloc (amt); 5357 if (counts == NULL) 5358 return 0; 5359 5360 /* Compute the "optimal" size for the hash table. The criteria is a 5361 minimal chain length. The minor criteria is (of course) the size 5362 of the table. */ 5363 for (i = minsize; i < maxsize; ++i) 5364 { 5365 /* Walk through the array of hashcodes and count the collisions. */ 5366 BFD_HOST_U_64_BIT max; 5367 unsigned long int j; 5368 unsigned long int fact; 5369 5370 if (gnu_hash && (i & 31) == 0) 5371 continue; 5372 5373 memset (counts, '\0', i * sizeof (unsigned long int)); 5374 5375 /* Determine how often each hash bucket is used. */ 5376 for (j = 0; j < nsyms; ++j) 5377 ++counts[hashcodes[j] % i]; 5378 5379 /* For the weight function we need some information about the 5380 pagesize on the target. This is information need not be 100% 5381 accurate. Since this information is not available (so far) we 5382 define it here to a reasonable default value. If it is crucial 5383 to have a better value some day simply define this value. */ 5384 # ifndef BFD_TARGET_PAGESIZE 5385 # define BFD_TARGET_PAGESIZE (4096) 5386 # endif 5387 5388 /* We in any case need 2 + DYNSYMCOUNT entries for the size values 5389 and the chains. */ 5390 max = (2 + dynsymcount) * bed->s->sizeof_hash_entry; 5391 5392 # if 1 5393 /* Variant 1: optimize for short chains. We add the squares 5394 of all the chain lengths (which favors many small chain 5395 over a few long chains). */ 5396 for (j = 0; j < i; ++j) 5397 max += counts[j] * counts[j]; 5398 5399 /* This adds penalties for the overall size of the table. */ 5400 fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1; 5401 max *= fact * fact; 5402 # else 5403 /* Variant 2: Optimize a lot more for small table. Here we 5404 also add squares of the size but we also add penalties for 5405 empty slots (the +1 term). */ 5406 for (j = 0; j < i; ++j) 5407 max += (1 + counts[j]) * (1 + counts[j]); 5408 5409 /* The overall size of the table is considered, but not as 5410 strong as in variant 1, where it is squared. */ 5411 fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1; 5412 max *= fact; 5413 # endif 5414 5415 /* Compare with current best results. */ 5416 if (max < best_chlen) 5417 { 5418 best_chlen = max; 5419 best_size = i; 5420 } 5421 } 5422 5423 free (counts); 5424 } 5425 else 5426 #endif /* defined (BFD_HOST_U_64_BIT) */ 5427 { 5428 /* This is the fallback solution if no 64bit type is available or if we 5429 are not supposed to spend much time on optimizations. We select the 5430 bucket count using a fixed set of numbers. */ 5431 for (i = 0; elf_buckets[i] != 0; i++) 5432 { 5433 best_size = elf_buckets[i]; 5434 if (nsyms < elf_buckets[i + 1]) 5435 break; 5436 } 5437 if (gnu_hash && best_size < 2) 5438 best_size = 2; 5439 } 5440 5441 return best_size; 5442 } 5443 5444 /* Set up the sizes and contents of the ELF dynamic sections. This is 5445 called by the ELF linker emulation before_allocation routine. We 5446 must set the sizes of the sections before the linker sets the 5447 addresses of the various sections. */ 5448 5449 bfd_boolean 5450 bfd_elf_size_dynamic_sections (bfd *output_bfd, 5451 const char *soname, 5452 const char *rpath, 5453 const char *filter_shlib, 5454 const char * const *auxiliary_filters, 5455 struct bfd_link_info *info, 5456 asection **sinterpptr, 5457 struct bfd_elf_version_tree *verdefs) 5458 { 5459 bfd_size_type soname_indx; 5460 bfd *dynobj; 5461 const struct elf_backend_data *bed; 5462 struct elf_info_failed asvinfo; 5463 5464 *sinterpptr = NULL; 5465 5466 soname_indx = (bfd_size_type) -1; 5467 5468 if (!is_elf_hash_table (info->hash)) 5469 return TRUE; 5470 5471 bed = get_elf_backend_data (output_bfd); 5472 if (info->execstack) 5473 elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X; 5474 else if (info->noexecstack) 5475 elf_tdata (output_bfd)->stack_flags = PF_R | PF_W; 5476 else 5477 { 5478 bfd *inputobj; 5479 asection *notesec = NULL; 5480 int exec = 0; 5481 5482 for (inputobj = info->input_bfds; 5483 inputobj; 5484 inputobj = inputobj->link_next) 5485 { 5486 asection *s; 5487 5488 if (inputobj->flags & (DYNAMIC | EXEC_P | BFD_LINKER_CREATED)) 5489 continue; 5490 s = bfd_get_section_by_name (inputobj, ".note.GNU-stack"); 5491 if (s) 5492 { 5493 if (s->flags & SEC_CODE) 5494 exec = PF_X; 5495 notesec = s; 5496 } 5497 else if (bed->default_execstack) 5498 exec = PF_X; 5499 } 5500 if (notesec) 5501 { 5502 elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | exec; 5503 if (exec && info->relocatable 5504 && notesec->output_section != bfd_abs_section_ptr) 5505 notesec->output_section->flags |= SEC_CODE; 5506 } 5507 } 5508 5509 /* Any syms created from now on start with -1 in 5510 got.refcount/offset and plt.refcount/offset. */ 5511 elf_hash_table (info)->init_got_refcount 5512 = elf_hash_table (info)->init_got_offset; 5513 elf_hash_table (info)->init_plt_refcount 5514 = elf_hash_table (info)->init_plt_offset; 5515 5516 /* The backend may have to create some sections regardless of whether 5517 we're dynamic or not. */ 5518 if (bed->elf_backend_always_size_sections 5519 && ! (*bed->elf_backend_always_size_sections) (output_bfd, info)) 5520 return FALSE; 5521 5522 if (! _bfd_elf_maybe_strip_eh_frame_hdr (info)) 5523 return FALSE; 5524 5525 dynobj = elf_hash_table (info)->dynobj; 5526 5527 /* If there were no dynamic objects in the link, there is nothing to 5528 do here. */ 5529 if (dynobj == NULL) 5530 return TRUE; 5531 5532 if (elf_hash_table (info)->dynamic_sections_created) 5533 { 5534 struct elf_info_failed eif; 5535 struct elf_link_hash_entry *h; 5536 asection *dynstr; 5537 struct bfd_elf_version_tree *t; 5538 struct bfd_elf_version_expr *d; 5539 asection *s; 5540 bfd_boolean all_defined; 5541 5542 *sinterpptr = bfd_get_section_by_name (dynobj, ".interp"); 5543 BFD_ASSERT (*sinterpptr != NULL || !info->executable); 5544 5545 if (soname != NULL) 5546 { 5547 soname_indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, 5548 soname, TRUE); 5549 if (soname_indx == (bfd_size_type) -1 5550 || !_bfd_elf_add_dynamic_entry (info, DT_SONAME, soname_indx)) 5551 return FALSE; 5552 } 5553 5554 if (info->symbolic) 5555 { 5556 if (!_bfd_elf_add_dynamic_entry (info, DT_SYMBOLIC, 0)) 5557 return FALSE; 5558 info->flags |= DF_SYMBOLIC; 5559 } 5560 5561 if (rpath != NULL) 5562 { 5563 bfd_size_type indx; 5564 5565 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, rpath, 5566 TRUE); 5567 if (indx == (bfd_size_type) -1 5568 || !_bfd_elf_add_dynamic_entry (info, DT_RPATH, indx)) 5569 return FALSE; 5570 5571 if (info->new_dtags) 5572 { 5573 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr, indx); 5574 if (!_bfd_elf_add_dynamic_entry (info, DT_RUNPATH, indx)) 5575 return FALSE; 5576 } 5577 } 5578 5579 if (filter_shlib != NULL) 5580 { 5581 bfd_size_type indx; 5582 5583 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, 5584 filter_shlib, TRUE); 5585 if (indx == (bfd_size_type) -1 5586 || !_bfd_elf_add_dynamic_entry (info, DT_FILTER, indx)) 5587 return FALSE; 5588 } 5589 5590 if (auxiliary_filters != NULL) 5591 { 5592 const char * const *p; 5593 5594 for (p = auxiliary_filters; *p != NULL; p++) 5595 { 5596 bfd_size_type indx; 5597 5598 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, 5599 *p, TRUE); 5600 if (indx == (bfd_size_type) -1 5601 || !_bfd_elf_add_dynamic_entry (info, DT_AUXILIARY, indx)) 5602 return FALSE; 5603 } 5604 } 5605 5606 eif.info = info; 5607 eif.verdefs = verdefs; 5608 eif.failed = FALSE; 5609 5610 /* If we are supposed to export all symbols into the dynamic symbol 5611 table (this is not the normal case), then do so. */ 5612 if (info->export_dynamic 5613 || (info->executable && info->dynamic)) 5614 { 5615 elf_link_hash_traverse (elf_hash_table (info), 5616 _bfd_elf_export_symbol, 5617 &eif); 5618 if (eif.failed) 5619 return FALSE; 5620 } 5621 5622 /* Make all global versions with definition. */ 5623 for (t = verdefs; t != NULL; t = t->next) 5624 for (d = t->globals.list; d != NULL; d = d->next) 5625 if (!d->symver && d->literal) 5626 { 5627 const char *verstr, *name; 5628 size_t namelen, verlen, newlen; 5629 char *newname, *p; 5630 struct elf_link_hash_entry *newh; 5631 5632 name = d->pattern; 5633 namelen = strlen (name); 5634 verstr = t->name; 5635 verlen = strlen (verstr); 5636 newlen = namelen + verlen + 3; 5637 5638 newname = (char *) bfd_malloc (newlen); 5639 if (newname == NULL) 5640 return FALSE; 5641 memcpy (newname, name, namelen); 5642 5643 /* Check the hidden versioned definition. */ 5644 p = newname + namelen; 5645 *p++ = ELF_VER_CHR; 5646 memcpy (p, verstr, verlen + 1); 5647 newh = elf_link_hash_lookup (elf_hash_table (info), 5648 newname, FALSE, FALSE, 5649 FALSE); 5650 if (newh == NULL 5651 || (newh->root.type != bfd_link_hash_defined 5652 && newh->root.type != bfd_link_hash_defweak)) 5653 { 5654 /* Check the default versioned definition. */ 5655 *p++ = ELF_VER_CHR; 5656 memcpy (p, verstr, verlen + 1); 5657 newh = elf_link_hash_lookup (elf_hash_table (info), 5658 newname, FALSE, FALSE, 5659 FALSE); 5660 } 5661 free (newname); 5662 5663 /* Mark this version if there is a definition and it is 5664 not defined in a shared object. */ 5665 if (newh != NULL 5666 && !newh->def_dynamic 5667 && (newh->root.type == bfd_link_hash_defined 5668 || newh->root.type == bfd_link_hash_defweak)) 5669 d->symver = 1; 5670 } 5671 5672 /* Attach all the symbols to their version information. */ 5673 asvinfo.info = info; 5674 asvinfo.verdefs = verdefs; 5675 asvinfo.failed = FALSE; 5676 5677 elf_link_hash_traverse (elf_hash_table (info), 5678 _bfd_elf_link_assign_sym_version, 5679 &asvinfo); 5680 if (asvinfo.failed) 5681 return FALSE; 5682 5683 if (!info->allow_undefined_version) 5684 { 5685 /* Check if all global versions have a definition. */ 5686 all_defined = TRUE; 5687 for (t = verdefs; t != NULL; t = t->next) 5688 for (d = t->globals.list; d != NULL; d = d->next) 5689 if (d->literal && !d->symver && !d->script) 5690 { 5691 (*_bfd_error_handler) 5692 (_("%s: undefined version: %s"), 5693 d->pattern, t->name); 5694 all_defined = FALSE; 5695 } 5696 5697 if (!all_defined) 5698 { 5699 bfd_set_error (bfd_error_bad_value); 5700 return FALSE; 5701 } 5702 } 5703 5704 /* Find all symbols which were defined in a dynamic object and make 5705 the backend pick a reasonable value for them. */ 5706 elf_link_hash_traverse (elf_hash_table (info), 5707 _bfd_elf_adjust_dynamic_symbol, 5708 &eif); 5709 if (eif.failed) 5710 return FALSE; 5711 5712 /* Add some entries to the .dynamic section. We fill in some of the 5713 values later, in bfd_elf_final_link, but we must add the entries 5714 now so that we know the final size of the .dynamic section. */ 5715 5716 /* If there are initialization and/or finalization functions to 5717 call then add the corresponding DT_INIT/DT_FINI entries. */ 5718 h = (info->init_function 5719 ? elf_link_hash_lookup (elf_hash_table (info), 5720 info->init_function, FALSE, 5721 FALSE, FALSE) 5722 : NULL); 5723 if (h != NULL 5724 && (h->ref_regular 5725 || h->def_regular)) 5726 { 5727 if (!_bfd_elf_add_dynamic_entry (info, DT_INIT, 0)) 5728 return FALSE; 5729 } 5730 h = (info->fini_function 5731 ? elf_link_hash_lookup (elf_hash_table (info), 5732 info->fini_function, FALSE, 5733 FALSE, FALSE) 5734 : NULL); 5735 if (h != NULL 5736 && (h->ref_regular 5737 || h->def_regular)) 5738 { 5739 if (!_bfd_elf_add_dynamic_entry (info, DT_FINI, 0)) 5740 return FALSE; 5741 } 5742 5743 s = bfd_get_section_by_name (output_bfd, ".preinit_array"); 5744 if (s != NULL && s->linker_has_input) 5745 { 5746 /* DT_PREINIT_ARRAY is not allowed in shared library. */ 5747 if (! info->executable) 5748 { 5749 bfd *sub; 5750 asection *o; 5751 5752 for (sub = info->input_bfds; sub != NULL; 5753 sub = sub->link_next) 5754 if (bfd_get_flavour (sub) == bfd_target_elf_flavour) 5755 for (o = sub->sections; o != NULL; o = o->next) 5756 if (elf_section_data (o)->this_hdr.sh_type 5757 == SHT_PREINIT_ARRAY) 5758 { 5759 (*_bfd_error_handler) 5760 (_("%B: .preinit_array section is not allowed in DSO"), 5761 sub); 5762 break; 5763 } 5764 5765 bfd_set_error (bfd_error_nonrepresentable_section); 5766 return FALSE; 5767 } 5768 5769 if (!_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAY, 0) 5770 || !_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAYSZ, 0)) 5771 return FALSE; 5772 } 5773 s = bfd_get_section_by_name (output_bfd, ".init_array"); 5774 if (s != NULL && s->linker_has_input) 5775 { 5776 if (!_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAY, 0) 5777 || !_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAYSZ, 0)) 5778 return FALSE; 5779 } 5780 s = bfd_get_section_by_name (output_bfd, ".fini_array"); 5781 if (s != NULL && s->linker_has_input) 5782 { 5783 if (!_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAY, 0) 5784 || !_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAYSZ, 0)) 5785 return FALSE; 5786 } 5787 5788 dynstr = bfd_get_section_by_name (dynobj, ".dynstr"); 5789 /* If .dynstr is excluded from the link, we don't want any of 5790 these tags. Strictly, we should be checking each section 5791 individually; This quick check covers for the case where 5792 someone does a /DISCARD/ : { *(*) }. */ 5793 if (dynstr != NULL && dynstr->output_section != bfd_abs_section_ptr) 5794 { 5795 bfd_size_type strsize; 5796 5797 strsize = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr); 5798 if ((info->emit_hash 5799 && !_bfd_elf_add_dynamic_entry (info, DT_HASH, 0)) 5800 || (info->emit_gnu_hash 5801 && !_bfd_elf_add_dynamic_entry (info, DT_GNU_HASH, 0)) 5802 || !_bfd_elf_add_dynamic_entry (info, DT_STRTAB, 0) 5803 || !_bfd_elf_add_dynamic_entry (info, DT_SYMTAB, 0) 5804 || !_bfd_elf_add_dynamic_entry (info, DT_STRSZ, strsize) 5805 || !_bfd_elf_add_dynamic_entry (info, DT_SYMENT, 5806 bed->s->sizeof_sym)) 5807 return FALSE; 5808 } 5809 } 5810 5811 /* The backend must work out the sizes of all the other dynamic 5812 sections. */ 5813 if (bed->elf_backend_size_dynamic_sections 5814 && ! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info)) 5815 return FALSE; 5816 5817 if (elf_hash_table (info)->dynamic_sections_created) 5818 { 5819 unsigned long section_sym_count; 5820 asection *s; 5821 5822 /* Set up the version definition section. */ 5823 s = bfd_get_section_by_name (dynobj, ".gnu.version_d"); 5824 BFD_ASSERT (s != NULL); 5825 5826 /* We may have created additional version definitions if we are 5827 just linking a regular application. */ 5828 verdefs = asvinfo.verdefs; 5829 5830 /* Skip anonymous version tag. */ 5831 if (verdefs != NULL && verdefs->vernum == 0) 5832 verdefs = verdefs->next; 5833 5834 if (verdefs == NULL && !info->create_default_symver) 5835 s->flags |= SEC_EXCLUDE; 5836 else 5837 { 5838 unsigned int cdefs; 5839 bfd_size_type size; 5840 struct bfd_elf_version_tree *t; 5841 bfd_byte *p; 5842 Elf_Internal_Verdef def; 5843 Elf_Internal_Verdaux defaux; 5844 struct bfd_link_hash_entry *bh; 5845 struct elf_link_hash_entry *h; 5846 const char *name; 5847 5848 cdefs = 0; 5849 size = 0; 5850 5851 /* Make space for the base version. */ 5852 size += sizeof (Elf_External_Verdef); 5853 size += sizeof (Elf_External_Verdaux); 5854 ++cdefs; 5855 5856 /* Make space for the default version. */ 5857 if (info->create_default_symver) 5858 { 5859 size += sizeof (Elf_External_Verdef); 5860 ++cdefs; 5861 } 5862 5863 for (t = verdefs; t != NULL; t = t->next) 5864 { 5865 struct bfd_elf_version_deps *n; 5866 5867 size += sizeof (Elf_External_Verdef); 5868 size += sizeof (Elf_External_Verdaux); 5869 ++cdefs; 5870 5871 for (n = t->deps; n != NULL; n = n->next) 5872 size += sizeof (Elf_External_Verdaux); 5873 } 5874 5875 s->size = size; 5876 s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size); 5877 if (s->contents == NULL && s->size != 0) 5878 return FALSE; 5879 5880 /* Fill in the version definition section. */ 5881 5882 p = s->contents; 5883 5884 def.vd_version = VER_DEF_CURRENT; 5885 def.vd_flags = VER_FLG_BASE; 5886 def.vd_ndx = 1; 5887 def.vd_cnt = 1; 5888 if (info->create_default_symver) 5889 { 5890 def.vd_aux = 2 * sizeof (Elf_External_Verdef); 5891 def.vd_next = sizeof (Elf_External_Verdef); 5892 } 5893 else 5894 { 5895 def.vd_aux = sizeof (Elf_External_Verdef); 5896 def.vd_next = (sizeof (Elf_External_Verdef) 5897 + sizeof (Elf_External_Verdaux)); 5898 } 5899 5900 if (soname_indx != (bfd_size_type) -1) 5901 { 5902 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr, 5903 soname_indx); 5904 def.vd_hash = bfd_elf_hash (soname); 5905 defaux.vda_name = soname_indx; 5906 name = soname; 5907 } 5908 else 5909 { 5910 bfd_size_type indx; 5911 5912 name = lbasename (output_bfd->filename); 5913 def.vd_hash = bfd_elf_hash (name); 5914 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, 5915 name, FALSE); 5916 if (indx == (bfd_size_type) -1) 5917 return FALSE; 5918 defaux.vda_name = indx; 5919 } 5920 defaux.vda_next = 0; 5921 5922 _bfd_elf_swap_verdef_out (output_bfd, &def, 5923 (Elf_External_Verdef *) p); 5924 p += sizeof (Elf_External_Verdef); 5925 if (info->create_default_symver) 5926 { 5927 /* Add a symbol representing this version. */ 5928 bh = NULL; 5929 if (! (_bfd_generic_link_add_one_symbol 5930 (info, dynobj, name, BSF_GLOBAL, bfd_abs_section_ptr, 5931 0, NULL, FALSE, 5932 get_elf_backend_data (dynobj)->collect, &bh))) 5933 return FALSE; 5934 h = (struct elf_link_hash_entry *) bh; 5935 h->non_elf = 0; 5936 h->def_regular = 1; 5937 h->type = STT_OBJECT; 5938 h->verinfo.vertree = NULL; 5939 5940 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 5941 return FALSE; 5942 5943 /* Create a duplicate of the base version with the same 5944 aux block, but different flags. */ 5945 def.vd_flags = 0; 5946 def.vd_ndx = 2; 5947 def.vd_aux = sizeof (Elf_External_Verdef); 5948 if (verdefs) 5949 def.vd_next = (sizeof (Elf_External_Verdef) 5950 + sizeof (Elf_External_Verdaux)); 5951 else 5952 def.vd_next = 0; 5953 _bfd_elf_swap_verdef_out (output_bfd, &def, 5954 (Elf_External_Verdef *) p); 5955 p += sizeof (Elf_External_Verdef); 5956 } 5957 _bfd_elf_swap_verdaux_out (output_bfd, &defaux, 5958 (Elf_External_Verdaux *) p); 5959 p += sizeof (Elf_External_Verdaux); 5960 5961 for (t = verdefs; t != NULL; t = t->next) 5962 { 5963 unsigned int cdeps; 5964 struct bfd_elf_version_deps *n; 5965 5966 cdeps = 0; 5967 for (n = t->deps; n != NULL; n = n->next) 5968 ++cdeps; 5969 5970 /* Add a symbol representing this version. */ 5971 bh = NULL; 5972 if (! (_bfd_generic_link_add_one_symbol 5973 (info, dynobj, t->name, BSF_GLOBAL, bfd_abs_section_ptr, 5974 0, NULL, FALSE, 5975 get_elf_backend_data (dynobj)->collect, &bh))) 5976 return FALSE; 5977 h = (struct elf_link_hash_entry *) bh; 5978 h->non_elf = 0; 5979 h->def_regular = 1; 5980 h->type = STT_OBJECT; 5981 h->verinfo.vertree = t; 5982 5983 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 5984 return FALSE; 5985 5986 def.vd_version = VER_DEF_CURRENT; 5987 def.vd_flags = 0; 5988 if (t->globals.list == NULL 5989 && t->locals.list == NULL 5990 && ! t->used) 5991 def.vd_flags |= VER_FLG_WEAK; 5992 def.vd_ndx = t->vernum + (info->create_default_symver ? 2 : 1); 5993 def.vd_cnt = cdeps + 1; 5994 def.vd_hash = bfd_elf_hash (t->name); 5995 def.vd_aux = sizeof (Elf_External_Verdef); 5996 def.vd_next = 0; 5997 if (t->next != NULL) 5998 def.vd_next = (sizeof (Elf_External_Verdef) 5999 + (cdeps + 1) * sizeof (Elf_External_Verdaux)); 6000 6001 _bfd_elf_swap_verdef_out (output_bfd, &def, 6002 (Elf_External_Verdef *) p); 6003 p += sizeof (Elf_External_Verdef); 6004 6005 defaux.vda_name = h->dynstr_index; 6006 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr, 6007 h->dynstr_index); 6008 defaux.vda_next = 0; 6009 if (t->deps != NULL) 6010 defaux.vda_next = sizeof (Elf_External_Verdaux); 6011 t->name_indx = defaux.vda_name; 6012 6013 _bfd_elf_swap_verdaux_out (output_bfd, &defaux, 6014 (Elf_External_Verdaux *) p); 6015 p += sizeof (Elf_External_Verdaux); 6016 6017 for (n = t->deps; n != NULL; n = n->next) 6018 { 6019 if (n->version_needed == NULL) 6020 { 6021 /* This can happen if there was an error in the 6022 version script. */ 6023 defaux.vda_name = 0; 6024 } 6025 else 6026 { 6027 defaux.vda_name = n->version_needed->name_indx; 6028 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr, 6029 defaux.vda_name); 6030 } 6031 if (n->next == NULL) 6032 defaux.vda_next = 0; 6033 else 6034 defaux.vda_next = sizeof (Elf_External_Verdaux); 6035 6036 _bfd_elf_swap_verdaux_out (output_bfd, &defaux, 6037 (Elf_External_Verdaux *) p); 6038 p += sizeof (Elf_External_Verdaux); 6039 } 6040 } 6041 6042 if (!_bfd_elf_add_dynamic_entry (info, DT_VERDEF, 0) 6043 || !_bfd_elf_add_dynamic_entry (info, DT_VERDEFNUM, cdefs)) 6044 return FALSE; 6045 6046 elf_tdata (output_bfd)->cverdefs = cdefs; 6047 } 6048 6049 if ((info->new_dtags && info->flags) || (info->flags & DF_STATIC_TLS)) 6050 { 6051 if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS, info->flags)) 6052 return FALSE; 6053 } 6054 else if (info->flags & DF_BIND_NOW) 6055 { 6056 if (!_bfd_elf_add_dynamic_entry (info, DT_BIND_NOW, 0)) 6057 return FALSE; 6058 } 6059 6060 if (info->flags_1) 6061 { 6062 if (info->executable) 6063 info->flags_1 &= ~ (DF_1_INITFIRST 6064 | DF_1_NODELETE 6065 | DF_1_NOOPEN); 6066 if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS_1, info->flags_1)) 6067 return FALSE; 6068 } 6069 6070 /* Work out the size of the version reference section. */ 6071 6072 s = bfd_get_section_by_name (dynobj, ".gnu.version_r"); 6073 BFD_ASSERT (s != NULL); 6074 { 6075 struct elf_find_verdep_info sinfo; 6076 6077 sinfo.info = info; 6078 sinfo.vers = elf_tdata (output_bfd)->cverdefs; 6079 if (sinfo.vers == 0) 6080 sinfo.vers = 1; 6081 sinfo.failed = FALSE; 6082 6083 elf_link_hash_traverse (elf_hash_table (info), 6084 _bfd_elf_link_find_version_dependencies, 6085 &sinfo); 6086 if (sinfo.failed) 6087 return FALSE; 6088 6089 if (elf_tdata (output_bfd)->verref == NULL) 6090 s->flags |= SEC_EXCLUDE; 6091 else 6092 { 6093 Elf_Internal_Verneed *t; 6094 unsigned int size; 6095 unsigned int crefs; 6096 bfd_byte *p; 6097 6098 /* Build the version definition section. */ 6099 size = 0; 6100 crefs = 0; 6101 for (t = elf_tdata (output_bfd)->verref; 6102 t != NULL; 6103 t = t->vn_nextref) 6104 { 6105 Elf_Internal_Vernaux *a; 6106 6107 size += sizeof (Elf_External_Verneed); 6108 ++crefs; 6109 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr) 6110 size += sizeof (Elf_External_Vernaux); 6111 } 6112 6113 s->size = size; 6114 s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size); 6115 if (s->contents == NULL) 6116 return FALSE; 6117 6118 p = s->contents; 6119 for (t = elf_tdata (output_bfd)->verref; 6120 t != NULL; 6121 t = t->vn_nextref) 6122 { 6123 unsigned int caux; 6124 Elf_Internal_Vernaux *a; 6125 bfd_size_type indx; 6126 6127 caux = 0; 6128 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr) 6129 ++caux; 6130 6131 t->vn_version = VER_NEED_CURRENT; 6132 t->vn_cnt = caux; 6133 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, 6134 elf_dt_name (t->vn_bfd) != NULL 6135 ? elf_dt_name (t->vn_bfd) 6136 : lbasename (t->vn_bfd->filename), 6137 FALSE); 6138 if (indx == (bfd_size_type) -1) 6139 return FALSE; 6140 t->vn_file = indx; 6141 t->vn_aux = sizeof (Elf_External_Verneed); 6142 if (t->vn_nextref == NULL) 6143 t->vn_next = 0; 6144 else 6145 t->vn_next = (sizeof (Elf_External_Verneed) 6146 + caux * sizeof (Elf_External_Vernaux)); 6147 6148 _bfd_elf_swap_verneed_out (output_bfd, t, 6149 (Elf_External_Verneed *) p); 6150 p += sizeof (Elf_External_Verneed); 6151 6152 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr) 6153 { 6154 a->vna_hash = bfd_elf_hash (a->vna_nodename); 6155 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, 6156 a->vna_nodename, FALSE); 6157 if (indx == (bfd_size_type) -1) 6158 return FALSE; 6159 a->vna_name = indx; 6160 if (a->vna_nextptr == NULL) 6161 a->vna_next = 0; 6162 else 6163 a->vna_next = sizeof (Elf_External_Vernaux); 6164 6165 _bfd_elf_swap_vernaux_out (output_bfd, a, 6166 (Elf_External_Vernaux *) p); 6167 p += sizeof (Elf_External_Vernaux); 6168 } 6169 } 6170 6171 if (!_bfd_elf_add_dynamic_entry (info, DT_VERNEED, 0) 6172 || !_bfd_elf_add_dynamic_entry (info, DT_VERNEEDNUM, crefs)) 6173 return FALSE; 6174 6175 elf_tdata (output_bfd)->cverrefs = crefs; 6176 } 6177 } 6178 6179 if ((elf_tdata (output_bfd)->cverrefs == 0 6180 && elf_tdata (output_bfd)->cverdefs == 0) 6181 || _bfd_elf_link_renumber_dynsyms (output_bfd, info, 6182 §ion_sym_count) == 0) 6183 { 6184 s = bfd_get_section_by_name (dynobj, ".gnu.version"); 6185 s->flags |= SEC_EXCLUDE; 6186 } 6187 } 6188 return TRUE; 6189 } 6190 6191 /* Find the first non-excluded output section. We'll use its 6192 section symbol for some emitted relocs. */ 6193 void 6194 _bfd_elf_init_1_index_section (bfd *output_bfd, struct bfd_link_info *info) 6195 { 6196 asection *s; 6197 6198 for (s = output_bfd->sections; s != NULL; s = s->next) 6199 if ((s->flags & (SEC_EXCLUDE | SEC_ALLOC)) == SEC_ALLOC 6200 && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s)) 6201 { 6202 elf_hash_table (info)->text_index_section = s; 6203 break; 6204 } 6205 } 6206 6207 /* Find two non-excluded output sections, one for code, one for data. 6208 We'll use their section symbols for some emitted relocs. */ 6209 void 6210 _bfd_elf_init_2_index_sections (bfd *output_bfd, struct bfd_link_info *info) 6211 { 6212 asection *s; 6213 6214 /* Data first, since setting text_index_section changes 6215 _bfd_elf_link_omit_section_dynsym. */ 6216 for (s = output_bfd->sections; s != NULL; s = s->next) 6217 if (((s->flags & (SEC_EXCLUDE | SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC) 6218 && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s)) 6219 { 6220 elf_hash_table (info)->data_index_section = s; 6221 break; 6222 } 6223 6224 for (s = output_bfd->sections; s != NULL; s = s->next) 6225 if (((s->flags & (SEC_EXCLUDE | SEC_ALLOC | SEC_READONLY)) 6226 == (SEC_ALLOC | SEC_READONLY)) 6227 && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s)) 6228 { 6229 elf_hash_table (info)->text_index_section = s; 6230 break; 6231 } 6232 6233 if (elf_hash_table (info)->text_index_section == NULL) 6234 elf_hash_table (info)->text_index_section 6235 = elf_hash_table (info)->data_index_section; 6236 } 6237 6238 bfd_boolean 6239 bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info) 6240 { 6241 const struct elf_backend_data *bed; 6242 6243 if (!is_elf_hash_table (info->hash)) 6244 return TRUE; 6245 6246 bed = get_elf_backend_data (output_bfd); 6247 (*bed->elf_backend_init_index_section) (output_bfd, info); 6248 6249 if (elf_hash_table (info)->dynamic_sections_created) 6250 { 6251 bfd *dynobj; 6252 asection *s; 6253 bfd_size_type dynsymcount; 6254 unsigned long section_sym_count; 6255 unsigned int dtagcount; 6256 6257 dynobj = elf_hash_table (info)->dynobj; 6258 6259 /* Assign dynsym indicies. In a shared library we generate a 6260 section symbol for each output section, which come first. 6261 Next come all of the back-end allocated local dynamic syms, 6262 followed by the rest of the global symbols. */ 6263 6264 dynsymcount = _bfd_elf_link_renumber_dynsyms (output_bfd, info, 6265 §ion_sym_count); 6266 6267 /* Work out the size of the symbol version section. */ 6268 s = bfd_get_section_by_name (dynobj, ".gnu.version"); 6269 BFD_ASSERT (s != NULL); 6270 if (dynsymcount != 0 6271 && (s->flags & SEC_EXCLUDE) == 0) 6272 { 6273 s->size = dynsymcount * sizeof (Elf_External_Versym); 6274 s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size); 6275 if (s->contents == NULL) 6276 return FALSE; 6277 6278 if (!_bfd_elf_add_dynamic_entry (info, DT_VERSYM, 0)) 6279 return FALSE; 6280 } 6281 6282 /* Set the size of the .dynsym and .hash sections. We counted 6283 the number of dynamic symbols in elf_link_add_object_symbols. 6284 We will build the contents of .dynsym and .hash when we build 6285 the final symbol table, because until then we do not know the 6286 correct value to give the symbols. We built the .dynstr 6287 section as we went along in elf_link_add_object_symbols. */ 6288 s = bfd_get_section_by_name (dynobj, ".dynsym"); 6289 BFD_ASSERT (s != NULL); 6290 s->size = dynsymcount * bed->s->sizeof_sym; 6291 6292 if (dynsymcount != 0) 6293 { 6294 s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size); 6295 if (s->contents == NULL) 6296 return FALSE; 6297 6298 /* The first entry in .dynsym is a dummy symbol. 6299 Clear all the section syms, in case we don't output them all. */ 6300 ++section_sym_count; 6301 memset (s->contents, 0, section_sym_count * bed->s->sizeof_sym); 6302 } 6303 6304 elf_hash_table (info)->bucketcount = 0; 6305 6306 /* Compute the size of the hashing table. As a side effect this 6307 computes the hash values for all the names we export. */ 6308 if (info->emit_hash) 6309 { 6310 unsigned long int *hashcodes; 6311 struct hash_codes_info hashinf; 6312 bfd_size_type amt; 6313 unsigned long int nsyms; 6314 size_t bucketcount; 6315 size_t hash_entry_size; 6316 6317 /* Compute the hash values for all exported symbols. At the same 6318 time store the values in an array so that we could use them for 6319 optimizations. */ 6320 amt = dynsymcount * sizeof (unsigned long int); 6321 hashcodes = (unsigned long int *) bfd_malloc (amt); 6322 if (hashcodes == NULL) 6323 return FALSE; 6324 hashinf.hashcodes = hashcodes; 6325 hashinf.error = FALSE; 6326 6327 /* Put all hash values in HASHCODES. */ 6328 elf_link_hash_traverse (elf_hash_table (info), 6329 elf_collect_hash_codes, &hashinf); 6330 if (hashinf.error) 6331 { 6332 free (hashcodes); 6333 return FALSE; 6334 } 6335 6336 nsyms = hashinf.hashcodes - hashcodes; 6337 bucketcount 6338 = compute_bucket_count (info, hashcodes, nsyms, 0); 6339 free (hashcodes); 6340 6341 if (bucketcount == 0) 6342 return FALSE; 6343 6344 elf_hash_table (info)->bucketcount = bucketcount; 6345 6346 s = bfd_get_section_by_name (dynobj, ".hash"); 6347 BFD_ASSERT (s != NULL); 6348 hash_entry_size = elf_section_data (s)->this_hdr.sh_entsize; 6349 s->size = ((2 + bucketcount + dynsymcount) * hash_entry_size); 6350 s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size); 6351 if (s->contents == NULL) 6352 return FALSE; 6353 6354 bfd_put (8 * hash_entry_size, output_bfd, bucketcount, s->contents); 6355 bfd_put (8 * hash_entry_size, output_bfd, dynsymcount, 6356 s->contents + hash_entry_size); 6357 } 6358 6359 if (info->emit_gnu_hash) 6360 { 6361 size_t i, cnt; 6362 unsigned char *contents; 6363 struct collect_gnu_hash_codes cinfo; 6364 bfd_size_type amt; 6365 size_t bucketcount; 6366 6367 memset (&cinfo, 0, sizeof (cinfo)); 6368 6369 /* Compute the hash values for all exported symbols. At the same 6370 time store the values in an array so that we could use them for 6371 optimizations. */ 6372 amt = dynsymcount * 2 * sizeof (unsigned long int); 6373 cinfo.hashcodes = (long unsigned int *) bfd_malloc (amt); 6374 if (cinfo.hashcodes == NULL) 6375 return FALSE; 6376 6377 cinfo.hashval = cinfo.hashcodes + dynsymcount; 6378 cinfo.min_dynindx = -1; 6379 cinfo.output_bfd = output_bfd; 6380 cinfo.bed = bed; 6381 6382 /* Put all hash values in HASHCODES. */ 6383 elf_link_hash_traverse (elf_hash_table (info), 6384 elf_collect_gnu_hash_codes, &cinfo); 6385 if (cinfo.error) 6386 { 6387 free (cinfo.hashcodes); 6388 return FALSE; 6389 } 6390 6391 bucketcount 6392 = compute_bucket_count (info, cinfo.hashcodes, cinfo.nsyms, 1); 6393 6394 if (bucketcount == 0) 6395 { 6396 free (cinfo.hashcodes); 6397 return FALSE; 6398 } 6399 6400 s = bfd_get_section_by_name (dynobj, ".gnu.hash"); 6401 BFD_ASSERT (s != NULL); 6402 6403 if (cinfo.nsyms == 0) 6404 { 6405 /* Empty .gnu.hash section is special. */ 6406 BFD_ASSERT (cinfo.min_dynindx == -1); 6407 free (cinfo.hashcodes); 6408 s->size = 5 * 4 + bed->s->arch_size / 8; 6409 contents = (unsigned char *) bfd_zalloc (output_bfd, s->size); 6410 if (contents == NULL) 6411 return FALSE; 6412 s->contents = contents; 6413 /* 1 empty bucket. */ 6414 bfd_put_32 (output_bfd, 1, contents); 6415 /* SYMIDX above the special symbol 0. */ 6416 bfd_put_32 (output_bfd, 1, contents + 4); 6417 /* Just one word for bitmask. */ 6418 bfd_put_32 (output_bfd, 1, contents + 8); 6419 /* Only hash fn bloom filter. */ 6420 bfd_put_32 (output_bfd, 0, contents + 12); 6421 /* No hashes are valid - empty bitmask. */ 6422 bfd_put (bed->s->arch_size, output_bfd, 0, contents + 16); 6423 /* No hashes in the only bucket. */ 6424 bfd_put_32 (output_bfd, 0, 6425 contents + 16 + bed->s->arch_size / 8); 6426 } 6427 else 6428 { 6429 unsigned long int maskwords, maskbitslog2; 6430 BFD_ASSERT (cinfo.min_dynindx != -1); 6431 6432 maskbitslog2 = bfd_log2 (cinfo.nsyms) + 1; 6433 if (maskbitslog2 < 3) 6434 maskbitslog2 = 5; 6435 else if ((1 << (maskbitslog2 - 2)) & cinfo.nsyms) 6436 maskbitslog2 = maskbitslog2 + 3; 6437 else 6438 maskbitslog2 = maskbitslog2 + 2; 6439 if (bed->s->arch_size == 64) 6440 { 6441 if (maskbitslog2 == 5) 6442 maskbitslog2 = 6; 6443 cinfo.shift1 = 6; 6444 } 6445 else 6446 cinfo.shift1 = 5; 6447 cinfo.mask = (1 << cinfo.shift1) - 1; 6448 cinfo.shift2 = maskbitslog2; 6449 cinfo.maskbits = 1 << maskbitslog2; 6450 maskwords = 1 << (maskbitslog2 - cinfo.shift1); 6451 amt = bucketcount * sizeof (unsigned long int) * 2; 6452 amt += maskwords * sizeof (bfd_vma); 6453 cinfo.bitmask = (bfd_vma *) bfd_malloc (amt); 6454 if (cinfo.bitmask == NULL) 6455 { 6456 free (cinfo.hashcodes); 6457 return FALSE; 6458 } 6459 6460 cinfo.counts = (long unsigned int *) (cinfo.bitmask + maskwords); 6461 cinfo.indx = cinfo.counts + bucketcount; 6462 cinfo.symindx = dynsymcount - cinfo.nsyms; 6463 memset (cinfo.bitmask, 0, maskwords * sizeof (bfd_vma)); 6464 6465 /* Determine how often each hash bucket is used. */ 6466 memset (cinfo.counts, 0, bucketcount * sizeof (cinfo.counts[0])); 6467 for (i = 0; i < cinfo.nsyms; ++i) 6468 ++cinfo.counts[cinfo.hashcodes[i] % bucketcount]; 6469 6470 for (i = 0, cnt = cinfo.symindx; i < bucketcount; ++i) 6471 if (cinfo.counts[i] != 0) 6472 { 6473 cinfo.indx[i] = cnt; 6474 cnt += cinfo.counts[i]; 6475 } 6476 BFD_ASSERT (cnt == dynsymcount); 6477 cinfo.bucketcount = bucketcount; 6478 cinfo.local_indx = cinfo.min_dynindx; 6479 6480 s->size = (4 + bucketcount + cinfo.nsyms) * 4; 6481 s->size += cinfo.maskbits / 8; 6482 contents = (unsigned char *) bfd_zalloc (output_bfd, s->size); 6483 if (contents == NULL) 6484 { 6485 free (cinfo.bitmask); 6486 free (cinfo.hashcodes); 6487 return FALSE; 6488 } 6489 6490 s->contents = contents; 6491 bfd_put_32 (output_bfd, bucketcount, contents); 6492 bfd_put_32 (output_bfd, cinfo.symindx, contents + 4); 6493 bfd_put_32 (output_bfd, maskwords, contents + 8); 6494 bfd_put_32 (output_bfd, cinfo.shift2, contents + 12); 6495 contents += 16 + cinfo.maskbits / 8; 6496 6497 for (i = 0; i < bucketcount; ++i) 6498 { 6499 if (cinfo.counts[i] == 0) 6500 bfd_put_32 (output_bfd, 0, contents); 6501 else 6502 bfd_put_32 (output_bfd, cinfo.indx[i], contents); 6503 contents += 4; 6504 } 6505 6506 cinfo.contents = contents; 6507 6508 /* Renumber dynamic symbols, populate .gnu.hash section. */ 6509 elf_link_hash_traverse (elf_hash_table (info), 6510 elf_renumber_gnu_hash_syms, &cinfo); 6511 6512 contents = s->contents + 16; 6513 for (i = 0; i < maskwords; ++i) 6514 { 6515 bfd_put (bed->s->arch_size, output_bfd, cinfo.bitmask[i], 6516 contents); 6517 contents += bed->s->arch_size / 8; 6518 } 6519 6520 free (cinfo.bitmask); 6521 free (cinfo.hashcodes); 6522 } 6523 } 6524 6525 s = bfd_get_section_by_name (dynobj, ".dynstr"); 6526 BFD_ASSERT (s != NULL); 6527 6528 elf_finalize_dynstr (output_bfd, info); 6529 6530 s->size = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr); 6531 6532 for (dtagcount = 0; dtagcount <= info->spare_dynamic_tags; ++dtagcount) 6533 if (!_bfd_elf_add_dynamic_entry (info, DT_NULL, 0)) 6534 return FALSE; 6535 } 6536 6537 return TRUE; 6538 } 6539 6540 /* Indicate that we are only retrieving symbol values from this 6541 section. */ 6542 6543 void 6544 _bfd_elf_link_just_syms (asection *sec, struct bfd_link_info *info) 6545 { 6546 if (is_elf_hash_table (info->hash)) 6547 sec->sec_info_type = ELF_INFO_TYPE_JUST_SYMS; 6548 _bfd_generic_link_just_syms (sec, info); 6549 } 6550 6551 /* Make sure sec_info_type is cleared if sec_info is cleared too. */ 6552 6553 static void 6554 merge_sections_remove_hook (bfd *abfd ATTRIBUTE_UNUSED, 6555 asection *sec) 6556 { 6557 BFD_ASSERT (sec->sec_info_type == ELF_INFO_TYPE_MERGE); 6558 sec->sec_info_type = ELF_INFO_TYPE_NONE; 6559 } 6560 6561 /* Finish SHF_MERGE section merging. */ 6562 6563 bfd_boolean 6564 _bfd_elf_merge_sections (bfd *abfd, struct bfd_link_info *info) 6565 { 6566 bfd *ibfd; 6567 asection *sec; 6568 6569 if (!is_elf_hash_table (info->hash)) 6570 return FALSE; 6571 6572 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 6573 if ((ibfd->flags & DYNAMIC) == 0) 6574 for (sec = ibfd->sections; sec != NULL; sec = sec->next) 6575 if ((sec->flags & SEC_MERGE) != 0 6576 && !bfd_is_abs_section (sec->output_section)) 6577 { 6578 struct bfd_elf_section_data *secdata; 6579 6580 secdata = elf_section_data (sec); 6581 if (! _bfd_add_merge_section (abfd, 6582 &elf_hash_table (info)->merge_info, 6583 sec, &secdata->sec_info)) 6584 return FALSE; 6585 else if (secdata->sec_info) 6586 sec->sec_info_type = ELF_INFO_TYPE_MERGE; 6587 } 6588 6589 if (elf_hash_table (info)->merge_info != NULL) 6590 _bfd_merge_sections (abfd, info, elf_hash_table (info)->merge_info, 6591 merge_sections_remove_hook); 6592 return TRUE; 6593 } 6594 6595 /* Create an entry in an ELF linker hash table. */ 6596 6597 struct bfd_hash_entry * 6598 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry *entry, 6599 struct bfd_hash_table *table, 6600 const char *string) 6601 { 6602 /* Allocate the structure if it has not already been allocated by a 6603 subclass. */ 6604 if (entry == NULL) 6605 { 6606 entry = (struct bfd_hash_entry *) 6607 bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry)); 6608 if (entry == NULL) 6609 return entry; 6610 } 6611 6612 /* Call the allocation method of the superclass. */ 6613 entry = _bfd_link_hash_newfunc (entry, table, string); 6614 if (entry != NULL) 6615 { 6616 struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry; 6617 struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table; 6618 6619 /* Set local fields. */ 6620 ret->indx = -1; 6621 ret->dynindx = -1; 6622 ret->got = htab->init_got_refcount; 6623 ret->plt = htab->init_plt_refcount; 6624 memset (&ret->size, 0, (sizeof (struct elf_link_hash_entry) 6625 - offsetof (struct elf_link_hash_entry, size))); 6626 /* Assume that we have been called by a non-ELF symbol reader. 6627 This flag is then reset by the code which reads an ELF input 6628 file. This ensures that a symbol created by a non-ELF symbol 6629 reader will have the flag set correctly. */ 6630 ret->non_elf = 1; 6631 } 6632 6633 return entry; 6634 } 6635 6636 /* Copy data from an indirect symbol to its direct symbol, hiding the 6637 old indirect symbol. Also used for copying flags to a weakdef. */ 6638 6639 void 6640 _bfd_elf_link_hash_copy_indirect (struct bfd_link_info *info, 6641 struct elf_link_hash_entry *dir, 6642 struct elf_link_hash_entry *ind) 6643 { 6644 struct elf_link_hash_table *htab; 6645 6646 /* Copy down any references that we may have already seen to the 6647 symbol which just became indirect. */ 6648 6649 dir->ref_dynamic |= ind->ref_dynamic; 6650 dir->ref_regular |= ind->ref_regular; 6651 dir->ref_regular_nonweak |= ind->ref_regular_nonweak; 6652 dir->non_got_ref |= ind->non_got_ref; 6653 dir->needs_plt |= ind->needs_plt; 6654 dir->pointer_equality_needed |= ind->pointer_equality_needed; 6655 6656 if (ind->root.type != bfd_link_hash_indirect) 6657 return; 6658 6659 /* Copy over the global and procedure linkage table refcount entries. 6660 These may have been already set up by a check_relocs routine. */ 6661 htab = elf_hash_table (info); 6662 if (ind->got.refcount > htab->init_got_refcount.refcount) 6663 { 6664 if (dir->got.refcount < 0) 6665 dir->got.refcount = 0; 6666 dir->got.refcount += ind->got.refcount; 6667 ind->got.refcount = htab->init_got_refcount.refcount; 6668 } 6669 6670 if (ind->plt.refcount > htab->init_plt_refcount.refcount) 6671 { 6672 if (dir->plt.refcount < 0) 6673 dir->plt.refcount = 0; 6674 dir->plt.refcount += ind->plt.refcount; 6675 ind->plt.refcount = htab->init_plt_refcount.refcount; 6676 } 6677 6678 if (ind->dynindx != -1) 6679 { 6680 if (dir->dynindx != -1) 6681 _bfd_elf_strtab_delref (htab->dynstr, dir->dynstr_index); 6682 dir->dynindx = ind->dynindx; 6683 dir->dynstr_index = ind->dynstr_index; 6684 ind->dynindx = -1; 6685 ind->dynstr_index = 0; 6686 } 6687 } 6688 6689 void 6690 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info *info, 6691 struct elf_link_hash_entry *h, 6692 bfd_boolean force_local) 6693 { 6694 /* STT_GNU_IFUNC symbol must go through PLT. */ 6695 if (h->type != STT_GNU_IFUNC) 6696 { 6697 h->plt = elf_hash_table (info)->init_plt_offset; 6698 h->needs_plt = 0; 6699 } 6700 if (force_local) 6701 { 6702 h->forced_local = 1; 6703 if (h->dynindx != -1) 6704 { 6705 h->dynindx = -1; 6706 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr, 6707 h->dynstr_index); 6708 } 6709 } 6710 } 6711 6712 /* Initialize an ELF linker hash table. */ 6713 6714 bfd_boolean 6715 _bfd_elf_link_hash_table_init 6716 (struct elf_link_hash_table *table, 6717 bfd *abfd, 6718 struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *, 6719 struct bfd_hash_table *, 6720 const char *), 6721 unsigned int entsize) 6722 { 6723 bfd_boolean ret; 6724 int can_refcount = get_elf_backend_data (abfd)->can_refcount; 6725 6726 memset (table, 0, sizeof * table); 6727 table->init_got_refcount.refcount = can_refcount - 1; 6728 table->init_plt_refcount.refcount = can_refcount - 1; 6729 table->init_got_offset.offset = -(bfd_vma) 1; 6730 table->init_plt_offset.offset = -(bfd_vma) 1; 6731 /* The first dynamic symbol is a dummy. */ 6732 table->dynsymcount = 1; 6733 6734 ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize); 6735 table->root.type = bfd_link_elf_hash_table; 6736 6737 return ret; 6738 } 6739 6740 /* Create an ELF linker hash table. */ 6741 6742 struct bfd_link_hash_table * 6743 _bfd_elf_link_hash_table_create (bfd *abfd) 6744 { 6745 struct elf_link_hash_table *ret; 6746 bfd_size_type amt = sizeof (struct elf_link_hash_table); 6747 6748 ret = (struct elf_link_hash_table *) bfd_malloc (amt); 6749 if (ret == NULL) 6750 return NULL; 6751 6752 if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc, 6753 sizeof (struct elf_link_hash_entry))) 6754 { 6755 free (ret); 6756 return NULL; 6757 } 6758 6759 return &ret->root; 6760 } 6761 6762 /* This is a hook for the ELF emulation code in the generic linker to 6763 tell the backend linker what file name to use for the DT_NEEDED 6764 entry for a dynamic object. */ 6765 6766 void 6767 bfd_elf_set_dt_needed_name (bfd *abfd, const char *name) 6768 { 6769 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour 6770 && bfd_get_format (abfd) == bfd_object) 6771 elf_dt_name (abfd) = name; 6772 } 6773 6774 int 6775 bfd_elf_get_dyn_lib_class (bfd *abfd) 6776 { 6777 int lib_class; 6778 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour 6779 && bfd_get_format (abfd) == bfd_object) 6780 lib_class = elf_dyn_lib_class (abfd); 6781 else 6782 lib_class = 0; 6783 return lib_class; 6784 } 6785 6786 void 6787 bfd_elf_set_dyn_lib_class (bfd *abfd, enum dynamic_lib_link_class lib_class) 6788 { 6789 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour 6790 && bfd_get_format (abfd) == bfd_object) 6791 elf_dyn_lib_class (abfd) = lib_class; 6792 } 6793 6794 /* Get the list of DT_NEEDED entries for a link. This is a hook for 6795 the linker ELF emulation code. */ 6796 6797 struct bfd_link_needed_list * 6798 bfd_elf_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED, 6799 struct bfd_link_info *info) 6800 { 6801 if (! is_elf_hash_table (info->hash)) 6802 return NULL; 6803 return elf_hash_table (info)->needed; 6804 } 6805 6806 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a 6807 hook for the linker ELF emulation code. */ 6808 6809 struct bfd_link_needed_list * 6810 bfd_elf_get_runpath_list (bfd *abfd ATTRIBUTE_UNUSED, 6811 struct bfd_link_info *info) 6812 { 6813 if (! is_elf_hash_table (info->hash)) 6814 return NULL; 6815 return elf_hash_table (info)->runpath; 6816 } 6817 6818 /* Get the name actually used for a dynamic object for a link. This 6819 is the SONAME entry if there is one. Otherwise, it is the string 6820 passed to bfd_elf_set_dt_needed_name, or it is the filename. */ 6821 6822 const char * 6823 bfd_elf_get_dt_soname (bfd *abfd) 6824 { 6825 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour 6826 && bfd_get_format (abfd) == bfd_object) 6827 return elf_dt_name (abfd); 6828 return NULL; 6829 } 6830 6831 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for 6832 the ELF linker emulation code. */ 6833 6834 bfd_boolean 6835 bfd_elf_get_bfd_needed_list (bfd *abfd, 6836 struct bfd_link_needed_list **pneeded) 6837 { 6838 asection *s; 6839 bfd_byte *dynbuf = NULL; 6840 unsigned int elfsec; 6841 unsigned long shlink; 6842 bfd_byte *extdyn, *extdynend; 6843 size_t extdynsize; 6844 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *); 6845 6846 *pneeded = NULL; 6847 6848 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour 6849 || bfd_get_format (abfd) != bfd_object) 6850 return TRUE; 6851 6852 s = bfd_get_section_by_name (abfd, ".dynamic"); 6853 if (s == NULL || s->size == 0) 6854 return TRUE; 6855 6856 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf)) 6857 goto error_return; 6858 6859 elfsec = _bfd_elf_section_from_bfd_section (abfd, s); 6860 if (elfsec == SHN_BAD) 6861 goto error_return; 6862 6863 shlink = elf_elfsections (abfd)[elfsec]->sh_link; 6864 6865 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn; 6866 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in; 6867 6868 extdyn = dynbuf; 6869 extdynend = extdyn + s->size; 6870 for (; extdyn < extdynend; extdyn += extdynsize) 6871 { 6872 Elf_Internal_Dyn dyn; 6873 6874 (*swap_dyn_in) (abfd, extdyn, &dyn); 6875 6876 if (dyn.d_tag == DT_NULL) 6877 break; 6878 6879 if (dyn.d_tag == DT_NEEDED) 6880 { 6881 const char *string; 6882 struct bfd_link_needed_list *l; 6883 unsigned int tagv = dyn.d_un.d_val; 6884 bfd_size_type amt; 6885 6886 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv); 6887 if (string == NULL) 6888 goto error_return; 6889 6890 amt = sizeof *l; 6891 l = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt); 6892 if (l == NULL) 6893 goto error_return; 6894 6895 l->by = abfd; 6896 l->name = string; 6897 l->next = *pneeded; 6898 *pneeded = l; 6899 } 6900 } 6901 6902 free (dynbuf); 6903 6904 return TRUE; 6905 6906 error_return: 6907 if (dynbuf != NULL) 6908 free (dynbuf); 6909 return FALSE; 6910 } 6911 6912 struct elf_symbuf_symbol 6913 { 6914 unsigned long st_name; /* Symbol name, index in string tbl */ 6915 unsigned char st_info; /* Type and binding attributes */ 6916 unsigned char st_other; /* Visibilty, and target specific */ 6917 }; 6918 6919 struct elf_symbuf_head 6920 { 6921 struct elf_symbuf_symbol *ssym; 6922 bfd_size_type count; 6923 unsigned int st_shndx; 6924 }; 6925 6926 struct elf_symbol 6927 { 6928 union 6929 { 6930 Elf_Internal_Sym *isym; 6931 struct elf_symbuf_symbol *ssym; 6932 } u; 6933 const char *name; 6934 }; 6935 6936 /* Sort references to symbols by ascending section number. */ 6937 6938 static int 6939 elf_sort_elf_symbol (const void *arg1, const void *arg2) 6940 { 6941 const Elf_Internal_Sym *s1 = *(const Elf_Internal_Sym **) arg1; 6942 const Elf_Internal_Sym *s2 = *(const Elf_Internal_Sym **) arg2; 6943 6944 return s1->st_shndx - s2->st_shndx; 6945 } 6946 6947 static int 6948 elf_sym_name_compare (const void *arg1, const void *arg2) 6949 { 6950 const struct elf_symbol *s1 = (const struct elf_symbol *) arg1; 6951 const struct elf_symbol *s2 = (const struct elf_symbol *) arg2; 6952 return strcmp (s1->name, s2->name); 6953 } 6954 6955 static struct elf_symbuf_head * 6956 elf_create_symbuf (bfd_size_type symcount, Elf_Internal_Sym *isymbuf) 6957 { 6958 Elf_Internal_Sym **ind, **indbufend, **indbuf; 6959 struct elf_symbuf_symbol *ssym; 6960 struct elf_symbuf_head *ssymbuf, *ssymhead; 6961 bfd_size_type i, shndx_count, total_size; 6962 6963 indbuf = (Elf_Internal_Sym **) bfd_malloc2 (symcount, sizeof (*indbuf)); 6964 if (indbuf == NULL) 6965 return NULL; 6966 6967 for (ind = indbuf, i = 0; i < symcount; i++) 6968 if (isymbuf[i].st_shndx != SHN_UNDEF) 6969 *ind++ = &isymbuf[i]; 6970 indbufend = ind; 6971 6972 qsort (indbuf, indbufend - indbuf, sizeof (Elf_Internal_Sym *), 6973 elf_sort_elf_symbol); 6974 6975 shndx_count = 0; 6976 if (indbufend > indbuf) 6977 for (ind = indbuf, shndx_count++; ind < indbufend - 1; ind++) 6978 if (ind[0]->st_shndx != ind[1]->st_shndx) 6979 shndx_count++; 6980 6981 total_size = ((shndx_count + 1) * sizeof (*ssymbuf) 6982 + (indbufend - indbuf) * sizeof (*ssym)); 6983 ssymbuf = (struct elf_symbuf_head *) bfd_malloc (total_size); 6984 if (ssymbuf == NULL) 6985 { 6986 free (indbuf); 6987 return NULL; 6988 } 6989 6990 ssym = (struct elf_symbuf_symbol *) (ssymbuf + shndx_count + 1); 6991 ssymbuf->ssym = NULL; 6992 ssymbuf->count = shndx_count; 6993 ssymbuf->st_shndx = 0; 6994 for (ssymhead = ssymbuf, ind = indbuf; ind < indbufend; ssym++, ind++) 6995 { 6996 if (ind == indbuf || ssymhead->st_shndx != (*ind)->st_shndx) 6997 { 6998 ssymhead++; 6999 ssymhead->ssym = ssym; 7000 ssymhead->count = 0; 7001 ssymhead->st_shndx = (*ind)->st_shndx; 7002 } 7003 ssym->st_name = (*ind)->st_name; 7004 ssym->st_info = (*ind)->st_info; 7005 ssym->st_other = (*ind)->st_other; 7006 ssymhead->count++; 7007 } 7008 BFD_ASSERT ((bfd_size_type) (ssymhead - ssymbuf) == shndx_count 7009 && (((bfd_hostptr_t) ssym - (bfd_hostptr_t) ssymbuf) 7010 == total_size)); 7011 7012 free (indbuf); 7013 return ssymbuf; 7014 } 7015 7016 /* Check if 2 sections define the same set of local and global 7017 symbols. */ 7018 7019 static bfd_boolean 7020 bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2, 7021 struct bfd_link_info *info) 7022 { 7023 bfd *bfd1, *bfd2; 7024 const struct elf_backend_data *bed1, *bed2; 7025 Elf_Internal_Shdr *hdr1, *hdr2; 7026 bfd_size_type symcount1, symcount2; 7027 Elf_Internal_Sym *isymbuf1, *isymbuf2; 7028 struct elf_symbuf_head *ssymbuf1, *ssymbuf2; 7029 Elf_Internal_Sym *isym, *isymend; 7030 struct elf_symbol *symtable1 = NULL, *symtable2 = NULL; 7031 bfd_size_type count1, count2, i; 7032 unsigned int shndx1, shndx2; 7033 bfd_boolean result; 7034 7035 bfd1 = sec1->owner; 7036 bfd2 = sec2->owner; 7037 7038 /* Both sections have to be in ELF. */ 7039 if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour 7040 || bfd_get_flavour (bfd2) != bfd_target_elf_flavour) 7041 return FALSE; 7042 7043 if (elf_section_type (sec1) != elf_section_type (sec2)) 7044 return FALSE; 7045 7046 shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1); 7047 shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2); 7048 if (shndx1 == SHN_BAD || shndx2 == SHN_BAD) 7049 return FALSE; 7050 7051 bed1 = get_elf_backend_data (bfd1); 7052 bed2 = get_elf_backend_data (bfd2); 7053 hdr1 = &elf_tdata (bfd1)->symtab_hdr; 7054 symcount1 = hdr1->sh_size / bed1->s->sizeof_sym; 7055 hdr2 = &elf_tdata (bfd2)->symtab_hdr; 7056 symcount2 = hdr2->sh_size / bed2->s->sizeof_sym; 7057 7058 if (symcount1 == 0 || symcount2 == 0) 7059 return FALSE; 7060 7061 result = FALSE; 7062 isymbuf1 = NULL; 7063 isymbuf2 = NULL; 7064 ssymbuf1 = (struct elf_symbuf_head *) elf_tdata (bfd1)->symbuf; 7065 ssymbuf2 = (struct elf_symbuf_head *) elf_tdata (bfd2)->symbuf; 7066 7067 if (ssymbuf1 == NULL) 7068 { 7069 isymbuf1 = bfd_elf_get_elf_syms (bfd1, hdr1, symcount1, 0, 7070 NULL, NULL, NULL); 7071 if (isymbuf1 == NULL) 7072 goto done; 7073 7074 if (!info->reduce_memory_overheads) 7075 elf_tdata (bfd1)->symbuf = ssymbuf1 7076 = elf_create_symbuf (symcount1, isymbuf1); 7077 } 7078 7079 if (ssymbuf1 == NULL || ssymbuf2 == NULL) 7080 { 7081 isymbuf2 = bfd_elf_get_elf_syms (bfd2, hdr2, symcount2, 0, 7082 NULL, NULL, NULL); 7083 if (isymbuf2 == NULL) 7084 goto done; 7085 7086 if (ssymbuf1 != NULL && !info->reduce_memory_overheads) 7087 elf_tdata (bfd2)->symbuf = ssymbuf2 7088 = elf_create_symbuf (symcount2, isymbuf2); 7089 } 7090 7091 if (ssymbuf1 != NULL && ssymbuf2 != NULL) 7092 { 7093 /* Optimized faster version. */ 7094 bfd_size_type lo, hi, mid; 7095 struct elf_symbol *symp; 7096 struct elf_symbuf_symbol *ssym, *ssymend; 7097 7098 lo = 0; 7099 hi = ssymbuf1->count; 7100 ssymbuf1++; 7101 count1 = 0; 7102 while (lo < hi) 7103 { 7104 mid = (lo + hi) / 2; 7105 if (shndx1 < ssymbuf1[mid].st_shndx) 7106 hi = mid; 7107 else if (shndx1 > ssymbuf1[mid].st_shndx) 7108 lo = mid + 1; 7109 else 7110 { 7111 count1 = ssymbuf1[mid].count; 7112 ssymbuf1 += mid; 7113 break; 7114 } 7115 } 7116 7117 lo = 0; 7118 hi = ssymbuf2->count; 7119 ssymbuf2++; 7120 count2 = 0; 7121 while (lo < hi) 7122 { 7123 mid = (lo + hi) / 2; 7124 if (shndx2 < ssymbuf2[mid].st_shndx) 7125 hi = mid; 7126 else if (shndx2 > ssymbuf2[mid].st_shndx) 7127 lo = mid + 1; 7128 else 7129 { 7130 count2 = ssymbuf2[mid].count; 7131 ssymbuf2 += mid; 7132 break; 7133 } 7134 } 7135 7136 if (count1 == 0 || count2 == 0 || count1 != count2) 7137 goto done; 7138 7139 symtable1 = (struct elf_symbol *) 7140 bfd_malloc (count1 * sizeof (struct elf_symbol)); 7141 symtable2 = (struct elf_symbol *) 7142 bfd_malloc (count2 * sizeof (struct elf_symbol)); 7143 if (symtable1 == NULL || symtable2 == NULL) 7144 goto done; 7145 7146 symp = symtable1; 7147 for (ssym = ssymbuf1->ssym, ssymend = ssym + count1; 7148 ssym < ssymend; ssym++, symp++) 7149 { 7150 symp->u.ssym = ssym; 7151 symp->name = bfd_elf_string_from_elf_section (bfd1, 7152 hdr1->sh_link, 7153 ssym->st_name); 7154 } 7155 7156 symp = symtable2; 7157 for (ssym = ssymbuf2->ssym, ssymend = ssym + count2; 7158 ssym < ssymend; ssym++, symp++) 7159 { 7160 symp->u.ssym = ssym; 7161 symp->name = bfd_elf_string_from_elf_section (bfd2, 7162 hdr2->sh_link, 7163 ssym->st_name); 7164 } 7165 7166 /* Sort symbol by name. */ 7167 qsort (symtable1, count1, sizeof (struct elf_symbol), 7168 elf_sym_name_compare); 7169 qsort (symtable2, count1, sizeof (struct elf_symbol), 7170 elf_sym_name_compare); 7171 7172 for (i = 0; i < count1; i++) 7173 /* Two symbols must have the same binding, type and name. */ 7174 if (symtable1 [i].u.ssym->st_info != symtable2 [i].u.ssym->st_info 7175 || symtable1 [i].u.ssym->st_other != symtable2 [i].u.ssym->st_other 7176 || strcmp (symtable1 [i].name, symtable2 [i].name) != 0) 7177 goto done; 7178 7179 result = TRUE; 7180 goto done; 7181 } 7182 7183 symtable1 = (struct elf_symbol *) 7184 bfd_malloc (symcount1 * sizeof (struct elf_symbol)); 7185 symtable2 = (struct elf_symbol *) 7186 bfd_malloc (symcount2 * sizeof (struct elf_symbol)); 7187 if (symtable1 == NULL || symtable2 == NULL) 7188 goto done; 7189 7190 /* Count definitions in the section. */ 7191 count1 = 0; 7192 for (isym = isymbuf1, isymend = isym + symcount1; isym < isymend; isym++) 7193 if (isym->st_shndx == shndx1) 7194 symtable1[count1++].u.isym = isym; 7195 7196 count2 = 0; 7197 for (isym = isymbuf2, isymend = isym + symcount2; isym < isymend; isym++) 7198 if (isym->st_shndx == shndx2) 7199 symtable2[count2++].u.isym = isym; 7200 7201 if (count1 == 0 || count2 == 0 || count1 != count2) 7202 goto done; 7203 7204 for (i = 0; i < count1; i++) 7205 symtable1[i].name 7206 = bfd_elf_string_from_elf_section (bfd1, hdr1->sh_link, 7207 symtable1[i].u.isym->st_name); 7208 7209 for (i = 0; i < count2; i++) 7210 symtable2[i].name 7211 = bfd_elf_string_from_elf_section (bfd2, hdr2->sh_link, 7212 symtable2[i].u.isym->st_name); 7213 7214 /* Sort symbol by name. */ 7215 qsort (symtable1, count1, sizeof (struct elf_symbol), 7216 elf_sym_name_compare); 7217 qsort (symtable2, count1, sizeof (struct elf_symbol), 7218 elf_sym_name_compare); 7219 7220 for (i = 0; i < count1; i++) 7221 /* Two symbols must have the same binding, type and name. */ 7222 if (symtable1 [i].u.isym->st_info != symtable2 [i].u.isym->st_info 7223 || symtable1 [i].u.isym->st_other != symtable2 [i].u.isym->st_other 7224 || strcmp (symtable1 [i].name, symtable2 [i].name) != 0) 7225 goto done; 7226 7227 result = TRUE; 7228 7229 done: 7230 if (symtable1) 7231 free (symtable1); 7232 if (symtable2) 7233 free (symtable2); 7234 if (isymbuf1) 7235 free (isymbuf1); 7236 if (isymbuf2) 7237 free (isymbuf2); 7238 7239 return result; 7240 } 7241 7242 /* Return TRUE if 2 section types are compatible. */ 7243 7244 bfd_boolean 7245 _bfd_elf_match_sections_by_type (bfd *abfd, const asection *asec, 7246 bfd *bbfd, const asection *bsec) 7247 { 7248 if (asec == NULL 7249 || bsec == NULL 7250 || abfd->xvec->flavour != bfd_target_elf_flavour 7251 || bbfd->xvec->flavour != bfd_target_elf_flavour) 7252 return TRUE; 7253 7254 return elf_section_type (asec) == elf_section_type (bsec); 7255 } 7256 7257 /* Final phase of ELF linker. */ 7258 7259 /* A structure we use to avoid passing large numbers of arguments. */ 7260 7261 struct elf_final_link_info 7262 { 7263 /* General link information. */ 7264 struct bfd_link_info *info; 7265 /* Output BFD. */ 7266 bfd *output_bfd; 7267 /* Symbol string table. */ 7268 struct bfd_strtab_hash *symstrtab; 7269 /* .dynsym section. */ 7270 asection *dynsym_sec; 7271 /* .hash section. */ 7272 asection *hash_sec; 7273 /* symbol version section (.gnu.version). */ 7274 asection *symver_sec; 7275 /* Buffer large enough to hold contents of any section. */ 7276 bfd_byte *contents; 7277 /* Buffer large enough to hold external relocs of any section. */ 7278 void *external_relocs; 7279 /* Buffer large enough to hold internal relocs of any section. */ 7280 Elf_Internal_Rela *internal_relocs; 7281 /* Buffer large enough to hold external local symbols of any input 7282 BFD. */ 7283 bfd_byte *external_syms; 7284 /* And a buffer for symbol section indices. */ 7285 Elf_External_Sym_Shndx *locsym_shndx; 7286 /* Buffer large enough to hold internal local symbols of any input 7287 BFD. */ 7288 Elf_Internal_Sym *internal_syms; 7289 /* Array large enough to hold a symbol index for each local symbol 7290 of any input BFD. */ 7291 long *indices; 7292 /* Array large enough to hold a section pointer for each local 7293 symbol of any input BFD. */ 7294 asection **sections; 7295 /* Buffer to hold swapped out symbols. */ 7296 bfd_byte *symbuf; 7297 /* And one for symbol section indices. */ 7298 Elf_External_Sym_Shndx *symshndxbuf; 7299 /* Number of swapped out symbols in buffer. */ 7300 size_t symbuf_count; 7301 /* Number of symbols which fit in symbuf. */ 7302 size_t symbuf_size; 7303 /* And same for symshndxbuf. */ 7304 size_t shndxbuf_size; 7305 }; 7306 7307 /* This struct is used to pass information to elf_link_output_extsym. */ 7308 7309 struct elf_outext_info 7310 { 7311 bfd_boolean failed; 7312 bfd_boolean localsyms; 7313 struct elf_final_link_info *finfo; 7314 }; 7315 7316 7317 /* Support for evaluating a complex relocation. 7318 7319 Complex relocations are generalized, self-describing relocations. The 7320 implementation of them consists of two parts: complex symbols, and the 7321 relocations themselves. 7322 7323 The relocations are use a reserved elf-wide relocation type code (R_RELC 7324 external / BFD_RELOC_RELC internal) and an encoding of relocation field 7325 information (start bit, end bit, word width, etc) into the addend. This 7326 information is extracted from CGEN-generated operand tables within gas. 7327 7328 Complex symbols are mangled symbols (BSF_RELC external / STT_RELC 7329 internal) representing prefix-notation expressions, including but not 7330 limited to those sorts of expressions normally encoded as addends in the 7331 addend field. The symbol mangling format is: 7332 7333 <node> := <literal> 7334 | <unary-operator> ':' <node> 7335 | <binary-operator> ':' <node> ':' <node> 7336 ; 7337 7338 <literal> := 's' <digits=N> ':' <N character symbol name> 7339 | 'S' <digits=N> ':' <N character section name> 7340 | '#' <hexdigits> 7341 ; 7342 7343 <binary-operator> := as in C 7344 <unary-operator> := as in C, plus "0-" for unambiguous negation. */ 7345 7346 static void 7347 set_symbol_value (bfd *bfd_with_globals, 7348 Elf_Internal_Sym *isymbuf, 7349 size_t locsymcount, 7350 size_t symidx, 7351 bfd_vma val) 7352 { 7353 struct elf_link_hash_entry **sym_hashes; 7354 struct elf_link_hash_entry *h; 7355 size_t extsymoff = locsymcount; 7356 7357 if (symidx < locsymcount) 7358 { 7359 Elf_Internal_Sym *sym; 7360 7361 sym = isymbuf + symidx; 7362 if (ELF_ST_BIND (sym->st_info) == STB_LOCAL) 7363 { 7364 /* It is a local symbol: move it to the 7365 "absolute" section and give it a value. */ 7366 sym->st_shndx = SHN_ABS; 7367 sym->st_value = val; 7368 return; 7369 } 7370 BFD_ASSERT (elf_bad_symtab (bfd_with_globals)); 7371 extsymoff = 0; 7372 } 7373 7374 /* It is a global symbol: set its link type 7375 to "defined" and give it a value. */ 7376 7377 sym_hashes = elf_sym_hashes (bfd_with_globals); 7378 h = sym_hashes [symidx - extsymoff]; 7379 while (h->root.type == bfd_link_hash_indirect 7380 || h->root.type == bfd_link_hash_warning) 7381 h = (struct elf_link_hash_entry *) h->root.u.i.link; 7382 h->root.type = bfd_link_hash_defined; 7383 h->root.u.def.value = val; 7384 h->root.u.def.section = bfd_abs_section_ptr; 7385 } 7386 7387 static bfd_boolean 7388 resolve_symbol (const char *name, 7389 bfd *input_bfd, 7390 struct elf_final_link_info *finfo, 7391 bfd_vma *result, 7392 Elf_Internal_Sym *isymbuf, 7393 size_t locsymcount) 7394 { 7395 Elf_Internal_Sym *sym; 7396 struct bfd_link_hash_entry *global_entry; 7397 const char *candidate = NULL; 7398 Elf_Internal_Shdr *symtab_hdr; 7399 size_t i; 7400 7401 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; 7402 7403 for (i = 0; i < locsymcount; ++ i) 7404 { 7405 sym = isymbuf + i; 7406 7407 if (ELF_ST_BIND (sym->st_info) != STB_LOCAL) 7408 continue; 7409 7410 candidate = bfd_elf_string_from_elf_section (input_bfd, 7411 symtab_hdr->sh_link, 7412 sym->st_name); 7413 #ifdef DEBUG 7414 printf ("Comparing string: '%s' vs. '%s' = 0x%lx\n", 7415 name, candidate, (unsigned long) sym->st_value); 7416 #endif 7417 if (candidate && strcmp (candidate, name) == 0) 7418 { 7419 asection *sec = finfo->sections [i]; 7420 7421 *result = _bfd_elf_rel_local_sym (input_bfd, sym, &sec, 0); 7422 *result += sec->output_offset + sec->output_section->vma; 7423 #ifdef DEBUG 7424 printf ("Found symbol with value %8.8lx\n", 7425 (unsigned long) *result); 7426 #endif 7427 return TRUE; 7428 } 7429 } 7430 7431 /* Hmm, haven't found it yet. perhaps it is a global. */ 7432 global_entry = bfd_link_hash_lookup (finfo->info->hash, name, 7433 FALSE, FALSE, TRUE); 7434 if (!global_entry) 7435 return FALSE; 7436 7437 if (global_entry->type == bfd_link_hash_defined 7438 || global_entry->type == bfd_link_hash_defweak) 7439 { 7440 *result = (global_entry->u.def.value 7441 + global_entry->u.def.section->output_section->vma 7442 + global_entry->u.def.section->output_offset); 7443 #ifdef DEBUG 7444 printf ("Found GLOBAL symbol '%s' with value %8.8lx\n", 7445 global_entry->root.string, (unsigned long) *result); 7446 #endif 7447 return TRUE; 7448 } 7449 7450 return FALSE; 7451 } 7452 7453 static bfd_boolean 7454 resolve_section (const char *name, 7455 asection *sections, 7456 bfd_vma *result) 7457 { 7458 asection *curr; 7459 unsigned int len; 7460 7461 for (curr = sections; curr; curr = curr->next) 7462 if (strcmp (curr->name, name) == 0) 7463 { 7464 *result = curr->vma; 7465 return TRUE; 7466 } 7467 7468 /* Hmm. still haven't found it. try pseudo-section names. */ 7469 for (curr = sections; curr; curr = curr->next) 7470 { 7471 len = strlen (curr->name); 7472 if (len > strlen (name)) 7473 continue; 7474 7475 if (strncmp (curr->name, name, len) == 0) 7476 { 7477 if (strncmp (".end", name + len, 4) == 0) 7478 { 7479 *result = curr->vma + curr->size; 7480 return TRUE; 7481 } 7482 7483 /* Insert more pseudo-section names here, if you like. */ 7484 } 7485 } 7486 7487 return FALSE; 7488 } 7489 7490 static void 7491 undefined_reference (const char *reftype, const char *name) 7492 { 7493 _bfd_error_handler (_("undefined %s reference in complex symbol: %s"), 7494 reftype, name); 7495 } 7496 7497 static bfd_boolean 7498 eval_symbol (bfd_vma *result, 7499 const char **symp, 7500 bfd *input_bfd, 7501 struct elf_final_link_info *finfo, 7502 bfd_vma dot, 7503 Elf_Internal_Sym *isymbuf, 7504 size_t locsymcount, 7505 int signed_p) 7506 { 7507 size_t len; 7508 size_t symlen; 7509 bfd_vma a; 7510 bfd_vma b; 7511 char symbuf[4096]; 7512 const char *sym = *symp; 7513 const char *symend; 7514 bfd_boolean symbol_is_section = FALSE; 7515 7516 len = strlen (sym); 7517 symend = sym + len; 7518 7519 if (len < 1 || len > sizeof (symbuf)) 7520 { 7521 bfd_set_error (bfd_error_invalid_operation); 7522 return FALSE; 7523 } 7524 7525 switch (* sym) 7526 { 7527 case '.': 7528 *result = dot; 7529 *symp = sym + 1; 7530 return TRUE; 7531 7532 case '#': 7533 ++sym; 7534 *result = strtoul (sym, (char **) symp, 16); 7535 return TRUE; 7536 7537 case 'S': 7538 symbol_is_section = TRUE; 7539 case 's': 7540 ++sym; 7541 symlen = strtol (sym, (char **) symp, 10); 7542 sym = *symp + 1; /* Skip the trailing ':'. */ 7543 7544 if (symend < sym || symlen + 1 > sizeof (symbuf)) 7545 { 7546 bfd_set_error (bfd_error_invalid_operation); 7547 return FALSE; 7548 } 7549 7550 memcpy (symbuf, sym, symlen); 7551 symbuf[symlen] = '\0'; 7552 *symp = sym + symlen; 7553 7554 /* Is it always possible, with complex symbols, that gas "mis-guessed" 7555 the symbol as a section, or vice-versa. so we're pretty liberal in our 7556 interpretation here; section means "try section first", not "must be a 7557 section", and likewise with symbol. */ 7558 7559 if (symbol_is_section) 7560 { 7561 if (!resolve_section (symbuf, finfo->output_bfd->sections, result) 7562 && !resolve_symbol (symbuf, input_bfd, finfo, result, 7563 isymbuf, locsymcount)) 7564 { 7565 undefined_reference ("section", symbuf); 7566 return FALSE; 7567 } 7568 } 7569 else 7570 { 7571 if (!resolve_symbol (symbuf, input_bfd, finfo, result, 7572 isymbuf, locsymcount) 7573 && !resolve_section (symbuf, finfo->output_bfd->sections, 7574 result)) 7575 { 7576 undefined_reference ("symbol", symbuf); 7577 return FALSE; 7578 } 7579 } 7580 7581 return TRUE; 7582 7583 /* All that remains are operators. */ 7584 7585 #define UNARY_OP(op) \ 7586 if (strncmp (sym, #op, strlen (#op)) == 0) \ 7587 { \ 7588 sym += strlen (#op); \ 7589 if (*sym == ':') \ 7590 ++sym; \ 7591 *symp = sym; \ 7592 if (!eval_symbol (&a, symp, input_bfd, finfo, dot, \ 7593 isymbuf, locsymcount, signed_p)) \ 7594 return FALSE; \ 7595 if (signed_p) \ 7596 *result = op ((bfd_signed_vma) a); \ 7597 else \ 7598 *result = op a; \ 7599 return TRUE; \ 7600 } 7601 7602 #define BINARY_OP(op) \ 7603 if (strncmp (sym, #op, strlen (#op)) == 0) \ 7604 { \ 7605 sym += strlen (#op); \ 7606 if (*sym == ':') \ 7607 ++sym; \ 7608 *symp = sym; \ 7609 if (!eval_symbol (&a, symp, input_bfd, finfo, dot, \ 7610 isymbuf, locsymcount, signed_p)) \ 7611 return FALSE; \ 7612 ++*symp; \ 7613 if (!eval_symbol (&b, symp, input_bfd, finfo, dot, \ 7614 isymbuf, locsymcount, signed_p)) \ 7615 return FALSE; \ 7616 if (signed_p) \ 7617 *result = ((bfd_signed_vma) a) op ((bfd_signed_vma) b); \ 7618 else \ 7619 *result = a op b; \ 7620 return TRUE; \ 7621 } 7622 7623 default: 7624 UNARY_OP (0-); 7625 BINARY_OP (<<); 7626 BINARY_OP (>>); 7627 BINARY_OP (==); 7628 BINARY_OP (!=); 7629 BINARY_OP (<=); 7630 BINARY_OP (>=); 7631 BINARY_OP (&&); 7632 BINARY_OP (||); 7633 UNARY_OP (~); 7634 UNARY_OP (!); 7635 BINARY_OP (*); 7636 BINARY_OP (/); 7637 BINARY_OP (%); 7638 BINARY_OP (^); 7639 BINARY_OP (|); 7640 BINARY_OP (&); 7641 BINARY_OP (+); 7642 BINARY_OP (-); 7643 BINARY_OP (<); 7644 BINARY_OP (>); 7645 #undef UNARY_OP 7646 #undef BINARY_OP 7647 _bfd_error_handler (_("unknown operator '%c' in complex symbol"), * sym); 7648 bfd_set_error (bfd_error_invalid_operation); 7649 return FALSE; 7650 } 7651 } 7652 7653 static void 7654 put_value (bfd_vma size, 7655 unsigned long chunksz, 7656 bfd *input_bfd, 7657 bfd_vma x, 7658 bfd_byte *location) 7659 { 7660 location += (size - chunksz); 7661 7662 for (; size; size -= chunksz, location -= chunksz, x >>= (chunksz * 8)) 7663 { 7664 switch (chunksz) 7665 { 7666 default: 7667 case 0: 7668 abort (); 7669 case 1: 7670 bfd_put_8 (input_bfd, x, location); 7671 break; 7672 case 2: 7673 bfd_put_16 (input_bfd, x, location); 7674 break; 7675 case 4: 7676 bfd_put_32 (input_bfd, x, location); 7677 break; 7678 case 8: 7679 #ifdef BFD64 7680 bfd_put_64 (input_bfd, x, location); 7681 #else 7682 abort (); 7683 #endif 7684 break; 7685 } 7686 } 7687 } 7688 7689 static bfd_vma 7690 get_value (bfd_vma size, 7691 unsigned long chunksz, 7692 bfd *input_bfd, 7693 bfd_byte *location) 7694 { 7695 bfd_vma x = 0; 7696 7697 for (; size; size -= chunksz, location += chunksz) 7698 { 7699 switch (chunksz) 7700 { 7701 default: 7702 case 0: 7703 abort (); 7704 case 1: 7705 x = (x << (8 * chunksz)) | bfd_get_8 (input_bfd, location); 7706 break; 7707 case 2: 7708 x = (x << (8 * chunksz)) | bfd_get_16 (input_bfd, location); 7709 break; 7710 case 4: 7711 x = (x << (8 * chunksz)) | bfd_get_32 (input_bfd, location); 7712 break; 7713 case 8: 7714 #ifdef BFD64 7715 x = (x << (8 * chunksz)) | bfd_get_64 (input_bfd, location); 7716 #else 7717 abort (); 7718 #endif 7719 break; 7720 } 7721 } 7722 return x; 7723 } 7724 7725 static void 7726 decode_complex_addend (unsigned long *start, /* in bits */ 7727 unsigned long *oplen, /* in bits */ 7728 unsigned long *len, /* in bits */ 7729 unsigned long *wordsz, /* in bytes */ 7730 unsigned long *chunksz, /* in bytes */ 7731 unsigned long *lsb0_p, 7732 unsigned long *signed_p, 7733 unsigned long *trunc_p, 7734 unsigned long encoded) 7735 { 7736 * start = encoded & 0x3F; 7737 * len = (encoded >> 6) & 0x3F; 7738 * oplen = (encoded >> 12) & 0x3F; 7739 * wordsz = (encoded >> 18) & 0xF; 7740 * chunksz = (encoded >> 22) & 0xF; 7741 * lsb0_p = (encoded >> 27) & 1; 7742 * signed_p = (encoded >> 28) & 1; 7743 * trunc_p = (encoded >> 29) & 1; 7744 } 7745 7746 bfd_reloc_status_type 7747 bfd_elf_perform_complex_relocation (bfd *input_bfd, 7748 asection *input_section ATTRIBUTE_UNUSED, 7749 bfd_byte *contents, 7750 Elf_Internal_Rela *rel, 7751 bfd_vma relocation) 7752 { 7753 bfd_vma shift, x, mask; 7754 unsigned long start, oplen, len, wordsz, chunksz, lsb0_p, signed_p, trunc_p; 7755 bfd_reloc_status_type r; 7756 7757 /* Perform this reloc, since it is complex. 7758 (this is not to say that it necessarily refers to a complex 7759 symbol; merely that it is a self-describing CGEN based reloc. 7760 i.e. the addend has the complete reloc information (bit start, end, 7761 word size, etc) encoded within it.). */ 7762 7763 decode_complex_addend (&start, &oplen, &len, &wordsz, 7764 &chunksz, &lsb0_p, &signed_p, 7765 &trunc_p, rel->r_addend); 7766 7767 mask = (((1L << (len - 1)) - 1) << 1) | 1; 7768 7769 if (lsb0_p) 7770 shift = (start + 1) - len; 7771 else 7772 shift = (8 * wordsz) - (start + len); 7773 7774 /* FIXME: octets_per_byte. */ 7775 x = get_value (wordsz, chunksz, input_bfd, contents + rel->r_offset); 7776 7777 #ifdef DEBUG 7778 printf ("Doing complex reloc: " 7779 "lsb0? %ld, signed? %ld, trunc? %ld, wordsz %ld, " 7780 "chunksz %ld, start %ld, len %ld, oplen %ld\n" 7781 " dest: %8.8lx, mask: %8.8lx, reloc: %8.8lx\n", 7782 lsb0_p, signed_p, trunc_p, wordsz, chunksz, start, len, 7783 oplen, x, mask, relocation); 7784 #endif 7785 7786 r = bfd_reloc_ok; 7787 if (! trunc_p) 7788 /* Now do an overflow check. */ 7789 r = bfd_check_overflow ((signed_p 7790 ? complain_overflow_signed 7791 : complain_overflow_unsigned), 7792 len, 0, (8 * wordsz), 7793 relocation); 7794 7795 /* Do the deed. */ 7796 x = (x & ~(mask << shift)) | ((relocation & mask) << shift); 7797 7798 #ifdef DEBUG 7799 printf (" relocation: %8.8lx\n" 7800 " shifted mask: %8.8lx\n" 7801 " shifted/masked reloc: %8.8lx\n" 7802 " result: %8.8lx\n", 7803 relocation, (mask << shift), 7804 ((relocation & mask) << shift), x); 7805 #endif 7806 /* FIXME: octets_per_byte. */ 7807 put_value (wordsz, chunksz, input_bfd, x, contents + rel->r_offset); 7808 return r; 7809 } 7810 7811 /* When performing a relocatable link, the input relocations are 7812 preserved. But, if they reference global symbols, the indices 7813 referenced must be updated. Update all the relocations in 7814 REL_HDR (there are COUNT of them), using the data in REL_HASH. */ 7815 7816 static void 7817 elf_link_adjust_relocs (bfd *abfd, 7818 Elf_Internal_Shdr *rel_hdr, 7819 unsigned int count, 7820 struct elf_link_hash_entry **rel_hash) 7821 { 7822 unsigned int i; 7823 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 7824 bfd_byte *erela; 7825 void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *); 7826 void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *); 7827 bfd_vma r_type_mask; 7828 int r_sym_shift; 7829 7830 if (rel_hdr->sh_entsize == bed->s->sizeof_rel) 7831 { 7832 swap_in = bed->s->swap_reloc_in; 7833 swap_out = bed->s->swap_reloc_out; 7834 } 7835 else if (rel_hdr->sh_entsize == bed->s->sizeof_rela) 7836 { 7837 swap_in = bed->s->swap_reloca_in; 7838 swap_out = bed->s->swap_reloca_out; 7839 } 7840 else 7841 abort (); 7842 7843 if (bed->s->int_rels_per_ext_rel > MAX_INT_RELS_PER_EXT_REL) 7844 abort (); 7845 7846 if (bed->s->arch_size == 32) 7847 { 7848 r_type_mask = 0xff; 7849 r_sym_shift = 8; 7850 } 7851 else 7852 { 7853 r_type_mask = 0xffffffff; 7854 r_sym_shift = 32; 7855 } 7856 7857 erela = rel_hdr->contents; 7858 for (i = 0; i < count; i++, rel_hash++, erela += rel_hdr->sh_entsize) 7859 { 7860 Elf_Internal_Rela irela[MAX_INT_RELS_PER_EXT_REL]; 7861 unsigned int j; 7862 7863 if (*rel_hash == NULL) 7864 continue; 7865 7866 BFD_ASSERT ((*rel_hash)->indx >= 0); 7867 7868 (*swap_in) (abfd, erela, irela); 7869 for (j = 0; j < bed->s->int_rels_per_ext_rel; j++) 7870 irela[j].r_info = ((bfd_vma) (*rel_hash)->indx << r_sym_shift 7871 | (irela[j].r_info & r_type_mask)); 7872 (*swap_out) (abfd, irela, erela); 7873 } 7874 } 7875 7876 struct elf_link_sort_rela 7877 { 7878 union { 7879 bfd_vma offset; 7880 bfd_vma sym_mask; 7881 } u; 7882 enum elf_reloc_type_class type; 7883 /* We use this as an array of size int_rels_per_ext_rel. */ 7884 Elf_Internal_Rela rela[1]; 7885 }; 7886 7887 static int 7888 elf_link_sort_cmp1 (const void *A, const void *B) 7889 { 7890 const struct elf_link_sort_rela *a = (const struct elf_link_sort_rela *) A; 7891 const struct elf_link_sort_rela *b = (const struct elf_link_sort_rela *) B; 7892 int relativea, relativeb; 7893 7894 relativea = a->type == reloc_class_relative; 7895 relativeb = b->type == reloc_class_relative; 7896 7897 if (relativea < relativeb) 7898 return 1; 7899 if (relativea > relativeb) 7900 return -1; 7901 if ((a->rela->r_info & a->u.sym_mask) < (b->rela->r_info & b->u.sym_mask)) 7902 return -1; 7903 if ((a->rela->r_info & a->u.sym_mask) > (b->rela->r_info & b->u.sym_mask)) 7904 return 1; 7905 if (a->rela->r_offset < b->rela->r_offset) 7906 return -1; 7907 if (a->rela->r_offset > b->rela->r_offset) 7908 return 1; 7909 return 0; 7910 } 7911 7912 static int 7913 elf_link_sort_cmp2 (const void *A, const void *B) 7914 { 7915 const struct elf_link_sort_rela *a = (const struct elf_link_sort_rela *) A; 7916 const struct elf_link_sort_rela *b = (const struct elf_link_sort_rela *) B; 7917 int copya, copyb; 7918 7919 if (a->u.offset < b->u.offset) 7920 return -1; 7921 if (a->u.offset > b->u.offset) 7922 return 1; 7923 copya = (a->type == reloc_class_copy) * 2 + (a->type == reloc_class_plt); 7924 copyb = (b->type == reloc_class_copy) * 2 + (b->type == reloc_class_plt); 7925 if (copya < copyb) 7926 return -1; 7927 if (copya > copyb) 7928 return 1; 7929 if (a->rela->r_offset < b->rela->r_offset) 7930 return -1; 7931 if (a->rela->r_offset > b->rela->r_offset) 7932 return 1; 7933 return 0; 7934 } 7935 7936 static size_t 7937 elf_link_sort_relocs (bfd *abfd, struct bfd_link_info *info, asection **psec) 7938 { 7939 asection *dynamic_relocs; 7940 asection *rela_dyn; 7941 asection *rel_dyn; 7942 bfd_size_type count, size; 7943 size_t i, ret, sort_elt, ext_size; 7944 bfd_byte *sort, *s_non_relative, *p; 7945 struct elf_link_sort_rela *sq; 7946 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 7947 int i2e = bed->s->int_rels_per_ext_rel; 7948 void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *); 7949 void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *); 7950 struct bfd_link_order *lo; 7951 bfd_vma r_sym_mask; 7952 bfd_boolean use_rela; 7953 7954 /* Find a dynamic reloc section. */ 7955 rela_dyn = bfd_get_section_by_name (abfd, ".rela.dyn"); 7956 rel_dyn = bfd_get_section_by_name (abfd, ".rel.dyn"); 7957 if (rela_dyn != NULL && rela_dyn->size > 0 7958 && rel_dyn != NULL && rel_dyn->size > 0) 7959 { 7960 bfd_boolean use_rela_initialised = FALSE; 7961 7962 /* This is just here to stop gcc from complaining. 7963 It's initialization checking code is not perfect. */ 7964 use_rela = TRUE; 7965 7966 /* Both sections are present. Examine the sizes 7967 of the indirect sections to help us choose. */ 7968 for (lo = rela_dyn->map_head.link_order; lo != NULL; lo = lo->next) 7969 if (lo->type == bfd_indirect_link_order) 7970 { 7971 asection *o = lo->u.indirect.section; 7972 7973 if ((o->size % bed->s->sizeof_rela) == 0) 7974 { 7975 if ((o->size % bed->s->sizeof_rel) == 0) 7976 /* Section size is divisible by both rel and rela sizes. 7977 It is of no help to us. */ 7978 ; 7979 else 7980 { 7981 /* Section size is only divisible by rela. */ 7982 if (use_rela_initialised && (use_rela == FALSE)) 7983 { 7984 _bfd_error_handler 7985 (_("%B: Unable to sort relocs - they are in more than one size"), abfd); 7986 bfd_set_error (bfd_error_invalid_operation); 7987 return 0; 7988 } 7989 else 7990 { 7991 use_rela = TRUE; 7992 use_rela_initialised = TRUE; 7993 } 7994 } 7995 } 7996 else if ((o->size % bed->s->sizeof_rel) == 0) 7997 { 7998 /* Section size is only divisible by rel. */ 7999 if (use_rela_initialised && (use_rela == TRUE)) 8000 { 8001 _bfd_error_handler 8002 (_("%B: Unable to sort relocs - they are in more than one size"), abfd); 8003 bfd_set_error (bfd_error_invalid_operation); 8004 return 0; 8005 } 8006 else 8007 { 8008 use_rela = FALSE; 8009 use_rela_initialised = TRUE; 8010 } 8011 } 8012 else 8013 { 8014 /* The section size is not divisible by either - something is wrong. */ 8015 _bfd_error_handler 8016 (_("%B: Unable to sort relocs - they are of an unknown size"), abfd); 8017 bfd_set_error (bfd_error_invalid_operation); 8018 return 0; 8019 } 8020 } 8021 8022 for (lo = rel_dyn->map_head.link_order; lo != NULL; lo = lo->next) 8023 if (lo->type == bfd_indirect_link_order) 8024 { 8025 asection *o = lo->u.indirect.section; 8026 8027 if ((o->size % bed->s->sizeof_rela) == 0) 8028 { 8029 if ((o->size % bed->s->sizeof_rel) == 0) 8030 /* Section size is divisible by both rel and rela sizes. 8031 It is of no help to us. */ 8032 ; 8033 else 8034 { 8035 /* Section size is only divisible by rela. */ 8036 if (use_rela_initialised && (use_rela == FALSE)) 8037 { 8038 _bfd_error_handler 8039 (_("%B: Unable to sort relocs - they are in more than one size"), abfd); 8040 bfd_set_error (bfd_error_invalid_operation); 8041 return 0; 8042 } 8043 else 8044 { 8045 use_rela = TRUE; 8046 use_rela_initialised = TRUE; 8047 } 8048 } 8049 } 8050 else if ((o->size % bed->s->sizeof_rel) == 0) 8051 { 8052 /* Section size is only divisible by rel. */ 8053 if (use_rela_initialised && (use_rela == TRUE)) 8054 { 8055 _bfd_error_handler 8056 (_("%B: Unable to sort relocs - they are in more than one size"), abfd); 8057 bfd_set_error (bfd_error_invalid_operation); 8058 return 0; 8059 } 8060 else 8061 { 8062 use_rela = FALSE; 8063 use_rela_initialised = TRUE; 8064 } 8065 } 8066 else 8067 { 8068 /* The section size is not divisible by either - something is wrong. */ 8069 _bfd_error_handler 8070 (_("%B: Unable to sort relocs - they are of an unknown size"), abfd); 8071 bfd_set_error (bfd_error_invalid_operation); 8072 return 0; 8073 } 8074 } 8075 8076 if (! use_rela_initialised) 8077 /* Make a guess. */ 8078 use_rela = TRUE; 8079 } 8080 else if (rela_dyn != NULL && rela_dyn->size > 0) 8081 use_rela = TRUE; 8082 else if (rel_dyn != NULL && rel_dyn->size > 0) 8083 use_rela = FALSE; 8084 else 8085 return 0; 8086 8087 if (use_rela) 8088 { 8089 dynamic_relocs = rela_dyn; 8090 ext_size = bed->s->sizeof_rela; 8091 swap_in = bed->s->swap_reloca_in; 8092 swap_out = bed->s->swap_reloca_out; 8093 } 8094 else 8095 { 8096 dynamic_relocs = rel_dyn; 8097 ext_size = bed->s->sizeof_rel; 8098 swap_in = bed->s->swap_reloc_in; 8099 swap_out = bed->s->swap_reloc_out; 8100 } 8101 8102 size = 0; 8103 for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next) 8104 if (lo->type == bfd_indirect_link_order) 8105 size += lo->u.indirect.section->size; 8106 8107 if (size != dynamic_relocs->size) 8108 return 0; 8109 8110 sort_elt = (sizeof (struct elf_link_sort_rela) 8111 + (i2e - 1) * sizeof (Elf_Internal_Rela)); 8112 8113 count = dynamic_relocs->size / ext_size; 8114 if (count == 0) 8115 return 0; 8116 sort = (bfd_byte *) bfd_zmalloc (sort_elt * count); 8117 8118 if (sort == NULL) 8119 { 8120 (*info->callbacks->warning) 8121 (info, _("Not enough memory to sort relocations"), 0, abfd, 0, 0); 8122 return 0; 8123 } 8124 8125 if (bed->s->arch_size == 32) 8126 r_sym_mask = ~(bfd_vma) 0xff; 8127 else 8128 r_sym_mask = ~(bfd_vma) 0xffffffff; 8129 8130 for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next) 8131 if (lo->type == bfd_indirect_link_order) 8132 { 8133 bfd_byte *erel, *erelend; 8134 asection *o = lo->u.indirect.section; 8135 8136 if (o->contents == NULL && o->size != 0) 8137 { 8138 /* This is a reloc section that is being handled as a normal 8139 section. See bfd_section_from_shdr. We can't combine 8140 relocs in this case. */ 8141 free (sort); 8142 return 0; 8143 } 8144 erel = o->contents; 8145 erelend = o->contents + o->size; 8146 /* FIXME: octets_per_byte. */ 8147 p = sort + o->output_offset / ext_size * sort_elt; 8148 8149 while (erel < erelend) 8150 { 8151 struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p; 8152 8153 (*swap_in) (abfd, erel, s->rela); 8154 s->type = (*bed->elf_backend_reloc_type_class) (s->rela); 8155 s->u.sym_mask = r_sym_mask; 8156 p += sort_elt; 8157 erel += ext_size; 8158 } 8159 } 8160 8161 qsort (sort, count, sort_elt, elf_link_sort_cmp1); 8162 8163 for (i = 0, p = sort; i < count; i++, p += sort_elt) 8164 { 8165 struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p; 8166 if (s->type != reloc_class_relative) 8167 break; 8168 } 8169 ret = i; 8170 s_non_relative = p; 8171 8172 sq = (struct elf_link_sort_rela *) s_non_relative; 8173 for (; i < count; i++, p += sort_elt) 8174 { 8175 struct elf_link_sort_rela *sp = (struct elf_link_sort_rela *) p; 8176 if (((sp->rela->r_info ^ sq->rela->r_info) & r_sym_mask) != 0) 8177 sq = sp; 8178 sp->u.offset = sq->rela->r_offset; 8179 } 8180 8181 qsort (s_non_relative, count - ret, sort_elt, elf_link_sort_cmp2); 8182 8183 for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next) 8184 if (lo->type == bfd_indirect_link_order) 8185 { 8186 bfd_byte *erel, *erelend; 8187 asection *o = lo->u.indirect.section; 8188 8189 erel = o->contents; 8190 erelend = o->contents + o->size; 8191 /* FIXME: octets_per_byte. */ 8192 p = sort + o->output_offset / ext_size * sort_elt; 8193 while (erel < erelend) 8194 { 8195 struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p; 8196 (*swap_out) (abfd, s->rela, erel); 8197 p += sort_elt; 8198 erel += ext_size; 8199 } 8200 } 8201 8202 free (sort); 8203 *psec = dynamic_relocs; 8204 return ret; 8205 } 8206 8207 /* Flush the output symbols to the file. */ 8208 8209 static bfd_boolean 8210 elf_link_flush_output_syms (struct elf_final_link_info *finfo, 8211 const struct elf_backend_data *bed) 8212 { 8213 if (finfo->symbuf_count > 0) 8214 { 8215 Elf_Internal_Shdr *hdr; 8216 file_ptr pos; 8217 bfd_size_type amt; 8218 8219 hdr = &elf_tdata (finfo->output_bfd)->symtab_hdr; 8220 pos = hdr->sh_offset + hdr->sh_size; 8221 amt = finfo->symbuf_count * bed->s->sizeof_sym; 8222 if (bfd_seek (finfo->output_bfd, pos, SEEK_SET) != 0 8223 || bfd_bwrite (finfo->symbuf, amt, finfo->output_bfd) != amt) 8224 return FALSE; 8225 8226 hdr->sh_size += amt; 8227 finfo->symbuf_count = 0; 8228 } 8229 8230 return TRUE; 8231 } 8232 8233 /* Add a symbol to the output symbol table. */ 8234 8235 static int 8236 elf_link_output_sym (struct elf_final_link_info *finfo, 8237 const char *name, 8238 Elf_Internal_Sym *elfsym, 8239 asection *input_sec, 8240 struct elf_link_hash_entry *h) 8241 { 8242 bfd_byte *dest; 8243 Elf_External_Sym_Shndx *destshndx; 8244 int (*output_symbol_hook) 8245 (struct bfd_link_info *, const char *, Elf_Internal_Sym *, asection *, 8246 struct elf_link_hash_entry *); 8247 const struct elf_backend_data *bed; 8248 8249 bed = get_elf_backend_data (finfo->output_bfd); 8250 output_symbol_hook = bed->elf_backend_link_output_symbol_hook; 8251 if (output_symbol_hook != NULL) 8252 { 8253 int ret = (*output_symbol_hook) (finfo->info, name, elfsym, input_sec, h); 8254 if (ret != 1) 8255 return ret; 8256 } 8257 8258 if (name == NULL || *name == '\0') 8259 elfsym->st_name = 0; 8260 else if (input_sec->flags & SEC_EXCLUDE) 8261 elfsym->st_name = 0; 8262 else 8263 { 8264 elfsym->st_name = (unsigned long) _bfd_stringtab_add (finfo->symstrtab, 8265 name, TRUE, FALSE); 8266 if (elfsym->st_name == (unsigned long) -1) 8267 return 0; 8268 } 8269 8270 if (finfo->symbuf_count >= finfo->symbuf_size) 8271 { 8272 if (! elf_link_flush_output_syms (finfo, bed)) 8273 return 0; 8274 } 8275 8276 dest = finfo->symbuf + finfo->symbuf_count * bed->s->sizeof_sym; 8277 destshndx = finfo->symshndxbuf; 8278 if (destshndx != NULL) 8279 { 8280 if (bfd_get_symcount (finfo->output_bfd) >= finfo->shndxbuf_size) 8281 { 8282 bfd_size_type amt; 8283 8284 amt = finfo->shndxbuf_size * sizeof (Elf_External_Sym_Shndx); 8285 destshndx = (Elf_External_Sym_Shndx *) bfd_realloc (destshndx, 8286 amt * 2); 8287 if (destshndx == NULL) 8288 return 0; 8289 finfo->symshndxbuf = destshndx; 8290 memset ((char *) destshndx + amt, 0, amt); 8291 finfo->shndxbuf_size *= 2; 8292 } 8293 destshndx += bfd_get_symcount (finfo->output_bfd); 8294 } 8295 8296 bed->s->swap_symbol_out (finfo->output_bfd, elfsym, dest, destshndx); 8297 finfo->symbuf_count += 1; 8298 bfd_get_symcount (finfo->output_bfd) += 1; 8299 8300 return 1; 8301 } 8302 8303 /* Return TRUE if the dynamic symbol SYM in ABFD is supported. */ 8304 8305 static bfd_boolean 8306 check_dynsym (bfd *abfd, Elf_Internal_Sym *sym) 8307 { 8308 if (sym->st_shndx >= (SHN_LORESERVE & 0xffff) 8309 && sym->st_shndx < SHN_LORESERVE) 8310 { 8311 /* The gABI doesn't support dynamic symbols in output sections 8312 beyond 64k. */ 8313 (*_bfd_error_handler) 8314 (_("%B: Too many sections: %d (>= %d)"), 8315 abfd, bfd_count_sections (abfd), SHN_LORESERVE & 0xffff); 8316 bfd_set_error (bfd_error_nonrepresentable_section); 8317 return FALSE; 8318 } 8319 return TRUE; 8320 } 8321 8322 /* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in 8323 allowing an unsatisfied unversioned symbol in the DSO to match a 8324 versioned symbol that would normally require an explicit version. 8325 We also handle the case that a DSO references a hidden symbol 8326 which may be satisfied by a versioned symbol in another DSO. */ 8327 8328 static bfd_boolean 8329 elf_link_check_versioned_symbol (struct bfd_link_info *info, 8330 const struct elf_backend_data *bed, 8331 struct elf_link_hash_entry *h) 8332 { 8333 bfd *abfd; 8334 struct elf_link_loaded_list *loaded; 8335 8336 if (!is_elf_hash_table (info->hash)) 8337 return FALSE; 8338 8339 switch (h->root.type) 8340 { 8341 default: 8342 abfd = NULL; 8343 break; 8344 8345 case bfd_link_hash_undefined: 8346 case bfd_link_hash_undefweak: 8347 abfd = h->root.u.undef.abfd; 8348 if ((abfd->flags & DYNAMIC) == 0 8349 || (elf_dyn_lib_class (abfd) & DYN_DT_NEEDED) == 0) 8350 return FALSE; 8351 break; 8352 8353 case bfd_link_hash_defined: 8354 case bfd_link_hash_defweak: 8355 abfd = h->root.u.def.section->owner; 8356 break; 8357 8358 case bfd_link_hash_common: 8359 abfd = h->root.u.c.p->section->owner; 8360 break; 8361 } 8362 BFD_ASSERT (abfd != NULL); 8363 8364 for (loaded = elf_hash_table (info)->loaded; 8365 loaded != NULL; 8366 loaded = loaded->next) 8367 { 8368 bfd *input; 8369 Elf_Internal_Shdr *hdr; 8370 bfd_size_type symcount; 8371 bfd_size_type extsymcount; 8372 bfd_size_type extsymoff; 8373 Elf_Internal_Shdr *versymhdr; 8374 Elf_Internal_Sym *isym; 8375 Elf_Internal_Sym *isymend; 8376 Elf_Internal_Sym *isymbuf; 8377 Elf_External_Versym *ever; 8378 Elf_External_Versym *extversym; 8379 8380 input = loaded->abfd; 8381 8382 /* We check each DSO for a possible hidden versioned definition. */ 8383 if (input == abfd 8384 || (input->flags & DYNAMIC) == 0 8385 || elf_dynversym (input) == 0) 8386 continue; 8387 8388 hdr = &elf_tdata (input)->dynsymtab_hdr; 8389 8390 symcount = hdr->sh_size / bed->s->sizeof_sym; 8391 if (elf_bad_symtab (input)) 8392 { 8393 extsymcount = symcount; 8394 extsymoff = 0; 8395 } 8396 else 8397 { 8398 extsymcount = symcount - hdr->sh_info; 8399 extsymoff = hdr->sh_info; 8400 } 8401 8402 if (extsymcount == 0) 8403 continue; 8404 8405 isymbuf = bfd_elf_get_elf_syms (input, hdr, extsymcount, extsymoff, 8406 NULL, NULL, NULL); 8407 if (isymbuf == NULL) 8408 return FALSE; 8409 8410 /* Read in any version definitions. */ 8411 versymhdr = &elf_tdata (input)->dynversym_hdr; 8412 extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size); 8413 if (extversym == NULL) 8414 goto error_ret; 8415 8416 if (bfd_seek (input, versymhdr->sh_offset, SEEK_SET) != 0 8417 || (bfd_bread (extversym, versymhdr->sh_size, input) 8418 != versymhdr->sh_size)) 8419 { 8420 free (extversym); 8421 error_ret: 8422 free (isymbuf); 8423 return FALSE; 8424 } 8425 8426 ever = extversym + extsymoff; 8427 isymend = isymbuf + extsymcount; 8428 for (isym = isymbuf; isym < isymend; isym++, ever++) 8429 { 8430 const char *name; 8431 Elf_Internal_Versym iver; 8432 unsigned short version_index; 8433 8434 if (ELF_ST_BIND (isym->st_info) == STB_LOCAL 8435 || isym->st_shndx == SHN_UNDEF) 8436 continue; 8437 8438 name = bfd_elf_string_from_elf_section (input, 8439 hdr->sh_link, 8440 isym->st_name); 8441 if (strcmp (name, h->root.root.string) != 0) 8442 continue; 8443 8444 _bfd_elf_swap_versym_in (input, ever, &iver); 8445 8446 if ((iver.vs_vers & VERSYM_HIDDEN) == 0) 8447 { 8448 /* If we have a non-hidden versioned sym, then it should 8449 have provided a definition for the undefined sym. */ 8450 abort (); 8451 } 8452 8453 version_index = iver.vs_vers & VERSYM_VERSION; 8454 if (version_index == 1 || version_index == 2) 8455 { 8456 /* This is the base or first version. We can use it. */ 8457 free (extversym); 8458 free (isymbuf); 8459 return TRUE; 8460 } 8461 } 8462 8463 free (extversym); 8464 free (isymbuf); 8465 } 8466 8467 return FALSE; 8468 } 8469 8470 /* Add an external symbol to the symbol table. This is called from 8471 the hash table traversal routine. When generating a shared object, 8472 we go through the symbol table twice. The first time we output 8473 anything that might have been forced to local scope in a version 8474 script. The second time we output the symbols that are still 8475 global symbols. */ 8476 8477 static bfd_boolean 8478 elf_link_output_extsym (struct elf_link_hash_entry *h, void *data) 8479 { 8480 struct elf_outext_info *eoinfo = (struct elf_outext_info *) data; 8481 struct elf_final_link_info *finfo = eoinfo->finfo; 8482 bfd_boolean strip; 8483 Elf_Internal_Sym sym; 8484 asection *input_sec; 8485 const struct elf_backend_data *bed; 8486 long indx; 8487 int ret; 8488 8489 if (h->root.type == bfd_link_hash_warning) 8490 { 8491 h = (struct elf_link_hash_entry *) h->root.u.i.link; 8492 if (h->root.type == bfd_link_hash_new) 8493 return TRUE; 8494 } 8495 8496 /* Decide whether to output this symbol in this pass. */ 8497 if (eoinfo->localsyms) 8498 { 8499 if (!h->forced_local) 8500 return TRUE; 8501 } 8502 else 8503 { 8504 if (h->forced_local) 8505 return TRUE; 8506 } 8507 8508 bed = get_elf_backend_data (finfo->output_bfd); 8509 8510 if (h->root.type == bfd_link_hash_undefined) 8511 { 8512 /* If we have an undefined symbol reference here then it must have 8513 come from a shared library that is being linked in. (Undefined 8514 references in regular files have already been handled). */ 8515 bfd_boolean ignore_undef = FALSE; 8516 8517 /* Some symbols may be special in that the fact that they're 8518 undefined can be safely ignored - let backend determine that. */ 8519 if (bed->elf_backend_ignore_undef_symbol) 8520 ignore_undef = bed->elf_backend_ignore_undef_symbol (h); 8521 8522 /* If we are reporting errors for this situation then do so now. */ 8523 if (ignore_undef == FALSE 8524 && h->ref_dynamic 8525 && ! h->ref_regular 8526 && ! elf_link_check_versioned_symbol (finfo->info, bed, h) 8527 && finfo->info->unresolved_syms_in_shared_libs != RM_IGNORE) 8528 { 8529 if (! (finfo->info->callbacks->undefined_symbol 8530 (finfo->info, h->root.root.string, h->root.u.undef.abfd, 8531 NULL, 0, finfo->info->unresolved_syms_in_shared_libs == RM_GENERATE_ERROR))) 8532 { 8533 eoinfo->failed = TRUE; 8534 return FALSE; 8535 } 8536 } 8537 } 8538 8539 /* We should also warn if a forced local symbol is referenced from 8540 shared libraries. */ 8541 if (! finfo->info->relocatable 8542 && (! finfo->info->shared) 8543 && h->forced_local 8544 && h->ref_dynamic 8545 && !h->dynamic_def 8546 && !h->dynamic_weak 8547 && ! elf_link_check_versioned_symbol (finfo->info, bed, h)) 8548 { 8549 (*_bfd_error_handler) 8550 (_("%B: %s symbol `%s' in %B is referenced by DSO"), 8551 finfo->output_bfd, 8552 h->root.u.def.section == bfd_abs_section_ptr 8553 ? finfo->output_bfd : h->root.u.def.section->owner, 8554 ELF_ST_VISIBILITY (h->other) == STV_INTERNAL 8555 ? "internal" 8556 : ELF_ST_VISIBILITY (h->other) == STV_HIDDEN 8557 ? "hidden" : "local", 8558 h->root.root.string); 8559 eoinfo->failed = TRUE; 8560 return FALSE; 8561 } 8562 8563 /* We don't want to output symbols that have never been mentioned by 8564 a regular file, or that we have been told to strip. However, if 8565 h->indx is set to -2, the symbol is used by a reloc and we must 8566 output it. */ 8567 if (h->indx == -2) 8568 strip = FALSE; 8569 else if ((h->def_dynamic 8570 || h->ref_dynamic 8571 || h->root.type == bfd_link_hash_new) 8572 && !h->def_regular 8573 && !h->ref_regular) 8574 strip = TRUE; 8575 else if (finfo->info->strip == strip_all) 8576 strip = TRUE; 8577 else if (finfo->info->strip == strip_some 8578 && bfd_hash_lookup (finfo->info->keep_hash, 8579 h->root.root.string, FALSE, FALSE) == NULL) 8580 strip = TRUE; 8581 else if (finfo->info->strip_discarded 8582 && (h->root.type == bfd_link_hash_defined 8583 || h->root.type == bfd_link_hash_defweak) 8584 && elf_discarded_section (h->root.u.def.section)) 8585 strip = TRUE; 8586 else 8587 strip = FALSE; 8588 8589 /* If we're stripping it, and it's not a dynamic symbol, there's 8590 nothing else to do unless it is a forced local symbol. */ 8591 if (strip 8592 && h->dynindx == -1 8593 && !h->forced_local) 8594 return TRUE; 8595 8596 sym.st_value = 0; 8597 sym.st_size = h->size; 8598 sym.st_other = h->other; 8599 if (h->forced_local) 8600 sym.st_info = ELF_ST_INFO (STB_LOCAL, h->type); 8601 else if (h->unique_global) 8602 sym.st_info = ELF_ST_INFO (STB_GNU_UNIQUE, h->type); 8603 else if (h->root.type == bfd_link_hash_undefweak 8604 || h->root.type == bfd_link_hash_defweak) 8605 sym.st_info = ELF_ST_INFO (STB_WEAK, h->type); 8606 else 8607 sym.st_info = ELF_ST_INFO (STB_GLOBAL, h->type); 8608 8609 switch (h->root.type) 8610 { 8611 default: 8612 case bfd_link_hash_new: 8613 case bfd_link_hash_warning: 8614 abort (); 8615 return FALSE; 8616 8617 case bfd_link_hash_undefined: 8618 case bfd_link_hash_undefweak: 8619 input_sec = bfd_und_section_ptr; 8620 sym.st_shndx = SHN_UNDEF; 8621 break; 8622 8623 case bfd_link_hash_defined: 8624 case bfd_link_hash_defweak: 8625 { 8626 input_sec = h->root.u.def.section; 8627 if (input_sec->output_section != NULL) 8628 { 8629 sym.st_shndx = 8630 _bfd_elf_section_from_bfd_section (finfo->output_bfd, 8631 input_sec->output_section); 8632 if (sym.st_shndx == SHN_BAD) 8633 { 8634 (*_bfd_error_handler) 8635 (_("%B: could not find output section %A for input section %A"), 8636 finfo->output_bfd, input_sec->output_section, input_sec); 8637 eoinfo->failed = TRUE; 8638 return FALSE; 8639 } 8640 8641 /* ELF symbols in relocatable files are section relative, 8642 but in nonrelocatable files they are virtual 8643 addresses. */ 8644 sym.st_value = h->root.u.def.value + input_sec->output_offset; 8645 if (! finfo->info->relocatable) 8646 { 8647 sym.st_value += input_sec->output_section->vma; 8648 if (h->type == STT_TLS) 8649 { 8650 asection *tls_sec = elf_hash_table (finfo->info)->tls_sec; 8651 if (tls_sec != NULL) 8652 sym.st_value -= tls_sec->vma; 8653 else 8654 { 8655 /* The TLS section may have been garbage collected. */ 8656 BFD_ASSERT (finfo->info->gc_sections 8657 && !input_sec->gc_mark); 8658 } 8659 } 8660 } 8661 } 8662 else 8663 { 8664 BFD_ASSERT (input_sec->owner == NULL 8665 || (input_sec->owner->flags & DYNAMIC) != 0); 8666 sym.st_shndx = SHN_UNDEF; 8667 input_sec = bfd_und_section_ptr; 8668 } 8669 } 8670 break; 8671 8672 case bfd_link_hash_common: 8673 input_sec = h->root.u.c.p->section; 8674 sym.st_shndx = bed->common_section_index (input_sec); 8675 sym.st_value = 1 << h->root.u.c.p->alignment_power; 8676 break; 8677 8678 case bfd_link_hash_indirect: 8679 /* These symbols are created by symbol versioning. They point 8680 to the decorated version of the name. For example, if the 8681 symbol foo@@GNU_1.2 is the default, which should be used when 8682 foo is used with no version, then we add an indirect symbol 8683 foo which points to foo@@GNU_1.2. We ignore these symbols, 8684 since the indirected symbol is already in the hash table. */ 8685 return TRUE; 8686 } 8687 8688 /* Give the processor backend a chance to tweak the symbol value, 8689 and also to finish up anything that needs to be done for this 8690 symbol. FIXME: Not calling elf_backend_finish_dynamic_symbol for 8691 forced local syms when non-shared is due to a historical quirk. 8692 STT_GNU_IFUNC symbol must go through PLT. */ 8693 if ((h->type == STT_GNU_IFUNC 8694 && h->def_regular 8695 && !finfo->info->relocatable) 8696 || ((h->dynindx != -1 8697 || h->forced_local) 8698 && ((finfo->info->shared 8699 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 8700 || h->root.type != bfd_link_hash_undefweak)) 8701 || !h->forced_local) 8702 && elf_hash_table (finfo->info)->dynamic_sections_created)) 8703 { 8704 if (! ((*bed->elf_backend_finish_dynamic_symbol) 8705 (finfo->output_bfd, finfo->info, h, &sym))) 8706 { 8707 eoinfo->failed = TRUE; 8708 return FALSE; 8709 } 8710 } 8711 8712 /* If we are marking the symbol as undefined, and there are no 8713 non-weak references to this symbol from a regular object, then 8714 mark the symbol as weak undefined; if there are non-weak 8715 references, mark the symbol as strong. We can't do this earlier, 8716 because it might not be marked as undefined until the 8717 finish_dynamic_symbol routine gets through with it. */ 8718 if (sym.st_shndx == SHN_UNDEF 8719 && h->ref_regular 8720 && (ELF_ST_BIND (sym.st_info) == STB_GLOBAL 8721 || ELF_ST_BIND (sym.st_info) == STB_WEAK)) 8722 { 8723 int bindtype; 8724 unsigned int type = ELF_ST_TYPE (sym.st_info); 8725 8726 /* Turn an undefined IFUNC symbol into a normal FUNC symbol. */ 8727 if (type == STT_GNU_IFUNC) 8728 type = STT_FUNC; 8729 8730 if (h->ref_regular_nonweak) 8731 bindtype = STB_GLOBAL; 8732 else 8733 bindtype = STB_WEAK; 8734 sym.st_info = ELF_ST_INFO (bindtype, type); 8735 } 8736 8737 /* If this is a symbol defined in a dynamic library, don't use the 8738 symbol size from the dynamic library. Relinking an executable 8739 against a new library may introduce gratuitous changes in the 8740 executable's symbols if we keep the size. */ 8741 if (sym.st_shndx == SHN_UNDEF 8742 && !h->def_regular 8743 && h->def_dynamic) 8744 sym.st_size = 0; 8745 8746 /* If a non-weak symbol with non-default visibility is not defined 8747 locally, it is a fatal error. */ 8748 if (! finfo->info->relocatable 8749 && ELF_ST_VISIBILITY (sym.st_other) != STV_DEFAULT 8750 && ELF_ST_BIND (sym.st_info) != STB_WEAK 8751 && h->root.type == bfd_link_hash_undefined 8752 && !h->def_regular) 8753 { 8754 (*_bfd_error_handler) 8755 (_("%B: %s symbol `%s' isn't defined"), 8756 finfo->output_bfd, 8757 ELF_ST_VISIBILITY (sym.st_other) == STV_PROTECTED 8758 ? "protected" 8759 : ELF_ST_VISIBILITY (sym.st_other) == STV_INTERNAL 8760 ? "internal" : "hidden", 8761 h->root.root.string); 8762 eoinfo->failed = TRUE; 8763 return FALSE; 8764 } 8765 8766 /* If this symbol should be put in the .dynsym section, then put it 8767 there now. We already know the symbol index. We also fill in 8768 the entry in the .hash section. */ 8769 if (h->dynindx != -1 8770 && elf_hash_table (finfo->info)->dynamic_sections_created) 8771 { 8772 bfd_byte *esym; 8773 8774 sym.st_name = h->dynstr_index; 8775 esym = finfo->dynsym_sec->contents + h->dynindx * bed->s->sizeof_sym; 8776 if (! check_dynsym (finfo->output_bfd, &sym)) 8777 { 8778 eoinfo->failed = TRUE; 8779 return FALSE; 8780 } 8781 bed->s->swap_symbol_out (finfo->output_bfd, &sym, esym, 0); 8782 8783 if (finfo->hash_sec != NULL) 8784 { 8785 size_t hash_entry_size; 8786 bfd_byte *bucketpos; 8787 bfd_vma chain; 8788 size_t bucketcount; 8789 size_t bucket; 8790 8791 bucketcount = elf_hash_table (finfo->info)->bucketcount; 8792 bucket = h->u.elf_hash_value % bucketcount; 8793 8794 hash_entry_size 8795 = elf_section_data (finfo->hash_sec)->this_hdr.sh_entsize; 8796 bucketpos = ((bfd_byte *) finfo->hash_sec->contents 8797 + (bucket + 2) * hash_entry_size); 8798 chain = bfd_get (8 * hash_entry_size, finfo->output_bfd, bucketpos); 8799 bfd_put (8 * hash_entry_size, finfo->output_bfd, h->dynindx, bucketpos); 8800 bfd_put (8 * hash_entry_size, finfo->output_bfd, chain, 8801 ((bfd_byte *) finfo->hash_sec->contents 8802 + (bucketcount + 2 + h->dynindx) * hash_entry_size)); 8803 } 8804 8805 if (finfo->symver_sec != NULL && finfo->symver_sec->contents != NULL) 8806 { 8807 Elf_Internal_Versym iversym; 8808 Elf_External_Versym *eversym; 8809 8810 if (!h->def_regular) 8811 { 8812 if (h->verinfo.verdef == NULL) 8813 iversym.vs_vers = 0; 8814 else 8815 iversym.vs_vers = h->verinfo.verdef->vd_exp_refno + 1; 8816 } 8817 else 8818 { 8819 if (h->verinfo.vertree == NULL) 8820 iversym.vs_vers = 1; 8821 else 8822 iversym.vs_vers = h->verinfo.vertree->vernum + 1; 8823 if (finfo->info->create_default_symver) 8824 iversym.vs_vers++; 8825 } 8826 8827 if (h->hidden) 8828 iversym.vs_vers |= VERSYM_HIDDEN; 8829 8830 eversym = (Elf_External_Versym *) finfo->symver_sec->contents; 8831 eversym += h->dynindx; 8832 _bfd_elf_swap_versym_out (finfo->output_bfd, &iversym, eversym); 8833 } 8834 } 8835 8836 /* If we're stripping it, then it was just a dynamic symbol, and 8837 there's nothing else to do. */ 8838 if (strip || (input_sec->flags & SEC_EXCLUDE) != 0) 8839 return TRUE; 8840 8841 indx = bfd_get_symcount (finfo->output_bfd); 8842 ret = elf_link_output_sym (finfo, h->root.root.string, &sym, input_sec, h); 8843 if (ret == 0) 8844 { 8845 eoinfo->failed = TRUE; 8846 return FALSE; 8847 } 8848 else if (ret == 1) 8849 h->indx = indx; 8850 else if (h->indx == -2) 8851 abort(); 8852 8853 return TRUE; 8854 } 8855 8856 /* Return TRUE if special handling is done for relocs in SEC against 8857 symbols defined in discarded sections. */ 8858 8859 static bfd_boolean 8860 elf_section_ignore_discarded_relocs (asection *sec) 8861 { 8862 const struct elf_backend_data *bed; 8863 8864 switch (sec->sec_info_type) 8865 { 8866 case ELF_INFO_TYPE_STABS: 8867 case ELF_INFO_TYPE_EH_FRAME: 8868 return TRUE; 8869 default: 8870 break; 8871 } 8872 8873 bed = get_elf_backend_data (sec->owner); 8874 if (bed->elf_backend_ignore_discarded_relocs != NULL 8875 && (*bed->elf_backend_ignore_discarded_relocs) (sec)) 8876 return TRUE; 8877 8878 return FALSE; 8879 } 8880 8881 /* Return a mask saying how ld should treat relocations in SEC against 8882 symbols defined in discarded sections. If this function returns 8883 COMPLAIN set, ld will issue a warning message. If this function 8884 returns PRETEND set, and the discarded section was link-once and the 8885 same size as the kept link-once section, ld will pretend that the 8886 symbol was actually defined in the kept section. Otherwise ld will 8887 zero the reloc (at least that is the intent, but some cooperation by 8888 the target dependent code is needed, particularly for REL targets). */ 8889 8890 unsigned int 8891 _bfd_elf_default_action_discarded (asection *sec) 8892 { 8893 if (sec->flags & SEC_DEBUGGING) 8894 return PRETEND; 8895 8896 if (strcmp (".eh_frame", sec->name) == 0) 8897 return 0; 8898 8899 if (strcmp (".gcc_except_table", sec->name) == 0) 8900 return 0; 8901 8902 return COMPLAIN | PRETEND; 8903 } 8904 8905 /* Find a match between a section and a member of a section group. */ 8906 8907 static asection * 8908 match_group_member (asection *sec, asection *group, 8909 struct bfd_link_info *info) 8910 { 8911 asection *first = elf_next_in_group (group); 8912 asection *s = first; 8913 8914 while (s != NULL) 8915 { 8916 if (bfd_elf_match_symbols_in_sections (s, sec, info)) 8917 return s; 8918 8919 s = elf_next_in_group (s); 8920 if (s == first) 8921 break; 8922 } 8923 8924 return NULL; 8925 } 8926 8927 /* Check if the kept section of a discarded section SEC can be used 8928 to replace it. Return the replacement if it is OK. Otherwise return 8929 NULL. */ 8930 8931 asection * 8932 _bfd_elf_check_kept_section (asection *sec, struct bfd_link_info *info) 8933 { 8934 asection *kept; 8935 8936 kept = sec->kept_section; 8937 if (kept != NULL) 8938 { 8939 if ((kept->flags & SEC_GROUP) != 0) 8940 kept = match_group_member (sec, kept, info); 8941 if (kept != NULL 8942 && ((sec->rawsize != 0 ? sec->rawsize : sec->size) 8943 != (kept->rawsize != 0 ? kept->rawsize : kept->size))) 8944 kept = NULL; 8945 sec->kept_section = kept; 8946 } 8947 return kept; 8948 } 8949 8950 /* Link an input file into the linker output file. This function 8951 handles all the sections and relocations of the input file at once. 8952 This is so that we only have to read the local symbols once, and 8953 don't have to keep them in memory. */ 8954 8955 static bfd_boolean 8956 elf_link_input_bfd (struct elf_final_link_info *finfo, bfd *input_bfd) 8957 { 8958 int (*relocate_section) 8959 (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, 8960 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **); 8961 bfd *output_bfd; 8962 Elf_Internal_Shdr *symtab_hdr; 8963 size_t locsymcount; 8964 size_t extsymoff; 8965 Elf_Internal_Sym *isymbuf; 8966 Elf_Internal_Sym *isym; 8967 Elf_Internal_Sym *isymend; 8968 long *pindex; 8969 asection **ppsection; 8970 asection *o; 8971 const struct elf_backend_data *bed; 8972 struct elf_link_hash_entry **sym_hashes; 8973 8974 output_bfd = finfo->output_bfd; 8975 bed = get_elf_backend_data (output_bfd); 8976 relocate_section = bed->elf_backend_relocate_section; 8977 8978 /* If this is a dynamic object, we don't want to do anything here: 8979 we don't want the local symbols, and we don't want the section 8980 contents. */ 8981 if ((input_bfd->flags & DYNAMIC) != 0) 8982 return TRUE; 8983 8984 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 8985 if (elf_bad_symtab (input_bfd)) 8986 { 8987 locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym; 8988 extsymoff = 0; 8989 } 8990 else 8991 { 8992 locsymcount = symtab_hdr->sh_info; 8993 extsymoff = symtab_hdr->sh_info; 8994 } 8995 8996 /* Read the local symbols. */ 8997 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 8998 if (isymbuf == NULL && locsymcount != 0) 8999 { 9000 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0, 9001 finfo->internal_syms, 9002 finfo->external_syms, 9003 finfo->locsym_shndx); 9004 if (isymbuf == NULL) 9005 return FALSE; 9006 } 9007 9008 /* Find local symbol sections and adjust values of symbols in 9009 SEC_MERGE sections. Write out those local symbols we know are 9010 going into the output file. */ 9011 isymend = isymbuf + locsymcount; 9012 for (isym = isymbuf, pindex = finfo->indices, ppsection = finfo->sections; 9013 isym < isymend; 9014 isym++, pindex++, ppsection++) 9015 { 9016 asection *isec; 9017 const char *name; 9018 Elf_Internal_Sym osym; 9019 long indx; 9020 int ret; 9021 9022 *pindex = -1; 9023 9024 if (elf_bad_symtab (input_bfd)) 9025 { 9026 if (ELF_ST_BIND (isym->st_info) != STB_LOCAL) 9027 { 9028 *ppsection = NULL; 9029 continue; 9030 } 9031 } 9032 9033 if (isym->st_shndx == SHN_UNDEF) 9034 isec = bfd_und_section_ptr; 9035 else if (isym->st_shndx == SHN_ABS) 9036 isec = bfd_abs_section_ptr; 9037 else if (isym->st_shndx == SHN_COMMON) 9038 isec = bfd_com_section_ptr; 9039 else 9040 { 9041 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx); 9042 if (isec == NULL) 9043 { 9044 /* Don't attempt to output symbols with st_shnx in the 9045 reserved range other than SHN_ABS and SHN_COMMON. */ 9046 *ppsection = NULL; 9047 continue; 9048 } 9049 else if (isec->sec_info_type == ELF_INFO_TYPE_MERGE 9050 && ELF_ST_TYPE (isym->st_info) != STT_SECTION) 9051 isym->st_value = 9052 _bfd_merged_section_offset (output_bfd, &isec, 9053 elf_section_data (isec)->sec_info, 9054 isym->st_value); 9055 } 9056 9057 *ppsection = isec; 9058 9059 /* Don't output the first, undefined, symbol. */ 9060 if (ppsection == finfo->sections) 9061 continue; 9062 9063 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION) 9064 { 9065 /* We never output section symbols. Instead, we use the 9066 section symbol of the corresponding section in the output 9067 file. */ 9068 continue; 9069 } 9070 9071 /* If we are stripping all symbols, we don't want to output this 9072 one. */ 9073 if (finfo->info->strip == strip_all) 9074 continue; 9075 9076 /* If we are discarding all local symbols, we don't want to 9077 output this one. If we are generating a relocatable output 9078 file, then some of the local symbols may be required by 9079 relocs; we output them below as we discover that they are 9080 needed. */ 9081 if (finfo->info->discard == discard_all) 9082 continue; 9083 9084 /* If this symbol is defined in a section which we are 9085 discarding, we don't need to keep it. */ 9086 if (isym->st_shndx != SHN_UNDEF 9087 && isym->st_shndx < SHN_LORESERVE 9088 && bfd_section_removed_from_list (output_bfd, 9089 isec->output_section)) 9090 continue; 9091 9092 /* Get the name of the symbol. */ 9093 name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link, 9094 isym->st_name); 9095 if (name == NULL) 9096 return FALSE; 9097 9098 /* See if we are discarding symbols with this name. */ 9099 if ((finfo->info->strip == strip_some 9100 && (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE, FALSE) 9101 == NULL)) 9102 || (((finfo->info->discard == discard_sec_merge 9103 && (isec->flags & SEC_MERGE) && ! finfo->info->relocatable) 9104 || finfo->info->discard == discard_l) 9105 && bfd_is_local_label_name (input_bfd, name))) 9106 continue; 9107 9108 osym = *isym; 9109 9110 /* Adjust the section index for the output file. */ 9111 osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd, 9112 isec->output_section); 9113 if (osym.st_shndx == SHN_BAD) 9114 return FALSE; 9115 9116 /* ELF symbols in relocatable files are section relative, but 9117 in executable files they are virtual addresses. Note that 9118 this code assumes that all ELF sections have an associated 9119 BFD section with a reasonable value for output_offset; below 9120 we assume that they also have a reasonable value for 9121 output_section. Any special sections must be set up to meet 9122 these requirements. */ 9123 osym.st_value += isec->output_offset; 9124 if (! finfo->info->relocatable) 9125 { 9126 osym.st_value += isec->output_section->vma; 9127 if (ELF_ST_TYPE (osym.st_info) == STT_TLS) 9128 { 9129 /* STT_TLS symbols are relative to PT_TLS segment base. */ 9130 BFD_ASSERT (elf_hash_table (finfo->info)->tls_sec != NULL); 9131 osym.st_value -= elf_hash_table (finfo->info)->tls_sec->vma; 9132 } 9133 } 9134 9135 indx = bfd_get_symcount (output_bfd); 9136 ret = elf_link_output_sym (finfo, name, &osym, isec, NULL); 9137 if (ret == 0) 9138 return FALSE; 9139 else if (ret == 1) 9140 *pindex = indx; 9141 } 9142 9143 /* Relocate the contents of each section. */ 9144 sym_hashes = elf_sym_hashes (input_bfd); 9145 for (o = input_bfd->sections; o != NULL; o = o->next) 9146 { 9147 bfd_byte *contents; 9148 9149 if (! o->linker_mark) 9150 { 9151 /* This section was omitted from the link. */ 9152 continue; 9153 } 9154 9155 if (finfo->info->relocatable 9156 && (o->flags & (SEC_LINKER_CREATED | SEC_GROUP)) == SEC_GROUP) 9157 { 9158 /* Deal with the group signature symbol. */ 9159 struct bfd_elf_section_data *sec_data = elf_section_data (o); 9160 unsigned long symndx = sec_data->this_hdr.sh_info; 9161 asection *osec = o->output_section; 9162 9163 if (symndx >= locsymcount 9164 || (elf_bad_symtab (input_bfd) 9165 && finfo->sections[symndx] == NULL)) 9166 { 9167 struct elf_link_hash_entry *h = sym_hashes[symndx - extsymoff]; 9168 while (h->root.type == bfd_link_hash_indirect 9169 || h->root.type == bfd_link_hash_warning) 9170 h = (struct elf_link_hash_entry *) h->root.u.i.link; 9171 /* Arrange for symbol to be output. */ 9172 h->indx = -2; 9173 elf_section_data (osec)->this_hdr.sh_info = -2; 9174 } 9175 else if (ELF_ST_TYPE (isymbuf[symndx].st_info) == STT_SECTION) 9176 { 9177 /* We'll use the output section target_index. */ 9178 asection *sec = finfo->sections[symndx]->output_section; 9179 elf_section_data (osec)->this_hdr.sh_info = sec->target_index; 9180 } 9181 else 9182 { 9183 if (finfo->indices[symndx] == -1) 9184 { 9185 /* Otherwise output the local symbol now. */ 9186 Elf_Internal_Sym sym = isymbuf[symndx]; 9187 asection *sec = finfo->sections[symndx]->output_section; 9188 const char *name; 9189 long indx; 9190 int ret; 9191 9192 name = bfd_elf_string_from_elf_section (input_bfd, 9193 symtab_hdr->sh_link, 9194 sym.st_name); 9195 if (name == NULL) 9196 return FALSE; 9197 9198 sym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd, 9199 sec); 9200 if (sym.st_shndx == SHN_BAD) 9201 return FALSE; 9202 9203 sym.st_value += o->output_offset; 9204 9205 indx = bfd_get_symcount (output_bfd); 9206 ret = elf_link_output_sym (finfo, name, &sym, o, NULL); 9207 if (ret == 0) 9208 return FALSE; 9209 else if (ret == 1) 9210 finfo->indices[symndx] = indx; 9211 else 9212 abort (); 9213 } 9214 elf_section_data (osec)->this_hdr.sh_info 9215 = finfo->indices[symndx]; 9216 } 9217 } 9218 9219 if ((o->flags & SEC_HAS_CONTENTS) == 0 9220 || (o->size == 0 && (o->flags & SEC_RELOC) == 0)) 9221 continue; 9222 9223 if ((o->flags & SEC_LINKER_CREATED) != 0) 9224 { 9225 /* Section was created by _bfd_elf_link_create_dynamic_sections 9226 or somesuch. */ 9227 continue; 9228 } 9229 9230 /* Get the contents of the section. They have been cached by a 9231 relaxation routine. Note that o is a section in an input 9232 file, so the contents field will not have been set by any of 9233 the routines which work on output files. */ 9234 if (elf_section_data (o)->this_hdr.contents != NULL) 9235 contents = elf_section_data (o)->this_hdr.contents; 9236 else 9237 { 9238 bfd_size_type amt = o->rawsize ? o->rawsize : o->size; 9239 9240 contents = finfo->contents; 9241 if (! bfd_get_section_contents (input_bfd, o, contents, 0, amt)) 9242 return FALSE; 9243 } 9244 9245 if ((o->flags & SEC_RELOC) != 0) 9246 { 9247 Elf_Internal_Rela *internal_relocs; 9248 Elf_Internal_Rela *rel, *relend; 9249 bfd_vma r_type_mask; 9250 int r_sym_shift; 9251 int action_discarded; 9252 int ret; 9253 9254 /* Get the swapped relocs. */ 9255 internal_relocs 9256 = _bfd_elf_link_read_relocs (input_bfd, o, finfo->external_relocs, 9257 finfo->internal_relocs, FALSE); 9258 if (internal_relocs == NULL 9259 && o->reloc_count > 0) 9260 return FALSE; 9261 9262 if (bed->s->arch_size == 32) 9263 { 9264 r_type_mask = 0xff; 9265 r_sym_shift = 8; 9266 } 9267 else 9268 { 9269 r_type_mask = 0xffffffff; 9270 r_sym_shift = 32; 9271 } 9272 9273 action_discarded = -1; 9274 if (!elf_section_ignore_discarded_relocs (o)) 9275 action_discarded = (*bed->action_discarded) (o); 9276 9277 /* Run through the relocs evaluating complex reloc symbols and 9278 looking for relocs against symbols from discarded sections 9279 or section symbols from removed link-once sections. 9280 Complain about relocs against discarded sections. Zero 9281 relocs against removed link-once sections. */ 9282 9283 rel = internal_relocs; 9284 relend = rel + o->reloc_count * bed->s->int_rels_per_ext_rel; 9285 for ( ; rel < relend; rel++) 9286 { 9287 unsigned long r_symndx = rel->r_info >> r_sym_shift; 9288 unsigned int s_type; 9289 asection **ps, *sec; 9290 struct elf_link_hash_entry *h = NULL; 9291 const char *sym_name; 9292 9293 if (r_symndx == STN_UNDEF) 9294 continue; 9295 9296 if (r_symndx >= locsymcount 9297 || (elf_bad_symtab (input_bfd) 9298 && finfo->sections[r_symndx] == NULL)) 9299 { 9300 h = sym_hashes[r_symndx - extsymoff]; 9301 9302 /* Badly formatted input files can contain relocs that 9303 reference non-existant symbols. Check here so that 9304 we do not seg fault. */ 9305 if (h == NULL) 9306 { 9307 char buffer [32]; 9308 9309 sprintf_vma (buffer, rel->r_info); 9310 (*_bfd_error_handler) 9311 (_("error: %B contains a reloc (0x%s) for section %A " 9312 "that references a non-existent global symbol"), 9313 input_bfd, o, buffer); 9314 bfd_set_error (bfd_error_bad_value); 9315 return FALSE; 9316 } 9317 9318 while (h->root.type == bfd_link_hash_indirect 9319 || h->root.type == bfd_link_hash_warning) 9320 h = (struct elf_link_hash_entry *) h->root.u.i.link; 9321 9322 s_type = h->type; 9323 9324 ps = NULL; 9325 if (h->root.type == bfd_link_hash_defined 9326 || h->root.type == bfd_link_hash_defweak) 9327 ps = &h->root.u.def.section; 9328 9329 sym_name = h->root.root.string; 9330 } 9331 else 9332 { 9333 Elf_Internal_Sym *sym = isymbuf + r_symndx; 9334 9335 s_type = ELF_ST_TYPE (sym->st_info); 9336 ps = &finfo->sections[r_symndx]; 9337 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, 9338 sym, *ps); 9339 } 9340 9341 if ((s_type == STT_RELC || s_type == STT_SRELC) 9342 && !finfo->info->relocatable) 9343 { 9344 bfd_vma val; 9345 bfd_vma dot = (rel->r_offset 9346 + o->output_offset + o->output_section->vma); 9347 #ifdef DEBUG 9348 printf ("Encountered a complex symbol!"); 9349 printf (" (input_bfd %s, section %s, reloc %ld\n", 9350 input_bfd->filename, o->name, rel - internal_relocs); 9351 printf (" symbol: idx %8.8lx, name %s\n", 9352 r_symndx, sym_name); 9353 printf (" reloc : info %8.8lx, addr %8.8lx\n", 9354 (unsigned long) rel->r_info, 9355 (unsigned long) rel->r_offset); 9356 #endif 9357 if (!eval_symbol (&val, &sym_name, input_bfd, finfo, dot, 9358 isymbuf, locsymcount, s_type == STT_SRELC)) 9359 return FALSE; 9360 9361 /* Symbol evaluated OK. Update to absolute value. */ 9362 set_symbol_value (input_bfd, isymbuf, locsymcount, 9363 r_symndx, val); 9364 continue; 9365 } 9366 9367 if (action_discarded != -1 && ps != NULL) 9368 { 9369 /* Complain if the definition comes from a 9370 discarded section. */ 9371 if ((sec = *ps) != NULL && elf_discarded_section (sec)) 9372 { 9373 BFD_ASSERT (r_symndx != 0); 9374 if (action_discarded & COMPLAIN) 9375 (*finfo->info->callbacks->einfo) 9376 (_("%X`%s' referenced in section `%A' of %B: " 9377 "defined in discarded section `%A' of %B\n"), 9378 sym_name, o, input_bfd, sec, sec->owner); 9379 9380 /* Try to do the best we can to support buggy old 9381 versions of gcc. Pretend that the symbol is 9382 really defined in the kept linkonce section. 9383 FIXME: This is quite broken. Modifying the 9384 symbol here means we will be changing all later 9385 uses of the symbol, not just in this section. */ 9386 if (action_discarded & PRETEND) 9387 { 9388 asection *kept; 9389 9390 kept = _bfd_elf_check_kept_section (sec, 9391 finfo->info); 9392 if (kept != NULL) 9393 { 9394 *ps = kept; 9395 continue; 9396 } 9397 } 9398 } 9399 } 9400 } 9401 9402 /* Relocate the section by invoking a back end routine. 9403 9404 The back end routine is responsible for adjusting the 9405 section contents as necessary, and (if using Rela relocs 9406 and generating a relocatable output file) adjusting the 9407 reloc addend as necessary. 9408 9409 The back end routine does not have to worry about setting 9410 the reloc address or the reloc symbol index. 9411 9412 The back end routine is given a pointer to the swapped in 9413 internal symbols, and can access the hash table entries 9414 for the external symbols via elf_sym_hashes (input_bfd). 9415 9416 When generating relocatable output, the back end routine 9417 must handle STB_LOCAL/STT_SECTION symbols specially. The 9418 output symbol is going to be a section symbol 9419 corresponding to the output section, which will require 9420 the addend to be adjusted. */ 9421 9422 ret = (*relocate_section) (output_bfd, finfo->info, 9423 input_bfd, o, contents, 9424 internal_relocs, 9425 isymbuf, 9426 finfo->sections); 9427 if (!ret) 9428 return FALSE; 9429 9430 if (ret == 2 9431 || finfo->info->relocatable 9432 || finfo->info->emitrelocations) 9433 { 9434 Elf_Internal_Rela *irela; 9435 Elf_Internal_Rela *irelaend; 9436 bfd_vma last_offset; 9437 struct elf_link_hash_entry **rel_hash; 9438 struct elf_link_hash_entry **rel_hash_list; 9439 Elf_Internal_Shdr *input_rel_hdr, *input_rel_hdr2; 9440 unsigned int next_erel; 9441 bfd_boolean rela_normal; 9442 9443 input_rel_hdr = &elf_section_data (o)->rel_hdr; 9444 rela_normal = (bed->rela_normal 9445 && (input_rel_hdr->sh_entsize 9446 == bed->s->sizeof_rela)); 9447 9448 /* Adjust the reloc addresses and symbol indices. */ 9449 9450 irela = internal_relocs; 9451 irelaend = irela + o->reloc_count * bed->s->int_rels_per_ext_rel; 9452 rel_hash = (elf_section_data (o->output_section)->rel_hashes 9453 + elf_section_data (o->output_section)->rel_count 9454 + elf_section_data (o->output_section)->rel_count2); 9455 rel_hash_list = rel_hash; 9456 last_offset = o->output_offset; 9457 if (!finfo->info->relocatable) 9458 last_offset += o->output_section->vma; 9459 for (next_erel = 0; irela < irelaend; irela++, next_erel++) 9460 { 9461 unsigned long r_symndx; 9462 asection *sec; 9463 Elf_Internal_Sym sym; 9464 9465 if (next_erel == bed->s->int_rels_per_ext_rel) 9466 { 9467 rel_hash++; 9468 next_erel = 0; 9469 } 9470 9471 irela->r_offset = _bfd_elf_section_offset (output_bfd, 9472 finfo->info, o, 9473 irela->r_offset); 9474 if (irela->r_offset >= (bfd_vma) -2) 9475 { 9476 /* This is a reloc for a deleted entry or somesuch. 9477 Turn it into an R_*_NONE reloc, at the same 9478 offset as the last reloc. elf_eh_frame.c and 9479 bfd_elf_discard_info rely on reloc offsets 9480 being ordered. */ 9481 irela->r_offset = last_offset; 9482 irela->r_info = 0; 9483 irela->r_addend = 0; 9484 continue; 9485 } 9486 9487 irela->r_offset += o->output_offset; 9488 9489 /* Relocs in an executable have to be virtual addresses. */ 9490 if (!finfo->info->relocatable) 9491 irela->r_offset += o->output_section->vma; 9492 9493 last_offset = irela->r_offset; 9494 9495 r_symndx = irela->r_info >> r_sym_shift; 9496 if (r_symndx == STN_UNDEF) 9497 continue; 9498 9499 if (r_symndx >= locsymcount 9500 || (elf_bad_symtab (input_bfd) 9501 && finfo->sections[r_symndx] == NULL)) 9502 { 9503 struct elf_link_hash_entry *rh; 9504 unsigned long indx; 9505 9506 /* This is a reloc against a global symbol. We 9507 have not yet output all the local symbols, so 9508 we do not know the symbol index of any global 9509 symbol. We set the rel_hash entry for this 9510 reloc to point to the global hash table entry 9511 for this symbol. The symbol index is then 9512 set at the end of bfd_elf_final_link. */ 9513 indx = r_symndx - extsymoff; 9514 rh = elf_sym_hashes (input_bfd)[indx]; 9515 while (rh->root.type == bfd_link_hash_indirect 9516 || rh->root.type == bfd_link_hash_warning) 9517 rh = (struct elf_link_hash_entry *) rh->root.u.i.link; 9518 9519 /* Setting the index to -2 tells 9520 elf_link_output_extsym that this symbol is 9521 used by a reloc. */ 9522 BFD_ASSERT (rh->indx < 0); 9523 rh->indx = -2; 9524 9525 *rel_hash = rh; 9526 9527 continue; 9528 } 9529 9530 /* This is a reloc against a local symbol. */ 9531 9532 *rel_hash = NULL; 9533 sym = isymbuf[r_symndx]; 9534 sec = finfo->sections[r_symndx]; 9535 if (ELF_ST_TYPE (sym.st_info) == STT_SECTION) 9536 { 9537 /* I suppose the backend ought to fill in the 9538 section of any STT_SECTION symbol against a 9539 processor specific section. */ 9540 r_symndx = 0; 9541 if (bfd_is_abs_section (sec)) 9542 ; 9543 else if (sec == NULL || sec->owner == NULL) 9544 { 9545 bfd_set_error (bfd_error_bad_value); 9546 return FALSE; 9547 } 9548 else 9549 { 9550 asection *osec = sec->output_section; 9551 9552 /* If we have discarded a section, the output 9553 section will be the absolute section. In 9554 case of discarded SEC_MERGE sections, use 9555 the kept section. relocate_section should 9556 have already handled discarded linkonce 9557 sections. */ 9558 if (bfd_is_abs_section (osec) 9559 && sec->kept_section != NULL 9560 && sec->kept_section->output_section != NULL) 9561 { 9562 osec = sec->kept_section->output_section; 9563 irela->r_addend -= osec->vma; 9564 } 9565 9566 if (!bfd_is_abs_section (osec)) 9567 { 9568 r_symndx = osec->target_index; 9569 if (r_symndx == 0) 9570 { 9571 struct elf_link_hash_table *htab; 9572 asection *oi; 9573 9574 htab = elf_hash_table (finfo->info); 9575 oi = htab->text_index_section; 9576 if ((osec->flags & SEC_READONLY) == 0 9577 && htab->data_index_section != NULL) 9578 oi = htab->data_index_section; 9579 9580 if (oi != NULL) 9581 { 9582 irela->r_addend += osec->vma - oi->vma; 9583 r_symndx = oi->target_index; 9584 } 9585 } 9586 9587 BFD_ASSERT (r_symndx != 0); 9588 } 9589 } 9590 9591 /* Adjust the addend according to where the 9592 section winds up in the output section. */ 9593 if (rela_normal) 9594 irela->r_addend += sec->output_offset; 9595 } 9596 else 9597 { 9598 if (finfo->indices[r_symndx] == -1) 9599 { 9600 unsigned long shlink; 9601 const char *name; 9602 asection *osec; 9603 long indx; 9604 9605 if (finfo->info->strip == strip_all) 9606 { 9607 /* You can't do ld -r -s. */ 9608 bfd_set_error (bfd_error_invalid_operation); 9609 return FALSE; 9610 } 9611 9612 /* This symbol was skipped earlier, but 9613 since it is needed by a reloc, we 9614 must output it now. */ 9615 shlink = symtab_hdr->sh_link; 9616 name = (bfd_elf_string_from_elf_section 9617 (input_bfd, shlink, sym.st_name)); 9618 if (name == NULL) 9619 return FALSE; 9620 9621 osec = sec->output_section; 9622 sym.st_shndx = 9623 _bfd_elf_section_from_bfd_section (output_bfd, 9624 osec); 9625 if (sym.st_shndx == SHN_BAD) 9626 return FALSE; 9627 9628 sym.st_value += sec->output_offset; 9629 if (! finfo->info->relocatable) 9630 { 9631 sym.st_value += osec->vma; 9632 if (ELF_ST_TYPE (sym.st_info) == STT_TLS) 9633 { 9634 /* STT_TLS symbols are relative to PT_TLS 9635 segment base. */ 9636 BFD_ASSERT (elf_hash_table (finfo->info) 9637 ->tls_sec != NULL); 9638 sym.st_value -= (elf_hash_table (finfo->info) 9639 ->tls_sec->vma); 9640 } 9641 } 9642 9643 indx = bfd_get_symcount (output_bfd); 9644 ret = elf_link_output_sym (finfo, name, &sym, sec, 9645 NULL); 9646 if (ret == 0) 9647 return FALSE; 9648 else if (ret == 1) 9649 finfo->indices[r_symndx] = indx; 9650 else 9651 abort (); 9652 } 9653 9654 r_symndx = finfo->indices[r_symndx]; 9655 } 9656 9657 irela->r_info = ((bfd_vma) r_symndx << r_sym_shift 9658 | (irela->r_info & r_type_mask)); 9659 } 9660 9661 /* Swap out the relocs. */ 9662 if (input_rel_hdr->sh_size != 0 9663 && !bed->elf_backend_emit_relocs (output_bfd, o, 9664 input_rel_hdr, 9665 internal_relocs, 9666 rel_hash_list)) 9667 return FALSE; 9668 9669 input_rel_hdr2 = elf_section_data (o)->rel_hdr2; 9670 if (input_rel_hdr2 && input_rel_hdr2->sh_size != 0) 9671 { 9672 internal_relocs += (NUM_SHDR_ENTRIES (input_rel_hdr) 9673 * bed->s->int_rels_per_ext_rel); 9674 rel_hash_list += NUM_SHDR_ENTRIES (input_rel_hdr); 9675 if (!bed->elf_backend_emit_relocs (output_bfd, o, 9676 input_rel_hdr2, 9677 internal_relocs, 9678 rel_hash_list)) 9679 return FALSE; 9680 } 9681 } 9682 } 9683 9684 /* Write out the modified section contents. */ 9685 if (bed->elf_backend_write_section 9686 && (*bed->elf_backend_write_section) (output_bfd, finfo->info, o, 9687 contents)) 9688 { 9689 /* Section written out. */ 9690 } 9691 else switch (o->sec_info_type) 9692 { 9693 case ELF_INFO_TYPE_STABS: 9694 if (! (_bfd_write_section_stabs 9695 (output_bfd, 9696 &elf_hash_table (finfo->info)->stab_info, 9697 o, &elf_section_data (o)->sec_info, contents))) 9698 return FALSE; 9699 break; 9700 case ELF_INFO_TYPE_MERGE: 9701 if (! _bfd_write_merged_section (output_bfd, o, 9702 elf_section_data (o)->sec_info)) 9703 return FALSE; 9704 break; 9705 case ELF_INFO_TYPE_EH_FRAME: 9706 { 9707 if (! _bfd_elf_write_section_eh_frame (output_bfd, finfo->info, 9708 o, contents)) 9709 return FALSE; 9710 } 9711 break; 9712 default: 9713 { 9714 /* FIXME: octets_per_byte. */ 9715 if (! (o->flags & SEC_EXCLUDE) 9716 && ! (o->output_section->flags & SEC_NEVER_LOAD) 9717 && ! bfd_set_section_contents (output_bfd, o->output_section, 9718 contents, 9719 (file_ptr) o->output_offset, 9720 o->size)) 9721 return FALSE; 9722 } 9723 break; 9724 } 9725 } 9726 9727 return TRUE; 9728 } 9729 9730 /* Generate a reloc when linking an ELF file. This is a reloc 9731 requested by the linker, and does not come from any input file. This 9732 is used to build constructor and destructor tables when linking 9733 with -Ur. */ 9734 9735 static bfd_boolean 9736 elf_reloc_link_order (bfd *output_bfd, 9737 struct bfd_link_info *info, 9738 asection *output_section, 9739 struct bfd_link_order *link_order) 9740 { 9741 reloc_howto_type *howto; 9742 long indx; 9743 bfd_vma offset; 9744 bfd_vma addend; 9745 struct elf_link_hash_entry **rel_hash_ptr; 9746 Elf_Internal_Shdr *rel_hdr; 9747 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd); 9748 Elf_Internal_Rela irel[MAX_INT_RELS_PER_EXT_REL]; 9749 bfd_byte *erel; 9750 unsigned int i; 9751 9752 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc); 9753 if (howto == NULL) 9754 { 9755 bfd_set_error (bfd_error_bad_value); 9756 return FALSE; 9757 } 9758 9759 addend = link_order->u.reloc.p->addend; 9760 9761 /* Figure out the symbol index. */ 9762 rel_hash_ptr = (elf_section_data (output_section)->rel_hashes 9763 + elf_section_data (output_section)->rel_count 9764 + elf_section_data (output_section)->rel_count2); 9765 if (link_order->type == bfd_section_reloc_link_order) 9766 { 9767 indx = link_order->u.reloc.p->u.section->target_index; 9768 BFD_ASSERT (indx != 0); 9769 *rel_hash_ptr = NULL; 9770 } 9771 else 9772 { 9773 struct elf_link_hash_entry *h; 9774 9775 /* Treat a reloc against a defined symbol as though it were 9776 actually against the section. */ 9777 h = ((struct elf_link_hash_entry *) 9778 bfd_wrapped_link_hash_lookup (output_bfd, info, 9779 link_order->u.reloc.p->u.name, 9780 FALSE, FALSE, TRUE)); 9781 if (h != NULL 9782 && (h->root.type == bfd_link_hash_defined 9783 || h->root.type == bfd_link_hash_defweak)) 9784 { 9785 asection *section; 9786 9787 section = h->root.u.def.section; 9788 indx = section->output_section->target_index; 9789 *rel_hash_ptr = NULL; 9790 /* It seems that we ought to add the symbol value to the 9791 addend here, but in practice it has already been added 9792 because it was passed to constructor_callback. */ 9793 addend += section->output_section->vma + section->output_offset; 9794 } 9795 else if (h != NULL) 9796 { 9797 /* Setting the index to -2 tells elf_link_output_extsym that 9798 this symbol is used by a reloc. */ 9799 h->indx = -2; 9800 *rel_hash_ptr = h; 9801 indx = 0; 9802 } 9803 else 9804 { 9805 if (! ((*info->callbacks->unattached_reloc) 9806 (info, link_order->u.reloc.p->u.name, NULL, NULL, 0))) 9807 return FALSE; 9808 indx = 0; 9809 } 9810 } 9811 9812 /* If this is an inplace reloc, we must write the addend into the 9813 object file. */ 9814 if (howto->partial_inplace && addend != 0) 9815 { 9816 bfd_size_type size; 9817 bfd_reloc_status_type rstat; 9818 bfd_byte *buf; 9819 bfd_boolean ok; 9820 const char *sym_name; 9821 9822 size = (bfd_size_type) bfd_get_reloc_size (howto); 9823 buf = (bfd_byte *) bfd_zmalloc (size); 9824 if (buf == NULL) 9825 return FALSE; 9826 rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf); 9827 switch (rstat) 9828 { 9829 case bfd_reloc_ok: 9830 break; 9831 9832 default: 9833 case bfd_reloc_outofrange: 9834 abort (); 9835 9836 case bfd_reloc_overflow: 9837 if (link_order->type == bfd_section_reloc_link_order) 9838 sym_name = bfd_section_name (output_bfd, 9839 link_order->u.reloc.p->u.section); 9840 else 9841 sym_name = link_order->u.reloc.p->u.name; 9842 if (! ((*info->callbacks->reloc_overflow) 9843 (info, NULL, sym_name, howto->name, addend, NULL, 9844 NULL, (bfd_vma) 0))) 9845 { 9846 free (buf); 9847 return FALSE; 9848 } 9849 break; 9850 } 9851 ok = bfd_set_section_contents (output_bfd, output_section, buf, 9852 link_order->offset, size); 9853 free (buf); 9854 if (! ok) 9855 return FALSE; 9856 } 9857 9858 /* The address of a reloc is relative to the section in a 9859 relocatable file, and is a virtual address in an executable 9860 file. */ 9861 offset = link_order->offset; 9862 if (! info->relocatable) 9863 offset += output_section->vma; 9864 9865 for (i = 0; i < bed->s->int_rels_per_ext_rel; i++) 9866 { 9867 irel[i].r_offset = offset; 9868 irel[i].r_info = 0; 9869 irel[i].r_addend = 0; 9870 } 9871 if (bed->s->arch_size == 32) 9872 irel[0].r_info = ELF32_R_INFO (indx, howto->type); 9873 else 9874 irel[0].r_info = ELF64_R_INFO (indx, howto->type); 9875 9876 rel_hdr = &elf_section_data (output_section)->rel_hdr; 9877 erel = rel_hdr->contents; 9878 if (rel_hdr->sh_type == SHT_REL) 9879 { 9880 erel += (elf_section_data (output_section)->rel_count 9881 * bed->s->sizeof_rel); 9882 (*bed->s->swap_reloc_out) (output_bfd, irel, erel); 9883 } 9884 else 9885 { 9886 irel[0].r_addend = addend; 9887 erel += (elf_section_data (output_section)->rel_count 9888 * bed->s->sizeof_rela); 9889 (*bed->s->swap_reloca_out) (output_bfd, irel, erel); 9890 } 9891 9892 ++elf_section_data (output_section)->rel_count; 9893 9894 return TRUE; 9895 } 9896 9897 9898 /* Get the output vma of the section pointed to by the sh_link field. */ 9899 9900 static bfd_vma 9901 elf_get_linked_section_vma (struct bfd_link_order *p) 9902 { 9903 Elf_Internal_Shdr **elf_shdrp; 9904 asection *s; 9905 int elfsec; 9906 9907 s = p->u.indirect.section; 9908 elf_shdrp = elf_elfsections (s->owner); 9909 elfsec = _bfd_elf_section_from_bfd_section (s->owner, s); 9910 elfsec = elf_shdrp[elfsec]->sh_link; 9911 /* PR 290: 9912 The Intel C compiler generates SHT_IA_64_UNWIND with 9913 SHF_LINK_ORDER. But it doesn't set the sh_link or 9914 sh_info fields. Hence we could get the situation 9915 where elfsec is 0. */ 9916 if (elfsec == 0) 9917 { 9918 const struct elf_backend_data *bed 9919 = get_elf_backend_data (s->owner); 9920 if (bed->link_order_error_handler) 9921 bed->link_order_error_handler 9922 (_("%B: warning: sh_link not set for section `%A'"), s->owner, s); 9923 return 0; 9924 } 9925 else 9926 { 9927 s = elf_shdrp[elfsec]->bfd_section; 9928 return s->output_section->vma + s->output_offset; 9929 } 9930 } 9931 9932 9933 /* Compare two sections based on the locations of the sections they are 9934 linked to. Used by elf_fixup_link_order. */ 9935 9936 static int 9937 compare_link_order (const void * a, const void * b) 9938 { 9939 bfd_vma apos; 9940 bfd_vma bpos; 9941 9942 apos = elf_get_linked_section_vma (*(struct bfd_link_order **)a); 9943 bpos = elf_get_linked_section_vma (*(struct bfd_link_order **)b); 9944 if (apos < bpos) 9945 return -1; 9946 return apos > bpos; 9947 } 9948 9949 9950 /* Looks for sections with SHF_LINK_ORDER set. Rearranges them into the same 9951 order as their linked sections. Returns false if this could not be done 9952 because an output section includes both ordered and unordered 9953 sections. Ideally we'd do this in the linker proper. */ 9954 9955 static bfd_boolean 9956 elf_fixup_link_order (bfd *abfd, asection *o) 9957 { 9958 int seen_linkorder; 9959 int seen_other; 9960 int n; 9961 struct bfd_link_order *p; 9962 bfd *sub; 9963 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 9964 unsigned elfsec; 9965 struct bfd_link_order **sections; 9966 asection *s, *other_sec, *linkorder_sec; 9967 bfd_vma offset; 9968 9969 other_sec = NULL; 9970 linkorder_sec = NULL; 9971 seen_other = 0; 9972 seen_linkorder = 0; 9973 for (p = o->map_head.link_order; p != NULL; p = p->next) 9974 { 9975 if (p->type == bfd_indirect_link_order) 9976 { 9977 s = p->u.indirect.section; 9978 sub = s->owner; 9979 if (bfd_get_flavour (sub) == bfd_target_elf_flavour 9980 && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass 9981 && (elfsec = _bfd_elf_section_from_bfd_section (sub, s)) 9982 && elfsec < elf_numsections (sub) 9983 && elf_elfsections (sub)[elfsec]->sh_flags & SHF_LINK_ORDER 9984 && elf_elfsections (sub)[elfsec]->sh_link < elf_numsections (sub)) 9985 { 9986 seen_linkorder++; 9987 linkorder_sec = s; 9988 } 9989 else 9990 { 9991 seen_other++; 9992 other_sec = s; 9993 } 9994 } 9995 else 9996 seen_other++; 9997 9998 if (seen_other && seen_linkorder) 9999 { 10000 if (other_sec && linkorder_sec) 10001 (*_bfd_error_handler) (_("%A has both ordered [`%A' in %B] and unordered [`%A' in %B] sections"), 10002 o, linkorder_sec, 10003 linkorder_sec->owner, other_sec, 10004 other_sec->owner); 10005 else 10006 (*_bfd_error_handler) (_("%A has both ordered and unordered sections"), 10007 o); 10008 bfd_set_error (bfd_error_bad_value); 10009 return FALSE; 10010 } 10011 } 10012 10013 if (!seen_linkorder) 10014 return TRUE; 10015 10016 sections = (struct bfd_link_order **) 10017 bfd_malloc (seen_linkorder * sizeof (struct bfd_link_order *)); 10018 if (sections == NULL) 10019 return FALSE; 10020 seen_linkorder = 0; 10021 10022 for (p = o->map_head.link_order; p != NULL; p = p->next) 10023 { 10024 sections[seen_linkorder++] = p; 10025 } 10026 /* Sort the input sections in the order of their linked section. */ 10027 qsort (sections, seen_linkorder, sizeof (struct bfd_link_order *), 10028 compare_link_order); 10029 10030 /* Change the offsets of the sections. */ 10031 offset = 0; 10032 for (n = 0; n < seen_linkorder; n++) 10033 { 10034 s = sections[n]->u.indirect.section; 10035 offset &= ~(bfd_vma) 0 << s->alignment_power; 10036 s->output_offset = offset; 10037 sections[n]->offset = offset; 10038 /* FIXME: octets_per_byte. */ 10039 offset += sections[n]->size; 10040 } 10041 10042 free (sections); 10043 return TRUE; 10044 } 10045 10046 10047 /* Do the final step of an ELF link. */ 10048 10049 bfd_boolean 10050 bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info) 10051 { 10052 bfd_boolean dynamic; 10053 bfd_boolean emit_relocs; 10054 bfd *dynobj; 10055 struct elf_final_link_info finfo; 10056 register asection *o; 10057 register struct bfd_link_order *p; 10058 register bfd *sub; 10059 bfd_size_type max_contents_size; 10060 bfd_size_type max_external_reloc_size; 10061 bfd_size_type max_internal_reloc_count; 10062 bfd_size_type max_sym_count; 10063 bfd_size_type max_sym_shndx_count; 10064 file_ptr off; 10065 Elf_Internal_Sym elfsym; 10066 unsigned int i; 10067 Elf_Internal_Shdr *symtab_hdr; 10068 Elf_Internal_Shdr *symtab_shndx_hdr; 10069 Elf_Internal_Shdr *symstrtab_hdr; 10070 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 10071 struct elf_outext_info eoinfo; 10072 bfd_boolean merged; 10073 size_t relativecount = 0; 10074 asection *reldyn = 0; 10075 bfd_size_type amt; 10076 asection *attr_section = NULL; 10077 bfd_vma attr_size = 0; 10078 const char *std_attrs_section; 10079 10080 if (! is_elf_hash_table (info->hash)) 10081 return FALSE; 10082 10083 if (info->shared) 10084 abfd->flags |= DYNAMIC; 10085 10086 dynamic = elf_hash_table (info)->dynamic_sections_created; 10087 dynobj = elf_hash_table (info)->dynobj; 10088 10089 emit_relocs = (info->relocatable 10090 || info->emitrelocations); 10091 10092 finfo.info = info; 10093 finfo.output_bfd = abfd; 10094 finfo.symstrtab = _bfd_elf_stringtab_init (); 10095 if (finfo.symstrtab == NULL) 10096 return FALSE; 10097 10098 if (! dynamic) 10099 { 10100 finfo.dynsym_sec = NULL; 10101 finfo.hash_sec = NULL; 10102 finfo.symver_sec = NULL; 10103 } 10104 else 10105 { 10106 finfo.dynsym_sec = bfd_get_section_by_name (dynobj, ".dynsym"); 10107 finfo.hash_sec = bfd_get_section_by_name (dynobj, ".hash"); 10108 BFD_ASSERT (finfo.dynsym_sec != NULL); 10109 finfo.symver_sec = bfd_get_section_by_name (dynobj, ".gnu.version"); 10110 /* Note that it is OK if symver_sec is NULL. */ 10111 } 10112 10113 finfo.contents = NULL; 10114 finfo.external_relocs = NULL; 10115 finfo.internal_relocs = NULL; 10116 finfo.external_syms = NULL; 10117 finfo.locsym_shndx = NULL; 10118 finfo.internal_syms = NULL; 10119 finfo.indices = NULL; 10120 finfo.sections = NULL; 10121 finfo.symbuf = NULL; 10122 finfo.symshndxbuf = NULL; 10123 finfo.symbuf_count = 0; 10124 finfo.shndxbuf_size = 0; 10125 10126 /* The object attributes have been merged. Remove the input 10127 sections from the link, and set the contents of the output 10128 secton. */ 10129 std_attrs_section = get_elf_backend_data (abfd)->obj_attrs_section; 10130 for (o = abfd->sections; o != NULL; o = o->next) 10131 { 10132 if ((std_attrs_section && strcmp (o->name, std_attrs_section) == 0) 10133 || strcmp (o->name, ".gnu.attributes") == 0) 10134 { 10135 for (p = o->map_head.link_order; p != NULL; p = p->next) 10136 { 10137 asection *input_section; 10138 10139 if (p->type != bfd_indirect_link_order) 10140 continue; 10141 input_section = p->u.indirect.section; 10142 /* Hack: reset the SEC_HAS_CONTENTS flag so that 10143 elf_link_input_bfd ignores this section. */ 10144 input_section->flags &= ~SEC_HAS_CONTENTS; 10145 } 10146 10147 attr_size = bfd_elf_obj_attr_size (abfd); 10148 if (attr_size) 10149 { 10150 bfd_set_section_size (abfd, o, attr_size); 10151 attr_section = o; 10152 /* Skip this section later on. */ 10153 o->map_head.link_order = NULL; 10154 } 10155 else 10156 o->flags |= SEC_EXCLUDE; 10157 } 10158 } 10159 10160 /* Count up the number of relocations we will output for each output 10161 section, so that we know the sizes of the reloc sections. We 10162 also figure out some maximum sizes. */ 10163 max_contents_size = 0; 10164 max_external_reloc_size = 0; 10165 max_internal_reloc_count = 0; 10166 max_sym_count = 0; 10167 max_sym_shndx_count = 0; 10168 merged = FALSE; 10169 for (o = abfd->sections; o != NULL; o = o->next) 10170 { 10171 struct bfd_elf_section_data *esdo = elf_section_data (o); 10172 o->reloc_count = 0; 10173 10174 for (p = o->map_head.link_order; p != NULL; p = p->next) 10175 { 10176 unsigned int reloc_count = 0; 10177 struct bfd_elf_section_data *esdi = NULL; 10178 unsigned int *rel_count1; 10179 10180 if (p->type == bfd_section_reloc_link_order 10181 || p->type == bfd_symbol_reloc_link_order) 10182 reloc_count = 1; 10183 else if (p->type == bfd_indirect_link_order) 10184 { 10185 asection *sec; 10186 10187 sec = p->u.indirect.section; 10188 esdi = elf_section_data (sec); 10189 10190 /* Mark all sections which are to be included in the 10191 link. This will normally be every section. We need 10192 to do this so that we can identify any sections which 10193 the linker has decided to not include. */ 10194 sec->linker_mark = TRUE; 10195 10196 if (sec->flags & SEC_MERGE) 10197 merged = TRUE; 10198 10199 if (info->relocatable || info->emitrelocations) 10200 reloc_count = sec->reloc_count; 10201 else if (bed->elf_backend_count_relocs) 10202 reloc_count = (*bed->elf_backend_count_relocs) (info, sec); 10203 10204 if (sec->rawsize > max_contents_size) 10205 max_contents_size = sec->rawsize; 10206 if (sec->size > max_contents_size) 10207 max_contents_size = sec->size; 10208 10209 /* We are interested in just local symbols, not all 10210 symbols. */ 10211 if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour 10212 && (sec->owner->flags & DYNAMIC) == 0) 10213 { 10214 size_t sym_count; 10215 10216 if (elf_bad_symtab (sec->owner)) 10217 sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size 10218 / bed->s->sizeof_sym); 10219 else 10220 sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info; 10221 10222 if (sym_count > max_sym_count) 10223 max_sym_count = sym_count; 10224 10225 if (sym_count > max_sym_shndx_count 10226 && elf_symtab_shndx (sec->owner) != 0) 10227 max_sym_shndx_count = sym_count; 10228 10229 if ((sec->flags & SEC_RELOC) != 0) 10230 { 10231 size_t ext_size; 10232 10233 ext_size = elf_section_data (sec)->rel_hdr.sh_size; 10234 if (ext_size > max_external_reloc_size) 10235 max_external_reloc_size = ext_size; 10236 if (sec->reloc_count > max_internal_reloc_count) 10237 max_internal_reloc_count = sec->reloc_count; 10238 } 10239 } 10240 } 10241 10242 if (reloc_count == 0) 10243 continue; 10244 10245 o->reloc_count += reloc_count; 10246 10247 /* MIPS may have a mix of REL and RELA relocs on sections. 10248 To support this curious ABI we keep reloc counts in 10249 elf_section_data too. We must be careful to add the 10250 relocations from the input section to the right output 10251 count. FIXME: Get rid of one count. We have 10252 o->reloc_count == esdo->rel_count + esdo->rel_count2. */ 10253 rel_count1 = &esdo->rel_count; 10254 if (esdi != NULL) 10255 { 10256 bfd_boolean same_size; 10257 bfd_size_type entsize1; 10258 10259 entsize1 = esdi->rel_hdr.sh_entsize; 10260 /* PR 9827: If the header size has not been set yet then 10261 assume that it will match the output section's reloc type. */ 10262 if (entsize1 == 0) 10263 entsize1 = o->use_rela_p ? bed->s->sizeof_rela : bed->s->sizeof_rel; 10264 else 10265 BFD_ASSERT (entsize1 == bed->s->sizeof_rel 10266 || entsize1 == bed->s->sizeof_rela); 10267 same_size = !o->use_rela_p == (entsize1 == bed->s->sizeof_rel); 10268 10269 if (!same_size) 10270 rel_count1 = &esdo->rel_count2; 10271 10272 if (esdi->rel_hdr2 != NULL) 10273 { 10274 bfd_size_type entsize2 = esdi->rel_hdr2->sh_entsize; 10275 unsigned int alt_count; 10276 unsigned int *rel_count2; 10277 10278 BFD_ASSERT (entsize2 != entsize1 10279 && (entsize2 == bed->s->sizeof_rel 10280 || entsize2 == bed->s->sizeof_rela)); 10281 10282 rel_count2 = &esdo->rel_count2; 10283 if (!same_size) 10284 rel_count2 = &esdo->rel_count; 10285 10286 /* The following is probably too simplistic if the 10287 backend counts output relocs unusually. */ 10288 BFD_ASSERT (bed->elf_backend_count_relocs == NULL); 10289 alt_count = NUM_SHDR_ENTRIES (esdi->rel_hdr2); 10290 *rel_count2 += alt_count; 10291 reloc_count -= alt_count; 10292 } 10293 } 10294 *rel_count1 += reloc_count; 10295 } 10296 10297 if (o->reloc_count > 0) 10298 o->flags |= SEC_RELOC; 10299 else 10300 { 10301 /* Explicitly clear the SEC_RELOC flag. The linker tends to 10302 set it (this is probably a bug) and if it is set 10303 assign_section_numbers will create a reloc section. */ 10304 o->flags &=~ SEC_RELOC; 10305 } 10306 10307 /* If the SEC_ALLOC flag is not set, force the section VMA to 10308 zero. This is done in elf_fake_sections as well, but forcing 10309 the VMA to 0 here will ensure that relocs against these 10310 sections are handled correctly. */ 10311 if ((o->flags & SEC_ALLOC) == 0 10312 && ! o->user_set_vma) 10313 o->vma = 0; 10314 } 10315 10316 if (! info->relocatable && merged) 10317 elf_link_hash_traverse (elf_hash_table (info), 10318 _bfd_elf_link_sec_merge_syms, abfd); 10319 10320 /* Figure out the file positions for everything but the symbol table 10321 and the relocs. We set symcount to force assign_section_numbers 10322 to create a symbol table. */ 10323 bfd_get_symcount (abfd) = info->strip == strip_all ? 0 : 1; 10324 BFD_ASSERT (! abfd->output_has_begun); 10325 if (! _bfd_elf_compute_section_file_positions (abfd, info)) 10326 goto error_return; 10327 10328 /* Set sizes, and assign file positions for reloc sections. */ 10329 for (o = abfd->sections; o != NULL; o = o->next) 10330 { 10331 if ((o->flags & SEC_RELOC) != 0) 10332 { 10333 if (!(_bfd_elf_link_size_reloc_section 10334 (abfd, &elf_section_data (o)->rel_hdr, o))) 10335 goto error_return; 10336 10337 if (elf_section_data (o)->rel_hdr2 10338 && !(_bfd_elf_link_size_reloc_section 10339 (abfd, elf_section_data (o)->rel_hdr2, o))) 10340 goto error_return; 10341 } 10342 10343 /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them 10344 to count upwards while actually outputting the relocations. */ 10345 elf_section_data (o)->rel_count = 0; 10346 elf_section_data (o)->rel_count2 = 0; 10347 } 10348 10349 _bfd_elf_assign_file_positions_for_relocs (abfd); 10350 10351 /* We have now assigned file positions for all the sections except 10352 .symtab and .strtab. We start the .symtab section at the current 10353 file position, and write directly to it. We build the .strtab 10354 section in memory. */ 10355 bfd_get_symcount (abfd) = 0; 10356 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 10357 /* sh_name is set in prep_headers. */ 10358 symtab_hdr->sh_type = SHT_SYMTAB; 10359 /* sh_flags, sh_addr and sh_size all start off zero. */ 10360 symtab_hdr->sh_entsize = bed->s->sizeof_sym; 10361 /* sh_link is set in assign_section_numbers. */ 10362 /* sh_info is set below. */ 10363 /* sh_offset is set just below. */ 10364 symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align; 10365 10366 off = elf_tdata (abfd)->next_file_pos; 10367 off = _bfd_elf_assign_file_position_for_section (symtab_hdr, off, TRUE); 10368 10369 /* Note that at this point elf_tdata (abfd)->next_file_pos is 10370 incorrect. We do not yet know the size of the .symtab section. 10371 We correct next_file_pos below, after we do know the size. */ 10372 10373 /* Allocate a buffer to hold swapped out symbols. This is to avoid 10374 continuously seeking to the right position in the file. */ 10375 if (! info->keep_memory || max_sym_count < 20) 10376 finfo.symbuf_size = 20; 10377 else 10378 finfo.symbuf_size = max_sym_count; 10379 amt = finfo.symbuf_size; 10380 amt *= bed->s->sizeof_sym; 10381 finfo.symbuf = (bfd_byte *) bfd_malloc (amt); 10382 if (finfo.symbuf == NULL) 10383 goto error_return; 10384 if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF)) 10385 { 10386 /* Wild guess at number of output symbols. realloc'd as needed. */ 10387 amt = 2 * max_sym_count + elf_numsections (abfd) + 1000; 10388 finfo.shndxbuf_size = amt; 10389 amt *= sizeof (Elf_External_Sym_Shndx); 10390 finfo.symshndxbuf = (Elf_External_Sym_Shndx *) bfd_zmalloc (amt); 10391 if (finfo.symshndxbuf == NULL) 10392 goto error_return; 10393 } 10394 10395 /* Start writing out the symbol table. The first symbol is always a 10396 dummy symbol. */ 10397 if (info->strip != strip_all 10398 || emit_relocs) 10399 { 10400 elfsym.st_value = 0; 10401 elfsym.st_size = 0; 10402 elfsym.st_info = 0; 10403 elfsym.st_other = 0; 10404 elfsym.st_shndx = SHN_UNDEF; 10405 if (elf_link_output_sym (&finfo, NULL, &elfsym, bfd_und_section_ptr, 10406 NULL) != 1) 10407 goto error_return; 10408 } 10409 10410 /* Output a symbol for each section. We output these even if we are 10411 discarding local symbols, since they are used for relocs. These 10412 symbols have no names. We store the index of each one in the 10413 index field of the section, so that we can find it again when 10414 outputting relocs. */ 10415 if (info->strip != strip_all 10416 || emit_relocs) 10417 { 10418 elfsym.st_size = 0; 10419 elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION); 10420 elfsym.st_other = 0; 10421 elfsym.st_value = 0; 10422 for (i = 1; i < elf_numsections (abfd); i++) 10423 { 10424 o = bfd_section_from_elf_index (abfd, i); 10425 if (o != NULL) 10426 { 10427 o->target_index = bfd_get_symcount (abfd); 10428 elfsym.st_shndx = i; 10429 if (!info->relocatable) 10430 elfsym.st_value = o->vma; 10431 if (elf_link_output_sym (&finfo, NULL, &elfsym, o, NULL) != 1) 10432 goto error_return; 10433 } 10434 } 10435 } 10436 10437 /* Allocate some memory to hold information read in from the input 10438 files. */ 10439 if (max_contents_size != 0) 10440 { 10441 finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size); 10442 if (finfo.contents == NULL) 10443 goto error_return; 10444 } 10445 10446 if (max_external_reloc_size != 0) 10447 { 10448 finfo.external_relocs = bfd_malloc (max_external_reloc_size); 10449 if (finfo.external_relocs == NULL) 10450 goto error_return; 10451 } 10452 10453 if (max_internal_reloc_count != 0) 10454 { 10455 amt = max_internal_reloc_count * bed->s->int_rels_per_ext_rel; 10456 amt *= sizeof (Elf_Internal_Rela); 10457 finfo.internal_relocs = (Elf_Internal_Rela *) bfd_malloc (amt); 10458 if (finfo.internal_relocs == NULL) 10459 goto error_return; 10460 } 10461 10462 if (max_sym_count != 0) 10463 { 10464 amt = max_sym_count * bed->s->sizeof_sym; 10465 finfo.external_syms = (bfd_byte *) bfd_malloc (amt); 10466 if (finfo.external_syms == NULL) 10467 goto error_return; 10468 10469 amt = max_sym_count * sizeof (Elf_Internal_Sym); 10470 finfo.internal_syms = (Elf_Internal_Sym *) bfd_malloc (amt); 10471 if (finfo.internal_syms == NULL) 10472 goto error_return; 10473 10474 amt = max_sym_count * sizeof (long); 10475 finfo.indices = (long int *) bfd_malloc (amt); 10476 if (finfo.indices == NULL) 10477 goto error_return; 10478 10479 amt = max_sym_count * sizeof (asection *); 10480 finfo.sections = (asection **) bfd_malloc (amt); 10481 if (finfo.sections == NULL) 10482 goto error_return; 10483 } 10484 10485 if (max_sym_shndx_count != 0) 10486 { 10487 amt = max_sym_shndx_count * sizeof (Elf_External_Sym_Shndx); 10488 finfo.locsym_shndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt); 10489 if (finfo.locsym_shndx == NULL) 10490 goto error_return; 10491 } 10492 10493 if (elf_hash_table (info)->tls_sec) 10494 { 10495 bfd_vma base, end = 0; 10496 asection *sec; 10497 10498 for (sec = elf_hash_table (info)->tls_sec; 10499 sec && (sec->flags & SEC_THREAD_LOCAL); 10500 sec = sec->next) 10501 { 10502 bfd_size_type size = sec->size; 10503 10504 if (size == 0 10505 && (sec->flags & SEC_HAS_CONTENTS) == 0) 10506 { 10507 struct bfd_link_order *o = sec->map_tail.link_order; 10508 if (o != NULL) 10509 size = o->offset + o->size; 10510 } 10511 end = sec->vma + size; 10512 } 10513 base = elf_hash_table (info)->tls_sec->vma; 10514 end = align_power (end, elf_hash_table (info)->tls_sec->alignment_power); 10515 elf_hash_table (info)->tls_size = end - base; 10516 } 10517 10518 /* Reorder SHF_LINK_ORDER sections. */ 10519 for (o = abfd->sections; o != NULL; o = o->next) 10520 { 10521 if (!elf_fixup_link_order (abfd, o)) 10522 return FALSE; 10523 } 10524 10525 /* Since ELF permits relocations to be against local symbols, we 10526 must have the local symbols available when we do the relocations. 10527 Since we would rather only read the local symbols once, and we 10528 would rather not keep them in memory, we handle all the 10529 relocations for a single input file at the same time. 10530 10531 Unfortunately, there is no way to know the total number of local 10532 symbols until we have seen all of them, and the local symbol 10533 indices precede the global symbol indices. This means that when 10534 we are generating relocatable output, and we see a reloc against 10535 a global symbol, we can not know the symbol index until we have 10536 finished examining all the local symbols to see which ones we are 10537 going to output. To deal with this, we keep the relocations in 10538 memory, and don't output them until the end of the link. This is 10539 an unfortunate waste of memory, but I don't see a good way around 10540 it. Fortunately, it only happens when performing a relocatable 10541 link, which is not the common case. FIXME: If keep_memory is set 10542 we could write the relocs out and then read them again; I don't 10543 know how bad the memory loss will be. */ 10544 10545 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next) 10546 sub->output_has_begun = FALSE; 10547 for (o = abfd->sections; o != NULL; o = o->next) 10548 { 10549 for (p = o->map_head.link_order; p != NULL; p = p->next) 10550 { 10551 if (p->type == bfd_indirect_link_order 10552 && (bfd_get_flavour ((sub = p->u.indirect.section->owner)) 10553 == bfd_target_elf_flavour) 10554 && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass) 10555 { 10556 if (! sub->output_has_begun) 10557 { 10558 if (! elf_link_input_bfd (&finfo, sub)) 10559 goto error_return; 10560 sub->output_has_begun = TRUE; 10561 } 10562 } 10563 else if (p->type == bfd_section_reloc_link_order 10564 || p->type == bfd_symbol_reloc_link_order) 10565 { 10566 if (! elf_reloc_link_order (abfd, info, o, p)) 10567 goto error_return; 10568 } 10569 else 10570 { 10571 if (! _bfd_default_link_order (abfd, info, o, p)) 10572 goto error_return; 10573 } 10574 } 10575 } 10576 10577 /* Free symbol buffer if needed. */ 10578 if (!info->reduce_memory_overheads) 10579 { 10580 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next) 10581 if (bfd_get_flavour (sub) == bfd_target_elf_flavour 10582 && elf_tdata (sub)->symbuf) 10583 { 10584 free (elf_tdata (sub)->symbuf); 10585 elf_tdata (sub)->symbuf = NULL; 10586 } 10587 } 10588 10589 /* Output any global symbols that got converted to local in a 10590 version script or due to symbol visibility. We do this in a 10591 separate step since ELF requires all local symbols to appear 10592 prior to any global symbols. FIXME: We should only do this if 10593 some global symbols were, in fact, converted to become local. 10594 FIXME: Will this work correctly with the Irix 5 linker? */ 10595 eoinfo.failed = FALSE; 10596 eoinfo.finfo = &finfo; 10597 eoinfo.localsyms = TRUE; 10598 elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym, 10599 &eoinfo); 10600 if (eoinfo.failed) 10601 return FALSE; 10602 10603 /* If backend needs to output some local symbols not present in the hash 10604 table, do it now. */ 10605 if (bed->elf_backend_output_arch_local_syms) 10606 { 10607 typedef int (*out_sym_func) 10608 (void *, const char *, Elf_Internal_Sym *, asection *, 10609 struct elf_link_hash_entry *); 10610 10611 if (! ((*bed->elf_backend_output_arch_local_syms) 10612 (abfd, info, &finfo, (out_sym_func) elf_link_output_sym))) 10613 return FALSE; 10614 } 10615 10616 /* That wrote out all the local symbols. Finish up the symbol table 10617 with the global symbols. Even if we want to strip everything we 10618 can, we still need to deal with those global symbols that got 10619 converted to local in a version script. */ 10620 10621 /* The sh_info field records the index of the first non local symbol. */ 10622 symtab_hdr->sh_info = bfd_get_symcount (abfd); 10623 10624 if (dynamic 10625 && finfo.dynsym_sec->output_section != bfd_abs_section_ptr) 10626 { 10627 Elf_Internal_Sym sym; 10628 bfd_byte *dynsym = finfo.dynsym_sec->contents; 10629 long last_local = 0; 10630 10631 /* Write out the section symbols for the output sections. */ 10632 if (info->shared || elf_hash_table (info)->is_relocatable_executable) 10633 { 10634 asection *s; 10635 10636 sym.st_size = 0; 10637 sym.st_name = 0; 10638 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION); 10639 sym.st_other = 0; 10640 10641 for (s = abfd->sections; s != NULL; s = s->next) 10642 { 10643 int indx; 10644 bfd_byte *dest; 10645 long dynindx; 10646 10647 dynindx = elf_section_data (s)->dynindx; 10648 if (dynindx <= 0) 10649 continue; 10650 indx = elf_section_data (s)->this_idx; 10651 BFD_ASSERT (indx > 0); 10652 sym.st_shndx = indx; 10653 if (! check_dynsym (abfd, &sym)) 10654 return FALSE; 10655 sym.st_value = s->vma; 10656 dest = dynsym + dynindx * bed->s->sizeof_sym; 10657 if (last_local < dynindx) 10658 last_local = dynindx; 10659 bed->s->swap_symbol_out (abfd, &sym, dest, 0); 10660 } 10661 } 10662 10663 /* Write out the local dynsyms. */ 10664 if (elf_hash_table (info)->dynlocal) 10665 { 10666 struct elf_link_local_dynamic_entry *e; 10667 for (e = elf_hash_table (info)->dynlocal; e ; e = e->next) 10668 { 10669 asection *s; 10670 bfd_byte *dest; 10671 10672 sym.st_size = e->isym.st_size; 10673 sym.st_other = e->isym.st_other; 10674 10675 /* Copy the internal symbol as is. 10676 Note that we saved a word of storage and overwrote 10677 the original st_name with the dynstr_index. */ 10678 sym = e->isym; 10679 10680 s = bfd_section_from_elf_index (e->input_bfd, 10681 e->isym.st_shndx); 10682 if (s != NULL) 10683 { 10684 sym.st_shndx = 10685 elf_section_data (s->output_section)->this_idx; 10686 if (! check_dynsym (abfd, &sym)) 10687 return FALSE; 10688 sym.st_value = (s->output_section->vma 10689 + s->output_offset 10690 + e->isym.st_value); 10691 } 10692 10693 if (last_local < e->dynindx) 10694 last_local = e->dynindx; 10695 10696 dest = dynsym + e->dynindx * bed->s->sizeof_sym; 10697 bed->s->swap_symbol_out (abfd, &sym, dest, 0); 10698 } 10699 } 10700 10701 elf_section_data (finfo.dynsym_sec->output_section)->this_hdr.sh_info = 10702 last_local + 1; 10703 } 10704 10705 /* We get the global symbols from the hash table. */ 10706 eoinfo.failed = FALSE; 10707 eoinfo.localsyms = FALSE; 10708 eoinfo.finfo = &finfo; 10709 elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym, 10710 &eoinfo); 10711 if (eoinfo.failed) 10712 return FALSE; 10713 10714 /* If backend needs to output some symbols not present in the hash 10715 table, do it now. */ 10716 if (bed->elf_backend_output_arch_syms) 10717 { 10718 typedef int (*out_sym_func) 10719 (void *, const char *, Elf_Internal_Sym *, asection *, 10720 struct elf_link_hash_entry *); 10721 10722 if (! ((*bed->elf_backend_output_arch_syms) 10723 (abfd, info, &finfo, (out_sym_func) elf_link_output_sym))) 10724 return FALSE; 10725 } 10726 10727 /* Flush all symbols to the file. */ 10728 if (! elf_link_flush_output_syms (&finfo, bed)) 10729 return FALSE; 10730 10731 /* Now we know the size of the symtab section. */ 10732 off += symtab_hdr->sh_size; 10733 10734 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr; 10735 if (symtab_shndx_hdr->sh_name != 0) 10736 { 10737 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX; 10738 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx); 10739 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx); 10740 amt = bfd_get_symcount (abfd) * sizeof (Elf_External_Sym_Shndx); 10741 symtab_shndx_hdr->sh_size = amt; 10742 10743 off = _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr, 10744 off, TRUE); 10745 10746 if (bfd_seek (abfd, symtab_shndx_hdr->sh_offset, SEEK_SET) != 0 10747 || (bfd_bwrite (finfo.symshndxbuf, amt, abfd) != amt)) 10748 return FALSE; 10749 } 10750 10751 10752 /* Finish up and write out the symbol string table (.strtab) 10753 section. */ 10754 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr; 10755 /* sh_name was set in prep_headers. */ 10756 symstrtab_hdr->sh_type = SHT_STRTAB; 10757 symstrtab_hdr->sh_flags = 0; 10758 symstrtab_hdr->sh_addr = 0; 10759 symstrtab_hdr->sh_size = _bfd_stringtab_size (finfo.symstrtab); 10760 symstrtab_hdr->sh_entsize = 0; 10761 symstrtab_hdr->sh_link = 0; 10762 symstrtab_hdr->sh_info = 0; 10763 /* sh_offset is set just below. */ 10764 symstrtab_hdr->sh_addralign = 1; 10765 10766 off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr, off, TRUE); 10767 elf_tdata (abfd)->next_file_pos = off; 10768 10769 if (bfd_get_symcount (abfd) > 0) 10770 { 10771 if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0 10772 || ! _bfd_stringtab_emit (abfd, finfo.symstrtab)) 10773 return FALSE; 10774 } 10775 10776 /* Adjust the relocs to have the correct symbol indices. */ 10777 for (o = abfd->sections; o != NULL; o = o->next) 10778 { 10779 if ((o->flags & SEC_RELOC) == 0) 10780 continue; 10781 10782 elf_link_adjust_relocs (abfd, &elf_section_data (o)->rel_hdr, 10783 elf_section_data (o)->rel_count, 10784 elf_section_data (o)->rel_hashes); 10785 if (elf_section_data (o)->rel_hdr2 != NULL) 10786 elf_link_adjust_relocs (abfd, elf_section_data (o)->rel_hdr2, 10787 elf_section_data (o)->rel_count2, 10788 (elf_section_data (o)->rel_hashes 10789 + elf_section_data (o)->rel_count)); 10790 10791 /* Set the reloc_count field to 0 to prevent write_relocs from 10792 trying to swap the relocs out itself. */ 10793 o->reloc_count = 0; 10794 } 10795 10796 if (dynamic && info->combreloc && dynobj != NULL) 10797 relativecount = elf_link_sort_relocs (abfd, info, &reldyn); 10798 10799 /* If we are linking against a dynamic object, or generating a 10800 shared library, finish up the dynamic linking information. */ 10801 if (dynamic) 10802 { 10803 bfd_byte *dyncon, *dynconend; 10804 10805 /* Fix up .dynamic entries. */ 10806 o = bfd_get_section_by_name (dynobj, ".dynamic"); 10807 BFD_ASSERT (o != NULL); 10808 10809 dyncon = o->contents; 10810 dynconend = o->contents + o->size; 10811 for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn) 10812 { 10813 Elf_Internal_Dyn dyn; 10814 const char *name; 10815 unsigned int type; 10816 10817 bed->s->swap_dyn_in (dynobj, dyncon, &dyn); 10818 10819 switch (dyn.d_tag) 10820 { 10821 default: 10822 continue; 10823 case DT_NULL: 10824 if (relativecount > 0 && dyncon + bed->s->sizeof_dyn < dynconend) 10825 { 10826 switch (elf_section_data (reldyn)->this_hdr.sh_type) 10827 { 10828 case SHT_REL: dyn.d_tag = DT_RELCOUNT; break; 10829 case SHT_RELA: dyn.d_tag = DT_RELACOUNT; break; 10830 default: continue; 10831 } 10832 dyn.d_un.d_val = relativecount; 10833 relativecount = 0; 10834 break; 10835 } 10836 continue; 10837 10838 case DT_INIT: 10839 name = info->init_function; 10840 goto get_sym; 10841 case DT_FINI: 10842 name = info->fini_function; 10843 get_sym: 10844 { 10845 struct elf_link_hash_entry *h; 10846 10847 h = elf_link_hash_lookup (elf_hash_table (info), name, 10848 FALSE, FALSE, TRUE); 10849 if (h != NULL 10850 && (h->root.type == bfd_link_hash_defined 10851 || h->root.type == bfd_link_hash_defweak)) 10852 { 10853 dyn.d_un.d_ptr = h->root.u.def.value; 10854 o = h->root.u.def.section; 10855 if (o->output_section != NULL) 10856 dyn.d_un.d_ptr += (o->output_section->vma 10857 + o->output_offset); 10858 else 10859 { 10860 /* The symbol is imported from another shared 10861 library and does not apply to this one. */ 10862 dyn.d_un.d_ptr = 0; 10863 } 10864 break; 10865 } 10866 } 10867 continue; 10868 10869 case DT_PREINIT_ARRAYSZ: 10870 name = ".preinit_array"; 10871 goto get_size; 10872 case DT_INIT_ARRAYSZ: 10873 name = ".init_array"; 10874 goto get_size; 10875 case DT_FINI_ARRAYSZ: 10876 name = ".fini_array"; 10877 get_size: 10878 o = bfd_get_section_by_name (abfd, name); 10879 if (o == NULL) 10880 { 10881 (*_bfd_error_handler) 10882 (_("%B: could not find output section %s"), abfd, name); 10883 goto error_return; 10884 } 10885 if (o->size == 0) 10886 (*_bfd_error_handler) 10887 (_("warning: %s section has zero size"), name); 10888 dyn.d_un.d_val = o->size; 10889 break; 10890 10891 case DT_PREINIT_ARRAY: 10892 name = ".preinit_array"; 10893 goto get_vma; 10894 case DT_INIT_ARRAY: 10895 name = ".init_array"; 10896 goto get_vma; 10897 case DT_FINI_ARRAY: 10898 name = ".fini_array"; 10899 goto get_vma; 10900 10901 case DT_HASH: 10902 name = ".hash"; 10903 goto get_vma; 10904 case DT_GNU_HASH: 10905 name = ".gnu.hash"; 10906 goto get_vma; 10907 case DT_STRTAB: 10908 name = ".dynstr"; 10909 goto get_vma; 10910 case DT_SYMTAB: 10911 name = ".dynsym"; 10912 goto get_vma; 10913 case DT_VERDEF: 10914 name = ".gnu.version_d"; 10915 goto get_vma; 10916 case DT_VERNEED: 10917 name = ".gnu.version_r"; 10918 goto get_vma; 10919 case DT_VERSYM: 10920 name = ".gnu.version"; 10921 get_vma: 10922 o = bfd_get_section_by_name (abfd, name); 10923 if (o == NULL) 10924 { 10925 (*_bfd_error_handler) 10926 (_("%B: could not find output section %s"), abfd, name); 10927 goto error_return; 10928 } 10929 dyn.d_un.d_ptr = o->vma; 10930 break; 10931 10932 case DT_REL: 10933 case DT_RELA: 10934 case DT_RELSZ: 10935 case DT_RELASZ: 10936 if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ) 10937 type = SHT_REL; 10938 else 10939 type = SHT_RELA; 10940 dyn.d_un.d_val = 0; 10941 dyn.d_un.d_ptr = 0; 10942 for (i = 1; i < elf_numsections (abfd); i++) 10943 { 10944 Elf_Internal_Shdr *hdr; 10945 10946 hdr = elf_elfsections (abfd)[i]; 10947 if (hdr->sh_type == type 10948 && (hdr->sh_flags & SHF_ALLOC) != 0) 10949 { 10950 if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ) 10951 dyn.d_un.d_val += hdr->sh_size; 10952 else 10953 { 10954 if (dyn.d_un.d_ptr == 0 10955 || hdr->sh_addr < dyn.d_un.d_ptr) 10956 dyn.d_un.d_ptr = hdr->sh_addr; 10957 } 10958 } 10959 } 10960 break; 10961 } 10962 bed->s->swap_dyn_out (dynobj, &dyn, dyncon); 10963 } 10964 } 10965 10966 /* If we have created any dynamic sections, then output them. */ 10967 if (dynobj != NULL) 10968 { 10969 if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info)) 10970 goto error_return; 10971 10972 /* Check for DT_TEXTREL (late, in case the backend removes it). */ 10973 if (info->warn_shared_textrel && info->shared) 10974 { 10975 bfd_byte *dyncon, *dynconend; 10976 10977 /* Fix up .dynamic entries. */ 10978 o = bfd_get_section_by_name (dynobj, ".dynamic"); 10979 BFD_ASSERT (o != NULL); 10980 10981 dyncon = o->contents; 10982 dynconend = o->contents + o->size; 10983 for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn) 10984 { 10985 Elf_Internal_Dyn dyn; 10986 10987 bed->s->swap_dyn_in (dynobj, dyncon, &dyn); 10988 10989 if (dyn.d_tag == DT_TEXTREL) 10990 { 10991 info->callbacks->einfo 10992 (_("%P: warning: creating a DT_TEXTREL in a shared object.\n")); 10993 break; 10994 } 10995 } 10996 } 10997 10998 for (o = dynobj->sections; o != NULL; o = o->next) 10999 { 11000 if ((o->flags & SEC_HAS_CONTENTS) == 0 11001 || o->size == 0 11002 || o->output_section == bfd_abs_section_ptr) 11003 continue; 11004 if ((o->flags & SEC_LINKER_CREATED) == 0) 11005 { 11006 /* At this point, we are only interested in sections 11007 created by _bfd_elf_link_create_dynamic_sections. */ 11008 continue; 11009 } 11010 if (elf_hash_table (info)->stab_info.stabstr == o) 11011 continue; 11012 if (elf_hash_table (info)->eh_info.hdr_sec == o) 11013 continue; 11014 if ((elf_section_data (o->output_section)->this_hdr.sh_type 11015 != SHT_STRTAB) 11016 || strcmp (bfd_get_section_name (abfd, o), ".dynstr") != 0) 11017 { 11018 /* FIXME: octets_per_byte. */ 11019 if (! bfd_set_section_contents (abfd, o->output_section, 11020 o->contents, 11021 (file_ptr) o->output_offset, 11022 o->size)) 11023 goto error_return; 11024 } 11025 else 11026 { 11027 /* The contents of the .dynstr section are actually in a 11028 stringtab. */ 11029 off = elf_section_data (o->output_section)->this_hdr.sh_offset; 11030 if (bfd_seek (abfd, off, SEEK_SET) != 0 11031 || ! _bfd_elf_strtab_emit (abfd, 11032 elf_hash_table (info)->dynstr)) 11033 goto error_return; 11034 } 11035 } 11036 } 11037 11038 if (info->relocatable) 11039 { 11040 bfd_boolean failed = FALSE; 11041 11042 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed); 11043 if (failed) 11044 goto error_return; 11045 } 11046 11047 /* If we have optimized stabs strings, output them. */ 11048 if (elf_hash_table (info)->stab_info.stabstr != NULL) 11049 { 11050 if (! _bfd_write_stab_strings (abfd, &elf_hash_table (info)->stab_info)) 11051 goto error_return; 11052 } 11053 11054 if (info->eh_frame_hdr) 11055 { 11056 if (! _bfd_elf_write_section_eh_frame_hdr (abfd, info)) 11057 goto error_return; 11058 } 11059 11060 if (finfo.symstrtab != NULL) 11061 _bfd_stringtab_free (finfo.symstrtab); 11062 if (finfo.contents != NULL) 11063 free (finfo.contents); 11064 if (finfo.external_relocs != NULL) 11065 free (finfo.external_relocs); 11066 if (finfo.internal_relocs != NULL) 11067 free (finfo.internal_relocs); 11068 if (finfo.external_syms != NULL) 11069 free (finfo.external_syms); 11070 if (finfo.locsym_shndx != NULL) 11071 free (finfo.locsym_shndx); 11072 if (finfo.internal_syms != NULL) 11073 free (finfo.internal_syms); 11074 if (finfo.indices != NULL) 11075 free (finfo.indices); 11076 if (finfo.sections != NULL) 11077 free (finfo.sections); 11078 if (finfo.symbuf != NULL) 11079 free (finfo.symbuf); 11080 if (finfo.symshndxbuf != NULL) 11081 free (finfo.symshndxbuf); 11082 for (o = abfd->sections; o != NULL; o = o->next) 11083 { 11084 if ((o->flags & SEC_RELOC) != 0 11085 && elf_section_data (o)->rel_hashes != NULL) 11086 free (elf_section_data (o)->rel_hashes); 11087 } 11088 11089 elf_tdata (abfd)->linker = TRUE; 11090 11091 if (attr_section) 11092 { 11093 bfd_byte *contents = (bfd_byte *) bfd_malloc (attr_size); 11094 if (contents == NULL) 11095 return FALSE; /* Bail out and fail. */ 11096 bfd_elf_set_obj_attr_contents (abfd, contents, attr_size); 11097 bfd_set_section_contents (abfd, attr_section, contents, 0, attr_size); 11098 free (contents); 11099 } 11100 11101 return TRUE; 11102 11103 error_return: 11104 if (finfo.symstrtab != NULL) 11105 _bfd_stringtab_free (finfo.symstrtab); 11106 if (finfo.contents != NULL) 11107 free (finfo.contents); 11108 if (finfo.external_relocs != NULL) 11109 free (finfo.external_relocs); 11110 if (finfo.internal_relocs != NULL) 11111 free (finfo.internal_relocs); 11112 if (finfo.external_syms != NULL) 11113 free (finfo.external_syms); 11114 if (finfo.locsym_shndx != NULL) 11115 free (finfo.locsym_shndx); 11116 if (finfo.internal_syms != NULL) 11117 free (finfo.internal_syms); 11118 if (finfo.indices != NULL) 11119 free (finfo.indices); 11120 if (finfo.sections != NULL) 11121 free (finfo.sections); 11122 if (finfo.symbuf != NULL) 11123 free (finfo.symbuf); 11124 if (finfo.symshndxbuf != NULL) 11125 free (finfo.symshndxbuf); 11126 for (o = abfd->sections; o != NULL; o = o->next) 11127 { 11128 if ((o->flags & SEC_RELOC) != 0 11129 && elf_section_data (o)->rel_hashes != NULL) 11130 free (elf_section_data (o)->rel_hashes); 11131 } 11132 11133 return FALSE; 11134 } 11135 11136 /* Initialize COOKIE for input bfd ABFD. */ 11137 11138 static bfd_boolean 11139 init_reloc_cookie (struct elf_reloc_cookie *cookie, 11140 struct bfd_link_info *info, bfd *abfd) 11141 { 11142 Elf_Internal_Shdr *symtab_hdr; 11143 const struct elf_backend_data *bed; 11144 11145 bed = get_elf_backend_data (abfd); 11146 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 11147 11148 cookie->abfd = abfd; 11149 cookie->sym_hashes = elf_sym_hashes (abfd); 11150 cookie->bad_symtab = elf_bad_symtab (abfd); 11151 if (cookie->bad_symtab) 11152 { 11153 cookie->locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym; 11154 cookie->extsymoff = 0; 11155 } 11156 else 11157 { 11158 cookie->locsymcount = symtab_hdr->sh_info; 11159 cookie->extsymoff = symtab_hdr->sh_info; 11160 } 11161 11162 if (bed->s->arch_size == 32) 11163 cookie->r_sym_shift = 8; 11164 else 11165 cookie->r_sym_shift = 32; 11166 11167 cookie->locsyms = (Elf_Internal_Sym *) symtab_hdr->contents; 11168 if (cookie->locsyms == NULL && cookie->locsymcount != 0) 11169 { 11170 cookie->locsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, 11171 cookie->locsymcount, 0, 11172 NULL, NULL, NULL); 11173 if (cookie->locsyms == NULL) 11174 { 11175 info->callbacks->einfo (_("%P%X: can not read symbols: %E\n")); 11176 return FALSE; 11177 } 11178 if (info->keep_memory) 11179 symtab_hdr->contents = (bfd_byte *) cookie->locsyms; 11180 } 11181 return TRUE; 11182 } 11183 11184 /* Free the memory allocated by init_reloc_cookie, if appropriate. */ 11185 11186 static void 11187 fini_reloc_cookie (struct elf_reloc_cookie *cookie, bfd *abfd) 11188 { 11189 Elf_Internal_Shdr *symtab_hdr; 11190 11191 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 11192 if (cookie->locsyms != NULL 11193 && symtab_hdr->contents != (unsigned char *) cookie->locsyms) 11194 free (cookie->locsyms); 11195 } 11196 11197 /* Initialize the relocation information in COOKIE for input section SEC 11198 of input bfd ABFD. */ 11199 11200 static bfd_boolean 11201 init_reloc_cookie_rels (struct elf_reloc_cookie *cookie, 11202 struct bfd_link_info *info, bfd *abfd, 11203 asection *sec) 11204 { 11205 const struct elf_backend_data *bed; 11206 11207 if (sec->reloc_count == 0) 11208 { 11209 cookie->rels = NULL; 11210 cookie->relend = NULL; 11211 } 11212 else 11213 { 11214 bed = get_elf_backend_data (abfd); 11215 11216 cookie->rels = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, 11217 info->keep_memory); 11218 if (cookie->rels == NULL) 11219 return FALSE; 11220 cookie->rel = cookie->rels; 11221 cookie->relend = (cookie->rels 11222 + sec->reloc_count * bed->s->int_rels_per_ext_rel); 11223 } 11224 cookie->rel = cookie->rels; 11225 return TRUE; 11226 } 11227 11228 /* Free the memory allocated by init_reloc_cookie_rels, 11229 if appropriate. */ 11230 11231 static void 11232 fini_reloc_cookie_rels (struct elf_reloc_cookie *cookie, 11233 asection *sec) 11234 { 11235 if (cookie->rels && elf_section_data (sec)->relocs != cookie->rels) 11236 free (cookie->rels); 11237 } 11238 11239 /* Initialize the whole of COOKIE for input section SEC. */ 11240 11241 static bfd_boolean 11242 init_reloc_cookie_for_section (struct elf_reloc_cookie *cookie, 11243 struct bfd_link_info *info, 11244 asection *sec) 11245 { 11246 if (!init_reloc_cookie (cookie, info, sec->owner)) 11247 goto error1; 11248 if (!init_reloc_cookie_rels (cookie, info, sec->owner, sec)) 11249 goto error2; 11250 return TRUE; 11251 11252 error2: 11253 fini_reloc_cookie (cookie, sec->owner); 11254 error1: 11255 return FALSE; 11256 } 11257 11258 /* Free the memory allocated by init_reloc_cookie_for_section, 11259 if appropriate. */ 11260 11261 static void 11262 fini_reloc_cookie_for_section (struct elf_reloc_cookie *cookie, 11263 asection *sec) 11264 { 11265 fini_reloc_cookie_rels (cookie, sec); 11266 fini_reloc_cookie (cookie, sec->owner); 11267 } 11268 11269 /* Garbage collect unused sections. */ 11270 11271 /* Default gc_mark_hook. */ 11272 11273 asection * 11274 _bfd_elf_gc_mark_hook (asection *sec, 11275 struct bfd_link_info *info ATTRIBUTE_UNUSED, 11276 Elf_Internal_Rela *rel ATTRIBUTE_UNUSED, 11277 struct elf_link_hash_entry *h, 11278 Elf_Internal_Sym *sym) 11279 { 11280 if (h != NULL) 11281 { 11282 switch (h->root.type) 11283 { 11284 case bfd_link_hash_defined: 11285 case bfd_link_hash_defweak: 11286 return h->root.u.def.section; 11287 11288 case bfd_link_hash_common: 11289 return h->root.u.c.p->section; 11290 11291 default: 11292 break; 11293 } 11294 } 11295 else 11296 return bfd_section_from_elf_index (sec->owner, sym->st_shndx); 11297 11298 return NULL; 11299 } 11300 11301 /* COOKIE->rel describes a relocation against section SEC, which is 11302 a section we've decided to keep. Return the section that contains 11303 the relocation symbol, or NULL if no section contains it. */ 11304 11305 asection * 11306 _bfd_elf_gc_mark_rsec (struct bfd_link_info *info, asection *sec, 11307 elf_gc_mark_hook_fn gc_mark_hook, 11308 struct elf_reloc_cookie *cookie) 11309 { 11310 unsigned long r_symndx; 11311 struct elf_link_hash_entry *h; 11312 11313 r_symndx = cookie->rel->r_info >> cookie->r_sym_shift; 11314 if (r_symndx == 0) 11315 return NULL; 11316 11317 if (r_symndx >= cookie->locsymcount 11318 || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL) 11319 { 11320 h = cookie->sym_hashes[r_symndx - cookie->extsymoff]; 11321 while (h->root.type == bfd_link_hash_indirect 11322 || h->root.type == bfd_link_hash_warning) 11323 h = (struct elf_link_hash_entry *) h->root.u.i.link; 11324 return (*gc_mark_hook) (sec, info, cookie->rel, h, NULL); 11325 } 11326 11327 return (*gc_mark_hook) (sec, info, cookie->rel, NULL, 11328 &cookie->locsyms[r_symndx]); 11329 } 11330 11331 /* COOKIE->rel describes a relocation against section SEC, which is 11332 a section we've decided to keep. Mark the section that contains 11333 the relocation symbol. */ 11334 11335 bfd_boolean 11336 _bfd_elf_gc_mark_reloc (struct bfd_link_info *info, 11337 asection *sec, 11338 elf_gc_mark_hook_fn gc_mark_hook, 11339 struct elf_reloc_cookie *cookie) 11340 { 11341 asection *rsec; 11342 11343 rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie); 11344 if (rsec && !rsec->gc_mark) 11345 { 11346 if (bfd_get_flavour (rsec->owner) != bfd_target_elf_flavour) 11347 rsec->gc_mark = 1; 11348 else if (!_bfd_elf_gc_mark (info, rsec, gc_mark_hook)) 11349 return FALSE; 11350 } 11351 return TRUE; 11352 } 11353 11354 /* The mark phase of garbage collection. For a given section, mark 11355 it and any sections in this section's group, and all the sections 11356 which define symbols to which it refers. */ 11357 11358 bfd_boolean 11359 _bfd_elf_gc_mark (struct bfd_link_info *info, 11360 asection *sec, 11361 elf_gc_mark_hook_fn gc_mark_hook) 11362 { 11363 bfd_boolean ret; 11364 asection *group_sec, *eh_frame; 11365 11366 sec->gc_mark = 1; 11367 11368 /* Mark all the sections in the group. */ 11369 group_sec = elf_section_data (sec)->next_in_group; 11370 if (group_sec && !group_sec->gc_mark) 11371 if (!_bfd_elf_gc_mark (info, group_sec, gc_mark_hook)) 11372 return FALSE; 11373 11374 /* Look through the section relocs. */ 11375 ret = TRUE; 11376 eh_frame = elf_eh_frame_section (sec->owner); 11377 if ((sec->flags & SEC_RELOC) != 0 11378 && sec->reloc_count > 0 11379 && sec != eh_frame) 11380 { 11381 struct elf_reloc_cookie cookie; 11382 11383 if (!init_reloc_cookie_for_section (&cookie, info, sec)) 11384 ret = FALSE; 11385 else 11386 { 11387 for (; cookie.rel < cookie.relend; cookie.rel++) 11388 if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, &cookie)) 11389 { 11390 ret = FALSE; 11391 break; 11392 } 11393 fini_reloc_cookie_for_section (&cookie, sec); 11394 } 11395 } 11396 11397 if (ret && eh_frame && elf_fde_list (sec)) 11398 { 11399 struct elf_reloc_cookie cookie; 11400 11401 if (!init_reloc_cookie_for_section (&cookie, info, eh_frame)) 11402 ret = FALSE; 11403 else 11404 { 11405 if (!_bfd_elf_gc_mark_fdes (info, sec, eh_frame, 11406 gc_mark_hook, &cookie)) 11407 ret = FALSE; 11408 fini_reloc_cookie_for_section (&cookie, eh_frame); 11409 } 11410 } 11411 11412 return ret; 11413 } 11414 11415 /* Sweep symbols in swept sections. Called via elf_link_hash_traverse. */ 11416 11417 struct elf_gc_sweep_symbol_info 11418 { 11419 struct bfd_link_info *info; 11420 void (*hide_symbol) (struct bfd_link_info *, struct elf_link_hash_entry *, 11421 bfd_boolean); 11422 }; 11423 11424 static bfd_boolean 11425 elf_gc_sweep_symbol (struct elf_link_hash_entry *h, void *data) 11426 { 11427 if (h->root.type == bfd_link_hash_warning) 11428 h = (struct elf_link_hash_entry *) h->root.u.i.link; 11429 11430 if ((h->root.type == bfd_link_hash_defined 11431 || h->root.type == bfd_link_hash_defweak) 11432 && !h->root.u.def.section->gc_mark 11433 && !(h->root.u.def.section->owner->flags & DYNAMIC)) 11434 { 11435 struct elf_gc_sweep_symbol_info *inf = 11436 (struct elf_gc_sweep_symbol_info *) data; 11437 (*inf->hide_symbol) (inf->info, h, TRUE); 11438 } 11439 11440 return TRUE; 11441 } 11442 11443 /* The sweep phase of garbage collection. Remove all garbage sections. */ 11444 11445 typedef bfd_boolean (*gc_sweep_hook_fn) 11446 (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *); 11447 11448 static bfd_boolean 11449 elf_gc_sweep (bfd *abfd, struct bfd_link_info *info) 11450 { 11451 bfd *sub; 11452 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 11453 gc_sweep_hook_fn gc_sweep_hook = bed->gc_sweep_hook; 11454 unsigned long section_sym_count; 11455 struct elf_gc_sweep_symbol_info sweep_info; 11456 11457 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next) 11458 { 11459 asection *o; 11460 11461 if (bfd_get_flavour (sub) != bfd_target_elf_flavour) 11462 continue; 11463 11464 for (o = sub->sections; o != NULL; o = o->next) 11465 { 11466 /* When any section in a section group is kept, we keep all 11467 sections in the section group. If the first member of 11468 the section group is excluded, we will also exclude the 11469 group section. */ 11470 if (o->flags & SEC_GROUP) 11471 { 11472 asection *first = elf_next_in_group (o); 11473 o->gc_mark = first->gc_mark; 11474 } 11475 else if ((o->flags & (SEC_DEBUGGING | SEC_LINKER_CREATED)) != 0 11476 || (o->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0) 11477 { 11478 /* Keep debug and special sections. */ 11479 o->gc_mark = 1; 11480 } 11481 11482 if (o->gc_mark) 11483 continue; 11484 11485 /* Skip sweeping sections already excluded. */ 11486 if (o->flags & SEC_EXCLUDE) 11487 continue; 11488 11489 /* Since this is early in the link process, it is simple 11490 to remove a section from the output. */ 11491 o->flags |= SEC_EXCLUDE; 11492 11493 if (info->print_gc_sections && o->size != 0) 11494 _bfd_error_handler (_("Removing unused section '%s' in file '%B'"), sub, o->name); 11495 11496 /* But we also have to update some of the relocation 11497 info we collected before. */ 11498 if (gc_sweep_hook 11499 && (o->flags & SEC_RELOC) != 0 11500 && o->reloc_count > 0 11501 && !bfd_is_abs_section (o->output_section)) 11502 { 11503 Elf_Internal_Rela *internal_relocs; 11504 bfd_boolean r; 11505 11506 internal_relocs 11507 = _bfd_elf_link_read_relocs (o->owner, o, NULL, NULL, 11508 info->keep_memory); 11509 if (internal_relocs == NULL) 11510 return FALSE; 11511 11512 r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs); 11513 11514 if (elf_section_data (o)->relocs != internal_relocs) 11515 free (internal_relocs); 11516 11517 if (!r) 11518 return FALSE; 11519 } 11520 } 11521 } 11522 11523 /* Remove the symbols that were in the swept sections from the dynamic 11524 symbol table. GCFIXME: Anyone know how to get them out of the 11525 static symbol table as well? */ 11526 sweep_info.info = info; 11527 sweep_info.hide_symbol = bed->elf_backend_hide_symbol; 11528 elf_link_hash_traverse (elf_hash_table (info), elf_gc_sweep_symbol, 11529 &sweep_info); 11530 11531 _bfd_elf_link_renumber_dynsyms (abfd, info, §ion_sym_count); 11532 return TRUE; 11533 } 11534 11535 /* Propagate collected vtable information. This is called through 11536 elf_link_hash_traverse. */ 11537 11538 static bfd_boolean 11539 elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry *h, void *okp) 11540 { 11541 if (h->root.type == bfd_link_hash_warning) 11542 h = (struct elf_link_hash_entry *) h->root.u.i.link; 11543 11544 /* Those that are not vtables. */ 11545 if (h->vtable == NULL || h->vtable->parent == NULL) 11546 return TRUE; 11547 11548 /* Those vtables that do not have parents, we cannot merge. */ 11549 if (h->vtable->parent == (struct elf_link_hash_entry *) -1) 11550 return TRUE; 11551 11552 /* If we've already been done, exit. */ 11553 if (h->vtable->used && h->vtable->used[-1]) 11554 return TRUE; 11555 11556 /* Make sure the parent's table is up to date. */ 11557 elf_gc_propagate_vtable_entries_used (h->vtable->parent, okp); 11558 11559 if (h->vtable->used == NULL) 11560 { 11561 /* None of this table's entries were referenced. Re-use the 11562 parent's table. */ 11563 h->vtable->used = h->vtable->parent->vtable->used; 11564 h->vtable->size = h->vtable->parent->vtable->size; 11565 } 11566 else 11567 { 11568 size_t n; 11569 bfd_boolean *cu, *pu; 11570 11571 /* Or the parent's entries into ours. */ 11572 cu = h->vtable->used; 11573 cu[-1] = TRUE; 11574 pu = h->vtable->parent->vtable->used; 11575 if (pu != NULL) 11576 { 11577 const struct elf_backend_data *bed; 11578 unsigned int log_file_align; 11579 11580 bed = get_elf_backend_data (h->root.u.def.section->owner); 11581 log_file_align = bed->s->log_file_align; 11582 n = h->vtable->parent->vtable->size >> log_file_align; 11583 while (n--) 11584 { 11585 if (*pu) 11586 *cu = TRUE; 11587 pu++; 11588 cu++; 11589 } 11590 } 11591 } 11592 11593 return TRUE; 11594 } 11595 11596 static bfd_boolean 11597 elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry *h, void *okp) 11598 { 11599 asection *sec; 11600 bfd_vma hstart, hend; 11601 Elf_Internal_Rela *relstart, *relend, *rel; 11602 const struct elf_backend_data *bed; 11603 unsigned int log_file_align; 11604 11605 if (h->root.type == bfd_link_hash_warning) 11606 h = (struct elf_link_hash_entry *) h->root.u.i.link; 11607 11608 /* Take care of both those symbols that do not describe vtables as 11609 well as those that are not loaded. */ 11610 if (h->vtable == NULL || h->vtable->parent == NULL) 11611 return TRUE; 11612 11613 BFD_ASSERT (h->root.type == bfd_link_hash_defined 11614 || h->root.type == bfd_link_hash_defweak); 11615 11616 sec = h->root.u.def.section; 11617 hstart = h->root.u.def.value; 11618 hend = hstart + h->size; 11619 11620 relstart = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL, TRUE); 11621 if (!relstart) 11622 return *(bfd_boolean *) okp = FALSE; 11623 bed = get_elf_backend_data (sec->owner); 11624 log_file_align = bed->s->log_file_align; 11625 11626 relend = relstart + sec->reloc_count * bed->s->int_rels_per_ext_rel; 11627 11628 for (rel = relstart; rel < relend; ++rel) 11629 if (rel->r_offset >= hstart && rel->r_offset < hend) 11630 { 11631 /* If the entry is in use, do nothing. */ 11632 if (h->vtable->used 11633 && (rel->r_offset - hstart) < h->vtable->size) 11634 { 11635 bfd_vma entry = (rel->r_offset - hstart) >> log_file_align; 11636 if (h->vtable->used[entry]) 11637 continue; 11638 } 11639 /* Otherwise, kill it. */ 11640 rel->r_offset = rel->r_info = rel->r_addend = 0; 11641 } 11642 11643 return TRUE; 11644 } 11645 11646 /* Mark sections containing dynamically referenced symbols. When 11647 building shared libraries, we must assume that any visible symbol is 11648 referenced. */ 11649 11650 bfd_boolean 11651 bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry *h, void *inf) 11652 { 11653 struct bfd_link_info *info = (struct bfd_link_info *) inf; 11654 11655 if (h->root.type == bfd_link_hash_warning) 11656 h = (struct elf_link_hash_entry *) h->root.u.i.link; 11657 11658 if ((h->root.type == bfd_link_hash_defined 11659 || h->root.type == bfd_link_hash_defweak) 11660 && (h->ref_dynamic 11661 || (!info->executable 11662 && h->def_regular 11663 && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL 11664 && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN))) 11665 h->root.u.def.section->flags |= SEC_KEEP; 11666 11667 return TRUE; 11668 } 11669 11670 /* Keep all sections containing symbols undefined on the command-line, 11671 and the section containing the entry symbol. */ 11672 11673 void 11674 _bfd_elf_gc_keep (struct bfd_link_info *info) 11675 { 11676 struct bfd_sym_chain *sym; 11677 11678 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next) 11679 { 11680 struct elf_link_hash_entry *h; 11681 11682 h = elf_link_hash_lookup (elf_hash_table (info), sym->name, 11683 FALSE, FALSE, FALSE); 11684 11685 if (h != NULL 11686 && (h->root.type == bfd_link_hash_defined 11687 || h->root.type == bfd_link_hash_defweak) 11688 && !bfd_is_abs_section (h->root.u.def.section)) 11689 h->root.u.def.section->flags |= SEC_KEEP; 11690 } 11691 } 11692 11693 /* Do mark and sweep of unused sections. */ 11694 11695 bfd_boolean 11696 bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info) 11697 { 11698 bfd_boolean ok = TRUE; 11699 bfd *sub; 11700 elf_gc_mark_hook_fn gc_mark_hook; 11701 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 11702 11703 if (!bed->can_gc_sections 11704 || !is_elf_hash_table (info->hash)) 11705 { 11706 (*_bfd_error_handler)(_("Warning: gc-sections option ignored")); 11707 return TRUE; 11708 } 11709 11710 bed->gc_keep (info); 11711 11712 /* Try to parse each bfd's .eh_frame section. Point elf_eh_frame_section 11713 at the .eh_frame section if we can mark the FDEs individually. */ 11714 _bfd_elf_begin_eh_frame_parsing (info); 11715 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next) 11716 { 11717 asection *sec; 11718 struct elf_reloc_cookie cookie; 11719 11720 sec = bfd_get_section_by_name (sub, ".eh_frame"); 11721 if (sec && init_reloc_cookie_for_section (&cookie, info, sec)) 11722 { 11723 _bfd_elf_parse_eh_frame (sub, info, sec, &cookie); 11724 if (elf_section_data (sec)->sec_info) 11725 elf_eh_frame_section (sub) = sec; 11726 fini_reloc_cookie_for_section (&cookie, sec); 11727 } 11728 } 11729 _bfd_elf_end_eh_frame_parsing (info); 11730 11731 /* Apply transitive closure to the vtable entry usage info. */ 11732 elf_link_hash_traverse (elf_hash_table (info), 11733 elf_gc_propagate_vtable_entries_used, 11734 &ok); 11735 if (!ok) 11736 return FALSE; 11737 11738 /* Kill the vtable relocations that were not used. */ 11739 elf_link_hash_traverse (elf_hash_table (info), 11740 elf_gc_smash_unused_vtentry_relocs, 11741 &ok); 11742 if (!ok) 11743 return FALSE; 11744 11745 /* Mark dynamically referenced symbols. */ 11746 if (elf_hash_table (info)->dynamic_sections_created) 11747 elf_link_hash_traverse (elf_hash_table (info), 11748 bed->gc_mark_dynamic_ref, 11749 info); 11750 11751 /* Grovel through relocs to find out who stays ... */ 11752 gc_mark_hook = bed->gc_mark_hook; 11753 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next) 11754 { 11755 asection *o; 11756 11757 if (bfd_get_flavour (sub) != bfd_target_elf_flavour) 11758 continue; 11759 11760 for (o = sub->sections; o != NULL; o = o->next) 11761 if ((o->flags & (SEC_EXCLUDE | SEC_KEEP)) == SEC_KEEP && !o->gc_mark) 11762 if (!_bfd_elf_gc_mark (info, o, gc_mark_hook)) 11763 return FALSE; 11764 } 11765 11766 /* Allow the backend to mark additional target specific sections. */ 11767 if (bed->gc_mark_extra_sections) 11768 bed->gc_mark_extra_sections (info, gc_mark_hook); 11769 11770 /* ... and mark SEC_EXCLUDE for those that go. */ 11771 return elf_gc_sweep (abfd, info); 11772 } 11773 11774 /* Called from check_relocs to record the existence of a VTINHERIT reloc. */ 11775 11776 bfd_boolean 11777 bfd_elf_gc_record_vtinherit (bfd *abfd, 11778 asection *sec, 11779 struct elf_link_hash_entry *h, 11780 bfd_vma offset) 11781 { 11782 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end; 11783 struct elf_link_hash_entry **search, *child; 11784 bfd_size_type extsymcount; 11785 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 11786 11787 /* The sh_info field of the symtab header tells us where the 11788 external symbols start. We don't care about the local symbols at 11789 this point. */ 11790 extsymcount = elf_tdata (abfd)->symtab_hdr.sh_size / bed->s->sizeof_sym; 11791 if (!elf_bad_symtab (abfd)) 11792 extsymcount -= elf_tdata (abfd)->symtab_hdr.sh_info; 11793 11794 sym_hashes = elf_sym_hashes (abfd); 11795 sym_hashes_end = sym_hashes + extsymcount; 11796 11797 /* Hunt down the child symbol, which is in this section at the same 11798 offset as the relocation. */ 11799 for (search = sym_hashes; search != sym_hashes_end; ++search) 11800 { 11801 if ((child = *search) != NULL 11802 && (child->root.type == bfd_link_hash_defined 11803 || child->root.type == bfd_link_hash_defweak) 11804 && child->root.u.def.section == sec 11805 && child->root.u.def.value == offset) 11806 goto win; 11807 } 11808 11809 (*_bfd_error_handler) ("%B: %A+%lu: No symbol found for INHERIT", 11810 abfd, sec, (unsigned long) offset); 11811 bfd_set_error (bfd_error_invalid_operation); 11812 return FALSE; 11813 11814 win: 11815 if (!child->vtable) 11816 { 11817 child->vtable = (struct elf_link_virtual_table_entry *) 11818 bfd_zalloc (abfd, sizeof (*child->vtable)); 11819 if (!child->vtable) 11820 return FALSE; 11821 } 11822 if (!h) 11823 { 11824 /* This *should* only be the absolute section. It could potentially 11825 be that someone has defined a non-global vtable though, which 11826 would be bad. It isn't worth paging in the local symbols to be 11827 sure though; that case should simply be handled by the assembler. */ 11828 11829 child->vtable->parent = (struct elf_link_hash_entry *) -1; 11830 } 11831 else 11832 child->vtable->parent = h; 11833 11834 return TRUE; 11835 } 11836 11837 /* Called from check_relocs to record the existence of a VTENTRY reloc. */ 11838 11839 bfd_boolean 11840 bfd_elf_gc_record_vtentry (bfd *abfd ATTRIBUTE_UNUSED, 11841 asection *sec ATTRIBUTE_UNUSED, 11842 struct elf_link_hash_entry *h, 11843 bfd_vma addend) 11844 { 11845 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 11846 unsigned int log_file_align = bed->s->log_file_align; 11847 11848 if (!h->vtable) 11849 { 11850 h->vtable = (struct elf_link_virtual_table_entry *) 11851 bfd_zalloc (abfd, sizeof (*h->vtable)); 11852 if (!h->vtable) 11853 return FALSE; 11854 } 11855 11856 if (addend >= h->vtable->size) 11857 { 11858 size_t size, bytes, file_align; 11859 bfd_boolean *ptr = h->vtable->used; 11860 11861 /* While the symbol is undefined, we have to be prepared to handle 11862 a zero size. */ 11863 file_align = 1 << log_file_align; 11864 if (h->root.type == bfd_link_hash_undefined) 11865 size = addend + file_align; 11866 else 11867 { 11868 size = h->size; 11869 if (addend >= size) 11870 { 11871 /* Oops! We've got a reference past the defined end of 11872 the table. This is probably a bug -- shall we warn? */ 11873 size = addend + file_align; 11874 } 11875 } 11876 size = (size + file_align - 1) & -file_align; 11877 11878 /* Allocate one extra entry for use as a "done" flag for the 11879 consolidation pass. */ 11880 bytes = ((size >> log_file_align) + 1) * sizeof (bfd_boolean); 11881 11882 if (ptr) 11883 { 11884 ptr = (bfd_boolean *) bfd_realloc (ptr - 1, bytes); 11885 11886 if (ptr != NULL) 11887 { 11888 size_t oldbytes; 11889 11890 oldbytes = (((h->vtable->size >> log_file_align) + 1) 11891 * sizeof (bfd_boolean)); 11892 memset (((char *) ptr) + oldbytes, 0, bytes - oldbytes); 11893 } 11894 } 11895 else 11896 ptr = (bfd_boolean *) bfd_zmalloc (bytes); 11897 11898 if (ptr == NULL) 11899 return FALSE; 11900 11901 /* And arrange for that done flag to be at index -1. */ 11902 h->vtable->used = ptr + 1; 11903 h->vtable->size = size; 11904 } 11905 11906 h->vtable->used[addend >> log_file_align] = TRUE; 11907 11908 return TRUE; 11909 } 11910 11911 struct alloc_got_off_arg { 11912 bfd_vma gotoff; 11913 struct bfd_link_info *info; 11914 }; 11915 11916 /* We need a special top-level link routine to convert got reference counts 11917 to real got offsets. */ 11918 11919 static bfd_boolean 11920 elf_gc_allocate_got_offsets (struct elf_link_hash_entry *h, void *arg) 11921 { 11922 struct alloc_got_off_arg *gofarg = (struct alloc_got_off_arg *) arg; 11923 bfd *obfd = gofarg->info->output_bfd; 11924 const struct elf_backend_data *bed = get_elf_backend_data (obfd); 11925 11926 if (h->root.type == bfd_link_hash_warning) 11927 h = (struct elf_link_hash_entry *) h->root.u.i.link; 11928 11929 if (h->got.refcount > 0) 11930 { 11931 h->got.offset = gofarg->gotoff; 11932 gofarg->gotoff += bed->got_elt_size (obfd, gofarg->info, h, NULL, 0); 11933 } 11934 else 11935 h->got.offset = (bfd_vma) -1; 11936 11937 return TRUE; 11938 } 11939 11940 /* And an accompanying bit to work out final got entry offsets once 11941 we're done. Should be called from final_link. */ 11942 11943 bfd_boolean 11944 bfd_elf_gc_common_finalize_got_offsets (bfd *abfd, 11945 struct bfd_link_info *info) 11946 { 11947 bfd *i; 11948 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 11949 bfd_vma gotoff; 11950 struct alloc_got_off_arg gofarg; 11951 11952 BFD_ASSERT (abfd == info->output_bfd); 11953 11954 if (! is_elf_hash_table (info->hash)) 11955 return FALSE; 11956 11957 /* The GOT offset is relative to the .got section, but the GOT header is 11958 put into the .got.plt section, if the backend uses it. */ 11959 if (bed->want_got_plt) 11960 gotoff = 0; 11961 else 11962 gotoff = bed->got_header_size; 11963 11964 /* Do the local .got entries first. */ 11965 for (i = info->input_bfds; i; i = i->link_next) 11966 { 11967 bfd_signed_vma *local_got; 11968 bfd_size_type j, locsymcount; 11969 Elf_Internal_Shdr *symtab_hdr; 11970 11971 if (bfd_get_flavour (i) != bfd_target_elf_flavour) 11972 continue; 11973 11974 local_got = elf_local_got_refcounts (i); 11975 if (!local_got) 11976 continue; 11977 11978 symtab_hdr = &elf_tdata (i)->symtab_hdr; 11979 if (elf_bad_symtab (i)) 11980 locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym; 11981 else 11982 locsymcount = symtab_hdr->sh_info; 11983 11984 for (j = 0; j < locsymcount; ++j) 11985 { 11986 if (local_got[j] > 0) 11987 { 11988 local_got[j] = gotoff; 11989 gotoff += bed->got_elt_size (abfd, info, NULL, i, j); 11990 } 11991 else 11992 local_got[j] = (bfd_vma) -1; 11993 } 11994 } 11995 11996 /* Then the global .got entries. .plt refcounts are handled by 11997 adjust_dynamic_symbol */ 11998 gofarg.gotoff = gotoff; 11999 gofarg.info = info; 12000 elf_link_hash_traverse (elf_hash_table (info), 12001 elf_gc_allocate_got_offsets, 12002 &gofarg); 12003 return TRUE; 12004 } 12005 12006 /* Many folk need no more in the way of final link than this, once 12007 got entry reference counting is enabled. */ 12008 12009 bfd_boolean 12010 bfd_elf_gc_common_final_link (bfd *abfd, struct bfd_link_info *info) 12011 { 12012 if (!bfd_elf_gc_common_finalize_got_offsets (abfd, info)) 12013 return FALSE; 12014 12015 /* Invoke the regular ELF backend linker to do all the work. */ 12016 return bfd_elf_final_link (abfd, info); 12017 } 12018 12019 bfd_boolean 12020 bfd_elf_reloc_symbol_deleted_p (bfd_vma offset, void *cookie) 12021 { 12022 struct elf_reloc_cookie *rcookie = (struct elf_reloc_cookie *) cookie; 12023 12024 if (rcookie->bad_symtab) 12025 rcookie->rel = rcookie->rels; 12026 12027 for (; rcookie->rel < rcookie->relend; rcookie->rel++) 12028 { 12029 unsigned long r_symndx; 12030 12031 if (! rcookie->bad_symtab) 12032 if (rcookie->rel->r_offset > offset) 12033 return FALSE; 12034 if (rcookie->rel->r_offset != offset) 12035 continue; 12036 12037 r_symndx = rcookie->rel->r_info >> rcookie->r_sym_shift; 12038 if (r_symndx == SHN_UNDEF) 12039 return TRUE; 12040 12041 if (r_symndx >= rcookie->locsymcount 12042 || ELF_ST_BIND (rcookie->locsyms[r_symndx].st_info) != STB_LOCAL) 12043 { 12044 struct elf_link_hash_entry *h; 12045 12046 h = rcookie->sym_hashes[r_symndx - rcookie->extsymoff]; 12047 12048 while (h->root.type == bfd_link_hash_indirect 12049 || h->root.type == bfd_link_hash_warning) 12050 h = (struct elf_link_hash_entry *) h->root.u.i.link; 12051 12052 if ((h->root.type == bfd_link_hash_defined 12053 || h->root.type == bfd_link_hash_defweak) 12054 && elf_discarded_section (h->root.u.def.section)) 12055 return TRUE; 12056 else 12057 return FALSE; 12058 } 12059 else 12060 { 12061 /* It's not a relocation against a global symbol, 12062 but it could be a relocation against a local 12063 symbol for a discarded section. */ 12064 asection *isec; 12065 Elf_Internal_Sym *isym; 12066 12067 /* Need to: get the symbol; get the section. */ 12068 isym = &rcookie->locsyms[r_symndx]; 12069 isec = bfd_section_from_elf_index (rcookie->abfd, isym->st_shndx); 12070 if (isec != NULL && elf_discarded_section (isec)) 12071 return TRUE; 12072 } 12073 return FALSE; 12074 } 12075 return FALSE; 12076 } 12077 12078 /* Discard unneeded references to discarded sections. 12079 Returns TRUE if any section's size was changed. */ 12080 /* This function assumes that the relocations are in sorted order, 12081 which is true for all known assemblers. */ 12082 12083 bfd_boolean 12084 bfd_elf_discard_info (bfd *output_bfd, struct bfd_link_info *info) 12085 { 12086 struct elf_reloc_cookie cookie; 12087 asection *stab, *eh; 12088 const struct elf_backend_data *bed; 12089 bfd *abfd; 12090 bfd_boolean ret = FALSE; 12091 12092 if (info->traditional_format 12093 || !is_elf_hash_table (info->hash)) 12094 return FALSE; 12095 12096 _bfd_elf_begin_eh_frame_parsing (info); 12097 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next) 12098 { 12099 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour) 12100 continue; 12101 12102 bed = get_elf_backend_data (abfd); 12103 12104 if ((abfd->flags & DYNAMIC) != 0) 12105 continue; 12106 12107 eh = NULL; 12108 if (!info->relocatable) 12109 { 12110 eh = bfd_get_section_by_name (abfd, ".eh_frame"); 12111 if (eh != NULL 12112 && (eh->size == 0 12113 || bfd_is_abs_section (eh->output_section))) 12114 eh = NULL; 12115 } 12116 12117 stab = bfd_get_section_by_name (abfd, ".stab"); 12118 if (stab != NULL 12119 && (stab->size == 0 12120 || bfd_is_abs_section (stab->output_section) 12121 || stab->sec_info_type != ELF_INFO_TYPE_STABS)) 12122 stab = NULL; 12123 12124 if (stab == NULL 12125 && eh == NULL 12126 && bed->elf_backend_discard_info == NULL) 12127 continue; 12128 12129 if (!init_reloc_cookie (&cookie, info, abfd)) 12130 return FALSE; 12131 12132 if (stab != NULL 12133 && stab->reloc_count > 0 12134 && init_reloc_cookie_rels (&cookie, info, abfd, stab)) 12135 { 12136 if (_bfd_discard_section_stabs (abfd, stab, 12137 elf_section_data (stab)->sec_info, 12138 bfd_elf_reloc_symbol_deleted_p, 12139 &cookie)) 12140 ret = TRUE; 12141 fini_reloc_cookie_rels (&cookie, stab); 12142 } 12143 12144 if (eh != NULL 12145 && init_reloc_cookie_rels (&cookie, info, abfd, eh)) 12146 { 12147 _bfd_elf_parse_eh_frame (abfd, info, eh, &cookie); 12148 if (_bfd_elf_discard_section_eh_frame (abfd, info, eh, 12149 bfd_elf_reloc_symbol_deleted_p, 12150 &cookie)) 12151 ret = TRUE; 12152 fini_reloc_cookie_rels (&cookie, eh); 12153 } 12154 12155 if (bed->elf_backend_discard_info != NULL 12156 && (*bed->elf_backend_discard_info) (abfd, &cookie, info)) 12157 ret = TRUE; 12158 12159 fini_reloc_cookie (&cookie, abfd); 12160 } 12161 _bfd_elf_end_eh_frame_parsing (info); 12162 12163 if (info->eh_frame_hdr 12164 && !info->relocatable 12165 && _bfd_elf_discard_section_eh_frame_hdr (output_bfd, info)) 12166 ret = TRUE; 12167 12168 return ret; 12169 } 12170 12171 /* For a SHT_GROUP section, return the group signature. For other 12172 sections, return the normal section name. */ 12173 12174 static const char * 12175 section_signature (asection *sec) 12176 { 12177 if ((sec->flags & SEC_GROUP) != 0 12178 && elf_next_in_group (sec) != NULL 12179 && elf_group_name (elf_next_in_group (sec)) != NULL) 12180 return elf_group_name (elf_next_in_group (sec)); 12181 return sec->name; 12182 } 12183 12184 void 12185 _bfd_elf_section_already_linked (bfd *abfd, asection *sec, 12186 struct bfd_link_info *info) 12187 { 12188 flagword flags; 12189 const char *name, *p; 12190 struct bfd_section_already_linked *l; 12191 struct bfd_section_already_linked_hash_entry *already_linked_list; 12192 12193 if (sec->output_section == bfd_abs_section_ptr) 12194 return; 12195 12196 flags = sec->flags; 12197 12198 /* Return if it isn't a linkonce section. A comdat group section 12199 also has SEC_LINK_ONCE set. */ 12200 if ((flags & SEC_LINK_ONCE) == 0) 12201 return; 12202 12203 /* Don't put group member sections on our list of already linked 12204 sections. They are handled as a group via their group section. */ 12205 if (elf_sec_group (sec) != NULL) 12206 return; 12207 12208 /* FIXME: When doing a relocatable link, we may have trouble 12209 copying relocations in other sections that refer to local symbols 12210 in the section being discarded. Those relocations will have to 12211 be converted somehow; as of this writing I'm not sure that any of 12212 the backends handle that correctly. 12213 12214 It is tempting to instead not discard link once sections when 12215 doing a relocatable link (technically, they should be discarded 12216 whenever we are building constructors). However, that fails, 12217 because the linker winds up combining all the link once sections 12218 into a single large link once section, which defeats the purpose 12219 of having link once sections in the first place. 12220 12221 Also, not merging link once sections in a relocatable link 12222 causes trouble for MIPS ELF, which relies on link once semantics 12223 to handle the .reginfo section correctly. */ 12224 12225 name = section_signature (sec); 12226 12227 if (CONST_STRNEQ (name, ".gnu.linkonce.") 12228 && (p = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL) 12229 p++; 12230 else 12231 p = name; 12232 12233 already_linked_list = bfd_section_already_linked_table_lookup (p); 12234 12235 for (l = already_linked_list->entry; l != NULL; l = l->next) 12236 { 12237 /* We may have 2 different types of sections on the list: group 12238 sections and linkonce sections. Match like sections. */ 12239 if ((flags & SEC_GROUP) == (l->sec->flags & SEC_GROUP) 12240 && strcmp (name, section_signature (l->sec)) == 0 12241 && bfd_coff_get_comdat_section (l->sec->owner, l->sec) == NULL) 12242 { 12243 /* The section has already been linked. See if we should 12244 issue a warning. */ 12245 switch (flags & SEC_LINK_DUPLICATES) 12246 { 12247 default: 12248 abort (); 12249 12250 case SEC_LINK_DUPLICATES_DISCARD: 12251 break; 12252 12253 case SEC_LINK_DUPLICATES_ONE_ONLY: 12254 (*_bfd_error_handler) 12255 (_("%B: ignoring duplicate section `%A'"), 12256 abfd, sec); 12257 break; 12258 12259 case SEC_LINK_DUPLICATES_SAME_SIZE: 12260 if (sec->size != l->sec->size) 12261 (*_bfd_error_handler) 12262 (_("%B: duplicate section `%A' has different size"), 12263 abfd, sec); 12264 break; 12265 12266 case SEC_LINK_DUPLICATES_SAME_CONTENTS: 12267 if (sec->size != l->sec->size) 12268 (*_bfd_error_handler) 12269 (_("%B: duplicate section `%A' has different size"), 12270 abfd, sec); 12271 else if (sec->size != 0) 12272 { 12273 bfd_byte *sec_contents, *l_sec_contents; 12274 12275 if (!bfd_malloc_and_get_section (abfd, sec, &sec_contents)) 12276 (*_bfd_error_handler) 12277 (_("%B: warning: could not read contents of section `%A'"), 12278 abfd, sec); 12279 else if (!bfd_malloc_and_get_section (l->sec->owner, l->sec, 12280 &l_sec_contents)) 12281 (*_bfd_error_handler) 12282 (_("%B: warning: could not read contents of section `%A'"), 12283 l->sec->owner, l->sec); 12284 else if (memcmp (sec_contents, l_sec_contents, sec->size) != 0) 12285 (*_bfd_error_handler) 12286 (_("%B: warning: duplicate section `%A' has different contents"), 12287 abfd, sec); 12288 12289 if (sec_contents) 12290 free (sec_contents); 12291 if (l_sec_contents) 12292 free (l_sec_contents); 12293 } 12294 break; 12295 } 12296 12297 /* Set the output_section field so that lang_add_section 12298 does not create a lang_input_section structure for this 12299 section. Since there might be a symbol in the section 12300 being discarded, we must retain a pointer to the section 12301 which we are really going to use. */ 12302 sec->output_section = bfd_abs_section_ptr; 12303 sec->kept_section = l->sec; 12304 12305 if (flags & SEC_GROUP) 12306 { 12307 asection *first = elf_next_in_group (sec); 12308 asection *s = first; 12309 12310 while (s != NULL) 12311 { 12312 s->output_section = bfd_abs_section_ptr; 12313 /* Record which group discards it. */ 12314 s->kept_section = l->sec; 12315 s = elf_next_in_group (s); 12316 /* These lists are circular. */ 12317 if (s == first) 12318 break; 12319 } 12320 } 12321 12322 return; 12323 } 12324 } 12325 12326 /* A single member comdat group section may be discarded by a 12327 linkonce section and vice versa. */ 12328 12329 if ((flags & SEC_GROUP) != 0) 12330 { 12331 asection *first = elf_next_in_group (sec); 12332 12333 if (first != NULL && elf_next_in_group (first) == first) 12334 /* Check this single member group against linkonce sections. */ 12335 for (l = already_linked_list->entry; l != NULL; l = l->next) 12336 if ((l->sec->flags & SEC_GROUP) == 0 12337 && bfd_coff_get_comdat_section (l->sec->owner, l->sec) == NULL 12338 && bfd_elf_match_symbols_in_sections (l->sec, first, info)) 12339 { 12340 first->output_section = bfd_abs_section_ptr; 12341 first->kept_section = l->sec; 12342 sec->output_section = bfd_abs_section_ptr; 12343 break; 12344 } 12345 } 12346 else 12347 /* Check this linkonce section against single member groups. */ 12348 for (l = already_linked_list->entry; l != NULL; l = l->next) 12349 if (l->sec->flags & SEC_GROUP) 12350 { 12351 asection *first = elf_next_in_group (l->sec); 12352 12353 if (first != NULL 12354 && elf_next_in_group (first) == first 12355 && bfd_elf_match_symbols_in_sections (first, sec, info)) 12356 { 12357 sec->output_section = bfd_abs_section_ptr; 12358 sec->kept_section = first; 12359 break; 12360 } 12361 } 12362 12363 /* Do not complain on unresolved relocations in `.gnu.linkonce.r.F' 12364 referencing its discarded `.gnu.linkonce.t.F' counterpart - g++-3.4 12365 specific as g++-4.x is using COMDAT groups (without the `.gnu.linkonce' 12366 prefix) instead. `.gnu.linkonce.r.*' were the `.rodata' part of its 12367 matching `.gnu.linkonce.t.*'. If `.gnu.linkonce.r.F' is not discarded 12368 but its `.gnu.linkonce.t.F' is discarded means we chose one-only 12369 `.gnu.linkonce.t.F' section from a different bfd not requiring any 12370 `.gnu.linkonce.r.F'. Thus `.gnu.linkonce.r.F' should be discarded. 12371 The reverse order cannot happen as there is never a bfd with only the 12372 `.gnu.linkonce.r.F' section. The order of sections in a bfd does not 12373 matter as here were are looking only for cross-bfd sections. */ 12374 12375 if ((flags & SEC_GROUP) == 0 && CONST_STRNEQ (name, ".gnu.linkonce.r.")) 12376 for (l = already_linked_list->entry; l != NULL; l = l->next) 12377 if ((l->sec->flags & SEC_GROUP) == 0 12378 && CONST_STRNEQ (l->sec->name, ".gnu.linkonce.t.")) 12379 { 12380 if (abfd != l->sec->owner) 12381 sec->output_section = bfd_abs_section_ptr; 12382 break; 12383 } 12384 12385 /* This is the first section with this name. Record it. */ 12386 if (! bfd_section_already_linked_table_insert (already_linked_list, sec)) 12387 info->callbacks->einfo (_("%F%P: already_linked_table: %E\n")); 12388 } 12389 12390 bfd_boolean 12391 _bfd_elf_common_definition (Elf_Internal_Sym *sym) 12392 { 12393 return sym->st_shndx == SHN_COMMON; 12394 } 12395 12396 unsigned int 12397 _bfd_elf_common_section_index (asection *sec ATTRIBUTE_UNUSED) 12398 { 12399 return SHN_COMMON; 12400 } 12401 12402 asection * 12403 _bfd_elf_common_section (asection *sec ATTRIBUTE_UNUSED) 12404 { 12405 return bfd_com_section_ptr; 12406 } 12407 12408 bfd_vma 12409 _bfd_elf_default_got_elt_size (bfd *abfd, 12410 struct bfd_link_info *info ATTRIBUTE_UNUSED, 12411 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED, 12412 bfd *ibfd ATTRIBUTE_UNUSED, 12413 unsigned long symndx ATTRIBUTE_UNUSED) 12414 { 12415 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 12416 return bed->s->arch_size / 8; 12417 } 12418 12419 /* Routines to support the creation of dynamic relocs. */ 12420 12421 /* Return true if NAME is a name of a relocation 12422 section associated with section S. */ 12423 12424 static bfd_boolean 12425 is_reloc_section (bfd_boolean rela, const char * name, asection * s) 12426 { 12427 if (rela) 12428 return CONST_STRNEQ (name, ".rela") 12429 && strcmp (bfd_get_section_name (NULL, s), name + 5) == 0; 12430 12431 return CONST_STRNEQ (name, ".rel") 12432 && strcmp (bfd_get_section_name (NULL, s), name + 4) == 0; 12433 } 12434 12435 /* Returns the name of the dynamic reloc section associated with SEC. */ 12436 12437 static const char * 12438 get_dynamic_reloc_section_name (bfd * abfd, 12439 asection * sec, 12440 bfd_boolean is_rela) 12441 { 12442 const char * name; 12443 unsigned int strndx = elf_elfheader (abfd)->e_shstrndx; 12444 unsigned int shnam = elf_section_data (sec)->rel_hdr.sh_name; 12445 12446 name = bfd_elf_string_from_elf_section (abfd, strndx, shnam); 12447 if (name == NULL) 12448 return NULL; 12449 12450 if (! is_reloc_section (is_rela, name, sec)) 12451 { 12452 static bfd_boolean complained = FALSE; 12453 12454 if (! complained) 12455 { 12456 (*_bfd_error_handler) 12457 (_("%B: bad relocation section name `%s\'"), abfd, name); 12458 complained = TRUE; 12459 } 12460 name = NULL; 12461 } 12462 12463 return name; 12464 } 12465 12466 /* Returns the dynamic reloc section associated with SEC. 12467 If necessary compute the name of the dynamic reloc section based 12468 on SEC's name (looked up in ABFD's string table) and the setting 12469 of IS_RELA. */ 12470 12471 asection * 12472 _bfd_elf_get_dynamic_reloc_section (bfd * abfd, 12473 asection * sec, 12474 bfd_boolean is_rela) 12475 { 12476 asection * reloc_sec = elf_section_data (sec)->sreloc; 12477 12478 if (reloc_sec == NULL) 12479 { 12480 const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela); 12481 12482 if (name != NULL) 12483 { 12484 reloc_sec = bfd_get_section_by_name (abfd, name); 12485 12486 if (reloc_sec != NULL) 12487 elf_section_data (sec)->sreloc = reloc_sec; 12488 } 12489 } 12490 12491 return reloc_sec; 12492 } 12493 12494 /* Returns the dynamic reloc section associated with SEC. If the 12495 section does not exist it is created and attached to the DYNOBJ 12496 bfd and stored in the SRELOC field of SEC's elf_section_data 12497 structure. 12498 12499 ALIGNMENT is the alignment for the newly created section and 12500 IS_RELA defines whether the name should be .rela.<SEC's name> 12501 or .rel.<SEC's name>. The section name is looked up in the 12502 string table associated with ABFD. */ 12503 12504 asection * 12505 _bfd_elf_make_dynamic_reloc_section (asection * sec, 12506 bfd * dynobj, 12507 unsigned int alignment, 12508 bfd * abfd, 12509 bfd_boolean is_rela) 12510 { 12511 asection * reloc_sec = elf_section_data (sec)->sreloc; 12512 12513 if (reloc_sec == NULL) 12514 { 12515 const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela); 12516 12517 if (name == NULL) 12518 return NULL; 12519 12520 reloc_sec = bfd_get_section_by_name (dynobj, name); 12521 12522 if (reloc_sec == NULL) 12523 { 12524 flagword flags; 12525 12526 flags = (SEC_HAS_CONTENTS | SEC_READONLY | SEC_IN_MEMORY | SEC_LINKER_CREATED); 12527 if ((sec->flags & SEC_ALLOC) != 0) 12528 flags |= SEC_ALLOC | SEC_LOAD; 12529 12530 reloc_sec = bfd_make_section_with_flags (dynobj, name, flags); 12531 if (reloc_sec != NULL) 12532 { 12533 if (! bfd_set_section_alignment (dynobj, reloc_sec, alignment)) 12534 reloc_sec = NULL; 12535 } 12536 } 12537 12538 elf_section_data (sec)->sreloc = reloc_sec; 12539 } 12540 12541 return reloc_sec; 12542 } 12543