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