1/* ELF linking support for BFD. 2 Copyright (C) 1995-2020 Free Software Foundation, Inc. 3 4 This file is part of BFD, the Binary File Descriptor library. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 19 MA 02110-1301, USA. */ 20 21#include "sysdep.h" 22#include "bfd.h" 23#include "bfdlink.h" 24#include "libbfd.h" 25#define ARCH_SIZE 0 26#include "elf-bfd.h" 27#include "safe-ctype.h" 28#include "libiberty.h" 29#include "objalloc.h" 30#if BFD_SUPPORTS_PLUGINS 31#include "plugin-api.h" 32#include "plugin.h" 33#endif 34 35#ifdef HAVE_LIMITS_H 36#include <limits.h> 37#endif 38#ifndef CHAR_BIT 39#define CHAR_BIT 8 40#endif 41 42/* This struct is used to pass information to routines called via 43 elf_link_hash_traverse which must return failure. */ 44 45struct elf_info_failed 46{ 47 struct bfd_link_info *info; 48 bfd_boolean failed; 49}; 50 51/* This structure is used to pass information to 52 _bfd_elf_link_find_version_dependencies. */ 53 54struct elf_find_verdep_info 55{ 56 /* General link information. */ 57 struct bfd_link_info *info; 58 /* The number of dependencies. */ 59 unsigned int vers; 60 /* Whether we had a failure. */ 61 bfd_boolean failed; 62}; 63 64static bfd_boolean _bfd_elf_fix_symbol_flags 65 (struct elf_link_hash_entry *, struct elf_info_failed *); 66 67asection * 68_bfd_elf_section_for_symbol (struct elf_reloc_cookie *cookie, 69 unsigned long r_symndx, 70 bfd_boolean discard) 71{ 72 if (r_symndx >= cookie->locsymcount 73 || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL) 74 { 75 struct elf_link_hash_entry *h; 76 77 h = cookie->sym_hashes[r_symndx - cookie->extsymoff]; 78 79 while (h->root.type == bfd_link_hash_indirect 80 || h->root.type == bfd_link_hash_warning) 81 h = (struct elf_link_hash_entry *) h->root.u.i.link; 82 83 if ((h->root.type == bfd_link_hash_defined 84 || h->root.type == bfd_link_hash_defweak) 85 && discarded_section (h->root.u.def.section)) 86 return h->root.u.def.section; 87 else 88 return NULL; 89 } 90 else 91 { 92 /* It's not a relocation against a global symbol, 93 but it could be a relocation against a local 94 symbol for a discarded section. */ 95 asection *isec; 96 Elf_Internal_Sym *isym; 97 98 /* Need to: get the symbol; get the section. */ 99 isym = &cookie->locsyms[r_symndx]; 100 isec = bfd_section_from_elf_index (cookie->abfd, isym->st_shndx); 101 if (isec != NULL 102 && discard ? discarded_section (isec) : 1) 103 return isec; 104 } 105 return NULL; 106} 107 108/* Define a symbol in a dynamic linkage section. */ 109 110struct elf_link_hash_entry * 111_bfd_elf_define_linkage_sym (bfd *abfd, 112 struct bfd_link_info *info, 113 asection *sec, 114 const char *name) 115{ 116 struct elf_link_hash_entry *h; 117 struct bfd_link_hash_entry *bh; 118 const struct elf_backend_data *bed; 119 120 h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE); 121 if (h != NULL) 122 { 123 /* Zap symbol defined in an as-needed lib that wasn't linked. 124 This is a symptom of a larger problem: Absolute symbols 125 defined in shared libraries can't be overridden, because we 126 lose the link to the bfd which is via the symbol section. */ 127 h->root.type = bfd_link_hash_new; 128 bh = &h->root; 129 } 130 else 131 bh = NULL; 132 133 bed = get_elf_backend_data (abfd); 134 if (!_bfd_generic_link_add_one_symbol (info, abfd, name, BSF_GLOBAL, 135 sec, 0, NULL, FALSE, bed->collect, 136 &bh)) 137 return NULL; 138 h = (struct elf_link_hash_entry *) bh; 139 BFD_ASSERT (h != NULL); 140 h->def_regular = 1; 141 h->non_elf = 0; 142 h->root.linker_def = 1; 143 h->type = STT_OBJECT; 144 if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL) 145 h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN; 146 147 (*bed->elf_backend_hide_symbol) (info, h, TRUE); 148 return h; 149} 150 151bfd_boolean 152_bfd_elf_create_got_section (bfd *abfd, struct bfd_link_info *info) 153{ 154 flagword flags; 155 asection *s; 156 struct elf_link_hash_entry *h; 157 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 158 struct elf_link_hash_table *htab = elf_hash_table (info); 159 160 /* This function may be called more than once. */ 161 if (htab->sgot != NULL) 162 return TRUE; 163 164 flags = bed->dynamic_sec_flags; 165 166 s = bfd_make_section_anyway_with_flags (abfd, 167 (bed->rela_plts_and_copies_p 168 ? ".rela.got" : ".rel.got"), 169 (bed->dynamic_sec_flags 170 | SEC_READONLY)); 171 if (s == NULL 172 || !bfd_set_section_alignment (s, bed->s->log_file_align)) 173 return FALSE; 174 htab->srelgot = s; 175 176 s = bfd_make_section_anyway_with_flags (abfd, ".got", flags); 177 if (s == NULL 178 || !bfd_set_section_alignment (s, bed->s->log_file_align)) 179 return FALSE; 180 htab->sgot = s; 181 182 if (bed->want_got_plt) 183 { 184 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags); 185 if (s == NULL 186 || !bfd_set_section_alignment (s, bed->s->log_file_align)) 187 return FALSE; 188 htab->sgotplt = s; 189 } 190 191 /* The first bit of the global offset table is the header. */ 192 s->size += bed->got_header_size; 193 194 if (bed->want_got_sym) 195 { 196 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got 197 (or .got.plt) section. We don't do this in the linker script 198 because we don't want to define the symbol if we are not creating 199 a global offset table. */ 200 h = _bfd_elf_define_linkage_sym (abfd, info, s, 201 "_GLOBAL_OFFSET_TABLE_"); 202 elf_hash_table (info)->hgot = h; 203 if (h == NULL) 204 return FALSE; 205 } 206 207 return TRUE; 208} 209 210/* Create a strtab to hold the dynamic symbol names. */ 211static bfd_boolean 212_bfd_elf_link_create_dynstrtab (bfd *abfd, struct bfd_link_info *info) 213{ 214 struct elf_link_hash_table *hash_table; 215 216 hash_table = elf_hash_table (info); 217 if (hash_table->dynobj == NULL) 218 { 219 /* We may not set dynobj, an input file holding linker created 220 dynamic sections to abfd, which may be a dynamic object with 221 its own dynamic sections. We need to find a normal input file 222 to hold linker created sections if possible. */ 223 if ((abfd->flags & (DYNAMIC | BFD_PLUGIN)) != 0) 224 { 225 bfd *ibfd; 226 asection *s; 227 for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next) 228 if ((ibfd->flags 229 & (DYNAMIC | BFD_LINKER_CREATED | BFD_PLUGIN)) == 0 230 && bfd_get_flavour (ibfd) == bfd_target_elf_flavour 231 && elf_object_id (ibfd) == elf_hash_table_id (hash_table) 232 && !((s = ibfd->sections) != NULL 233 && s->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)) 234 { 235 abfd = ibfd; 236 break; 237 } 238 } 239 hash_table->dynobj = abfd; 240 } 241 242 if (hash_table->dynstr == NULL) 243 { 244 hash_table->dynstr = _bfd_elf_strtab_init (); 245 if (hash_table->dynstr == NULL) 246 return FALSE; 247 } 248 return TRUE; 249} 250 251/* Create some sections which will be filled in with dynamic linking 252 information. ABFD is an input file which requires dynamic sections 253 to be created. The dynamic sections take up virtual memory space 254 when the final executable is run, so we need to create them before 255 addresses are assigned to the output sections. We work out the 256 actual contents and size of these sections later. */ 257 258bfd_boolean 259_bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) 260{ 261 flagword flags; 262 asection *s; 263 const struct elf_backend_data *bed; 264 struct elf_link_hash_entry *h; 265 266 if (! is_elf_hash_table (info->hash)) 267 return FALSE; 268 269 if (elf_hash_table (info)->dynamic_sections_created) 270 return TRUE; 271 272 if (!_bfd_elf_link_create_dynstrtab (abfd, info)) 273 return FALSE; 274 275 abfd = elf_hash_table (info)->dynobj; 276 bed = get_elf_backend_data (abfd); 277 278 flags = bed->dynamic_sec_flags; 279 280 /* A dynamically linked executable has a .interp section, but a 281 shared library does not. */ 282 if (bfd_link_executable (info) && !info->nointerp) 283 { 284 s = bfd_make_section_anyway_with_flags (abfd, ".interp", 285 flags | SEC_READONLY); 286 if (s == NULL) 287 return FALSE; 288 } 289 290 /* Create sections to hold version informations. These are removed 291 if they are not needed. */ 292 s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version_d", 293 flags | SEC_READONLY); 294 if (s == NULL 295 || !bfd_set_section_alignment (s, bed->s->log_file_align)) 296 return FALSE; 297 298 s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version", 299 flags | SEC_READONLY); 300 if (s == NULL 301 || !bfd_set_section_alignment (s, 1)) 302 return FALSE; 303 304 s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version_r", 305 flags | SEC_READONLY); 306 if (s == NULL 307 || !bfd_set_section_alignment (s, bed->s->log_file_align)) 308 return FALSE; 309 310 s = bfd_make_section_anyway_with_flags (abfd, ".dynsym", 311 flags | SEC_READONLY); 312 if (s == NULL 313 || !bfd_set_section_alignment (s, bed->s->log_file_align)) 314 return FALSE; 315 elf_hash_table (info)->dynsym = s; 316 317 s = bfd_make_section_anyway_with_flags (abfd, ".dynstr", 318 flags | SEC_READONLY); 319 if (s == NULL) 320 return FALSE; 321 322 s = bfd_make_section_anyway_with_flags (abfd, ".dynamic", flags); 323 if (s == NULL 324 || !bfd_set_section_alignment (s, bed->s->log_file_align)) 325 return FALSE; 326 327 /* The special symbol _DYNAMIC is always set to the start of the 328 .dynamic section. We could set _DYNAMIC in a linker script, but we 329 only want to define it if we are, in fact, creating a .dynamic 330 section. We don't want to define it if there is no .dynamic 331 section, since on some ELF platforms the start up code examines it 332 to decide how to initialize the process. */ 333 h = _bfd_elf_define_linkage_sym (abfd, info, s, "_DYNAMIC"); 334 elf_hash_table (info)->hdynamic = h; 335 if (h == NULL) 336 return FALSE; 337 338 if (info->emit_hash) 339 { 340 s = bfd_make_section_anyway_with_flags (abfd, ".hash", 341 flags | SEC_READONLY); 342 if (s == NULL 343 || !bfd_set_section_alignment (s, bed->s->log_file_align)) 344 return FALSE; 345 elf_section_data (s)->this_hdr.sh_entsize = bed->s->sizeof_hash_entry; 346 } 347 348 if (info->emit_gnu_hash && bed->record_xhash_symbol == NULL) 349 { 350 s = bfd_make_section_anyway_with_flags (abfd, ".gnu.hash", 351 flags | SEC_READONLY); 352 if (s == NULL 353 || !bfd_set_section_alignment (s, bed->s->log_file_align)) 354 return FALSE; 355 /* For 64-bit ELF, .gnu.hash is a non-uniform entity size section: 356 4 32-bit words followed by variable count of 64-bit words, then 357 variable count of 32-bit words. */ 358 if (bed->s->arch_size == 64) 359 elf_section_data (s)->this_hdr.sh_entsize = 0; 360 else 361 elf_section_data (s)->this_hdr.sh_entsize = 4; 362 } 363 364 /* Let the backend create the rest of the sections. This lets the 365 backend set the right flags. The backend will normally create 366 the .got and .plt sections. */ 367 if (bed->elf_backend_create_dynamic_sections == NULL 368 || ! (*bed->elf_backend_create_dynamic_sections) (abfd, info)) 369 return FALSE; 370 371 elf_hash_table (info)->dynamic_sections_created = TRUE; 372 373 return TRUE; 374} 375 376/* Create dynamic sections when linking against a dynamic object. */ 377 378bfd_boolean 379_bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) 380{ 381 flagword flags, pltflags; 382 struct elf_link_hash_entry *h; 383 asection *s; 384 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 385 struct elf_link_hash_table *htab = elf_hash_table (info); 386 387 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and 388 .rel[a].bss sections. */ 389 flags = bed->dynamic_sec_flags; 390 391 pltflags = flags; 392 if (bed->plt_not_loaded) 393 /* We do not clear SEC_ALLOC here because we still want the OS to 394 allocate space for the section; it's just that there's nothing 395 to read in from the object file. */ 396 pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS); 397 else 398 pltflags |= SEC_ALLOC | SEC_CODE | SEC_LOAD; 399 if (bed->plt_readonly) 400 pltflags |= SEC_READONLY; 401 402 s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags); 403 if (s == NULL 404 || !bfd_set_section_alignment (s, bed->plt_alignment)) 405 return FALSE; 406 htab->splt = s; 407 408 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the 409 .plt section. */ 410 if (bed->want_plt_sym) 411 { 412 h = _bfd_elf_define_linkage_sym (abfd, info, s, 413 "_PROCEDURE_LINKAGE_TABLE_"); 414 elf_hash_table (info)->hplt = h; 415 if (h == NULL) 416 return FALSE; 417 } 418 419 s = bfd_make_section_anyway_with_flags (abfd, 420 (bed->rela_plts_and_copies_p 421 ? ".rela.plt" : ".rel.plt"), 422 flags | SEC_READONLY); 423 if (s == NULL 424 || !bfd_set_section_alignment (s, bed->s->log_file_align)) 425 return FALSE; 426 htab->srelplt = s; 427 428 if (! _bfd_elf_create_got_section (abfd, info)) 429 return FALSE; 430 431 if (bed->want_dynbss) 432 { 433 /* The .dynbss section is a place to put symbols which are defined 434 by dynamic objects, are referenced by regular objects, and are 435 not functions. We must allocate space for them in the process 436 image and use a R_*_COPY reloc to tell the dynamic linker to 437 initialize them at run time. The linker script puts the .dynbss 438 section into the .bss section of the final image. */ 439 s = bfd_make_section_anyway_with_flags (abfd, ".dynbss", 440 SEC_ALLOC | SEC_LINKER_CREATED); 441 if (s == NULL) 442 return FALSE; 443 htab->sdynbss = s; 444 445 if (bed->want_dynrelro) 446 { 447 /* Similarly, but for symbols that were originally in read-only 448 sections. This section doesn't really need to have contents, 449 but make it like other .data.rel.ro sections. */ 450 s = bfd_make_section_anyway_with_flags (abfd, ".data.rel.ro", 451 flags); 452 if (s == NULL) 453 return FALSE; 454 htab->sdynrelro = s; 455 } 456 457 /* The .rel[a].bss section holds copy relocs. This section is not 458 normally needed. We need to create it here, though, so that the 459 linker will map it to an output section. We can't just create it 460 only if we need it, because we will not know whether we need it 461 until we have seen all the input files, and the first time the 462 main linker code calls BFD after examining all the input files 463 (size_dynamic_sections) the input sections have already been 464 mapped to the output sections. If the section turns out not to 465 be needed, we can discard it later. We will never need this 466 section when generating a shared object, since they do not use 467 copy relocs. */ 468 if (bfd_link_executable (info)) 469 { 470 s = bfd_make_section_anyway_with_flags (abfd, 471 (bed->rela_plts_and_copies_p 472 ? ".rela.bss" : ".rel.bss"), 473 flags | SEC_READONLY); 474 if (s == NULL 475 || !bfd_set_section_alignment (s, bed->s->log_file_align)) 476 return FALSE; 477 htab->srelbss = s; 478 479 if (bed->want_dynrelro) 480 { 481 s = (bfd_make_section_anyway_with_flags 482 (abfd, (bed->rela_plts_and_copies_p 483 ? ".rela.data.rel.ro" : ".rel.data.rel.ro"), 484 flags | SEC_READONLY)); 485 if (s == NULL 486 || !bfd_set_section_alignment (s, bed->s->log_file_align)) 487 return FALSE; 488 htab->sreldynrelro = s; 489 } 490 } 491 } 492 493 return TRUE; 494} 495 496/* Record a new dynamic symbol. We record the dynamic symbols as we 497 read the input files, since we need to have a list of all of them 498 before we can determine the final sizes of the output sections. 499 Note that we may actually call this function even though we are not 500 going to output any dynamic symbols; in some cases we know that a 501 symbol should be in the dynamic symbol table, but only if there is 502 one. */ 503 504bfd_boolean 505bfd_elf_link_record_dynamic_symbol (struct bfd_link_info *info, 506 struct elf_link_hash_entry *h) 507{ 508 if (h->dynindx == -1) 509 { 510 struct elf_strtab_hash *dynstr; 511 char *p; 512 const char *name; 513 size_t indx; 514 515 if (h->root.type == bfd_link_hash_defined 516 || h->root.type == bfd_link_hash_defweak) 517 { 518 /* An IR symbol should not be made dynamic. */ 519 if (h->root.u.def.section != NULL 520 && h->root.u.def.section->owner != NULL 521 && (h->root.u.def.section->owner->flags & BFD_PLUGIN) != 0) 522 return TRUE; 523 } 524 525 /* XXX: The ABI draft says the linker must turn hidden and 526 internal symbols into STB_LOCAL symbols when producing the 527 DSO. However, if ld.so honors st_other in the dynamic table, 528 this would not be necessary. */ 529 switch (ELF_ST_VISIBILITY (h->other)) 530 { 531 case STV_INTERNAL: 532 case STV_HIDDEN: 533 if (h->root.type != bfd_link_hash_undefined 534 && h->root.type != bfd_link_hash_undefweak) 535 { 536 h->forced_local = 1; 537 if (!elf_hash_table (info)->is_relocatable_executable) 538 return TRUE; 539 } 540 541 default: 542 break; 543 } 544 545 h->dynindx = elf_hash_table (info)->dynsymcount; 546 ++elf_hash_table (info)->dynsymcount; 547 548 dynstr = elf_hash_table (info)->dynstr; 549 if (dynstr == NULL) 550 { 551 /* Create a strtab to hold the dynamic symbol names. */ 552 elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init (); 553 if (dynstr == NULL) 554 return FALSE; 555 } 556 557 /* We don't put any version information in the dynamic string 558 table. */ 559 name = h->root.root.string; 560 p = strchr (name, ELF_VER_CHR); 561 if (p != NULL) 562 /* We know that the p points into writable memory. In fact, 563 there are only a few symbols that have read-only names, being 564 those like _GLOBAL_OFFSET_TABLE_ that are created specially 565 by the backends. Most symbols will have names pointing into 566 an ELF string table read from a file, or to objalloc memory. */ 567 *p = 0; 568 569 indx = _bfd_elf_strtab_add (dynstr, name, p != NULL); 570 571 if (p != NULL) 572 *p = ELF_VER_CHR; 573 574 if (indx == (size_t) -1) 575 return FALSE; 576 h->dynstr_index = indx; 577 } 578 579 return TRUE; 580} 581 582/* Mark a symbol dynamic. */ 583 584static void 585bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info *info, 586 struct elf_link_hash_entry *h, 587 Elf_Internal_Sym *sym) 588{ 589 struct bfd_elf_dynamic_list *d = info->dynamic_list; 590 591 /* It may be called more than once on the same H. */ 592 if(h->dynamic || bfd_link_relocatable (info)) 593 return; 594 595 if ((info->dynamic_data 596 && (h->type == STT_OBJECT 597 || h->type == STT_COMMON 598 || (sym != NULL 599 && (ELF_ST_TYPE (sym->st_info) == STT_OBJECT 600 || ELF_ST_TYPE (sym->st_info) == STT_COMMON)))) 601 || (d != NULL 602 && h->non_elf 603 && (*d->match) (&d->head, NULL, h->root.root.string))) 604 { 605 h->dynamic = 1; 606 /* NB: If a symbol is made dynamic by --dynamic-list, it has 607 non-IR reference. */ 608 h->root.non_ir_ref_dynamic = 1; 609 } 610} 611 612/* Record an assignment to a symbol made by a linker script. We need 613 this in case some dynamic object refers to this symbol. */ 614 615bfd_boolean 616bfd_elf_record_link_assignment (bfd *output_bfd, 617 struct bfd_link_info *info, 618 const char *name, 619 bfd_boolean provide, 620 bfd_boolean hidden) 621{ 622 struct elf_link_hash_entry *h, *hv; 623 struct elf_link_hash_table *htab; 624 const struct elf_backend_data *bed; 625 626 if (!is_elf_hash_table (info->hash)) 627 return TRUE; 628 629 htab = elf_hash_table (info); 630 h = elf_link_hash_lookup (htab, name, !provide, TRUE, FALSE); 631 if (h == NULL) 632 return provide; 633 634 if (h->root.type == bfd_link_hash_warning) 635 h = (struct elf_link_hash_entry *) h->root.u.i.link; 636 637 if (h->versioned == unknown) 638 { 639 /* Set versioned if symbol version is unknown. */ 640 char *version = strrchr (name, ELF_VER_CHR); 641 if (version) 642 { 643 if (version > name && version[-1] != ELF_VER_CHR) 644 h->versioned = versioned_hidden; 645 else 646 h->versioned = versioned; 647 } 648 } 649 650 /* Symbols defined in a linker script but not referenced anywhere 651 else will have non_elf set. */ 652 if (h->non_elf) 653 { 654 bfd_elf_link_mark_dynamic_symbol (info, h, NULL); 655 h->non_elf = 0; 656 } 657 658 switch (h->root.type) 659 { 660 case bfd_link_hash_defined: 661 case bfd_link_hash_defweak: 662 case bfd_link_hash_common: 663 break; 664 case bfd_link_hash_undefweak: 665 case bfd_link_hash_undefined: 666 /* Since we're defining the symbol, don't let it seem to have not 667 been defined. record_dynamic_symbol and size_dynamic_sections 668 may depend on this. */ 669 h->root.type = bfd_link_hash_new; 670 if (h->root.u.undef.next != NULL || htab->root.undefs_tail == &h->root) 671 bfd_link_repair_undef_list (&htab->root); 672 break; 673 case bfd_link_hash_new: 674 break; 675 case bfd_link_hash_indirect: 676 /* We had a versioned symbol in a dynamic library. We make the 677 the versioned symbol point to this one. */ 678 bed = get_elf_backend_data (output_bfd); 679 hv = h; 680 while (hv->root.type == bfd_link_hash_indirect 681 || hv->root.type == bfd_link_hash_warning) 682 hv = (struct elf_link_hash_entry *) hv->root.u.i.link; 683 /* We don't need to update h->root.u since linker will set them 684 later. */ 685 h->root.type = bfd_link_hash_undefined; 686 hv->root.type = bfd_link_hash_indirect; 687 hv->root.u.i.link = (struct bfd_link_hash_entry *) h; 688 (*bed->elf_backend_copy_indirect_symbol) (info, h, hv); 689 break; 690 default: 691 BFD_FAIL (); 692 return FALSE; 693 } 694 695 /* If this symbol is being provided by the linker script, and it is 696 currently defined by a dynamic object, but not by a regular 697 object, then mark it as undefined so that the generic linker will 698 force the correct value. */ 699 if (provide 700 && h->def_dynamic 701 && !h->def_regular) 702 h->root.type = bfd_link_hash_undefined; 703 704 /* If this symbol is currently defined by a dynamic object, but not 705 by a regular object, then clear out any version information because 706 the symbol will not be associated with the dynamic object any 707 more. */ 708 if (h->def_dynamic && !h->def_regular) 709 h->verinfo.verdef = NULL; 710 711 /* Make sure this symbol is not garbage collected. */ 712 h->mark = 1; 713 714 h->def_regular = 1; 715 716 if (hidden) 717 { 718 bed = get_elf_backend_data (output_bfd); 719 if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL) 720 h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN; 721 (*bed->elf_backend_hide_symbol) (info, h, TRUE); 722 } 723 724 /* STV_HIDDEN and STV_INTERNAL symbols must be STB_LOCAL in shared objects 725 and executables. */ 726 if (!bfd_link_relocatable (info) 727 && h->dynindx != -1 728 && (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN 729 || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)) 730 h->forced_local = 1; 731 732 if ((h->def_dynamic 733 || h->ref_dynamic 734 || bfd_link_dll (info) 735 || elf_hash_table (info)->is_relocatable_executable) 736 && !h->forced_local 737 && h->dynindx == -1) 738 { 739 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 740 return FALSE; 741 742 /* If this is a weak defined symbol, and we know a corresponding 743 real symbol from the same dynamic object, make sure the real 744 symbol is also made into a dynamic symbol. */ 745 if (h->is_weakalias) 746 { 747 struct elf_link_hash_entry *def = weakdef (h); 748 749 if (def->dynindx == -1 750 && !bfd_elf_link_record_dynamic_symbol (info, def)) 751 return FALSE; 752 } 753 } 754 755 return TRUE; 756} 757 758/* Record a new local dynamic symbol. Returns 0 on failure, 1 on 759 success, and 2 on a failure caused by attempting to record a symbol 760 in a discarded section, eg. a discarded link-once section symbol. */ 761 762int 763bfd_elf_link_record_local_dynamic_symbol (struct bfd_link_info *info, 764 bfd *input_bfd, 765 long input_indx) 766{ 767 size_t amt; 768 struct elf_link_local_dynamic_entry *entry; 769 struct elf_link_hash_table *eht; 770 struct elf_strtab_hash *dynstr; 771 size_t dynstr_index; 772 char *name; 773 Elf_External_Sym_Shndx eshndx; 774 char esym[sizeof (Elf64_External_Sym)]; 775 776 if (! is_elf_hash_table (info->hash)) 777 return 0; 778 779 /* See if the entry exists already. */ 780 for (entry = elf_hash_table (info)->dynlocal; entry ; entry = entry->next) 781 if (entry->input_bfd == input_bfd && entry->input_indx == input_indx) 782 return 1; 783 784 amt = sizeof (*entry); 785 entry = (struct elf_link_local_dynamic_entry *) bfd_alloc (input_bfd, amt); 786 if (entry == NULL) 787 return 0; 788 789 /* Go find the symbol, so that we can find it's name. */ 790 if (!bfd_elf_get_elf_syms (input_bfd, &elf_tdata (input_bfd)->symtab_hdr, 791 1, input_indx, &entry->isym, esym, &eshndx)) 792 { 793 bfd_release (input_bfd, entry); 794 return 0; 795 } 796 797 if (entry->isym.st_shndx != SHN_UNDEF 798 && entry->isym.st_shndx < SHN_LORESERVE) 799 { 800 asection *s; 801 802 s = bfd_section_from_elf_index (input_bfd, entry->isym.st_shndx); 803 if (s == NULL || bfd_is_abs_section (s->output_section)) 804 { 805 /* We can still bfd_release here as nothing has done another 806 bfd_alloc. We can't do this later in this function. */ 807 bfd_release (input_bfd, entry); 808 return 2; 809 } 810 } 811 812 name = (bfd_elf_string_from_elf_section 813 (input_bfd, elf_tdata (input_bfd)->symtab_hdr.sh_link, 814 entry->isym.st_name)); 815 816 dynstr = elf_hash_table (info)->dynstr; 817 if (dynstr == NULL) 818 { 819 /* Create a strtab to hold the dynamic symbol names. */ 820 elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init (); 821 if (dynstr == NULL) 822 return 0; 823 } 824 825 dynstr_index = _bfd_elf_strtab_add (dynstr, name, FALSE); 826 if (dynstr_index == (size_t) -1) 827 return 0; 828 entry->isym.st_name = dynstr_index; 829 830 eht = elf_hash_table (info); 831 832 entry->next = eht->dynlocal; 833 eht->dynlocal = entry; 834 entry->input_bfd = input_bfd; 835 entry->input_indx = input_indx; 836 eht->dynsymcount++; 837 838 /* Whatever binding the symbol had before, it's now local. */ 839 entry->isym.st_info 840 = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (entry->isym.st_info)); 841 842 /* The dynindx will be set at the end of size_dynamic_sections. */ 843 844 return 1; 845} 846 847/* Return the dynindex of a local dynamic symbol. */ 848 849long 850_bfd_elf_link_lookup_local_dynindx (struct bfd_link_info *info, 851 bfd *input_bfd, 852 long input_indx) 853{ 854 struct elf_link_local_dynamic_entry *e; 855 856 for (e = elf_hash_table (info)->dynlocal; e ; e = e->next) 857 if (e->input_bfd == input_bfd && e->input_indx == input_indx) 858 return e->dynindx; 859 return -1; 860} 861 862/* This function is used to renumber the dynamic symbols, if some of 863 them are removed because they are marked as local. This is called 864 via elf_link_hash_traverse. */ 865 866static bfd_boolean 867elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry *h, 868 void *data) 869{ 870 size_t *count = (size_t *) data; 871 872 if (h->forced_local) 873 return TRUE; 874 875 if (h->dynindx != -1) 876 h->dynindx = ++(*count); 877 878 return TRUE; 879} 880 881 882/* Like elf_link_renumber_hash_table_dynsyms, but just number symbols with 883 STB_LOCAL binding. */ 884 885static bfd_boolean 886elf_link_renumber_local_hash_table_dynsyms (struct elf_link_hash_entry *h, 887 void *data) 888{ 889 size_t *count = (size_t *) data; 890 891 if (!h->forced_local) 892 return TRUE; 893 894 if (h->dynindx != -1) 895 h->dynindx = ++(*count); 896 897 return TRUE; 898} 899 900/* Return true if the dynamic symbol for a given section should be 901 omitted when creating a shared library. */ 902bfd_boolean 903_bfd_elf_omit_section_dynsym_default (bfd *output_bfd ATTRIBUTE_UNUSED, 904 struct bfd_link_info *info, 905 asection *p) 906{ 907 struct elf_link_hash_table *htab; 908 asection *ip; 909 910 switch (elf_section_data (p)->this_hdr.sh_type) 911 { 912 case SHT_PROGBITS: 913 case SHT_NOBITS: 914 /* If sh_type is yet undecided, assume it could be 915 SHT_PROGBITS/SHT_NOBITS. */ 916 case SHT_NULL: 917 htab = elf_hash_table (info); 918 if (htab->text_index_section != NULL) 919 return p != htab->text_index_section && p != htab->data_index_section; 920 921 return (htab->dynobj != NULL 922 && (ip = bfd_get_linker_section (htab->dynobj, p->name)) != NULL 923 && ip->output_section == p); 924 925 /* There shouldn't be section relative relocations 926 against any other section. */ 927 default: 928 return TRUE; 929 } 930} 931 932bfd_boolean 933_bfd_elf_omit_section_dynsym_all 934 (bfd *output_bfd ATTRIBUTE_UNUSED, 935 struct bfd_link_info *info ATTRIBUTE_UNUSED, 936 asection *p ATTRIBUTE_UNUSED) 937{ 938 return TRUE; 939} 940 941/* Assign dynsym indices. In a shared library we generate a section 942 symbol for each output section, which come first. Next come symbols 943 which have been forced to local binding. Then all of the back-end 944 allocated local dynamic syms, followed by the rest of the global 945 symbols. If SECTION_SYM_COUNT is NULL, section dynindx is not set. 946 (This prevents the early call before elf_backend_init_index_section 947 and strip_excluded_output_sections setting dynindx for sections 948 that are stripped.) */ 949 950static unsigned long 951_bfd_elf_link_renumber_dynsyms (bfd *output_bfd, 952 struct bfd_link_info *info, 953 unsigned long *section_sym_count) 954{ 955 unsigned long dynsymcount = 0; 956 bfd_boolean do_sec = section_sym_count != NULL; 957 958 if (bfd_link_pic (info) 959 || elf_hash_table (info)->is_relocatable_executable) 960 { 961 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd); 962 asection *p; 963 for (p = output_bfd->sections; p ; p = p->next) 964 if ((p->flags & SEC_EXCLUDE) == 0 965 && (p->flags & SEC_ALLOC) != 0 966 && elf_hash_table (info)->dynamic_relocs 967 && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p)) 968 { 969 ++dynsymcount; 970 if (do_sec) 971 elf_section_data (p)->dynindx = dynsymcount; 972 } 973 else if (do_sec) 974 elf_section_data (p)->dynindx = 0; 975 } 976 if (do_sec) 977 *section_sym_count = dynsymcount; 978 979 elf_link_hash_traverse (elf_hash_table (info), 980 elf_link_renumber_local_hash_table_dynsyms, 981 &dynsymcount); 982 983 if (elf_hash_table (info)->dynlocal) 984 { 985 struct elf_link_local_dynamic_entry *p; 986 for (p = elf_hash_table (info)->dynlocal; p ; p = p->next) 987 p->dynindx = ++dynsymcount; 988 } 989 elf_hash_table (info)->local_dynsymcount = dynsymcount; 990 991 elf_link_hash_traverse (elf_hash_table (info), 992 elf_link_renumber_hash_table_dynsyms, 993 &dynsymcount); 994 995 /* There is an unused NULL entry at the head of the table which we 996 must account for in our count even if the table is empty since it 997 is intended for the mandatory DT_SYMTAB tag (.dynsym section) in 998 .dynamic section. */ 999 dynsymcount++; 1000 1001 elf_hash_table (info)->dynsymcount = dynsymcount; 1002 return dynsymcount; 1003} 1004 1005/* Merge st_other field. */ 1006 1007static void 1008elf_merge_st_other (bfd *abfd, struct elf_link_hash_entry *h, 1009 const Elf_Internal_Sym *isym, asection *sec, 1010 bfd_boolean definition, bfd_boolean dynamic) 1011{ 1012 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 1013 1014 /* If st_other has a processor-specific meaning, specific 1015 code might be needed here. */ 1016 if (bed->elf_backend_merge_symbol_attribute) 1017 (*bed->elf_backend_merge_symbol_attribute) (h, isym, definition, 1018 dynamic); 1019 1020 if (!dynamic) 1021 { 1022 unsigned symvis = ELF_ST_VISIBILITY (isym->st_other); 1023 unsigned hvis = ELF_ST_VISIBILITY (h->other); 1024 1025 /* Keep the most constraining visibility. Leave the remainder 1026 of the st_other field to elf_backend_merge_symbol_attribute. */ 1027 if (symvis - 1 < hvis - 1) 1028 h->other = symvis | (h->other & ~ELF_ST_VISIBILITY (-1)); 1029 } 1030 else if (definition 1031 && ELF_ST_VISIBILITY (isym->st_other) != STV_DEFAULT 1032 && (sec->flags & SEC_READONLY) == 0) 1033 h->protected_def = 1; 1034} 1035 1036/* This function is called when we want to merge a new symbol with an 1037 existing symbol. It handles the various cases which arise when we 1038 find a definition in a dynamic object, or when there is already a 1039 definition in a dynamic object. The new symbol is described by 1040 NAME, SYM, PSEC, and PVALUE. We set SYM_HASH to the hash table 1041 entry. We set POLDBFD to the old symbol's BFD. We set POLD_WEAK 1042 if the old symbol was weak. We set POLD_ALIGNMENT to the alignment 1043 of an old common symbol. We set OVERRIDE if the old symbol is 1044 overriding a new definition. We set TYPE_CHANGE_OK if it is OK for 1045 the type to change. We set SIZE_CHANGE_OK if it is OK for the size 1046 to change. By OK to change, we mean that we shouldn't warn if the 1047 type or size does change. */ 1048 1049static bfd_boolean 1050_bfd_elf_merge_symbol (bfd *abfd, 1051 struct bfd_link_info *info, 1052 const char *name, 1053 Elf_Internal_Sym *sym, 1054 asection **psec, 1055 bfd_vma *pvalue, 1056 struct elf_link_hash_entry **sym_hash, 1057 bfd **poldbfd, 1058 bfd_boolean *pold_weak, 1059 unsigned int *pold_alignment, 1060 bfd_boolean *skip, 1061 bfd **override, 1062 bfd_boolean *type_change_ok, 1063 bfd_boolean *size_change_ok, 1064 bfd_boolean *matched) 1065{ 1066 asection *sec, *oldsec; 1067 struct elf_link_hash_entry *h; 1068 struct elf_link_hash_entry *hi; 1069 struct elf_link_hash_entry *flip; 1070 int bind; 1071 bfd *oldbfd; 1072 bfd_boolean newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon; 1073 bfd_boolean newweak, oldweak, newfunc, oldfunc; 1074 const struct elf_backend_data *bed; 1075 char *new_version; 1076 bfd_boolean default_sym = *matched; 1077 1078 *skip = FALSE; 1079 *override = NULL; 1080 1081 sec = *psec; 1082 bind = ELF_ST_BIND (sym->st_info); 1083 1084 if (! bfd_is_und_section (sec)) 1085 h = elf_link_hash_lookup (elf_hash_table (info), name, TRUE, FALSE, FALSE); 1086 else 1087 h = ((struct elf_link_hash_entry *) 1088 bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, FALSE, FALSE)); 1089 if (h == NULL) 1090 return FALSE; 1091 *sym_hash = h; 1092 1093 bed = get_elf_backend_data (abfd); 1094 1095 /* NEW_VERSION is the symbol version of the new symbol. */ 1096 if (h->versioned != unversioned) 1097 { 1098 /* Symbol version is unknown or versioned. */ 1099 new_version = strrchr (name, ELF_VER_CHR); 1100 if (new_version) 1101 { 1102 if (h->versioned == unknown) 1103 { 1104 if (new_version > name && new_version[-1] != ELF_VER_CHR) 1105 h->versioned = versioned_hidden; 1106 else 1107 h->versioned = versioned; 1108 } 1109 new_version += 1; 1110 if (new_version[0] == '\0') 1111 new_version = NULL; 1112 } 1113 else 1114 h->versioned = unversioned; 1115 } 1116 else 1117 new_version = NULL; 1118 1119 /* For merging, we only care about real symbols. But we need to make 1120 sure that indirect symbol dynamic flags are updated. */ 1121 hi = h; 1122 while (h->root.type == bfd_link_hash_indirect 1123 || h->root.type == bfd_link_hash_warning) 1124 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1125 1126 if (!*matched) 1127 { 1128 if (hi == h || h->root.type == bfd_link_hash_new) 1129 *matched = TRUE; 1130 else 1131 { 1132 /* OLD_HIDDEN is true if the existing symbol is only visible 1133 to the symbol with the same symbol version. NEW_HIDDEN is 1134 true if the new symbol is only visible to the symbol with 1135 the same symbol version. */ 1136 bfd_boolean old_hidden = h->versioned == versioned_hidden; 1137 bfd_boolean new_hidden = hi->versioned == versioned_hidden; 1138 if (!old_hidden && !new_hidden) 1139 /* The new symbol matches the existing symbol if both 1140 aren't hidden. */ 1141 *matched = TRUE; 1142 else 1143 { 1144 /* OLD_VERSION is the symbol version of the existing 1145 symbol. */ 1146 char *old_version; 1147 1148 if (h->versioned >= versioned) 1149 old_version = strrchr (h->root.root.string, 1150 ELF_VER_CHR) + 1; 1151 else 1152 old_version = NULL; 1153 1154 /* The new symbol matches the existing symbol if they 1155 have the same symbol version. */ 1156 *matched = (old_version == new_version 1157 || (old_version != NULL 1158 && new_version != NULL 1159 && strcmp (old_version, new_version) == 0)); 1160 } 1161 } 1162 } 1163 1164 /* OLDBFD and OLDSEC are a BFD and an ASECTION associated with the 1165 existing symbol. */ 1166 1167 oldbfd = NULL; 1168 oldsec = NULL; 1169 switch (h->root.type) 1170 { 1171 default: 1172 break; 1173 1174 case bfd_link_hash_undefined: 1175 case bfd_link_hash_undefweak: 1176 oldbfd = h->root.u.undef.abfd; 1177 break; 1178 1179 case bfd_link_hash_defined: 1180 case bfd_link_hash_defweak: 1181 oldbfd = h->root.u.def.section->owner; 1182 oldsec = h->root.u.def.section; 1183 break; 1184 1185 case bfd_link_hash_common: 1186 oldbfd = h->root.u.c.p->section->owner; 1187 oldsec = h->root.u.c.p->section; 1188 if (pold_alignment) 1189 *pold_alignment = h->root.u.c.p->alignment_power; 1190 break; 1191 } 1192 if (poldbfd && *poldbfd == NULL) 1193 *poldbfd = oldbfd; 1194 1195 /* Differentiate strong and weak symbols. */ 1196 newweak = bind == STB_WEAK; 1197 oldweak = (h->root.type == bfd_link_hash_defweak 1198 || h->root.type == bfd_link_hash_undefweak); 1199 if (pold_weak) 1200 *pold_weak = oldweak; 1201 1202 /* We have to check it for every instance since the first few may be 1203 references and not all compilers emit symbol type for undefined 1204 symbols. */ 1205 bfd_elf_link_mark_dynamic_symbol (info, h, sym); 1206 1207 /* NEWDYN and OLDDYN indicate whether the new or old symbol, 1208 respectively, is from a dynamic object. */ 1209 1210 newdyn = (abfd->flags & DYNAMIC) != 0; 1211 1212 /* ref_dynamic_nonweak and dynamic_def flags track actual undefined 1213 syms and defined syms in dynamic libraries respectively. 1214 ref_dynamic on the other hand can be set for a symbol defined in 1215 a dynamic library, and def_dynamic may not be set; When the 1216 definition in a dynamic lib is overridden by a definition in the 1217 executable use of the symbol in the dynamic lib becomes a 1218 reference to the executable symbol. */ 1219 if (newdyn) 1220 { 1221 if (bfd_is_und_section (sec)) 1222 { 1223 if (bind != STB_WEAK) 1224 { 1225 h->ref_dynamic_nonweak = 1; 1226 hi->ref_dynamic_nonweak = 1; 1227 } 1228 } 1229 else 1230 { 1231 /* Update the existing symbol only if they match. */ 1232 if (*matched) 1233 h->dynamic_def = 1; 1234 hi->dynamic_def = 1; 1235 } 1236 } 1237 1238 /* If we just created the symbol, mark it as being an ELF symbol. 1239 Other than that, there is nothing to do--there is no merge issue 1240 with a newly defined symbol--so we just return. */ 1241 1242 if (h->root.type == bfd_link_hash_new) 1243 { 1244 h->non_elf = 0; 1245 return TRUE; 1246 } 1247 1248 /* In cases involving weak versioned symbols, we may wind up trying 1249 to merge a symbol with itself. Catch that here, to avoid the 1250 confusion that results if we try to override a symbol with 1251 itself. The additional tests catch cases like 1252 _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a 1253 dynamic object, which we do want to handle here. */ 1254 if (abfd == oldbfd 1255 && (newweak || oldweak) 1256 && ((abfd->flags & DYNAMIC) == 0 1257 || !h->def_regular)) 1258 return TRUE; 1259 1260 olddyn = FALSE; 1261 if (oldbfd != NULL) 1262 olddyn = (oldbfd->flags & DYNAMIC) != 0; 1263 else if (oldsec != NULL) 1264 { 1265 /* This handles the special SHN_MIPS_{TEXT,DATA} section 1266 indices used by MIPS ELF. */ 1267 olddyn = (oldsec->symbol->flags & BSF_DYNAMIC) != 0; 1268 } 1269 1270 /* Handle a case where plugin_notice won't be called and thus won't 1271 set the non_ir_ref flags on the first pass over symbols. */ 1272 if (oldbfd != NULL 1273 && (oldbfd->flags & BFD_PLUGIN) != (abfd->flags & BFD_PLUGIN) 1274 && newdyn != olddyn) 1275 { 1276 h->root.non_ir_ref_dynamic = TRUE; 1277 hi->root.non_ir_ref_dynamic = TRUE; 1278 } 1279 1280 /* NEWDEF and OLDDEF indicate whether the new or old symbol, 1281 respectively, appear to be a definition rather than reference. */ 1282 1283 newdef = !bfd_is_und_section (sec) && !bfd_is_com_section (sec); 1284 1285 olddef = (h->root.type != bfd_link_hash_undefined 1286 && h->root.type != bfd_link_hash_undefweak 1287 && h->root.type != bfd_link_hash_common); 1288 1289 /* NEWFUNC and OLDFUNC indicate whether the new or old symbol, 1290 respectively, appear to be a function. */ 1291 1292 newfunc = (ELF_ST_TYPE (sym->st_info) != STT_NOTYPE 1293 && bed->is_function_type (ELF_ST_TYPE (sym->st_info))); 1294 1295 oldfunc = (h->type != STT_NOTYPE 1296 && bed->is_function_type (h->type)); 1297 1298 if (!(newfunc && oldfunc) 1299 && ELF_ST_TYPE (sym->st_info) != h->type 1300 && ELF_ST_TYPE (sym->st_info) != STT_NOTYPE 1301 && h->type != STT_NOTYPE 1302 && (newdef || bfd_is_com_section (sec)) 1303 && (olddef || h->root.type == bfd_link_hash_common)) 1304 { 1305 /* If creating a default indirect symbol ("foo" or "foo@") from 1306 a dynamic versioned definition ("foo@@") skip doing so if 1307 there is an existing regular definition with a different 1308 type. We don't want, for example, a "time" variable in the 1309 executable overriding a "time" function in a shared library. */ 1310 if (newdyn 1311 && !olddyn) 1312 { 1313 *skip = TRUE; 1314 return TRUE; 1315 } 1316 1317 /* When adding a symbol from a regular object file after we have 1318 created indirect symbols, undo the indirection and any 1319 dynamic state. */ 1320 if (hi != h 1321 && !newdyn 1322 && olddyn) 1323 { 1324 h = hi; 1325 (*bed->elf_backend_hide_symbol) (info, h, TRUE); 1326 h->forced_local = 0; 1327 h->ref_dynamic = 0; 1328 h->def_dynamic = 0; 1329 h->dynamic_def = 0; 1330 if (h->root.u.undef.next || info->hash->undefs_tail == &h->root) 1331 { 1332 h->root.type = bfd_link_hash_undefined; 1333 h->root.u.undef.abfd = abfd; 1334 } 1335 else 1336 { 1337 h->root.type = bfd_link_hash_new; 1338 h->root.u.undef.abfd = NULL; 1339 } 1340 return TRUE; 1341 } 1342 } 1343 1344 /* Check TLS symbols. We don't check undefined symbols introduced 1345 by "ld -u" which have no type (and oldbfd NULL), and we don't 1346 check symbols from plugins because they also have no type. */ 1347 if (oldbfd != NULL 1348 && (oldbfd->flags & BFD_PLUGIN) == 0 1349 && (abfd->flags & BFD_PLUGIN) == 0 1350 && ELF_ST_TYPE (sym->st_info) != h->type 1351 && (ELF_ST_TYPE (sym->st_info) == STT_TLS || h->type == STT_TLS)) 1352 { 1353 bfd *ntbfd, *tbfd; 1354 bfd_boolean ntdef, tdef; 1355 asection *ntsec, *tsec; 1356 1357 if (h->type == STT_TLS) 1358 { 1359 ntbfd = abfd; 1360 ntsec = sec; 1361 ntdef = newdef; 1362 tbfd = oldbfd; 1363 tsec = oldsec; 1364 tdef = olddef; 1365 } 1366 else 1367 { 1368 ntbfd = oldbfd; 1369 ntsec = oldsec; 1370 ntdef = olddef; 1371 tbfd = abfd; 1372 tsec = sec; 1373 tdef = newdef; 1374 } 1375 1376 if (tdef && ntdef) 1377 _bfd_error_handler 1378 /* xgettext:c-format */ 1379 (_("%s: TLS definition in %pB section %pA " 1380 "mismatches non-TLS definition in %pB section %pA"), 1381 h->root.root.string, tbfd, tsec, ntbfd, ntsec); 1382 else if (!tdef && !ntdef) 1383 _bfd_error_handler 1384 /* xgettext:c-format */ 1385 (_("%s: TLS reference in %pB " 1386 "mismatches non-TLS reference in %pB"), 1387 h->root.root.string, tbfd, ntbfd); 1388 else if (tdef) 1389 _bfd_error_handler 1390 /* xgettext:c-format */ 1391 (_("%s: TLS definition in %pB section %pA " 1392 "mismatches non-TLS reference in %pB"), 1393 h->root.root.string, tbfd, tsec, ntbfd); 1394 else 1395 _bfd_error_handler 1396 /* xgettext:c-format */ 1397 (_("%s: TLS reference in %pB " 1398 "mismatches non-TLS definition in %pB section %pA"), 1399 h->root.root.string, tbfd, ntbfd, ntsec); 1400 1401 bfd_set_error (bfd_error_bad_value); 1402 return FALSE; 1403 } 1404 1405 /* If the old symbol has non-default visibility, we ignore the new 1406 definition from a dynamic object. */ 1407 if (newdyn 1408 && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 1409 && !bfd_is_und_section (sec)) 1410 { 1411 *skip = TRUE; 1412 /* Make sure this symbol is dynamic. */ 1413 h->ref_dynamic = 1; 1414 hi->ref_dynamic = 1; 1415 /* A protected symbol has external availability. Make sure it is 1416 recorded as dynamic. 1417 1418 FIXME: Should we check type and size for protected symbol? */ 1419 if (ELF_ST_VISIBILITY (h->other) == STV_PROTECTED) 1420 return bfd_elf_link_record_dynamic_symbol (info, h); 1421 else 1422 return TRUE; 1423 } 1424 else if (!newdyn 1425 && ELF_ST_VISIBILITY (sym->st_other) != STV_DEFAULT 1426 && h->def_dynamic) 1427 { 1428 /* If the new symbol with non-default visibility comes from a 1429 relocatable file and the old definition comes from a dynamic 1430 object, we remove the old definition. */ 1431 if (hi->root.type == bfd_link_hash_indirect) 1432 { 1433 /* Handle the case where the old dynamic definition is 1434 default versioned. We need to copy the symbol info from 1435 the symbol with default version to the normal one if it 1436 was referenced before. */ 1437 if (h->ref_regular) 1438 { 1439 hi->root.type = h->root.type; 1440 h->root.type = bfd_link_hash_indirect; 1441 (*bed->elf_backend_copy_indirect_symbol) (info, hi, h); 1442 1443 h->root.u.i.link = (struct bfd_link_hash_entry *) hi; 1444 if (ELF_ST_VISIBILITY (sym->st_other) != STV_PROTECTED) 1445 { 1446 /* If the new symbol is hidden or internal, completely undo 1447 any dynamic link state. */ 1448 (*bed->elf_backend_hide_symbol) (info, h, TRUE); 1449 h->forced_local = 0; 1450 h->ref_dynamic = 0; 1451 } 1452 else 1453 h->ref_dynamic = 1; 1454 1455 h->def_dynamic = 0; 1456 /* FIXME: Should we check type and size for protected symbol? */ 1457 h->size = 0; 1458 h->type = 0; 1459 1460 h = hi; 1461 } 1462 else 1463 h = hi; 1464 } 1465 1466 /* If the old symbol was undefined before, then it will still be 1467 on the undefs list. If the new symbol is undefined or 1468 common, we can't make it bfd_link_hash_new here, because new 1469 undefined or common symbols will be added to the undefs list 1470 by _bfd_generic_link_add_one_symbol. Symbols may not be 1471 added twice to the undefs list. Also, if the new symbol is 1472 undefweak then we don't want to lose the strong undef. */ 1473 if (h->root.u.undef.next || info->hash->undefs_tail == &h->root) 1474 { 1475 h->root.type = bfd_link_hash_undefined; 1476 h->root.u.undef.abfd = abfd; 1477 } 1478 else 1479 { 1480 h->root.type = bfd_link_hash_new; 1481 h->root.u.undef.abfd = NULL; 1482 } 1483 1484 if (ELF_ST_VISIBILITY (sym->st_other) != STV_PROTECTED) 1485 { 1486 /* If the new symbol is hidden or internal, completely undo 1487 any dynamic link state. */ 1488 (*bed->elf_backend_hide_symbol) (info, h, TRUE); 1489 h->forced_local = 0; 1490 h->ref_dynamic = 0; 1491 } 1492 else 1493 h->ref_dynamic = 1; 1494 h->def_dynamic = 0; 1495 /* FIXME: Should we check type and size for protected symbol? */ 1496 h->size = 0; 1497 h->type = 0; 1498 return TRUE; 1499 } 1500 1501 /* If a new weak symbol definition comes from a regular file and the 1502 old symbol comes from a dynamic library, we treat the new one as 1503 strong. Similarly, an old weak symbol definition from a regular 1504 file is treated as strong when the new symbol comes from a dynamic 1505 library. Further, an old weak symbol from a dynamic library is 1506 treated as strong if the new symbol is from a dynamic library. 1507 This reflects the way glibc's ld.so works. 1508 1509 Also allow a weak symbol to override a linker script symbol 1510 defined by an early pass over the script. This is done so the 1511 linker knows the symbol is defined in an object file, for the 1512 DEFINED script function. 1513 1514 Do this before setting *type_change_ok or *size_change_ok so that 1515 we warn properly when dynamic library symbols are overridden. */ 1516 1517 if (newdef && !newdyn && (olddyn || h->root.ldscript_def)) 1518 newweak = FALSE; 1519 if (olddef && newdyn) 1520 oldweak = FALSE; 1521 1522 /* Allow changes between different types of function symbol. */ 1523 if (newfunc && oldfunc) 1524 *type_change_ok = TRUE; 1525 1526 /* It's OK to change the type if either the existing symbol or the 1527 new symbol is weak. A type change is also OK if the old symbol 1528 is undefined and the new symbol is defined. */ 1529 1530 if (oldweak 1531 || newweak 1532 || (newdef 1533 && h->root.type == bfd_link_hash_undefined)) 1534 *type_change_ok = TRUE; 1535 1536 /* It's OK to change the size if either the existing symbol or the 1537 new symbol is weak, or if the old symbol is undefined. */ 1538 1539 if (*type_change_ok 1540 || h->root.type == bfd_link_hash_undefined) 1541 *size_change_ok = TRUE; 1542 1543 /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old 1544 symbol, respectively, appears to be a common symbol in a dynamic 1545 object. If a symbol appears in an uninitialized section, and is 1546 not weak, and is not a function, then it may be a common symbol 1547 which was resolved when the dynamic object was created. We want 1548 to treat such symbols specially, because they raise special 1549 considerations when setting the symbol size: if the symbol 1550 appears as a common symbol in a regular object, and the size in 1551 the regular object is larger, we must make sure that we use the 1552 larger size. This problematic case can always be avoided in C, 1553 but it must be handled correctly when using Fortran shared 1554 libraries. 1555 1556 Note that if NEWDYNCOMMON is set, NEWDEF will be set, and 1557 likewise for OLDDYNCOMMON and OLDDEF. 1558 1559 Note that this test is just a heuristic, and that it is quite 1560 possible to have an uninitialized symbol in a shared object which 1561 is really a definition, rather than a common symbol. This could 1562 lead to some minor confusion when the symbol really is a common 1563 symbol in some regular object. However, I think it will be 1564 harmless. */ 1565 1566 if (newdyn 1567 && newdef 1568 && !newweak 1569 && (sec->flags & SEC_ALLOC) != 0 1570 && (sec->flags & SEC_LOAD) == 0 1571 && sym->st_size > 0 1572 && !newfunc) 1573 newdyncommon = TRUE; 1574 else 1575 newdyncommon = FALSE; 1576 1577 if (olddyn 1578 && olddef 1579 && h->root.type == bfd_link_hash_defined 1580 && h->def_dynamic 1581 && (h->root.u.def.section->flags & SEC_ALLOC) != 0 1582 && (h->root.u.def.section->flags & SEC_LOAD) == 0 1583 && h->size > 0 1584 && !oldfunc) 1585 olddyncommon = TRUE; 1586 else 1587 olddyncommon = FALSE; 1588 1589 /* We now know everything about the old and new symbols. We ask the 1590 backend to check if we can merge them. */ 1591 if (bed->merge_symbol != NULL) 1592 { 1593 if (!bed->merge_symbol (h, sym, psec, newdef, olddef, oldbfd, oldsec)) 1594 return FALSE; 1595 sec = *psec; 1596 } 1597 1598 /* There are multiple definitions of a normal symbol. Skip the 1599 default symbol as well as definition from an IR object. */ 1600 if (olddef && !olddyn && !oldweak && newdef && !newdyn && !newweak 1601 && !default_sym && h->def_regular 1602 && !(oldbfd != NULL 1603 && (oldbfd->flags & BFD_PLUGIN) != 0 1604 && (abfd->flags & BFD_PLUGIN) == 0)) 1605 { 1606 /* Handle a multiple definition. */ 1607 (*info->callbacks->multiple_definition) (info, &h->root, 1608 abfd, sec, *pvalue); 1609 *skip = TRUE; 1610 return TRUE; 1611 } 1612 1613 /* If both the old and the new symbols look like common symbols in a 1614 dynamic object, set the size of the symbol to the larger of the 1615 two. */ 1616 1617 if (olddyncommon 1618 && newdyncommon 1619 && sym->st_size != h->size) 1620 { 1621 /* Since we think we have two common symbols, issue a multiple 1622 common warning if desired. Note that we only warn if the 1623 size is different. If the size is the same, we simply let 1624 the old symbol override the new one as normally happens with 1625 symbols defined in dynamic objects. */ 1626 1627 (*info->callbacks->multiple_common) (info, &h->root, abfd, 1628 bfd_link_hash_common, sym->st_size); 1629 if (sym->st_size > h->size) 1630 h->size = sym->st_size; 1631 1632 *size_change_ok = TRUE; 1633 } 1634 1635 /* If we are looking at a dynamic object, and we have found a 1636 definition, we need to see if the symbol was already defined by 1637 some other object. If so, we want to use the existing 1638 definition, and we do not want to report a multiple symbol 1639 definition error; we do this by clobbering *PSEC to be 1640 bfd_und_section_ptr. 1641 1642 We treat a common symbol as a definition if the symbol in the 1643 shared library is a function, since common symbols always 1644 represent variables; this can cause confusion in principle, but 1645 any such confusion would seem to indicate an erroneous program or 1646 shared library. We also permit a common symbol in a regular 1647 object to override a weak symbol in a shared object. */ 1648 1649 if (newdyn 1650 && newdef 1651 && (olddef 1652 || (h->root.type == bfd_link_hash_common 1653 && (newweak || newfunc)))) 1654 { 1655 *override = abfd; 1656 newdef = FALSE; 1657 newdyncommon = FALSE; 1658 1659 *psec = sec = bfd_und_section_ptr; 1660 *size_change_ok = TRUE; 1661 1662 /* If we get here when the old symbol is a common symbol, then 1663 we are explicitly letting it override a weak symbol or 1664 function in a dynamic object, and we don't want to warn about 1665 a type change. If the old symbol is a defined symbol, a type 1666 change warning may still be appropriate. */ 1667 1668 if (h->root.type == bfd_link_hash_common) 1669 *type_change_ok = TRUE; 1670 } 1671 1672 /* Handle the special case of an old common symbol merging with a 1673 new symbol which looks like a common symbol in a shared object. 1674 We change *PSEC and *PVALUE to make the new symbol look like a 1675 common symbol, and let _bfd_generic_link_add_one_symbol do the 1676 right thing. */ 1677 1678 if (newdyncommon 1679 && h->root.type == bfd_link_hash_common) 1680 { 1681 *override = oldbfd; 1682 newdef = FALSE; 1683 newdyncommon = FALSE; 1684 *pvalue = sym->st_size; 1685 *psec = sec = bed->common_section (oldsec); 1686 *size_change_ok = TRUE; 1687 } 1688 1689 /* Skip weak definitions of symbols that are already defined. */ 1690 if (newdef && olddef && newweak) 1691 { 1692 /* Don't skip new non-IR weak syms. */ 1693 if (!(oldbfd != NULL 1694 && (oldbfd->flags & BFD_PLUGIN) != 0 1695 && (abfd->flags & BFD_PLUGIN) == 0)) 1696 { 1697 newdef = FALSE; 1698 *skip = TRUE; 1699 } 1700 1701 /* Merge st_other. If the symbol already has a dynamic index, 1702 but visibility says it should not be visible, turn it into a 1703 local symbol. */ 1704 elf_merge_st_other (abfd, h, sym, sec, newdef, newdyn); 1705 if (h->dynindx != -1) 1706 switch (ELF_ST_VISIBILITY (h->other)) 1707 { 1708 case STV_INTERNAL: 1709 case STV_HIDDEN: 1710 (*bed->elf_backend_hide_symbol) (info, h, TRUE); 1711 break; 1712 } 1713 } 1714 1715 /* If the old symbol is from a dynamic object, and the new symbol is 1716 a definition which is not from a dynamic object, then the new 1717 symbol overrides the old symbol. Symbols from regular files 1718 always take precedence over symbols from dynamic objects, even if 1719 they are defined after the dynamic object in the link. 1720 1721 As above, we again permit a common symbol in a regular object to 1722 override a definition in a shared object if the shared object 1723 symbol is a function or is weak. */ 1724 1725 flip = NULL; 1726 if (!newdyn 1727 && (newdef 1728 || (bfd_is_com_section (sec) 1729 && (oldweak || oldfunc))) 1730 && olddyn 1731 && olddef 1732 && h->def_dynamic) 1733 { 1734 /* Change the hash table entry to undefined, and let 1735 _bfd_generic_link_add_one_symbol do the right thing with the 1736 new definition. */ 1737 1738 h->root.type = bfd_link_hash_undefined; 1739 h->root.u.undef.abfd = h->root.u.def.section->owner; 1740 *size_change_ok = TRUE; 1741 1742 olddef = FALSE; 1743 olddyncommon = FALSE; 1744 1745 /* We again permit a type change when a common symbol may be 1746 overriding a function. */ 1747 1748 if (bfd_is_com_section (sec)) 1749 { 1750 if (oldfunc) 1751 { 1752 /* If a common symbol overrides a function, make sure 1753 that it isn't defined dynamically nor has type 1754 function. */ 1755 h->def_dynamic = 0; 1756 h->type = STT_NOTYPE; 1757 } 1758 *type_change_ok = TRUE; 1759 } 1760 1761 if (hi->root.type == bfd_link_hash_indirect) 1762 flip = hi; 1763 else 1764 /* This union may have been set to be non-NULL when this symbol 1765 was seen in a dynamic object. We must force the union to be 1766 NULL, so that it is correct for a regular symbol. */ 1767 h->verinfo.vertree = NULL; 1768 } 1769 1770 /* Handle the special case of a new common symbol merging with an 1771 old symbol that looks like it might be a common symbol defined in 1772 a shared object. Note that we have already handled the case in 1773 which a new common symbol should simply override the definition 1774 in the shared library. */ 1775 1776 if (! newdyn 1777 && bfd_is_com_section (sec) 1778 && olddyncommon) 1779 { 1780 /* It would be best if we could set the hash table entry to a 1781 common symbol, but we don't know what to use for the section 1782 or the alignment. */ 1783 (*info->callbacks->multiple_common) (info, &h->root, abfd, 1784 bfd_link_hash_common, sym->st_size); 1785 1786 /* If the presumed common symbol in the dynamic object is 1787 larger, pretend that the new symbol has its size. */ 1788 1789 if (h->size > *pvalue) 1790 *pvalue = h->size; 1791 1792 /* We need to remember the alignment required by the symbol 1793 in the dynamic object. */ 1794 BFD_ASSERT (pold_alignment); 1795 *pold_alignment = h->root.u.def.section->alignment_power; 1796 1797 olddef = FALSE; 1798 olddyncommon = FALSE; 1799 1800 h->root.type = bfd_link_hash_undefined; 1801 h->root.u.undef.abfd = h->root.u.def.section->owner; 1802 1803 *size_change_ok = TRUE; 1804 *type_change_ok = TRUE; 1805 1806 if (hi->root.type == bfd_link_hash_indirect) 1807 flip = hi; 1808 else 1809 h->verinfo.vertree = NULL; 1810 } 1811 1812 if (flip != NULL) 1813 { 1814 /* Handle the case where we had a versioned symbol in a dynamic 1815 library and now find a definition in a normal object. In this 1816 case, we make the versioned symbol point to the normal one. */ 1817 flip->root.type = h->root.type; 1818 flip->root.u.undef.abfd = h->root.u.undef.abfd; 1819 h->root.type = bfd_link_hash_indirect; 1820 h->root.u.i.link = (struct bfd_link_hash_entry *) flip; 1821 (*bed->elf_backend_copy_indirect_symbol) (info, flip, h); 1822 if (h->def_dynamic) 1823 { 1824 h->def_dynamic = 0; 1825 flip->ref_dynamic = 1; 1826 } 1827 } 1828 1829 return TRUE; 1830} 1831 1832/* This function is called to create an indirect symbol from the 1833 default for the symbol with the default version if needed. The 1834 symbol is described by H, NAME, SYM, SEC, and VALUE. We 1835 set DYNSYM if the new indirect symbol is dynamic. */ 1836 1837static bfd_boolean 1838_bfd_elf_add_default_symbol (bfd *abfd, 1839 struct bfd_link_info *info, 1840 struct elf_link_hash_entry *h, 1841 const char *name, 1842 Elf_Internal_Sym *sym, 1843 asection *sec, 1844 bfd_vma value, 1845 bfd **poldbfd, 1846 bfd_boolean *dynsym) 1847{ 1848 bfd_boolean type_change_ok; 1849 bfd_boolean size_change_ok; 1850 bfd_boolean skip; 1851 char *shortname; 1852 struct elf_link_hash_entry *hi; 1853 struct bfd_link_hash_entry *bh; 1854 const struct elf_backend_data *bed; 1855 bfd_boolean collect; 1856 bfd_boolean dynamic; 1857 bfd *override; 1858 char *p; 1859 size_t len, shortlen; 1860 asection *tmp_sec; 1861 bfd_boolean matched; 1862 1863 if (h->versioned == unversioned || h->versioned == versioned_hidden) 1864 return TRUE; 1865 1866 /* If this symbol has a version, and it is the default version, we 1867 create an indirect symbol from the default name to the fully 1868 decorated name. This will cause external references which do not 1869 specify a version to be bound to this version of the symbol. */ 1870 p = strchr (name, ELF_VER_CHR); 1871 if (h->versioned == unknown) 1872 { 1873 if (p == NULL) 1874 { 1875 h->versioned = unversioned; 1876 return TRUE; 1877 } 1878 else 1879 { 1880 if (p[1] != ELF_VER_CHR) 1881 { 1882 h->versioned = versioned_hidden; 1883 return TRUE; 1884 } 1885 else 1886 h->versioned = versioned; 1887 } 1888 } 1889 else 1890 { 1891 /* PR ld/19073: We may see an unversioned definition after the 1892 default version. */ 1893 if (p == NULL) 1894 return TRUE; 1895 } 1896 1897 bed = get_elf_backend_data (abfd); 1898 collect = bed->collect; 1899 dynamic = (abfd->flags & DYNAMIC) != 0; 1900 1901 shortlen = p - name; 1902 shortname = (char *) bfd_hash_allocate (&info->hash->table, shortlen + 1); 1903 if (shortname == NULL) 1904 return FALSE; 1905 memcpy (shortname, name, shortlen); 1906 shortname[shortlen] = '\0'; 1907 1908 /* We are going to create a new symbol. Merge it with any existing 1909 symbol with this name. For the purposes of the merge, act as 1910 though we were defining the symbol we just defined, although we 1911 actually going to define an indirect symbol. */ 1912 type_change_ok = FALSE; 1913 size_change_ok = FALSE; 1914 matched = TRUE; 1915 tmp_sec = sec; 1916 if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &tmp_sec, &value, 1917 &hi, poldbfd, NULL, NULL, &skip, &override, 1918 &type_change_ok, &size_change_ok, &matched)) 1919 return FALSE; 1920 1921 if (skip) 1922 goto nondefault; 1923 1924 if (hi->def_regular || ELF_COMMON_DEF_P (hi)) 1925 { 1926 /* If the undecorated symbol will have a version added by a 1927 script different to H, then don't indirect to/from the 1928 undecorated symbol. This isn't ideal because we may not yet 1929 have seen symbol versions, if given by a script on the 1930 command line rather than via --version-script. */ 1931 if (hi->verinfo.vertree == NULL && info->version_info != NULL) 1932 { 1933 bfd_boolean hide; 1934 1935 hi->verinfo.vertree 1936 = bfd_find_version_for_sym (info->version_info, 1937 hi->root.root.string, &hide); 1938 if (hi->verinfo.vertree != NULL && hide) 1939 { 1940 (*bed->elf_backend_hide_symbol) (info, hi, TRUE); 1941 goto nondefault; 1942 } 1943 } 1944 if (hi->verinfo.vertree != NULL 1945 && strcmp (p + 1 + (p[1] == '@'), hi->verinfo.vertree->name) != 0) 1946 goto nondefault; 1947 } 1948 1949 if (! override) 1950 { 1951 /* Add the default symbol if not performing a relocatable link. */ 1952 if (! bfd_link_relocatable (info)) 1953 { 1954 bh = &hi->root; 1955 if (bh->type == bfd_link_hash_defined 1956 && bh->u.def.section->owner != NULL 1957 && (bh->u.def.section->owner->flags & BFD_PLUGIN) != 0) 1958 { 1959 /* Mark the previous definition from IR object as 1960 undefined so that the generic linker will override 1961 it. */ 1962 bh->type = bfd_link_hash_undefined; 1963 bh->u.undef.abfd = bh->u.def.section->owner; 1964 } 1965 if (! (_bfd_generic_link_add_one_symbol 1966 (info, abfd, shortname, BSF_INDIRECT, 1967 bfd_ind_section_ptr, 1968 0, name, FALSE, collect, &bh))) 1969 return FALSE; 1970 hi = (struct elf_link_hash_entry *) bh; 1971 } 1972 } 1973 else 1974 { 1975 /* In this case the symbol named SHORTNAME is overriding the 1976 indirect symbol we want to add. We were planning on making 1977 SHORTNAME an indirect symbol referring to NAME. SHORTNAME 1978 is the name without a version. NAME is the fully versioned 1979 name, and it is the default version. 1980 1981 Overriding means that we already saw a definition for the 1982 symbol SHORTNAME in a regular object, and it is overriding 1983 the symbol defined in the dynamic object. 1984 1985 When this happens, we actually want to change NAME, the 1986 symbol we just added, to refer to SHORTNAME. This will cause 1987 references to NAME in the shared object to become references 1988 to SHORTNAME in the regular object. This is what we expect 1989 when we override a function in a shared object: that the 1990 references in the shared object will be mapped to the 1991 definition in the regular object. */ 1992 1993 while (hi->root.type == bfd_link_hash_indirect 1994 || hi->root.type == bfd_link_hash_warning) 1995 hi = (struct elf_link_hash_entry *) hi->root.u.i.link; 1996 1997 h->root.type = bfd_link_hash_indirect; 1998 h->root.u.i.link = (struct bfd_link_hash_entry *) hi; 1999 if (h->def_dynamic) 2000 { 2001 h->def_dynamic = 0; 2002 hi->ref_dynamic = 1; 2003 if (hi->ref_regular 2004 || hi->def_regular) 2005 { 2006 if (! bfd_elf_link_record_dynamic_symbol (info, hi)) 2007 return FALSE; 2008 } 2009 } 2010 2011 /* Now set HI to H, so that the following code will set the 2012 other fields correctly. */ 2013 hi = h; 2014 } 2015 2016 /* Check if HI is a warning symbol. */ 2017 if (hi->root.type == bfd_link_hash_warning) 2018 hi = (struct elf_link_hash_entry *) hi->root.u.i.link; 2019 2020 /* If there is a duplicate definition somewhere, then HI may not 2021 point to an indirect symbol. We will have reported an error to 2022 the user in that case. */ 2023 2024 if (hi->root.type == bfd_link_hash_indirect) 2025 { 2026 struct elf_link_hash_entry *ht; 2027 2028 ht = (struct elf_link_hash_entry *) hi->root.u.i.link; 2029 (*bed->elf_backend_copy_indirect_symbol) (info, ht, hi); 2030 2031 /* A reference to the SHORTNAME symbol from a dynamic library 2032 will be satisfied by the versioned symbol at runtime. In 2033 effect, we have a reference to the versioned symbol. */ 2034 ht->ref_dynamic_nonweak |= hi->ref_dynamic_nonweak; 2035 hi->dynamic_def |= ht->dynamic_def; 2036 2037 /* See if the new flags lead us to realize that the symbol must 2038 be dynamic. */ 2039 if (! *dynsym) 2040 { 2041 if (! dynamic) 2042 { 2043 if (! bfd_link_executable (info) 2044 || hi->def_dynamic 2045 || hi->ref_dynamic) 2046 *dynsym = TRUE; 2047 } 2048 else 2049 { 2050 if (hi->ref_regular) 2051 *dynsym = TRUE; 2052 } 2053 } 2054 } 2055 2056 /* We also need to define an indirection from the nondefault version 2057 of the symbol. */ 2058 2059 nondefault: 2060 len = strlen (name); 2061 shortname = (char *) bfd_hash_allocate (&info->hash->table, len); 2062 if (shortname == NULL) 2063 return FALSE; 2064 memcpy (shortname, name, shortlen); 2065 memcpy (shortname + shortlen, p + 1, len - shortlen); 2066 2067 /* Once again, merge with any existing symbol. */ 2068 type_change_ok = FALSE; 2069 size_change_ok = FALSE; 2070 tmp_sec = sec; 2071 if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &tmp_sec, &value, 2072 &hi, poldbfd, NULL, NULL, &skip, &override, 2073 &type_change_ok, &size_change_ok, &matched)) 2074 return FALSE; 2075 2076 if (skip) 2077 return TRUE; 2078 2079 if (override) 2080 { 2081 /* Here SHORTNAME is a versioned name, so we don't expect to see 2082 the type of override we do in the case above unless it is 2083 overridden by a versioned definition. */ 2084 if (hi->root.type != bfd_link_hash_defined 2085 && hi->root.type != bfd_link_hash_defweak) 2086 _bfd_error_handler 2087 /* xgettext:c-format */ 2088 (_("%pB: unexpected redefinition of indirect versioned symbol `%s'"), 2089 abfd, shortname); 2090 } 2091 else 2092 { 2093 bh = &hi->root; 2094 if (! (_bfd_generic_link_add_one_symbol 2095 (info, abfd, shortname, BSF_INDIRECT, 2096 bfd_ind_section_ptr, 0, name, FALSE, collect, &bh))) 2097 return FALSE; 2098 hi = (struct elf_link_hash_entry *) bh; 2099 2100 /* If there is a duplicate definition somewhere, then HI may not 2101 point to an indirect symbol. We will have reported an error 2102 to the user in that case. */ 2103 2104 if (hi->root.type == bfd_link_hash_indirect) 2105 { 2106 (*bed->elf_backend_copy_indirect_symbol) (info, h, hi); 2107 h->ref_dynamic_nonweak |= hi->ref_dynamic_nonweak; 2108 hi->dynamic_def |= h->dynamic_def; 2109 2110 /* See if the new flags lead us to realize that the symbol 2111 must be dynamic. */ 2112 if (! *dynsym) 2113 { 2114 if (! dynamic) 2115 { 2116 if (! bfd_link_executable (info) 2117 || hi->ref_dynamic) 2118 *dynsym = TRUE; 2119 } 2120 else 2121 { 2122 if (hi->ref_regular) 2123 *dynsym = TRUE; 2124 } 2125 } 2126 } 2127 } 2128 2129 return TRUE; 2130} 2131 2132/* This routine is used to export all defined symbols into the dynamic 2133 symbol table. It is called via elf_link_hash_traverse. */ 2134 2135static bfd_boolean 2136_bfd_elf_export_symbol (struct elf_link_hash_entry *h, void *data) 2137{ 2138 struct elf_info_failed *eif = (struct elf_info_failed *) data; 2139 2140 /* Ignore indirect symbols. These are added by the versioning code. */ 2141 if (h->root.type == bfd_link_hash_indirect) 2142 return TRUE; 2143 2144 /* Ignore this if we won't export it. */ 2145 if (!eif->info->export_dynamic && !h->dynamic) 2146 return TRUE; 2147 2148 if (h->dynindx == -1 2149 && (h->def_regular || h->ref_regular) 2150 && ! bfd_hide_sym_by_version (eif->info->version_info, 2151 h->root.root.string)) 2152 { 2153 if (! bfd_elf_link_record_dynamic_symbol (eif->info, h)) 2154 { 2155 eif->failed = TRUE; 2156 return FALSE; 2157 } 2158 } 2159 2160 return TRUE; 2161} 2162 2163/* Look through the symbols which are defined in other shared 2164 libraries and referenced here. Update the list of version 2165 dependencies. This will be put into the .gnu.version_r section. 2166 This function is called via elf_link_hash_traverse. */ 2167 2168static bfd_boolean 2169_bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry *h, 2170 void *data) 2171{ 2172 struct elf_find_verdep_info *rinfo = (struct elf_find_verdep_info *) data; 2173 Elf_Internal_Verneed *t; 2174 Elf_Internal_Vernaux *a; 2175 size_t amt; 2176 2177 /* We only care about symbols defined in shared objects with version 2178 information. */ 2179 if (!h->def_dynamic 2180 || h->def_regular 2181 || h->dynindx == -1 2182 || h->verinfo.verdef == NULL 2183 || (elf_dyn_lib_class (h->verinfo.verdef->vd_bfd) 2184 & (DYN_AS_NEEDED | DYN_DT_NEEDED | DYN_NO_NEEDED))) 2185 return TRUE; 2186 2187 /* See if we already know about this version. */ 2188 for (t = elf_tdata (rinfo->info->output_bfd)->verref; 2189 t != NULL; 2190 t = t->vn_nextref) 2191 { 2192 if (t->vn_bfd != h->verinfo.verdef->vd_bfd) 2193 continue; 2194 2195 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr) 2196 if (a->vna_nodename == h->verinfo.verdef->vd_nodename) 2197 return TRUE; 2198 2199 break; 2200 } 2201 2202 /* This is a new version. Add it to tree we are building. */ 2203 2204 if (t == NULL) 2205 { 2206 amt = sizeof *t; 2207 t = (Elf_Internal_Verneed *) bfd_zalloc (rinfo->info->output_bfd, amt); 2208 if (t == NULL) 2209 { 2210 rinfo->failed = TRUE; 2211 return FALSE; 2212 } 2213 2214 t->vn_bfd = h->verinfo.verdef->vd_bfd; 2215 t->vn_nextref = elf_tdata (rinfo->info->output_bfd)->verref; 2216 elf_tdata (rinfo->info->output_bfd)->verref = t; 2217 } 2218 2219 amt = sizeof *a; 2220 a = (Elf_Internal_Vernaux *) bfd_zalloc (rinfo->info->output_bfd, amt); 2221 if (a == NULL) 2222 { 2223 rinfo->failed = TRUE; 2224 return FALSE; 2225 } 2226 2227 /* Note that we are copying a string pointer here, and testing it 2228 above. If bfd_elf_string_from_elf_section is ever changed to 2229 discard the string data when low in memory, this will have to be 2230 fixed. */ 2231 a->vna_nodename = h->verinfo.verdef->vd_nodename; 2232 2233 a->vna_flags = h->verinfo.verdef->vd_flags; 2234 a->vna_nextptr = t->vn_auxptr; 2235 2236 h->verinfo.verdef->vd_exp_refno = rinfo->vers; 2237 ++rinfo->vers; 2238 2239 a->vna_other = h->verinfo.verdef->vd_exp_refno + 1; 2240 2241 t->vn_auxptr = a; 2242 2243 return TRUE; 2244} 2245 2246/* Return TRUE and set *HIDE to TRUE if the versioned symbol is 2247 hidden. Set *T_P to NULL if there is no match. */ 2248 2249static bfd_boolean 2250_bfd_elf_link_hide_versioned_symbol (struct bfd_link_info *info, 2251 struct elf_link_hash_entry *h, 2252 const char *version_p, 2253 struct bfd_elf_version_tree **t_p, 2254 bfd_boolean *hide) 2255{ 2256 struct bfd_elf_version_tree *t; 2257 2258 /* Look for the version. If we find it, it is no longer weak. */ 2259 for (t = info->version_info; t != NULL; t = t->next) 2260 { 2261 if (strcmp (t->name, version_p) == 0) 2262 { 2263 size_t len; 2264 char *alc; 2265 struct bfd_elf_version_expr *d; 2266 2267 len = version_p - h->root.root.string; 2268 alc = (char *) bfd_malloc (len); 2269 if (alc == NULL) 2270 return FALSE; 2271 memcpy (alc, h->root.root.string, len - 1); 2272 alc[len - 1] = '\0'; 2273 if (alc[len - 2] == ELF_VER_CHR) 2274 alc[len - 2] = '\0'; 2275 2276 h->verinfo.vertree = t; 2277 t->used = TRUE; 2278 d = NULL; 2279 2280 if (t->globals.list != NULL) 2281 d = (*t->match) (&t->globals, NULL, alc); 2282 2283 /* See if there is anything to force this symbol to 2284 local scope. */ 2285 if (d == NULL && t->locals.list != NULL) 2286 { 2287 d = (*t->match) (&t->locals, NULL, alc); 2288 if (d != NULL 2289 && h->dynindx != -1 2290 && ! info->export_dynamic) 2291 *hide = TRUE; 2292 } 2293 2294 free (alc); 2295 break; 2296 } 2297 } 2298 2299 *t_p = t; 2300 2301 return TRUE; 2302} 2303 2304/* Return TRUE if the symbol H is hidden by version script. */ 2305 2306bfd_boolean 2307_bfd_elf_link_hide_sym_by_version (struct bfd_link_info *info, 2308 struct elf_link_hash_entry *h) 2309{ 2310 const char *p; 2311 bfd_boolean hide = FALSE; 2312 const struct elf_backend_data *bed 2313 = get_elf_backend_data (info->output_bfd); 2314 2315 /* Version script only hides symbols defined in regular objects. */ 2316 if (!h->def_regular && !ELF_COMMON_DEF_P (h)) 2317 return TRUE; 2318 2319 p = strchr (h->root.root.string, ELF_VER_CHR); 2320 if (p != NULL && h->verinfo.vertree == NULL) 2321 { 2322 struct bfd_elf_version_tree *t; 2323 2324 ++p; 2325 if (*p == ELF_VER_CHR) 2326 ++p; 2327 2328 if (*p != '\0' 2329 && _bfd_elf_link_hide_versioned_symbol (info, h, p, &t, &hide) 2330 && hide) 2331 { 2332 if (hide) 2333 (*bed->elf_backend_hide_symbol) (info, h, TRUE); 2334 return TRUE; 2335 } 2336 } 2337 2338 /* If we don't have a version for this symbol, see if we can find 2339 something. */ 2340 if (h->verinfo.vertree == NULL && info->version_info != NULL) 2341 { 2342 h->verinfo.vertree 2343 = bfd_find_version_for_sym (info->version_info, 2344 h->root.root.string, &hide); 2345 if (h->verinfo.vertree != NULL && hide) 2346 { 2347 (*bed->elf_backend_hide_symbol) (info, h, TRUE); 2348 return TRUE; 2349 } 2350 } 2351 2352 return FALSE; 2353} 2354 2355/* Figure out appropriate versions for all the symbols. We may not 2356 have the version number script until we have read all of the input 2357 files, so until that point we don't know which symbols should be 2358 local. This function is called via elf_link_hash_traverse. */ 2359 2360static bfd_boolean 2361_bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data) 2362{ 2363 struct elf_info_failed *sinfo; 2364 struct bfd_link_info *info; 2365 const struct elf_backend_data *bed; 2366 struct elf_info_failed eif; 2367 char *p; 2368 bfd_boolean hide; 2369 2370 sinfo = (struct elf_info_failed *) data; 2371 info = sinfo->info; 2372 2373 /* Fix the symbol flags. */ 2374 eif.failed = FALSE; 2375 eif.info = info; 2376 if (! _bfd_elf_fix_symbol_flags (h, &eif)) 2377 { 2378 if (eif.failed) 2379 sinfo->failed = TRUE; 2380 return FALSE; 2381 } 2382 2383 bed = get_elf_backend_data (info->output_bfd); 2384 2385 /* We only need version numbers for symbols defined in regular 2386 objects. */ 2387 if (!h->def_regular && !ELF_COMMON_DEF_P (h)) 2388 { 2389 /* Hide symbols defined in discarded input sections. */ 2390 if ((h->root.type == bfd_link_hash_defined 2391 || h->root.type == bfd_link_hash_defweak) 2392 && discarded_section (h->root.u.def.section)) 2393 (*bed->elf_backend_hide_symbol) (info, h, TRUE); 2394 return TRUE; 2395 } 2396 2397 hide = FALSE; 2398 p = strchr (h->root.root.string, ELF_VER_CHR); 2399 if (p != NULL && h->verinfo.vertree == NULL) 2400 { 2401 struct bfd_elf_version_tree *t; 2402 2403 ++p; 2404 if (*p == ELF_VER_CHR) 2405 ++p; 2406 2407 /* If there is no version string, we can just return out. */ 2408 if (*p == '\0') 2409 return TRUE; 2410 2411 if (!_bfd_elf_link_hide_versioned_symbol (info, h, p, &t, &hide)) 2412 { 2413 sinfo->failed = TRUE; 2414 return FALSE; 2415 } 2416 2417 if (hide) 2418 (*bed->elf_backend_hide_symbol) (info, h, TRUE); 2419 2420 /* If we are building an application, we need to create a 2421 version node for this version. */ 2422 if (t == NULL && bfd_link_executable (info)) 2423 { 2424 struct bfd_elf_version_tree **pp; 2425 int version_index; 2426 2427 /* If we aren't going to export this symbol, we don't need 2428 to worry about it. */ 2429 if (h->dynindx == -1) 2430 return TRUE; 2431 2432 t = (struct bfd_elf_version_tree *) bfd_zalloc (info->output_bfd, 2433 sizeof *t); 2434 if (t == NULL) 2435 { 2436 sinfo->failed = TRUE; 2437 return FALSE; 2438 } 2439 2440 t->name = p; 2441 t->name_indx = (unsigned int) -1; 2442 t->used = TRUE; 2443 2444 version_index = 1; 2445 /* Don't count anonymous version tag. */ 2446 if (sinfo->info->version_info != NULL 2447 && sinfo->info->version_info->vernum == 0) 2448 version_index = 0; 2449 for (pp = &sinfo->info->version_info; 2450 *pp != NULL; 2451 pp = &(*pp)->next) 2452 ++version_index; 2453 t->vernum = version_index; 2454 2455 *pp = t; 2456 2457 h->verinfo.vertree = t; 2458 } 2459 else if (t == NULL) 2460 { 2461 /* We could not find the version for a symbol when 2462 generating a shared archive. Return an error. */ 2463 _bfd_error_handler 2464 /* xgettext:c-format */ 2465 (_("%pB: version node not found for symbol %s"), 2466 info->output_bfd, h->root.root.string); 2467 bfd_set_error (bfd_error_bad_value); 2468 sinfo->failed = TRUE; 2469 return FALSE; 2470 } 2471 } 2472 2473 /* If we don't have a version for this symbol, see if we can find 2474 something. */ 2475 if (!hide 2476 && h->verinfo.vertree == NULL 2477 && sinfo->info->version_info != NULL) 2478 { 2479 h->verinfo.vertree 2480 = bfd_find_version_for_sym (sinfo->info->version_info, 2481 h->root.root.string, &hide); 2482 if (h->verinfo.vertree != NULL && hide) 2483 (*bed->elf_backend_hide_symbol) (info, h, TRUE); 2484 } 2485 2486 return TRUE; 2487} 2488 2489/* Read and swap the relocs from the section indicated by SHDR. This 2490 may be either a REL or a RELA section. The relocations are 2491 translated into RELA relocations and stored in INTERNAL_RELOCS, 2492 which should have already been allocated to contain enough space. 2493 The EXTERNAL_RELOCS are a buffer where the external form of the 2494 relocations should be stored. 2495 2496 Returns FALSE if something goes wrong. */ 2497 2498static bfd_boolean 2499elf_link_read_relocs_from_section (bfd *abfd, 2500 asection *sec, 2501 Elf_Internal_Shdr *shdr, 2502 void *external_relocs, 2503 Elf_Internal_Rela *internal_relocs) 2504{ 2505 const struct elf_backend_data *bed; 2506 void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *); 2507 const bfd_byte *erela; 2508 const bfd_byte *erelaend; 2509 Elf_Internal_Rela *irela; 2510 Elf_Internal_Shdr *symtab_hdr; 2511 size_t nsyms; 2512 2513 /* Position ourselves at the start of the section. */ 2514 if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0) 2515 return FALSE; 2516 2517 /* Read the relocations. */ 2518 if (bfd_bread (external_relocs, shdr->sh_size, abfd) != shdr->sh_size) 2519 return FALSE; 2520 2521 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 2522 nsyms = NUM_SHDR_ENTRIES (symtab_hdr); 2523 2524 bed = get_elf_backend_data (abfd); 2525 2526 /* Convert the external relocations to the internal format. */ 2527 if (shdr->sh_entsize == bed->s->sizeof_rel) 2528 swap_in = bed->s->swap_reloc_in; 2529 else if (shdr->sh_entsize == bed->s->sizeof_rela) 2530 swap_in = bed->s->swap_reloca_in; 2531 else 2532 { 2533 bfd_set_error (bfd_error_wrong_format); 2534 return FALSE; 2535 } 2536 2537 erela = (const bfd_byte *) external_relocs; 2538 /* Setting erelaend like this and comparing with <= handles case of 2539 a fuzzed object with sh_size not a multiple of sh_entsize. */ 2540 erelaend = erela + shdr->sh_size - shdr->sh_entsize; 2541 irela = internal_relocs; 2542 while (erela <= erelaend) 2543 { 2544 bfd_vma r_symndx; 2545 2546 (*swap_in) (abfd, erela, irela); 2547 r_symndx = ELF32_R_SYM (irela->r_info); 2548 if (bed->s->arch_size == 64) 2549 r_symndx >>= 24; 2550 if (nsyms > 0) 2551 { 2552 if ((size_t) r_symndx >= nsyms) 2553 { 2554 _bfd_error_handler 2555 /* xgettext:c-format */ 2556 (_("%pB: bad reloc symbol index (%#" PRIx64 " >= %#lx)" 2557 " for offset %#" PRIx64 " in section `%pA'"), 2558 abfd, (uint64_t) r_symndx, (unsigned long) nsyms, 2559 (uint64_t) irela->r_offset, sec); 2560 bfd_set_error (bfd_error_bad_value); 2561 return FALSE; 2562 } 2563 } 2564 else if (r_symndx != STN_UNDEF) 2565 { 2566 _bfd_error_handler 2567 /* xgettext:c-format */ 2568 (_("%pB: non-zero symbol index (%#" PRIx64 ")" 2569 " for offset %#" PRIx64 " in section `%pA'" 2570 " when the object file has no symbol table"), 2571 abfd, (uint64_t) r_symndx, 2572 (uint64_t) irela->r_offset, sec); 2573 bfd_set_error (bfd_error_bad_value); 2574 return FALSE; 2575 } 2576 irela += bed->s->int_rels_per_ext_rel; 2577 erela += shdr->sh_entsize; 2578 } 2579 2580 return TRUE; 2581} 2582 2583/* Read and swap the relocs for a section O. They may have been 2584 cached. If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are 2585 not NULL, they are used as buffers to read into. They are known to 2586 be large enough. If the INTERNAL_RELOCS relocs argument is NULL, 2587 the return value is allocated using either malloc or bfd_alloc, 2588 according to the KEEP_MEMORY argument. If O has two relocation 2589 sections (both REL and RELA relocations), then the REL_HDR 2590 relocations will appear first in INTERNAL_RELOCS, followed by the 2591 RELA_HDR relocations. */ 2592 2593Elf_Internal_Rela * 2594_bfd_elf_link_read_relocs (bfd *abfd, 2595 asection *o, 2596 void *external_relocs, 2597 Elf_Internal_Rela *internal_relocs, 2598 bfd_boolean keep_memory) 2599{ 2600 void *alloc1 = NULL; 2601 Elf_Internal_Rela *alloc2 = NULL; 2602 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 2603 struct bfd_elf_section_data *esdo = elf_section_data (o); 2604 Elf_Internal_Rela *internal_rela_relocs; 2605 2606 if (esdo->relocs != NULL) 2607 return esdo->relocs; 2608 2609 if (o->reloc_count == 0) 2610 return NULL; 2611 2612 if (internal_relocs == NULL) 2613 { 2614 bfd_size_type size; 2615 2616 size = (bfd_size_type) o->reloc_count * sizeof (Elf_Internal_Rela); 2617 if (keep_memory) 2618 internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_alloc (abfd, size); 2619 else 2620 internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_malloc (size); 2621 if (internal_relocs == NULL) 2622 goto error_return; 2623 } 2624 2625 if (external_relocs == NULL) 2626 { 2627 bfd_size_type size = 0; 2628 2629 if (esdo->rel.hdr) 2630 size += esdo->rel.hdr->sh_size; 2631 if (esdo->rela.hdr) 2632 size += esdo->rela.hdr->sh_size; 2633 2634 alloc1 = bfd_malloc (size); 2635 if (alloc1 == NULL) 2636 goto error_return; 2637 external_relocs = alloc1; 2638 } 2639 2640 internal_rela_relocs = internal_relocs; 2641 if (esdo->rel.hdr) 2642 { 2643 if (!elf_link_read_relocs_from_section (abfd, o, esdo->rel.hdr, 2644 external_relocs, 2645 internal_relocs)) 2646 goto error_return; 2647 external_relocs = (((bfd_byte *) external_relocs) 2648 + esdo->rel.hdr->sh_size); 2649 internal_rela_relocs += (NUM_SHDR_ENTRIES (esdo->rel.hdr) 2650 * bed->s->int_rels_per_ext_rel); 2651 } 2652 2653 if (esdo->rela.hdr 2654 && (!elf_link_read_relocs_from_section (abfd, o, esdo->rela.hdr, 2655 external_relocs, 2656 internal_rela_relocs))) 2657 goto error_return; 2658 2659 /* Cache the results for next time, if we can. */ 2660 if (keep_memory) 2661 esdo->relocs = internal_relocs; 2662 2663 free (alloc1); 2664 2665 /* Don't free alloc2, since if it was allocated we are passing it 2666 back (under the name of internal_relocs). */ 2667 2668 return internal_relocs; 2669 2670 error_return: 2671 free (alloc1); 2672 if (alloc2 != NULL) 2673 { 2674 if (keep_memory) 2675 bfd_release (abfd, alloc2); 2676 else 2677 free (alloc2); 2678 } 2679 return NULL; 2680} 2681 2682/* Compute the size of, and allocate space for, REL_HDR which is the 2683 section header for a section containing relocations for O. */ 2684 2685static bfd_boolean 2686_bfd_elf_link_size_reloc_section (bfd *abfd, 2687 struct bfd_elf_section_reloc_data *reldata) 2688{ 2689 Elf_Internal_Shdr *rel_hdr = reldata->hdr; 2690 2691 /* That allows us to calculate the size of the section. */ 2692 rel_hdr->sh_size = rel_hdr->sh_entsize * reldata->count; 2693 2694 /* The contents field must last into write_object_contents, so we 2695 allocate it with bfd_alloc rather than malloc. Also since we 2696 cannot be sure that the contents will actually be filled in, 2697 we zero the allocated space. */ 2698 rel_hdr->contents = (unsigned char *) bfd_zalloc (abfd, rel_hdr->sh_size); 2699 if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0) 2700 return FALSE; 2701 2702 if (reldata->hashes == NULL && reldata->count) 2703 { 2704 struct elf_link_hash_entry **p; 2705 2706 p = ((struct elf_link_hash_entry **) 2707 bfd_zmalloc (reldata->count * sizeof (*p))); 2708 if (p == NULL) 2709 return FALSE; 2710 2711 reldata->hashes = p; 2712 } 2713 2714 return TRUE; 2715} 2716 2717/* Copy the relocations indicated by the INTERNAL_RELOCS (which 2718 originated from the section given by INPUT_REL_HDR) to the 2719 OUTPUT_BFD. */ 2720 2721bfd_boolean 2722_bfd_elf_link_output_relocs (bfd *output_bfd, 2723 asection *input_section, 2724 Elf_Internal_Shdr *input_rel_hdr, 2725 Elf_Internal_Rela *internal_relocs, 2726 struct elf_link_hash_entry **rel_hash 2727 ATTRIBUTE_UNUSED) 2728{ 2729 Elf_Internal_Rela *irela; 2730 Elf_Internal_Rela *irelaend; 2731 bfd_byte *erel; 2732 struct bfd_elf_section_reloc_data *output_reldata; 2733 asection *output_section; 2734 const struct elf_backend_data *bed; 2735 void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *); 2736 struct bfd_elf_section_data *esdo; 2737 2738 output_section = input_section->output_section; 2739 2740 bed = get_elf_backend_data (output_bfd); 2741 esdo = elf_section_data (output_section); 2742 if (esdo->rel.hdr && esdo->rel.hdr->sh_entsize == input_rel_hdr->sh_entsize) 2743 { 2744 output_reldata = &esdo->rel; 2745 swap_out = bed->s->swap_reloc_out; 2746 } 2747 else if (esdo->rela.hdr 2748 && esdo->rela.hdr->sh_entsize == input_rel_hdr->sh_entsize) 2749 { 2750 output_reldata = &esdo->rela; 2751 swap_out = bed->s->swap_reloca_out; 2752 } 2753 else 2754 { 2755 _bfd_error_handler 2756 /* xgettext:c-format */ 2757 (_("%pB: relocation size mismatch in %pB section %pA"), 2758 output_bfd, input_section->owner, input_section); 2759 bfd_set_error (bfd_error_wrong_format); 2760 return FALSE; 2761 } 2762 2763 erel = output_reldata->hdr->contents; 2764 erel += output_reldata->count * input_rel_hdr->sh_entsize; 2765 irela = internal_relocs; 2766 irelaend = irela + (NUM_SHDR_ENTRIES (input_rel_hdr) 2767 * bed->s->int_rels_per_ext_rel); 2768 while (irela < irelaend) 2769 { 2770 (*swap_out) (output_bfd, irela, erel); 2771 irela += bed->s->int_rels_per_ext_rel; 2772 erel += input_rel_hdr->sh_entsize; 2773 } 2774 2775 /* Bump the counter, so that we know where to add the next set of 2776 relocations. */ 2777 output_reldata->count += NUM_SHDR_ENTRIES (input_rel_hdr); 2778 2779 return TRUE; 2780} 2781 2782/* Make weak undefined symbols in PIE dynamic. */ 2783 2784bfd_boolean 2785_bfd_elf_link_hash_fixup_symbol (struct bfd_link_info *info, 2786 struct elf_link_hash_entry *h) 2787{ 2788 if (bfd_link_pie (info) 2789 && h->dynindx == -1 2790 && h->root.type == bfd_link_hash_undefweak) 2791 return bfd_elf_link_record_dynamic_symbol (info, h); 2792 2793 return TRUE; 2794} 2795 2796/* Fix up the flags for a symbol. This handles various cases which 2797 can only be fixed after all the input files are seen. This is 2798 currently called by both adjust_dynamic_symbol and 2799 assign_sym_version, which is unnecessary but perhaps more robust in 2800 the face of future changes. */ 2801 2802static bfd_boolean 2803_bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h, 2804 struct elf_info_failed *eif) 2805{ 2806 const struct elf_backend_data *bed; 2807 2808 /* If this symbol was mentioned in a non-ELF file, try to set 2809 DEF_REGULAR and REF_REGULAR correctly. This is the only way to 2810 permit a non-ELF file to correctly refer to a symbol defined in 2811 an ELF dynamic object. */ 2812 if (h->non_elf) 2813 { 2814 while (h->root.type == bfd_link_hash_indirect) 2815 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2816 2817 if (h->root.type != bfd_link_hash_defined 2818 && h->root.type != bfd_link_hash_defweak) 2819 { 2820 h->ref_regular = 1; 2821 h->ref_regular_nonweak = 1; 2822 } 2823 else 2824 { 2825 if (h->root.u.def.section->owner != NULL 2826 && (bfd_get_flavour (h->root.u.def.section->owner) 2827 == bfd_target_elf_flavour)) 2828 { 2829 h->ref_regular = 1; 2830 h->ref_regular_nonweak = 1; 2831 } 2832 else 2833 h->def_regular = 1; 2834 } 2835 2836 if (h->dynindx == -1 2837 && (h->def_dynamic 2838 || h->ref_dynamic)) 2839 { 2840 if (! bfd_elf_link_record_dynamic_symbol (eif->info, h)) 2841 { 2842 eif->failed = TRUE; 2843 return FALSE; 2844 } 2845 } 2846 } 2847 else 2848 { 2849 /* Unfortunately, NON_ELF is only correct if the symbol 2850 was first seen in a non-ELF file. Fortunately, if the symbol 2851 was first seen in an ELF file, we're probably OK unless the 2852 symbol was defined in a non-ELF file. Catch that case here. 2853 FIXME: We're still in trouble if the symbol was first seen in 2854 a dynamic object, and then later in a non-ELF regular object. */ 2855 if ((h->root.type == bfd_link_hash_defined 2856 || h->root.type == bfd_link_hash_defweak) 2857 && !h->def_regular 2858 && (h->root.u.def.section->owner != NULL 2859 ? (bfd_get_flavour (h->root.u.def.section->owner) 2860 != bfd_target_elf_flavour) 2861 : (bfd_is_abs_section (h->root.u.def.section) 2862 && !h->def_dynamic))) 2863 h->def_regular = 1; 2864 } 2865 2866 /* Backend specific symbol fixup. */ 2867 bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj); 2868 if (bed->elf_backend_fixup_symbol 2869 && !(*bed->elf_backend_fixup_symbol) (eif->info, h)) 2870 return FALSE; 2871 2872 /* If this is a final link, and the symbol was defined as a common 2873 symbol in a regular object file, and there was no definition in 2874 any dynamic object, then the linker will have allocated space for 2875 the symbol in a common section but the DEF_REGULAR 2876 flag will not have been set. */ 2877 if (h->root.type == bfd_link_hash_defined 2878 && !h->def_regular 2879 && h->ref_regular 2880 && !h->def_dynamic 2881 && (h->root.u.def.section->owner->flags & (DYNAMIC | BFD_PLUGIN)) == 0) 2882 h->def_regular = 1; 2883 2884 /* Symbols defined in discarded sections shouldn't be dynamic. */ 2885 if (h->root.type == bfd_link_hash_undefined && h->indx == -3) 2886 (*bed->elf_backend_hide_symbol) (eif->info, h, TRUE); 2887 2888 /* If a weak undefined symbol has non-default visibility, we also 2889 hide it from the dynamic linker. */ 2890 else if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 2891 && h->root.type == bfd_link_hash_undefweak) 2892 (*bed->elf_backend_hide_symbol) (eif->info, h, TRUE); 2893 2894 /* A hidden versioned symbol in executable should be forced local if 2895 it is is locally defined, not referenced by shared library and not 2896 exported. */ 2897 else if (bfd_link_executable (eif->info) 2898 && h->versioned == versioned_hidden 2899 && !eif->info->export_dynamic 2900 && !h->dynamic 2901 && !h->ref_dynamic 2902 && h->def_regular) 2903 (*bed->elf_backend_hide_symbol) (eif->info, h, TRUE); 2904 2905 /* If -Bsymbolic was used (which means to bind references to global 2906 symbols to the definition within the shared object), and this 2907 symbol was defined in a regular object, then it actually doesn't 2908 need a PLT entry. Likewise, if the symbol has non-default 2909 visibility. If the symbol has hidden or internal visibility, we 2910 will force it local. */ 2911 else if (h->needs_plt 2912 && bfd_link_pic (eif->info) 2913 && is_elf_hash_table (eif->info->hash) 2914 && (SYMBOLIC_BIND (eif->info, h) 2915 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) 2916 && h->def_regular) 2917 { 2918 bfd_boolean force_local; 2919 2920 force_local = (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL 2921 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN); 2922 (*bed->elf_backend_hide_symbol) (eif->info, h, force_local); 2923 } 2924 2925 /* If this is a weak defined symbol in a dynamic object, and we know 2926 the real definition in the dynamic object, copy interesting flags 2927 over to the real definition. */ 2928 if (h->is_weakalias) 2929 { 2930 struct elf_link_hash_entry *def = weakdef (h); 2931 2932 /* If the real definition is defined by a regular object file, 2933 don't do anything special. See the longer description in 2934 _bfd_elf_adjust_dynamic_symbol, below. If the def is not 2935 bfd_link_hash_defined as it was when put on the alias list 2936 then it must have originally been a versioned symbol (for 2937 which a non-versioned indirect symbol is created) and later 2938 a definition for the non-versioned symbol is found. In that 2939 case the indirection is flipped with the versioned symbol 2940 becoming an indirect pointing at the non-versioned symbol. 2941 Thus, not an alias any more. */ 2942 if (def->def_regular 2943 || def->root.type != bfd_link_hash_defined) 2944 { 2945 h = def; 2946 while ((h = h->u.alias) != def) 2947 h->is_weakalias = 0; 2948 } 2949 else 2950 { 2951 while (h->root.type == bfd_link_hash_indirect) 2952 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2953 BFD_ASSERT (h->root.type == bfd_link_hash_defined 2954 || h->root.type == bfd_link_hash_defweak); 2955 BFD_ASSERT (def->def_dynamic); 2956 (*bed->elf_backend_copy_indirect_symbol) (eif->info, def, h); 2957 } 2958 } 2959 2960 return TRUE; 2961} 2962 2963/* Make the backend pick a good value for a dynamic symbol. This is 2964 called via elf_link_hash_traverse, and also calls itself 2965 recursively. */ 2966 2967static bfd_boolean 2968_bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data) 2969{ 2970 struct elf_info_failed *eif = (struct elf_info_failed *) data; 2971 struct elf_link_hash_table *htab; 2972 const struct elf_backend_data *bed; 2973 2974 if (! is_elf_hash_table (eif->info->hash)) 2975 return FALSE; 2976 2977 /* Ignore indirect symbols. These are added by the versioning code. */ 2978 if (h->root.type == bfd_link_hash_indirect) 2979 return TRUE; 2980 2981 /* Fix the symbol flags. */ 2982 if (! _bfd_elf_fix_symbol_flags (h, eif)) 2983 return FALSE; 2984 2985 htab = elf_hash_table (eif->info); 2986 bed = get_elf_backend_data (htab->dynobj); 2987 2988 if (h->root.type == bfd_link_hash_undefweak) 2989 { 2990 if (eif->info->dynamic_undefined_weak == 0) 2991 (*bed->elf_backend_hide_symbol) (eif->info, h, TRUE); 2992 else if (eif->info->dynamic_undefined_weak > 0 2993 && h->ref_regular 2994 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 2995 && !bfd_hide_sym_by_version (eif->info->version_info, 2996 h->root.root.string)) 2997 { 2998 if (!bfd_elf_link_record_dynamic_symbol (eif->info, h)) 2999 { 3000 eif->failed = TRUE; 3001 return FALSE; 3002 } 3003 } 3004 } 3005 3006 /* If this symbol does not require a PLT entry, and it is not 3007 defined by a dynamic object, or is not referenced by a regular 3008 object, ignore it. We do have to handle a weak defined symbol, 3009 even if no regular object refers to it, if we decided to add it 3010 to the dynamic symbol table. FIXME: Do we normally need to worry 3011 about symbols which are defined by one dynamic object and 3012 referenced by another one? */ 3013 if (!h->needs_plt 3014 && h->type != STT_GNU_IFUNC 3015 && (h->def_regular 3016 || !h->def_dynamic 3017 || (!h->ref_regular 3018 && (!h->is_weakalias || weakdef (h)->dynindx == -1)))) 3019 { 3020 h->plt = elf_hash_table (eif->info)->init_plt_offset; 3021 return TRUE; 3022 } 3023 3024 /* If we've already adjusted this symbol, don't do it again. This 3025 can happen via a recursive call. */ 3026 if (h->dynamic_adjusted) 3027 return TRUE; 3028 3029 /* Don't look at this symbol again. Note that we must set this 3030 after checking the above conditions, because we may look at a 3031 symbol once, decide not to do anything, and then get called 3032 recursively later after REF_REGULAR is set below. */ 3033 h->dynamic_adjusted = 1; 3034 3035 /* If this is a weak definition, and we know a real definition, and 3036 the real symbol is not itself defined by a regular object file, 3037 then get a good value for the real definition. We handle the 3038 real symbol first, for the convenience of the backend routine. 3039 3040 Note that there is a confusing case here. If the real definition 3041 is defined by a regular object file, we don't get the real symbol 3042 from the dynamic object, but we do get the weak symbol. If the 3043 processor backend uses a COPY reloc, then if some routine in the 3044 dynamic object changes the real symbol, we will not see that 3045 change in the corresponding weak symbol. This is the way other 3046 ELF linkers work as well, and seems to be a result of the shared 3047 library model. 3048 3049 I will clarify this issue. Most SVR4 shared libraries define the 3050 variable _timezone and define timezone as a weak synonym. The 3051 tzset call changes _timezone. If you write 3052 extern int timezone; 3053 int _timezone = 5; 3054 int main () { tzset (); printf ("%d %d\n", timezone, _timezone); } 3055 you might expect that, since timezone is a synonym for _timezone, 3056 the same number will print both times. However, if the processor 3057 backend uses a COPY reloc, then actually timezone will be copied 3058 into your process image, and, since you define _timezone 3059 yourself, _timezone will not. Thus timezone and _timezone will 3060 wind up at different memory locations. The tzset call will set 3061 _timezone, leaving timezone unchanged. */ 3062 3063 if (h->is_weakalias) 3064 { 3065 struct elf_link_hash_entry *def = weakdef (h); 3066 3067 /* If we get to this point, there is an implicit reference to 3068 the alias by a regular object file via the weak symbol H. */ 3069 def->ref_regular = 1; 3070 3071 /* Ensure that the backend adjust_dynamic_symbol function sees 3072 the strong alias before H by recursively calling ourselves. */ 3073 if (!_bfd_elf_adjust_dynamic_symbol (def, eif)) 3074 return FALSE; 3075 } 3076 3077 /* If a symbol has no type and no size and does not require a PLT 3078 entry, then we are probably about to do the wrong thing here: we 3079 are probably going to create a COPY reloc for an empty object. 3080 This case can arise when a shared object is built with assembly 3081 code, and the assembly code fails to set the symbol type. */ 3082 if (h->size == 0 3083 && h->type == STT_NOTYPE 3084 && !h->needs_plt) 3085 _bfd_error_handler 3086 (_("warning: type and size of dynamic symbol `%s' are not defined"), 3087 h->root.root.string); 3088 3089 if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h)) 3090 { 3091 eif->failed = TRUE; 3092 return FALSE; 3093 } 3094 3095 return TRUE; 3096} 3097 3098/* Adjust the dynamic symbol, H, for copy in the dynamic bss section, 3099 DYNBSS. */ 3100 3101bfd_boolean 3102_bfd_elf_adjust_dynamic_copy (struct bfd_link_info *info, 3103 struct elf_link_hash_entry *h, 3104 asection *dynbss) 3105{ 3106 unsigned int power_of_two; 3107 bfd_vma mask; 3108 asection *sec = h->root.u.def.section; 3109 3110 /* The section alignment of the definition is the maximum alignment 3111 requirement of symbols defined in the section. Since we don't 3112 know the symbol alignment requirement, we start with the 3113 maximum alignment and check low bits of the symbol address 3114 for the minimum alignment. */ 3115 power_of_two = bfd_section_alignment (sec); 3116 mask = ((bfd_vma) 1 << power_of_two) - 1; 3117 while ((h->root.u.def.value & mask) != 0) 3118 { 3119 mask >>= 1; 3120 --power_of_two; 3121 } 3122 3123 if (power_of_two > bfd_section_alignment (dynbss)) 3124 { 3125 /* Adjust the section alignment if needed. */ 3126 if (!bfd_set_section_alignment (dynbss, power_of_two)) 3127 return FALSE; 3128 } 3129 3130 /* We make sure that the symbol will be aligned properly. */ 3131 dynbss->size = BFD_ALIGN (dynbss->size, mask + 1); 3132 3133 /* Define the symbol as being at this point in DYNBSS. */ 3134 h->root.u.def.section = dynbss; 3135 h->root.u.def.value = dynbss->size; 3136 3137 /* Increment the size of DYNBSS to make room for the symbol. */ 3138 dynbss->size += h->size; 3139 3140 /* No error if extern_protected_data is true. */ 3141 if (h->protected_def 3142 && (!info->extern_protected_data 3143 || (info->extern_protected_data < 0 3144 && !get_elf_backend_data (dynbss->owner)->extern_protected_data))) 3145 info->callbacks->einfo 3146 (_("%P: copy reloc against protected `%pT' is dangerous\n"), 3147 h->root.root.string); 3148 3149 return TRUE; 3150} 3151 3152/* Adjust all external symbols pointing into SEC_MERGE sections 3153 to reflect the object merging within the sections. */ 3154 3155static bfd_boolean 3156_bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry *h, void *data) 3157{ 3158 asection *sec; 3159 3160 if ((h->root.type == bfd_link_hash_defined 3161 || h->root.type == bfd_link_hash_defweak) 3162 && ((sec = h->root.u.def.section)->flags & SEC_MERGE) 3163 && sec->sec_info_type == SEC_INFO_TYPE_MERGE) 3164 { 3165 bfd *output_bfd = (bfd *) data; 3166 3167 h->root.u.def.value = 3168 _bfd_merged_section_offset (output_bfd, 3169 &h->root.u.def.section, 3170 elf_section_data (sec)->sec_info, 3171 h->root.u.def.value); 3172 } 3173 3174 return TRUE; 3175} 3176 3177/* Returns false if the symbol referred to by H should be considered 3178 to resolve local to the current module, and true if it should be 3179 considered to bind dynamically. */ 3180 3181bfd_boolean 3182_bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h, 3183 struct bfd_link_info *info, 3184 bfd_boolean not_local_protected) 3185{ 3186 bfd_boolean binding_stays_local_p; 3187 const struct elf_backend_data *bed; 3188 struct elf_link_hash_table *hash_table; 3189 3190 if (h == NULL) 3191 return FALSE; 3192 3193 while (h->root.type == bfd_link_hash_indirect 3194 || h->root.type == bfd_link_hash_warning) 3195 h = (struct elf_link_hash_entry *) h->root.u.i.link; 3196 3197 /* If it was forced local, then clearly it's not dynamic. */ 3198 if (h->dynindx == -1) 3199 return FALSE; 3200 if (h->forced_local) 3201 return FALSE; 3202 3203 /* Identify the cases where name binding rules say that a 3204 visible symbol resolves locally. */ 3205 binding_stays_local_p = (bfd_link_executable (info) 3206 || SYMBOLIC_BIND (info, h)); 3207 3208 switch (ELF_ST_VISIBILITY (h->other)) 3209 { 3210 case STV_INTERNAL: 3211 case STV_HIDDEN: 3212 return FALSE; 3213 3214 case STV_PROTECTED: 3215 hash_table = elf_hash_table (info); 3216 if (!is_elf_hash_table (hash_table)) 3217 return FALSE; 3218 3219 bed = get_elf_backend_data (hash_table->dynobj); 3220 3221 /* Proper resolution for function pointer equality may require 3222 that these symbols perhaps be resolved dynamically, even though 3223 we should be resolving them to the current module. */ 3224 if (!not_local_protected || !bed->is_function_type (h->type)) 3225 binding_stays_local_p = TRUE; 3226 break; 3227 3228 default: 3229 break; 3230 } 3231 3232 /* If it isn't defined locally, then clearly it's dynamic. */ 3233 if (!h->def_regular && !ELF_COMMON_DEF_P (h)) 3234 return TRUE; 3235 3236 /* Otherwise, the symbol is dynamic if binding rules don't tell 3237 us that it remains local. */ 3238 return !binding_stays_local_p; 3239} 3240 3241/* Return true if the symbol referred to by H should be considered 3242 to resolve local to the current module, and false otherwise. Differs 3243 from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of 3244 undefined symbols. The two functions are virtually identical except 3245 for the place where dynindx == -1 is tested. If that test is true, 3246 _bfd_elf_dynamic_symbol_p will say the symbol is local, while 3247 _bfd_elf_symbol_refs_local_p will say the symbol is local only for 3248 defined symbols. 3249 It might seem that _bfd_elf_dynamic_symbol_p could be rewritten as 3250 !_bfd_elf_symbol_refs_local_p, except that targets differ in their 3251 treatment of undefined weak symbols. For those that do not make 3252 undefined weak symbols dynamic, both functions may return false. */ 3253 3254bfd_boolean 3255_bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry *h, 3256 struct bfd_link_info *info, 3257 bfd_boolean local_protected) 3258{ 3259 const struct elf_backend_data *bed; 3260 struct elf_link_hash_table *hash_table; 3261 3262 /* If it's a local sym, of course we resolve locally. */ 3263 if (h == NULL) 3264 return TRUE; 3265 3266 /* STV_HIDDEN or STV_INTERNAL ones must be local. */ 3267 if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN 3268 || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL) 3269 return TRUE; 3270 3271 /* Forced local symbols resolve locally. */ 3272 if (h->forced_local) 3273 return TRUE; 3274 3275 /* Common symbols that become definitions don't get the DEF_REGULAR 3276 flag set, so test it first, and don't bail out. */ 3277 if (ELF_COMMON_DEF_P (h)) 3278 /* Do nothing. */; 3279 /* If we don't have a definition in a regular file, then we can't 3280 resolve locally. The sym is either undefined or dynamic. */ 3281 else if (!h->def_regular) 3282 return FALSE; 3283 3284 /* Non-dynamic symbols resolve locally. */ 3285 if (h->dynindx == -1) 3286 return TRUE; 3287 3288 /* At this point, we know the symbol is defined and dynamic. In an 3289 executable it must resolve locally, likewise when building symbolic 3290 shared libraries. */ 3291 if (bfd_link_executable (info) || SYMBOLIC_BIND (info, h)) 3292 return TRUE; 3293 3294 /* Now deal with defined dynamic symbols in shared libraries. Ones 3295 with default visibility might not resolve locally. */ 3296 if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) 3297 return FALSE; 3298 3299 hash_table = elf_hash_table (info); 3300 if (!is_elf_hash_table (hash_table)) 3301 return TRUE; 3302 3303 bed = get_elf_backend_data (hash_table->dynobj); 3304 3305 /* If extern_protected_data is false, STV_PROTECTED non-function 3306 symbols are local. */ 3307 if ((!info->extern_protected_data 3308 || (info->extern_protected_data < 0 3309 && !bed->extern_protected_data)) 3310 && !bed->is_function_type (h->type)) 3311 return TRUE; 3312 3313 /* Function pointer equality tests may require that STV_PROTECTED 3314 symbols be treated as dynamic symbols. If the address of a 3315 function not defined in an executable is set to that function's 3316 plt entry in the executable, then the address of the function in 3317 a shared library must also be the plt entry in the executable. */ 3318 return local_protected; 3319} 3320 3321/* Caches some TLS segment info, and ensures that the TLS segment vma is 3322 aligned. Returns the first TLS output section. */ 3323 3324struct bfd_section * 3325_bfd_elf_tls_setup (bfd *obfd, struct bfd_link_info *info) 3326{ 3327 struct bfd_section *sec, *tls; 3328 unsigned int align = 0; 3329 3330 for (sec = obfd->sections; sec != NULL; sec = sec->next) 3331 if ((sec->flags & SEC_THREAD_LOCAL) != 0) 3332 break; 3333 tls = sec; 3334 3335 for (; sec != NULL && (sec->flags & SEC_THREAD_LOCAL) != 0; sec = sec->next) 3336 if (sec->alignment_power > align) 3337 align = sec->alignment_power; 3338 3339 elf_hash_table (info)->tls_sec = tls; 3340 3341 /* Ensure the alignment of the first section (usually .tdata) is the largest 3342 alignment, so that the tls segment starts aligned. */ 3343 if (tls != NULL) 3344 tls->alignment_power = align; 3345 3346 return tls; 3347} 3348 3349/* Return TRUE iff this is a non-common, definition of a non-function symbol. */ 3350static bfd_boolean 3351is_global_data_symbol_definition (bfd *abfd ATTRIBUTE_UNUSED, 3352 Elf_Internal_Sym *sym) 3353{ 3354 const struct elf_backend_data *bed; 3355 3356 /* Local symbols do not count, but target specific ones might. */ 3357 if (ELF_ST_BIND (sym->st_info) != STB_GLOBAL 3358 && ELF_ST_BIND (sym->st_info) < STB_LOOS) 3359 return FALSE; 3360 3361 bed = get_elf_backend_data (abfd); 3362 /* Function symbols do not count. */ 3363 if (bed->is_function_type (ELF_ST_TYPE (sym->st_info))) 3364 return FALSE; 3365 3366 /* If the section is undefined, then so is the symbol. */ 3367 if (sym->st_shndx == SHN_UNDEF) 3368 return FALSE; 3369 3370 /* If the symbol is defined in the common section, then 3371 it is a common definition and so does not count. */ 3372 if (bed->common_definition (sym)) 3373 return FALSE; 3374 3375 /* If the symbol is in a target specific section then we 3376 must rely upon the backend to tell us what it is. */ 3377 if (sym->st_shndx >= SHN_LORESERVE && sym->st_shndx < SHN_ABS) 3378 /* FIXME - this function is not coded yet: 3379 3380 return _bfd_is_global_symbol_definition (abfd, sym); 3381 3382 Instead for now assume that the definition is not global, 3383 Even if this is wrong, at least the linker will behave 3384 in the same way that it used to do. */ 3385 return FALSE; 3386 3387 return TRUE; 3388} 3389 3390/* Search the symbol table of the archive element of the archive ABFD 3391 whose archive map contains a mention of SYMDEF, and determine if 3392 the symbol is defined in this element. */ 3393static bfd_boolean 3394elf_link_is_defined_archive_symbol (bfd * abfd, carsym * symdef) 3395{ 3396 Elf_Internal_Shdr * hdr; 3397 size_t symcount; 3398 size_t extsymcount; 3399 size_t extsymoff; 3400 Elf_Internal_Sym *isymbuf; 3401 Elf_Internal_Sym *isym; 3402 Elf_Internal_Sym *isymend; 3403 bfd_boolean result; 3404 3405 abfd = _bfd_get_elt_at_filepos (abfd, symdef->file_offset); 3406 if (abfd == NULL) 3407 return FALSE; 3408 3409 if (! bfd_check_format (abfd, bfd_object)) 3410 return FALSE; 3411 3412 /* Select the appropriate symbol table. If we don't know if the 3413 object file is an IR object, give linker LTO plugin a chance to 3414 get the correct symbol table. */ 3415 if (abfd->plugin_format == bfd_plugin_yes 3416#if BFD_SUPPORTS_PLUGINS 3417 || (abfd->plugin_format == bfd_plugin_unknown 3418 && bfd_link_plugin_object_p (abfd)) 3419#endif 3420 ) 3421 { 3422 /* Use the IR symbol table if the object has been claimed by 3423 plugin. */ 3424 abfd = abfd->plugin_dummy_bfd; 3425 hdr = &elf_tdata (abfd)->symtab_hdr; 3426 } 3427 else if ((abfd->flags & DYNAMIC) == 0 || elf_dynsymtab (abfd) == 0) 3428 hdr = &elf_tdata (abfd)->symtab_hdr; 3429 else 3430 hdr = &elf_tdata (abfd)->dynsymtab_hdr; 3431 3432 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym; 3433 3434 /* The sh_info field of the symtab header tells us where the 3435 external symbols start. We don't care about the local symbols. */ 3436 if (elf_bad_symtab (abfd)) 3437 { 3438 extsymcount = symcount; 3439 extsymoff = 0; 3440 } 3441 else 3442 { 3443 extsymcount = symcount - hdr->sh_info; 3444 extsymoff = hdr->sh_info; 3445 } 3446 3447 if (extsymcount == 0) 3448 return FALSE; 3449 3450 /* Read in the symbol table. */ 3451 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff, 3452 NULL, NULL, NULL); 3453 if (isymbuf == NULL) 3454 return FALSE; 3455 3456 /* Scan the symbol table looking for SYMDEF. */ 3457 result = FALSE; 3458 for (isym = isymbuf, isymend = isymbuf + extsymcount; isym < isymend; isym++) 3459 { 3460 const char *name; 3461 3462 name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link, 3463 isym->st_name); 3464 if (name == NULL) 3465 break; 3466 3467 if (strcmp (name, symdef->name) == 0) 3468 { 3469 result = is_global_data_symbol_definition (abfd, isym); 3470 break; 3471 } 3472 } 3473 3474 free (isymbuf); 3475 3476 return result; 3477} 3478 3479/* Add an entry to the .dynamic table. */ 3480 3481bfd_boolean 3482_bfd_elf_add_dynamic_entry (struct bfd_link_info *info, 3483 bfd_vma tag, 3484 bfd_vma val) 3485{ 3486 struct elf_link_hash_table *hash_table; 3487 const struct elf_backend_data *bed; 3488 asection *s; 3489 bfd_size_type newsize; 3490 bfd_byte *newcontents; 3491 Elf_Internal_Dyn dyn; 3492 3493 hash_table = elf_hash_table (info); 3494 if (! is_elf_hash_table (hash_table)) 3495 return FALSE; 3496 3497 if (tag == DT_RELA || tag == DT_REL) 3498 hash_table->dynamic_relocs = TRUE; 3499 3500 bed = get_elf_backend_data (hash_table->dynobj); 3501 s = bfd_get_linker_section (hash_table->dynobj, ".dynamic"); 3502 BFD_ASSERT (s != NULL); 3503 3504 newsize = s->size + bed->s->sizeof_dyn; 3505 newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize); 3506 if (newcontents == NULL) 3507 return FALSE; 3508 3509 dyn.d_tag = tag; 3510 dyn.d_un.d_val = val; 3511 bed->s->swap_dyn_out (hash_table->dynobj, &dyn, newcontents + s->size); 3512 3513 s->size = newsize; 3514 s->contents = newcontents; 3515 3516 return TRUE; 3517} 3518 3519/* Strip zero-sized dynamic sections. */ 3520 3521bfd_boolean 3522_bfd_elf_strip_zero_sized_dynamic_sections (struct bfd_link_info *info) 3523{ 3524 struct elf_link_hash_table *hash_table; 3525 const struct elf_backend_data *bed; 3526 asection *s, *sdynamic, **pp; 3527 asection *rela_dyn, *rel_dyn; 3528 Elf_Internal_Dyn dyn; 3529 bfd_byte *extdyn, *next; 3530 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *); 3531 bfd_boolean strip_zero_sized; 3532 bfd_boolean strip_zero_sized_plt; 3533 3534 if (bfd_link_relocatable (info)) 3535 return TRUE; 3536 3537 hash_table = elf_hash_table (info); 3538 if (!is_elf_hash_table (hash_table)) 3539 return FALSE; 3540 3541 if (!hash_table->dynobj) 3542 return TRUE; 3543 3544 sdynamic= bfd_get_linker_section (hash_table->dynobj, ".dynamic"); 3545 if (!sdynamic) 3546 return TRUE; 3547 3548 bed = get_elf_backend_data (hash_table->dynobj); 3549 swap_dyn_in = bed->s->swap_dyn_in; 3550 3551 strip_zero_sized = FALSE; 3552 strip_zero_sized_plt = FALSE; 3553 3554 /* Strip zero-sized dynamic sections. */ 3555 rela_dyn = bfd_get_section_by_name (info->output_bfd, ".rela.dyn"); 3556 rel_dyn = bfd_get_section_by_name (info->output_bfd, ".rel.dyn"); 3557 for (pp = &info->output_bfd->sections; (s = *pp) != NULL;) 3558 if (s->size == 0 3559 && (s == rela_dyn 3560 || s == rel_dyn 3561 || s == hash_table->srelplt->output_section 3562 || s == hash_table->splt->output_section)) 3563 { 3564 *pp = s->next; 3565 info->output_bfd->section_count--; 3566 strip_zero_sized = TRUE; 3567 if (s == rela_dyn) 3568 s = rela_dyn; 3569 if (s == rel_dyn) 3570 s = rel_dyn; 3571 else if (s == hash_table->splt->output_section) 3572 { 3573 s = hash_table->splt; 3574 strip_zero_sized_plt = TRUE; 3575 } 3576 else 3577 s = hash_table->srelplt; 3578 s->flags |= SEC_EXCLUDE; 3579 s->output_section = bfd_abs_section_ptr; 3580 } 3581 else 3582 pp = &s->next; 3583 3584 if (strip_zero_sized_plt) 3585 for (extdyn = sdynamic->contents; 3586 extdyn < sdynamic->contents + sdynamic->size; 3587 extdyn = next) 3588 { 3589 next = extdyn + bed->s->sizeof_dyn; 3590 swap_dyn_in (hash_table->dynobj, extdyn, &dyn); 3591 switch (dyn.d_tag) 3592 { 3593 default: 3594 break; 3595 case DT_JMPREL: 3596 case DT_PLTRELSZ: 3597 case DT_PLTREL: 3598 /* Strip DT_PLTRELSZ, DT_JMPREL and DT_PLTREL entries if 3599 the procedure linkage table (the .plt section) has been 3600 removed. */ 3601 memmove (extdyn, next, 3602 sdynamic->size - (next - sdynamic->contents)); 3603 next = extdyn; 3604 } 3605 } 3606 3607 if (strip_zero_sized) 3608 { 3609 /* Regenerate program headers. */ 3610 elf_seg_map (info->output_bfd) = NULL; 3611 return _bfd_elf_map_sections_to_segments (info->output_bfd, info); 3612 } 3613 3614 return TRUE; 3615} 3616 3617/* Add a DT_NEEDED entry for this dynamic object. Returns -1 on error, 3618 1 if a DT_NEEDED tag already exists, and 0 on success. */ 3619 3620int 3621bfd_elf_add_dt_needed_tag (bfd *abfd, struct bfd_link_info *info) 3622{ 3623 struct elf_link_hash_table *hash_table; 3624 size_t strindex; 3625 const char *soname; 3626 3627 if (!_bfd_elf_link_create_dynstrtab (abfd, info)) 3628 return -1; 3629 3630 hash_table = elf_hash_table (info); 3631 soname = elf_dt_name (abfd); 3632 strindex = _bfd_elf_strtab_add (hash_table->dynstr, soname, FALSE); 3633 if (strindex == (size_t) -1) 3634 return -1; 3635 3636 if (_bfd_elf_strtab_refcount (hash_table->dynstr, strindex) != 1) 3637 { 3638 asection *sdyn; 3639 const struct elf_backend_data *bed; 3640 bfd_byte *extdyn; 3641 3642 bed = get_elf_backend_data (hash_table->dynobj); 3643 sdyn = bfd_get_linker_section (hash_table->dynobj, ".dynamic"); 3644 if (sdyn != NULL) 3645 for (extdyn = sdyn->contents; 3646 extdyn < sdyn->contents + sdyn->size; 3647 extdyn += bed->s->sizeof_dyn) 3648 { 3649 Elf_Internal_Dyn dyn; 3650 3651 bed->s->swap_dyn_in (hash_table->dynobj, extdyn, &dyn); 3652 if (dyn.d_tag == DT_NEEDED 3653 && dyn.d_un.d_val == strindex) 3654 { 3655 _bfd_elf_strtab_delref (hash_table->dynstr, strindex); 3656 return 1; 3657 } 3658 } 3659 } 3660 3661 if (!_bfd_elf_link_create_dynamic_sections (hash_table->dynobj, info)) 3662 return -1; 3663 3664 if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex)) 3665 return -1; 3666 3667 return 0; 3668} 3669 3670/* Return true if SONAME is on the needed list between NEEDED and STOP 3671 (or the end of list if STOP is NULL), and needed by a library that 3672 will be loaded. */ 3673 3674static bfd_boolean 3675on_needed_list (const char *soname, 3676 struct bfd_link_needed_list *needed, 3677 struct bfd_link_needed_list *stop) 3678{ 3679 struct bfd_link_needed_list *look; 3680 for (look = needed; look != stop; look = look->next) 3681 if (strcmp (soname, look->name) == 0 3682 && ((elf_dyn_lib_class (look->by) & DYN_AS_NEEDED) == 0 3683 /* If needed by a library that itself is not directly 3684 needed, recursively check whether that library is 3685 indirectly needed. Since we add DT_NEEDED entries to 3686 the end of the list, library dependencies appear after 3687 the library. Therefore search prior to the current 3688 LOOK, preventing possible infinite recursion. */ 3689 || on_needed_list (elf_dt_name (look->by), needed, look))) 3690 return TRUE; 3691 3692 return FALSE; 3693} 3694 3695/* Sort symbol by value, section, size, and type. */ 3696static int 3697elf_sort_symbol (const void *arg1, const void *arg2) 3698{ 3699 const struct elf_link_hash_entry *h1; 3700 const struct elf_link_hash_entry *h2; 3701 bfd_signed_vma vdiff; 3702 int sdiff; 3703 const char *n1; 3704 const char *n2; 3705 3706 h1 = *(const struct elf_link_hash_entry **) arg1; 3707 h2 = *(const struct elf_link_hash_entry **) arg2; 3708 vdiff = h1->root.u.def.value - h2->root.u.def.value; 3709 if (vdiff != 0) 3710 return vdiff > 0 ? 1 : -1; 3711 3712 sdiff = h1->root.u.def.section->id - h2->root.u.def.section->id; 3713 if (sdiff != 0) 3714 return sdiff; 3715 3716 /* Sort so that sized symbols are selected over zero size symbols. */ 3717 vdiff = h1->size - h2->size; 3718 if (vdiff != 0) 3719 return vdiff > 0 ? 1 : -1; 3720 3721 /* Sort so that STT_OBJECT is selected over STT_NOTYPE. */ 3722 if (h1->type != h2->type) 3723 return h1->type - h2->type; 3724 3725 /* If symbols are properly sized and typed, and multiple strong 3726 aliases are not defined in a shared library by the user we 3727 shouldn't get here. Unfortunately linker script symbols like 3728 __bss_start sometimes match a user symbol defined at the start of 3729 .bss without proper size and type. We'd like to preference the 3730 user symbol over reserved system symbols. Sort on leading 3731 underscores. */ 3732 n1 = h1->root.root.string; 3733 n2 = h2->root.root.string; 3734 while (*n1 == *n2) 3735 { 3736 if (*n1 == 0) 3737 break; 3738 ++n1; 3739 ++n2; 3740 } 3741 if (*n1 == '_') 3742 return -1; 3743 if (*n2 == '_') 3744 return 1; 3745 3746 /* Final sort on name selects user symbols like '_u' over reserved 3747 system symbols like '_Z' and also will avoid qsort instability. */ 3748 return *n1 - *n2; 3749} 3750 3751/* This function is used to adjust offsets into .dynstr for 3752 dynamic symbols. This is called via elf_link_hash_traverse. */ 3753 3754static bfd_boolean 3755elf_adjust_dynstr_offsets (struct elf_link_hash_entry *h, void *data) 3756{ 3757 struct elf_strtab_hash *dynstr = (struct elf_strtab_hash *) data; 3758 3759 if (h->dynindx != -1) 3760 h->dynstr_index = _bfd_elf_strtab_offset (dynstr, h->dynstr_index); 3761 return TRUE; 3762} 3763 3764/* Assign string offsets in .dynstr, update all structures referencing 3765 them. */ 3766 3767static bfd_boolean 3768elf_finalize_dynstr (bfd *output_bfd, struct bfd_link_info *info) 3769{ 3770 struct elf_link_hash_table *hash_table = elf_hash_table (info); 3771 struct elf_link_local_dynamic_entry *entry; 3772 struct elf_strtab_hash *dynstr = hash_table->dynstr; 3773 bfd *dynobj = hash_table->dynobj; 3774 asection *sdyn; 3775 bfd_size_type size; 3776 const struct elf_backend_data *bed; 3777 bfd_byte *extdyn; 3778 3779 _bfd_elf_strtab_finalize (dynstr); 3780 size = _bfd_elf_strtab_size (dynstr); 3781 3782 bed = get_elf_backend_data (dynobj); 3783 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 3784 BFD_ASSERT (sdyn != NULL); 3785 3786 /* Update all .dynamic entries referencing .dynstr strings. */ 3787 for (extdyn = sdyn->contents; 3788 extdyn < sdyn->contents + sdyn->size; 3789 extdyn += bed->s->sizeof_dyn) 3790 { 3791 Elf_Internal_Dyn dyn; 3792 3793 bed->s->swap_dyn_in (dynobj, extdyn, &dyn); 3794 switch (dyn.d_tag) 3795 { 3796 case DT_STRSZ: 3797 dyn.d_un.d_val = size; 3798 break; 3799 case DT_NEEDED: 3800 case DT_SONAME: 3801 case DT_RPATH: 3802 case DT_RUNPATH: 3803 case DT_FILTER: 3804 case DT_AUXILIARY: 3805 case DT_AUDIT: 3806 case DT_DEPAUDIT: 3807 dyn.d_un.d_val = _bfd_elf_strtab_offset (dynstr, dyn.d_un.d_val); 3808 break; 3809 default: 3810 continue; 3811 } 3812 bed->s->swap_dyn_out (dynobj, &dyn, extdyn); 3813 } 3814 3815 /* Now update local dynamic symbols. */ 3816 for (entry = hash_table->dynlocal; entry ; entry = entry->next) 3817 entry->isym.st_name = _bfd_elf_strtab_offset (dynstr, 3818 entry->isym.st_name); 3819 3820 /* And the rest of dynamic symbols. */ 3821 elf_link_hash_traverse (hash_table, elf_adjust_dynstr_offsets, dynstr); 3822 3823 /* Adjust version definitions. */ 3824 if (elf_tdata (output_bfd)->cverdefs) 3825 { 3826 asection *s; 3827 bfd_byte *p; 3828 size_t i; 3829 Elf_Internal_Verdef def; 3830 Elf_Internal_Verdaux defaux; 3831 3832 s = bfd_get_linker_section (dynobj, ".gnu.version_d"); 3833 p = s->contents; 3834 do 3835 { 3836 _bfd_elf_swap_verdef_in (output_bfd, (Elf_External_Verdef *) p, 3837 &def); 3838 p += sizeof (Elf_External_Verdef); 3839 if (def.vd_aux != sizeof (Elf_External_Verdef)) 3840 continue; 3841 for (i = 0; i < def.vd_cnt; ++i) 3842 { 3843 _bfd_elf_swap_verdaux_in (output_bfd, 3844 (Elf_External_Verdaux *) p, &defaux); 3845 defaux.vda_name = _bfd_elf_strtab_offset (dynstr, 3846 defaux.vda_name); 3847 _bfd_elf_swap_verdaux_out (output_bfd, 3848 &defaux, (Elf_External_Verdaux *) p); 3849 p += sizeof (Elf_External_Verdaux); 3850 } 3851 } 3852 while (def.vd_next); 3853 } 3854 3855 /* Adjust version references. */ 3856 if (elf_tdata (output_bfd)->verref) 3857 { 3858 asection *s; 3859 bfd_byte *p; 3860 size_t i; 3861 Elf_Internal_Verneed need; 3862 Elf_Internal_Vernaux needaux; 3863 3864 s = bfd_get_linker_section (dynobj, ".gnu.version_r"); 3865 p = s->contents; 3866 do 3867 { 3868 _bfd_elf_swap_verneed_in (output_bfd, (Elf_External_Verneed *) p, 3869 &need); 3870 need.vn_file = _bfd_elf_strtab_offset (dynstr, need.vn_file); 3871 _bfd_elf_swap_verneed_out (output_bfd, &need, 3872 (Elf_External_Verneed *) p); 3873 p += sizeof (Elf_External_Verneed); 3874 for (i = 0; i < need.vn_cnt; ++i) 3875 { 3876 _bfd_elf_swap_vernaux_in (output_bfd, 3877 (Elf_External_Vernaux *) p, &needaux); 3878 needaux.vna_name = _bfd_elf_strtab_offset (dynstr, 3879 needaux.vna_name); 3880 _bfd_elf_swap_vernaux_out (output_bfd, 3881 &needaux, 3882 (Elf_External_Vernaux *) p); 3883 p += sizeof (Elf_External_Vernaux); 3884 } 3885 } 3886 while (need.vn_next); 3887 } 3888 3889 return TRUE; 3890} 3891 3892/* Return TRUE iff relocations for INPUT are compatible with OUTPUT. 3893 The default is to only match when the INPUT and OUTPUT are exactly 3894 the same target. */ 3895 3896bfd_boolean 3897_bfd_elf_default_relocs_compatible (const bfd_target *input, 3898 const bfd_target *output) 3899{ 3900 return input == output; 3901} 3902 3903/* Return TRUE iff relocations for INPUT are compatible with OUTPUT. 3904 This version is used when different targets for the same architecture 3905 are virtually identical. */ 3906 3907bfd_boolean 3908_bfd_elf_relocs_compatible (const bfd_target *input, 3909 const bfd_target *output) 3910{ 3911 const struct elf_backend_data *obed, *ibed; 3912 3913 if (input == output) 3914 return TRUE; 3915 3916 ibed = xvec_get_elf_backend_data (input); 3917 obed = xvec_get_elf_backend_data (output); 3918 3919 if (ibed->arch != obed->arch) 3920 return FALSE; 3921 3922 /* If both backends are using this function, deem them compatible. */ 3923 return ibed->relocs_compatible == obed->relocs_compatible; 3924} 3925 3926/* Make a special call to the linker "notice" function to tell it that 3927 we are about to handle an as-needed lib, or have finished 3928 processing the lib. */ 3929 3930bfd_boolean 3931_bfd_elf_notice_as_needed (bfd *ibfd, 3932 struct bfd_link_info *info, 3933 enum notice_asneeded_action act) 3934{ 3935 return (*info->callbacks->notice) (info, NULL, NULL, ibfd, NULL, act, 0); 3936} 3937 3938/* Check relocations an ELF object file. */ 3939 3940bfd_boolean 3941_bfd_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info) 3942{ 3943 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 3944 struct elf_link_hash_table *htab = elf_hash_table (info); 3945 3946 /* If this object is the same format as the output object, and it is 3947 not a shared library, then let the backend look through the 3948 relocs. 3949 3950 This is required to build global offset table entries and to 3951 arrange for dynamic relocs. It is not required for the 3952 particular common case of linking non PIC code, even when linking 3953 against shared libraries, but unfortunately there is no way of 3954 knowing whether an object file has been compiled PIC or not. 3955 Looking through the relocs is not particularly time consuming. 3956 The problem is that we must either (1) keep the relocs in memory, 3957 which causes the linker to require additional runtime memory or 3958 (2) read the relocs twice from the input file, which wastes time. 3959 This would be a good case for using mmap. 3960 3961 I have no idea how to handle linking PIC code into a file of a 3962 different format. It probably can't be done. */ 3963 if ((abfd->flags & DYNAMIC) == 0 3964 && is_elf_hash_table (htab) 3965 && bed->check_relocs != NULL 3966 && elf_object_id (abfd) == elf_hash_table_id (htab) 3967 && (*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec)) 3968 { 3969 asection *o; 3970 3971 for (o = abfd->sections; o != NULL; o = o->next) 3972 { 3973 Elf_Internal_Rela *internal_relocs; 3974 bfd_boolean ok; 3975 3976 /* Don't check relocations in excluded sections. Don't do 3977 anything special with non-loaded, non-alloced sections. 3978 In particular, any relocs in such sections should not 3979 affect GOT and PLT reference counting (ie. we don't 3980 allow them to create GOT or PLT entries), there's no 3981 possibility or desire to optimize TLS relocs, and 3982 there's not much point in propagating relocs to shared 3983 libs that the dynamic linker won't relocate. */ 3984 if ((o->flags & SEC_ALLOC) == 0 3985 || (o->flags & SEC_RELOC) == 0 3986 || (o->flags & SEC_EXCLUDE) != 0 3987 || o->reloc_count == 0 3988 || ((info->strip == strip_all || info->strip == strip_debugger) 3989 && (o->flags & SEC_DEBUGGING) != 0) 3990 || bfd_is_abs_section (o->output_section)) 3991 continue; 3992 3993 internal_relocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL, 3994 info->keep_memory); 3995 if (internal_relocs == NULL) 3996 return FALSE; 3997 3998 ok = (*bed->check_relocs) (abfd, info, o, internal_relocs); 3999 4000 if (elf_section_data (o)->relocs != internal_relocs) 4001 free (internal_relocs); 4002 4003 if (! ok) 4004 return FALSE; 4005 } 4006 } 4007 4008 return TRUE; 4009} 4010 4011/* Add symbols from an ELF object file to the linker hash table. */ 4012 4013static bfd_boolean 4014elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info) 4015{ 4016 Elf_Internal_Ehdr *ehdr; 4017 Elf_Internal_Shdr *hdr; 4018 size_t symcount; 4019 size_t extsymcount; 4020 size_t extsymoff; 4021 struct elf_link_hash_entry **sym_hash; 4022 bfd_boolean dynamic; 4023 Elf_External_Versym *extversym = NULL; 4024 Elf_External_Versym *extversym_end = NULL; 4025 Elf_External_Versym *ever; 4026 struct elf_link_hash_entry *weaks; 4027 struct elf_link_hash_entry **nondeflt_vers = NULL; 4028 size_t nondeflt_vers_cnt = 0; 4029 Elf_Internal_Sym *isymbuf = NULL; 4030 Elf_Internal_Sym *isym; 4031 Elf_Internal_Sym *isymend; 4032 const struct elf_backend_data *bed; 4033 bfd_boolean add_needed; 4034 struct elf_link_hash_table *htab; 4035 void *alloc_mark = NULL; 4036 struct bfd_hash_entry **old_table = NULL; 4037 unsigned int old_size = 0; 4038 unsigned int old_count = 0; 4039 void *old_tab = NULL; 4040 void *old_ent; 4041 struct bfd_link_hash_entry *old_undefs = NULL; 4042 struct bfd_link_hash_entry *old_undefs_tail = NULL; 4043 void *old_strtab = NULL; 4044 size_t tabsize = 0; 4045 asection *s; 4046 bfd_boolean just_syms; 4047 4048 htab = elf_hash_table (info); 4049 bed = get_elf_backend_data (abfd); 4050 4051 if ((abfd->flags & DYNAMIC) == 0) 4052 dynamic = FALSE; 4053 else 4054 { 4055 dynamic = TRUE; 4056 4057 /* You can't use -r against a dynamic object. Also, there's no 4058 hope of using a dynamic object which does not exactly match 4059 the format of the output file. */ 4060 if (bfd_link_relocatable (info) 4061 || !is_elf_hash_table (htab) 4062 || info->output_bfd->xvec != abfd->xvec) 4063 { 4064 if (bfd_link_relocatable (info)) 4065 bfd_set_error (bfd_error_invalid_operation); 4066 else 4067 bfd_set_error (bfd_error_wrong_format); 4068 goto error_return; 4069 } 4070 } 4071 4072 ehdr = elf_elfheader (abfd); 4073 if (info->warn_alternate_em 4074 && bed->elf_machine_code != ehdr->e_machine 4075 && ((bed->elf_machine_alt1 != 0 4076 && ehdr->e_machine == bed->elf_machine_alt1) 4077 || (bed->elf_machine_alt2 != 0 4078 && ehdr->e_machine == bed->elf_machine_alt2))) 4079 _bfd_error_handler 4080 /* xgettext:c-format */ 4081 (_("alternate ELF machine code found (%d) in %pB, expecting %d"), 4082 ehdr->e_machine, abfd, bed->elf_machine_code); 4083 4084 /* As a GNU extension, any input sections which are named 4085 .gnu.warning.SYMBOL are treated as warning symbols for the given 4086 symbol. This differs from .gnu.warning sections, which generate 4087 warnings when they are included in an output file. */ 4088 /* PR 12761: Also generate this warning when building shared libraries. */ 4089 for (s = abfd->sections; s != NULL; s = s->next) 4090 { 4091 const char *name; 4092 4093 name = bfd_section_name (s); 4094 if (CONST_STRNEQ (name, ".gnu.warning.")) 4095 { 4096 char *msg; 4097 bfd_size_type sz; 4098 4099 name += sizeof ".gnu.warning." - 1; 4100 4101 /* If this is a shared object, then look up the symbol 4102 in the hash table. If it is there, and it is already 4103 been defined, then we will not be using the entry 4104 from this shared object, so we don't need to warn. 4105 FIXME: If we see the definition in a regular object 4106 later on, we will warn, but we shouldn't. The only 4107 fix is to keep track of what warnings we are supposed 4108 to emit, and then handle them all at the end of the 4109 link. */ 4110 if (dynamic) 4111 { 4112 struct elf_link_hash_entry *h; 4113 4114 h = elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE); 4115 4116 /* FIXME: What about bfd_link_hash_common? */ 4117 if (h != NULL 4118 && (h->root.type == bfd_link_hash_defined 4119 || h->root.type == bfd_link_hash_defweak)) 4120 continue; 4121 } 4122 4123 sz = s->size; 4124 msg = (char *) bfd_alloc (abfd, sz + 1); 4125 if (msg == NULL) 4126 goto error_return; 4127 4128 if (! bfd_get_section_contents (abfd, s, msg, 0, sz)) 4129 goto error_return; 4130 4131 msg[sz] = '\0'; 4132 4133 if (! (_bfd_generic_link_add_one_symbol 4134 (info, abfd, name, BSF_WARNING, s, 0, msg, 4135 FALSE, bed->collect, NULL))) 4136 goto error_return; 4137 4138 if (bfd_link_executable (info)) 4139 { 4140 /* Clobber the section size so that the warning does 4141 not get copied into the output file. */ 4142 s->size = 0; 4143 4144 /* Also set SEC_EXCLUDE, so that symbols defined in 4145 the warning section don't get copied to the output. */ 4146 s->flags |= SEC_EXCLUDE; 4147 } 4148 } 4149 } 4150 4151 just_syms = ((s = abfd->sections) != NULL 4152 && s->sec_info_type == SEC_INFO_TYPE_JUST_SYMS); 4153 4154 add_needed = TRUE; 4155 if (! dynamic) 4156 { 4157 /* If we are creating a shared library, create all the dynamic 4158 sections immediately. We need to attach them to something, 4159 so we attach them to this BFD, provided it is the right 4160 format and is not from ld --just-symbols. Always create the 4161 dynamic sections for -E/--dynamic-list. FIXME: If there 4162 are no input BFD's of the same format as the output, we can't 4163 make a shared library. */ 4164 if (!just_syms 4165 && (bfd_link_pic (info) 4166 || (!bfd_link_relocatable (info) 4167 && info->nointerp 4168 && (info->export_dynamic || info->dynamic))) 4169 && is_elf_hash_table (htab) 4170 && info->output_bfd->xvec == abfd->xvec 4171 && !htab->dynamic_sections_created) 4172 { 4173 if (! _bfd_elf_link_create_dynamic_sections (abfd, info)) 4174 goto error_return; 4175 } 4176 } 4177 else if (!is_elf_hash_table (htab)) 4178 goto error_return; 4179 else 4180 { 4181 const char *soname = NULL; 4182 char *audit = NULL; 4183 struct bfd_link_needed_list *rpath = NULL, *runpath = NULL; 4184 const Elf_Internal_Phdr *phdr; 4185 struct elf_link_loaded_list *loaded_lib; 4186 4187 /* ld --just-symbols and dynamic objects don't mix very well. 4188 ld shouldn't allow it. */ 4189 if (just_syms) 4190 abort (); 4191 4192 /* If this dynamic lib was specified on the command line with 4193 --as-needed in effect, then we don't want to add a DT_NEEDED 4194 tag unless the lib is actually used. Similary for libs brought 4195 in by another lib's DT_NEEDED. When --no-add-needed is used 4196 on a dynamic lib, we don't want to add a DT_NEEDED entry for 4197 any dynamic library in DT_NEEDED tags in the dynamic lib at 4198 all. */ 4199 add_needed = (elf_dyn_lib_class (abfd) 4200 & (DYN_AS_NEEDED | DYN_DT_NEEDED 4201 | DYN_NO_NEEDED)) == 0; 4202 4203 s = bfd_get_section_by_name (abfd, ".dynamic"); 4204 if (s != NULL) 4205 { 4206 bfd_byte *dynbuf; 4207 bfd_byte *extdyn; 4208 unsigned int elfsec; 4209 unsigned long shlink; 4210 4211 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf)) 4212 { 4213 error_free_dyn: 4214 free (dynbuf); 4215 goto error_return; 4216 } 4217 4218 elfsec = _bfd_elf_section_from_bfd_section (abfd, s); 4219 if (elfsec == SHN_BAD) 4220 goto error_free_dyn; 4221 shlink = elf_elfsections (abfd)[elfsec]->sh_link; 4222 4223 for (extdyn = dynbuf; 4224 extdyn <= dynbuf + s->size - bed->s->sizeof_dyn; 4225 extdyn += bed->s->sizeof_dyn) 4226 { 4227 Elf_Internal_Dyn dyn; 4228 4229 bed->s->swap_dyn_in (abfd, extdyn, &dyn); 4230 if (dyn.d_tag == DT_SONAME) 4231 { 4232 unsigned int tagv = dyn.d_un.d_val; 4233 soname = bfd_elf_string_from_elf_section (abfd, shlink, tagv); 4234 if (soname == NULL) 4235 goto error_free_dyn; 4236 } 4237 if (dyn.d_tag == DT_NEEDED) 4238 { 4239 struct bfd_link_needed_list *n, **pn; 4240 char *fnm, *anm; 4241 unsigned int tagv = dyn.d_un.d_val; 4242 size_t amt = sizeof (struct bfd_link_needed_list); 4243 4244 n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt); 4245 fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv); 4246 if (n == NULL || fnm == NULL) 4247 goto error_free_dyn; 4248 amt = strlen (fnm) + 1; 4249 anm = (char *) bfd_alloc (abfd, amt); 4250 if (anm == NULL) 4251 goto error_free_dyn; 4252 memcpy (anm, fnm, amt); 4253 n->name = anm; 4254 n->by = abfd; 4255 n->next = NULL; 4256 for (pn = &htab->needed; *pn != NULL; pn = &(*pn)->next) 4257 ; 4258 *pn = n; 4259 } 4260 if (dyn.d_tag == DT_RUNPATH) 4261 { 4262 struct bfd_link_needed_list *n, **pn; 4263 char *fnm, *anm; 4264 unsigned int tagv = dyn.d_un.d_val; 4265 size_t amt = sizeof (struct bfd_link_needed_list); 4266 4267 n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt); 4268 fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv); 4269 if (n == NULL || fnm == NULL) 4270 goto error_free_dyn; 4271 amt = strlen (fnm) + 1; 4272 anm = (char *) bfd_alloc (abfd, amt); 4273 if (anm == NULL) 4274 goto error_free_dyn; 4275 memcpy (anm, fnm, amt); 4276 n->name = anm; 4277 n->by = abfd; 4278 n->next = NULL; 4279 for (pn = & runpath; 4280 *pn != NULL; 4281 pn = &(*pn)->next) 4282 ; 4283 *pn = n; 4284 } 4285 /* Ignore DT_RPATH if we have seen DT_RUNPATH. */ 4286 if (!runpath && dyn.d_tag == DT_RPATH) 4287 { 4288 struct bfd_link_needed_list *n, **pn; 4289 char *fnm, *anm; 4290 unsigned int tagv = dyn.d_un.d_val; 4291 size_t amt = sizeof (struct bfd_link_needed_list); 4292 4293 n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt); 4294 fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv); 4295 if (n == NULL || fnm == NULL) 4296 goto error_free_dyn; 4297 amt = strlen (fnm) + 1; 4298 anm = (char *) bfd_alloc (abfd, amt); 4299 if (anm == NULL) 4300 goto error_free_dyn; 4301 memcpy (anm, fnm, amt); 4302 n->name = anm; 4303 n->by = abfd; 4304 n->next = NULL; 4305 for (pn = & rpath; 4306 *pn != NULL; 4307 pn = &(*pn)->next) 4308 ; 4309 *pn = n; 4310 } 4311 if (dyn.d_tag == DT_AUDIT) 4312 { 4313 unsigned int tagv = dyn.d_un.d_val; 4314 audit = bfd_elf_string_from_elf_section (abfd, shlink, tagv); 4315 } 4316 } 4317 4318 free (dynbuf); 4319 } 4320 4321 /* DT_RUNPATH overrides DT_RPATH. Do _NOT_ bfd_release, as that 4322 frees all more recently bfd_alloc'd blocks as well. */ 4323 if (runpath) 4324 rpath = runpath; 4325 4326 if (rpath) 4327 { 4328 struct bfd_link_needed_list **pn; 4329 for (pn = &htab->runpath; *pn != NULL; pn = &(*pn)->next) 4330 ; 4331 *pn = rpath; 4332 } 4333 4334 /* If we have a PT_GNU_RELRO program header, mark as read-only 4335 all sections contained fully therein. This makes relro 4336 shared library sections appear as they will at run-time. */ 4337 phdr = elf_tdata (abfd)->phdr + elf_elfheader (abfd)->e_phnum; 4338 while (phdr-- > elf_tdata (abfd)->phdr) 4339 if (phdr->p_type == PT_GNU_RELRO) 4340 { 4341 for (s = abfd->sections; s != NULL; s = s->next) 4342 { 4343 unsigned int opb = bfd_octets_per_byte (abfd, s); 4344 4345 if ((s->flags & SEC_ALLOC) != 0 4346 && s->vma * opb >= phdr->p_vaddr 4347 && s->vma * opb + s->size <= phdr->p_vaddr + phdr->p_memsz) 4348 s->flags |= SEC_READONLY; 4349 } 4350 break; 4351 } 4352 4353 /* We do not want to include any of the sections in a dynamic 4354 object in the output file. We hack by simply clobbering the 4355 list of sections in the BFD. This could be handled more 4356 cleanly by, say, a new section flag; the existing 4357 SEC_NEVER_LOAD flag is not the one we want, because that one 4358 still implies that the section takes up space in the output 4359 file. */ 4360 bfd_section_list_clear (abfd); 4361 4362 /* Find the name to use in a DT_NEEDED entry that refers to this 4363 object. If the object has a DT_SONAME entry, we use it. 4364 Otherwise, if the generic linker stuck something in 4365 elf_dt_name, we use that. Otherwise, we just use the file 4366 name. */ 4367 if (soname == NULL || *soname == '\0') 4368 { 4369 soname = elf_dt_name (abfd); 4370 if (soname == NULL || *soname == '\0') 4371 soname = bfd_get_filename (abfd); 4372 } 4373 4374 /* Save the SONAME because sometimes the linker emulation code 4375 will need to know it. */ 4376 elf_dt_name (abfd) = soname; 4377 4378 /* If we have already included this dynamic object in the 4379 link, just ignore it. There is no reason to include a 4380 particular dynamic object more than once. */ 4381 for (loaded_lib = htab->dyn_loaded; 4382 loaded_lib != NULL; 4383 loaded_lib = loaded_lib->next) 4384 { 4385 if (strcmp (elf_dt_name (loaded_lib->abfd), soname) == 0) 4386 return TRUE; 4387 } 4388 4389 /* Create dynamic sections for backends that require that be done 4390 before setup_gnu_properties. */ 4391 if (add_needed 4392 && !_bfd_elf_link_create_dynamic_sections (abfd, info)) 4393 return FALSE; 4394 4395 /* Save the DT_AUDIT entry for the linker emulation code. */ 4396 elf_dt_audit (abfd) = audit; 4397 } 4398 4399 /* If this is a dynamic object, we always link against the .dynsym 4400 symbol table, not the .symtab symbol table. The dynamic linker 4401 will only see the .dynsym symbol table, so there is no reason to 4402 look at .symtab for a dynamic object. */ 4403 4404 if (! dynamic || elf_dynsymtab (abfd) == 0) 4405 hdr = &elf_tdata (abfd)->symtab_hdr; 4406 else 4407 hdr = &elf_tdata (abfd)->dynsymtab_hdr; 4408 4409 symcount = hdr->sh_size / bed->s->sizeof_sym; 4410 4411 /* The sh_info field of the symtab header tells us where the 4412 external symbols start. We don't care about the local symbols at 4413 this point. */ 4414 if (elf_bad_symtab (abfd)) 4415 { 4416 extsymcount = symcount; 4417 extsymoff = 0; 4418 } 4419 else 4420 { 4421 extsymcount = symcount - hdr->sh_info; 4422 extsymoff = hdr->sh_info; 4423 } 4424 4425 sym_hash = elf_sym_hashes (abfd); 4426 if (extsymcount != 0) 4427 { 4428 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff, 4429 NULL, NULL, NULL); 4430 if (isymbuf == NULL) 4431 goto error_return; 4432 4433 if (sym_hash == NULL) 4434 { 4435 /* We store a pointer to the hash table entry for each 4436 external symbol. */ 4437 size_t amt = extsymcount * sizeof (struct elf_link_hash_entry *); 4438 sym_hash = (struct elf_link_hash_entry **) bfd_zalloc (abfd, amt); 4439 if (sym_hash == NULL) 4440 goto error_free_sym; 4441 elf_sym_hashes (abfd) = sym_hash; 4442 } 4443 } 4444 4445 if (dynamic) 4446 { 4447 /* Read in any version definitions. */ 4448 if (!_bfd_elf_slurp_version_tables (abfd, 4449 info->default_imported_symver)) 4450 goto error_free_sym; 4451 4452 /* Read in the symbol versions, but don't bother to convert them 4453 to internal format. */ 4454 if (elf_dynversym (abfd) != 0) 4455 { 4456 Elf_Internal_Shdr *versymhdr = &elf_tdata (abfd)->dynversym_hdr; 4457 bfd_size_type amt = versymhdr->sh_size; 4458 4459 if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0) 4460 goto error_free_sym; 4461 extversym = (Elf_External_Versym *) 4462 _bfd_malloc_and_read (abfd, amt, amt); 4463 if (extversym == NULL) 4464 goto error_free_sym; 4465 extversym_end = extversym + amt / sizeof (*extversym); 4466 } 4467 } 4468 4469 /* If we are loading an as-needed shared lib, save the symbol table 4470 state before we start adding symbols. If the lib turns out 4471 to be unneeded, restore the state. */ 4472 if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0) 4473 { 4474 unsigned int i; 4475 size_t entsize; 4476 4477 for (entsize = 0, i = 0; i < htab->root.table.size; i++) 4478 { 4479 struct bfd_hash_entry *p; 4480 struct elf_link_hash_entry *h; 4481 4482 for (p = htab->root.table.table[i]; p != NULL; p = p->next) 4483 { 4484 h = (struct elf_link_hash_entry *) p; 4485 entsize += htab->root.table.entsize; 4486 if (h->root.type == bfd_link_hash_warning) 4487 { 4488 entsize += htab->root.table.entsize; 4489 h = (struct elf_link_hash_entry *) h->root.u.i.link; 4490 } 4491 if (h->root.type == bfd_link_hash_common) 4492 entsize += sizeof (*h->root.u.c.p); 4493 } 4494 } 4495 4496 tabsize = htab->root.table.size * sizeof (struct bfd_hash_entry *); 4497 old_tab = bfd_malloc (tabsize + entsize); 4498 if (old_tab == NULL) 4499 goto error_free_vers; 4500 4501 /* Remember the current objalloc pointer, so that all mem for 4502 symbols added can later be reclaimed. */ 4503 alloc_mark = bfd_hash_allocate (&htab->root.table, 1); 4504 if (alloc_mark == NULL) 4505 goto error_free_vers; 4506 4507 /* Make a special call to the linker "notice" function to 4508 tell it that we are about to handle an as-needed lib. */ 4509 if (!(*bed->notice_as_needed) (abfd, info, notice_as_needed)) 4510 goto error_free_vers; 4511 4512 /* Clone the symbol table. Remember some pointers into the 4513 symbol table, and dynamic symbol count. */ 4514 old_ent = (char *) old_tab + tabsize; 4515 memcpy (old_tab, htab->root.table.table, tabsize); 4516 old_undefs = htab->root.undefs; 4517 old_undefs_tail = htab->root.undefs_tail; 4518 old_table = htab->root.table.table; 4519 old_size = htab->root.table.size; 4520 old_count = htab->root.table.count; 4521 old_strtab = NULL; 4522 if (htab->dynstr != NULL) 4523 { 4524 old_strtab = _bfd_elf_strtab_save (htab->dynstr); 4525 if (old_strtab == NULL) 4526 goto error_free_vers; 4527 } 4528 4529 for (i = 0; i < htab->root.table.size; i++) 4530 { 4531 struct bfd_hash_entry *p; 4532 struct elf_link_hash_entry *h; 4533 4534 for (p = htab->root.table.table[i]; p != NULL; p = p->next) 4535 { 4536 h = (struct elf_link_hash_entry *) p; 4537 memcpy (old_ent, h, htab->root.table.entsize); 4538 old_ent = (char *) old_ent + htab->root.table.entsize; 4539 if (h->root.type == bfd_link_hash_warning) 4540 { 4541 h = (struct elf_link_hash_entry *) h->root.u.i.link; 4542 memcpy (old_ent, h, htab->root.table.entsize); 4543 old_ent = (char *) old_ent + htab->root.table.entsize; 4544 } 4545 if (h->root.type == bfd_link_hash_common) 4546 { 4547 memcpy (old_ent, h->root.u.c.p, sizeof (*h->root.u.c.p)); 4548 old_ent = (char *) old_ent + sizeof (*h->root.u.c.p); 4549 } 4550 } 4551 } 4552 } 4553 4554 weaks = NULL; 4555 if (extversym == NULL) 4556 ever = NULL; 4557 else if (extversym + extsymoff < extversym_end) 4558 ever = extversym + extsymoff; 4559 else 4560 { 4561 /* xgettext:c-format */ 4562 _bfd_error_handler (_("%pB: invalid version offset %lx (max %lx)"), 4563 abfd, (long) extsymoff, 4564 (long) (extversym_end - extversym) / sizeof (* extversym)); 4565 bfd_set_error (bfd_error_bad_value); 4566 goto error_free_vers; 4567 } 4568 4569 if (!bfd_link_relocatable (info) 4570 && abfd->lto_slim_object) 4571 { 4572 _bfd_error_handler 4573 (_("%pB: plugin needed to handle lto object"), abfd); 4574 } 4575 4576 for (isym = isymbuf, isymend = isymbuf + extsymcount; 4577 isym < isymend; 4578 isym++, sym_hash++, ever = (ever != NULL ? ever + 1 : NULL)) 4579 { 4580 int bind; 4581 bfd_vma value; 4582 asection *sec, *new_sec; 4583 flagword flags; 4584 const char *name; 4585 struct elf_link_hash_entry *h; 4586 struct elf_link_hash_entry *hi; 4587 bfd_boolean definition; 4588 bfd_boolean size_change_ok; 4589 bfd_boolean type_change_ok; 4590 bfd_boolean new_weak; 4591 bfd_boolean old_weak; 4592 bfd *override; 4593 bfd_boolean common; 4594 bfd_boolean discarded; 4595 unsigned int old_alignment; 4596 unsigned int shindex; 4597 bfd *old_bfd; 4598 bfd_boolean matched; 4599 4600 override = NULL; 4601 4602 flags = BSF_NO_FLAGS; 4603 sec = NULL; 4604 value = isym->st_value; 4605 common = bed->common_definition (isym); 4606 if (common && info->inhibit_common_definition) 4607 { 4608 /* Treat common symbol as undefined for --no-define-common. */ 4609 isym->st_shndx = SHN_UNDEF; 4610 common = FALSE; 4611 } 4612 discarded = FALSE; 4613 4614 bind = ELF_ST_BIND (isym->st_info); 4615 switch (bind) 4616 { 4617 case STB_LOCAL: 4618 /* This should be impossible, since ELF requires that all 4619 global symbols follow all local symbols, and that sh_info 4620 point to the first global symbol. Unfortunately, Irix 5 4621 screws this up. */ 4622 if (elf_bad_symtab (abfd)) 4623 continue; 4624 4625 /* If we aren't prepared to handle locals within the globals 4626 then we'll likely segfault on a NULL symbol hash if the 4627 symbol is ever referenced in relocations. */ 4628 shindex = elf_elfheader (abfd)->e_shstrndx; 4629 name = bfd_elf_string_from_elf_section (abfd, shindex, hdr->sh_name); 4630 _bfd_error_handler (_("%pB: %s local symbol at index %lu" 4631 " (>= sh_info of %lu)"), 4632 abfd, name, (long) (isym - isymbuf + extsymoff), 4633 (long) extsymoff); 4634 4635 /* Dynamic object relocations are not processed by ld, so 4636 ld won't run into the problem mentioned above. */ 4637 if (dynamic) 4638 continue; 4639 bfd_set_error (bfd_error_bad_value); 4640 goto error_free_vers; 4641 4642 case STB_GLOBAL: 4643 if (isym->st_shndx != SHN_UNDEF && !common) 4644 flags = BSF_GLOBAL; 4645 break; 4646 4647 case STB_WEAK: 4648 flags = BSF_WEAK; 4649 break; 4650 4651 case STB_GNU_UNIQUE: 4652 flags = BSF_GNU_UNIQUE; 4653 break; 4654 4655 default: 4656 /* Leave it up to the processor backend. */ 4657 break; 4658 } 4659 4660 if (isym->st_shndx == SHN_UNDEF) 4661 sec = bfd_und_section_ptr; 4662 else if (isym->st_shndx == SHN_ABS) 4663 sec = bfd_abs_section_ptr; 4664 else if (isym->st_shndx == SHN_COMMON) 4665 { 4666 sec = bfd_com_section_ptr; 4667 /* What ELF calls the size we call the value. What ELF 4668 calls the value we call the alignment. */ 4669 value = isym->st_size; 4670 } 4671 else 4672 { 4673 sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 4674 if (sec == NULL) 4675 sec = bfd_abs_section_ptr; 4676 else if (discarded_section (sec)) 4677 { 4678 /* Symbols from discarded section are undefined. We keep 4679 its visibility. */ 4680 sec = bfd_und_section_ptr; 4681 discarded = TRUE; 4682 isym->st_shndx = SHN_UNDEF; 4683 } 4684 else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0) 4685 value -= sec->vma; 4686 } 4687 4688 name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link, 4689 isym->st_name); 4690 if (name == NULL) 4691 goto error_free_vers; 4692 4693 if (isym->st_shndx == SHN_COMMON 4694 && (abfd->flags & BFD_PLUGIN) != 0) 4695 { 4696 asection *xc = bfd_get_section_by_name (abfd, "COMMON"); 4697 4698 if (xc == NULL) 4699 { 4700 flagword sflags = (SEC_ALLOC | SEC_IS_COMMON | SEC_KEEP 4701 | SEC_EXCLUDE); 4702 xc = bfd_make_section_with_flags (abfd, "COMMON", sflags); 4703 if (xc == NULL) 4704 goto error_free_vers; 4705 } 4706 sec = xc; 4707 } 4708 else if (isym->st_shndx == SHN_COMMON 4709 && ELF_ST_TYPE (isym->st_info) == STT_TLS 4710 && !bfd_link_relocatable (info)) 4711 { 4712 asection *tcomm = bfd_get_section_by_name (abfd, ".tcommon"); 4713 4714 if (tcomm == NULL) 4715 { 4716 flagword sflags = (SEC_ALLOC | SEC_THREAD_LOCAL | SEC_IS_COMMON 4717 | SEC_LINKER_CREATED); 4718 tcomm = bfd_make_section_with_flags (abfd, ".tcommon", sflags); 4719 if (tcomm == NULL) 4720 goto error_free_vers; 4721 } 4722 sec = tcomm; 4723 } 4724 else if (bed->elf_add_symbol_hook) 4725 { 4726 if (! (*bed->elf_add_symbol_hook) (abfd, info, isym, &name, &flags, 4727 &sec, &value)) 4728 goto error_free_vers; 4729 4730 /* The hook function sets the name to NULL if this symbol 4731 should be skipped for some reason. */ 4732 if (name == NULL) 4733 continue; 4734 } 4735 4736 /* Sanity check that all possibilities were handled. */ 4737 if (sec == NULL) 4738 abort (); 4739 4740 /* Silently discard TLS symbols from --just-syms. There's 4741 no way to combine a static TLS block with a new TLS block 4742 for this executable. */ 4743 if (ELF_ST_TYPE (isym->st_info) == STT_TLS 4744 && sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS) 4745 continue; 4746 4747 if (bfd_is_und_section (sec) 4748 || bfd_is_com_section (sec)) 4749 definition = FALSE; 4750 else 4751 definition = TRUE; 4752 4753 size_change_ok = FALSE; 4754 type_change_ok = bed->type_change_ok; 4755 old_weak = FALSE; 4756 matched = FALSE; 4757 old_alignment = 0; 4758 old_bfd = NULL; 4759 new_sec = sec; 4760 4761 if (is_elf_hash_table (htab)) 4762 { 4763 Elf_Internal_Versym iver; 4764 unsigned int vernum = 0; 4765 bfd_boolean skip; 4766 4767 if (ever == NULL) 4768 { 4769 if (info->default_imported_symver) 4770 /* Use the default symbol version created earlier. */ 4771 iver.vs_vers = elf_tdata (abfd)->cverdefs; 4772 else 4773 iver.vs_vers = 0; 4774 } 4775 else if (ever >= extversym_end) 4776 { 4777 /* xgettext:c-format */ 4778 _bfd_error_handler (_("%pB: not enough version information"), 4779 abfd); 4780 bfd_set_error (bfd_error_bad_value); 4781 goto error_free_vers; 4782 } 4783 else 4784 _bfd_elf_swap_versym_in (abfd, ever, &iver); 4785 4786 vernum = iver.vs_vers & VERSYM_VERSION; 4787 4788 /* If this is a hidden symbol, or if it is not version 4789 1, we append the version name to the symbol name. 4790 However, we do not modify a non-hidden absolute symbol 4791 if it is not a function, because it might be the version 4792 symbol itself. FIXME: What if it isn't? */ 4793 if ((iver.vs_vers & VERSYM_HIDDEN) != 0 4794 || (vernum > 1 4795 && (!bfd_is_abs_section (sec) 4796 || bed->is_function_type (ELF_ST_TYPE (isym->st_info))))) 4797 { 4798 const char *verstr; 4799 size_t namelen, verlen, newlen; 4800 char *newname, *p; 4801 4802 if (isym->st_shndx != SHN_UNDEF) 4803 { 4804 if (vernum > elf_tdata (abfd)->cverdefs) 4805 verstr = NULL; 4806 else if (vernum > 1) 4807 verstr = 4808 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename; 4809 else 4810 verstr = ""; 4811 4812 if (verstr == NULL) 4813 { 4814 _bfd_error_handler 4815 /* xgettext:c-format */ 4816 (_("%pB: %s: invalid version %u (max %d)"), 4817 abfd, name, vernum, 4818 elf_tdata (abfd)->cverdefs); 4819 bfd_set_error (bfd_error_bad_value); 4820 goto error_free_vers; 4821 } 4822 } 4823 else 4824 { 4825 /* We cannot simply test for the number of 4826 entries in the VERNEED section since the 4827 numbers for the needed versions do not start 4828 at 0. */ 4829 Elf_Internal_Verneed *t; 4830 4831 verstr = NULL; 4832 for (t = elf_tdata (abfd)->verref; 4833 t != NULL; 4834 t = t->vn_nextref) 4835 { 4836 Elf_Internal_Vernaux *a; 4837 4838 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr) 4839 { 4840 if (a->vna_other == vernum) 4841 { 4842 verstr = a->vna_nodename; 4843 break; 4844 } 4845 } 4846 if (a != NULL) 4847 break; 4848 } 4849 if (verstr == NULL) 4850 { 4851 _bfd_error_handler 4852 /* xgettext:c-format */ 4853 (_("%pB: %s: invalid needed version %d"), 4854 abfd, name, vernum); 4855 bfd_set_error (bfd_error_bad_value); 4856 goto error_free_vers; 4857 } 4858 } 4859 4860 namelen = strlen (name); 4861 verlen = strlen (verstr); 4862 newlen = namelen + verlen + 2; 4863 if ((iver.vs_vers & VERSYM_HIDDEN) == 0 4864 && isym->st_shndx != SHN_UNDEF) 4865 ++newlen; 4866 4867 newname = (char *) bfd_hash_allocate (&htab->root.table, newlen); 4868 if (newname == NULL) 4869 goto error_free_vers; 4870 memcpy (newname, name, namelen); 4871 p = newname + namelen; 4872 *p++ = ELF_VER_CHR; 4873 /* If this is a defined non-hidden version symbol, 4874 we add another @ to the name. This indicates the 4875 default version of the symbol. */ 4876 if ((iver.vs_vers & VERSYM_HIDDEN) == 0 4877 && isym->st_shndx != SHN_UNDEF) 4878 *p++ = ELF_VER_CHR; 4879 memcpy (p, verstr, verlen + 1); 4880 4881 name = newname; 4882 } 4883 4884 /* If this symbol has default visibility and the user has 4885 requested we not re-export it, then mark it as hidden. */ 4886 if (!bfd_is_und_section (sec) 4887 && !dynamic 4888 && abfd->no_export 4889 && ELF_ST_VISIBILITY (isym->st_other) != STV_INTERNAL) 4890 isym->st_other = (STV_HIDDEN 4891 | (isym->st_other & ~ELF_ST_VISIBILITY (-1))); 4892 4893 if (!_bfd_elf_merge_symbol (abfd, info, name, isym, &sec, &value, 4894 sym_hash, &old_bfd, &old_weak, 4895 &old_alignment, &skip, &override, 4896 &type_change_ok, &size_change_ok, 4897 &matched)) 4898 goto error_free_vers; 4899 4900 if (skip) 4901 continue; 4902 4903 /* Override a definition only if the new symbol matches the 4904 existing one. */ 4905 if (override && matched) 4906 definition = FALSE; 4907 4908 h = *sym_hash; 4909 while (h->root.type == bfd_link_hash_indirect 4910 || h->root.type == bfd_link_hash_warning) 4911 h = (struct elf_link_hash_entry *) h->root.u.i.link; 4912 4913 if (elf_tdata (abfd)->verdef != NULL 4914 && vernum > 1 4915 && definition) 4916 h->verinfo.verdef = &elf_tdata (abfd)->verdef[vernum - 1]; 4917 } 4918 4919 if (! (_bfd_generic_link_add_one_symbol 4920 (info, override ? override : abfd, name, flags, sec, value, 4921 NULL, FALSE, bed->collect, 4922 (struct bfd_link_hash_entry **) sym_hash))) 4923 goto error_free_vers; 4924 4925 h = *sym_hash; 4926 /* We need to make sure that indirect symbol dynamic flags are 4927 updated. */ 4928 hi = h; 4929 while (h->root.type == bfd_link_hash_indirect 4930 || h->root.type == bfd_link_hash_warning) 4931 h = (struct elf_link_hash_entry *) h->root.u.i.link; 4932 4933 /* Setting the index to -3 tells elf_link_output_extsym that 4934 this symbol is defined in a discarded section. */ 4935 if (discarded) 4936 h->indx = -3; 4937 4938 *sym_hash = h; 4939 4940 new_weak = (flags & BSF_WEAK) != 0; 4941 if (dynamic 4942 && definition 4943 && new_weak 4944 && !bed->is_function_type (ELF_ST_TYPE (isym->st_info)) 4945 && is_elf_hash_table (htab) 4946 && h->u.alias == NULL) 4947 { 4948 /* Keep a list of all weak defined non function symbols from 4949 a dynamic object, using the alias field. Later in this 4950 function we will set the alias field to the correct 4951 value. We only put non-function symbols from dynamic 4952 objects on this list, because that happens to be the only 4953 time we need to know the normal symbol corresponding to a 4954 weak symbol, and the information is time consuming to 4955 figure out. If the alias field is not already NULL, 4956 then this symbol was already defined by some previous 4957 dynamic object, and we will be using that previous 4958 definition anyhow. */ 4959 4960 h->u.alias = weaks; 4961 weaks = h; 4962 } 4963 4964 /* Set the alignment of a common symbol. */ 4965 if ((common || bfd_is_com_section (sec)) 4966 && h->root.type == bfd_link_hash_common) 4967 { 4968 unsigned int align; 4969 4970 if (common) 4971 align = bfd_log2 (isym->st_value); 4972 else 4973 { 4974 /* The new symbol is a common symbol in a shared object. 4975 We need to get the alignment from the section. */ 4976 align = new_sec->alignment_power; 4977 } 4978 if (align > old_alignment) 4979 h->root.u.c.p->alignment_power = align; 4980 else 4981 h->root.u.c.p->alignment_power = old_alignment; 4982 } 4983 4984 if (is_elf_hash_table (htab)) 4985 { 4986 /* Set a flag in the hash table entry indicating the type of 4987 reference or definition we just found. A dynamic symbol 4988 is one which is referenced or defined by both a regular 4989 object and a shared object. */ 4990 bfd_boolean dynsym = FALSE; 4991 4992 if (! dynamic) 4993 { 4994 if (! definition) 4995 { 4996 h->ref_regular = 1; 4997 if (bind != STB_WEAK) 4998 h->ref_regular_nonweak = 1; 4999 } 5000 else 5001 { 5002 h->def_regular = 1; 5003 if (h->def_dynamic) 5004 { 5005 h->def_dynamic = 0; 5006 h->ref_dynamic = 1; 5007 } 5008 } 5009 5010 /* If the indirect symbol has been forced local, don't 5011 make the real symbol dynamic. */ 5012 if ((h == hi || !hi->forced_local) 5013 && (bfd_link_dll (info) 5014 || h->def_dynamic 5015 || h->ref_dynamic)) 5016 dynsym = TRUE; 5017 } 5018 else 5019 { 5020 if (! definition) 5021 { 5022 h->ref_dynamic = 1; 5023 hi->ref_dynamic = 1; 5024 } 5025 else 5026 { 5027 h->def_dynamic = 1; 5028 hi->def_dynamic = 1; 5029 } 5030 5031 /* If the indirect symbol has been forced local, don't 5032 make the real symbol dynamic. */ 5033 if ((h == hi || !hi->forced_local) 5034 && (h->def_regular 5035 || h->ref_regular 5036 || (h->is_weakalias 5037 && weakdef (h)->dynindx != -1))) 5038 dynsym = TRUE; 5039 } 5040 5041 /* Check to see if we need to add an indirect symbol for 5042 the default name. */ 5043 if (definition 5044 || (!override && h->root.type == bfd_link_hash_common)) 5045 if (!_bfd_elf_add_default_symbol (abfd, info, h, name, isym, 5046 sec, value, &old_bfd, &dynsym)) 5047 goto error_free_vers; 5048 5049 /* Check the alignment when a common symbol is involved. This 5050 can change when a common symbol is overridden by a normal 5051 definition or a common symbol is ignored due to the old 5052 normal definition. We need to make sure the maximum 5053 alignment is maintained. */ 5054 if ((old_alignment || common) 5055 && h->root.type != bfd_link_hash_common) 5056 { 5057 unsigned int common_align; 5058 unsigned int normal_align; 5059 unsigned int symbol_align; 5060 bfd *normal_bfd; 5061 bfd *common_bfd; 5062 5063 BFD_ASSERT (h->root.type == bfd_link_hash_defined 5064 || h->root.type == bfd_link_hash_defweak); 5065 5066 symbol_align = ffs (h->root.u.def.value) - 1; 5067 if (h->root.u.def.section->owner != NULL 5068 && (h->root.u.def.section->owner->flags 5069 & (DYNAMIC | BFD_PLUGIN)) == 0) 5070 { 5071 normal_align = h->root.u.def.section->alignment_power; 5072 if (normal_align > symbol_align) 5073 normal_align = symbol_align; 5074 } 5075 else 5076 normal_align = symbol_align; 5077 5078 if (old_alignment) 5079 { 5080 common_align = old_alignment; 5081 common_bfd = old_bfd; 5082 normal_bfd = abfd; 5083 } 5084 else 5085 { 5086 common_align = bfd_log2 (isym->st_value); 5087 common_bfd = abfd; 5088 normal_bfd = old_bfd; 5089 } 5090 5091 if (normal_align < common_align) 5092 { 5093 /* PR binutils/2735 */ 5094 if (normal_bfd == NULL) 5095 _bfd_error_handler 5096 /* xgettext:c-format */ 5097 (_("warning: alignment %u of common symbol `%s' in %pB is" 5098 " greater than the alignment (%u) of its section %pA"), 5099 1 << common_align, name, common_bfd, 5100 1 << normal_align, h->root.u.def.section); 5101 else 5102 _bfd_error_handler 5103 /* xgettext:c-format */ 5104 (_("warning: alignment %u of symbol `%s' in %pB" 5105 " is smaller than %u in %pB"), 5106 1 << normal_align, name, normal_bfd, 5107 1 << common_align, common_bfd); 5108 } 5109 } 5110 5111 /* Remember the symbol size if it isn't undefined. */ 5112 if (isym->st_size != 0 5113 && isym->st_shndx != SHN_UNDEF 5114 && (definition || h->size == 0)) 5115 { 5116 if (h->size != 0 5117 && h->size != isym->st_size 5118 && ! size_change_ok) 5119 _bfd_error_handler 5120 /* xgettext:c-format */ 5121 (_("warning: size of symbol `%s' changed" 5122 " from %" PRIu64 " in %pB to %" PRIu64 " in %pB"), 5123 name, (uint64_t) h->size, old_bfd, 5124 (uint64_t) isym->st_size, abfd); 5125 5126 h->size = isym->st_size; 5127 } 5128 5129 /* If this is a common symbol, then we always want H->SIZE 5130 to be the size of the common symbol. The code just above 5131 won't fix the size if a common symbol becomes larger. We 5132 don't warn about a size change here, because that is 5133 covered by --warn-common. Allow changes between different 5134 function types. */ 5135 if (h->root.type == bfd_link_hash_common) 5136 h->size = h->root.u.c.size; 5137 5138 if (ELF_ST_TYPE (isym->st_info) != STT_NOTYPE 5139 && ((definition && !new_weak) 5140 || (old_weak && h->root.type == bfd_link_hash_common) 5141 || h->type == STT_NOTYPE)) 5142 { 5143 unsigned int type = ELF_ST_TYPE (isym->st_info); 5144 5145 /* Turn an IFUNC symbol from a DSO into a normal FUNC 5146 symbol. */ 5147 if (type == STT_GNU_IFUNC 5148 && (abfd->flags & DYNAMIC) != 0) 5149 type = STT_FUNC; 5150 5151 if (h->type != type) 5152 { 5153 if (h->type != STT_NOTYPE && ! type_change_ok) 5154 /* xgettext:c-format */ 5155 _bfd_error_handler 5156 (_("warning: type of symbol `%s' changed" 5157 " from %d to %d in %pB"), 5158 name, h->type, type, abfd); 5159 5160 h->type = type; 5161 } 5162 } 5163 5164 /* Merge st_other field. */ 5165 elf_merge_st_other (abfd, h, isym, sec, definition, dynamic); 5166 5167 /* We don't want to make debug symbol dynamic. */ 5168 if (definition 5169 && (sec->flags & SEC_DEBUGGING) 5170 && !bfd_link_relocatable (info)) 5171 dynsym = FALSE; 5172 5173 if (definition) 5174 { 5175 h->target_internal = isym->st_target_internal; 5176 h->unique_global = (flags & BSF_GNU_UNIQUE) != 0; 5177 } 5178 5179 if (definition && !dynamic) 5180 { 5181 char *p = strchr (name, ELF_VER_CHR); 5182 if (p != NULL && p[1] != ELF_VER_CHR) 5183 { 5184 /* Queue non-default versions so that .symver x, x@FOO 5185 aliases can be checked. */ 5186 if (!nondeflt_vers) 5187 { 5188 size_t amt = ((isymend - isym + 1) 5189 * sizeof (struct elf_link_hash_entry *)); 5190 nondeflt_vers 5191 = (struct elf_link_hash_entry **) bfd_malloc (amt); 5192 if (!nondeflt_vers) 5193 goto error_free_vers; 5194 } 5195 nondeflt_vers[nondeflt_vers_cnt++] = h; 5196 } 5197 } 5198 5199 if (dynsym && (abfd->flags & BFD_PLUGIN) == 0 && h->dynindx == -1) 5200 { 5201 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 5202 goto error_free_vers; 5203 if (h->is_weakalias 5204 && weakdef (h)->dynindx == -1) 5205 { 5206 if (!bfd_elf_link_record_dynamic_symbol (info, weakdef (h))) 5207 goto error_free_vers; 5208 } 5209 } 5210 else if (h->dynindx != -1) 5211 /* If the symbol already has a dynamic index, but 5212 visibility says it should not be visible, turn it into 5213 a local symbol. */ 5214 switch (ELF_ST_VISIBILITY (h->other)) 5215 { 5216 case STV_INTERNAL: 5217 case STV_HIDDEN: 5218 (*bed->elf_backend_hide_symbol) (info, h, TRUE); 5219 dynsym = FALSE; 5220 break; 5221 } 5222 5223 if (!add_needed 5224 && matched 5225 && definition 5226 && ((dynsym 5227 && h->ref_regular_nonweak) 5228 || (h->ref_dynamic_nonweak 5229 && (elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0 5230 && !on_needed_list (elf_dt_name (abfd), 5231 htab->needed, NULL)))) 5232 { 5233 const char *soname = elf_dt_name (abfd); 5234 5235 info->callbacks->minfo ("%!", soname, old_bfd, 5236 h->root.root.string); 5237 5238 /* A symbol from a library loaded via DT_NEEDED of some 5239 other library is referenced by a regular object. 5240 Add a DT_NEEDED entry for it. Issue an error if 5241 --no-add-needed is used and the reference was not 5242 a weak one. */ 5243 if (old_bfd != NULL 5244 && (elf_dyn_lib_class (abfd) & DYN_NO_NEEDED) != 0) 5245 { 5246 _bfd_error_handler 5247 /* xgettext:c-format */ 5248 (_("%pB: undefined reference to symbol '%s'"), 5249 old_bfd, name); 5250 bfd_set_error (bfd_error_missing_dso); 5251 goto error_free_vers; 5252 } 5253 5254 elf_dyn_lib_class (abfd) = (enum dynamic_lib_link_class) 5255 (elf_dyn_lib_class (abfd) & ~DYN_AS_NEEDED); 5256 5257 /* Create dynamic sections for backends that require 5258 that be done before setup_gnu_properties. */ 5259 if (!_bfd_elf_link_create_dynamic_sections (abfd, info)) 5260 return FALSE; 5261 add_needed = TRUE; 5262 } 5263 } 5264 } 5265 5266 if (info->lto_plugin_active 5267 && !bfd_link_relocatable (info) 5268 && (abfd->flags & BFD_PLUGIN) == 0 5269 && !just_syms 5270 && extsymcount) 5271 { 5272 int r_sym_shift; 5273 5274 if (bed->s->arch_size == 32) 5275 r_sym_shift = 8; 5276 else 5277 r_sym_shift = 32; 5278 5279 /* If linker plugin is enabled, set non_ir_ref_regular on symbols 5280 referenced in regular objects so that linker plugin will get 5281 the correct symbol resolution. */ 5282 5283 sym_hash = elf_sym_hashes (abfd); 5284 for (s = abfd->sections; s != NULL; s = s->next) 5285 { 5286 Elf_Internal_Rela *internal_relocs; 5287 Elf_Internal_Rela *rel, *relend; 5288 5289 /* Don't check relocations in excluded sections. */ 5290 if ((s->flags & SEC_RELOC) == 0 5291 || s->reloc_count == 0 5292 || (s->flags & SEC_EXCLUDE) != 0 5293 || ((info->strip == strip_all 5294 || info->strip == strip_debugger) 5295 && (s->flags & SEC_DEBUGGING) != 0)) 5296 continue; 5297 5298 internal_relocs = _bfd_elf_link_read_relocs (abfd, s, NULL, 5299 NULL, 5300 info->keep_memory); 5301 if (internal_relocs == NULL) 5302 goto error_free_vers; 5303 5304 rel = internal_relocs; 5305 relend = rel + s->reloc_count; 5306 for ( ; rel < relend; rel++) 5307 { 5308 unsigned long r_symndx = rel->r_info >> r_sym_shift; 5309 struct elf_link_hash_entry *h; 5310 5311 /* Skip local symbols. */ 5312 if (r_symndx < extsymoff) 5313 continue; 5314 5315 h = sym_hash[r_symndx - extsymoff]; 5316 if (h != NULL) 5317 h->root.non_ir_ref_regular = 1; 5318 } 5319 5320 if (elf_section_data (s)->relocs != internal_relocs) 5321 free (internal_relocs); 5322 } 5323 } 5324 5325 free (extversym); 5326 extversym = NULL; 5327 free (isymbuf); 5328 isymbuf = NULL; 5329 5330 if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0) 5331 { 5332 unsigned int i; 5333 5334 /* Restore the symbol table. */ 5335 old_ent = (char *) old_tab + tabsize; 5336 memset (elf_sym_hashes (abfd), 0, 5337 extsymcount * sizeof (struct elf_link_hash_entry *)); 5338 htab->root.table.table = old_table; 5339 htab->root.table.size = old_size; 5340 htab->root.table.count = old_count; 5341 memcpy (htab->root.table.table, old_tab, tabsize); 5342 htab->root.undefs = old_undefs; 5343 htab->root.undefs_tail = old_undefs_tail; 5344 if (htab->dynstr != NULL) 5345 _bfd_elf_strtab_restore (htab->dynstr, old_strtab); 5346 free (old_strtab); 5347 old_strtab = NULL; 5348 for (i = 0; i < htab->root.table.size; i++) 5349 { 5350 struct bfd_hash_entry *p; 5351 struct elf_link_hash_entry *h; 5352 unsigned int non_ir_ref_dynamic; 5353 5354 for (p = htab->root.table.table[i]; p != NULL; p = p->next) 5355 { 5356 /* Preserve non_ir_ref_dynamic so that this symbol 5357 will be exported when the dynamic lib becomes needed 5358 in the second pass. */ 5359 h = (struct elf_link_hash_entry *) p; 5360 if (h->root.type == bfd_link_hash_warning) 5361 h = (struct elf_link_hash_entry *) h->root.u.i.link; 5362 non_ir_ref_dynamic = h->root.non_ir_ref_dynamic; 5363 5364 h = (struct elf_link_hash_entry *) p; 5365 memcpy (h, old_ent, htab->root.table.entsize); 5366 old_ent = (char *) old_ent + htab->root.table.entsize; 5367 if (h->root.type == bfd_link_hash_warning) 5368 { 5369 h = (struct elf_link_hash_entry *) h->root.u.i.link; 5370 memcpy (h, old_ent, htab->root.table.entsize); 5371 old_ent = (char *) old_ent + htab->root.table.entsize; 5372 } 5373 if (h->root.type == bfd_link_hash_common) 5374 { 5375 memcpy (h->root.u.c.p, old_ent, sizeof (*h->root.u.c.p)); 5376 old_ent = (char *) old_ent + sizeof (*h->root.u.c.p); 5377 } 5378 h->root.non_ir_ref_dynamic = non_ir_ref_dynamic; 5379 } 5380 } 5381 5382 /* Make a special call to the linker "notice" function to 5383 tell it that symbols added for crefs may need to be removed. */ 5384 if (!(*bed->notice_as_needed) (abfd, info, notice_not_needed)) 5385 goto error_free_vers; 5386 5387 free (old_tab); 5388 objalloc_free_block ((struct objalloc *) htab->root.table.memory, 5389 alloc_mark); 5390 free (nondeflt_vers); 5391 return TRUE; 5392 } 5393 5394 if (old_tab != NULL) 5395 { 5396 if (!(*bed->notice_as_needed) (abfd, info, notice_needed)) 5397 goto error_free_vers; 5398 free (old_tab); 5399 old_tab = NULL; 5400 } 5401 5402 /* Now that all the symbols from this input file are created, if 5403 not performing a relocatable link, handle .symver foo, foo@BAR 5404 such that any relocs against foo become foo@BAR. */ 5405 if (!bfd_link_relocatable (info) && nondeflt_vers != NULL) 5406 { 5407 size_t cnt, symidx; 5408 5409 for (cnt = 0; cnt < nondeflt_vers_cnt; ++cnt) 5410 { 5411 struct elf_link_hash_entry *h = nondeflt_vers[cnt], *hi; 5412 char *shortname, *p; 5413 size_t amt; 5414 5415 p = strchr (h->root.root.string, ELF_VER_CHR); 5416 if (p == NULL 5417 || (h->root.type != bfd_link_hash_defined 5418 && h->root.type != bfd_link_hash_defweak)) 5419 continue; 5420 5421 amt = p - h->root.root.string; 5422 shortname = (char *) bfd_malloc (amt + 1); 5423 if (!shortname) 5424 goto error_free_vers; 5425 memcpy (shortname, h->root.root.string, amt); 5426 shortname[amt] = '\0'; 5427 5428 hi = (struct elf_link_hash_entry *) 5429 bfd_link_hash_lookup (&htab->root, shortname, 5430 FALSE, FALSE, FALSE); 5431 if (hi != NULL 5432 && hi->root.type == h->root.type 5433 && hi->root.u.def.value == h->root.u.def.value 5434 && hi->root.u.def.section == h->root.u.def.section) 5435 { 5436 (*bed->elf_backend_hide_symbol) (info, hi, TRUE); 5437 hi->root.type = bfd_link_hash_indirect; 5438 hi->root.u.i.link = (struct bfd_link_hash_entry *) h; 5439 (*bed->elf_backend_copy_indirect_symbol) (info, h, hi); 5440 sym_hash = elf_sym_hashes (abfd); 5441 if (sym_hash) 5442 for (symidx = 0; symidx < extsymcount; ++symidx) 5443 if (sym_hash[symidx] == hi) 5444 { 5445 sym_hash[symidx] = h; 5446 break; 5447 } 5448 } 5449 free (shortname); 5450 } 5451 free (nondeflt_vers); 5452 nondeflt_vers = NULL; 5453 } 5454 5455 /* Now set the alias field correctly for all the weak defined 5456 symbols we found. The only way to do this is to search all the 5457 symbols. Since we only need the information for non functions in 5458 dynamic objects, that's the only time we actually put anything on 5459 the list WEAKS. We need this information so that if a regular 5460 object refers to a symbol defined weakly in a dynamic object, the 5461 real symbol in the dynamic object is also put in the dynamic 5462 symbols; we also must arrange for both symbols to point to the 5463 same memory location. We could handle the general case of symbol 5464 aliasing, but a general symbol alias can only be generated in 5465 assembler code, handling it correctly would be very time 5466 consuming, and other ELF linkers don't handle general aliasing 5467 either. */ 5468 if (weaks != NULL) 5469 { 5470 struct elf_link_hash_entry **hpp; 5471 struct elf_link_hash_entry **hppend; 5472 struct elf_link_hash_entry **sorted_sym_hash; 5473 struct elf_link_hash_entry *h; 5474 size_t sym_count, amt; 5475 5476 /* Since we have to search the whole symbol list for each weak 5477 defined symbol, search time for N weak defined symbols will be 5478 O(N^2). Binary search will cut it down to O(NlogN). */ 5479 amt = extsymcount * sizeof (*sorted_sym_hash); 5480 sorted_sym_hash = bfd_malloc (amt); 5481 if (sorted_sym_hash == NULL) 5482 goto error_return; 5483 sym_hash = sorted_sym_hash; 5484 hpp = elf_sym_hashes (abfd); 5485 hppend = hpp + extsymcount; 5486 sym_count = 0; 5487 for (; hpp < hppend; hpp++) 5488 { 5489 h = *hpp; 5490 if (h != NULL 5491 && h->root.type == bfd_link_hash_defined 5492 && !bed->is_function_type (h->type)) 5493 { 5494 *sym_hash = h; 5495 sym_hash++; 5496 sym_count++; 5497 } 5498 } 5499 5500 qsort (sorted_sym_hash, sym_count, sizeof (*sorted_sym_hash), 5501 elf_sort_symbol); 5502 5503 while (weaks != NULL) 5504 { 5505 struct elf_link_hash_entry *hlook; 5506 asection *slook; 5507 bfd_vma vlook; 5508 size_t i, j, idx = 0; 5509 5510 hlook = weaks; 5511 weaks = hlook->u.alias; 5512 hlook->u.alias = NULL; 5513 5514 if (hlook->root.type != bfd_link_hash_defined 5515 && hlook->root.type != bfd_link_hash_defweak) 5516 continue; 5517 5518 slook = hlook->root.u.def.section; 5519 vlook = hlook->root.u.def.value; 5520 5521 i = 0; 5522 j = sym_count; 5523 while (i != j) 5524 { 5525 bfd_signed_vma vdiff; 5526 idx = (i + j) / 2; 5527 h = sorted_sym_hash[idx]; 5528 vdiff = vlook - h->root.u.def.value; 5529 if (vdiff < 0) 5530 j = idx; 5531 else if (vdiff > 0) 5532 i = idx + 1; 5533 else 5534 { 5535 int sdiff = slook->id - h->root.u.def.section->id; 5536 if (sdiff < 0) 5537 j = idx; 5538 else if (sdiff > 0) 5539 i = idx + 1; 5540 else 5541 break; 5542 } 5543 } 5544 5545 /* We didn't find a value/section match. */ 5546 if (i == j) 5547 continue; 5548 5549 /* With multiple aliases, or when the weak symbol is already 5550 strongly defined, we have multiple matching symbols and 5551 the binary search above may land on any of them. Step 5552 one past the matching symbol(s). */ 5553 while (++idx != j) 5554 { 5555 h = sorted_sym_hash[idx]; 5556 if (h->root.u.def.section != slook 5557 || h->root.u.def.value != vlook) 5558 break; 5559 } 5560 5561 /* Now look back over the aliases. Since we sorted by size 5562 as well as value and section, we'll choose the one with 5563 the largest size. */ 5564 while (idx-- != i) 5565 { 5566 h = sorted_sym_hash[idx]; 5567 5568 /* Stop if value or section doesn't match. */ 5569 if (h->root.u.def.section != slook 5570 || h->root.u.def.value != vlook) 5571 break; 5572 else if (h != hlook) 5573 { 5574 struct elf_link_hash_entry *t; 5575 5576 hlook->u.alias = h; 5577 hlook->is_weakalias = 1; 5578 t = h; 5579 if (t->u.alias != NULL) 5580 while (t->u.alias != h) 5581 t = t->u.alias; 5582 t->u.alias = hlook; 5583 5584 /* If the weak definition is in the list of dynamic 5585 symbols, make sure the real definition is put 5586 there as well. */ 5587 if (hlook->dynindx != -1 && h->dynindx == -1) 5588 { 5589 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 5590 { 5591 err_free_sym_hash: 5592 free (sorted_sym_hash); 5593 goto error_return; 5594 } 5595 } 5596 5597 /* If the real definition is in the list of dynamic 5598 symbols, make sure the weak definition is put 5599 there as well. If we don't do this, then the 5600 dynamic loader might not merge the entries for the 5601 real definition and the weak definition. */ 5602 if (h->dynindx != -1 && hlook->dynindx == -1) 5603 { 5604 if (! bfd_elf_link_record_dynamic_symbol (info, hlook)) 5605 goto err_free_sym_hash; 5606 } 5607 break; 5608 } 5609 } 5610 } 5611 5612 free (sorted_sym_hash); 5613 } 5614 5615 if (bed->check_directives 5616 && !(*bed->check_directives) (abfd, info)) 5617 return FALSE; 5618 5619 /* If this is a non-traditional link, try to optimize the handling 5620 of the .stab/.stabstr sections. */ 5621 if (! dynamic 5622 && ! info->traditional_format 5623 && is_elf_hash_table (htab) 5624 && (info->strip != strip_all && info->strip != strip_debugger)) 5625 { 5626 asection *stabstr; 5627 5628 stabstr = bfd_get_section_by_name (abfd, ".stabstr"); 5629 if (stabstr != NULL) 5630 { 5631 bfd_size_type string_offset = 0; 5632 asection *stab; 5633 5634 for (stab = abfd->sections; stab; stab = stab->next) 5635 if (CONST_STRNEQ (stab->name, ".stab") 5636 && (!stab->name[5] || 5637 (stab->name[5] == '.' && ISDIGIT (stab->name[6]))) 5638 && (stab->flags & SEC_MERGE) == 0 5639 && !bfd_is_abs_section (stab->output_section)) 5640 { 5641 struct bfd_elf_section_data *secdata; 5642 5643 secdata = elf_section_data (stab); 5644 if (! _bfd_link_section_stabs (abfd, &htab->stab_info, stab, 5645 stabstr, &secdata->sec_info, 5646 &string_offset)) 5647 goto error_return; 5648 if (secdata->sec_info) 5649 stab->sec_info_type = SEC_INFO_TYPE_STABS; 5650 } 5651 } 5652 } 5653 5654 if (dynamic && add_needed) 5655 { 5656 /* Add this bfd to the loaded list. */ 5657 struct elf_link_loaded_list *n; 5658 5659 n = (struct elf_link_loaded_list *) bfd_alloc (abfd, sizeof (*n)); 5660 if (n == NULL) 5661 goto error_return; 5662 n->abfd = abfd; 5663 n->next = htab->dyn_loaded; 5664 htab->dyn_loaded = n; 5665 } 5666 if (dynamic && !add_needed 5667 && (elf_dyn_lib_class (abfd) & DYN_DT_NEEDED) != 0) 5668 elf_dyn_lib_class (abfd) |= DYN_NO_NEEDED; 5669 5670 return TRUE; 5671 5672 error_free_vers: 5673 free (old_tab); 5674 free (old_strtab); 5675 free (nondeflt_vers); 5676 free (extversym); 5677 error_free_sym: 5678 free (isymbuf); 5679 error_return: 5680 return FALSE; 5681} 5682 5683/* Return the linker hash table entry of a symbol that might be 5684 satisfied by an archive symbol. Return -1 on error. */ 5685 5686struct elf_link_hash_entry * 5687_bfd_elf_archive_symbol_lookup (bfd *abfd, 5688 struct bfd_link_info *info, 5689 const char *name) 5690{ 5691 struct elf_link_hash_entry *h; 5692 char *p, *copy; 5693 size_t len, first; 5694 5695 h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, TRUE); 5696 if (h != NULL) 5697 return h; 5698 5699 /* If this is a default version (the name contains @@), look up the 5700 symbol again with only one `@' as well as without the version. 5701 The effect is that references to the symbol with and without the 5702 version will be matched by the default symbol in the archive. */ 5703 5704 p = strchr (name, ELF_VER_CHR); 5705 if (p == NULL || p[1] != ELF_VER_CHR) 5706 return h; 5707 5708 /* First check with only one `@'. */ 5709 len = strlen (name); 5710 copy = (char *) bfd_alloc (abfd, len); 5711 if (copy == NULL) 5712 return (struct elf_link_hash_entry *) -1; 5713 5714 first = p - name + 1; 5715 memcpy (copy, name, first); 5716 memcpy (copy + first, name + first + 1, len - first); 5717 5718 h = elf_link_hash_lookup (elf_hash_table (info), copy, FALSE, FALSE, TRUE); 5719 if (h == NULL) 5720 { 5721 /* We also need to check references to the symbol without the 5722 version. */ 5723 copy[first - 1] = '\0'; 5724 h = elf_link_hash_lookup (elf_hash_table (info), copy, 5725 FALSE, FALSE, TRUE); 5726 } 5727 5728 bfd_release (abfd, copy); 5729 return h; 5730} 5731 5732/* Add symbols from an ELF archive file to the linker hash table. We 5733 don't use _bfd_generic_link_add_archive_symbols because we need to 5734 handle versioned symbols. 5735 5736 Fortunately, ELF archive handling is simpler than that done by 5737 _bfd_generic_link_add_archive_symbols, which has to allow for a.out 5738 oddities. In ELF, if we find a symbol in the archive map, and the 5739 symbol is currently undefined, we know that we must pull in that 5740 object file. 5741 5742 Unfortunately, we do have to make multiple passes over the symbol 5743 table until nothing further is resolved. */ 5744 5745static bfd_boolean 5746elf_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info) 5747{ 5748 symindex c; 5749 unsigned char *included = NULL; 5750 carsym *symdefs; 5751 bfd_boolean loop; 5752 size_t amt; 5753 const struct elf_backend_data *bed; 5754 struct elf_link_hash_entry * (*archive_symbol_lookup) 5755 (bfd *, struct bfd_link_info *, const char *); 5756 5757 if (! bfd_has_map (abfd)) 5758 { 5759 /* An empty archive is a special case. */ 5760 if (bfd_openr_next_archived_file (abfd, NULL) == NULL) 5761 return TRUE; 5762 bfd_set_error (bfd_error_no_armap); 5763 return FALSE; 5764 } 5765 5766 /* Keep track of all symbols we know to be already defined, and all 5767 files we know to be already included. This is to speed up the 5768 second and subsequent passes. */ 5769 c = bfd_ardata (abfd)->symdef_count; 5770 if (c == 0) 5771 return TRUE; 5772 amt = c * sizeof (*included); 5773 included = (unsigned char *) bfd_zmalloc (amt); 5774 if (included == NULL) 5775 return FALSE; 5776 5777 symdefs = bfd_ardata (abfd)->symdefs; 5778 bed = get_elf_backend_data (abfd); 5779 archive_symbol_lookup = bed->elf_backend_archive_symbol_lookup; 5780 5781 do 5782 { 5783 file_ptr last; 5784 symindex i; 5785 carsym *symdef; 5786 carsym *symdefend; 5787 5788 loop = FALSE; 5789 last = -1; 5790 5791 symdef = symdefs; 5792 symdefend = symdef + c; 5793 for (i = 0; symdef < symdefend; symdef++, i++) 5794 { 5795 struct elf_link_hash_entry *h; 5796 bfd *element; 5797 struct bfd_link_hash_entry *undefs_tail; 5798 symindex mark; 5799 5800 if (included[i]) 5801 continue; 5802 if (symdef->file_offset == last) 5803 { 5804 included[i] = TRUE; 5805 continue; 5806 } 5807 5808 h = archive_symbol_lookup (abfd, info, symdef->name); 5809 if (h == (struct elf_link_hash_entry *) -1) 5810 goto error_return; 5811 5812 if (h == NULL) 5813 continue; 5814 5815 if (h->root.type == bfd_link_hash_undefined) 5816 { 5817 /* If the archive element has already been loaded then one 5818 of the symbols defined by that element might have been 5819 made undefined due to being in a discarded section. */ 5820 if (h->indx == -3) 5821 continue; 5822 } 5823 else if (h->root.type == bfd_link_hash_common) 5824 { 5825 /* We currently have a common symbol. The archive map contains 5826 a reference to this symbol, so we may want to include it. We 5827 only want to include it however, if this archive element 5828 contains a definition of the symbol, not just another common 5829 declaration of it. 5830 5831 Unfortunately some archivers (including GNU ar) will put 5832 declarations of common symbols into their archive maps, as 5833 well as real definitions, so we cannot just go by the archive 5834 map alone. Instead we must read in the element's symbol 5835 table and check that to see what kind of symbol definition 5836 this is. */ 5837 if (! elf_link_is_defined_archive_symbol (abfd, symdef)) 5838 continue; 5839 } 5840 else 5841 { 5842 if (h->root.type != bfd_link_hash_undefweak) 5843 /* Symbol must be defined. Don't check it again. */ 5844 included[i] = TRUE; 5845 continue; 5846 } 5847 5848 /* We need to include this archive member. */ 5849 element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset); 5850 if (element == NULL) 5851 goto error_return; 5852 5853 if (! bfd_check_format (element, bfd_object)) 5854 goto error_return; 5855 5856 undefs_tail = info->hash->undefs_tail; 5857 5858 if (!(*info->callbacks 5859 ->add_archive_element) (info, element, symdef->name, &element)) 5860 continue; 5861 if (!bfd_link_add_symbols (element, info)) 5862 goto error_return; 5863 5864 /* If there are any new undefined symbols, we need to make 5865 another pass through the archive in order to see whether 5866 they can be defined. FIXME: This isn't perfect, because 5867 common symbols wind up on undefs_tail and because an 5868 undefined symbol which is defined later on in this pass 5869 does not require another pass. This isn't a bug, but it 5870 does make the code less efficient than it could be. */ 5871 if (undefs_tail != info->hash->undefs_tail) 5872 loop = TRUE; 5873 5874 /* Look backward to mark all symbols from this object file 5875 which we have already seen in this pass. */ 5876 mark = i; 5877 do 5878 { 5879 included[mark] = TRUE; 5880 if (mark == 0) 5881 break; 5882 --mark; 5883 } 5884 while (symdefs[mark].file_offset == symdef->file_offset); 5885 5886 /* We mark subsequent symbols from this object file as we go 5887 on through the loop. */ 5888 last = symdef->file_offset; 5889 } 5890 } 5891 while (loop); 5892 5893 free (included); 5894 return TRUE; 5895 5896 error_return: 5897 free (included); 5898 return FALSE; 5899} 5900 5901/* Given an ELF BFD, add symbols to the global hash table as 5902 appropriate. */ 5903 5904bfd_boolean 5905bfd_elf_link_add_symbols (bfd *abfd, struct bfd_link_info *info) 5906{ 5907 switch (bfd_get_format (abfd)) 5908 { 5909 case bfd_object: 5910 return elf_link_add_object_symbols (abfd, info); 5911 case bfd_archive: 5912 return elf_link_add_archive_symbols (abfd, info); 5913 default: 5914 bfd_set_error (bfd_error_wrong_format); 5915 return FALSE; 5916 } 5917} 5918 5919struct hash_codes_info 5920{ 5921 unsigned long *hashcodes; 5922 bfd_boolean error; 5923}; 5924 5925/* This function will be called though elf_link_hash_traverse to store 5926 all hash value of the exported symbols in an array. */ 5927 5928static bfd_boolean 5929elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data) 5930{ 5931 struct hash_codes_info *inf = (struct hash_codes_info *) data; 5932 const char *name; 5933 unsigned long ha; 5934 char *alc = NULL; 5935 5936 /* Ignore indirect symbols. These are added by the versioning code. */ 5937 if (h->dynindx == -1) 5938 return TRUE; 5939 5940 name = h->root.root.string; 5941 if (h->versioned >= versioned) 5942 { 5943 char *p = strchr (name, ELF_VER_CHR); 5944 if (p != NULL) 5945 { 5946 alc = (char *) bfd_malloc (p - name + 1); 5947 if (alc == NULL) 5948 { 5949 inf->error = TRUE; 5950 return FALSE; 5951 } 5952 memcpy (alc, name, p - name); 5953 alc[p - name] = '\0'; 5954 name = alc; 5955 } 5956 } 5957 5958 /* Compute the hash value. */ 5959 ha = bfd_elf_hash (name); 5960 5961 /* Store the found hash value in the array given as the argument. */ 5962 *(inf->hashcodes)++ = ha; 5963 5964 /* And store it in the struct so that we can put it in the hash table 5965 later. */ 5966 h->u.elf_hash_value = ha; 5967 5968 free (alc); 5969 return TRUE; 5970} 5971 5972struct collect_gnu_hash_codes 5973{ 5974 bfd *output_bfd; 5975 const struct elf_backend_data *bed; 5976 unsigned long int nsyms; 5977 unsigned long int maskbits; 5978 unsigned long int *hashcodes; 5979 unsigned long int *hashval; 5980 unsigned long int *indx; 5981 unsigned long int *counts; 5982 bfd_vma *bitmask; 5983 bfd_byte *contents; 5984 bfd_size_type xlat; 5985 long int min_dynindx; 5986 unsigned long int bucketcount; 5987 unsigned long int symindx; 5988 long int local_indx; 5989 long int shift1, shift2; 5990 unsigned long int mask; 5991 bfd_boolean error; 5992}; 5993 5994/* This function will be called though elf_link_hash_traverse to store 5995 all hash value of the exported symbols in an array. */ 5996 5997static bfd_boolean 5998elf_collect_gnu_hash_codes (struct elf_link_hash_entry *h, void *data) 5999{ 6000 struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data; 6001 const char *name; 6002 unsigned long ha; 6003 char *alc = NULL; 6004 6005 /* Ignore indirect symbols. These are added by the versioning code. */ 6006 if (h->dynindx == -1) 6007 return TRUE; 6008 6009 /* Ignore also local symbols and undefined symbols. */ 6010 if (! (*s->bed->elf_hash_symbol) (h)) 6011 return TRUE; 6012 6013 name = h->root.root.string; 6014 if (h->versioned >= versioned) 6015 { 6016 char *p = strchr (name, ELF_VER_CHR); 6017 if (p != NULL) 6018 { 6019 alc = (char *) bfd_malloc (p - name + 1); 6020 if (alc == NULL) 6021 { 6022 s->error = TRUE; 6023 return FALSE; 6024 } 6025 memcpy (alc, name, p - name); 6026 alc[p - name] = '\0'; 6027 name = alc; 6028 } 6029 } 6030 6031 /* Compute the hash value. */ 6032 ha = bfd_elf_gnu_hash (name); 6033 6034 /* Store the found hash value in the array for compute_bucket_count, 6035 and also for .dynsym reordering purposes. */ 6036 s->hashcodes[s->nsyms] = ha; 6037 s->hashval[h->dynindx] = ha; 6038 ++s->nsyms; 6039 if (s->min_dynindx < 0 || s->min_dynindx > h->dynindx) 6040 s->min_dynindx = h->dynindx; 6041 6042 free (alc); 6043 return TRUE; 6044} 6045 6046/* This function will be called though elf_link_hash_traverse to do 6047 final dynamic symbol renumbering in case of .gnu.hash. 6048 If using .MIPS.xhash, invoke record_xhash_symbol to add symbol index 6049 to the translation table. */ 6050 6051static bfd_boolean 6052elf_gnu_hash_process_symidx (struct elf_link_hash_entry *h, void *data) 6053{ 6054 struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data; 6055 unsigned long int bucket; 6056 unsigned long int val; 6057 6058 /* Ignore indirect symbols. */ 6059 if (h->dynindx == -1) 6060 return TRUE; 6061 6062 /* Ignore also local symbols and undefined symbols. */ 6063 if (! (*s->bed->elf_hash_symbol) (h)) 6064 { 6065 if (h->dynindx >= s->min_dynindx) 6066 { 6067 if (s->bed->record_xhash_symbol != NULL) 6068 { 6069 (*s->bed->record_xhash_symbol) (h, 0); 6070 s->local_indx++; 6071 } 6072 else 6073 h->dynindx = s->local_indx++; 6074 } 6075 return TRUE; 6076 } 6077 6078 bucket = s->hashval[h->dynindx] % s->bucketcount; 6079 val = (s->hashval[h->dynindx] >> s->shift1) 6080 & ((s->maskbits >> s->shift1) - 1); 6081 s->bitmask[val] |= ((bfd_vma) 1) << (s->hashval[h->dynindx] & s->mask); 6082 s->bitmask[val] 6083 |= ((bfd_vma) 1) << ((s->hashval[h->dynindx] >> s->shift2) & s->mask); 6084 val = s->hashval[h->dynindx] & ~(unsigned long int) 1; 6085 if (s->counts[bucket] == 1) 6086 /* Last element terminates the chain. */ 6087 val |= 1; 6088 bfd_put_32 (s->output_bfd, val, 6089 s->contents + (s->indx[bucket] - s->symindx) * 4); 6090 --s->counts[bucket]; 6091 if (s->bed->record_xhash_symbol != NULL) 6092 { 6093 bfd_vma xlat_loc = s->xlat + (s->indx[bucket]++ - s->symindx) * 4; 6094 6095 (*s->bed->record_xhash_symbol) (h, xlat_loc); 6096 } 6097 else 6098 h->dynindx = s->indx[bucket]++; 6099 return TRUE; 6100} 6101 6102/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */ 6103 6104bfd_boolean 6105_bfd_elf_hash_symbol (struct elf_link_hash_entry *h) 6106{ 6107 return !(h->forced_local 6108 || h->root.type == bfd_link_hash_undefined 6109 || h->root.type == bfd_link_hash_undefweak 6110 || ((h->root.type == bfd_link_hash_defined 6111 || h->root.type == bfd_link_hash_defweak) 6112 && h->root.u.def.section->output_section == NULL)); 6113} 6114 6115/* Array used to determine the number of hash table buckets to use 6116 based on the number of symbols there are. If there are fewer than 6117 3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets, 6118 fewer than 37 we use 17 buckets, and so forth. We never use more 6119 than 32771 buckets. */ 6120 6121static const size_t elf_buckets[] = 6122{ 6123 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209, 6124 16411, 32771, 0 6125}; 6126 6127/* Compute bucket count for hashing table. We do not use a static set 6128 of possible tables sizes anymore. Instead we determine for all 6129 possible reasonable sizes of the table the outcome (i.e., the 6130 number of collisions etc) and choose the best solution. The 6131 weighting functions are not too simple to allow the table to grow 6132 without bounds. Instead one of the weighting factors is the size. 6133 Therefore the result is always a good payoff between few collisions 6134 (= short chain lengths) and table size. */ 6135static size_t 6136compute_bucket_count (struct bfd_link_info *info ATTRIBUTE_UNUSED, 6137 unsigned long int *hashcodes ATTRIBUTE_UNUSED, 6138 unsigned long int nsyms, 6139 int gnu_hash) 6140{ 6141 size_t best_size = 0; 6142 unsigned long int i; 6143 6144 /* We have a problem here. The following code to optimize the table 6145 size requires an integer type with more the 32 bits. If 6146 BFD_HOST_U_64_BIT is set we know about such a type. */ 6147#ifdef BFD_HOST_U_64_BIT 6148 if (info->optimize) 6149 { 6150 size_t minsize; 6151 size_t maxsize; 6152 BFD_HOST_U_64_BIT best_chlen = ~((BFD_HOST_U_64_BIT) 0); 6153 bfd *dynobj = elf_hash_table (info)->dynobj; 6154 size_t dynsymcount = elf_hash_table (info)->dynsymcount; 6155 const struct elf_backend_data *bed = get_elf_backend_data (dynobj); 6156 unsigned long int *counts; 6157 bfd_size_type amt; 6158 unsigned int no_improvement_count = 0; 6159 6160 /* Possible optimization parameters: if we have NSYMS symbols we say 6161 that the hashing table must at least have NSYMS/4 and at most 6162 2*NSYMS buckets. */ 6163 minsize = nsyms / 4; 6164 if (minsize == 0) 6165 minsize = 1; 6166 best_size = maxsize = nsyms * 2; 6167 if (gnu_hash) 6168 { 6169 if (minsize < 2) 6170 minsize = 2; 6171 if ((best_size & 31) == 0) 6172 ++best_size; 6173 } 6174 6175 /* Create array where we count the collisions in. We must use bfd_malloc 6176 since the size could be large. */ 6177 amt = maxsize; 6178 amt *= sizeof (unsigned long int); 6179 counts = (unsigned long int *) bfd_malloc (amt); 6180 if (counts == NULL) 6181 return 0; 6182 6183 /* Compute the "optimal" size for the hash table. The criteria is a 6184 minimal chain length. The minor criteria is (of course) the size 6185 of the table. */ 6186 for (i = minsize; i < maxsize; ++i) 6187 { 6188 /* Walk through the array of hashcodes and count the collisions. */ 6189 BFD_HOST_U_64_BIT max; 6190 unsigned long int j; 6191 unsigned long int fact; 6192 6193 if (gnu_hash && (i & 31) == 0) 6194 continue; 6195 6196 memset (counts, '\0', i * sizeof (unsigned long int)); 6197 6198 /* Determine how often each hash bucket is used. */ 6199 for (j = 0; j < nsyms; ++j) 6200 ++counts[hashcodes[j] % i]; 6201 6202 /* For the weight function we need some information about the 6203 pagesize on the target. This is information need not be 100% 6204 accurate. Since this information is not available (so far) we 6205 define it here to a reasonable default value. If it is crucial 6206 to have a better value some day simply define this value. */ 6207# ifndef BFD_TARGET_PAGESIZE 6208# define BFD_TARGET_PAGESIZE (4096) 6209# endif 6210 6211 /* We in any case need 2 + DYNSYMCOUNT entries for the size values 6212 and the chains. */ 6213 max = (2 + dynsymcount) * bed->s->sizeof_hash_entry; 6214 6215# if 1 6216 /* Variant 1: optimize for short chains. We add the squares 6217 of all the chain lengths (which favors many small chain 6218 over a few long chains). */ 6219 for (j = 0; j < i; ++j) 6220 max += counts[j] * counts[j]; 6221 6222 /* This adds penalties for the overall size of the table. */ 6223 fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1; 6224 max *= fact * fact; 6225# else 6226 /* Variant 2: Optimize a lot more for small table. Here we 6227 also add squares of the size but we also add penalties for 6228 empty slots (the +1 term). */ 6229 for (j = 0; j < i; ++j) 6230 max += (1 + counts[j]) * (1 + counts[j]); 6231 6232 /* The overall size of the table is considered, but not as 6233 strong as in variant 1, where it is squared. */ 6234 fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1; 6235 max *= fact; 6236# endif 6237 6238 /* Compare with current best results. */ 6239 if (max < best_chlen) 6240 { 6241 best_chlen = max; 6242 best_size = i; 6243 no_improvement_count = 0; 6244 } 6245 /* PR 11843: Avoid futile long searches for the best bucket size 6246 when there are a large number of symbols. */ 6247 else if (++no_improvement_count == 100) 6248 break; 6249 } 6250 6251 free (counts); 6252 } 6253 else 6254#endif /* defined (BFD_HOST_U_64_BIT) */ 6255 { 6256 /* This is the fallback solution if no 64bit type is available or if we 6257 are not supposed to spend much time on optimizations. We select the 6258 bucket count using a fixed set of numbers. */ 6259 for (i = 0; elf_buckets[i] != 0; i++) 6260 { 6261 best_size = elf_buckets[i]; 6262 if (nsyms < elf_buckets[i + 1]) 6263 break; 6264 } 6265 if (gnu_hash && best_size < 2) 6266 best_size = 2; 6267 } 6268 6269 return best_size; 6270} 6271 6272/* Size any SHT_GROUP section for ld -r. */ 6273 6274bfd_boolean 6275_bfd_elf_size_group_sections (struct bfd_link_info *info) 6276{ 6277 bfd *ibfd; 6278 asection *s; 6279 6280 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 6281 if (bfd_get_flavour (ibfd) == bfd_target_elf_flavour 6282 && (s = ibfd->sections) != NULL 6283 && s->sec_info_type != SEC_INFO_TYPE_JUST_SYMS 6284 && !_bfd_elf_fixup_group_sections (ibfd, bfd_abs_section_ptr)) 6285 return FALSE; 6286 return TRUE; 6287} 6288 6289/* Set a default stack segment size. The value in INFO wins. If it 6290 is unset, LEGACY_SYMBOL's value is used, and if that symbol is 6291 undefined it is initialized. */ 6292 6293bfd_boolean 6294bfd_elf_stack_segment_size (bfd *output_bfd, 6295 struct bfd_link_info *info, 6296 const char *legacy_symbol, 6297 bfd_vma default_size) 6298{ 6299 struct elf_link_hash_entry *h = NULL; 6300 6301 /* Look for legacy symbol. */ 6302 if (legacy_symbol) 6303 h = elf_link_hash_lookup (elf_hash_table (info), legacy_symbol, 6304 FALSE, FALSE, FALSE); 6305 if (h && (h->root.type == bfd_link_hash_defined 6306 || h->root.type == bfd_link_hash_defweak) 6307 && h->def_regular 6308 && (h->type == STT_NOTYPE || h->type == STT_OBJECT)) 6309 { 6310 /* The symbol has no type if specified on the command line. */ 6311 h->type = STT_OBJECT; 6312 if (info->stacksize) 6313 /* xgettext:c-format */ 6314 _bfd_error_handler (_("%pB: stack size specified and %s set"), 6315 output_bfd, legacy_symbol); 6316 else if (h->root.u.def.section != bfd_abs_section_ptr) 6317 /* xgettext:c-format */ 6318 _bfd_error_handler (_("%pB: %s not absolute"), 6319 output_bfd, legacy_symbol); 6320 else 6321 info->stacksize = h->root.u.def.value; 6322 } 6323 6324 if (!info->stacksize) 6325 /* If the user didn't set a size, or explicitly inhibit the 6326 size, set it now. */ 6327 info->stacksize = default_size; 6328 6329 /* Provide the legacy symbol, if it is referenced. */ 6330 if (h && (h->root.type == bfd_link_hash_undefined 6331 || h->root.type == bfd_link_hash_undefweak)) 6332 { 6333 struct bfd_link_hash_entry *bh = NULL; 6334 6335 if (!(_bfd_generic_link_add_one_symbol 6336 (info, output_bfd, legacy_symbol, 6337 BSF_GLOBAL, bfd_abs_section_ptr, 6338 info->stacksize >= 0 ? info->stacksize : 0, 6339 NULL, FALSE, get_elf_backend_data (output_bfd)->collect, &bh))) 6340 return FALSE; 6341 6342 h = (struct elf_link_hash_entry *) bh; 6343 h->def_regular = 1; 6344 h->type = STT_OBJECT; 6345 } 6346 6347 return TRUE; 6348} 6349 6350/* Sweep symbols in swept sections. Called via elf_link_hash_traverse. */ 6351 6352struct elf_gc_sweep_symbol_info 6353{ 6354 struct bfd_link_info *info; 6355 void (*hide_symbol) (struct bfd_link_info *, struct elf_link_hash_entry *, 6356 bfd_boolean); 6357}; 6358 6359static bfd_boolean 6360elf_gc_sweep_symbol (struct elf_link_hash_entry *h, void *data) 6361{ 6362 if (!h->mark 6363 && (((h->root.type == bfd_link_hash_defined 6364 || h->root.type == bfd_link_hash_defweak) 6365 && !((h->def_regular || ELF_COMMON_DEF_P (h)) 6366 && h->root.u.def.section->gc_mark)) 6367 || h->root.type == bfd_link_hash_undefined 6368 || h->root.type == bfd_link_hash_undefweak)) 6369 { 6370 struct elf_gc_sweep_symbol_info *inf; 6371 6372 inf = (struct elf_gc_sweep_symbol_info *) data; 6373 (*inf->hide_symbol) (inf->info, h, TRUE); 6374 h->def_regular = 0; 6375 h->ref_regular = 0; 6376 h->ref_regular_nonweak = 0; 6377 } 6378 6379 return TRUE; 6380} 6381 6382/* Set up the sizes and contents of the ELF dynamic sections. This is 6383 called by the ELF linker emulation before_allocation routine. We 6384 must set the sizes of the sections before the linker sets the 6385 addresses of the various sections. */ 6386 6387bfd_boolean 6388bfd_elf_size_dynamic_sections (bfd *output_bfd, 6389 const char *soname, 6390 const char *rpath, 6391 const char *filter_shlib, 6392 const char *audit, 6393 const char *depaudit, 6394 const char * const *auxiliary_filters, 6395 struct bfd_link_info *info, 6396 asection **sinterpptr) 6397{ 6398 bfd *dynobj; 6399 const struct elf_backend_data *bed; 6400 6401 *sinterpptr = NULL; 6402 6403 if (!is_elf_hash_table (info->hash)) 6404 return TRUE; 6405 6406 dynobj = elf_hash_table (info)->dynobj; 6407 6408 if (dynobj != NULL && elf_hash_table (info)->dynamic_sections_created) 6409 { 6410 struct bfd_elf_version_tree *verdefs; 6411 struct elf_info_failed asvinfo; 6412 struct bfd_elf_version_tree *t; 6413 struct bfd_elf_version_expr *d; 6414 asection *s; 6415 size_t soname_indx; 6416 6417 /* If we are supposed to export all symbols into the dynamic symbol 6418 table (this is not the normal case), then do so. */ 6419 if (info->export_dynamic 6420 || (bfd_link_executable (info) && info->dynamic)) 6421 { 6422 struct elf_info_failed eif; 6423 6424 eif.info = info; 6425 eif.failed = FALSE; 6426 elf_link_hash_traverse (elf_hash_table (info), 6427 _bfd_elf_export_symbol, 6428 &eif); 6429 if (eif.failed) 6430 return FALSE; 6431 } 6432 6433 if (soname != NULL) 6434 { 6435 soname_indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, 6436 soname, TRUE); 6437 if (soname_indx == (size_t) -1 6438 || !_bfd_elf_add_dynamic_entry (info, DT_SONAME, soname_indx)) 6439 return FALSE; 6440 } 6441 else 6442 soname_indx = (size_t) -1; 6443 6444 /* Make all global versions with definition. */ 6445 for (t = info->version_info; t != NULL; t = t->next) 6446 for (d = t->globals.list; d != NULL; d = d->next) 6447 if (!d->symver && d->literal) 6448 { 6449 const char *verstr, *name; 6450 size_t namelen, verlen, newlen; 6451 char *newname, *p, leading_char; 6452 struct elf_link_hash_entry *newh; 6453 6454 leading_char = bfd_get_symbol_leading_char (output_bfd); 6455 name = d->pattern; 6456 namelen = strlen (name) + (leading_char != '\0'); 6457 verstr = t->name; 6458 verlen = strlen (verstr); 6459 newlen = namelen + verlen + 3; 6460 6461 newname = (char *) bfd_malloc (newlen); 6462 if (newname == NULL) 6463 return FALSE; 6464 newname[0] = leading_char; 6465 memcpy (newname + (leading_char != '\0'), name, namelen); 6466 6467 /* Check the hidden versioned definition. */ 6468 p = newname + namelen; 6469 *p++ = ELF_VER_CHR; 6470 memcpy (p, verstr, verlen + 1); 6471 newh = elf_link_hash_lookup (elf_hash_table (info), 6472 newname, FALSE, FALSE, 6473 FALSE); 6474 if (newh == NULL 6475 || (newh->root.type != bfd_link_hash_defined 6476 && newh->root.type != bfd_link_hash_defweak)) 6477 { 6478 /* Check the default versioned definition. */ 6479 *p++ = ELF_VER_CHR; 6480 memcpy (p, verstr, verlen + 1); 6481 newh = elf_link_hash_lookup (elf_hash_table (info), 6482 newname, FALSE, FALSE, 6483 FALSE); 6484 } 6485 free (newname); 6486 6487 /* Mark this version if there is a definition and it is 6488 not defined in a shared object. */ 6489 if (newh != NULL 6490 && !newh->def_dynamic 6491 && (newh->root.type == bfd_link_hash_defined 6492 || newh->root.type == bfd_link_hash_defweak)) 6493 d->symver = 1; 6494 } 6495 6496 /* Attach all the symbols to their version information. */ 6497 asvinfo.info = info; 6498 asvinfo.failed = FALSE; 6499 6500 elf_link_hash_traverse (elf_hash_table (info), 6501 _bfd_elf_link_assign_sym_version, 6502 &asvinfo); 6503 if (asvinfo.failed) 6504 return FALSE; 6505 6506 if (!info->allow_undefined_version) 6507 { 6508 /* Check if all global versions have a definition. */ 6509 bfd_boolean all_defined = TRUE; 6510 for (t = info->version_info; t != NULL; t = t->next) 6511 for (d = t->globals.list; d != NULL; d = d->next) 6512 if (d->literal && !d->symver && !d->script) 6513 { 6514 _bfd_error_handler 6515 (_("%s: undefined version: %s"), 6516 d->pattern, t->name); 6517 all_defined = FALSE; 6518 } 6519 6520 if (!all_defined) 6521 { 6522 bfd_set_error (bfd_error_bad_value); 6523 return FALSE; 6524 } 6525 } 6526 6527 /* Set up the version definition section. */ 6528 s = bfd_get_linker_section (dynobj, ".gnu.version_d"); 6529 BFD_ASSERT (s != NULL); 6530 6531 /* We may have created additional version definitions if we are 6532 just linking a regular application. */ 6533 verdefs = info->version_info; 6534 6535 /* Skip anonymous version tag. */ 6536 if (verdefs != NULL && verdefs->vernum == 0) 6537 verdefs = verdefs->next; 6538 6539 if (verdefs == NULL && !info->create_default_symver) 6540 s->flags |= SEC_EXCLUDE; 6541 else 6542 { 6543 unsigned int cdefs; 6544 bfd_size_type size; 6545 bfd_byte *p; 6546 Elf_Internal_Verdef def; 6547 Elf_Internal_Verdaux defaux; 6548 struct bfd_link_hash_entry *bh; 6549 struct elf_link_hash_entry *h; 6550 const char *name; 6551 6552 cdefs = 0; 6553 size = 0; 6554 6555 /* Make space for the base version. */ 6556 size += sizeof (Elf_External_Verdef); 6557 size += sizeof (Elf_External_Verdaux); 6558 ++cdefs; 6559 6560 /* Make space for the default version. */ 6561 if (info->create_default_symver) 6562 { 6563 size += sizeof (Elf_External_Verdef); 6564 ++cdefs; 6565 } 6566 6567 for (t = verdefs; t != NULL; t = t->next) 6568 { 6569 struct bfd_elf_version_deps *n; 6570 6571 /* Don't emit base version twice. */ 6572 if (t->vernum == 0) 6573 continue; 6574 6575 size += sizeof (Elf_External_Verdef); 6576 size += sizeof (Elf_External_Verdaux); 6577 ++cdefs; 6578 6579 for (n = t->deps; n != NULL; n = n->next) 6580 size += sizeof (Elf_External_Verdaux); 6581 } 6582 6583 s->size = size; 6584 s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size); 6585 if (s->contents == NULL && s->size != 0) 6586 return FALSE; 6587 6588 /* Fill in the version definition section. */ 6589 6590 p = s->contents; 6591 6592 def.vd_version = VER_DEF_CURRENT; 6593 def.vd_flags = VER_FLG_BASE; 6594 def.vd_ndx = 1; 6595 def.vd_cnt = 1; 6596 if (info->create_default_symver) 6597 { 6598 def.vd_aux = 2 * sizeof (Elf_External_Verdef); 6599 def.vd_next = sizeof (Elf_External_Verdef); 6600 } 6601 else 6602 { 6603 def.vd_aux = sizeof (Elf_External_Verdef); 6604 def.vd_next = (sizeof (Elf_External_Verdef) 6605 + sizeof (Elf_External_Verdaux)); 6606 } 6607 6608 if (soname_indx != (size_t) -1) 6609 { 6610 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr, 6611 soname_indx); 6612 def.vd_hash = bfd_elf_hash (soname); 6613 defaux.vda_name = soname_indx; 6614 name = soname; 6615 } 6616 else 6617 { 6618 size_t indx; 6619 6620 name = lbasename (bfd_get_filename (output_bfd)); 6621 def.vd_hash = bfd_elf_hash (name); 6622 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, 6623 name, FALSE); 6624 if (indx == (size_t) -1) 6625 return FALSE; 6626 defaux.vda_name = indx; 6627 } 6628 defaux.vda_next = 0; 6629 6630 _bfd_elf_swap_verdef_out (output_bfd, &def, 6631 (Elf_External_Verdef *) p); 6632 p += sizeof (Elf_External_Verdef); 6633 if (info->create_default_symver) 6634 { 6635 /* Add a symbol representing this version. */ 6636 bh = NULL; 6637 if (! (_bfd_generic_link_add_one_symbol 6638 (info, dynobj, name, BSF_GLOBAL, bfd_abs_section_ptr, 6639 0, NULL, FALSE, 6640 get_elf_backend_data (dynobj)->collect, &bh))) 6641 return FALSE; 6642 h = (struct elf_link_hash_entry *) bh; 6643 h->non_elf = 0; 6644 h->def_regular = 1; 6645 h->type = STT_OBJECT; 6646 h->verinfo.vertree = NULL; 6647 6648 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 6649 return FALSE; 6650 6651 /* Create a duplicate of the base version with the same 6652 aux block, but different flags. */ 6653 def.vd_flags = 0; 6654 def.vd_ndx = 2; 6655 def.vd_aux = sizeof (Elf_External_Verdef); 6656 if (verdefs) 6657 def.vd_next = (sizeof (Elf_External_Verdef) 6658 + sizeof (Elf_External_Verdaux)); 6659 else 6660 def.vd_next = 0; 6661 _bfd_elf_swap_verdef_out (output_bfd, &def, 6662 (Elf_External_Verdef *) p); 6663 p += sizeof (Elf_External_Verdef); 6664 } 6665 _bfd_elf_swap_verdaux_out (output_bfd, &defaux, 6666 (Elf_External_Verdaux *) p); 6667 p += sizeof (Elf_External_Verdaux); 6668 6669 for (t = verdefs; t != NULL; t = t->next) 6670 { 6671 unsigned int cdeps; 6672 struct bfd_elf_version_deps *n; 6673 6674 /* Don't emit the base version twice. */ 6675 if (t->vernum == 0) 6676 continue; 6677 6678 cdeps = 0; 6679 for (n = t->deps; n != NULL; n = n->next) 6680 ++cdeps; 6681 6682 /* Add a symbol representing this version. */ 6683 bh = NULL; 6684 if (! (_bfd_generic_link_add_one_symbol 6685 (info, dynobj, t->name, BSF_GLOBAL, bfd_abs_section_ptr, 6686 0, NULL, FALSE, 6687 get_elf_backend_data (dynobj)->collect, &bh))) 6688 return FALSE; 6689 h = (struct elf_link_hash_entry *) bh; 6690 h->non_elf = 0; 6691 h->def_regular = 1; 6692 h->type = STT_OBJECT; 6693 h->verinfo.vertree = t; 6694 6695 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 6696 return FALSE; 6697 6698 def.vd_version = VER_DEF_CURRENT; 6699 def.vd_flags = 0; 6700 if (t->globals.list == NULL 6701 && t->locals.list == NULL 6702 && ! t->used) 6703 def.vd_flags |= VER_FLG_WEAK; 6704 def.vd_ndx = t->vernum + (info->create_default_symver ? 2 : 1); 6705 def.vd_cnt = cdeps + 1; 6706 def.vd_hash = bfd_elf_hash (t->name); 6707 def.vd_aux = sizeof (Elf_External_Verdef); 6708 def.vd_next = 0; 6709 6710 /* If a basever node is next, it *must* be the last node in 6711 the chain, otherwise Verdef construction breaks. */ 6712 if (t->next != NULL && t->next->vernum == 0) 6713 BFD_ASSERT (t->next->next == NULL); 6714 6715 if (t->next != NULL && t->next->vernum != 0) 6716 def.vd_next = (sizeof (Elf_External_Verdef) 6717 + (cdeps + 1) * sizeof (Elf_External_Verdaux)); 6718 6719 _bfd_elf_swap_verdef_out (output_bfd, &def, 6720 (Elf_External_Verdef *) p); 6721 p += sizeof (Elf_External_Verdef); 6722 6723 defaux.vda_name = h->dynstr_index; 6724 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr, 6725 h->dynstr_index); 6726 defaux.vda_next = 0; 6727 if (t->deps != NULL) 6728 defaux.vda_next = sizeof (Elf_External_Verdaux); 6729 t->name_indx = defaux.vda_name; 6730 6731 _bfd_elf_swap_verdaux_out (output_bfd, &defaux, 6732 (Elf_External_Verdaux *) p); 6733 p += sizeof (Elf_External_Verdaux); 6734 6735 for (n = t->deps; n != NULL; n = n->next) 6736 { 6737 if (n->version_needed == NULL) 6738 { 6739 /* This can happen if there was an error in the 6740 version script. */ 6741 defaux.vda_name = 0; 6742 } 6743 else 6744 { 6745 defaux.vda_name = n->version_needed->name_indx; 6746 _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr, 6747 defaux.vda_name); 6748 } 6749 if (n->next == NULL) 6750 defaux.vda_next = 0; 6751 else 6752 defaux.vda_next = sizeof (Elf_External_Verdaux); 6753 6754 _bfd_elf_swap_verdaux_out (output_bfd, &defaux, 6755 (Elf_External_Verdaux *) p); 6756 p += sizeof (Elf_External_Verdaux); 6757 } 6758 } 6759 6760 elf_tdata (output_bfd)->cverdefs = cdefs; 6761 } 6762 } 6763 6764 bed = get_elf_backend_data (output_bfd); 6765 6766 if (info->gc_sections && bed->can_gc_sections) 6767 { 6768 struct elf_gc_sweep_symbol_info sweep_info; 6769 6770 /* Remove the symbols that were in the swept sections from the 6771 dynamic symbol table. */ 6772 sweep_info.info = info; 6773 sweep_info.hide_symbol = bed->elf_backend_hide_symbol; 6774 elf_link_hash_traverse (elf_hash_table (info), elf_gc_sweep_symbol, 6775 &sweep_info); 6776 } 6777 6778 if (dynobj != NULL && elf_hash_table (info)->dynamic_sections_created) 6779 { 6780 asection *s; 6781 struct elf_find_verdep_info sinfo; 6782 6783 /* Work out the size of the version reference section. */ 6784 6785 s = bfd_get_linker_section (dynobj, ".gnu.version_r"); 6786 BFD_ASSERT (s != NULL); 6787 6788 sinfo.info = info; 6789 sinfo.vers = elf_tdata (output_bfd)->cverdefs; 6790 if (sinfo.vers == 0) 6791 sinfo.vers = 1; 6792 sinfo.failed = FALSE; 6793 6794 elf_link_hash_traverse (elf_hash_table (info), 6795 _bfd_elf_link_find_version_dependencies, 6796 &sinfo); 6797 if (sinfo.failed) 6798 return FALSE; 6799 6800 if (elf_tdata (output_bfd)->verref == NULL) 6801 s->flags |= SEC_EXCLUDE; 6802 else 6803 { 6804 Elf_Internal_Verneed *vn; 6805 unsigned int size; 6806 unsigned int crefs; 6807 bfd_byte *p; 6808 6809 /* Build the version dependency section. */ 6810 size = 0; 6811 crefs = 0; 6812 for (vn = elf_tdata (output_bfd)->verref; 6813 vn != NULL; 6814 vn = vn->vn_nextref) 6815 { 6816 Elf_Internal_Vernaux *a; 6817 6818 size += sizeof (Elf_External_Verneed); 6819 ++crefs; 6820 for (a = vn->vn_auxptr; a != NULL; a = a->vna_nextptr) 6821 size += sizeof (Elf_External_Vernaux); 6822 } 6823 6824 s->size = size; 6825 s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size); 6826 if (s->contents == NULL) 6827 return FALSE; 6828 6829 p = s->contents; 6830 for (vn = elf_tdata (output_bfd)->verref; 6831 vn != NULL; 6832 vn = vn->vn_nextref) 6833 { 6834 unsigned int caux; 6835 Elf_Internal_Vernaux *a; 6836 size_t indx; 6837 6838 caux = 0; 6839 for (a = vn->vn_auxptr; a != NULL; a = a->vna_nextptr) 6840 ++caux; 6841 6842 vn->vn_version = VER_NEED_CURRENT; 6843 vn->vn_cnt = caux; 6844 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, 6845 elf_dt_name (vn->vn_bfd) != NULL 6846 ? elf_dt_name (vn->vn_bfd) 6847 : lbasename (bfd_get_filename 6848 (vn->vn_bfd)), 6849 FALSE); 6850 if (indx == (size_t) -1) 6851 return FALSE; 6852 vn->vn_file = indx; 6853 vn->vn_aux = sizeof (Elf_External_Verneed); 6854 if (vn->vn_nextref == NULL) 6855 vn->vn_next = 0; 6856 else 6857 vn->vn_next = (sizeof (Elf_External_Verneed) 6858 + caux * sizeof (Elf_External_Vernaux)); 6859 6860 _bfd_elf_swap_verneed_out (output_bfd, vn, 6861 (Elf_External_Verneed *) p); 6862 p += sizeof (Elf_External_Verneed); 6863 6864 for (a = vn->vn_auxptr; a != NULL; a = a->vna_nextptr) 6865 { 6866 a->vna_hash = bfd_elf_hash (a->vna_nodename); 6867 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, 6868 a->vna_nodename, FALSE); 6869 if (indx == (size_t) -1) 6870 return FALSE; 6871 a->vna_name = indx; 6872 if (a->vna_nextptr == NULL) 6873 a->vna_next = 0; 6874 else 6875 a->vna_next = sizeof (Elf_External_Vernaux); 6876 6877 _bfd_elf_swap_vernaux_out (output_bfd, a, 6878 (Elf_External_Vernaux *) p); 6879 p += sizeof (Elf_External_Vernaux); 6880 } 6881 } 6882 6883 elf_tdata (output_bfd)->cverrefs = crefs; 6884 } 6885 } 6886 6887 /* Any syms created from now on start with -1 in 6888 got.refcount/offset and plt.refcount/offset. */ 6889 elf_hash_table (info)->init_got_refcount 6890 = elf_hash_table (info)->init_got_offset; 6891 elf_hash_table (info)->init_plt_refcount 6892 = elf_hash_table (info)->init_plt_offset; 6893 6894 if (bfd_link_relocatable (info) 6895 && !_bfd_elf_size_group_sections (info)) 6896 return FALSE; 6897 6898 /* The backend may have to create some sections regardless of whether 6899 we're dynamic or not. */ 6900 if (bed->elf_backend_always_size_sections 6901 && ! (*bed->elf_backend_always_size_sections) (output_bfd, info)) 6902 return FALSE; 6903 6904 /* Determine any GNU_STACK segment requirements, after the backend 6905 has had a chance to set a default segment size. */ 6906 if (info->execstack) 6907 elf_stack_flags (output_bfd) = PF_R | PF_W | PF_X; 6908 else if (info->noexecstack) 6909 elf_stack_flags (output_bfd) = PF_R | PF_W; 6910 else 6911 { 6912 bfd *inputobj; 6913 asection *notesec = NULL; 6914 int exec = 0; 6915 6916 for (inputobj = info->input_bfds; 6917 inputobj; 6918 inputobj = inputobj->link.next) 6919 { 6920 asection *s; 6921 6922 if (inputobj->flags 6923 & (DYNAMIC | EXEC_P | BFD_PLUGIN | BFD_LINKER_CREATED)) 6924 continue; 6925 s = inputobj->sections; 6926 if (s == NULL || s->sec_info_type == SEC_INFO_TYPE_JUST_SYMS) 6927 continue; 6928 6929 s = bfd_get_section_by_name (inputobj, ".note.GNU-stack"); 6930 if (s) 6931 { 6932 if (s->flags & SEC_CODE) 6933 exec = PF_X; 6934 notesec = s; 6935 } 6936 else if (bed->default_execstack) 6937 exec = PF_X; 6938 } 6939 if (notesec || info->stacksize > 0) 6940 elf_stack_flags (output_bfd) = PF_R | PF_W | exec; 6941 if (notesec && exec && bfd_link_relocatable (info) 6942 && notesec->output_section != bfd_abs_section_ptr) 6943 notesec->output_section->flags |= SEC_CODE; 6944 } 6945 6946 if (dynobj != NULL && elf_hash_table (info)->dynamic_sections_created) 6947 { 6948 struct elf_info_failed eif; 6949 struct elf_link_hash_entry *h; 6950 asection *dynstr; 6951 asection *s; 6952 6953 *sinterpptr = bfd_get_linker_section (dynobj, ".interp"); 6954 BFD_ASSERT (*sinterpptr != NULL || !bfd_link_executable (info) || info->nointerp); 6955 6956 if (info->symbolic) 6957 { 6958 if (!_bfd_elf_add_dynamic_entry (info, DT_SYMBOLIC, 0)) 6959 return FALSE; 6960 info->flags |= DF_SYMBOLIC; 6961 } 6962 6963 if (rpath != NULL) 6964 { 6965 size_t indx; 6966 bfd_vma tag; 6967 6968 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, rpath, 6969 TRUE); 6970 if (indx == (size_t) -1) 6971 return FALSE; 6972 6973 tag = info->new_dtags ? DT_RUNPATH : DT_RPATH; 6974 if (!_bfd_elf_add_dynamic_entry (info, tag, indx)) 6975 return FALSE; 6976 } 6977 6978 if (filter_shlib != NULL) 6979 { 6980 size_t indx; 6981 6982 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, 6983 filter_shlib, TRUE); 6984 if (indx == (size_t) -1 6985 || !_bfd_elf_add_dynamic_entry (info, DT_FILTER, indx)) 6986 return FALSE; 6987 } 6988 6989 if (auxiliary_filters != NULL) 6990 { 6991 const char * const *p; 6992 6993 for (p = auxiliary_filters; *p != NULL; p++) 6994 { 6995 size_t indx; 6996 6997 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, 6998 *p, TRUE); 6999 if (indx == (size_t) -1 7000 || !_bfd_elf_add_dynamic_entry (info, DT_AUXILIARY, indx)) 7001 return FALSE; 7002 } 7003 } 7004 7005 if (audit != NULL) 7006 { 7007 size_t indx; 7008 7009 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, audit, 7010 TRUE); 7011 if (indx == (size_t) -1 7012 || !_bfd_elf_add_dynamic_entry (info, DT_AUDIT, indx)) 7013 return FALSE; 7014 } 7015 7016 if (depaudit != NULL) 7017 { 7018 size_t indx; 7019 7020 indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, depaudit, 7021 TRUE); 7022 if (indx == (size_t) -1 7023 || !_bfd_elf_add_dynamic_entry (info, DT_DEPAUDIT, indx)) 7024 return FALSE; 7025 } 7026 7027 eif.info = info; 7028 eif.failed = FALSE; 7029 7030 /* Find all symbols which were defined in a dynamic object and make 7031 the backend pick a reasonable value for them. */ 7032 elf_link_hash_traverse (elf_hash_table (info), 7033 _bfd_elf_adjust_dynamic_symbol, 7034 &eif); 7035 if (eif.failed) 7036 return FALSE; 7037 7038 /* Add some entries to the .dynamic section. We fill in some of the 7039 values later, in bfd_elf_final_link, but we must add the entries 7040 now so that we know the final size of the .dynamic section. */ 7041 7042 /* If there are initialization and/or finalization functions to 7043 call then add the corresponding DT_INIT/DT_FINI entries. */ 7044 h = (info->init_function 7045 ? elf_link_hash_lookup (elf_hash_table (info), 7046 info->init_function, FALSE, 7047 FALSE, FALSE) 7048 : NULL); 7049 if (h != NULL 7050 && (h->ref_regular 7051 || h->def_regular)) 7052 { 7053 if (!_bfd_elf_add_dynamic_entry (info, DT_INIT, 0)) 7054 return FALSE; 7055 } 7056 h = (info->fini_function 7057 ? elf_link_hash_lookup (elf_hash_table (info), 7058 info->fini_function, FALSE, 7059 FALSE, FALSE) 7060 : NULL); 7061 if (h != NULL 7062 && (h->ref_regular 7063 || h->def_regular)) 7064 { 7065 if (!_bfd_elf_add_dynamic_entry (info, DT_FINI, 0)) 7066 return FALSE; 7067 } 7068 7069 s = bfd_get_section_by_name (output_bfd, ".preinit_array"); 7070 if (s != NULL && s->linker_has_input) 7071 { 7072 /* DT_PREINIT_ARRAY is not allowed in shared library. */ 7073 if (! bfd_link_executable (info)) 7074 { 7075 bfd *sub; 7076 asection *o; 7077 7078 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next) 7079 if (bfd_get_flavour (sub) == bfd_target_elf_flavour 7080 && (o = sub->sections) != NULL 7081 && o->sec_info_type != SEC_INFO_TYPE_JUST_SYMS) 7082 for (o = sub->sections; o != NULL; o = o->next) 7083 if (elf_section_data (o)->this_hdr.sh_type 7084 == SHT_PREINIT_ARRAY) 7085 { 7086 _bfd_error_handler 7087 (_("%pB: .preinit_array section is not allowed in DSO"), 7088 sub); 7089 break; 7090 } 7091 7092 bfd_set_error (bfd_error_nonrepresentable_section); 7093 return FALSE; 7094 } 7095 7096 if (!_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAY, 0) 7097 || !_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAYSZ, 0)) 7098 return FALSE; 7099 } 7100 s = bfd_get_section_by_name (output_bfd, ".init_array"); 7101 if (s != NULL && s->linker_has_input) 7102 { 7103 if (!_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAY, 0) 7104 || !_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAYSZ, 0)) 7105 return FALSE; 7106 } 7107 s = bfd_get_section_by_name (output_bfd, ".fini_array"); 7108 if (s != NULL && s->linker_has_input) 7109 { 7110 if (!_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAY, 0) 7111 || !_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAYSZ, 0)) 7112 return FALSE; 7113 } 7114 7115 dynstr = bfd_get_linker_section (dynobj, ".dynstr"); 7116 /* If .dynstr is excluded from the link, we don't want any of 7117 these tags. Strictly, we should be checking each section 7118 individually; This quick check covers for the case where 7119 someone does a /DISCARD/ : { *(*) }. */ 7120 if (dynstr != NULL && dynstr->output_section != bfd_abs_section_ptr) 7121 { 7122 bfd_size_type strsize; 7123 7124 strsize = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr); 7125 if ((info->emit_hash 7126 && !_bfd_elf_add_dynamic_entry (info, DT_HASH, 0)) 7127 || (info->emit_gnu_hash 7128 && (bed->record_xhash_symbol == NULL 7129 && !_bfd_elf_add_dynamic_entry (info, DT_GNU_HASH, 0))) 7130 || !_bfd_elf_add_dynamic_entry (info, DT_STRTAB, 0) 7131 || !_bfd_elf_add_dynamic_entry (info, DT_SYMTAB, 0) 7132 || !_bfd_elf_add_dynamic_entry (info, DT_STRSZ, strsize) 7133 || !_bfd_elf_add_dynamic_entry (info, DT_SYMENT, 7134 bed->s->sizeof_sym)) 7135 return FALSE; 7136 } 7137 } 7138 7139 if (! _bfd_elf_maybe_strip_eh_frame_hdr (info)) 7140 return FALSE; 7141 7142 /* The backend must work out the sizes of all the other dynamic 7143 sections. */ 7144 if (dynobj != NULL 7145 && bed->elf_backend_size_dynamic_sections != NULL 7146 && ! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info)) 7147 return FALSE; 7148 7149 if (dynobj != NULL && elf_hash_table (info)->dynamic_sections_created) 7150 { 7151 if (elf_tdata (output_bfd)->cverdefs) 7152 { 7153 unsigned int crefs = elf_tdata (output_bfd)->cverdefs; 7154 7155 if (!_bfd_elf_add_dynamic_entry (info, DT_VERDEF, 0) 7156 || !_bfd_elf_add_dynamic_entry (info, DT_VERDEFNUM, crefs)) 7157 return FALSE; 7158 } 7159 7160 if ((info->new_dtags && info->flags) || (info->flags & DF_STATIC_TLS)) 7161 { 7162 if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS, info->flags)) 7163 return FALSE; 7164 } 7165 else if (info->flags & DF_BIND_NOW) 7166 { 7167 if (!_bfd_elf_add_dynamic_entry (info, DT_BIND_NOW, 0)) 7168 return FALSE; 7169 } 7170 7171 if (info->flags_1) 7172 { 7173 if (bfd_link_executable (info)) 7174 info->flags_1 &= ~ (DF_1_INITFIRST 7175 | DF_1_NODELETE 7176 | DF_1_NOOPEN); 7177 if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS_1, info->flags_1)) 7178 return FALSE; 7179 } 7180 7181 if (elf_tdata (output_bfd)->cverrefs) 7182 { 7183 unsigned int crefs = elf_tdata (output_bfd)->cverrefs; 7184 7185 if (!_bfd_elf_add_dynamic_entry (info, DT_VERNEED, 0) 7186 || !_bfd_elf_add_dynamic_entry (info, DT_VERNEEDNUM, crefs)) 7187 return FALSE; 7188 } 7189 7190 if ((elf_tdata (output_bfd)->cverrefs == 0 7191 && elf_tdata (output_bfd)->cverdefs == 0) 7192 || _bfd_elf_link_renumber_dynsyms (output_bfd, info, NULL) <= 1) 7193 { 7194 asection *s; 7195 7196 s = bfd_get_linker_section (dynobj, ".gnu.version"); 7197 s->flags |= SEC_EXCLUDE; 7198 } 7199 } 7200 return TRUE; 7201} 7202 7203/* Find the first non-excluded output section. We'll use its 7204 section symbol for some emitted relocs. */ 7205void 7206_bfd_elf_init_1_index_section (bfd *output_bfd, struct bfd_link_info *info) 7207{ 7208 asection *s; 7209 asection *found = NULL; 7210 7211 for (s = output_bfd->sections; s != NULL; s = s->next) 7212 if ((s->flags & (SEC_EXCLUDE | SEC_ALLOC)) == SEC_ALLOC 7213 && !_bfd_elf_omit_section_dynsym_default (output_bfd, info, s)) 7214 { 7215 found = s; 7216 if ((s->flags & SEC_THREAD_LOCAL) == 0) 7217 break; 7218 } 7219 elf_hash_table (info)->text_index_section = found; 7220} 7221 7222/* Find two non-excluded output sections, one for code, one for data. 7223 We'll use their section symbols for some emitted relocs. */ 7224void 7225_bfd_elf_init_2_index_sections (bfd *output_bfd, struct bfd_link_info *info) 7226{ 7227 asection *s; 7228 asection *found = NULL; 7229 7230 /* Data first, since setting text_index_section changes 7231 _bfd_elf_omit_section_dynsym_default. */ 7232 for (s = output_bfd->sections; s != NULL; s = s->next) 7233 if ((s->flags & (SEC_EXCLUDE | SEC_ALLOC)) == SEC_ALLOC 7234 && !(s->flags & SEC_READONLY) 7235 && !_bfd_elf_omit_section_dynsym_default (output_bfd, info, s)) 7236 { 7237 found = s; 7238 if ((s->flags & SEC_THREAD_LOCAL) == 0) 7239 break; 7240 } 7241 elf_hash_table (info)->data_index_section = found; 7242 7243 for (s = output_bfd->sections; s != NULL; s = s->next) 7244 if ((s->flags & (SEC_EXCLUDE | SEC_ALLOC)) == SEC_ALLOC 7245 && (s->flags & SEC_READONLY) 7246 && !_bfd_elf_omit_section_dynsym_default (output_bfd, info, s)) 7247 { 7248 found = s; 7249 break; 7250 } 7251 elf_hash_table (info)->text_index_section = found; 7252} 7253 7254#define GNU_HASH_SECTION_NAME(bed) \ 7255 (bed)->record_xhash_symbol != NULL ? ".MIPS.xhash" : ".gnu.hash" 7256 7257bfd_boolean 7258bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info) 7259{ 7260 const struct elf_backend_data *bed; 7261 unsigned long section_sym_count; 7262 bfd_size_type dynsymcount = 0; 7263 7264 if (!is_elf_hash_table (info->hash)) 7265 return TRUE; 7266 7267 bed = get_elf_backend_data (output_bfd); 7268 (*bed->elf_backend_init_index_section) (output_bfd, info); 7269 7270 /* Assign dynsym indices. In a shared library we generate a section 7271 symbol for each output section, which come first. Next come all 7272 of the back-end allocated local dynamic syms, followed by the rest 7273 of the global symbols. 7274 7275 This is usually not needed for static binaries, however backends 7276 can request to always do it, e.g. the MIPS backend uses dynamic 7277 symbol counts to lay out GOT, which will be produced in the 7278 presence of GOT relocations even in static binaries (holding fixed 7279 data in that case, to satisfy those relocations). */ 7280 7281 if (elf_hash_table (info)->dynamic_sections_created 7282 || bed->always_renumber_dynsyms) 7283 dynsymcount = _bfd_elf_link_renumber_dynsyms (output_bfd, info, 7284 §ion_sym_count); 7285 7286 if (elf_hash_table (info)->dynamic_sections_created) 7287 { 7288 bfd *dynobj; 7289 asection *s; 7290 unsigned int dtagcount; 7291 7292 dynobj = elf_hash_table (info)->dynobj; 7293 7294 /* Work out the size of the symbol version section. */ 7295 s = bfd_get_linker_section (dynobj, ".gnu.version"); 7296 BFD_ASSERT (s != NULL); 7297 if ((s->flags & SEC_EXCLUDE) == 0) 7298 { 7299 s->size = dynsymcount * sizeof (Elf_External_Versym); 7300 s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size); 7301 if (s->contents == NULL) 7302 return FALSE; 7303 7304 if (!_bfd_elf_add_dynamic_entry (info, DT_VERSYM, 0)) 7305 return FALSE; 7306 } 7307 7308 /* Set the size of the .dynsym and .hash sections. We counted 7309 the number of dynamic symbols in elf_link_add_object_symbols. 7310 We will build the contents of .dynsym and .hash when we build 7311 the final symbol table, because until then we do not know the 7312 correct value to give the symbols. We built the .dynstr 7313 section as we went along in elf_link_add_object_symbols. */ 7314 s = elf_hash_table (info)->dynsym; 7315 BFD_ASSERT (s != NULL); 7316 s->size = dynsymcount * bed->s->sizeof_sym; 7317 7318 s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size); 7319 if (s->contents == NULL) 7320 return FALSE; 7321 7322 /* The first entry in .dynsym is a dummy symbol. Clear all the 7323 section syms, in case we don't output them all. */ 7324 ++section_sym_count; 7325 memset (s->contents, 0, section_sym_count * bed->s->sizeof_sym); 7326 7327 elf_hash_table (info)->bucketcount = 0; 7328 7329 /* Compute the size of the hashing table. As a side effect this 7330 computes the hash values for all the names we export. */ 7331 if (info->emit_hash) 7332 { 7333 unsigned long int *hashcodes; 7334 struct hash_codes_info hashinf; 7335 bfd_size_type amt; 7336 unsigned long int nsyms; 7337 size_t bucketcount; 7338 size_t hash_entry_size; 7339 7340 /* Compute the hash values for all exported symbols. At the same 7341 time store the values in an array so that we could use them for 7342 optimizations. */ 7343 amt = dynsymcount * sizeof (unsigned long int); 7344 hashcodes = (unsigned long int *) bfd_malloc (amt); 7345 if (hashcodes == NULL) 7346 return FALSE; 7347 hashinf.hashcodes = hashcodes; 7348 hashinf.error = FALSE; 7349 7350 /* Put all hash values in HASHCODES. */ 7351 elf_link_hash_traverse (elf_hash_table (info), 7352 elf_collect_hash_codes, &hashinf); 7353 if (hashinf.error) 7354 { 7355 free (hashcodes); 7356 return FALSE; 7357 } 7358 7359 nsyms = hashinf.hashcodes - hashcodes; 7360 bucketcount 7361 = compute_bucket_count (info, hashcodes, nsyms, 0); 7362 free (hashcodes); 7363 7364 if (bucketcount == 0 && nsyms > 0) 7365 return FALSE; 7366 7367 elf_hash_table (info)->bucketcount = bucketcount; 7368 7369 s = bfd_get_linker_section (dynobj, ".hash"); 7370 BFD_ASSERT (s != NULL); 7371 hash_entry_size = elf_section_data (s)->this_hdr.sh_entsize; 7372 s->size = ((2 + bucketcount + dynsymcount) * hash_entry_size); 7373 s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size); 7374 if (s->contents == NULL) 7375 return FALSE; 7376 7377 bfd_put (8 * hash_entry_size, output_bfd, bucketcount, s->contents); 7378 bfd_put (8 * hash_entry_size, output_bfd, dynsymcount, 7379 s->contents + hash_entry_size); 7380 } 7381 7382 if (info->emit_gnu_hash) 7383 { 7384 size_t i, cnt; 7385 unsigned char *contents; 7386 struct collect_gnu_hash_codes cinfo; 7387 bfd_size_type amt; 7388 size_t bucketcount; 7389 7390 memset (&cinfo, 0, sizeof (cinfo)); 7391 7392 /* Compute the hash values for all exported symbols. At the same 7393 time store the values in an array so that we could use them for 7394 optimizations. */ 7395 amt = dynsymcount * 2 * sizeof (unsigned long int); 7396 cinfo.hashcodes = (long unsigned int *) bfd_malloc (amt); 7397 if (cinfo.hashcodes == NULL) 7398 return FALSE; 7399 7400 cinfo.hashval = cinfo.hashcodes + dynsymcount; 7401 cinfo.min_dynindx = -1; 7402 cinfo.output_bfd = output_bfd; 7403 cinfo.bed = bed; 7404 7405 /* Put all hash values in HASHCODES. */ 7406 elf_link_hash_traverse (elf_hash_table (info), 7407 elf_collect_gnu_hash_codes, &cinfo); 7408 if (cinfo.error) 7409 { 7410 free (cinfo.hashcodes); 7411 return FALSE; 7412 } 7413 7414 bucketcount 7415 = compute_bucket_count (info, cinfo.hashcodes, cinfo.nsyms, 1); 7416 7417 if (bucketcount == 0) 7418 { 7419 free (cinfo.hashcodes); 7420 return FALSE; 7421 } 7422 7423 s = bfd_get_linker_section (dynobj, GNU_HASH_SECTION_NAME (bed)); 7424 BFD_ASSERT (s != NULL); 7425 7426 if (cinfo.nsyms == 0) 7427 { 7428 /* Empty .gnu.hash or .MIPS.xhash section is special. */ 7429 BFD_ASSERT (cinfo.min_dynindx == -1); 7430 free (cinfo.hashcodes); 7431 s->size = 5 * 4 + bed->s->arch_size / 8; 7432 contents = (unsigned char *) bfd_zalloc (output_bfd, s->size); 7433 if (contents == NULL) 7434 return FALSE; 7435 s->contents = contents; 7436 /* 1 empty bucket. */ 7437 bfd_put_32 (output_bfd, 1, contents); 7438 /* SYMIDX above the special symbol 0. */ 7439 bfd_put_32 (output_bfd, 1, contents + 4); 7440 /* Just one word for bitmask. */ 7441 bfd_put_32 (output_bfd, 1, contents + 8); 7442 /* Only hash fn bloom filter. */ 7443 bfd_put_32 (output_bfd, 0, contents + 12); 7444 /* No hashes are valid - empty bitmask. */ 7445 bfd_put (bed->s->arch_size, output_bfd, 0, contents + 16); 7446 /* No hashes in the only bucket. */ 7447 bfd_put_32 (output_bfd, 0, 7448 contents + 16 + bed->s->arch_size / 8); 7449 } 7450 else 7451 { 7452 unsigned long int maskwords, maskbitslog2, x; 7453 BFD_ASSERT (cinfo.min_dynindx != -1); 7454 7455 x = cinfo.nsyms; 7456 maskbitslog2 = 1; 7457 while ((x >>= 1) != 0) 7458 ++maskbitslog2; 7459 if (maskbitslog2 < 3) 7460 maskbitslog2 = 5; 7461 else if ((1 << (maskbitslog2 - 2)) & cinfo.nsyms) 7462 maskbitslog2 = maskbitslog2 + 3; 7463 else 7464 maskbitslog2 = maskbitslog2 + 2; 7465 if (bed->s->arch_size == 64) 7466 { 7467 if (maskbitslog2 == 5) 7468 maskbitslog2 = 6; 7469 cinfo.shift1 = 6; 7470 } 7471 else 7472 cinfo.shift1 = 5; 7473 cinfo.mask = (1 << cinfo.shift1) - 1; 7474 cinfo.shift2 = maskbitslog2; 7475 cinfo.maskbits = 1 << maskbitslog2; 7476 maskwords = 1 << (maskbitslog2 - cinfo.shift1); 7477 amt = bucketcount * sizeof (unsigned long int) * 2; 7478 amt += maskwords * sizeof (bfd_vma); 7479 cinfo.bitmask = (bfd_vma *) bfd_malloc (amt); 7480 if (cinfo.bitmask == NULL) 7481 { 7482 free (cinfo.hashcodes); 7483 return FALSE; 7484 } 7485 7486 cinfo.counts = (long unsigned int *) (cinfo.bitmask + maskwords); 7487 cinfo.indx = cinfo.counts + bucketcount; 7488 cinfo.symindx = dynsymcount - cinfo.nsyms; 7489 memset (cinfo.bitmask, 0, maskwords * sizeof (bfd_vma)); 7490 7491 /* Determine how often each hash bucket is used. */ 7492 memset (cinfo.counts, 0, bucketcount * sizeof (cinfo.counts[0])); 7493 for (i = 0; i < cinfo.nsyms; ++i) 7494 ++cinfo.counts[cinfo.hashcodes[i] % bucketcount]; 7495 7496 for (i = 0, cnt = cinfo.symindx; i < bucketcount; ++i) 7497 if (cinfo.counts[i] != 0) 7498 { 7499 cinfo.indx[i] = cnt; 7500 cnt += cinfo.counts[i]; 7501 } 7502 BFD_ASSERT (cnt == dynsymcount); 7503 cinfo.bucketcount = bucketcount; 7504 cinfo.local_indx = cinfo.min_dynindx; 7505 7506 s->size = (4 + bucketcount + cinfo.nsyms) * 4; 7507 s->size += cinfo.maskbits / 8; 7508 if (bed->record_xhash_symbol != NULL) 7509 s->size += cinfo.nsyms * 4; 7510 contents = (unsigned char *) bfd_zalloc (output_bfd, s->size); 7511 if (contents == NULL) 7512 { 7513 free (cinfo.bitmask); 7514 free (cinfo.hashcodes); 7515 return FALSE; 7516 } 7517 7518 s->contents = contents; 7519 bfd_put_32 (output_bfd, bucketcount, contents); 7520 bfd_put_32 (output_bfd, cinfo.symindx, contents + 4); 7521 bfd_put_32 (output_bfd, maskwords, contents + 8); 7522 bfd_put_32 (output_bfd, cinfo.shift2, contents + 12); 7523 contents += 16 + cinfo.maskbits / 8; 7524 7525 for (i = 0; i < bucketcount; ++i) 7526 { 7527 if (cinfo.counts[i] == 0) 7528 bfd_put_32 (output_bfd, 0, contents); 7529 else 7530 bfd_put_32 (output_bfd, cinfo.indx[i], contents); 7531 contents += 4; 7532 } 7533 7534 cinfo.contents = contents; 7535 7536 cinfo.xlat = contents + cinfo.nsyms * 4 - s->contents; 7537 /* Renumber dynamic symbols, if populating .gnu.hash section. 7538 If using .MIPS.xhash, populate the translation table. */ 7539 elf_link_hash_traverse (elf_hash_table (info), 7540 elf_gnu_hash_process_symidx, &cinfo); 7541 7542 contents = s->contents + 16; 7543 for (i = 0; i < maskwords; ++i) 7544 { 7545 bfd_put (bed->s->arch_size, output_bfd, cinfo.bitmask[i], 7546 contents); 7547 contents += bed->s->arch_size / 8; 7548 } 7549 7550 free (cinfo.bitmask); 7551 free (cinfo.hashcodes); 7552 } 7553 } 7554 7555 s = bfd_get_linker_section (dynobj, ".dynstr"); 7556 BFD_ASSERT (s != NULL); 7557 7558 elf_finalize_dynstr (output_bfd, info); 7559 7560 s->size = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr); 7561 7562 for (dtagcount = 0; dtagcount <= info->spare_dynamic_tags; ++dtagcount) 7563 if (!_bfd_elf_add_dynamic_entry (info, DT_NULL, 0)) 7564 return FALSE; 7565 } 7566 7567 return TRUE; 7568} 7569 7570/* Make sure sec_info_type is cleared if sec_info is cleared too. */ 7571 7572static void 7573merge_sections_remove_hook (bfd *abfd ATTRIBUTE_UNUSED, 7574 asection *sec) 7575{ 7576 BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_MERGE); 7577 sec->sec_info_type = SEC_INFO_TYPE_NONE; 7578} 7579 7580/* Finish SHF_MERGE section merging. */ 7581 7582bfd_boolean 7583_bfd_elf_merge_sections (bfd *obfd, struct bfd_link_info *info) 7584{ 7585 bfd *ibfd; 7586 asection *sec; 7587 7588 if (!is_elf_hash_table (info->hash)) 7589 return FALSE; 7590 7591 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 7592 if ((ibfd->flags & DYNAMIC) == 0 7593 && bfd_get_flavour (ibfd) == bfd_target_elf_flavour 7594 && (elf_elfheader (ibfd)->e_ident[EI_CLASS] 7595 == get_elf_backend_data (obfd)->s->elfclass)) 7596 for (sec = ibfd->sections; sec != NULL; sec = sec->next) 7597 if ((sec->flags & SEC_MERGE) != 0 7598 && !bfd_is_abs_section (sec->output_section)) 7599 { 7600 struct bfd_elf_section_data *secdata; 7601 7602 secdata = elf_section_data (sec); 7603 if (! _bfd_add_merge_section (obfd, 7604 &elf_hash_table (info)->merge_info, 7605 sec, &secdata->sec_info)) 7606 return FALSE; 7607 else if (secdata->sec_info) 7608 sec->sec_info_type = SEC_INFO_TYPE_MERGE; 7609 } 7610 7611 if (elf_hash_table (info)->merge_info != NULL) 7612 _bfd_merge_sections (obfd, info, elf_hash_table (info)->merge_info, 7613 merge_sections_remove_hook); 7614 return TRUE; 7615} 7616 7617/* Create an entry in an ELF linker hash table. */ 7618 7619struct bfd_hash_entry * 7620_bfd_elf_link_hash_newfunc (struct bfd_hash_entry *entry, 7621 struct bfd_hash_table *table, 7622 const char *string) 7623{ 7624 /* Allocate the structure if it has not already been allocated by a 7625 subclass. */ 7626 if (entry == NULL) 7627 { 7628 entry = (struct bfd_hash_entry *) 7629 bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry)); 7630 if (entry == NULL) 7631 return entry; 7632 } 7633 7634 /* Call the allocation method of the superclass. */ 7635 entry = _bfd_link_hash_newfunc (entry, table, string); 7636 if (entry != NULL) 7637 { 7638 struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry; 7639 struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table; 7640 7641 /* Set local fields. */ 7642 ret->indx = -1; 7643 ret->dynindx = -1; 7644 ret->got = htab->init_got_refcount; 7645 ret->plt = htab->init_plt_refcount; 7646 memset (&ret->size, 0, (sizeof (struct elf_link_hash_entry) 7647 - offsetof (struct elf_link_hash_entry, size))); 7648 /* Assume that we have been called by a non-ELF symbol reader. 7649 This flag is then reset by the code which reads an ELF input 7650 file. This ensures that a symbol created by a non-ELF symbol 7651 reader will have the flag set correctly. */ 7652 ret->non_elf = 1; 7653 } 7654 7655 return entry; 7656} 7657 7658/* Copy data from an indirect symbol to its direct symbol, hiding the 7659 old indirect symbol. Also used for copying flags to a weakdef. */ 7660 7661void 7662_bfd_elf_link_hash_copy_indirect (struct bfd_link_info *info, 7663 struct elf_link_hash_entry *dir, 7664 struct elf_link_hash_entry *ind) 7665{ 7666 struct elf_link_hash_table *htab; 7667 7668 if (ind->dyn_relocs != NULL) 7669 { 7670 if (dir->dyn_relocs != NULL) 7671 { 7672 struct elf_dyn_relocs **pp; 7673 struct elf_dyn_relocs *p; 7674 7675 /* Add reloc counts against the indirect sym to the direct sym 7676 list. Merge any entries against the same section. */ 7677 for (pp = &ind->dyn_relocs; (p = *pp) != NULL; ) 7678 { 7679 struct elf_dyn_relocs *q; 7680 7681 for (q = dir->dyn_relocs; q != NULL; q = q->next) 7682 if (q->sec == p->sec) 7683 { 7684 q->pc_count += p->pc_count; 7685 q->count += p->count; 7686 *pp = p->next; 7687 break; 7688 } 7689 if (q == NULL) 7690 pp = &p->next; 7691 } 7692 *pp = dir->dyn_relocs; 7693 } 7694 7695 dir->dyn_relocs = ind->dyn_relocs; 7696 ind->dyn_relocs = NULL; 7697 } 7698 7699 /* Copy down any references that we may have already seen to the 7700 symbol which just became indirect. */ 7701 7702 if (dir->versioned != versioned_hidden) 7703 dir->ref_dynamic |= ind->ref_dynamic; 7704 dir->ref_regular |= ind->ref_regular; 7705 dir->ref_regular_nonweak |= ind->ref_regular_nonweak; 7706 dir->non_got_ref |= ind->non_got_ref; 7707 dir->needs_plt |= ind->needs_plt; 7708 dir->pointer_equality_needed |= ind->pointer_equality_needed; 7709 7710 if (ind->root.type != bfd_link_hash_indirect) 7711 return; 7712 7713 /* Copy over the global and procedure linkage table refcount entries. 7714 These may have been already set up by a check_relocs routine. */ 7715 htab = elf_hash_table (info); 7716 if (ind->got.refcount > htab->init_got_refcount.refcount) 7717 { 7718 if (dir->got.refcount < 0) 7719 dir->got.refcount = 0; 7720 dir->got.refcount += ind->got.refcount; 7721 ind->got.refcount = htab->init_got_refcount.refcount; 7722 } 7723 7724 if (ind->plt.refcount > htab->init_plt_refcount.refcount) 7725 { 7726 if (dir->plt.refcount < 0) 7727 dir->plt.refcount = 0; 7728 dir->plt.refcount += ind->plt.refcount; 7729 ind->plt.refcount = htab->init_plt_refcount.refcount; 7730 } 7731 7732 if (ind->dynindx != -1) 7733 { 7734 if (dir->dynindx != -1) 7735 _bfd_elf_strtab_delref (htab->dynstr, dir->dynstr_index); 7736 dir->dynindx = ind->dynindx; 7737 dir->dynstr_index = ind->dynstr_index; 7738 ind->dynindx = -1; 7739 ind->dynstr_index = 0; 7740 } 7741} 7742 7743void 7744_bfd_elf_link_hash_hide_symbol (struct bfd_link_info *info, 7745 struct elf_link_hash_entry *h, 7746 bfd_boolean force_local) 7747{ 7748 /* STT_GNU_IFUNC symbol must go through PLT. */ 7749 if (h->type != STT_GNU_IFUNC) 7750 { 7751 h->plt = elf_hash_table (info)->init_plt_offset; 7752 h->needs_plt = 0; 7753 } 7754 if (force_local) 7755 { 7756 h->forced_local = 1; 7757 if (h->dynindx != -1) 7758 { 7759 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr, 7760 h->dynstr_index); 7761 h->dynindx = -1; 7762 h->dynstr_index = 0; 7763 } 7764 } 7765} 7766 7767/* Hide a symbol. */ 7768 7769void 7770_bfd_elf_link_hide_symbol (bfd *output_bfd, 7771 struct bfd_link_info *info, 7772 struct bfd_link_hash_entry *h) 7773{ 7774 if (is_elf_hash_table (info->hash)) 7775 { 7776 const struct elf_backend_data *bed 7777 = get_elf_backend_data (output_bfd); 7778 struct elf_link_hash_entry *eh 7779 = (struct elf_link_hash_entry *) h; 7780 bed->elf_backend_hide_symbol (info, eh, TRUE); 7781 eh->def_dynamic = 0; 7782 eh->ref_dynamic = 0; 7783 eh->dynamic_def = 0; 7784 } 7785} 7786 7787/* Initialize an ELF linker hash table. *TABLE has been zeroed by our 7788 caller. */ 7789 7790bfd_boolean 7791_bfd_elf_link_hash_table_init 7792 (struct elf_link_hash_table *table, 7793 bfd *abfd, 7794 struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *, 7795 struct bfd_hash_table *, 7796 const char *), 7797 unsigned int entsize, 7798 enum elf_target_id target_id) 7799{ 7800 bfd_boolean ret; 7801 int can_refcount = get_elf_backend_data (abfd)->can_refcount; 7802 7803 table->init_got_refcount.refcount = can_refcount - 1; 7804 table->init_plt_refcount.refcount = can_refcount - 1; 7805 table->init_got_offset.offset = -(bfd_vma) 1; 7806 table->init_plt_offset.offset = -(bfd_vma) 1; 7807 /* The first dynamic symbol is a dummy. */ 7808 table->dynsymcount = 1; 7809 7810 ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize); 7811 7812 table->root.type = bfd_link_elf_hash_table; 7813 table->hash_table_id = target_id; 7814 table->target_os = get_elf_backend_data (abfd)->target_os; 7815 7816 return ret; 7817} 7818 7819/* Create an ELF linker hash table. */ 7820 7821struct bfd_link_hash_table * 7822_bfd_elf_link_hash_table_create (bfd *abfd) 7823{ 7824 struct elf_link_hash_table *ret; 7825 size_t amt = sizeof (struct elf_link_hash_table); 7826 7827 ret = (struct elf_link_hash_table *) bfd_zmalloc (amt); 7828 if (ret == NULL) 7829 return NULL; 7830 7831 if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc, 7832 sizeof (struct elf_link_hash_entry), 7833 GENERIC_ELF_DATA)) 7834 { 7835 free (ret); 7836 return NULL; 7837 } 7838 ret->root.hash_table_free = _bfd_elf_link_hash_table_free; 7839 7840 return &ret->root; 7841} 7842 7843/* Destroy an ELF linker hash table. */ 7844 7845void 7846_bfd_elf_link_hash_table_free (bfd *obfd) 7847{ 7848 struct elf_link_hash_table *htab; 7849 7850 htab = (struct elf_link_hash_table *) obfd->link.hash; 7851 if (htab->dynstr != NULL) 7852 _bfd_elf_strtab_free (htab->dynstr); 7853 _bfd_merge_sections_free (htab->merge_info); 7854 _bfd_generic_link_hash_table_free (obfd); 7855} 7856 7857/* This is a hook for the ELF emulation code in the generic linker to 7858 tell the backend linker what file name to use for the DT_NEEDED 7859 entry for a dynamic object. */ 7860 7861void 7862bfd_elf_set_dt_needed_name (bfd *abfd, const char *name) 7863{ 7864 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour 7865 && bfd_get_format (abfd) == bfd_object) 7866 elf_dt_name (abfd) = name; 7867} 7868 7869int 7870bfd_elf_get_dyn_lib_class (bfd *abfd) 7871{ 7872 int lib_class; 7873 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour 7874 && bfd_get_format (abfd) == bfd_object) 7875 lib_class = elf_dyn_lib_class (abfd); 7876 else 7877 lib_class = 0; 7878 return lib_class; 7879} 7880 7881void 7882bfd_elf_set_dyn_lib_class (bfd *abfd, enum dynamic_lib_link_class lib_class) 7883{ 7884 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour 7885 && bfd_get_format (abfd) == bfd_object) 7886 elf_dyn_lib_class (abfd) = lib_class; 7887} 7888 7889/* Get the list of DT_NEEDED entries for a link. This is a hook for 7890 the linker ELF emulation code. */ 7891 7892struct bfd_link_needed_list * 7893bfd_elf_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED, 7894 struct bfd_link_info *info) 7895{ 7896 if (! is_elf_hash_table (info->hash)) 7897 return NULL; 7898 return elf_hash_table (info)->needed; 7899} 7900 7901/* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a 7902 hook for the linker ELF emulation code. */ 7903 7904struct bfd_link_needed_list * 7905bfd_elf_get_runpath_list (bfd *abfd ATTRIBUTE_UNUSED, 7906 struct bfd_link_info *info) 7907{ 7908 if (! is_elf_hash_table (info->hash)) 7909 return NULL; 7910 return elf_hash_table (info)->runpath; 7911} 7912 7913/* Get the name actually used for a dynamic object for a link. This 7914 is the SONAME entry if there is one. Otherwise, it is the string 7915 passed to bfd_elf_set_dt_needed_name, or it is the filename. */ 7916 7917const char * 7918bfd_elf_get_dt_soname (bfd *abfd) 7919{ 7920 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour 7921 && bfd_get_format (abfd) == bfd_object) 7922 return elf_dt_name (abfd); 7923 return NULL; 7924} 7925 7926/* Get the list of DT_NEEDED entries from a BFD. This is a hook for 7927 the ELF linker emulation code. */ 7928 7929bfd_boolean 7930bfd_elf_get_bfd_needed_list (bfd *abfd, 7931 struct bfd_link_needed_list **pneeded) 7932{ 7933 asection *s; 7934 bfd_byte *dynbuf = NULL; 7935 unsigned int elfsec; 7936 unsigned long shlink; 7937 bfd_byte *extdyn, *extdynend; 7938 size_t extdynsize; 7939 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *); 7940 7941 *pneeded = NULL; 7942 7943 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour 7944 || bfd_get_format (abfd) != bfd_object) 7945 return TRUE; 7946 7947 s = bfd_get_section_by_name (abfd, ".dynamic"); 7948 if (s == NULL || s->size == 0) 7949 return TRUE; 7950 7951 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf)) 7952 goto error_return; 7953 7954 elfsec = _bfd_elf_section_from_bfd_section (abfd, s); 7955 if (elfsec == SHN_BAD) 7956 goto error_return; 7957 7958 shlink = elf_elfsections (abfd)[elfsec]->sh_link; 7959 7960 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn; 7961 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in; 7962 7963 extdyn = dynbuf; 7964 extdynend = extdyn + s->size; 7965 for (; extdyn < extdynend; extdyn += extdynsize) 7966 { 7967 Elf_Internal_Dyn dyn; 7968 7969 (*swap_dyn_in) (abfd, extdyn, &dyn); 7970 7971 if (dyn.d_tag == DT_NULL) 7972 break; 7973 7974 if (dyn.d_tag == DT_NEEDED) 7975 { 7976 const char *string; 7977 struct bfd_link_needed_list *l; 7978 unsigned int tagv = dyn.d_un.d_val; 7979 size_t amt; 7980 7981 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv); 7982 if (string == NULL) 7983 goto error_return; 7984 7985 amt = sizeof *l; 7986 l = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt); 7987 if (l == NULL) 7988 goto error_return; 7989 7990 l->by = abfd; 7991 l->name = string; 7992 l->next = *pneeded; 7993 *pneeded = l; 7994 } 7995 } 7996 7997 free (dynbuf); 7998 7999 return TRUE; 8000 8001 error_return: 8002 free (dynbuf); 8003 return FALSE; 8004} 8005 8006struct elf_symbuf_symbol 8007{ 8008 unsigned long st_name; /* Symbol name, index in string tbl */ 8009 unsigned char st_info; /* Type and binding attributes */ 8010 unsigned char st_other; /* Visibilty, and target specific */ 8011}; 8012 8013struct elf_symbuf_head 8014{ 8015 struct elf_symbuf_symbol *ssym; 8016 size_t count; 8017 unsigned int st_shndx; 8018}; 8019 8020struct elf_symbol 8021{ 8022 union 8023 { 8024 Elf_Internal_Sym *isym; 8025 struct elf_symbuf_symbol *ssym; 8026 void *p; 8027 } u; 8028 const char *name; 8029}; 8030 8031/* Sort references to symbols by ascending section number. */ 8032 8033static int 8034elf_sort_elf_symbol (const void *arg1, const void *arg2) 8035{ 8036 const Elf_Internal_Sym *s1 = *(const Elf_Internal_Sym **) arg1; 8037 const Elf_Internal_Sym *s2 = *(const Elf_Internal_Sym **) arg2; 8038 8039 if (s1->st_shndx != s2->st_shndx) 8040 return s1->st_shndx > s2->st_shndx ? 1 : -1; 8041 /* Final sort by the address of the sym in the symbuf ensures 8042 a stable sort. */ 8043 if (s1 != s2) 8044 return s1 > s2 ? 1 : -1; 8045 return 0; 8046} 8047 8048static int 8049elf_sym_name_compare (const void *arg1, const void *arg2) 8050{ 8051 const struct elf_symbol *s1 = (const struct elf_symbol *) arg1; 8052 const struct elf_symbol *s2 = (const struct elf_symbol *) arg2; 8053 int ret = strcmp (s1->name, s2->name); 8054 if (ret != 0) 8055 return ret; 8056 if (s1->u.p != s2->u.p) 8057 return s1->u.p > s2->u.p ? 1 : -1; 8058 return 0; 8059} 8060 8061static struct elf_symbuf_head * 8062elf_create_symbuf (size_t symcount, Elf_Internal_Sym *isymbuf) 8063{ 8064 Elf_Internal_Sym **ind, **indbufend, **indbuf; 8065 struct elf_symbuf_symbol *ssym; 8066 struct elf_symbuf_head *ssymbuf, *ssymhead; 8067 size_t i, shndx_count, total_size, amt; 8068 8069 amt = symcount * sizeof (*indbuf); 8070 indbuf = (Elf_Internal_Sym **) bfd_malloc (amt); 8071 if (indbuf == NULL) 8072 return NULL; 8073 8074 for (ind = indbuf, i = 0; i < symcount; i++) 8075 if (isymbuf[i].st_shndx != SHN_UNDEF) 8076 *ind++ = &isymbuf[i]; 8077 indbufend = ind; 8078 8079 qsort (indbuf, indbufend - indbuf, sizeof (Elf_Internal_Sym *), 8080 elf_sort_elf_symbol); 8081 8082 shndx_count = 0; 8083 if (indbufend > indbuf) 8084 for (ind = indbuf, shndx_count++; ind < indbufend - 1; ind++) 8085 if (ind[0]->st_shndx != ind[1]->st_shndx) 8086 shndx_count++; 8087 8088 total_size = ((shndx_count + 1) * sizeof (*ssymbuf) 8089 + (indbufend - indbuf) * sizeof (*ssym)); 8090 ssymbuf = (struct elf_symbuf_head *) bfd_malloc (total_size); 8091 if (ssymbuf == NULL) 8092 { 8093 free (indbuf); 8094 return NULL; 8095 } 8096 8097 ssym = (struct elf_symbuf_symbol *) (ssymbuf + shndx_count + 1); 8098 ssymbuf->ssym = NULL; 8099 ssymbuf->count = shndx_count; 8100 ssymbuf->st_shndx = 0; 8101 for (ssymhead = ssymbuf, ind = indbuf; ind < indbufend; ssym++, ind++) 8102 { 8103 if (ind == indbuf || ssymhead->st_shndx != (*ind)->st_shndx) 8104 { 8105 ssymhead++; 8106 ssymhead->ssym = ssym; 8107 ssymhead->count = 0; 8108 ssymhead->st_shndx = (*ind)->st_shndx; 8109 } 8110 ssym->st_name = (*ind)->st_name; 8111 ssym->st_info = (*ind)->st_info; 8112 ssym->st_other = (*ind)->st_other; 8113 ssymhead->count++; 8114 } 8115 BFD_ASSERT ((size_t) (ssymhead - ssymbuf) == shndx_count 8116 && (((bfd_hostptr_t) ssym - (bfd_hostptr_t) ssymbuf) 8117 == total_size)); 8118 8119 free (indbuf); 8120 return ssymbuf; 8121} 8122 8123/* Check if 2 sections define the same set of local and global 8124 symbols. */ 8125 8126static bfd_boolean 8127bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2, 8128 struct bfd_link_info *info) 8129{ 8130 bfd *bfd1, *bfd2; 8131 const struct elf_backend_data *bed1, *bed2; 8132 Elf_Internal_Shdr *hdr1, *hdr2; 8133 size_t symcount1, symcount2; 8134 Elf_Internal_Sym *isymbuf1, *isymbuf2; 8135 struct elf_symbuf_head *ssymbuf1, *ssymbuf2; 8136 Elf_Internal_Sym *isym, *isymend; 8137 struct elf_symbol *symtable1 = NULL, *symtable2 = NULL; 8138 size_t count1, count2, i; 8139 unsigned int shndx1, shndx2; 8140 bfd_boolean result; 8141 8142 bfd1 = sec1->owner; 8143 bfd2 = sec2->owner; 8144 8145 /* Both sections have to be in ELF. */ 8146 if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour 8147 || bfd_get_flavour (bfd2) != bfd_target_elf_flavour) 8148 return FALSE; 8149 8150 if (elf_section_type (sec1) != elf_section_type (sec2)) 8151 return FALSE; 8152 8153 shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1); 8154 shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2); 8155 if (shndx1 == SHN_BAD || shndx2 == SHN_BAD) 8156 return FALSE; 8157 8158 bed1 = get_elf_backend_data (bfd1); 8159 bed2 = get_elf_backend_data (bfd2); 8160 hdr1 = &elf_tdata (bfd1)->symtab_hdr; 8161 symcount1 = hdr1->sh_size / bed1->s->sizeof_sym; 8162 hdr2 = &elf_tdata (bfd2)->symtab_hdr; 8163 symcount2 = hdr2->sh_size / bed2->s->sizeof_sym; 8164 8165 if (symcount1 == 0 || symcount2 == 0) 8166 return FALSE; 8167 8168 result = FALSE; 8169 isymbuf1 = NULL; 8170 isymbuf2 = NULL; 8171 ssymbuf1 = (struct elf_symbuf_head *) elf_tdata (bfd1)->symbuf; 8172 ssymbuf2 = (struct elf_symbuf_head *) elf_tdata (bfd2)->symbuf; 8173 8174 if (ssymbuf1 == NULL) 8175 { 8176 isymbuf1 = bfd_elf_get_elf_syms (bfd1, hdr1, symcount1, 0, 8177 NULL, NULL, NULL); 8178 if (isymbuf1 == NULL) 8179 goto done; 8180 8181 if (info != NULL && !info->reduce_memory_overheads) 8182 { 8183 ssymbuf1 = elf_create_symbuf (symcount1, isymbuf1); 8184 elf_tdata (bfd1)->symbuf = ssymbuf1; 8185 } 8186 } 8187 8188 if (ssymbuf1 == NULL || ssymbuf2 == NULL) 8189 { 8190 isymbuf2 = bfd_elf_get_elf_syms (bfd2, hdr2, symcount2, 0, 8191 NULL, NULL, NULL); 8192 if (isymbuf2 == NULL) 8193 goto done; 8194 8195 if (ssymbuf1 != NULL && info != NULL && !info->reduce_memory_overheads) 8196 { 8197 ssymbuf2 = elf_create_symbuf (symcount2, isymbuf2); 8198 elf_tdata (bfd2)->symbuf = ssymbuf2; 8199 } 8200 } 8201 8202 if (ssymbuf1 != NULL && ssymbuf2 != NULL) 8203 { 8204 /* Optimized faster version. */ 8205 size_t lo, hi, mid; 8206 struct elf_symbol *symp; 8207 struct elf_symbuf_symbol *ssym, *ssymend; 8208 8209 lo = 0; 8210 hi = ssymbuf1->count; 8211 ssymbuf1++; 8212 count1 = 0; 8213 while (lo < hi) 8214 { 8215 mid = (lo + hi) / 2; 8216 if (shndx1 < ssymbuf1[mid].st_shndx) 8217 hi = mid; 8218 else if (shndx1 > ssymbuf1[mid].st_shndx) 8219 lo = mid + 1; 8220 else 8221 { 8222 count1 = ssymbuf1[mid].count; 8223 ssymbuf1 += mid; 8224 break; 8225 } 8226 } 8227 8228 lo = 0; 8229 hi = ssymbuf2->count; 8230 ssymbuf2++; 8231 count2 = 0; 8232 while (lo < hi) 8233 { 8234 mid = (lo + hi) / 2; 8235 if (shndx2 < ssymbuf2[mid].st_shndx) 8236 hi = mid; 8237 else if (shndx2 > ssymbuf2[mid].st_shndx) 8238 lo = mid + 1; 8239 else 8240 { 8241 count2 = ssymbuf2[mid].count; 8242 ssymbuf2 += mid; 8243 break; 8244 } 8245 } 8246 8247 if (count1 == 0 || count2 == 0 || count1 != count2) 8248 goto done; 8249 8250 symtable1 8251 = (struct elf_symbol *) bfd_malloc (count1 * sizeof (*symtable1)); 8252 symtable2 8253 = (struct elf_symbol *) bfd_malloc (count2 * sizeof (*symtable2)); 8254 if (symtable1 == NULL || symtable2 == NULL) 8255 goto done; 8256 8257 symp = symtable1; 8258 for (ssym = ssymbuf1->ssym, ssymend = ssym + count1; 8259 ssym < ssymend; ssym++, symp++) 8260 { 8261 symp->u.ssym = ssym; 8262 symp->name = bfd_elf_string_from_elf_section (bfd1, 8263 hdr1->sh_link, 8264 ssym->st_name); 8265 } 8266 8267 symp = symtable2; 8268 for (ssym = ssymbuf2->ssym, ssymend = ssym + count2; 8269 ssym < ssymend; ssym++, symp++) 8270 { 8271 symp->u.ssym = ssym; 8272 symp->name = bfd_elf_string_from_elf_section (bfd2, 8273 hdr2->sh_link, 8274 ssym->st_name); 8275 } 8276 8277 /* Sort symbol by name. */ 8278 qsort (symtable1, count1, sizeof (struct elf_symbol), 8279 elf_sym_name_compare); 8280 qsort (symtable2, count1, sizeof (struct elf_symbol), 8281 elf_sym_name_compare); 8282 8283 for (i = 0; i < count1; i++) 8284 /* Two symbols must have the same binding, type and name. */ 8285 if (symtable1 [i].u.ssym->st_info != symtable2 [i].u.ssym->st_info 8286 || symtable1 [i].u.ssym->st_other != symtable2 [i].u.ssym->st_other 8287 || strcmp (symtable1 [i].name, symtable2 [i].name) != 0) 8288 goto done; 8289 8290 result = TRUE; 8291 goto done; 8292 } 8293 8294 symtable1 = (struct elf_symbol *) 8295 bfd_malloc (symcount1 * sizeof (struct elf_symbol)); 8296 symtable2 = (struct elf_symbol *) 8297 bfd_malloc (symcount2 * sizeof (struct elf_symbol)); 8298 if (symtable1 == NULL || symtable2 == NULL) 8299 goto done; 8300 8301 /* Count definitions in the section. */ 8302 count1 = 0; 8303 for (isym = isymbuf1, isymend = isym + symcount1; isym < isymend; isym++) 8304 if (isym->st_shndx == shndx1) 8305 symtable1[count1++].u.isym = isym; 8306 8307 count2 = 0; 8308 for (isym = isymbuf2, isymend = isym + symcount2; isym < isymend; isym++) 8309 if (isym->st_shndx == shndx2) 8310 symtable2[count2++].u.isym = isym; 8311 8312 if (count1 == 0 || count2 == 0 || count1 != count2) 8313 goto done; 8314 8315 for (i = 0; i < count1; i++) 8316 symtable1[i].name 8317 = bfd_elf_string_from_elf_section (bfd1, hdr1->sh_link, 8318 symtable1[i].u.isym->st_name); 8319 8320 for (i = 0; i < count2; i++) 8321 symtable2[i].name 8322 = bfd_elf_string_from_elf_section (bfd2, hdr2->sh_link, 8323 symtable2[i].u.isym->st_name); 8324 8325 /* Sort symbol by name. */ 8326 qsort (symtable1, count1, sizeof (struct elf_symbol), 8327 elf_sym_name_compare); 8328 qsort (symtable2, count1, sizeof (struct elf_symbol), 8329 elf_sym_name_compare); 8330 8331 for (i = 0; i < count1; i++) 8332 /* Two symbols must have the same binding, type and name. */ 8333 if (symtable1 [i].u.isym->st_info != symtable2 [i].u.isym->st_info 8334 || symtable1 [i].u.isym->st_other != symtable2 [i].u.isym->st_other 8335 || strcmp (symtable1 [i].name, symtable2 [i].name) != 0) 8336 goto done; 8337 8338 result = TRUE; 8339 8340 done: 8341 free (symtable1); 8342 free (symtable2); 8343 free (isymbuf1); 8344 free (isymbuf2); 8345 8346 return result; 8347} 8348 8349/* Return TRUE if 2 section types are compatible. */ 8350 8351bfd_boolean 8352_bfd_elf_match_sections_by_type (bfd *abfd, const asection *asec, 8353 bfd *bbfd, const asection *bsec) 8354{ 8355 if (asec == NULL 8356 || bsec == NULL 8357 || abfd->xvec->flavour != bfd_target_elf_flavour 8358 || bbfd->xvec->flavour != bfd_target_elf_flavour) 8359 return TRUE; 8360 8361 return elf_section_type (asec) == elf_section_type (bsec); 8362} 8363 8364/* Final phase of ELF linker. */ 8365 8366/* A structure we use to avoid passing large numbers of arguments. */ 8367 8368struct elf_final_link_info 8369{ 8370 /* General link information. */ 8371 struct bfd_link_info *info; 8372 /* Output BFD. */ 8373 bfd *output_bfd; 8374 /* Symbol string table. */ 8375 struct elf_strtab_hash *symstrtab; 8376 /* .hash section. */ 8377 asection *hash_sec; 8378 /* symbol version section (.gnu.version). */ 8379 asection *symver_sec; 8380 /* Buffer large enough to hold contents of any section. */ 8381 bfd_byte *contents; 8382 /* Buffer large enough to hold external relocs of any section. */ 8383 void *external_relocs; 8384 /* Buffer large enough to hold internal relocs of any section. */ 8385 Elf_Internal_Rela *internal_relocs; 8386 /* Buffer large enough to hold external local symbols of any input 8387 BFD. */ 8388 bfd_byte *external_syms; 8389 /* And a buffer for symbol section indices. */ 8390 Elf_External_Sym_Shndx *locsym_shndx; 8391 /* Buffer large enough to hold internal local symbols of any input 8392 BFD. */ 8393 Elf_Internal_Sym *internal_syms; 8394 /* Array large enough to hold a symbol index for each local symbol 8395 of any input BFD. */ 8396 long *indices; 8397 /* Array large enough to hold a section pointer for each local 8398 symbol of any input BFD. */ 8399 asection **sections; 8400 /* Buffer for SHT_SYMTAB_SHNDX section. */ 8401 Elf_External_Sym_Shndx *symshndxbuf; 8402 /* Number of STT_FILE syms seen. */ 8403 size_t filesym_count; 8404 /* Local symbol hash table. */ 8405 struct bfd_hash_table local_hash_table; 8406}; 8407 8408struct local_hash_entry 8409{ 8410 /* Base hash table entry structure. */ 8411 struct bfd_hash_entry root; 8412 /* Size of the local symbol name. */ 8413 size_t size; 8414 /* Number of the duplicated local symbol names. */ 8415 long count; 8416}; 8417 8418/* Create an entry in the local symbol hash table. */ 8419 8420static struct bfd_hash_entry * 8421local_hash_newfunc (struct bfd_hash_entry *entry, 8422 struct bfd_hash_table *table, 8423 const char *string) 8424{ 8425 8426 /* Allocate the structure if it has not already been allocated by a 8427 subclass. */ 8428 if (entry == NULL) 8429 { 8430 entry = bfd_hash_allocate (table, 8431 sizeof (struct local_hash_entry)); 8432 if (entry == NULL) 8433 return entry; 8434 } 8435 8436 /* Call the allocation method of the superclass. */ 8437 entry = bfd_hash_newfunc (entry, table, string); 8438 if (entry != NULL) 8439 { 8440 ((struct local_hash_entry *) entry)->count = 0; 8441 ((struct local_hash_entry *) entry)->size = 0; 8442 } 8443 8444 return entry; 8445} 8446 8447/* This struct is used to pass information to elf_link_output_extsym. */ 8448 8449struct elf_outext_info 8450{ 8451 bfd_boolean failed; 8452 bfd_boolean localsyms; 8453 bfd_boolean file_sym_done; 8454 struct elf_final_link_info *flinfo; 8455}; 8456 8457 8458/* Support for evaluating a complex relocation. 8459 8460 Complex relocations are generalized, self-describing relocations. The 8461 implementation of them consists of two parts: complex symbols, and the 8462 relocations themselves. 8463 8464 The relocations use a reserved elf-wide relocation type code (R_RELC 8465 external / BFD_RELOC_RELC internal) and an encoding of relocation field 8466 information (start bit, end bit, word width, etc) into the addend. This 8467 information is extracted from CGEN-generated operand tables within gas. 8468 8469 Complex symbols are mangled symbols (STT_RELC external / BSF_RELC 8470 internal) representing prefix-notation expressions, including but not 8471 limited to those sorts of expressions normally encoded as addends in the 8472 addend field. The symbol mangling format is: 8473 8474 <node> := <literal> 8475 | <unary-operator> ':' <node> 8476 | <binary-operator> ':' <node> ':' <node> 8477 ; 8478 8479 <literal> := 's' <digits=N> ':' <N character symbol name> 8480 | 'S' <digits=N> ':' <N character section name> 8481 | '#' <hexdigits> 8482 ; 8483 8484 <binary-operator> := as in C 8485 <unary-operator> := as in C, plus "0-" for unambiguous negation. */ 8486 8487static void 8488set_symbol_value (bfd *bfd_with_globals, 8489 Elf_Internal_Sym *isymbuf, 8490 size_t locsymcount, 8491 size_t symidx, 8492 bfd_vma val) 8493{ 8494 struct elf_link_hash_entry **sym_hashes; 8495 struct elf_link_hash_entry *h; 8496 size_t extsymoff = locsymcount; 8497 8498 if (symidx < locsymcount) 8499 { 8500 Elf_Internal_Sym *sym; 8501 8502 sym = isymbuf + symidx; 8503 if (ELF_ST_BIND (sym->st_info) == STB_LOCAL) 8504 { 8505 /* It is a local symbol: move it to the 8506 "absolute" section and give it a value. */ 8507 sym->st_shndx = SHN_ABS; 8508 sym->st_value = val; 8509 return; 8510 } 8511 BFD_ASSERT (elf_bad_symtab (bfd_with_globals)); 8512 extsymoff = 0; 8513 } 8514 8515 /* It is a global symbol: set its link type 8516 to "defined" and give it a value. */ 8517 8518 sym_hashes = elf_sym_hashes (bfd_with_globals); 8519 h = sym_hashes [symidx - extsymoff]; 8520 while (h->root.type == bfd_link_hash_indirect 8521 || h->root.type == bfd_link_hash_warning) 8522 h = (struct elf_link_hash_entry *) h->root.u.i.link; 8523 h->root.type = bfd_link_hash_defined; 8524 h->root.u.def.value = val; 8525 h->root.u.def.section = bfd_abs_section_ptr; 8526} 8527 8528static bfd_boolean 8529resolve_symbol (const char *name, 8530 bfd *input_bfd, 8531 struct elf_final_link_info *flinfo, 8532 bfd_vma *result, 8533 Elf_Internal_Sym *isymbuf, 8534 size_t locsymcount) 8535{ 8536 Elf_Internal_Sym *sym; 8537 struct bfd_link_hash_entry *global_entry; 8538 const char *candidate = NULL; 8539 Elf_Internal_Shdr *symtab_hdr; 8540 size_t i; 8541 8542 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; 8543 8544 for (i = 0; i < locsymcount; ++ i) 8545 { 8546 sym = isymbuf + i; 8547 8548 if (ELF_ST_BIND (sym->st_info) != STB_LOCAL) 8549 continue; 8550 8551 candidate = bfd_elf_string_from_elf_section (input_bfd, 8552 symtab_hdr->sh_link, 8553 sym->st_name); 8554#ifdef DEBUG 8555 printf ("Comparing string: '%s' vs. '%s' = 0x%lx\n", 8556 name, candidate, (unsigned long) sym->st_value); 8557#endif 8558 if (candidate && strcmp (candidate, name) == 0) 8559 { 8560 asection *sec = flinfo->sections [i]; 8561 8562 *result = _bfd_elf_rel_local_sym (input_bfd, sym, &sec, 0); 8563 *result += sec->output_offset + sec->output_section->vma; 8564#ifdef DEBUG 8565 printf ("Found symbol with value %8.8lx\n", 8566 (unsigned long) *result); 8567#endif 8568 return TRUE; 8569 } 8570 } 8571 8572 /* Hmm, haven't found it yet. perhaps it is a global. */ 8573 global_entry = bfd_link_hash_lookup (flinfo->info->hash, name, 8574 FALSE, FALSE, TRUE); 8575 if (!global_entry) 8576 return FALSE; 8577 8578 if (global_entry->type == bfd_link_hash_defined 8579 || global_entry->type == bfd_link_hash_defweak) 8580 { 8581 *result = (global_entry->u.def.value 8582 + global_entry->u.def.section->output_section->vma 8583 + global_entry->u.def.section->output_offset); 8584#ifdef DEBUG 8585 printf ("Found GLOBAL symbol '%s' with value %8.8lx\n", 8586 global_entry->root.string, (unsigned long) *result); 8587#endif 8588 return TRUE; 8589 } 8590 8591 return FALSE; 8592} 8593 8594/* Looks up NAME in SECTIONS. If found sets RESULT to NAME's address (in 8595 bytes) and returns TRUE, otherwise returns FALSE. Accepts pseudo-section 8596 names like "foo.end" which is the end address of section "foo". */ 8597 8598static bfd_boolean 8599resolve_section (const char *name, 8600 asection *sections, 8601 bfd_vma *result, 8602 bfd * abfd) 8603{ 8604 asection *curr; 8605 unsigned int len; 8606 8607 for (curr = sections; curr; curr = curr->next) 8608 if (strcmp (curr->name, name) == 0) 8609 { 8610 *result = curr->vma; 8611 return TRUE; 8612 } 8613 8614 /* Hmm. still haven't found it. try pseudo-section names. */ 8615 /* FIXME: This could be coded more efficiently... */ 8616 for (curr = sections; curr; curr = curr->next) 8617 { 8618 len = strlen (curr->name); 8619 if (len > strlen (name)) 8620 continue; 8621 8622 if (strncmp (curr->name, name, len) == 0) 8623 { 8624 if (strncmp (".end", name + len, 4) == 0) 8625 { 8626 *result = (curr->vma 8627 + curr->size / bfd_octets_per_byte (abfd, curr)); 8628 return TRUE; 8629 } 8630 8631 /* Insert more pseudo-section names here, if you like. */ 8632 } 8633 } 8634 8635 return FALSE; 8636} 8637 8638static void 8639undefined_reference (const char *reftype, const char *name) 8640{ 8641 /* xgettext:c-format */ 8642 _bfd_error_handler (_("undefined %s reference in complex symbol: %s"), 8643 reftype, name); 8644 bfd_set_error (bfd_error_bad_value); 8645} 8646 8647static bfd_boolean 8648eval_symbol (bfd_vma *result, 8649 const char **symp, 8650 bfd *input_bfd, 8651 struct elf_final_link_info *flinfo, 8652 bfd_vma dot, 8653 Elf_Internal_Sym *isymbuf, 8654 size_t locsymcount, 8655 int signed_p) 8656{ 8657 size_t len; 8658 size_t symlen; 8659 bfd_vma a; 8660 bfd_vma b; 8661 char symbuf[4096]; 8662 const char *sym = *symp; 8663 const char *symend; 8664 bfd_boolean symbol_is_section = FALSE; 8665 8666 len = strlen (sym); 8667 symend = sym + len; 8668 8669 if (len < 1 || len > sizeof (symbuf)) 8670 { 8671 bfd_set_error (bfd_error_invalid_operation); 8672 return FALSE; 8673 } 8674 8675 switch (* sym) 8676 { 8677 case '.': 8678 *result = dot; 8679 *symp = sym + 1; 8680 return TRUE; 8681 8682 case '#': 8683 ++sym; 8684 *result = strtoul (sym, (char **) symp, 16); 8685 return TRUE; 8686 8687 case 'S': 8688 symbol_is_section = TRUE; 8689 /* Fall through. */ 8690 case 's': 8691 ++sym; 8692 symlen = strtol (sym, (char **) symp, 10); 8693 sym = *symp + 1; /* Skip the trailing ':'. */ 8694 8695 if (symend < sym || symlen + 1 > sizeof (symbuf)) 8696 { 8697 bfd_set_error (bfd_error_invalid_operation); 8698 return FALSE; 8699 } 8700 8701 memcpy (symbuf, sym, symlen); 8702 symbuf[symlen] = '\0'; 8703 *symp = sym + symlen; 8704 8705 /* Is it always possible, with complex symbols, that gas "mis-guessed" 8706 the symbol as a section, or vice-versa. so we're pretty liberal in our 8707 interpretation here; section means "try section first", not "must be a 8708 section", and likewise with symbol. */ 8709 8710 if (symbol_is_section) 8711 { 8712 if (!resolve_section (symbuf, flinfo->output_bfd->sections, result, input_bfd) 8713 && !resolve_symbol (symbuf, input_bfd, flinfo, result, 8714 isymbuf, locsymcount)) 8715 { 8716 undefined_reference ("section", symbuf); 8717 return FALSE; 8718 } 8719 } 8720 else 8721 { 8722 if (!resolve_symbol (symbuf, input_bfd, flinfo, result, 8723 isymbuf, locsymcount) 8724 && !resolve_section (symbuf, flinfo->output_bfd->sections, 8725 result, input_bfd)) 8726 { 8727 undefined_reference ("symbol", symbuf); 8728 return FALSE; 8729 } 8730 } 8731 8732 return TRUE; 8733 8734 /* All that remains are operators. */ 8735 8736#define UNARY_OP(op) \ 8737 if (strncmp (sym, #op, strlen (#op)) == 0) \ 8738 { \ 8739 sym += strlen (#op); \ 8740 if (*sym == ':') \ 8741 ++sym; \ 8742 *symp = sym; \ 8743 if (!eval_symbol (&a, symp, input_bfd, flinfo, dot, \ 8744 isymbuf, locsymcount, signed_p)) \ 8745 return FALSE; \ 8746 if (signed_p) \ 8747 *result = op ((bfd_signed_vma) a); \ 8748 else \ 8749 *result = op a; \ 8750 return TRUE; \ 8751 } 8752 8753#define BINARY_OP_HEAD(op) \ 8754 if (strncmp (sym, #op, strlen (#op)) == 0) \ 8755 { \ 8756 sym += strlen (#op); \ 8757 if (*sym == ':') \ 8758 ++sym; \ 8759 *symp = sym; \ 8760 if (!eval_symbol (&a, symp, input_bfd, flinfo, dot, \ 8761 isymbuf, locsymcount, signed_p)) \ 8762 return FALSE; \ 8763 ++*symp; \ 8764 if (!eval_symbol (&b, symp, input_bfd, flinfo, dot, \ 8765 isymbuf, locsymcount, signed_p)) \ 8766 return FALSE; 8767#define BINARY_OP_TAIL(op) \ 8768 if (signed_p) \ 8769 *result = ((bfd_signed_vma) a) op ((bfd_signed_vma) b); \ 8770 else \ 8771 *result = a op b; \ 8772 return TRUE; \ 8773 } 8774#define BINARY_OP(op) BINARY_OP_HEAD(op) BINARY_OP_TAIL(op) 8775 8776 default: 8777 UNARY_OP (0-); 8778 BINARY_OP_HEAD (<<); 8779 if (b >= sizeof (a) * CHAR_BIT) 8780 { 8781 *result = 0; 8782 return TRUE; 8783 } 8784 signed_p = 0; 8785 BINARY_OP_TAIL (<<); 8786 BINARY_OP_HEAD (>>); 8787 if (b >= sizeof (a) * CHAR_BIT) 8788 { 8789 *result = signed_p && (bfd_signed_vma) a < 0 ? -1 : 0; 8790 return TRUE; 8791 } 8792 BINARY_OP_TAIL (>>); 8793 BINARY_OP (==); 8794 BINARY_OP (!=); 8795 BINARY_OP (<=); 8796 BINARY_OP (>=); 8797 BINARY_OP (&&); 8798 BINARY_OP (||); 8799 UNARY_OP (~); 8800 UNARY_OP (!); 8801 BINARY_OP (*); 8802 BINARY_OP_HEAD (/); 8803 if (b == 0) 8804 { 8805 _bfd_error_handler (_("division by zero")); 8806 bfd_set_error (bfd_error_bad_value); 8807 return FALSE; 8808 } 8809 BINARY_OP_TAIL (/); 8810 BINARY_OP_HEAD (%); 8811 if (b == 0) 8812 { 8813 _bfd_error_handler (_("division by zero")); 8814 bfd_set_error (bfd_error_bad_value); 8815 return FALSE; 8816 } 8817 BINARY_OP_TAIL (%); 8818 BINARY_OP (^); 8819 BINARY_OP (|); 8820 BINARY_OP (&); 8821 BINARY_OP (+); 8822 BINARY_OP (-); 8823 BINARY_OP (<); 8824 BINARY_OP (>); 8825#undef UNARY_OP 8826#undef BINARY_OP 8827 _bfd_error_handler (_("unknown operator '%c' in complex symbol"), * sym); 8828 bfd_set_error (bfd_error_invalid_operation); 8829 return FALSE; 8830 } 8831} 8832 8833static void 8834put_value (bfd_vma size, 8835 unsigned long chunksz, 8836 bfd *input_bfd, 8837 bfd_vma x, 8838 bfd_byte *location) 8839{ 8840 location += (size - chunksz); 8841 8842 for (; size; size -= chunksz, location -= chunksz) 8843 { 8844 switch (chunksz) 8845 { 8846 case 1: 8847 bfd_put_8 (input_bfd, x, location); 8848 x >>= 8; 8849 break; 8850 case 2: 8851 bfd_put_16 (input_bfd, x, location); 8852 x >>= 16; 8853 break; 8854 case 4: 8855 bfd_put_32 (input_bfd, x, location); 8856 /* Computed this way because x >>= 32 is undefined if x is a 32-bit value. */ 8857 x >>= 16; 8858 x >>= 16; 8859 break; 8860#ifdef BFD64 8861 case 8: 8862 bfd_put_64 (input_bfd, x, location); 8863 /* Computed this way because x >>= 64 is undefined if x is a 64-bit value. */ 8864 x >>= 32; 8865 x >>= 32; 8866 break; 8867#endif 8868 default: 8869 abort (); 8870 break; 8871 } 8872 } 8873} 8874 8875static bfd_vma 8876get_value (bfd_vma size, 8877 unsigned long chunksz, 8878 bfd *input_bfd, 8879 bfd_byte *location) 8880{ 8881 int shift; 8882 bfd_vma x = 0; 8883 8884 /* Sanity checks. */ 8885 BFD_ASSERT (chunksz <= sizeof (x) 8886 && size >= chunksz 8887 && chunksz != 0 8888 && (size % chunksz) == 0 8889 && input_bfd != NULL 8890 && location != NULL); 8891 8892 if (chunksz == sizeof (x)) 8893 { 8894 BFD_ASSERT (size == chunksz); 8895 8896 /* Make sure that we do not perform an undefined shift operation. 8897 We know that size == chunksz so there will only be one iteration 8898 of the loop below. */ 8899 shift = 0; 8900 } 8901 else 8902 shift = 8 * chunksz; 8903 8904 for (; size; size -= chunksz, location += chunksz) 8905 { 8906 switch (chunksz) 8907 { 8908 case 1: 8909 x = (x << shift) | bfd_get_8 (input_bfd, location); 8910 break; 8911 case 2: 8912 x = (x << shift) | bfd_get_16 (input_bfd, location); 8913 break; 8914 case 4: 8915 x = (x << shift) | bfd_get_32 (input_bfd, location); 8916 break; 8917#ifdef BFD64 8918 case 8: 8919 x = (x << shift) | bfd_get_64 (input_bfd, location); 8920 break; 8921#endif 8922 default: 8923 abort (); 8924 } 8925 } 8926 return x; 8927} 8928 8929static void 8930decode_complex_addend (unsigned long *start, /* in bits */ 8931 unsigned long *oplen, /* in bits */ 8932 unsigned long *len, /* in bits */ 8933 unsigned long *wordsz, /* in bytes */ 8934 unsigned long *chunksz, /* in bytes */ 8935 unsigned long *lsb0_p, 8936 unsigned long *signed_p, 8937 unsigned long *trunc_p, 8938 unsigned long encoded) 8939{ 8940 * start = encoded & 0x3F; 8941 * len = (encoded >> 6) & 0x3F; 8942 * oplen = (encoded >> 12) & 0x3F; 8943 * wordsz = (encoded >> 18) & 0xF; 8944 * chunksz = (encoded >> 22) & 0xF; 8945 * lsb0_p = (encoded >> 27) & 1; 8946 * signed_p = (encoded >> 28) & 1; 8947 * trunc_p = (encoded >> 29) & 1; 8948} 8949 8950bfd_reloc_status_type 8951bfd_elf_perform_complex_relocation (bfd *input_bfd, 8952 asection *input_section, 8953 bfd_byte *contents, 8954 Elf_Internal_Rela *rel, 8955 bfd_vma relocation) 8956{ 8957 bfd_vma shift, x, mask; 8958 unsigned long start, oplen, len, wordsz, chunksz, lsb0_p, signed_p, trunc_p; 8959 bfd_reloc_status_type r; 8960 bfd_size_type octets; 8961 8962 /* Perform this reloc, since it is complex. 8963 (this is not to say that it necessarily refers to a complex 8964 symbol; merely that it is a self-describing CGEN based reloc. 8965 i.e. the addend has the complete reloc information (bit start, end, 8966 word size, etc) encoded within it.). */ 8967 8968 decode_complex_addend (&start, &oplen, &len, &wordsz, 8969 &chunksz, &lsb0_p, &signed_p, 8970 &trunc_p, rel->r_addend); 8971 8972 mask = (((1L << (len - 1)) - 1) << 1) | 1; 8973 8974 if (lsb0_p) 8975 shift = (start + 1) - len; 8976 else 8977 shift = (8 * wordsz) - (start + len); 8978 8979 octets = rel->r_offset * bfd_octets_per_byte (input_bfd, input_section); 8980 x = get_value (wordsz, chunksz, input_bfd, contents + octets); 8981 8982#ifdef DEBUG 8983 printf ("Doing complex reloc: " 8984 "lsb0? %ld, signed? %ld, trunc? %ld, wordsz %ld, " 8985 "chunksz %ld, start %ld, len %ld, oplen %ld\n" 8986 " dest: %8.8lx, mask: %8.8lx, reloc: %8.8lx\n", 8987 lsb0_p, signed_p, trunc_p, wordsz, chunksz, start, len, 8988 oplen, (unsigned long) x, (unsigned long) mask, 8989 (unsigned long) relocation); 8990#endif 8991 8992 r = bfd_reloc_ok; 8993 if (! trunc_p) 8994 /* Now do an overflow check. */ 8995 r = bfd_check_overflow ((signed_p 8996 ? complain_overflow_signed 8997 : complain_overflow_unsigned), 8998 len, 0, (8 * wordsz), 8999 relocation); 9000 9001 /* Do the deed. */ 9002 x = (x & ~(mask << shift)) | ((relocation & mask) << shift); 9003 9004#ifdef DEBUG 9005 printf (" relocation: %8.8lx\n" 9006 " shifted mask: %8.8lx\n" 9007 " shifted/masked reloc: %8.8lx\n" 9008 " result: %8.8lx\n", 9009 (unsigned long) relocation, (unsigned long) (mask << shift), 9010 (unsigned long) ((relocation & mask) << shift), (unsigned long) x); 9011#endif 9012 put_value (wordsz, chunksz, input_bfd, x, contents + octets); 9013 return r; 9014} 9015 9016/* Functions to read r_offset from external (target order) reloc 9017 entry. Faster than bfd_getl32 et al, because we let the compiler 9018 know the value is aligned. */ 9019 9020static bfd_vma 9021ext32l_r_offset (const void *p) 9022{ 9023 union aligned32 9024 { 9025 uint32_t v; 9026 unsigned char c[4]; 9027 }; 9028 const union aligned32 *a 9029 = (const union aligned32 *) &((const Elf32_External_Rel *) p)->r_offset; 9030 9031 uint32_t aval = ( (uint32_t) a->c[0] 9032 | (uint32_t) a->c[1] << 8 9033 | (uint32_t) a->c[2] << 16 9034 | (uint32_t) a->c[3] << 24); 9035 return aval; 9036} 9037 9038static bfd_vma 9039ext32b_r_offset (const void *p) 9040{ 9041 union aligned32 9042 { 9043 uint32_t v; 9044 unsigned char c[4]; 9045 }; 9046 const union aligned32 *a 9047 = (const union aligned32 *) &((const Elf32_External_Rel *) p)->r_offset; 9048 9049 uint32_t aval = ( (uint32_t) a->c[0] << 24 9050 | (uint32_t) a->c[1] << 16 9051 | (uint32_t) a->c[2] << 8 9052 | (uint32_t) a->c[3]); 9053 return aval; 9054} 9055 9056#ifdef BFD_HOST_64_BIT 9057static bfd_vma 9058ext64l_r_offset (const void *p) 9059{ 9060 union aligned64 9061 { 9062 uint64_t v; 9063 unsigned char c[8]; 9064 }; 9065 const union aligned64 *a 9066 = (const union aligned64 *) &((const Elf64_External_Rel *) p)->r_offset; 9067 9068 uint64_t aval = ( (uint64_t) a->c[0] 9069 | (uint64_t) a->c[1] << 8 9070 | (uint64_t) a->c[2] << 16 9071 | (uint64_t) a->c[3] << 24 9072 | (uint64_t) a->c[4] << 32 9073 | (uint64_t) a->c[5] << 40 9074 | (uint64_t) a->c[6] << 48 9075 | (uint64_t) a->c[7] << 56); 9076 return aval; 9077} 9078 9079static bfd_vma 9080ext64b_r_offset (const void *p) 9081{ 9082 union aligned64 9083 { 9084 uint64_t v; 9085 unsigned char c[8]; 9086 }; 9087 const union aligned64 *a 9088 = (const union aligned64 *) &((const Elf64_External_Rel *) p)->r_offset; 9089 9090 uint64_t aval = ( (uint64_t) a->c[0] << 56 9091 | (uint64_t) a->c[1] << 48 9092 | (uint64_t) a->c[2] << 40 9093 | (uint64_t) a->c[3] << 32 9094 | (uint64_t) a->c[4] << 24 9095 | (uint64_t) a->c[5] << 16 9096 | (uint64_t) a->c[6] << 8 9097 | (uint64_t) a->c[7]); 9098 return aval; 9099} 9100#endif 9101 9102/* When performing a relocatable link, the input relocations are 9103 preserved. But, if they reference global symbols, the indices 9104 referenced must be updated. Update all the relocations found in 9105 RELDATA. */ 9106 9107static bfd_boolean 9108elf_link_adjust_relocs (bfd *abfd, 9109 asection *sec, 9110 struct bfd_elf_section_reloc_data *reldata, 9111 bfd_boolean sort, 9112 struct bfd_link_info *info) 9113{ 9114 unsigned int i; 9115 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 9116 bfd_byte *erela; 9117 void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *); 9118 void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *); 9119 bfd_vma r_type_mask; 9120 int r_sym_shift; 9121 unsigned int count = reldata->count; 9122 struct elf_link_hash_entry **rel_hash = reldata->hashes; 9123 9124 if (reldata->hdr->sh_entsize == bed->s->sizeof_rel) 9125 { 9126 swap_in = bed->s->swap_reloc_in; 9127 swap_out = bed->s->swap_reloc_out; 9128 } 9129 else if (reldata->hdr->sh_entsize == bed->s->sizeof_rela) 9130 { 9131 swap_in = bed->s->swap_reloca_in; 9132 swap_out = bed->s->swap_reloca_out; 9133 } 9134 else 9135 abort (); 9136 9137 if (bed->s->int_rels_per_ext_rel > MAX_INT_RELS_PER_EXT_REL) 9138 abort (); 9139 9140 if (bed->s->arch_size == 32) 9141 { 9142 r_type_mask = 0xff; 9143 r_sym_shift = 8; 9144 } 9145 else 9146 { 9147 r_type_mask = 0xffffffff; 9148 r_sym_shift = 32; 9149 } 9150 9151 erela = reldata->hdr->contents; 9152 for (i = 0; i < count; i++, rel_hash++, erela += reldata->hdr->sh_entsize) 9153 { 9154 Elf_Internal_Rela irela[MAX_INT_RELS_PER_EXT_REL]; 9155 unsigned int j; 9156 9157 if (*rel_hash == NULL) 9158 continue; 9159 9160 if ((*rel_hash)->indx == -2 9161 && info->gc_sections 9162 && ! info->gc_keep_exported) 9163 { 9164 /* PR 21524: Let the user know if a symbol was removed by garbage collection. */ 9165 _bfd_error_handler (_("%pB:%pA: error: relocation references symbol %s which was removed by garbage collection"), 9166 abfd, sec, 9167 (*rel_hash)->root.root.string); 9168 _bfd_error_handler (_("%pB:%pA: error: try relinking with --gc-keep-exported enabled"), 9169 abfd, sec); 9170 bfd_set_error (bfd_error_invalid_operation); 9171 return FALSE; 9172 } 9173 BFD_ASSERT ((*rel_hash)->indx >= 0); 9174 9175 (*swap_in) (abfd, erela, irela); 9176 for (j = 0; j < bed->s->int_rels_per_ext_rel; j++) 9177 irela[j].r_info = ((bfd_vma) (*rel_hash)->indx << r_sym_shift 9178 | (irela[j].r_info & r_type_mask)); 9179 (*swap_out) (abfd, irela, erela); 9180 } 9181 9182 if (bed->elf_backend_update_relocs) 9183 (*bed->elf_backend_update_relocs) (sec, reldata); 9184 9185 if (sort && count != 0) 9186 { 9187 bfd_vma (*ext_r_off) (const void *); 9188 bfd_vma r_off; 9189 size_t elt_size; 9190 bfd_byte *base, *end, *p, *loc; 9191 bfd_byte *buf = NULL; 9192 9193 if (bed->s->arch_size == 32) 9194 { 9195 if (abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE) 9196 ext_r_off = ext32l_r_offset; 9197 else if (abfd->xvec->header_byteorder == BFD_ENDIAN_BIG) 9198 ext_r_off = ext32b_r_offset; 9199 else 9200 abort (); 9201 } 9202 else 9203 { 9204#ifdef BFD_HOST_64_BIT 9205 if (abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE) 9206 ext_r_off = ext64l_r_offset; 9207 else if (abfd->xvec->header_byteorder == BFD_ENDIAN_BIG) 9208 ext_r_off = ext64b_r_offset; 9209 else 9210#endif 9211 abort (); 9212 } 9213 9214 /* Must use a stable sort here. A modified insertion sort, 9215 since the relocs are mostly sorted already. */ 9216 elt_size = reldata->hdr->sh_entsize; 9217 base = reldata->hdr->contents; 9218 end = base + count * elt_size; 9219 if (elt_size > sizeof (Elf64_External_Rela)) 9220 abort (); 9221 9222 /* Ensure the first element is lowest. This acts as a sentinel, 9223 speeding the main loop below. */ 9224 r_off = (*ext_r_off) (base); 9225 for (p = loc = base; (p += elt_size) < end; ) 9226 { 9227 bfd_vma r_off2 = (*ext_r_off) (p); 9228 if (r_off > r_off2) 9229 { 9230 r_off = r_off2; 9231 loc = p; 9232 } 9233 } 9234 if (loc != base) 9235 { 9236 /* Don't just swap *base and *loc as that changes the order 9237 of the original base[0] and base[1] if they happen to 9238 have the same r_offset. */ 9239 bfd_byte onebuf[sizeof (Elf64_External_Rela)]; 9240 memcpy (onebuf, loc, elt_size); 9241 memmove (base + elt_size, base, loc - base); 9242 memcpy (base, onebuf, elt_size); 9243 } 9244 9245 for (p = base + elt_size; (p += elt_size) < end; ) 9246 { 9247 /* base to p is sorted, *p is next to insert. */ 9248 r_off = (*ext_r_off) (p); 9249 /* Search the sorted region for location to insert. */ 9250 loc = p - elt_size; 9251 while (r_off < (*ext_r_off) (loc)) 9252 loc -= elt_size; 9253 loc += elt_size; 9254 if (loc != p) 9255 { 9256 /* Chances are there is a run of relocs to insert here, 9257 from one of more input files. Files are not always 9258 linked in order due to the way elf_link_input_bfd is 9259 called. See pr17666. */ 9260 size_t sortlen = p - loc; 9261 bfd_vma r_off2 = (*ext_r_off) (loc); 9262 size_t runlen = elt_size; 9263 size_t buf_size = 96 * 1024; 9264 while (p + runlen < end 9265 && (sortlen <= buf_size 9266 || runlen + elt_size <= buf_size) 9267 && r_off2 > (*ext_r_off) (p + runlen)) 9268 runlen += elt_size; 9269 if (buf == NULL) 9270 { 9271 buf = bfd_malloc (buf_size); 9272 if (buf == NULL) 9273 return FALSE; 9274 } 9275 if (runlen < sortlen) 9276 { 9277 memcpy (buf, p, runlen); 9278 memmove (loc + runlen, loc, sortlen); 9279 memcpy (loc, buf, runlen); 9280 } 9281 else 9282 { 9283 memcpy (buf, loc, sortlen); 9284 memmove (loc, p, runlen); 9285 memcpy (loc + runlen, buf, sortlen); 9286 } 9287 p += runlen - elt_size; 9288 } 9289 } 9290 /* Hashes are no longer valid. */ 9291 free (reldata->hashes); 9292 reldata->hashes = NULL; 9293 free (buf); 9294 } 9295 return TRUE; 9296} 9297 9298struct elf_link_sort_rela 9299{ 9300 union { 9301 bfd_vma offset; 9302 bfd_vma sym_mask; 9303 } u; 9304 enum elf_reloc_type_class type; 9305 /* We use this as an array of size int_rels_per_ext_rel. */ 9306 Elf_Internal_Rela rela[1]; 9307}; 9308 9309/* qsort stability here and for cmp2 is only an issue if multiple 9310 dynamic relocations are emitted at the same address. But targets 9311 that apply a series of dynamic relocations each operating on the 9312 result of the prior relocation can't use -z combreloc as 9313 implemented anyway. Such schemes tend to be broken by sorting on 9314 symbol index. That leaves dynamic NONE relocs as the only other 9315 case where ld might emit multiple relocs at the same address, and 9316 those are only emitted due to target bugs. */ 9317 9318static int 9319elf_link_sort_cmp1 (const void *A, const void *B) 9320{ 9321 const struct elf_link_sort_rela *a = (const struct elf_link_sort_rela *) A; 9322 const struct elf_link_sort_rela *b = (const struct elf_link_sort_rela *) B; 9323 int relativea, relativeb; 9324 9325 relativea = a->type == reloc_class_relative; 9326 relativeb = b->type == reloc_class_relative; 9327 9328 if (relativea < relativeb) 9329 return 1; 9330 if (relativea > relativeb) 9331 return -1; 9332 if ((a->rela->r_info & a->u.sym_mask) < (b->rela->r_info & b->u.sym_mask)) 9333 return -1; 9334 if ((a->rela->r_info & a->u.sym_mask) > (b->rela->r_info & b->u.sym_mask)) 9335 return 1; 9336 if (a->rela->r_offset < b->rela->r_offset) 9337 return -1; 9338 if (a->rela->r_offset > b->rela->r_offset) 9339 return 1; 9340 return 0; 9341} 9342 9343static int 9344elf_link_sort_cmp2 (const void *A, const void *B) 9345{ 9346 const struct elf_link_sort_rela *a = (const struct elf_link_sort_rela *) A; 9347 const struct elf_link_sort_rela *b = (const struct elf_link_sort_rela *) B; 9348 9349 if (a->type < b->type) 9350 return -1; 9351 if (a->type > b->type) 9352 return 1; 9353 if (a->u.offset < b->u.offset) 9354 return -1; 9355 if (a->u.offset > b->u.offset) 9356 return 1; 9357 if (a->rela->r_offset < b->rela->r_offset) 9358 return -1; 9359 if (a->rela->r_offset > b->rela->r_offset) 9360 return 1; 9361 return 0; 9362} 9363 9364static size_t 9365elf_link_sort_relocs (bfd *abfd, struct bfd_link_info *info, asection **psec) 9366{ 9367 asection *dynamic_relocs; 9368 asection *rela_dyn; 9369 asection *rel_dyn; 9370 bfd_size_type count, size; 9371 size_t i, ret, sort_elt, ext_size; 9372 bfd_byte *sort, *s_non_relative, *p; 9373 struct elf_link_sort_rela *sq; 9374 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 9375 int i2e = bed->s->int_rels_per_ext_rel; 9376 unsigned int opb = bfd_octets_per_byte (abfd, NULL); 9377 void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *); 9378 void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *); 9379 struct bfd_link_order *lo; 9380 bfd_vma r_sym_mask; 9381 bfd_boolean use_rela; 9382 9383 /* Find a dynamic reloc section. */ 9384 rela_dyn = bfd_get_section_by_name (abfd, ".rela.dyn"); 9385 rel_dyn = bfd_get_section_by_name (abfd, ".rel.dyn"); 9386 if (rela_dyn != NULL && rela_dyn->size > 0 9387 && rel_dyn != NULL && rel_dyn->size > 0) 9388 { 9389 bfd_boolean use_rela_initialised = FALSE; 9390 9391 /* This is just here to stop gcc from complaining. 9392 Its initialization checking code is not perfect. */ 9393 use_rela = TRUE; 9394 9395 /* Both sections are present. Examine the sizes 9396 of the indirect sections to help us choose. */ 9397 for (lo = rela_dyn->map_head.link_order; lo != NULL; lo = lo->next) 9398 if (lo->type == bfd_indirect_link_order) 9399 { 9400 asection *o = lo->u.indirect.section; 9401 9402 if ((o->size % bed->s->sizeof_rela) == 0) 9403 { 9404 if ((o->size % bed->s->sizeof_rel) == 0) 9405 /* Section size is divisible by both rel and rela sizes. 9406 It is of no help to us. */ 9407 ; 9408 else 9409 { 9410 /* Section size is only divisible by rela. */ 9411 if (use_rela_initialised && !use_rela) 9412 { 9413 _bfd_error_handler (_("%pB: unable to sort relocs - " 9414 "they are in more than one size"), 9415 abfd); 9416 bfd_set_error (bfd_error_invalid_operation); 9417 return 0; 9418 } 9419 else 9420 { 9421 use_rela = TRUE; 9422 use_rela_initialised = TRUE; 9423 } 9424 } 9425 } 9426 else if ((o->size % bed->s->sizeof_rel) == 0) 9427 { 9428 /* Section size is only divisible by rel. */ 9429 if (use_rela_initialised && use_rela) 9430 { 9431 _bfd_error_handler (_("%pB: unable to sort relocs - " 9432 "they are in more than one size"), 9433 abfd); 9434 bfd_set_error (bfd_error_invalid_operation); 9435 return 0; 9436 } 9437 else 9438 { 9439 use_rela = FALSE; 9440 use_rela_initialised = TRUE; 9441 } 9442 } 9443 else 9444 { 9445 /* The section size is not divisible by either - 9446 something is wrong. */ 9447 _bfd_error_handler (_("%pB: unable to sort relocs - " 9448 "they are of an unknown size"), abfd); 9449 bfd_set_error (bfd_error_invalid_operation); 9450 return 0; 9451 } 9452 } 9453 9454 for (lo = rel_dyn->map_head.link_order; lo != NULL; lo = lo->next) 9455 if (lo->type == bfd_indirect_link_order) 9456 { 9457 asection *o = lo->u.indirect.section; 9458 9459 if ((o->size % bed->s->sizeof_rela) == 0) 9460 { 9461 if ((o->size % bed->s->sizeof_rel) == 0) 9462 /* Section size is divisible by both rel and rela sizes. 9463 It is of no help to us. */ 9464 ; 9465 else 9466 { 9467 /* Section size is only divisible by rela. */ 9468 if (use_rela_initialised && !use_rela) 9469 { 9470 _bfd_error_handler (_("%pB: unable to sort relocs - " 9471 "they are in more than one size"), 9472 abfd); 9473 bfd_set_error (bfd_error_invalid_operation); 9474 return 0; 9475 } 9476 else 9477 { 9478 use_rela = TRUE; 9479 use_rela_initialised = TRUE; 9480 } 9481 } 9482 } 9483 else if ((o->size % bed->s->sizeof_rel) == 0) 9484 { 9485 /* Section size is only divisible by rel. */ 9486 if (use_rela_initialised && use_rela) 9487 { 9488 _bfd_error_handler (_("%pB: unable to sort relocs - " 9489 "they are in more than one size"), 9490 abfd); 9491 bfd_set_error (bfd_error_invalid_operation); 9492 return 0; 9493 } 9494 else 9495 { 9496 use_rela = FALSE; 9497 use_rela_initialised = TRUE; 9498 } 9499 } 9500 else 9501 { 9502 /* The section size is not divisible by either - 9503 something is wrong. */ 9504 _bfd_error_handler (_("%pB: unable to sort relocs - " 9505 "they are of an unknown size"), abfd); 9506 bfd_set_error (bfd_error_invalid_operation); 9507 return 0; 9508 } 9509 } 9510 9511 if (! use_rela_initialised) 9512 /* Make a guess. */ 9513 use_rela = TRUE; 9514 } 9515 else if (rela_dyn != NULL && rela_dyn->size > 0) 9516 use_rela = TRUE; 9517 else if (rel_dyn != NULL && rel_dyn->size > 0) 9518 use_rela = FALSE; 9519 else 9520 return 0; 9521 9522 if (use_rela) 9523 { 9524 dynamic_relocs = rela_dyn; 9525 ext_size = bed->s->sizeof_rela; 9526 swap_in = bed->s->swap_reloca_in; 9527 swap_out = bed->s->swap_reloca_out; 9528 } 9529 else 9530 { 9531 dynamic_relocs = rel_dyn; 9532 ext_size = bed->s->sizeof_rel; 9533 swap_in = bed->s->swap_reloc_in; 9534 swap_out = bed->s->swap_reloc_out; 9535 } 9536 9537 size = 0; 9538 for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next) 9539 if (lo->type == bfd_indirect_link_order) 9540 size += lo->u.indirect.section->size; 9541 9542 if (size != dynamic_relocs->size) 9543 return 0; 9544 9545 sort_elt = (sizeof (struct elf_link_sort_rela) 9546 + (i2e - 1) * sizeof (Elf_Internal_Rela)); 9547 9548 count = dynamic_relocs->size / ext_size; 9549 if (count == 0) 9550 return 0; 9551 sort = (bfd_byte *) bfd_zmalloc (sort_elt * count); 9552 9553 if (sort == NULL) 9554 { 9555 (*info->callbacks->warning) 9556 (info, _("not enough memory to sort relocations"), 0, abfd, 0, 0); 9557 return 0; 9558 } 9559 9560 if (bed->s->arch_size == 32) 9561 r_sym_mask = ~(bfd_vma) 0xff; 9562 else 9563 r_sym_mask = ~(bfd_vma) 0xffffffff; 9564 9565 for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next) 9566 if (lo->type == bfd_indirect_link_order) 9567 { 9568 bfd_byte *erel, *erelend; 9569 asection *o = lo->u.indirect.section; 9570 9571 if (o->contents == NULL && o->size != 0) 9572 { 9573 /* This is a reloc section that is being handled as a normal 9574 section. See bfd_section_from_shdr. We can't combine 9575 relocs in this case. */ 9576 free (sort); 9577 return 0; 9578 } 9579 erel = o->contents; 9580 erelend = o->contents + o->size; 9581 p = sort + o->output_offset * opb / ext_size * sort_elt; 9582 9583 while (erel < erelend) 9584 { 9585 struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p; 9586 9587 (*swap_in) (abfd, erel, s->rela); 9588 s->type = (*bed->elf_backend_reloc_type_class) (info, o, s->rela); 9589 s->u.sym_mask = r_sym_mask; 9590 p += sort_elt; 9591 erel += ext_size; 9592 } 9593 } 9594 9595 qsort (sort, count, sort_elt, elf_link_sort_cmp1); 9596 9597 for (i = 0, p = sort; i < count; i++, p += sort_elt) 9598 { 9599 struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p; 9600 if (s->type != reloc_class_relative) 9601 break; 9602 } 9603 ret = i; 9604 s_non_relative = p; 9605 9606 sq = (struct elf_link_sort_rela *) s_non_relative; 9607 for (; i < count; i++, p += sort_elt) 9608 { 9609 struct elf_link_sort_rela *sp = (struct elf_link_sort_rela *) p; 9610 if (((sp->rela->r_info ^ sq->rela->r_info) & r_sym_mask) != 0) 9611 sq = sp; 9612 sp->u.offset = sq->rela->r_offset; 9613 } 9614 9615 qsort (s_non_relative, count - ret, sort_elt, elf_link_sort_cmp2); 9616 9617 struct elf_link_hash_table *htab = elf_hash_table (info); 9618 if (htab->srelplt && htab->srelplt->output_section == dynamic_relocs) 9619 { 9620 /* We have plt relocs in .rela.dyn. */ 9621 sq = (struct elf_link_sort_rela *) sort; 9622 for (i = 0; i < count; i++) 9623 if (sq[count - i - 1].type != reloc_class_plt) 9624 break; 9625 if (i != 0 && htab->srelplt->size == i * ext_size) 9626 { 9627 struct bfd_link_order **plo; 9628 /* Put srelplt link_order last. This is so the output_offset 9629 set in the next loop is correct for DT_JMPREL. */ 9630 for (plo = &dynamic_relocs->map_head.link_order; *plo != NULL; ) 9631 if ((*plo)->type == bfd_indirect_link_order 9632 && (*plo)->u.indirect.section == htab->srelplt) 9633 { 9634 lo = *plo; 9635 *plo = lo->next; 9636 } 9637 else 9638 plo = &(*plo)->next; 9639 *plo = lo; 9640 lo->next = NULL; 9641 dynamic_relocs->map_tail.link_order = lo; 9642 } 9643 } 9644 9645 p = sort; 9646 for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next) 9647 if (lo->type == bfd_indirect_link_order) 9648 { 9649 bfd_byte *erel, *erelend; 9650 asection *o = lo->u.indirect.section; 9651 9652 erel = o->contents; 9653 erelend = o->contents + o->size; 9654 o->output_offset = (p - sort) / sort_elt * ext_size / opb; 9655 while (erel < erelend) 9656 { 9657 struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p; 9658 (*swap_out) (abfd, s->rela, erel); 9659 p += sort_elt; 9660 erel += ext_size; 9661 } 9662 } 9663 9664 free (sort); 9665 *psec = dynamic_relocs; 9666 return ret; 9667} 9668 9669/* Add a symbol to the output symbol string table. */ 9670 9671static int 9672elf_link_output_symstrtab (struct elf_final_link_info *flinfo, 9673 const char *name, 9674 Elf_Internal_Sym *elfsym, 9675 asection *input_sec, 9676 struct elf_link_hash_entry *h) 9677{ 9678 int (*output_symbol_hook) 9679 (struct bfd_link_info *, const char *, Elf_Internal_Sym *, asection *, 9680 struct elf_link_hash_entry *); 9681 struct elf_link_hash_table *hash_table; 9682 const struct elf_backend_data *bed; 9683 bfd_size_type strtabsize; 9684 9685 BFD_ASSERT (elf_onesymtab (flinfo->output_bfd)); 9686 9687 bed = get_elf_backend_data (flinfo->output_bfd); 9688 output_symbol_hook = bed->elf_backend_link_output_symbol_hook; 9689 if (output_symbol_hook != NULL) 9690 { 9691 int ret = (*output_symbol_hook) (flinfo->info, name, elfsym, input_sec, h); 9692 if (ret != 1) 9693 return ret; 9694 } 9695 9696 if (ELF_ST_TYPE (elfsym->st_info) == STT_GNU_IFUNC) 9697 elf_tdata (flinfo->output_bfd)->has_gnu_osabi |= elf_gnu_osabi_ifunc; 9698 if (ELF_ST_BIND (elfsym->st_info) == STB_GNU_UNIQUE) 9699 elf_tdata (flinfo->output_bfd)->has_gnu_osabi |= elf_gnu_osabi_unique; 9700 9701 if (name == NULL 9702 || *name == '\0' 9703 || (input_sec->flags & SEC_EXCLUDE)) 9704 elfsym->st_name = (unsigned long) -1; 9705 else 9706 { 9707 /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize 9708 to get the final offset for st_name. */ 9709 char *versioned_name = (char *) name; 9710 if (h != NULL) 9711 { 9712 if (h->versioned == versioned && h->def_dynamic) 9713 { 9714 /* Keep only one '@' for versioned symbols defined in 9715 shared objects. */ 9716 char *version = strrchr (name, ELF_VER_CHR); 9717 char *base_end = strchr (name, ELF_VER_CHR); 9718 if (version != base_end) 9719 { 9720 size_t base_len; 9721 size_t len = strlen (name); 9722 versioned_name = bfd_alloc (flinfo->output_bfd, len); 9723 if (versioned_name == NULL) 9724 return 0; 9725 base_len = base_end - name; 9726 memcpy (versioned_name, name, base_len); 9727 memcpy (versioned_name + base_len, version, 9728 len - base_len); 9729 } 9730 } 9731 } 9732 else if (flinfo->info->unique_symbol 9733 && ELF_ST_BIND (elfsym->st_info) == STB_LOCAL) 9734 { 9735 struct local_hash_entry *lh; 9736 switch (ELF_ST_TYPE (elfsym->st_info)) 9737 { 9738 case STT_FILE: 9739 case STT_SECTION: 9740 break; 9741 default: 9742 lh = (struct local_hash_entry *) bfd_hash_lookup 9743 (&flinfo->local_hash_table, name, TRUE, FALSE); 9744 if (lh == NULL) 9745 return 0; 9746 if (lh->count) 9747 { 9748 /* Append ".COUNT" to duplicated local symbols. */ 9749 size_t count_len; 9750 size_t base_len = lh->size; 9751 char buf[30]; 9752 sprintf (buf, "%lx", lh->count); 9753 if (!base_len) 9754 { 9755 base_len = strlen (name); 9756 lh->size = base_len; 9757 } 9758 count_len = strlen (buf); 9759 versioned_name = bfd_alloc (flinfo->output_bfd, 9760 base_len + count_len + 2); 9761 if (versioned_name == NULL) 9762 return 0; 9763 memcpy (versioned_name, name, base_len); 9764 versioned_name[base_len] = '.'; 9765 memcpy (versioned_name + base_len + 1, buf, 9766 count_len + 1); 9767 } 9768 lh->count++; 9769 break; 9770 } 9771 } 9772 elfsym->st_name 9773 = (unsigned long) _bfd_elf_strtab_add (flinfo->symstrtab, 9774 versioned_name, FALSE); 9775 if (elfsym->st_name == (unsigned long) -1) 9776 return 0; 9777 } 9778 9779 hash_table = elf_hash_table (flinfo->info); 9780 strtabsize = hash_table->strtabsize; 9781 if (strtabsize <= hash_table->strtabcount) 9782 { 9783 strtabsize += strtabsize; 9784 hash_table->strtabsize = strtabsize; 9785 strtabsize *= sizeof (*hash_table->strtab); 9786 hash_table->strtab 9787 = (struct elf_sym_strtab *) bfd_realloc (hash_table->strtab, 9788 strtabsize); 9789 if (hash_table->strtab == NULL) 9790 return 0; 9791 } 9792 hash_table->strtab[hash_table->strtabcount].sym = *elfsym; 9793 hash_table->strtab[hash_table->strtabcount].dest_index 9794 = hash_table->strtabcount; 9795 hash_table->strtab[hash_table->strtabcount].destshndx_index 9796 = flinfo->symshndxbuf ? bfd_get_symcount (flinfo->output_bfd) : 0; 9797 9798 flinfo->output_bfd->symcount += 1; 9799 hash_table->strtabcount += 1; 9800 9801 return 1; 9802} 9803 9804/* Swap symbols out to the symbol table and flush the output symbols to 9805 the file. */ 9806 9807static bfd_boolean 9808elf_link_swap_symbols_out (struct elf_final_link_info *flinfo) 9809{ 9810 struct elf_link_hash_table *hash_table = elf_hash_table (flinfo->info); 9811 size_t amt; 9812 size_t i; 9813 const struct elf_backend_data *bed; 9814 bfd_byte *symbuf; 9815 Elf_Internal_Shdr *hdr; 9816 file_ptr pos; 9817 bfd_boolean ret; 9818 9819 if (!hash_table->strtabcount) 9820 return TRUE; 9821 9822 BFD_ASSERT (elf_onesymtab (flinfo->output_bfd)); 9823 9824 bed = get_elf_backend_data (flinfo->output_bfd); 9825 9826 amt = bed->s->sizeof_sym * hash_table->strtabcount; 9827 symbuf = (bfd_byte *) bfd_malloc (amt); 9828 if (symbuf == NULL) 9829 return FALSE; 9830 9831 if (flinfo->symshndxbuf) 9832 { 9833 amt = sizeof (Elf_External_Sym_Shndx); 9834 amt *= bfd_get_symcount (flinfo->output_bfd); 9835 flinfo->symshndxbuf = (Elf_External_Sym_Shndx *) bfd_zmalloc (amt); 9836 if (flinfo->symshndxbuf == NULL) 9837 { 9838 free (symbuf); 9839 return FALSE; 9840 } 9841 } 9842 9843 for (i = 0; i < hash_table->strtabcount; i++) 9844 { 9845 struct elf_sym_strtab *elfsym = &hash_table->strtab[i]; 9846 if (elfsym->sym.st_name == (unsigned long) -1) 9847 elfsym->sym.st_name = 0; 9848 else 9849 elfsym->sym.st_name 9850 = (unsigned long) _bfd_elf_strtab_offset (flinfo->symstrtab, 9851 elfsym->sym.st_name); 9852 bed->s->swap_symbol_out (flinfo->output_bfd, &elfsym->sym, 9853 ((bfd_byte *) symbuf 9854 + (elfsym->dest_index 9855 * bed->s->sizeof_sym)), 9856 (flinfo->symshndxbuf 9857 + elfsym->destshndx_index)); 9858 } 9859 9860 /* Allow the linker to examine the strtab and symtab now they are 9861 populated. */ 9862 9863 if (flinfo->info->callbacks->examine_strtab) 9864 flinfo->info->callbacks->examine_strtab (hash_table->strtab, 9865 hash_table->strtabcount, 9866 flinfo->symstrtab); 9867 9868 hdr = &elf_tdata (flinfo->output_bfd)->symtab_hdr; 9869 pos = hdr->sh_offset + hdr->sh_size; 9870 amt = hash_table->strtabcount * bed->s->sizeof_sym; 9871 if (bfd_seek (flinfo->output_bfd, pos, SEEK_SET) == 0 9872 && bfd_bwrite (symbuf, amt, flinfo->output_bfd) == amt) 9873 { 9874 hdr->sh_size += amt; 9875 ret = TRUE; 9876 } 9877 else 9878 ret = FALSE; 9879 9880 free (symbuf); 9881 9882 free (hash_table->strtab); 9883 hash_table->strtab = NULL; 9884 9885 return ret; 9886} 9887 9888/* Return TRUE if the dynamic symbol SYM in ABFD is supported. */ 9889 9890static bfd_boolean 9891check_dynsym (bfd *abfd, Elf_Internal_Sym *sym) 9892{ 9893 if (sym->st_shndx >= (SHN_LORESERVE & 0xffff) 9894 && sym->st_shndx < SHN_LORESERVE) 9895 { 9896 /* The gABI doesn't support dynamic symbols in output sections 9897 beyond 64k. */ 9898 _bfd_error_handler 9899 /* xgettext:c-format */ 9900 (_("%pB: too many sections: %d (>= %d)"), 9901 abfd, bfd_count_sections (abfd), SHN_LORESERVE & 0xffff); 9902 bfd_set_error (bfd_error_nonrepresentable_section); 9903 return FALSE; 9904 } 9905 return TRUE; 9906} 9907 9908/* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in 9909 allowing an unsatisfied unversioned symbol in the DSO to match a 9910 versioned symbol that would normally require an explicit version. 9911 We also handle the case that a DSO references a hidden symbol 9912 which may be satisfied by a versioned symbol in another DSO. */ 9913 9914static bfd_boolean 9915elf_link_check_versioned_symbol (struct bfd_link_info *info, 9916 const struct elf_backend_data *bed, 9917 struct elf_link_hash_entry *h) 9918{ 9919 bfd *abfd; 9920 struct elf_link_loaded_list *loaded; 9921 9922 if (!is_elf_hash_table (info->hash)) 9923 return FALSE; 9924 9925 /* Check indirect symbol. */ 9926 while (h->root.type == bfd_link_hash_indirect) 9927 h = (struct elf_link_hash_entry *) h->root.u.i.link; 9928 9929 switch (h->root.type) 9930 { 9931 default: 9932 abfd = NULL; 9933 break; 9934 9935 case bfd_link_hash_undefined: 9936 case bfd_link_hash_undefweak: 9937 abfd = h->root.u.undef.abfd; 9938 if (abfd == NULL 9939 || (abfd->flags & DYNAMIC) == 0 9940 || (elf_dyn_lib_class (abfd) & DYN_DT_NEEDED) == 0) 9941 return FALSE; 9942 break; 9943 9944 case bfd_link_hash_defined: 9945 case bfd_link_hash_defweak: 9946 abfd = h->root.u.def.section->owner; 9947 break; 9948 9949 case bfd_link_hash_common: 9950 abfd = h->root.u.c.p->section->owner; 9951 break; 9952 } 9953 BFD_ASSERT (abfd != NULL); 9954 9955 for (loaded = elf_hash_table (info)->dyn_loaded; 9956 loaded != NULL; 9957 loaded = loaded->next) 9958 { 9959 bfd *input; 9960 Elf_Internal_Shdr *hdr; 9961 size_t symcount; 9962 size_t extsymcount; 9963 size_t extsymoff; 9964 Elf_Internal_Shdr *versymhdr; 9965 Elf_Internal_Sym *isym; 9966 Elf_Internal_Sym *isymend; 9967 Elf_Internal_Sym *isymbuf; 9968 Elf_External_Versym *ever; 9969 Elf_External_Versym *extversym; 9970 9971 input = loaded->abfd; 9972 9973 /* We check each DSO for a possible hidden versioned definition. */ 9974 if (input == abfd 9975 || elf_dynversym (input) == 0) 9976 continue; 9977 9978 hdr = &elf_tdata (input)->dynsymtab_hdr; 9979 9980 symcount = hdr->sh_size / bed->s->sizeof_sym; 9981 if (elf_bad_symtab (input)) 9982 { 9983 extsymcount = symcount; 9984 extsymoff = 0; 9985 } 9986 else 9987 { 9988 extsymcount = symcount - hdr->sh_info; 9989 extsymoff = hdr->sh_info; 9990 } 9991 9992 if (extsymcount == 0) 9993 continue; 9994 9995 isymbuf = bfd_elf_get_elf_syms (input, hdr, extsymcount, extsymoff, 9996 NULL, NULL, NULL); 9997 if (isymbuf == NULL) 9998 return FALSE; 9999 10000 /* Read in any version definitions. */ 10001 versymhdr = &elf_tdata (input)->dynversym_hdr; 10002 if (bfd_seek (input, versymhdr->sh_offset, SEEK_SET) != 0 10003 || (extversym = (Elf_External_Versym *) 10004 _bfd_malloc_and_read (input, versymhdr->sh_size, 10005 versymhdr->sh_size)) == NULL) 10006 { 10007 free (isymbuf); 10008 return FALSE; 10009 } 10010 10011 ever = extversym + extsymoff; 10012 isymend = isymbuf + extsymcount; 10013 for (isym = isymbuf; isym < isymend; isym++, ever++) 10014 { 10015 const char *name; 10016 Elf_Internal_Versym iver; 10017 unsigned short version_index; 10018 10019 if (ELF_ST_BIND (isym->st_info) == STB_LOCAL 10020 || isym->st_shndx == SHN_UNDEF) 10021 continue; 10022 10023 name = bfd_elf_string_from_elf_section (input, 10024 hdr->sh_link, 10025 isym->st_name); 10026 if (strcmp (name, h->root.root.string) != 0) 10027 continue; 10028 10029 _bfd_elf_swap_versym_in (input, ever, &iver); 10030 10031 if ((iver.vs_vers & VERSYM_HIDDEN) == 0 10032 && !(h->def_regular 10033 && h->forced_local)) 10034 { 10035 /* If we have a non-hidden versioned sym, then it should 10036 have provided a definition for the undefined sym unless 10037 it is defined in a non-shared object and forced local. 10038 */ 10039 abort (); 10040 } 10041 10042 version_index = iver.vs_vers & VERSYM_VERSION; 10043 if (version_index == 1 || version_index == 2) 10044 { 10045 /* This is the base or first version. We can use it. */ 10046 free (extversym); 10047 free (isymbuf); 10048 return TRUE; 10049 } 10050 } 10051 10052 free (extversym); 10053 free (isymbuf); 10054 } 10055 10056 return FALSE; 10057} 10058 10059/* Convert ELF common symbol TYPE. */ 10060 10061static int 10062elf_link_convert_common_type (struct bfd_link_info *info, int type) 10063{ 10064 /* Commom symbol can only appear in relocatable link. */ 10065 if (!bfd_link_relocatable (info)) 10066 abort (); 10067 switch (info->elf_stt_common) 10068 { 10069 case unchanged: 10070 break; 10071 case elf_stt_common: 10072 type = STT_COMMON; 10073 break; 10074 case no_elf_stt_common: 10075 type = STT_OBJECT; 10076 break; 10077 } 10078 return type; 10079} 10080 10081/* Add an external symbol to the symbol table. This is called from 10082 the hash table traversal routine. When generating a shared object, 10083 we go through the symbol table twice. The first time we output 10084 anything that might have been forced to local scope in a version 10085 script. The second time we output the symbols that are still 10086 global symbols. */ 10087 10088static bfd_boolean 10089elf_link_output_extsym (struct bfd_hash_entry *bh, void *data) 10090{ 10091 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh; 10092 struct elf_outext_info *eoinfo = (struct elf_outext_info *) data; 10093 struct elf_final_link_info *flinfo = eoinfo->flinfo; 10094 bfd_boolean strip; 10095 Elf_Internal_Sym sym; 10096 asection *input_sec; 10097 const struct elf_backend_data *bed; 10098 long indx; 10099 int ret; 10100 unsigned int type; 10101 10102 if (h->root.type == bfd_link_hash_warning) 10103 { 10104 h = (struct elf_link_hash_entry *) h->root.u.i.link; 10105 if (h->root.type == bfd_link_hash_new) 10106 return TRUE; 10107 } 10108 10109 /* Decide whether to output this symbol in this pass. */ 10110 if (eoinfo->localsyms) 10111 { 10112 if (!h->forced_local) 10113 return TRUE; 10114 } 10115 else 10116 { 10117 if (h->forced_local) 10118 return TRUE; 10119 } 10120 10121 bed = get_elf_backend_data (flinfo->output_bfd); 10122 10123 if (h->root.type == bfd_link_hash_undefined) 10124 { 10125 /* If we have an undefined symbol reference here then it must have 10126 come from a shared library that is being linked in. (Undefined 10127 references in regular files have already been handled unless 10128 they are in unreferenced sections which are removed by garbage 10129 collection). */ 10130 bfd_boolean ignore_undef = FALSE; 10131 10132 /* Some symbols may be special in that the fact that they're 10133 undefined can be safely ignored - let backend determine that. */ 10134 if (bed->elf_backend_ignore_undef_symbol) 10135 ignore_undef = bed->elf_backend_ignore_undef_symbol (h); 10136 10137 /* If we are reporting errors for this situation then do so now. */ 10138 if (!ignore_undef 10139 && h->ref_dynamic_nonweak 10140 && (!h->ref_regular || flinfo->info->gc_sections) 10141 && !elf_link_check_versioned_symbol (flinfo->info, bed, h) 10142 && flinfo->info->unresolved_syms_in_shared_libs != RM_IGNORE) 10143 { 10144 flinfo->info->callbacks->undefined_symbol 10145 (flinfo->info, h->root.root.string, 10146 h->ref_regular ? NULL : h->root.u.undef.abfd, NULL, 0, 10147 flinfo->info->unresolved_syms_in_shared_libs == RM_DIAGNOSE 10148 && !flinfo->info->warn_unresolved_syms); 10149 } 10150 10151 /* Strip a global symbol defined in a discarded section. */ 10152 if (h->indx == -3) 10153 return TRUE; 10154 } 10155 10156 /* We should also warn if a forced local symbol is referenced from 10157 shared libraries. */ 10158 if (bfd_link_executable (flinfo->info) 10159 && h->forced_local 10160 && h->ref_dynamic 10161 && h->def_regular 10162 && !h->dynamic_def 10163 && h->ref_dynamic_nonweak 10164 && !elf_link_check_versioned_symbol (flinfo->info, bed, h)) 10165 { 10166 bfd *def_bfd; 10167 const char *msg; 10168 struct elf_link_hash_entry *hi = h; 10169 10170 /* Check indirect symbol. */ 10171 while (hi->root.type == bfd_link_hash_indirect) 10172 hi = (struct elf_link_hash_entry *) hi->root.u.i.link; 10173 10174 if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL) 10175 /* xgettext:c-format */ 10176 msg = _("%pB: internal symbol `%s' in %pB is referenced by DSO"); 10177 else if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN) 10178 /* xgettext:c-format */ 10179 msg = _("%pB: hidden symbol `%s' in %pB is referenced by DSO"); 10180 else 10181 /* xgettext:c-format */ 10182 msg = _("%pB: local symbol `%s' in %pB is referenced by DSO"); 10183 def_bfd = flinfo->output_bfd; 10184 if (hi->root.u.def.section != bfd_abs_section_ptr) 10185 def_bfd = hi->root.u.def.section->owner; 10186 _bfd_error_handler (msg, flinfo->output_bfd, 10187 h->root.root.string, def_bfd); 10188 bfd_set_error (bfd_error_bad_value); 10189 eoinfo->failed = TRUE; 10190 return FALSE; 10191 } 10192 10193 /* We don't want to output symbols that have never been mentioned by 10194 a regular file, or that we have been told to strip. However, if 10195 h->indx is set to -2, the symbol is used by a reloc and we must 10196 output it. */ 10197 strip = FALSE; 10198 if (h->indx == -2) 10199 ; 10200 else if ((h->def_dynamic 10201 || h->ref_dynamic 10202 || h->root.type == bfd_link_hash_new) 10203 && !h->def_regular 10204 && !h->ref_regular) 10205 strip = TRUE; 10206 else if (flinfo->info->strip == strip_all) 10207 strip = TRUE; 10208 else if (flinfo->info->strip == strip_some 10209 && bfd_hash_lookup (flinfo->info->keep_hash, 10210 h->root.root.string, FALSE, FALSE) == NULL) 10211 strip = TRUE; 10212 else if ((h->root.type == bfd_link_hash_defined 10213 || h->root.type == bfd_link_hash_defweak) 10214 && ((flinfo->info->strip_discarded 10215 && discarded_section (h->root.u.def.section)) 10216 || ((h->root.u.def.section->flags & SEC_LINKER_CREATED) == 0 10217 && h->root.u.def.section->owner != NULL 10218 && (h->root.u.def.section->owner->flags & BFD_PLUGIN) != 0))) 10219 strip = TRUE; 10220 else if ((h->root.type == bfd_link_hash_undefined 10221 || h->root.type == bfd_link_hash_undefweak) 10222 && h->root.u.undef.abfd != NULL 10223 && (h->root.u.undef.abfd->flags & BFD_PLUGIN) != 0) 10224 strip = TRUE; 10225 10226 type = h->type; 10227 10228 /* If we're stripping it, and it's not a dynamic symbol, there's 10229 nothing else to do. However, if it is a forced local symbol or 10230 an ifunc symbol we need to give the backend finish_dynamic_symbol 10231 function a chance to make it dynamic. */ 10232 if (strip 10233 && h->dynindx == -1 10234 && type != STT_GNU_IFUNC 10235 && !h->forced_local) 10236 return TRUE; 10237 10238 sym.st_value = 0; 10239 sym.st_size = h->size; 10240 sym.st_other = h->other; 10241 switch (h->root.type) 10242 { 10243 default: 10244 case bfd_link_hash_new: 10245 case bfd_link_hash_warning: 10246 abort (); 10247 return FALSE; 10248 10249 case bfd_link_hash_undefined: 10250 case bfd_link_hash_undefweak: 10251 input_sec = bfd_und_section_ptr; 10252 sym.st_shndx = SHN_UNDEF; 10253 break; 10254 10255 case bfd_link_hash_defined: 10256 case bfd_link_hash_defweak: 10257 { 10258 input_sec = h->root.u.def.section; 10259 if (input_sec->output_section != NULL) 10260 { 10261 sym.st_shndx = 10262 _bfd_elf_section_from_bfd_section (flinfo->output_bfd, 10263 input_sec->output_section); 10264 if (sym.st_shndx == SHN_BAD) 10265 { 10266 _bfd_error_handler 10267 /* xgettext:c-format */ 10268 (_("%pB: could not find output section %pA for input section %pA"), 10269 flinfo->output_bfd, input_sec->output_section, input_sec); 10270 bfd_set_error (bfd_error_nonrepresentable_section); 10271 eoinfo->failed = TRUE; 10272 return FALSE; 10273 } 10274 10275 /* ELF symbols in relocatable files are section relative, 10276 but in nonrelocatable files they are virtual 10277 addresses. */ 10278 sym.st_value = h->root.u.def.value + input_sec->output_offset; 10279 if (!bfd_link_relocatable (flinfo->info)) 10280 { 10281 sym.st_value += input_sec->output_section->vma; 10282 if (h->type == STT_TLS) 10283 { 10284 asection *tls_sec = elf_hash_table (flinfo->info)->tls_sec; 10285 if (tls_sec != NULL) 10286 sym.st_value -= tls_sec->vma; 10287 } 10288 } 10289 } 10290 else 10291 { 10292 BFD_ASSERT (input_sec->owner == NULL 10293 || (input_sec->owner->flags & DYNAMIC) != 0); 10294 sym.st_shndx = SHN_UNDEF; 10295 input_sec = bfd_und_section_ptr; 10296 } 10297 } 10298 break; 10299 10300 case bfd_link_hash_common: 10301 input_sec = h->root.u.c.p->section; 10302 sym.st_shndx = bed->common_section_index (input_sec); 10303 sym.st_value = 1 << h->root.u.c.p->alignment_power; 10304 break; 10305 10306 case bfd_link_hash_indirect: 10307 /* These symbols are created by symbol versioning. They point 10308 to the decorated version of the name. For example, if the 10309 symbol foo@@GNU_1.2 is the default, which should be used when 10310 foo is used with no version, then we add an indirect symbol 10311 foo which points to foo@@GNU_1.2. We ignore these symbols, 10312 since the indirected symbol is already in the hash table. */ 10313 return TRUE; 10314 } 10315 10316 if (type == STT_COMMON || type == STT_OBJECT) 10317 switch (h->root.type) 10318 { 10319 case bfd_link_hash_common: 10320 type = elf_link_convert_common_type (flinfo->info, type); 10321 break; 10322 case bfd_link_hash_defined: 10323 case bfd_link_hash_defweak: 10324 if (bed->common_definition (&sym)) 10325 type = elf_link_convert_common_type (flinfo->info, type); 10326 else 10327 type = STT_OBJECT; 10328 break; 10329 case bfd_link_hash_undefined: 10330 case bfd_link_hash_undefweak: 10331 break; 10332 default: 10333 abort (); 10334 } 10335 10336 if (h->forced_local) 10337 { 10338 sym.st_info = ELF_ST_INFO (STB_LOCAL, type); 10339 /* Turn off visibility on local symbol. */ 10340 sym.st_other &= ~ELF_ST_VISIBILITY (-1); 10341 } 10342 /* Set STB_GNU_UNIQUE only if symbol is defined in regular object. */ 10343 else if (h->unique_global && h->def_regular) 10344 sym.st_info = ELF_ST_INFO (STB_GNU_UNIQUE, type); 10345 else if (h->root.type == bfd_link_hash_undefweak 10346 || h->root.type == bfd_link_hash_defweak) 10347 sym.st_info = ELF_ST_INFO (STB_WEAK, type); 10348 else 10349 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type); 10350 sym.st_target_internal = h->target_internal; 10351 10352 /* Give the processor backend a chance to tweak the symbol value, 10353 and also to finish up anything that needs to be done for this 10354 symbol. FIXME: Not calling elf_backend_finish_dynamic_symbol for 10355 forced local syms when non-shared is due to a historical quirk. 10356 STT_GNU_IFUNC symbol must go through PLT. */ 10357 if ((h->type == STT_GNU_IFUNC 10358 && h->def_regular 10359 && !bfd_link_relocatable (flinfo->info)) 10360 || ((h->dynindx != -1 10361 || h->forced_local) 10362 && ((bfd_link_pic (flinfo->info) 10363 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 10364 || h->root.type != bfd_link_hash_undefweak)) 10365 || !h->forced_local) 10366 && elf_hash_table (flinfo->info)->dynamic_sections_created)) 10367 { 10368 if (! ((*bed->elf_backend_finish_dynamic_symbol) 10369 (flinfo->output_bfd, flinfo->info, h, &sym))) 10370 { 10371 eoinfo->failed = TRUE; 10372 return FALSE; 10373 } 10374 } 10375 10376 /* If we are marking the symbol as undefined, and there are no 10377 non-weak references to this symbol from a regular object, then 10378 mark the symbol as weak undefined; if there are non-weak 10379 references, mark the symbol as strong. We can't do this earlier, 10380 because it might not be marked as undefined until the 10381 finish_dynamic_symbol routine gets through with it. */ 10382 if (sym.st_shndx == SHN_UNDEF 10383 && h->ref_regular 10384 && (ELF_ST_BIND (sym.st_info) == STB_GLOBAL 10385 || ELF_ST_BIND (sym.st_info) == STB_WEAK)) 10386 { 10387 int bindtype; 10388 type = ELF_ST_TYPE (sym.st_info); 10389 10390 /* Turn an undefined IFUNC symbol into a normal FUNC symbol. */ 10391 if (type == STT_GNU_IFUNC) 10392 type = STT_FUNC; 10393 10394 if (h->ref_regular_nonweak) 10395 bindtype = STB_GLOBAL; 10396 else 10397 bindtype = STB_WEAK; 10398 sym.st_info = ELF_ST_INFO (bindtype, type); 10399 } 10400 10401 /* If this is a symbol defined in a dynamic library, don't use the 10402 symbol size from the dynamic library. Relinking an executable 10403 against a new library may introduce gratuitous changes in the 10404 executable's symbols if we keep the size. */ 10405 if (sym.st_shndx == SHN_UNDEF 10406 && !h->def_regular 10407 && h->def_dynamic) 10408 sym.st_size = 0; 10409 10410 /* If a non-weak symbol with non-default visibility is not defined 10411 locally, it is a fatal error. */ 10412 if (!bfd_link_relocatable (flinfo->info) 10413 && ELF_ST_VISIBILITY (sym.st_other) != STV_DEFAULT 10414 && ELF_ST_BIND (sym.st_info) != STB_WEAK 10415 && h->root.type == bfd_link_hash_undefined 10416 && !h->def_regular) 10417 { 10418 const char *msg; 10419 10420 if (ELF_ST_VISIBILITY (sym.st_other) == STV_PROTECTED) 10421 /* xgettext:c-format */ 10422 msg = _("%pB: protected symbol `%s' isn't defined"); 10423 else if (ELF_ST_VISIBILITY (sym.st_other) == STV_INTERNAL) 10424 /* xgettext:c-format */ 10425 msg = _("%pB: internal symbol `%s' isn't defined"); 10426 else 10427 /* xgettext:c-format */ 10428 msg = _("%pB: hidden symbol `%s' isn't defined"); 10429 _bfd_error_handler (msg, flinfo->output_bfd, h->root.root.string); 10430 bfd_set_error (bfd_error_bad_value); 10431 eoinfo->failed = TRUE; 10432 return FALSE; 10433 } 10434 10435 /* If this symbol should be put in the .dynsym section, then put it 10436 there now. We already know the symbol index. We also fill in 10437 the entry in the .hash section. */ 10438 if (h->dynindx != -1 10439 && elf_hash_table (flinfo->info)->dynamic_sections_created 10440 && elf_hash_table (flinfo->info)->dynsym != NULL 10441 && !discarded_section (elf_hash_table (flinfo->info)->dynsym)) 10442 { 10443 bfd_byte *esym; 10444 10445 /* Since there is no version information in the dynamic string, 10446 if there is no version info in symbol version section, we will 10447 have a run-time problem if not linking executable, referenced 10448 by shared library, or not bound locally. */ 10449 if (h->verinfo.verdef == NULL 10450 && (!bfd_link_executable (flinfo->info) 10451 || h->ref_dynamic 10452 || !h->def_regular)) 10453 { 10454 char *p = strrchr (h->root.root.string, ELF_VER_CHR); 10455 10456 if (p && p [1] != '\0') 10457 { 10458 _bfd_error_handler 10459 /* xgettext:c-format */ 10460 (_("%pB: no symbol version section for versioned symbol `%s'"), 10461 flinfo->output_bfd, h->root.root.string); 10462 eoinfo->failed = TRUE; 10463 return FALSE; 10464 } 10465 } 10466 10467 sym.st_name = h->dynstr_index; 10468 esym = (elf_hash_table (flinfo->info)->dynsym->contents 10469 + h->dynindx * bed->s->sizeof_sym); 10470 if (!check_dynsym (flinfo->output_bfd, &sym)) 10471 { 10472 eoinfo->failed = TRUE; 10473 return FALSE; 10474 } 10475 bed->s->swap_symbol_out (flinfo->output_bfd, &sym, esym, 0); 10476 10477 if (flinfo->hash_sec != NULL) 10478 { 10479 size_t hash_entry_size; 10480 bfd_byte *bucketpos; 10481 bfd_vma chain; 10482 size_t bucketcount; 10483 size_t bucket; 10484 10485 bucketcount = elf_hash_table (flinfo->info)->bucketcount; 10486 bucket = h->u.elf_hash_value % bucketcount; 10487 10488 hash_entry_size 10489 = elf_section_data (flinfo->hash_sec)->this_hdr.sh_entsize; 10490 bucketpos = ((bfd_byte *) flinfo->hash_sec->contents 10491 + (bucket + 2) * hash_entry_size); 10492 chain = bfd_get (8 * hash_entry_size, flinfo->output_bfd, bucketpos); 10493 bfd_put (8 * hash_entry_size, flinfo->output_bfd, h->dynindx, 10494 bucketpos); 10495 bfd_put (8 * hash_entry_size, flinfo->output_bfd, chain, 10496 ((bfd_byte *) flinfo->hash_sec->contents 10497 + (bucketcount + 2 + h->dynindx) * hash_entry_size)); 10498 } 10499 10500 if (flinfo->symver_sec != NULL && flinfo->symver_sec->contents != NULL) 10501 { 10502 Elf_Internal_Versym iversym; 10503 Elf_External_Versym *eversym; 10504 10505 if (!h->def_regular && !ELF_COMMON_DEF_P (h)) 10506 { 10507 if (h->verinfo.verdef == NULL 10508 || (elf_dyn_lib_class (h->verinfo.verdef->vd_bfd) 10509 & (DYN_AS_NEEDED | DYN_DT_NEEDED | DYN_NO_NEEDED))) 10510 iversym.vs_vers = 0; 10511 else 10512 iversym.vs_vers = h->verinfo.verdef->vd_exp_refno + 1; 10513 } 10514 else 10515 { 10516 if (h->verinfo.vertree == NULL) 10517 iversym.vs_vers = 1; 10518 else 10519 iversym.vs_vers = h->verinfo.vertree->vernum + 1; 10520 if (flinfo->info->create_default_symver) 10521 iversym.vs_vers++; 10522 } 10523 10524 /* Turn on VERSYM_HIDDEN only if the hidden versioned symbol is 10525 defined locally. */ 10526 if (h->versioned == versioned_hidden && h->def_regular) 10527 iversym.vs_vers |= VERSYM_HIDDEN; 10528 10529 eversym = (Elf_External_Versym *) flinfo->symver_sec->contents; 10530 eversym += h->dynindx; 10531 _bfd_elf_swap_versym_out (flinfo->output_bfd, &iversym, eversym); 10532 } 10533 } 10534 10535 /* If the symbol is undefined, and we didn't output it to .dynsym, 10536 strip it from .symtab too. Obviously we can't do this for 10537 relocatable output or when needed for --emit-relocs. */ 10538 else if (input_sec == bfd_und_section_ptr 10539 && h->indx != -2 10540 /* PR 22319 Do not strip global undefined symbols marked as being needed. */ 10541 && (h->mark != 1 || ELF_ST_BIND (sym.st_info) != STB_GLOBAL) 10542 && !bfd_link_relocatable (flinfo->info)) 10543 return TRUE; 10544 10545 /* Also strip others that we couldn't earlier due to dynamic symbol 10546 processing. */ 10547 if (strip) 10548 return TRUE; 10549 if ((input_sec->flags & SEC_EXCLUDE) != 0) 10550 return TRUE; 10551 10552 /* Output a FILE symbol so that following locals are not associated 10553 with the wrong input file. We need one for forced local symbols 10554 if we've seen more than one FILE symbol or when we have exactly 10555 one FILE symbol but global symbols are present in a file other 10556 than the one with the FILE symbol. We also need one if linker 10557 defined symbols are present. In practice these conditions are 10558 always met, so just emit the FILE symbol unconditionally. */ 10559 if (eoinfo->localsyms 10560 && !eoinfo->file_sym_done 10561 && eoinfo->flinfo->filesym_count != 0) 10562 { 10563 Elf_Internal_Sym fsym; 10564 10565 memset (&fsym, 0, sizeof (fsym)); 10566 fsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE); 10567 fsym.st_shndx = SHN_ABS; 10568 if (!elf_link_output_symstrtab (eoinfo->flinfo, NULL, &fsym, 10569 bfd_und_section_ptr, NULL)) 10570 return FALSE; 10571 10572 eoinfo->file_sym_done = TRUE; 10573 } 10574 10575 indx = bfd_get_symcount (flinfo->output_bfd); 10576 ret = elf_link_output_symstrtab (flinfo, h->root.root.string, &sym, 10577 input_sec, h); 10578 if (ret == 0) 10579 { 10580 eoinfo->failed = TRUE; 10581 return FALSE; 10582 } 10583 else if (ret == 1) 10584 h->indx = indx; 10585 else if (h->indx == -2) 10586 abort(); 10587 10588 return TRUE; 10589} 10590 10591/* Return TRUE if special handling is done for relocs in SEC against 10592 symbols defined in discarded sections. */ 10593 10594static bfd_boolean 10595elf_section_ignore_discarded_relocs (asection *sec) 10596{ 10597 const struct elf_backend_data *bed; 10598 10599 switch (sec->sec_info_type) 10600 { 10601 case SEC_INFO_TYPE_STABS: 10602 case SEC_INFO_TYPE_EH_FRAME: 10603 case SEC_INFO_TYPE_EH_FRAME_ENTRY: 10604 return TRUE; 10605 default: 10606 break; 10607 } 10608 10609 bed = get_elf_backend_data (sec->owner); 10610 if (bed->elf_backend_ignore_discarded_relocs != NULL 10611 && (*bed->elf_backend_ignore_discarded_relocs) (sec)) 10612 return TRUE; 10613 10614 return FALSE; 10615} 10616 10617/* Return a mask saying how ld should treat relocations in SEC against 10618 symbols defined in discarded sections. If this function returns 10619 COMPLAIN set, ld will issue a warning message. If this function 10620 returns PRETEND set, and the discarded section was link-once and the 10621 same size as the kept link-once section, ld will pretend that the 10622 symbol was actually defined in the kept section. Otherwise ld will 10623 zero the reloc (at least that is the intent, but some cooperation by 10624 the target dependent code is needed, particularly for REL targets). */ 10625 10626unsigned int 10627_bfd_elf_default_action_discarded (asection *sec) 10628{ 10629 if (sec->flags & SEC_DEBUGGING) 10630 return PRETEND; 10631 10632 if (strcmp (".eh_frame", sec->name) == 0) 10633 return 0; 10634 10635 if (strcmp (".gcc_except_table", sec->name) == 0) 10636 return 0; 10637 10638 return COMPLAIN | PRETEND; 10639} 10640 10641/* Find a match between a section and a member of a section group. */ 10642 10643static asection * 10644match_group_member (asection *sec, asection *group, 10645 struct bfd_link_info *info) 10646{ 10647 asection *first = elf_next_in_group (group); 10648 asection *s = first; 10649 10650 while (s != NULL) 10651 { 10652 if (bfd_elf_match_symbols_in_sections (s, sec, info)) 10653 return s; 10654 10655 s = elf_next_in_group (s); 10656 if (s == first) 10657 break; 10658 } 10659 10660 return NULL; 10661} 10662 10663/* Check if the kept section of a discarded section SEC can be used 10664 to replace it. Return the replacement if it is OK. Otherwise return 10665 NULL. */ 10666 10667asection * 10668_bfd_elf_check_kept_section (asection *sec, struct bfd_link_info *info) 10669{ 10670 asection *kept; 10671 10672 kept = sec->kept_section; 10673 if (kept != NULL) 10674 { 10675 if ((kept->flags & SEC_GROUP) != 0) 10676 kept = match_group_member (sec, kept, info); 10677 if (kept != NULL 10678 && ((sec->rawsize != 0 ? sec->rawsize : sec->size) 10679 != (kept->rawsize != 0 ? kept->rawsize : kept->size))) 10680 kept = NULL; 10681 sec->kept_section = kept; 10682 } 10683 return kept; 10684} 10685 10686/* Link an input file into the linker output file. This function 10687 handles all the sections and relocations of the input file at once. 10688 This is so that we only have to read the local symbols once, and 10689 don't have to keep them in memory. */ 10690 10691static bfd_boolean 10692elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd) 10693{ 10694 int (*relocate_section) 10695 (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, 10696 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **); 10697 bfd *output_bfd; 10698 Elf_Internal_Shdr *symtab_hdr; 10699 size_t locsymcount; 10700 size_t extsymoff; 10701 Elf_Internal_Sym *isymbuf; 10702 Elf_Internal_Sym *isym; 10703 Elf_Internal_Sym *isymend; 10704 long *pindex; 10705 asection **ppsection; 10706 asection *o; 10707 const struct elf_backend_data *bed; 10708 struct elf_link_hash_entry **sym_hashes; 10709 bfd_size_type address_size; 10710 bfd_vma r_type_mask; 10711 int r_sym_shift; 10712 bfd_boolean have_file_sym = FALSE; 10713 10714 output_bfd = flinfo->output_bfd; 10715 bed = get_elf_backend_data (output_bfd); 10716 relocate_section = bed->elf_backend_relocate_section; 10717 10718 /* If this is a dynamic object, we don't want to do anything here: 10719 we don't want the local symbols, and we don't want the section 10720 contents. */ 10721 if ((input_bfd->flags & DYNAMIC) != 0) 10722 return TRUE; 10723 10724 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 10725 if (elf_bad_symtab (input_bfd)) 10726 { 10727 locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym; 10728 extsymoff = 0; 10729 } 10730 else 10731 { 10732 locsymcount = symtab_hdr->sh_info; 10733 extsymoff = symtab_hdr->sh_info; 10734 } 10735 10736 /* Read the local symbols. */ 10737 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 10738 if (isymbuf == NULL && locsymcount != 0) 10739 { 10740 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0, 10741 flinfo->internal_syms, 10742 flinfo->external_syms, 10743 flinfo->locsym_shndx); 10744 if (isymbuf == NULL) 10745 return FALSE; 10746 } 10747 10748 /* Find local symbol sections and adjust values of symbols in 10749 SEC_MERGE sections. Write out those local symbols we know are 10750 going into the output file. */ 10751 isymend = isymbuf + locsymcount; 10752 for (isym = isymbuf, pindex = flinfo->indices, ppsection = flinfo->sections; 10753 isym < isymend; 10754 isym++, pindex++, ppsection++) 10755 { 10756 asection *isec; 10757 const char *name; 10758 Elf_Internal_Sym osym; 10759 long indx; 10760 int ret; 10761 10762 *pindex = -1; 10763 10764 if (elf_bad_symtab (input_bfd)) 10765 { 10766 if (ELF_ST_BIND (isym->st_info) != STB_LOCAL) 10767 { 10768 *ppsection = NULL; 10769 continue; 10770 } 10771 } 10772 10773 if (isym->st_shndx == SHN_UNDEF) 10774 isec = bfd_und_section_ptr; 10775 else if (isym->st_shndx == SHN_ABS) 10776 isec = bfd_abs_section_ptr; 10777 else if (isym->st_shndx == SHN_COMMON) 10778 isec = bfd_com_section_ptr; 10779 else 10780 { 10781 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx); 10782 if (isec == NULL) 10783 { 10784 /* Don't attempt to output symbols with st_shnx in the 10785 reserved range other than SHN_ABS and SHN_COMMON. */ 10786 isec = bfd_und_section_ptr; 10787 } 10788 else if (isec->sec_info_type == SEC_INFO_TYPE_MERGE 10789 && ELF_ST_TYPE (isym->st_info) != STT_SECTION) 10790 isym->st_value = 10791 _bfd_merged_section_offset (output_bfd, &isec, 10792 elf_section_data (isec)->sec_info, 10793 isym->st_value); 10794 } 10795 10796 *ppsection = isec; 10797 10798 /* Don't output the first, undefined, symbol. In fact, don't 10799 output any undefined local symbol. */ 10800 if (isec == bfd_und_section_ptr) 10801 continue; 10802 10803 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION) 10804 { 10805 /* We never output section symbols. Instead, we use the 10806 section symbol of the corresponding section in the output 10807 file. */ 10808 continue; 10809 } 10810 10811 /* If we are stripping all symbols, we don't want to output this 10812 one. */ 10813 if (flinfo->info->strip == strip_all) 10814 continue; 10815 10816 /* If we are discarding all local symbols, we don't want to 10817 output this one. If we are generating a relocatable output 10818 file, then some of the local symbols may be required by 10819 relocs; we output them below as we discover that they are 10820 needed. */ 10821 if (flinfo->info->discard == discard_all) 10822 continue; 10823 10824 /* If this symbol is defined in a section which we are 10825 discarding, we don't need to keep it. */ 10826 if (isym->st_shndx != SHN_UNDEF 10827 && isym->st_shndx < SHN_LORESERVE 10828 && isec->output_section == NULL 10829 && flinfo->info->non_contiguous_regions 10830 && flinfo->info->non_contiguous_regions_warnings) 10831 { 10832 _bfd_error_handler (_("warning: --enable-non-contiguous-regions " 10833 "discards section `%s' from '%s'\n"), 10834 isec->name, bfd_get_filename (isec->owner)); 10835 continue; 10836 } 10837 10838 if (isym->st_shndx != SHN_UNDEF 10839 && isym->st_shndx < SHN_LORESERVE 10840 && bfd_section_removed_from_list (output_bfd, 10841 isec->output_section)) 10842 continue; 10843 10844 /* Get the name of the symbol. */ 10845 name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link, 10846 isym->st_name); 10847 if (name == NULL) 10848 return FALSE; 10849 10850 /* See if we are discarding symbols with this name. */ 10851 if ((flinfo->info->strip == strip_some 10852 && (bfd_hash_lookup (flinfo->info->keep_hash, name, FALSE, FALSE) 10853 == NULL)) 10854 || (((flinfo->info->discard == discard_sec_merge 10855 && (isec->flags & SEC_MERGE) 10856 && !bfd_link_relocatable (flinfo->info)) 10857 || flinfo->info->discard == discard_l) 10858 && bfd_is_local_label_name (input_bfd, name))) 10859 continue; 10860 10861 if (ELF_ST_TYPE (isym->st_info) == STT_FILE) 10862 { 10863 if (input_bfd->lto_output) 10864 /* -flto puts a temp file name here. This means builds 10865 are not reproducible. Discard the symbol. */ 10866 continue; 10867 have_file_sym = TRUE; 10868 flinfo->filesym_count += 1; 10869 } 10870 if (!have_file_sym) 10871 { 10872 /* In the absence of debug info, bfd_find_nearest_line uses 10873 FILE symbols to determine the source file for local 10874 function symbols. Provide a FILE symbol here if input 10875 files lack such, so that their symbols won't be 10876 associated with a previous input file. It's not the 10877 source file, but the best we can do. */ 10878 have_file_sym = TRUE; 10879 flinfo->filesym_count += 1; 10880 memset (&osym, 0, sizeof (osym)); 10881 osym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE); 10882 osym.st_shndx = SHN_ABS; 10883 if (!elf_link_output_symstrtab (flinfo, 10884 (input_bfd->lto_output ? NULL 10885 : bfd_get_filename (input_bfd)), 10886 &osym, bfd_abs_section_ptr, 10887 NULL)) 10888 return FALSE; 10889 } 10890 10891 osym = *isym; 10892 10893 /* Adjust the section index for the output file. */ 10894 osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd, 10895 isec->output_section); 10896 if (osym.st_shndx == SHN_BAD) 10897 return FALSE; 10898 10899 /* ELF symbols in relocatable files are section relative, but 10900 in executable files they are virtual addresses. Note that 10901 this code assumes that all ELF sections have an associated 10902 BFD section with a reasonable value for output_offset; below 10903 we assume that they also have a reasonable value for 10904 output_section. Any special sections must be set up to meet 10905 these requirements. */ 10906 osym.st_value += isec->output_offset; 10907 if (!bfd_link_relocatable (flinfo->info)) 10908 { 10909 osym.st_value += isec->output_section->vma; 10910 if (ELF_ST_TYPE (osym.st_info) == STT_TLS) 10911 { 10912 /* STT_TLS symbols are relative to PT_TLS segment base. */ 10913 if (elf_hash_table (flinfo->info)->tls_sec != NULL) 10914 osym.st_value -= elf_hash_table (flinfo->info)->tls_sec->vma; 10915 else 10916 osym.st_info = ELF_ST_INFO (ELF_ST_BIND (osym.st_info), 10917 STT_NOTYPE); 10918 } 10919 } 10920 10921 indx = bfd_get_symcount (output_bfd); 10922 ret = elf_link_output_symstrtab (flinfo, name, &osym, isec, NULL); 10923 if (ret == 0) 10924 return FALSE; 10925 else if (ret == 1) 10926 *pindex = indx; 10927 } 10928 10929 if (bed->s->arch_size == 32) 10930 { 10931 r_type_mask = 0xff; 10932 r_sym_shift = 8; 10933 address_size = 4; 10934 } 10935 else 10936 { 10937 r_type_mask = 0xffffffff; 10938 r_sym_shift = 32; 10939 address_size = 8; 10940 } 10941 10942 /* Relocate the contents of each section. */ 10943 sym_hashes = elf_sym_hashes (input_bfd); 10944 for (o = input_bfd->sections; o != NULL; o = o->next) 10945 { 10946 bfd_byte *contents; 10947 10948 if (! o->linker_mark) 10949 { 10950 /* This section was omitted from the link. */ 10951 continue; 10952 } 10953 10954 if (!flinfo->info->resolve_section_groups 10955 && (o->flags & (SEC_LINKER_CREATED | SEC_GROUP)) == SEC_GROUP) 10956 { 10957 /* Deal with the group signature symbol. */ 10958 struct bfd_elf_section_data *sec_data = elf_section_data (o); 10959 unsigned long symndx = sec_data->this_hdr.sh_info; 10960 asection *osec = o->output_section; 10961 10962 BFD_ASSERT (bfd_link_relocatable (flinfo->info)); 10963 if (symndx >= locsymcount 10964 || (elf_bad_symtab (input_bfd) 10965 && flinfo->sections[symndx] == NULL)) 10966 { 10967 struct elf_link_hash_entry *h = sym_hashes[symndx - extsymoff]; 10968 while (h->root.type == bfd_link_hash_indirect 10969 || h->root.type == bfd_link_hash_warning) 10970 h = (struct elf_link_hash_entry *) h->root.u.i.link; 10971 /* Arrange for symbol to be output. */ 10972 h->indx = -2; 10973 elf_section_data (osec)->this_hdr.sh_info = -2; 10974 } 10975 else if (ELF_ST_TYPE (isymbuf[symndx].st_info) == STT_SECTION) 10976 { 10977 /* We'll use the output section target_index. */ 10978 asection *sec = flinfo->sections[symndx]->output_section; 10979 elf_section_data (osec)->this_hdr.sh_info = sec->target_index; 10980 } 10981 else 10982 { 10983 if (flinfo->indices[symndx] == -1) 10984 { 10985 /* Otherwise output the local symbol now. */ 10986 Elf_Internal_Sym sym = isymbuf[symndx]; 10987 asection *sec = flinfo->sections[symndx]->output_section; 10988 const char *name; 10989 long indx; 10990 int ret; 10991 10992 name = bfd_elf_string_from_elf_section (input_bfd, 10993 symtab_hdr->sh_link, 10994 sym.st_name); 10995 if (name == NULL) 10996 return FALSE; 10997 10998 sym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd, 10999 sec); 11000 if (sym.st_shndx == SHN_BAD) 11001 return FALSE; 11002 11003 sym.st_value += o->output_offset; 11004 11005 indx = bfd_get_symcount (output_bfd); 11006 ret = elf_link_output_symstrtab (flinfo, name, &sym, o, 11007 NULL); 11008 if (ret == 0) 11009 return FALSE; 11010 else if (ret == 1) 11011 flinfo->indices[symndx] = indx; 11012 else 11013 abort (); 11014 } 11015 elf_section_data (osec)->this_hdr.sh_info 11016 = flinfo->indices[symndx]; 11017 } 11018 } 11019 11020 if ((o->flags & SEC_HAS_CONTENTS) == 0 11021 || (o->size == 0 && (o->flags & SEC_RELOC) == 0)) 11022 continue; 11023 11024 if ((o->flags & SEC_LINKER_CREATED) != 0) 11025 { 11026 /* Section was created by _bfd_elf_link_create_dynamic_sections 11027 or somesuch. */ 11028 continue; 11029 } 11030 11031 /* Get the contents of the section. They have been cached by a 11032 relaxation routine. Note that o is a section in an input 11033 file, so the contents field will not have been set by any of 11034 the routines which work on output files. */ 11035 if (elf_section_data (o)->this_hdr.contents != NULL) 11036 { 11037 contents = elf_section_data (o)->this_hdr.contents; 11038 if (bed->caches_rawsize 11039 && o->rawsize != 0 11040 && o->rawsize < o->size) 11041 { 11042 memcpy (flinfo->contents, contents, o->rawsize); 11043 contents = flinfo->contents; 11044 } 11045 } 11046 else 11047 { 11048 contents = flinfo->contents; 11049 if (! bfd_get_full_section_contents (input_bfd, o, &contents)) 11050 return FALSE; 11051 } 11052 11053 if ((o->flags & SEC_RELOC) != 0) 11054 { 11055 Elf_Internal_Rela *internal_relocs; 11056 Elf_Internal_Rela *rel, *relend; 11057 int action_discarded; 11058 int ret; 11059 11060 /* Get the swapped relocs. */ 11061 internal_relocs 11062 = _bfd_elf_link_read_relocs (input_bfd, o, flinfo->external_relocs, 11063 flinfo->internal_relocs, FALSE); 11064 if (internal_relocs == NULL 11065 && o->reloc_count > 0) 11066 return FALSE; 11067 11068 /* We need to reverse-copy input .ctors/.dtors sections if 11069 they are placed in .init_array/.finit_array for output. */ 11070 if (o->size > address_size 11071 && ((strncmp (o->name, ".ctors", 6) == 0 11072 && strcmp (o->output_section->name, 11073 ".init_array") == 0) 11074 || (strncmp (o->name, ".dtors", 6) == 0 11075 && strcmp (o->output_section->name, 11076 ".fini_array") == 0)) 11077 && (o->name[6] == 0 || o->name[6] == '.')) 11078 { 11079 if (o->size * bed->s->int_rels_per_ext_rel 11080 != o->reloc_count * address_size) 11081 { 11082 _bfd_error_handler 11083 /* xgettext:c-format */ 11084 (_("error: %pB: size of section %pA is not " 11085 "multiple of address size"), 11086 input_bfd, o); 11087 bfd_set_error (bfd_error_bad_value); 11088 return FALSE; 11089 } 11090 o->flags |= SEC_ELF_REVERSE_COPY; 11091 } 11092 11093 action_discarded = -1; 11094 if (!elf_section_ignore_discarded_relocs (o)) 11095 action_discarded = (*bed->action_discarded) (o); 11096 11097 /* Run through the relocs evaluating complex reloc symbols and 11098 looking for relocs against symbols from discarded sections 11099 or section symbols from removed link-once sections. 11100 Complain about relocs against discarded sections. Zero 11101 relocs against removed link-once sections. */ 11102 11103 rel = internal_relocs; 11104 relend = rel + o->reloc_count; 11105 for ( ; rel < relend; rel++) 11106 { 11107 unsigned long r_symndx = rel->r_info >> r_sym_shift; 11108 unsigned int s_type; 11109 asection **ps, *sec; 11110 struct elf_link_hash_entry *h = NULL; 11111 const char *sym_name; 11112 11113 if (r_symndx == STN_UNDEF) 11114 continue; 11115 11116 if (r_symndx >= locsymcount 11117 || (elf_bad_symtab (input_bfd) 11118 && flinfo->sections[r_symndx] == NULL)) 11119 { 11120 h = sym_hashes[r_symndx - extsymoff]; 11121 11122 /* Badly formatted input files can contain relocs that 11123 reference non-existant symbols. Check here so that 11124 we do not seg fault. */ 11125 if (h == NULL) 11126 { 11127 _bfd_error_handler 11128 /* xgettext:c-format */ 11129 (_("error: %pB contains a reloc (%#" PRIx64 ") for section %pA " 11130 "that references a non-existent global symbol"), 11131 input_bfd, (uint64_t) rel->r_info, o); 11132 bfd_set_error (bfd_error_bad_value); 11133 return FALSE; 11134 } 11135 11136 while (h->root.type == bfd_link_hash_indirect 11137 || h->root.type == bfd_link_hash_warning) 11138 h = (struct elf_link_hash_entry *) h->root.u.i.link; 11139 11140 s_type = h->type; 11141 11142 /* If a plugin symbol is referenced from a non-IR file, 11143 mark the symbol as undefined. Note that the 11144 linker may attach linker created dynamic sections 11145 to the plugin bfd. Symbols defined in linker 11146 created sections are not plugin symbols. */ 11147 if ((h->root.non_ir_ref_regular 11148 || h->root.non_ir_ref_dynamic) 11149 && (h->root.type == bfd_link_hash_defined 11150 || h->root.type == bfd_link_hash_defweak) 11151 && (h->root.u.def.section->flags 11152 & SEC_LINKER_CREATED) == 0 11153 && h->root.u.def.section->owner != NULL 11154 && (h->root.u.def.section->owner->flags 11155 & BFD_PLUGIN) != 0) 11156 { 11157 h->root.type = bfd_link_hash_undefined; 11158 h->root.u.undef.abfd = h->root.u.def.section->owner; 11159 } 11160 11161 ps = NULL; 11162 if (h->root.type == bfd_link_hash_defined 11163 || h->root.type == bfd_link_hash_defweak) 11164 ps = &h->root.u.def.section; 11165 11166 sym_name = h->root.root.string; 11167 } 11168 else 11169 { 11170 Elf_Internal_Sym *sym = isymbuf + r_symndx; 11171 11172 s_type = ELF_ST_TYPE (sym->st_info); 11173 ps = &flinfo->sections[r_symndx]; 11174 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, 11175 sym, *ps); 11176 } 11177 11178 if ((s_type == STT_RELC || s_type == STT_SRELC) 11179 && !bfd_link_relocatable (flinfo->info)) 11180 { 11181 bfd_vma val; 11182 bfd_vma dot = (rel->r_offset 11183 + o->output_offset + o->output_section->vma); 11184#ifdef DEBUG 11185 printf ("Encountered a complex symbol!"); 11186 printf (" (input_bfd %s, section %s, reloc %ld\n", 11187 bfd_get_filename (input_bfd), o->name, 11188 (long) (rel - internal_relocs)); 11189 printf (" symbol: idx %8.8lx, name %s\n", 11190 r_symndx, sym_name); 11191 printf (" reloc : info %8.8lx, addr %8.8lx\n", 11192 (unsigned long) rel->r_info, 11193 (unsigned long) rel->r_offset); 11194#endif 11195 if (!eval_symbol (&val, &sym_name, input_bfd, flinfo, dot, 11196 isymbuf, locsymcount, s_type == STT_SRELC)) 11197 return FALSE; 11198 11199 /* Symbol evaluated OK. Update to absolute value. */ 11200 set_symbol_value (input_bfd, isymbuf, locsymcount, 11201 r_symndx, val); 11202 continue; 11203 } 11204 11205 if (action_discarded != -1 && ps != NULL) 11206 { 11207 /* Complain if the definition comes from a 11208 discarded section. */ 11209 if ((sec = *ps) != NULL && discarded_section (sec)) 11210 { 11211 BFD_ASSERT (r_symndx != STN_UNDEF); 11212 if (action_discarded & COMPLAIN) 11213 (*flinfo->info->callbacks->einfo) 11214 /* xgettext:c-format */ 11215 (_("%X`%s' referenced in section `%pA' of %pB: " 11216 "defined in discarded section `%pA' of %pB\n"), 11217 sym_name, o, input_bfd, sec, sec->owner); 11218 11219 /* Try to do the best we can to support buggy old 11220 versions of gcc. Pretend that the symbol is 11221 really defined in the kept linkonce section. 11222 FIXME: This is quite broken. Modifying the 11223 symbol here means we will be changing all later 11224 uses of the symbol, not just in this section. */ 11225 if (action_discarded & PRETEND) 11226 { 11227 asection *kept; 11228 11229 kept = _bfd_elf_check_kept_section (sec, 11230 flinfo->info); 11231 if (kept != NULL) 11232 { 11233 *ps = kept; 11234 continue; 11235 } 11236 } 11237 } 11238 } 11239 } 11240 11241 /* Relocate the section by invoking a back end routine. 11242 11243 The back end routine is responsible for adjusting the 11244 section contents as necessary, and (if using Rela relocs 11245 and generating a relocatable output file) adjusting the 11246 reloc addend as necessary. 11247 11248 The back end routine does not have to worry about setting 11249 the reloc address or the reloc symbol index. 11250 11251 The back end routine is given a pointer to the swapped in 11252 internal symbols, and can access the hash table entries 11253 for the external symbols via elf_sym_hashes (input_bfd). 11254 11255 When generating relocatable output, the back end routine 11256 must handle STB_LOCAL/STT_SECTION symbols specially. The 11257 output symbol is going to be a section symbol 11258 corresponding to the output section, which will require 11259 the addend to be adjusted. */ 11260 11261 ret = (*relocate_section) (output_bfd, flinfo->info, 11262 input_bfd, o, contents, 11263 internal_relocs, 11264 isymbuf, 11265 flinfo->sections); 11266 if (!ret) 11267 return FALSE; 11268 11269 if (ret == 2 11270 || bfd_link_relocatable (flinfo->info) 11271 || flinfo->info->emitrelocations) 11272 { 11273 Elf_Internal_Rela *irela; 11274 Elf_Internal_Rela *irelaend, *irelamid; 11275 bfd_vma last_offset; 11276 struct elf_link_hash_entry **rel_hash; 11277 struct elf_link_hash_entry **rel_hash_list, **rela_hash_list; 11278 Elf_Internal_Shdr *input_rel_hdr, *input_rela_hdr; 11279 unsigned int next_erel; 11280 bfd_boolean rela_normal; 11281 struct bfd_elf_section_data *esdi, *esdo; 11282 11283 esdi = elf_section_data (o); 11284 esdo = elf_section_data (o->output_section); 11285 rela_normal = FALSE; 11286 11287 /* Adjust the reloc addresses and symbol indices. */ 11288 11289 irela = internal_relocs; 11290 irelaend = irela + o->reloc_count; 11291 rel_hash = esdo->rel.hashes + esdo->rel.count; 11292 /* We start processing the REL relocs, if any. When we reach 11293 IRELAMID in the loop, we switch to the RELA relocs. */ 11294 irelamid = irela; 11295 if (esdi->rel.hdr != NULL) 11296 irelamid += (NUM_SHDR_ENTRIES (esdi->rel.hdr) 11297 * bed->s->int_rels_per_ext_rel); 11298 rel_hash_list = rel_hash; 11299 rela_hash_list = NULL; 11300 last_offset = o->output_offset; 11301 if (!bfd_link_relocatable (flinfo->info)) 11302 last_offset += o->output_section->vma; 11303 for (next_erel = 0; irela < irelaend; irela++, next_erel++) 11304 { 11305 unsigned long r_symndx; 11306 asection *sec; 11307 Elf_Internal_Sym sym; 11308 11309 if (next_erel == bed->s->int_rels_per_ext_rel) 11310 { 11311 rel_hash++; 11312 next_erel = 0; 11313 } 11314 11315 if (irela == irelamid) 11316 { 11317 rel_hash = esdo->rela.hashes + esdo->rela.count; 11318 rela_hash_list = rel_hash; 11319 rela_normal = bed->rela_normal; 11320 } 11321 11322 irela->r_offset = _bfd_elf_section_offset (output_bfd, 11323 flinfo->info, o, 11324 irela->r_offset); 11325 if (irela->r_offset >= (bfd_vma) -2) 11326 { 11327 /* This is a reloc for a deleted entry or somesuch. 11328 Turn it into an R_*_NONE reloc, at the same 11329 offset as the last reloc. elf_eh_frame.c and 11330 bfd_elf_discard_info rely on reloc offsets 11331 being ordered. */ 11332 irela->r_offset = last_offset; 11333 irela->r_info = 0; 11334 irela->r_addend = 0; 11335 continue; 11336 } 11337 11338 irela->r_offset += o->output_offset; 11339 11340 /* Relocs in an executable have to be virtual addresses. */ 11341 if (!bfd_link_relocatable (flinfo->info)) 11342 irela->r_offset += o->output_section->vma; 11343 11344 last_offset = irela->r_offset; 11345 11346 r_symndx = irela->r_info >> r_sym_shift; 11347 if (r_symndx == STN_UNDEF) 11348 continue; 11349 11350 if (r_symndx >= locsymcount 11351 || (elf_bad_symtab (input_bfd) 11352 && flinfo->sections[r_symndx] == NULL)) 11353 { 11354 struct elf_link_hash_entry *rh; 11355 unsigned long indx; 11356 11357 /* This is a reloc against a global symbol. We 11358 have not yet output all the local symbols, so 11359 we do not know the symbol index of any global 11360 symbol. We set the rel_hash entry for this 11361 reloc to point to the global hash table entry 11362 for this symbol. The symbol index is then 11363 set at the end of bfd_elf_final_link. */ 11364 indx = r_symndx - extsymoff; 11365 rh = elf_sym_hashes (input_bfd)[indx]; 11366 while (rh->root.type == bfd_link_hash_indirect 11367 || rh->root.type == bfd_link_hash_warning) 11368 rh = (struct elf_link_hash_entry *) rh->root.u.i.link; 11369 11370 /* Setting the index to -2 tells 11371 elf_link_output_extsym that this symbol is 11372 used by a reloc. */ 11373 BFD_ASSERT (rh->indx < 0); 11374 rh->indx = -2; 11375 *rel_hash = rh; 11376 11377 continue; 11378 } 11379 11380 /* This is a reloc against a local symbol. */ 11381 11382 *rel_hash = NULL; 11383 sym = isymbuf[r_symndx]; 11384 sec = flinfo->sections[r_symndx]; 11385 if (ELF_ST_TYPE (sym.st_info) == STT_SECTION) 11386 { 11387 /* I suppose the backend ought to fill in the 11388 section of any STT_SECTION symbol against a 11389 processor specific section. */ 11390 r_symndx = STN_UNDEF; 11391 if (bfd_is_abs_section (sec)) 11392 ; 11393 else if (sec == NULL || sec->owner == NULL) 11394 { 11395 bfd_set_error (bfd_error_bad_value); 11396 return FALSE; 11397 } 11398 else 11399 { 11400 asection *osec = sec->output_section; 11401 11402 /* If we have discarded a section, the output 11403 section will be the absolute section. In 11404 case of discarded SEC_MERGE sections, use 11405 the kept section. relocate_section should 11406 have already handled discarded linkonce 11407 sections. */ 11408 if (bfd_is_abs_section (osec) 11409 && sec->kept_section != NULL 11410 && sec->kept_section->output_section != NULL) 11411 { 11412 osec = sec->kept_section->output_section; 11413 irela->r_addend -= osec->vma; 11414 } 11415 11416 if (!bfd_is_abs_section (osec)) 11417 { 11418 r_symndx = osec->target_index; 11419 if (r_symndx == STN_UNDEF) 11420 { 11421 irela->r_addend += osec->vma; 11422 osec = _bfd_nearby_section (output_bfd, osec, 11423 osec->vma); 11424 irela->r_addend -= osec->vma; 11425 r_symndx = osec->target_index; 11426 } 11427 } 11428 } 11429 11430 /* Adjust the addend according to where the 11431 section winds up in the output section. */ 11432 if (rela_normal) 11433 irela->r_addend += sec->output_offset; 11434 } 11435 else 11436 { 11437 if (flinfo->indices[r_symndx] == -1) 11438 { 11439 unsigned long shlink; 11440 const char *name; 11441 asection *osec; 11442 long indx; 11443 11444 if (flinfo->info->strip == strip_all) 11445 { 11446 /* You can't do ld -r -s. */ 11447 bfd_set_error (bfd_error_invalid_operation); 11448 return FALSE; 11449 } 11450 11451 /* This symbol was skipped earlier, but 11452 since it is needed by a reloc, we 11453 must output it now. */ 11454 shlink = symtab_hdr->sh_link; 11455 name = (bfd_elf_string_from_elf_section 11456 (input_bfd, shlink, sym.st_name)); 11457 if (name == NULL) 11458 return FALSE; 11459 11460 osec = sec->output_section; 11461 sym.st_shndx = 11462 _bfd_elf_section_from_bfd_section (output_bfd, 11463 osec); 11464 if (sym.st_shndx == SHN_BAD) 11465 return FALSE; 11466 11467 sym.st_value += sec->output_offset; 11468 if (!bfd_link_relocatable (flinfo->info)) 11469 { 11470 sym.st_value += osec->vma; 11471 if (ELF_ST_TYPE (sym.st_info) == STT_TLS) 11472 { 11473 struct elf_link_hash_table *htab 11474 = elf_hash_table (flinfo->info); 11475 11476 /* STT_TLS symbols are relative to PT_TLS 11477 segment base. */ 11478 if (htab->tls_sec != NULL) 11479 sym.st_value -= htab->tls_sec->vma; 11480 else 11481 sym.st_info 11482 = ELF_ST_INFO (ELF_ST_BIND (sym.st_info), 11483 STT_NOTYPE); 11484 } 11485 } 11486 11487 indx = bfd_get_symcount (output_bfd); 11488 ret = elf_link_output_symstrtab (flinfo, name, 11489 &sym, sec, 11490 NULL); 11491 if (ret == 0) 11492 return FALSE; 11493 else if (ret == 1) 11494 flinfo->indices[r_symndx] = indx; 11495 else 11496 abort (); 11497 } 11498 11499 r_symndx = flinfo->indices[r_symndx]; 11500 } 11501 11502 irela->r_info = ((bfd_vma) r_symndx << r_sym_shift 11503 | (irela->r_info & r_type_mask)); 11504 } 11505 11506 /* Swap out the relocs. */ 11507 input_rel_hdr = esdi->rel.hdr; 11508 if (input_rel_hdr && input_rel_hdr->sh_size != 0) 11509 { 11510 if (!bed->elf_backend_emit_relocs (output_bfd, o, 11511 input_rel_hdr, 11512 internal_relocs, 11513 rel_hash_list)) 11514 return FALSE; 11515 internal_relocs += (NUM_SHDR_ENTRIES (input_rel_hdr) 11516 * bed->s->int_rels_per_ext_rel); 11517 rel_hash_list += NUM_SHDR_ENTRIES (input_rel_hdr); 11518 } 11519 11520 input_rela_hdr = esdi->rela.hdr; 11521 if (input_rela_hdr && input_rela_hdr->sh_size != 0) 11522 { 11523 if (!bed->elf_backend_emit_relocs (output_bfd, o, 11524 input_rela_hdr, 11525 internal_relocs, 11526 rela_hash_list)) 11527 return FALSE; 11528 } 11529 } 11530 } 11531 11532 /* Write out the modified section contents. */ 11533 if (bed->elf_backend_write_section 11534 && (*bed->elf_backend_write_section) (output_bfd, flinfo->info, o, 11535 contents)) 11536 { 11537 /* Section written out. */ 11538 } 11539 else switch (o->sec_info_type) 11540 { 11541 case SEC_INFO_TYPE_STABS: 11542 if (! (_bfd_write_section_stabs 11543 (output_bfd, 11544 &elf_hash_table (flinfo->info)->stab_info, 11545 o, &elf_section_data (o)->sec_info, contents))) 11546 return FALSE; 11547 break; 11548 case SEC_INFO_TYPE_MERGE: 11549 if (! _bfd_write_merged_section (output_bfd, o, 11550 elf_section_data (o)->sec_info)) 11551 return FALSE; 11552 break; 11553 case SEC_INFO_TYPE_EH_FRAME: 11554 { 11555 if (! _bfd_elf_write_section_eh_frame (output_bfd, flinfo->info, 11556 o, contents)) 11557 return FALSE; 11558 } 11559 break; 11560 case SEC_INFO_TYPE_EH_FRAME_ENTRY: 11561 { 11562 if (! _bfd_elf_write_section_eh_frame_entry (output_bfd, 11563 flinfo->info, 11564 o, contents)) 11565 return FALSE; 11566 } 11567 break; 11568 default: 11569 { 11570 if (! (o->flags & SEC_EXCLUDE)) 11571 { 11572 file_ptr offset = (file_ptr) o->output_offset; 11573 bfd_size_type todo = o->size; 11574 11575 offset *= bfd_octets_per_byte (output_bfd, o); 11576 11577 if ((o->flags & SEC_ELF_REVERSE_COPY)) 11578 { 11579 /* Reverse-copy input section to output. */ 11580 do 11581 { 11582 todo -= address_size; 11583 if (! bfd_set_section_contents (output_bfd, 11584 o->output_section, 11585 contents + todo, 11586 offset, 11587 address_size)) 11588 return FALSE; 11589 if (todo == 0) 11590 break; 11591 offset += address_size; 11592 } 11593 while (1); 11594 } 11595 else if (! bfd_set_section_contents (output_bfd, 11596 o->output_section, 11597 contents, 11598 offset, todo)) 11599 return FALSE; 11600 } 11601 } 11602 break; 11603 } 11604 } 11605 11606 return TRUE; 11607} 11608 11609/* Generate a reloc when linking an ELF file. This is a reloc 11610 requested by the linker, and does not come from any input file. This 11611 is used to build constructor and destructor tables when linking 11612 with -Ur. */ 11613 11614static bfd_boolean 11615elf_reloc_link_order (bfd *output_bfd, 11616 struct bfd_link_info *info, 11617 asection *output_section, 11618 struct bfd_link_order *link_order) 11619{ 11620 reloc_howto_type *howto; 11621 long indx; 11622 bfd_vma offset; 11623 bfd_vma addend; 11624 struct bfd_elf_section_reloc_data *reldata; 11625 struct elf_link_hash_entry **rel_hash_ptr; 11626 Elf_Internal_Shdr *rel_hdr; 11627 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd); 11628 Elf_Internal_Rela irel[MAX_INT_RELS_PER_EXT_REL]; 11629 bfd_byte *erel; 11630 unsigned int i; 11631 struct bfd_elf_section_data *esdo = elf_section_data (output_section); 11632 11633 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc); 11634 if (howto == NULL) 11635 { 11636 bfd_set_error (bfd_error_bad_value); 11637 return FALSE; 11638 } 11639 11640 addend = link_order->u.reloc.p->addend; 11641 11642 if (esdo->rel.hdr) 11643 reldata = &esdo->rel; 11644 else if (esdo->rela.hdr) 11645 reldata = &esdo->rela; 11646 else 11647 { 11648 reldata = NULL; 11649 BFD_ASSERT (0); 11650 } 11651 11652 /* Figure out the symbol index. */ 11653 rel_hash_ptr = reldata->hashes + reldata->count; 11654 if (link_order->type == bfd_section_reloc_link_order) 11655 { 11656 indx = link_order->u.reloc.p->u.section->target_index; 11657 BFD_ASSERT (indx != 0); 11658 *rel_hash_ptr = NULL; 11659 } 11660 else 11661 { 11662 struct elf_link_hash_entry *h; 11663 11664 /* Treat a reloc against a defined symbol as though it were 11665 actually against the section. */ 11666 h = ((struct elf_link_hash_entry *) 11667 bfd_wrapped_link_hash_lookup (output_bfd, info, 11668 link_order->u.reloc.p->u.name, 11669 FALSE, FALSE, TRUE)); 11670 if (h != NULL 11671 && (h->root.type == bfd_link_hash_defined 11672 || h->root.type == bfd_link_hash_defweak)) 11673 { 11674 asection *section; 11675 11676 section = h->root.u.def.section; 11677 indx = section->output_section->target_index; 11678 *rel_hash_ptr = NULL; 11679 /* It seems that we ought to add the symbol value to the 11680 addend here, but in practice it has already been added 11681 because it was passed to constructor_callback. */ 11682 addend += section->output_section->vma + section->output_offset; 11683 } 11684 else if (h != NULL) 11685 { 11686 /* Setting the index to -2 tells elf_link_output_extsym that 11687 this symbol is used by a reloc. */ 11688 h->indx = -2; 11689 *rel_hash_ptr = h; 11690 indx = 0; 11691 } 11692 else 11693 { 11694 (*info->callbacks->unattached_reloc) 11695 (info, link_order->u.reloc.p->u.name, NULL, NULL, 0); 11696 indx = 0; 11697 } 11698 } 11699 11700 /* If this is an inplace reloc, we must write the addend into the 11701 object file. */ 11702 if (howto->partial_inplace && addend != 0) 11703 { 11704 bfd_size_type size; 11705 bfd_reloc_status_type rstat; 11706 bfd_byte *buf; 11707 bfd_boolean ok; 11708 const char *sym_name; 11709 bfd_size_type octets; 11710 11711 size = (bfd_size_type) bfd_get_reloc_size (howto); 11712 buf = (bfd_byte *) bfd_zmalloc (size); 11713 if (buf == NULL && size != 0) 11714 return FALSE; 11715 rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf); 11716 switch (rstat) 11717 { 11718 case bfd_reloc_ok: 11719 break; 11720 11721 default: 11722 case bfd_reloc_outofrange: 11723 abort (); 11724 11725 case bfd_reloc_overflow: 11726 if (link_order->type == bfd_section_reloc_link_order) 11727 sym_name = bfd_section_name (link_order->u.reloc.p->u.section); 11728 else 11729 sym_name = link_order->u.reloc.p->u.name; 11730 (*info->callbacks->reloc_overflow) (info, NULL, sym_name, 11731 howto->name, addend, NULL, NULL, 11732 (bfd_vma) 0); 11733 break; 11734 } 11735 11736 octets = link_order->offset * bfd_octets_per_byte (output_bfd, 11737 output_section); 11738 ok = bfd_set_section_contents (output_bfd, output_section, buf, 11739 octets, size); 11740 free (buf); 11741 if (! ok) 11742 return FALSE; 11743 } 11744 11745 /* The address of a reloc is relative to the section in a 11746 relocatable file, and is a virtual address in an executable 11747 file. */ 11748 offset = link_order->offset; 11749 if (! bfd_link_relocatable (info)) 11750 offset += output_section->vma; 11751 11752 for (i = 0; i < bed->s->int_rels_per_ext_rel; i++) 11753 { 11754 irel[i].r_offset = offset; 11755 irel[i].r_info = 0; 11756 irel[i].r_addend = 0; 11757 } 11758 if (bed->s->arch_size == 32) 11759 irel[0].r_info = ELF32_R_INFO (indx, howto->type); 11760 else 11761 irel[0].r_info = ELF64_R_INFO (indx, howto->type); 11762 11763 rel_hdr = reldata->hdr; 11764 erel = rel_hdr->contents; 11765 if (rel_hdr->sh_type == SHT_REL) 11766 { 11767 erel += reldata->count * bed->s->sizeof_rel; 11768 (*bed->s->swap_reloc_out) (output_bfd, irel, erel); 11769 } 11770 else 11771 { 11772 irel[0].r_addend = addend; 11773 erel += reldata->count * bed->s->sizeof_rela; 11774 (*bed->s->swap_reloca_out) (output_bfd, irel, erel); 11775 } 11776 11777 ++reldata->count; 11778 11779 return TRUE; 11780} 11781 11782 11783/* Compare two sections based on the locations of the sections they are 11784 linked to. Used by elf_fixup_link_order. */ 11785 11786static int 11787compare_link_order (const void *a, const void *b) 11788{ 11789 const struct bfd_link_order *alo = *(const struct bfd_link_order **) a; 11790 const struct bfd_link_order *blo = *(const struct bfd_link_order **) b; 11791 asection *asec = elf_linked_to_section (alo->u.indirect.section); 11792 asection *bsec = elf_linked_to_section (blo->u.indirect.section); 11793 bfd_vma apos = asec->output_section->lma + asec->output_offset; 11794 bfd_vma bpos = bsec->output_section->lma + bsec->output_offset; 11795 11796 if (apos < bpos) 11797 return -1; 11798 if (apos > bpos) 11799 return 1; 11800 11801 /* The only way we should get matching LMAs is when the first of two 11802 sections has zero size. */ 11803 if (asec->size < bsec->size) 11804 return -1; 11805 if (asec->size > bsec->size) 11806 return 1; 11807 11808 /* If they are both zero size then they almost certainly have the same 11809 VMA and thus are not ordered with respect to each other. Test VMA 11810 anyway, and fall back to id to make the result reproducible across 11811 qsort implementations. */ 11812 apos = asec->output_section->vma + asec->output_offset; 11813 bpos = bsec->output_section->vma + bsec->output_offset; 11814 if (apos < bpos) 11815 return -1; 11816 if (apos > bpos) 11817 return 1; 11818 11819 return asec->id - bsec->id; 11820} 11821 11822 11823/* Looks for sections with SHF_LINK_ORDER set. Rearranges them into the same 11824 order as their linked sections. Returns false if this could not be done 11825 because an output section includes both ordered and unordered 11826 sections. Ideally we'd do this in the linker proper. */ 11827 11828static bfd_boolean 11829elf_fixup_link_order (bfd *abfd, asection *o) 11830{ 11831 size_t seen_linkorder; 11832 size_t seen_other; 11833 size_t n; 11834 struct bfd_link_order *p; 11835 bfd *sub; 11836 struct bfd_link_order **sections; 11837 asection *other_sec, *linkorder_sec; 11838 bfd_vma offset; /* Octets. */ 11839 11840 other_sec = NULL; 11841 linkorder_sec = NULL; 11842 seen_other = 0; 11843 seen_linkorder = 0; 11844 for (p = o->map_head.link_order; p != NULL; p = p->next) 11845 { 11846 if (p->type == bfd_indirect_link_order) 11847 { 11848 asection *s = p->u.indirect.section; 11849 sub = s->owner; 11850 if ((s->flags & SEC_LINKER_CREATED) == 0 11851 && bfd_get_flavour (sub) == bfd_target_elf_flavour 11852 && elf_section_data (s) != NULL 11853 && elf_linked_to_section (s) != NULL) 11854 { 11855 seen_linkorder++; 11856 linkorder_sec = s; 11857 } 11858 else 11859 { 11860 seen_other++; 11861 other_sec = s; 11862 } 11863 } 11864 else 11865 seen_other++; 11866 11867 if (seen_other && seen_linkorder) 11868 { 11869 if (other_sec && linkorder_sec) 11870 _bfd_error_handler 11871 /* xgettext:c-format */ 11872 (_("%pA has both ordered [`%pA' in %pB] " 11873 "and unordered [`%pA' in %pB] sections"), 11874 o, linkorder_sec, linkorder_sec->owner, 11875 other_sec, other_sec->owner); 11876 else 11877 _bfd_error_handler 11878 (_("%pA has both ordered and unordered sections"), o); 11879 bfd_set_error (bfd_error_bad_value); 11880 return FALSE; 11881 } 11882 } 11883 11884 if (!seen_linkorder) 11885 return TRUE; 11886 11887 sections = bfd_malloc (seen_linkorder * sizeof (*sections)); 11888 if (sections == NULL) 11889 return FALSE; 11890 11891 seen_linkorder = 0; 11892 for (p = o->map_head.link_order; p != NULL; p = p->next) 11893 sections[seen_linkorder++] = p; 11894 11895 /* Sort the input sections in the order of their linked section. */ 11896 qsort (sections, seen_linkorder, sizeof (*sections), compare_link_order); 11897 11898 /* Change the offsets of the sections. */ 11899 offset = 0; 11900 for (n = 0; n < seen_linkorder; n++) 11901 { 11902 bfd_vma mask; 11903 asection *s = sections[n]->u.indirect.section; 11904 unsigned int opb = bfd_octets_per_byte (abfd, s); 11905 11906 mask = ~(bfd_vma) 0 << s->alignment_power * opb; 11907 offset = (offset + ~mask) & mask; 11908 sections[n]->offset = s->output_offset = offset / opb; 11909 offset += sections[n]->size; 11910 } 11911 11912 free (sections); 11913 return TRUE; 11914} 11915 11916/* Generate an import library in INFO->implib_bfd from symbols in ABFD. 11917 Returns TRUE upon success, FALSE otherwise. */ 11918 11919static bfd_boolean 11920elf_output_implib (bfd *abfd, struct bfd_link_info *info) 11921{ 11922 bfd_boolean ret = FALSE; 11923 bfd *implib_bfd; 11924 const struct elf_backend_data *bed; 11925 flagword flags; 11926 enum bfd_architecture arch; 11927 unsigned int mach; 11928 asymbol **sympp = NULL; 11929 long symsize; 11930 long symcount; 11931 long src_count; 11932 elf_symbol_type *osymbuf; 11933 size_t amt; 11934 11935 implib_bfd = info->out_implib_bfd; 11936 bed = get_elf_backend_data (abfd); 11937 11938 if (!bfd_set_format (implib_bfd, bfd_object)) 11939 return FALSE; 11940 11941 /* Use flag from executable but make it a relocatable object. */ 11942 flags = bfd_get_file_flags (abfd); 11943 flags &= ~HAS_RELOC; 11944 if (!bfd_set_start_address (implib_bfd, 0) 11945 || !bfd_set_file_flags (implib_bfd, flags & ~EXEC_P)) 11946 return FALSE; 11947 11948 /* Copy architecture of output file to import library file. */ 11949 arch = bfd_get_arch (abfd); 11950 mach = bfd_get_mach (abfd); 11951 if (!bfd_set_arch_mach (implib_bfd, arch, mach) 11952 && (abfd->target_defaulted 11953 || bfd_get_arch (abfd) != bfd_get_arch (implib_bfd))) 11954 return FALSE; 11955 11956 /* Get symbol table size. */ 11957 symsize = bfd_get_symtab_upper_bound (abfd); 11958 if (symsize < 0) 11959 return FALSE; 11960 11961 /* Read in the symbol table. */ 11962 sympp = (asymbol **) bfd_malloc (symsize); 11963 if (sympp == NULL) 11964 return FALSE; 11965 11966 symcount = bfd_canonicalize_symtab (abfd, sympp); 11967 if (symcount < 0) 11968 goto free_sym_buf; 11969 11970 /* Allow the BFD backend to copy any private header data it 11971 understands from the output BFD to the import library BFD. */ 11972 if (! bfd_copy_private_header_data (abfd, implib_bfd)) 11973 goto free_sym_buf; 11974 11975 /* Filter symbols to appear in the import library. */ 11976 if (bed->elf_backend_filter_implib_symbols) 11977 symcount = bed->elf_backend_filter_implib_symbols (abfd, info, sympp, 11978 symcount); 11979 else 11980 symcount = _bfd_elf_filter_global_symbols (abfd, info, sympp, symcount); 11981 if (symcount == 0) 11982 { 11983 bfd_set_error (bfd_error_no_symbols); 11984 _bfd_error_handler (_("%pB: no symbol found for import library"), 11985 implib_bfd); 11986 goto free_sym_buf; 11987 } 11988 11989 11990 /* Make symbols absolute. */ 11991 amt = symcount * sizeof (*osymbuf); 11992 osymbuf = (elf_symbol_type *) bfd_alloc (implib_bfd, amt); 11993 if (osymbuf == NULL) 11994 goto free_sym_buf; 11995 11996 for (src_count = 0; src_count < symcount; src_count++) 11997 { 11998 memcpy (&osymbuf[src_count], (elf_symbol_type *) sympp[src_count], 11999 sizeof (*osymbuf)); 12000 osymbuf[src_count].symbol.section = bfd_abs_section_ptr; 12001 osymbuf[src_count].internal_elf_sym.st_shndx = SHN_ABS; 12002 osymbuf[src_count].symbol.value += sympp[src_count]->section->vma; 12003 osymbuf[src_count].internal_elf_sym.st_value = 12004 osymbuf[src_count].symbol.value; 12005 sympp[src_count] = &osymbuf[src_count].symbol; 12006 } 12007 12008 bfd_set_symtab (implib_bfd, sympp, symcount); 12009 12010 /* Allow the BFD backend to copy any private data it understands 12011 from the output BFD to the import library BFD. This is done last 12012 to permit the routine to look at the filtered symbol table. */ 12013 if (! bfd_copy_private_bfd_data (abfd, implib_bfd)) 12014 goto free_sym_buf; 12015 12016 if (!bfd_close (implib_bfd)) 12017 goto free_sym_buf; 12018 12019 ret = TRUE; 12020 12021 free_sym_buf: 12022 free (sympp); 12023 return ret; 12024} 12025 12026static void 12027elf_final_link_free (bfd *obfd, struct elf_final_link_info *flinfo) 12028{ 12029 asection *o; 12030 12031 if (flinfo->symstrtab != NULL) 12032 _bfd_elf_strtab_free (flinfo->symstrtab); 12033 free (flinfo->contents); 12034 free (flinfo->external_relocs); 12035 free (flinfo->internal_relocs); 12036 free (flinfo->external_syms); 12037 free (flinfo->locsym_shndx); 12038 free (flinfo->internal_syms); 12039 free (flinfo->indices); 12040 free (flinfo->sections); 12041 if (flinfo->symshndxbuf != (Elf_External_Sym_Shndx *) -1) 12042 free (flinfo->symshndxbuf); 12043 for (o = obfd->sections; o != NULL; o = o->next) 12044 { 12045 struct bfd_elf_section_data *esdo = elf_section_data (o); 12046 free (esdo->rel.hashes); 12047 free (esdo->rela.hashes); 12048 } 12049} 12050 12051/* Do the final step of an ELF link. */ 12052 12053bfd_boolean 12054bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info) 12055{ 12056 bfd_boolean dynamic; 12057 bfd_boolean emit_relocs; 12058 bfd *dynobj; 12059 struct elf_final_link_info flinfo; 12060 asection *o; 12061 struct bfd_link_order *p; 12062 bfd *sub; 12063 bfd_size_type max_contents_size; 12064 bfd_size_type max_external_reloc_size; 12065 bfd_size_type max_internal_reloc_count; 12066 bfd_size_type max_sym_count; 12067 bfd_size_type max_sym_shndx_count; 12068 Elf_Internal_Sym elfsym; 12069 unsigned int i; 12070 Elf_Internal_Shdr *symtab_hdr; 12071 Elf_Internal_Shdr *symtab_shndx_hdr; 12072 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 12073 struct elf_outext_info eoinfo; 12074 bfd_boolean merged; 12075 size_t relativecount = 0; 12076 asection *reldyn = 0; 12077 bfd_size_type amt; 12078 asection *attr_section = NULL; 12079 bfd_vma attr_size = 0; 12080 const char *std_attrs_section; 12081 struct elf_link_hash_table *htab = elf_hash_table (info); 12082 bfd_boolean sections_removed; 12083 bfd_boolean ret; 12084 12085 if (!is_elf_hash_table (htab)) 12086 return FALSE; 12087 12088 if (bfd_link_pic (info)) 12089 abfd->flags |= DYNAMIC; 12090 12091 dynamic = htab->dynamic_sections_created; 12092 dynobj = htab->dynobj; 12093 12094 emit_relocs = (bfd_link_relocatable (info) 12095 || info->emitrelocations); 12096 12097 memset (&flinfo, 0, sizeof (flinfo)); 12098 flinfo.info = info; 12099 flinfo.output_bfd = abfd; 12100 flinfo.symstrtab = _bfd_elf_strtab_init (); 12101 if (flinfo.symstrtab == NULL) 12102 return FALSE; 12103 12104 if (! dynamic) 12105 { 12106 flinfo.hash_sec = NULL; 12107 flinfo.symver_sec = NULL; 12108 } 12109 else 12110 { 12111 flinfo.hash_sec = bfd_get_linker_section (dynobj, ".hash"); 12112 /* Note that dynsym_sec can be NULL (on VMS). */ 12113 flinfo.symver_sec = bfd_get_linker_section (dynobj, ".gnu.version"); 12114 /* Note that it is OK if symver_sec is NULL. */ 12115 } 12116 12117 if (info->unique_symbol 12118 && !bfd_hash_table_init (&flinfo.local_hash_table, 12119 local_hash_newfunc, 12120 sizeof (struct local_hash_entry))) 12121 return FALSE; 12122 12123 /* The object attributes have been merged. Remove the input 12124 sections from the link, and set the contents of the output 12125 section. */ 12126 sections_removed = FALSE; 12127 std_attrs_section = get_elf_backend_data (abfd)->obj_attrs_section; 12128 for (o = abfd->sections; o != NULL; o = o->next) 12129 { 12130 bfd_boolean remove_section = FALSE; 12131 12132 if ((std_attrs_section && strcmp (o->name, std_attrs_section) == 0) 12133 || strcmp (o->name, ".gnu.attributes") == 0) 12134 { 12135 for (p = o->map_head.link_order; p != NULL; p = p->next) 12136 { 12137 asection *input_section; 12138 12139 if (p->type != bfd_indirect_link_order) 12140 continue; 12141 input_section = p->u.indirect.section; 12142 /* Hack: reset the SEC_HAS_CONTENTS flag so that 12143 elf_link_input_bfd ignores this section. */ 12144 input_section->flags &= ~SEC_HAS_CONTENTS; 12145 } 12146 12147 attr_size = bfd_elf_obj_attr_size (abfd); 12148 bfd_set_section_size (o, attr_size); 12149 /* Skip this section later on. */ 12150 o->map_head.link_order = NULL; 12151 if (attr_size) 12152 attr_section = o; 12153 else 12154 remove_section = TRUE; 12155 } 12156 else if ((o->flags & SEC_GROUP) != 0 && o->size == 0) 12157 { 12158 /* Remove empty group section from linker output. */ 12159 remove_section = TRUE; 12160 } 12161 if (remove_section) 12162 { 12163 o->flags |= SEC_EXCLUDE; 12164 bfd_section_list_remove (abfd, o); 12165 abfd->section_count--; 12166 sections_removed = TRUE; 12167 } 12168 } 12169 if (sections_removed) 12170 _bfd_fix_excluded_sec_syms (abfd, info); 12171 12172 /* Count up the number of relocations we will output for each output 12173 section, so that we know the sizes of the reloc sections. We 12174 also figure out some maximum sizes. */ 12175 max_contents_size = 0; 12176 max_external_reloc_size = 0; 12177 max_internal_reloc_count = 0; 12178 max_sym_count = 0; 12179 max_sym_shndx_count = 0; 12180 merged = FALSE; 12181 for (o = abfd->sections; o != NULL; o = o->next) 12182 { 12183 struct bfd_elf_section_data *esdo = elf_section_data (o); 12184 o->reloc_count = 0; 12185 12186 for (p = o->map_head.link_order; p != NULL; p = p->next) 12187 { 12188 unsigned int reloc_count = 0; 12189 unsigned int additional_reloc_count = 0; 12190 struct bfd_elf_section_data *esdi = NULL; 12191 12192 if (p->type == bfd_section_reloc_link_order 12193 || p->type == bfd_symbol_reloc_link_order) 12194 reloc_count = 1; 12195 else if (p->type == bfd_indirect_link_order) 12196 { 12197 asection *sec; 12198 12199 sec = p->u.indirect.section; 12200 12201 /* Mark all sections which are to be included in the 12202 link. This will normally be every section. We need 12203 to do this so that we can identify any sections which 12204 the linker has decided to not include. */ 12205 sec->linker_mark = TRUE; 12206 12207 if (sec->flags & SEC_MERGE) 12208 merged = TRUE; 12209 12210 if (sec->rawsize > max_contents_size) 12211 max_contents_size = sec->rawsize; 12212 if (sec->size > max_contents_size) 12213 max_contents_size = sec->size; 12214 12215 if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour 12216 && (sec->owner->flags & DYNAMIC) == 0) 12217 { 12218 size_t sym_count; 12219 12220 /* We are interested in just local symbols, not all 12221 symbols. */ 12222 if (elf_bad_symtab (sec->owner)) 12223 sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size 12224 / bed->s->sizeof_sym); 12225 else 12226 sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info; 12227 12228 if (sym_count > max_sym_count) 12229 max_sym_count = sym_count; 12230 12231 if (sym_count > max_sym_shndx_count 12232 && elf_symtab_shndx_list (sec->owner) != NULL) 12233 max_sym_shndx_count = sym_count; 12234 12235 if (esdo->this_hdr.sh_type == SHT_REL 12236 || esdo->this_hdr.sh_type == SHT_RELA) 12237 /* Some backends use reloc_count in relocation sections 12238 to count particular types of relocs. Of course, 12239 reloc sections themselves can't have relocations. */ 12240 ; 12241 else if (emit_relocs) 12242 { 12243 reloc_count = sec->reloc_count; 12244 if (bed->elf_backend_count_additional_relocs) 12245 { 12246 int c; 12247 c = (*bed->elf_backend_count_additional_relocs) (sec); 12248 additional_reloc_count += c; 12249 } 12250 } 12251 else if (bed->elf_backend_count_relocs) 12252 reloc_count = (*bed->elf_backend_count_relocs) (info, sec); 12253 12254 esdi = elf_section_data (sec); 12255 12256 if ((sec->flags & SEC_RELOC) != 0) 12257 { 12258 size_t ext_size = 0; 12259 12260 if (esdi->rel.hdr != NULL) 12261 ext_size = esdi->rel.hdr->sh_size; 12262 if (esdi->rela.hdr != NULL) 12263 ext_size += esdi->rela.hdr->sh_size; 12264 12265 if (ext_size > max_external_reloc_size) 12266 max_external_reloc_size = ext_size; 12267 if (sec->reloc_count > max_internal_reloc_count) 12268 max_internal_reloc_count = sec->reloc_count; 12269 } 12270 } 12271 } 12272 12273 if (reloc_count == 0) 12274 continue; 12275 12276 reloc_count += additional_reloc_count; 12277 o->reloc_count += reloc_count; 12278 12279 if (p->type == bfd_indirect_link_order && emit_relocs) 12280 { 12281 if (esdi->rel.hdr) 12282 { 12283 esdo->rel.count += NUM_SHDR_ENTRIES (esdi->rel.hdr); 12284 esdo->rel.count += additional_reloc_count; 12285 } 12286 if (esdi->rela.hdr) 12287 { 12288 esdo->rela.count += NUM_SHDR_ENTRIES (esdi->rela.hdr); 12289 esdo->rela.count += additional_reloc_count; 12290 } 12291 } 12292 else 12293 { 12294 if (o->use_rela_p) 12295 esdo->rela.count += reloc_count; 12296 else 12297 esdo->rel.count += reloc_count; 12298 } 12299 } 12300 12301 if (o->reloc_count > 0) 12302 o->flags |= SEC_RELOC; 12303 else 12304 { 12305 /* Explicitly clear the SEC_RELOC flag. The linker tends to 12306 set it (this is probably a bug) and if it is set 12307 assign_section_numbers will create a reloc section. */ 12308 o->flags &=~ SEC_RELOC; 12309 } 12310 12311 /* If the SEC_ALLOC flag is not set, force the section VMA to 12312 zero. This is done in elf_fake_sections as well, but forcing 12313 the VMA to 0 here will ensure that relocs against these 12314 sections are handled correctly. */ 12315 if ((o->flags & SEC_ALLOC) == 0 12316 && ! o->user_set_vma) 12317 o->vma = 0; 12318 } 12319 12320 if (! bfd_link_relocatable (info) && merged) 12321 elf_link_hash_traverse (htab, _bfd_elf_link_sec_merge_syms, abfd); 12322 12323 /* Figure out the file positions for everything but the symbol table 12324 and the relocs. We set symcount to force assign_section_numbers 12325 to create a symbol table. */ 12326 abfd->symcount = info->strip != strip_all || emit_relocs; 12327 BFD_ASSERT (! abfd->output_has_begun); 12328 if (! _bfd_elf_compute_section_file_positions (abfd, info)) 12329 goto error_return; 12330 12331 /* Set sizes, and assign file positions for reloc sections. */ 12332 for (o = abfd->sections; o != NULL; o = o->next) 12333 { 12334 struct bfd_elf_section_data *esdo = elf_section_data (o); 12335 if ((o->flags & SEC_RELOC) != 0) 12336 { 12337 if (esdo->rel.hdr 12338 && !(_bfd_elf_link_size_reloc_section (abfd, &esdo->rel))) 12339 goto error_return; 12340 12341 if (esdo->rela.hdr 12342 && !(_bfd_elf_link_size_reloc_section (abfd, &esdo->rela))) 12343 goto error_return; 12344 } 12345 12346 /* _bfd_elf_compute_section_file_positions makes temporary use 12347 of target_index. Reset it. */ 12348 o->target_index = 0; 12349 12350 /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them 12351 to count upwards while actually outputting the relocations. */ 12352 esdo->rel.count = 0; 12353 esdo->rela.count = 0; 12354 12355 if ((esdo->this_hdr.sh_offset == (file_ptr) -1) 12356 && !bfd_section_is_ctf (o)) 12357 { 12358 /* Cache the section contents so that they can be compressed 12359 later. Use bfd_malloc since it will be freed by 12360 bfd_compress_section_contents. */ 12361 unsigned char *contents = esdo->this_hdr.contents; 12362 if ((o->flags & SEC_ELF_COMPRESS) == 0 || contents != NULL) 12363 abort (); 12364 contents 12365 = (unsigned char *) bfd_malloc (esdo->this_hdr.sh_size); 12366 if (contents == NULL) 12367 goto error_return; 12368 esdo->this_hdr.contents = contents; 12369 } 12370 } 12371 12372 /* We have now assigned file positions for all the sections except .symtab, 12373 .strtab, and non-loaded reloc and compressed debugging sections. We start 12374 the .symtab section at the current file position, and write directly to it. 12375 We build the .strtab section in memory. */ 12376 abfd->symcount = 0; 12377 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 12378 /* sh_name is set in prep_headers. */ 12379 symtab_hdr->sh_type = SHT_SYMTAB; 12380 /* sh_flags, sh_addr and sh_size all start off zero. */ 12381 symtab_hdr->sh_entsize = bed->s->sizeof_sym; 12382 /* sh_link is set in assign_section_numbers. */ 12383 /* sh_info is set below. */ 12384 /* sh_offset is set just below. */ 12385 symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align; 12386 12387 if (max_sym_count < 20) 12388 max_sym_count = 20; 12389 htab->strtabsize = max_sym_count; 12390 amt = max_sym_count * sizeof (struct elf_sym_strtab); 12391 htab->strtab = (struct elf_sym_strtab *) bfd_malloc (amt); 12392 if (htab->strtab == NULL) 12393 goto error_return; 12394 /* The real buffer will be allocated in elf_link_swap_symbols_out. */ 12395 flinfo.symshndxbuf 12396 = (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF) 12397 ? (Elf_External_Sym_Shndx *) -1 : NULL); 12398 12399 if (info->strip != strip_all || emit_relocs) 12400 { 12401 bfd_boolean name_local_sections; 12402 const char *name; 12403 12404 file_ptr off = elf_next_file_pos (abfd); 12405 12406 _bfd_elf_assign_file_position_for_section (symtab_hdr, off, TRUE); 12407 12408 /* Note that at this point elf_next_file_pos (abfd) is 12409 incorrect. We do not yet know the size of the .symtab section. 12410 We correct next_file_pos below, after we do know the size. */ 12411 12412 /* Start writing out the symbol table. The first symbol is always a 12413 dummy symbol. */ 12414 elfsym.st_value = 0; 12415 elfsym.st_size = 0; 12416 elfsym.st_info = 0; 12417 elfsym.st_other = 0; 12418 elfsym.st_shndx = SHN_UNDEF; 12419 elfsym.st_target_internal = 0; 12420 if (elf_link_output_symstrtab (&flinfo, NULL, &elfsym, 12421 bfd_und_section_ptr, NULL) != 1) 12422 goto error_return; 12423 12424 /* Output a symbol for each section. We output these even if we are 12425 discarding local symbols, since they are used for relocs. These 12426 symbols usually have no names. We store the index of each one in 12427 the index field of the section, so that we can find it again when 12428 outputting relocs. */ 12429 12430 name_local_sections 12431 = (bed->elf_backend_name_local_section_symbols 12432 && bed->elf_backend_name_local_section_symbols (abfd)); 12433 12434 name = NULL; 12435 elfsym.st_size = 0; 12436 elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION); 12437 elfsym.st_other = 0; 12438 elfsym.st_value = 0; 12439 elfsym.st_target_internal = 0; 12440 for (i = 1; i < elf_numsections (abfd); i++) 12441 { 12442 o = bfd_section_from_elf_index (abfd, i); 12443 if (o != NULL) 12444 { 12445 o->target_index = bfd_get_symcount (abfd); 12446 elfsym.st_shndx = i; 12447 if (!bfd_link_relocatable (info)) 12448 elfsym.st_value = o->vma; 12449 if (name_local_sections) 12450 name = o->name; 12451 if (elf_link_output_symstrtab (&flinfo, name, &elfsym, o, 12452 NULL) != 1) 12453 goto error_return; 12454 } 12455 } 12456 } 12457 12458 /* On some targets like Irix 5 the symbol split between local and global 12459 ones recorded in the sh_info field needs to be done between section 12460 and all other symbols. */ 12461 if (bed->elf_backend_elfsym_local_is_section 12462 && bed->elf_backend_elfsym_local_is_section (abfd)) 12463 symtab_hdr->sh_info = bfd_get_symcount (abfd); 12464 12465 /* Allocate some memory to hold information read in from the input 12466 files. */ 12467 if (max_contents_size != 0) 12468 { 12469 flinfo.contents = (bfd_byte *) bfd_malloc (max_contents_size); 12470 if (flinfo.contents == NULL) 12471 goto error_return; 12472 } 12473 12474 if (max_external_reloc_size != 0) 12475 { 12476 flinfo.external_relocs = bfd_malloc (max_external_reloc_size); 12477 if (flinfo.external_relocs == NULL) 12478 goto error_return; 12479 } 12480 12481 if (max_internal_reloc_count != 0) 12482 { 12483 amt = max_internal_reloc_count * sizeof (Elf_Internal_Rela); 12484 flinfo.internal_relocs = (Elf_Internal_Rela *) bfd_malloc (amt); 12485 if (flinfo.internal_relocs == NULL) 12486 goto error_return; 12487 } 12488 12489 if (max_sym_count != 0) 12490 { 12491 amt = max_sym_count * bed->s->sizeof_sym; 12492 flinfo.external_syms = (bfd_byte *) bfd_malloc (amt); 12493 if (flinfo.external_syms == NULL) 12494 goto error_return; 12495 12496 amt = max_sym_count * sizeof (Elf_Internal_Sym); 12497 flinfo.internal_syms = (Elf_Internal_Sym *) bfd_malloc (amt); 12498 if (flinfo.internal_syms == NULL) 12499 goto error_return; 12500 12501 amt = max_sym_count * sizeof (long); 12502 flinfo.indices = (long int *) bfd_malloc (amt); 12503 if (flinfo.indices == NULL) 12504 goto error_return; 12505 12506 amt = max_sym_count * sizeof (asection *); 12507 flinfo.sections = (asection **) bfd_malloc (amt); 12508 if (flinfo.sections == NULL) 12509 goto error_return; 12510 } 12511 12512 if (max_sym_shndx_count != 0) 12513 { 12514 amt = max_sym_shndx_count * sizeof (Elf_External_Sym_Shndx); 12515 flinfo.locsym_shndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt); 12516 if (flinfo.locsym_shndx == NULL) 12517 goto error_return; 12518 } 12519 12520 if (htab->tls_sec) 12521 { 12522 bfd_vma base, end = 0; /* Both bytes. */ 12523 asection *sec; 12524 12525 for (sec = htab->tls_sec; 12526 sec && (sec->flags & SEC_THREAD_LOCAL); 12527 sec = sec->next) 12528 { 12529 bfd_size_type size = sec->size; 12530 unsigned int opb = bfd_octets_per_byte (abfd, sec); 12531 12532 if (size == 0 12533 && (sec->flags & SEC_HAS_CONTENTS) == 0) 12534 { 12535 struct bfd_link_order *ord = sec->map_tail.link_order; 12536 12537 if (ord != NULL) 12538 size = ord->offset * opb + ord->size; 12539 } 12540 end = sec->vma + size / opb; 12541 } 12542 base = htab->tls_sec->vma; 12543 /* Only align end of TLS section if static TLS doesn't have special 12544 alignment requirements. */ 12545 if (bed->static_tls_alignment == 1) 12546 end = align_power (end, htab->tls_sec->alignment_power); 12547 htab->tls_size = end - base; 12548 } 12549 12550 /* Reorder SHF_LINK_ORDER sections. */ 12551 for (o = abfd->sections; o != NULL; o = o->next) 12552 { 12553 if (!elf_fixup_link_order (abfd, o)) 12554 return FALSE; 12555 } 12556 12557 if (!_bfd_elf_fixup_eh_frame_hdr (info)) 12558 return FALSE; 12559 12560 /* Since ELF permits relocations to be against local symbols, we 12561 must have the local symbols available when we do the relocations. 12562 Since we would rather only read the local symbols once, and we 12563 would rather not keep them in memory, we handle all the 12564 relocations for a single input file at the same time. 12565 12566 Unfortunately, there is no way to know the total number of local 12567 symbols until we have seen all of them, and the local symbol 12568 indices precede the global symbol indices. This means that when 12569 we are generating relocatable output, and we see a reloc against 12570 a global symbol, we can not know the symbol index until we have 12571 finished examining all the local symbols to see which ones we are 12572 going to output. To deal with this, we keep the relocations in 12573 memory, and don't output them until the end of the link. This is 12574 an unfortunate waste of memory, but I don't see a good way around 12575 it. Fortunately, it only happens when performing a relocatable 12576 link, which is not the common case. FIXME: If keep_memory is set 12577 we could write the relocs out and then read them again; I don't 12578 know how bad the memory loss will be. */ 12579 12580 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next) 12581 sub->output_has_begun = FALSE; 12582 for (o = abfd->sections; o != NULL; o = o->next) 12583 { 12584 for (p = o->map_head.link_order; p != NULL; p = p->next) 12585 { 12586 if (p->type == bfd_indirect_link_order 12587 && (bfd_get_flavour ((sub = p->u.indirect.section->owner)) 12588 == bfd_target_elf_flavour) 12589 && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass) 12590 { 12591 if (! sub->output_has_begun) 12592 { 12593 if (! elf_link_input_bfd (&flinfo, sub)) 12594 goto error_return; 12595 sub->output_has_begun = TRUE; 12596 } 12597 } 12598 else if (p->type == bfd_section_reloc_link_order 12599 || p->type == bfd_symbol_reloc_link_order) 12600 { 12601 if (! elf_reloc_link_order (abfd, info, o, p)) 12602 goto error_return; 12603 } 12604 else 12605 { 12606 if (! _bfd_default_link_order (abfd, info, o, p)) 12607 { 12608 if (p->type == bfd_indirect_link_order 12609 && (bfd_get_flavour (sub) 12610 == bfd_target_elf_flavour) 12611 && (elf_elfheader (sub)->e_ident[EI_CLASS] 12612 != bed->s->elfclass)) 12613 { 12614 const char *iclass, *oclass; 12615 12616 switch (bed->s->elfclass) 12617 { 12618 case ELFCLASS64: oclass = "ELFCLASS64"; break; 12619 case ELFCLASS32: oclass = "ELFCLASS32"; break; 12620 case ELFCLASSNONE: oclass = "ELFCLASSNONE"; break; 12621 default: abort (); 12622 } 12623 12624 switch (elf_elfheader (sub)->e_ident[EI_CLASS]) 12625 { 12626 case ELFCLASS64: iclass = "ELFCLASS64"; break; 12627 case ELFCLASS32: iclass = "ELFCLASS32"; break; 12628 case ELFCLASSNONE: iclass = "ELFCLASSNONE"; break; 12629 default: abort (); 12630 } 12631 12632 bfd_set_error (bfd_error_wrong_format); 12633 _bfd_error_handler 12634 /* xgettext:c-format */ 12635 (_("%pB: file class %s incompatible with %s"), 12636 sub, iclass, oclass); 12637 } 12638 12639 goto error_return; 12640 } 12641 } 12642 } 12643 } 12644 12645 /* Free symbol buffer if needed. */ 12646 if (!info->reduce_memory_overheads) 12647 { 12648 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next) 12649 if (bfd_get_flavour (sub) == bfd_target_elf_flavour) 12650 { 12651 free (elf_tdata (sub)->symbuf); 12652 elf_tdata (sub)->symbuf = NULL; 12653 } 12654 } 12655 12656 ret = TRUE; 12657 12658 /* Output any global symbols that got converted to local in a 12659 version script or due to symbol visibility. We do this in a 12660 separate step since ELF requires all local symbols to appear 12661 prior to any global symbols. FIXME: We should only do this if 12662 some global symbols were, in fact, converted to become local. 12663 FIXME: Will this work correctly with the Irix 5 linker? */ 12664 eoinfo.failed = FALSE; 12665 eoinfo.flinfo = &flinfo; 12666 eoinfo.localsyms = TRUE; 12667 eoinfo.file_sym_done = FALSE; 12668 bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo); 12669 if (eoinfo.failed) 12670 { 12671 ret = FALSE; 12672 goto return_local_hash_table; 12673 } 12674 12675 /* If backend needs to output some local symbols not present in the hash 12676 table, do it now. */ 12677 if (bed->elf_backend_output_arch_local_syms 12678 && (info->strip != strip_all || emit_relocs)) 12679 { 12680 typedef int (*out_sym_func) 12681 (void *, const char *, Elf_Internal_Sym *, asection *, 12682 struct elf_link_hash_entry *); 12683 12684 if (! ((*bed->elf_backend_output_arch_local_syms) 12685 (abfd, info, &flinfo, 12686 (out_sym_func) elf_link_output_symstrtab))) 12687 { 12688 ret = FALSE; 12689 goto return_local_hash_table; 12690 } 12691 } 12692 12693 /* That wrote out all the local symbols. Finish up the symbol table 12694 with the global symbols. Even if we want to strip everything we 12695 can, we still need to deal with those global symbols that got 12696 converted to local in a version script. */ 12697 12698 /* The sh_info field records the index of the first non local symbol. */ 12699 if (!symtab_hdr->sh_info) 12700 symtab_hdr->sh_info = bfd_get_symcount (abfd); 12701 12702 if (dynamic 12703 && htab->dynsym != NULL 12704 && htab->dynsym->output_section != bfd_abs_section_ptr) 12705 { 12706 Elf_Internal_Sym sym; 12707 bfd_byte *dynsym = htab->dynsym->contents; 12708 12709 o = htab->dynsym->output_section; 12710 elf_section_data (o)->this_hdr.sh_info = htab->local_dynsymcount + 1; 12711 12712 /* Write out the section symbols for the output sections. */ 12713 if (bfd_link_pic (info) 12714 || htab->is_relocatable_executable) 12715 { 12716 asection *s; 12717 12718 sym.st_size = 0; 12719 sym.st_name = 0; 12720 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION); 12721 sym.st_other = 0; 12722 sym.st_target_internal = 0; 12723 12724 for (s = abfd->sections; s != NULL; s = s->next) 12725 { 12726 int indx; 12727 bfd_byte *dest; 12728 long dynindx; 12729 12730 dynindx = elf_section_data (s)->dynindx; 12731 if (dynindx <= 0) 12732 continue; 12733 indx = elf_section_data (s)->this_idx; 12734 BFD_ASSERT (indx > 0); 12735 sym.st_shndx = indx; 12736 if (! check_dynsym (abfd, &sym)) 12737 { 12738 ret = FALSE; 12739 goto return_local_hash_table; 12740 } 12741 sym.st_value = s->vma; 12742 dest = dynsym + dynindx * bed->s->sizeof_sym; 12743 bed->s->swap_symbol_out (abfd, &sym, dest, 0); 12744 } 12745 } 12746 12747 /* Write out the local dynsyms. */ 12748 if (htab->dynlocal) 12749 { 12750 struct elf_link_local_dynamic_entry *e; 12751 for (e = htab->dynlocal; e ; e = e->next) 12752 { 12753 asection *s; 12754 bfd_byte *dest; 12755 12756 /* Copy the internal symbol and turn off visibility. 12757 Note that we saved a word of storage and overwrote 12758 the original st_name with the dynstr_index. */ 12759 sym = e->isym; 12760 sym.st_other &= ~ELF_ST_VISIBILITY (-1); 12761 sym.st_shndx = SHN_UNDEF; 12762 12763 s = bfd_section_from_elf_index (e->input_bfd, 12764 e->isym.st_shndx); 12765 if (s != NULL 12766 && s->output_section != NULL 12767 && elf_section_data (s->output_section) != NULL) 12768 { 12769 sym.st_shndx = 12770 elf_section_data (s->output_section)->this_idx; 12771 if (! check_dynsym (abfd, &sym)) 12772 { 12773 ret = FALSE; 12774 goto return_local_hash_table; 12775 } 12776 sym.st_value = (s->output_section->vma 12777 + s->output_offset 12778 + e->isym.st_value); 12779 } 12780 12781 dest = dynsym + e->dynindx * bed->s->sizeof_sym; 12782 bed->s->swap_symbol_out (abfd, &sym, dest, 0); 12783 } 12784 } 12785 } 12786 12787 /* We get the global symbols from the hash table. */ 12788 eoinfo.failed = FALSE; 12789 eoinfo.localsyms = FALSE; 12790 eoinfo.flinfo = &flinfo; 12791 bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo); 12792 if (eoinfo.failed) 12793 { 12794 ret = FALSE; 12795 goto return_local_hash_table; 12796 } 12797 12798 /* If backend needs to output some symbols not present in the hash 12799 table, do it now. */ 12800 if (bed->elf_backend_output_arch_syms 12801 && (info->strip != strip_all || emit_relocs)) 12802 { 12803 typedef int (*out_sym_func) 12804 (void *, const char *, Elf_Internal_Sym *, asection *, 12805 struct elf_link_hash_entry *); 12806 12807 if (! ((*bed->elf_backend_output_arch_syms) 12808 (abfd, info, &flinfo, 12809 (out_sym_func) elf_link_output_symstrtab))) 12810 { 12811 ret = FALSE; 12812 goto return_local_hash_table; 12813 } 12814 } 12815 12816 /* Finalize the .strtab section. */ 12817 _bfd_elf_strtab_finalize (flinfo.symstrtab); 12818 12819 /* Swap out the .strtab section. */ 12820 if (!elf_link_swap_symbols_out (&flinfo)) 12821 { 12822 ret = FALSE; 12823 goto return_local_hash_table; 12824 } 12825 12826 /* Now we know the size of the symtab section. */ 12827 if (bfd_get_symcount (abfd) > 0) 12828 { 12829 /* Finish up and write out the symbol string table (.strtab) 12830 section. */ 12831 Elf_Internal_Shdr *symstrtab_hdr = NULL; 12832 file_ptr off = symtab_hdr->sh_offset + symtab_hdr->sh_size; 12833 12834 if (elf_symtab_shndx_list (abfd)) 12835 { 12836 symtab_shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr; 12837 12838 if (symtab_shndx_hdr != NULL && symtab_shndx_hdr->sh_name != 0) 12839 { 12840 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX; 12841 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx); 12842 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx); 12843 amt = bfd_get_symcount (abfd) * sizeof (Elf_External_Sym_Shndx); 12844 symtab_shndx_hdr->sh_size = amt; 12845 12846 off = _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr, 12847 off, TRUE); 12848 12849 if (bfd_seek (abfd, symtab_shndx_hdr->sh_offset, SEEK_SET) != 0 12850 || (bfd_bwrite (flinfo.symshndxbuf, amt, abfd) != amt)) 12851 { 12852 ret = FALSE; 12853 goto return_local_hash_table; 12854 } 12855 } 12856 } 12857 12858 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr; 12859 /* sh_name was set in prep_headers. */ 12860 symstrtab_hdr->sh_type = SHT_STRTAB; 12861 symstrtab_hdr->sh_flags = bed->elf_strtab_flags; 12862 symstrtab_hdr->sh_addr = 0; 12863 symstrtab_hdr->sh_size = _bfd_elf_strtab_size (flinfo.symstrtab); 12864 symstrtab_hdr->sh_entsize = 0; 12865 symstrtab_hdr->sh_link = 0; 12866 symstrtab_hdr->sh_info = 0; 12867 /* sh_offset is set just below. */ 12868 symstrtab_hdr->sh_addralign = 1; 12869 12870 off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr, 12871 off, TRUE); 12872 elf_next_file_pos (abfd) = off; 12873 12874 if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0 12875 || ! _bfd_elf_strtab_emit (abfd, flinfo.symstrtab)) 12876 { 12877 ret = FALSE; 12878 goto return_local_hash_table; 12879 } 12880 } 12881 12882 if (info->out_implib_bfd && !elf_output_implib (abfd, info)) 12883 { 12884 _bfd_error_handler (_("%pB: failed to generate import library"), 12885 info->out_implib_bfd); 12886 ret = FALSE; 12887 goto return_local_hash_table; 12888 } 12889 12890 /* Adjust the relocs to have the correct symbol indices. */ 12891 for (o = abfd->sections; o != NULL; o = o->next) 12892 { 12893 struct bfd_elf_section_data *esdo = elf_section_data (o); 12894 bfd_boolean sort; 12895 12896 if ((o->flags & SEC_RELOC) == 0) 12897 continue; 12898 12899 sort = bed->sort_relocs_p == NULL || (*bed->sort_relocs_p) (o); 12900 if (esdo->rel.hdr != NULL 12901 && !elf_link_adjust_relocs (abfd, o, &esdo->rel, sort, info)) 12902 { 12903 ret = FALSE; 12904 goto return_local_hash_table; 12905 } 12906 if (esdo->rela.hdr != NULL 12907 && !elf_link_adjust_relocs (abfd, o, &esdo->rela, sort, info)) 12908 { 12909 ret = FALSE; 12910 goto return_local_hash_table; 12911 } 12912 12913 /* Set the reloc_count field to 0 to prevent write_relocs from 12914 trying to swap the relocs out itself. */ 12915 o->reloc_count = 0; 12916 } 12917 12918 if (dynamic && info->combreloc && dynobj != NULL) 12919 relativecount = elf_link_sort_relocs (abfd, info, &reldyn); 12920 12921 /* If we are linking against a dynamic object, or generating a 12922 shared library, finish up the dynamic linking information. */ 12923 if (dynamic) 12924 { 12925 bfd_byte *dyncon, *dynconend; 12926 12927 /* Fix up .dynamic entries. */ 12928 o = bfd_get_linker_section (dynobj, ".dynamic"); 12929 BFD_ASSERT (o != NULL); 12930 12931 dyncon = o->contents; 12932 dynconend = o->contents + o->size; 12933 for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn) 12934 { 12935 Elf_Internal_Dyn dyn; 12936 const char *name; 12937 unsigned int type; 12938 bfd_size_type sh_size; 12939 bfd_vma sh_addr; 12940 12941 bed->s->swap_dyn_in (dynobj, dyncon, &dyn); 12942 12943 switch (dyn.d_tag) 12944 { 12945 default: 12946 continue; 12947 case DT_NULL: 12948 if (relativecount > 0 && dyncon + bed->s->sizeof_dyn < dynconend) 12949 { 12950 switch (elf_section_data (reldyn)->this_hdr.sh_type) 12951 { 12952 case SHT_REL: dyn.d_tag = DT_RELCOUNT; break; 12953 case SHT_RELA: dyn.d_tag = DT_RELACOUNT; break; 12954 default: continue; 12955 } 12956 dyn.d_un.d_val = relativecount; 12957 relativecount = 0; 12958 break; 12959 } 12960 continue; 12961 12962 case DT_INIT: 12963 name = info->init_function; 12964 goto get_sym; 12965 case DT_FINI: 12966 name = info->fini_function; 12967 get_sym: 12968 { 12969 struct elf_link_hash_entry *h; 12970 12971 h = elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE); 12972 if (h != NULL 12973 && (h->root.type == bfd_link_hash_defined 12974 || h->root.type == bfd_link_hash_defweak)) 12975 { 12976 dyn.d_un.d_ptr = h->root.u.def.value; 12977 o = h->root.u.def.section; 12978 if (o->output_section != NULL) 12979 dyn.d_un.d_ptr += (o->output_section->vma 12980 + o->output_offset); 12981 else 12982 { 12983 /* The symbol is imported from another shared 12984 library and does not apply to this one. */ 12985 dyn.d_un.d_ptr = 0; 12986 } 12987 break; 12988 } 12989 } 12990 continue; 12991 12992 case DT_PREINIT_ARRAYSZ: 12993 name = ".preinit_array"; 12994 goto get_out_size; 12995 case DT_INIT_ARRAYSZ: 12996 name = ".init_array"; 12997 goto get_out_size; 12998 case DT_FINI_ARRAYSZ: 12999 name = ".fini_array"; 13000 get_out_size: 13001 o = bfd_get_section_by_name (abfd, name); 13002 if (o == NULL) 13003 { 13004 _bfd_error_handler 13005 (_("could not find section %s"), name); 13006 goto error_return; 13007 } 13008 if (o->size == 0) 13009 _bfd_error_handler 13010 (_("warning: %s section has zero size"), name); 13011 dyn.d_un.d_val = o->size; 13012 break; 13013 13014 case DT_PREINIT_ARRAY: 13015 name = ".preinit_array"; 13016 goto get_out_vma; 13017 case DT_INIT_ARRAY: 13018 name = ".init_array"; 13019 goto get_out_vma; 13020 case DT_FINI_ARRAY: 13021 name = ".fini_array"; 13022 get_out_vma: 13023 o = bfd_get_section_by_name (abfd, name); 13024 goto do_vma; 13025 13026 case DT_HASH: 13027 name = ".hash"; 13028 goto get_vma; 13029 case DT_GNU_HASH: 13030 name = ".gnu.hash"; 13031 goto get_vma; 13032 case DT_STRTAB: 13033 name = ".dynstr"; 13034 goto get_vma; 13035 case DT_SYMTAB: 13036 name = ".dynsym"; 13037 goto get_vma; 13038 case DT_VERDEF: 13039 name = ".gnu.version_d"; 13040 goto get_vma; 13041 case DT_VERNEED: 13042 name = ".gnu.version_r"; 13043 goto get_vma; 13044 case DT_VERSYM: 13045 name = ".gnu.version"; 13046 get_vma: 13047 o = bfd_get_linker_section (dynobj, name); 13048 do_vma: 13049 if (o == NULL || bfd_is_abs_section (o->output_section)) 13050 { 13051 _bfd_error_handler 13052 (_("could not find section %s"), name); 13053 goto error_return; 13054 } 13055 if (elf_section_data (o->output_section)->this_hdr.sh_type == SHT_NOTE) 13056 { 13057 _bfd_error_handler 13058 (_("warning: section '%s' is being made into a note"), name); 13059 bfd_set_error (bfd_error_nonrepresentable_section); 13060 goto error_return; 13061 } 13062 dyn.d_un.d_ptr = o->output_section->vma + o->output_offset; 13063 break; 13064 13065 case DT_REL: 13066 case DT_RELA: 13067 case DT_RELSZ: 13068 case DT_RELASZ: 13069 if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ) 13070 type = SHT_REL; 13071 else 13072 type = SHT_RELA; 13073 sh_size = 0; 13074 sh_addr = 0; 13075 for (i = 1; i < elf_numsections (abfd); i++) 13076 { 13077 Elf_Internal_Shdr *hdr; 13078 13079 hdr = elf_elfsections (abfd)[i]; 13080 if (hdr->sh_type == type 13081 && (hdr->sh_flags & SHF_ALLOC) != 0) 13082 { 13083 sh_size += hdr->sh_size; 13084 if (sh_addr == 0 13085 || sh_addr > hdr->sh_addr) 13086 sh_addr = hdr->sh_addr; 13087 } 13088 } 13089 13090 if (bed->dtrel_excludes_plt && htab->srelplt != NULL) 13091 { 13092 unsigned int opb = bfd_octets_per_byte (abfd, o); 13093 13094 /* Don't count procedure linkage table relocs in the 13095 overall reloc count. */ 13096 sh_size -= htab->srelplt->size; 13097 if (sh_size == 0) 13098 /* If the size is zero, make the address zero too. 13099 This is to avoid a glibc bug. If the backend 13100 emits DT_RELA/DT_RELASZ even when DT_RELASZ is 13101 zero, then we'll put DT_RELA at the end of 13102 DT_JMPREL. glibc will interpret the end of 13103 DT_RELA matching the end of DT_JMPREL as the 13104 case where DT_RELA includes DT_JMPREL, and for 13105 LD_BIND_NOW will decide that processing DT_RELA 13106 will process the PLT relocs too. Net result: 13107 No PLT relocs applied. */ 13108 sh_addr = 0; 13109 13110 /* If .rela.plt is the first .rela section, exclude 13111 it from DT_RELA. */ 13112 else if (sh_addr == (htab->srelplt->output_section->vma 13113 + htab->srelplt->output_offset) * opb) 13114 sh_addr += htab->srelplt->size; 13115 } 13116 13117 if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ) 13118 dyn.d_un.d_val = sh_size; 13119 else 13120 dyn.d_un.d_ptr = sh_addr; 13121 break; 13122 } 13123 bed->s->swap_dyn_out (dynobj, &dyn, dyncon); 13124 } 13125 } 13126 13127 /* If we have created any dynamic sections, then output them. */ 13128 if (dynobj != NULL) 13129 { 13130 if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info)) 13131 goto error_return; 13132 13133 /* Check for DT_TEXTREL (late, in case the backend removes it). */ 13134 if (bfd_link_textrel_check (info) 13135 && (o = bfd_get_linker_section (dynobj, ".dynamic")) != NULL) 13136 { 13137 bfd_byte *dyncon, *dynconend; 13138 13139 dyncon = o->contents; 13140 dynconend = o->contents + o->size; 13141 for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn) 13142 { 13143 Elf_Internal_Dyn dyn; 13144 13145 bed->s->swap_dyn_in (dynobj, dyncon, &dyn); 13146 13147 if (dyn.d_tag == DT_TEXTREL) 13148 { 13149 if (info->textrel_check == textrel_check_error) 13150 info->callbacks->einfo 13151 (_("%P%X: read-only segment has dynamic relocations\n")); 13152 else if (bfd_link_dll (info)) 13153 info->callbacks->einfo 13154 (_("%P: warning: creating DT_TEXTREL in a shared object\n")); 13155 else 13156 info->callbacks->einfo 13157 (_("%P: warning: creating DT_TEXTREL in a PIE\n")); 13158 break; 13159 } 13160 } 13161 } 13162 13163 for (o = dynobj->sections; o != NULL; o = o->next) 13164 { 13165 if ((o->flags & SEC_HAS_CONTENTS) == 0 13166 || o->size == 0 13167 || o->output_section == bfd_abs_section_ptr) 13168 continue; 13169 if ((o->flags & SEC_LINKER_CREATED) == 0) 13170 { 13171 /* At this point, we are only interested in sections 13172 created by _bfd_elf_link_create_dynamic_sections. */ 13173 continue; 13174 } 13175 if (htab->stab_info.stabstr == o) 13176 continue; 13177 if (htab->eh_info.hdr_sec == o) 13178 continue; 13179 if (strcmp (o->name, ".dynstr") != 0) 13180 { 13181 bfd_size_type octets = ((file_ptr) o->output_offset 13182 * bfd_octets_per_byte (abfd, o)); 13183 if (!bfd_set_section_contents (abfd, o->output_section, 13184 o->contents, octets, o->size)) 13185 goto error_return; 13186 } 13187 else 13188 { 13189 /* The contents of the .dynstr section are actually in a 13190 stringtab. */ 13191 file_ptr off; 13192 13193 off = elf_section_data (o->output_section)->this_hdr.sh_offset; 13194 if (bfd_seek (abfd, off, SEEK_SET) != 0 13195 || !_bfd_elf_strtab_emit (abfd, htab->dynstr)) 13196 goto error_return; 13197 } 13198 } 13199 } 13200 13201 if (!info->resolve_section_groups) 13202 { 13203 bfd_boolean failed = FALSE; 13204 13205 BFD_ASSERT (bfd_link_relocatable (info)); 13206 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed); 13207 if (failed) 13208 goto error_return; 13209 } 13210 13211 /* If we have optimized stabs strings, output them. */ 13212 if (htab->stab_info.stabstr != NULL) 13213 { 13214 if (!_bfd_write_stab_strings (abfd, &htab->stab_info)) 13215 goto error_return; 13216 } 13217 13218 if (! _bfd_elf_write_section_eh_frame_hdr (abfd, info)) 13219 goto error_return; 13220 13221 if (info->callbacks->emit_ctf) 13222 info->callbacks->emit_ctf (); 13223 13224 elf_final_link_free (abfd, &flinfo); 13225 13226 if (attr_section) 13227 { 13228 bfd_byte *contents = (bfd_byte *) bfd_malloc (attr_size); 13229 if (contents == NULL) 13230 { 13231 /* Bail out and fail. */ 13232 ret = FALSE; 13233 goto return_local_hash_table; 13234 } 13235 bfd_elf_set_obj_attr_contents (abfd, contents, attr_size); 13236 bfd_set_section_contents (abfd, attr_section, contents, 0, attr_size); 13237 free (contents); 13238 } 13239 13240 return_local_hash_table: 13241 if (info->unique_symbol) 13242 bfd_hash_table_free (&flinfo.local_hash_table); 13243 return ret; 13244 13245 error_return: 13246 elf_final_link_free (abfd, &flinfo); 13247 ret = FALSE; 13248 goto return_local_hash_table; 13249} 13250 13251/* Initialize COOKIE for input bfd ABFD. */ 13252 13253static bfd_boolean 13254init_reloc_cookie (struct elf_reloc_cookie *cookie, 13255 struct bfd_link_info *info, bfd *abfd) 13256{ 13257 Elf_Internal_Shdr *symtab_hdr; 13258 const struct elf_backend_data *bed; 13259 13260 bed = get_elf_backend_data (abfd); 13261 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 13262 13263 cookie->abfd = abfd; 13264 cookie->sym_hashes = elf_sym_hashes (abfd); 13265 cookie->bad_symtab = elf_bad_symtab (abfd); 13266 if (cookie->bad_symtab) 13267 { 13268 cookie->locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym; 13269 cookie->extsymoff = 0; 13270 } 13271 else 13272 { 13273 cookie->locsymcount = symtab_hdr->sh_info; 13274 cookie->extsymoff = symtab_hdr->sh_info; 13275 } 13276 13277 if (bed->s->arch_size == 32) 13278 cookie->r_sym_shift = 8; 13279 else 13280 cookie->r_sym_shift = 32; 13281 13282 cookie->locsyms = (Elf_Internal_Sym *) symtab_hdr->contents; 13283 if (cookie->locsyms == NULL && cookie->locsymcount != 0) 13284 { 13285 cookie->locsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, 13286 cookie->locsymcount, 0, 13287 NULL, NULL, NULL); 13288 if (cookie->locsyms == NULL) 13289 { 13290 info->callbacks->einfo (_("%P%X: can not read symbols: %E\n")); 13291 return FALSE; 13292 } 13293 if (info->keep_memory) 13294 symtab_hdr->contents = (bfd_byte *) cookie->locsyms; 13295 } 13296 return TRUE; 13297} 13298 13299/* Free the memory allocated by init_reloc_cookie, if appropriate. */ 13300 13301static void 13302fini_reloc_cookie (struct elf_reloc_cookie *cookie, bfd *abfd) 13303{ 13304 Elf_Internal_Shdr *symtab_hdr; 13305 13306 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 13307 if (symtab_hdr->contents != (unsigned char *) cookie->locsyms) 13308 free (cookie->locsyms); 13309} 13310 13311/* Initialize the relocation information in COOKIE for input section SEC 13312 of input bfd ABFD. */ 13313 13314static bfd_boolean 13315init_reloc_cookie_rels (struct elf_reloc_cookie *cookie, 13316 struct bfd_link_info *info, bfd *abfd, 13317 asection *sec) 13318{ 13319 if (sec->reloc_count == 0) 13320 { 13321 cookie->rels = NULL; 13322 cookie->relend = NULL; 13323 } 13324 else 13325 { 13326 cookie->rels = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, 13327 info->keep_memory); 13328 if (cookie->rels == NULL) 13329 return FALSE; 13330 cookie->rel = cookie->rels; 13331 cookie->relend = cookie->rels + sec->reloc_count; 13332 } 13333 cookie->rel = cookie->rels; 13334 return TRUE; 13335} 13336 13337/* Free the memory allocated by init_reloc_cookie_rels, 13338 if appropriate. */ 13339 13340static void 13341fini_reloc_cookie_rels (struct elf_reloc_cookie *cookie, 13342 asection *sec) 13343{ 13344 if (elf_section_data (sec)->relocs != cookie->rels) 13345 free (cookie->rels); 13346} 13347 13348/* Initialize the whole of COOKIE for input section SEC. */ 13349 13350static bfd_boolean 13351init_reloc_cookie_for_section (struct elf_reloc_cookie *cookie, 13352 struct bfd_link_info *info, 13353 asection *sec) 13354{ 13355 if (!init_reloc_cookie (cookie, info, sec->owner)) 13356 goto error1; 13357 if (!init_reloc_cookie_rels (cookie, info, sec->owner, sec)) 13358 goto error2; 13359 return TRUE; 13360 13361 error2: 13362 fini_reloc_cookie (cookie, sec->owner); 13363 error1: 13364 return FALSE; 13365} 13366 13367/* Free the memory allocated by init_reloc_cookie_for_section, 13368 if appropriate. */ 13369 13370static void 13371fini_reloc_cookie_for_section (struct elf_reloc_cookie *cookie, 13372 asection *sec) 13373{ 13374 fini_reloc_cookie_rels (cookie, sec); 13375 fini_reloc_cookie (cookie, sec->owner); 13376} 13377 13378/* Garbage collect unused sections. */ 13379 13380/* Default gc_mark_hook. */ 13381 13382asection * 13383_bfd_elf_gc_mark_hook (asection *sec, 13384 struct bfd_link_info *info ATTRIBUTE_UNUSED, 13385 Elf_Internal_Rela *rel ATTRIBUTE_UNUSED, 13386 struct elf_link_hash_entry *h, 13387 Elf_Internal_Sym *sym) 13388{ 13389 if (h != NULL) 13390 { 13391 switch (h->root.type) 13392 { 13393 case bfd_link_hash_defined: 13394 case bfd_link_hash_defweak: 13395 return h->root.u.def.section; 13396 13397 case bfd_link_hash_common: 13398 return h->root.u.c.p->section; 13399 13400 default: 13401 break; 13402 } 13403 } 13404 else 13405 return bfd_section_from_elf_index (sec->owner, sym->st_shndx); 13406 13407 return NULL; 13408} 13409 13410/* Return the debug definition section. */ 13411 13412static asection * 13413elf_gc_mark_debug_section (asection *sec ATTRIBUTE_UNUSED, 13414 struct bfd_link_info *info ATTRIBUTE_UNUSED, 13415 Elf_Internal_Rela *rel ATTRIBUTE_UNUSED, 13416 struct elf_link_hash_entry *h, 13417 Elf_Internal_Sym *sym) 13418{ 13419 if (h != NULL) 13420 { 13421 /* Return the global debug definition section. */ 13422 if ((h->root.type == bfd_link_hash_defined 13423 || h->root.type == bfd_link_hash_defweak) 13424 && (h->root.u.def.section->flags & SEC_DEBUGGING) != 0) 13425 return h->root.u.def.section; 13426 } 13427 else 13428 { 13429 /* Return the local debug definition section. */ 13430 asection *isec = bfd_section_from_elf_index (sec->owner, 13431 sym->st_shndx); 13432 if ((isec->flags & SEC_DEBUGGING) != 0) 13433 return isec; 13434 } 13435 13436 return NULL; 13437} 13438 13439/* COOKIE->rel describes a relocation against section SEC, which is 13440 a section we've decided to keep. Return the section that contains 13441 the relocation symbol, or NULL if no section contains it. */ 13442 13443asection * 13444_bfd_elf_gc_mark_rsec (struct bfd_link_info *info, asection *sec, 13445 elf_gc_mark_hook_fn gc_mark_hook, 13446 struct elf_reloc_cookie *cookie, 13447 bfd_boolean *start_stop) 13448{ 13449 unsigned long r_symndx; 13450 struct elf_link_hash_entry *h, *hw; 13451 13452 r_symndx = cookie->rel->r_info >> cookie->r_sym_shift; 13453 if (r_symndx == STN_UNDEF) 13454 return NULL; 13455 13456 if (r_symndx >= cookie->locsymcount 13457 || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL) 13458 { 13459 h = cookie->sym_hashes[r_symndx - cookie->extsymoff]; 13460 if (h == NULL) 13461 { 13462 info->callbacks->einfo (_("%F%P: corrupt input: %pB\n"), 13463 sec->owner); 13464 return NULL; 13465 } 13466 while (h->root.type == bfd_link_hash_indirect 13467 || h->root.type == bfd_link_hash_warning) 13468 h = (struct elf_link_hash_entry *) h->root.u.i.link; 13469 h->mark = 1; 13470 /* Keep all aliases of the symbol too. If an object symbol 13471 needs to be copied into .dynbss then all of its aliases 13472 should be present as dynamic symbols, not just the one used 13473 on the copy relocation. */ 13474 hw = h; 13475 while (hw->is_weakalias) 13476 { 13477 hw = hw->u.alias; 13478 hw->mark = 1; 13479 } 13480 13481 if (start_stop != NULL) 13482 { 13483 /* To work around a glibc bug, mark XXX input sections 13484 when there is a reference to __start_XXX or __stop_XXX 13485 symbols. */ 13486 if (h->start_stop) 13487 { 13488 asection *s = h->u2.start_stop_section; 13489 *start_stop = !s->gc_mark; 13490 return s; 13491 } 13492 } 13493 13494 return (*gc_mark_hook) (sec, info, cookie->rel, h, NULL); 13495 } 13496 13497 return (*gc_mark_hook) (sec, info, cookie->rel, NULL, 13498 &cookie->locsyms[r_symndx]); 13499} 13500 13501/* COOKIE->rel describes a relocation against section SEC, which is 13502 a section we've decided to keep. Mark the section that contains 13503 the relocation symbol. */ 13504 13505bfd_boolean 13506_bfd_elf_gc_mark_reloc (struct bfd_link_info *info, 13507 asection *sec, 13508 elf_gc_mark_hook_fn gc_mark_hook, 13509 struct elf_reloc_cookie *cookie) 13510{ 13511 asection *rsec; 13512 bfd_boolean start_stop = FALSE; 13513 13514 rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie, &start_stop); 13515 while (rsec != NULL) 13516 { 13517 if (!rsec->gc_mark) 13518 { 13519 if (bfd_get_flavour (rsec->owner) != bfd_target_elf_flavour 13520 || (rsec->owner->flags & DYNAMIC) != 0) 13521 rsec->gc_mark = 1; 13522 else if (!_bfd_elf_gc_mark (info, rsec, gc_mark_hook)) 13523 return FALSE; 13524 } 13525 if (!start_stop) 13526 break; 13527 rsec = bfd_get_next_section_by_name (rsec->owner, rsec); 13528 } 13529 return TRUE; 13530} 13531 13532/* The mark phase of garbage collection. For a given section, mark 13533 it and any sections in this section's group, and all the sections 13534 which define symbols to which it refers. */ 13535 13536bfd_boolean 13537_bfd_elf_gc_mark (struct bfd_link_info *info, 13538 asection *sec, 13539 elf_gc_mark_hook_fn gc_mark_hook) 13540{ 13541 bfd_boolean ret; 13542 asection *group_sec, *eh_frame; 13543 13544 sec->gc_mark = 1; 13545 13546 /* Mark all the sections in the group. */ 13547 group_sec = elf_section_data (sec)->next_in_group; 13548 if (group_sec && !group_sec->gc_mark) 13549 if (!_bfd_elf_gc_mark (info, group_sec, gc_mark_hook)) 13550 return FALSE; 13551 13552 /* Look through the section relocs. */ 13553 ret = TRUE; 13554 eh_frame = elf_eh_frame_section (sec->owner); 13555 if ((sec->flags & SEC_RELOC) != 0 13556 && sec->reloc_count > 0 13557 && sec != eh_frame) 13558 { 13559 struct elf_reloc_cookie cookie; 13560 13561 if (!init_reloc_cookie_for_section (&cookie, info, sec)) 13562 ret = FALSE; 13563 else 13564 { 13565 for (; cookie.rel < cookie.relend; cookie.rel++) 13566 if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, &cookie)) 13567 { 13568 ret = FALSE; 13569 break; 13570 } 13571 fini_reloc_cookie_for_section (&cookie, sec); 13572 } 13573 } 13574 13575 if (ret && eh_frame && elf_fde_list (sec)) 13576 { 13577 struct elf_reloc_cookie cookie; 13578 13579 if (!init_reloc_cookie_for_section (&cookie, info, eh_frame)) 13580 ret = FALSE; 13581 else 13582 { 13583 if (!_bfd_elf_gc_mark_fdes (info, sec, eh_frame, 13584 gc_mark_hook, &cookie)) 13585 ret = FALSE; 13586 fini_reloc_cookie_for_section (&cookie, eh_frame); 13587 } 13588 } 13589 13590 eh_frame = elf_section_eh_frame_entry (sec); 13591 if (ret && eh_frame && !eh_frame->gc_mark) 13592 if (!_bfd_elf_gc_mark (info, eh_frame, gc_mark_hook)) 13593 ret = FALSE; 13594 13595 return ret; 13596} 13597 13598/* Scan and mark sections in a special or debug section group. */ 13599 13600static void 13601_bfd_elf_gc_mark_debug_special_section_group (asection *grp) 13602{ 13603 /* Point to first section of section group. */ 13604 asection *ssec; 13605 /* Used to iterate the section group. */ 13606 asection *msec; 13607 13608 bfd_boolean is_special_grp = TRUE; 13609 bfd_boolean is_debug_grp = TRUE; 13610 13611 /* First scan to see if group contains any section other than debug 13612 and special section. */ 13613 ssec = msec = elf_next_in_group (grp); 13614 do 13615 { 13616 if ((msec->flags & SEC_DEBUGGING) == 0) 13617 is_debug_grp = FALSE; 13618 13619 if ((msec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) != 0) 13620 is_special_grp = FALSE; 13621 13622 msec = elf_next_in_group (msec); 13623 } 13624 while (msec != ssec); 13625 13626 /* If this is a pure debug section group or pure special section group, 13627 keep all sections in this group. */ 13628 if (is_debug_grp || is_special_grp) 13629 { 13630 do 13631 { 13632 msec->gc_mark = 1; 13633 msec = elf_next_in_group (msec); 13634 } 13635 while (msec != ssec); 13636 } 13637} 13638 13639/* Keep debug and special sections. */ 13640 13641bfd_boolean 13642_bfd_elf_gc_mark_extra_sections (struct bfd_link_info *info, 13643 elf_gc_mark_hook_fn mark_hook) 13644{ 13645 bfd *ibfd; 13646 13647 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 13648 { 13649 asection *isec; 13650 bfd_boolean some_kept; 13651 bfd_boolean debug_frag_seen; 13652 bfd_boolean has_kept_debug_info; 13653 13654 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour) 13655 continue; 13656 isec = ibfd->sections; 13657 if (isec == NULL || isec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS) 13658 continue; 13659 13660 /* Ensure all linker created sections are kept, 13661 see if any other section is already marked, 13662 and note if we have any fragmented debug sections. */ 13663 debug_frag_seen = some_kept = has_kept_debug_info = FALSE; 13664 for (isec = ibfd->sections; isec != NULL; isec = isec->next) 13665 { 13666 if ((isec->flags & SEC_LINKER_CREATED) != 0) 13667 isec->gc_mark = 1; 13668 else if (isec->gc_mark 13669 && (isec->flags & SEC_ALLOC) != 0 13670 && elf_section_type (isec) != SHT_NOTE) 13671 some_kept = TRUE; 13672 else 13673 { 13674 /* Since all sections, except for backend specific ones, 13675 have been garbage collected, call mark_hook on this 13676 section if any of its linked-to sections is marked. */ 13677 asection *linked_to_sec = elf_linked_to_section (isec); 13678 for (; linked_to_sec != NULL; 13679 linked_to_sec = elf_linked_to_section (linked_to_sec)) 13680 if (linked_to_sec->gc_mark) 13681 { 13682 if (!_bfd_elf_gc_mark (info, isec, mark_hook)) 13683 return FALSE; 13684 break; 13685 } 13686 } 13687 13688 if (!debug_frag_seen 13689 && (isec->flags & SEC_DEBUGGING) 13690 && CONST_STRNEQ (isec->name, ".debug_line.")) 13691 debug_frag_seen = TRUE; 13692 else if (strcmp (bfd_section_name (isec), 13693 "__patchable_function_entries") == 0 13694 && elf_linked_to_section (isec) == NULL) 13695 info->callbacks->einfo (_("%F%P: %pB(%pA): error: " 13696 "need linked-to section " 13697 "for --gc-sections\n"), 13698 isec->owner, isec); 13699 } 13700 13701 /* If no non-note alloc section in this file will be kept, then 13702 we can toss out the debug and special sections. */ 13703 if (!some_kept) 13704 continue; 13705 13706 /* Keep debug and special sections like .comment when they are 13707 not part of a group. Also keep section groups that contain 13708 just debug sections or special sections. NB: Sections with 13709 linked-to section has been handled above. */ 13710 for (isec = ibfd->sections; isec != NULL; isec = isec->next) 13711 { 13712 if ((isec->flags & SEC_GROUP) != 0) 13713 _bfd_elf_gc_mark_debug_special_section_group (isec); 13714 else if (((isec->flags & SEC_DEBUGGING) != 0 13715 || (isec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0) 13716 && elf_next_in_group (isec) == NULL 13717 && elf_linked_to_section (isec) == NULL) 13718 isec->gc_mark = 1; 13719 if (isec->gc_mark && (isec->flags & SEC_DEBUGGING) != 0) 13720 has_kept_debug_info = TRUE; 13721 } 13722 13723 /* Look for CODE sections which are going to be discarded, 13724 and find and discard any fragmented debug sections which 13725 are associated with that code section. */ 13726 if (debug_frag_seen) 13727 for (isec = ibfd->sections; isec != NULL; isec = isec->next) 13728 if ((isec->flags & SEC_CODE) != 0 13729 && isec->gc_mark == 0) 13730 { 13731 unsigned int ilen; 13732 asection *dsec; 13733 13734 ilen = strlen (isec->name); 13735 13736 /* Association is determined by the name of the debug 13737 section containing the name of the code section as 13738 a suffix. For example .debug_line.text.foo is a 13739 debug section associated with .text.foo. */ 13740 for (dsec = ibfd->sections; dsec != NULL; dsec = dsec->next) 13741 { 13742 unsigned int dlen; 13743 13744 if (dsec->gc_mark == 0 13745 || (dsec->flags & SEC_DEBUGGING) == 0) 13746 continue; 13747 13748 dlen = strlen (dsec->name); 13749 13750 if (dlen > ilen 13751 && strncmp (dsec->name + (dlen - ilen), 13752 isec->name, ilen) == 0) 13753 dsec->gc_mark = 0; 13754 } 13755 } 13756 13757 /* Mark debug sections referenced by kept debug sections. */ 13758 if (has_kept_debug_info) 13759 for (isec = ibfd->sections; isec != NULL; isec = isec->next) 13760 if (isec->gc_mark 13761 && (isec->flags & SEC_DEBUGGING) != 0) 13762 if (!_bfd_elf_gc_mark (info, isec, 13763 elf_gc_mark_debug_section)) 13764 return FALSE; 13765 } 13766 return TRUE; 13767} 13768 13769static bfd_boolean 13770elf_gc_sweep (bfd *abfd, struct bfd_link_info *info) 13771{ 13772 bfd *sub; 13773 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 13774 13775 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next) 13776 { 13777 asection *o; 13778 13779 if (bfd_get_flavour (sub) != bfd_target_elf_flavour 13780 || elf_object_id (sub) != elf_hash_table_id (elf_hash_table (info)) 13781 || !(*bed->relocs_compatible) (sub->xvec, abfd->xvec)) 13782 continue; 13783 o = sub->sections; 13784 if (o == NULL || o->sec_info_type == SEC_INFO_TYPE_JUST_SYMS) 13785 continue; 13786 13787 for (o = sub->sections; o != NULL; o = o->next) 13788 { 13789 /* When any section in a section group is kept, we keep all 13790 sections in the section group. If the first member of 13791 the section group is excluded, we will also exclude the 13792 group section. */ 13793 if (o->flags & SEC_GROUP) 13794 { 13795 asection *first = elf_next_in_group (o); 13796 o->gc_mark = first->gc_mark; 13797 } 13798 13799 if (o->gc_mark) 13800 continue; 13801 13802 /* Skip sweeping sections already excluded. */ 13803 if (o->flags & SEC_EXCLUDE) 13804 continue; 13805 13806 /* Since this is early in the link process, it is simple 13807 to remove a section from the output. */ 13808 o->flags |= SEC_EXCLUDE; 13809 13810 if (info->print_gc_sections && o->size != 0) 13811 /* xgettext:c-format */ 13812 _bfd_error_handler (_("removing unused section '%pA' in file '%pB'"), 13813 o, sub); 13814 } 13815 } 13816 13817 return TRUE; 13818} 13819 13820/* Propagate collected vtable information. This is called through 13821 elf_link_hash_traverse. */ 13822 13823static bfd_boolean 13824elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry *h, void *okp) 13825{ 13826 /* Those that are not vtables. */ 13827 if (h->start_stop 13828 || h->u2.vtable == NULL 13829 || h->u2.vtable->parent == NULL) 13830 return TRUE; 13831 13832 /* Those vtables that do not have parents, we cannot merge. */ 13833 if (h->u2.vtable->parent == (struct elf_link_hash_entry *) -1) 13834 return TRUE; 13835 13836 /* If we've already been done, exit. */ 13837 if (h->u2.vtable->used && h->u2.vtable->used[-1]) 13838 return TRUE; 13839 13840 /* Make sure the parent's table is up to date. */ 13841 elf_gc_propagate_vtable_entries_used (h->u2.vtable->parent, okp); 13842 13843 if (h->u2.vtable->used == NULL) 13844 { 13845 /* None of this table's entries were referenced. Re-use the 13846 parent's table. */ 13847 h->u2.vtable->used = h->u2.vtable->parent->u2.vtable->used; 13848 h->u2.vtable->size = h->u2.vtable->parent->u2.vtable->size; 13849 } 13850 else 13851 { 13852 size_t n; 13853 bfd_boolean *cu, *pu; 13854 13855 /* Or the parent's entries into ours. */ 13856 cu = h->u2.vtable->used; 13857 cu[-1] = TRUE; 13858 pu = h->u2.vtable->parent->u2.vtable->used; 13859 if (pu != NULL) 13860 { 13861 const struct elf_backend_data *bed; 13862 unsigned int log_file_align; 13863 13864 bed = get_elf_backend_data (h->root.u.def.section->owner); 13865 log_file_align = bed->s->log_file_align; 13866 n = h->u2.vtable->parent->u2.vtable->size >> log_file_align; 13867 while (n--) 13868 { 13869 if (*pu) 13870 *cu = TRUE; 13871 pu++; 13872 cu++; 13873 } 13874 } 13875 } 13876 13877 return TRUE; 13878} 13879 13880static bfd_boolean 13881elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry *h, void *okp) 13882{ 13883 asection *sec; 13884 bfd_vma hstart, hend; 13885 Elf_Internal_Rela *relstart, *relend, *rel; 13886 const struct elf_backend_data *bed; 13887 unsigned int log_file_align; 13888 13889 /* Take care of both those symbols that do not describe vtables as 13890 well as those that are not loaded. */ 13891 if (h->start_stop 13892 || h->u2.vtable == NULL 13893 || h->u2.vtable->parent == NULL) 13894 return TRUE; 13895 13896 BFD_ASSERT (h->root.type == bfd_link_hash_defined 13897 || h->root.type == bfd_link_hash_defweak); 13898 13899 sec = h->root.u.def.section; 13900 hstart = h->root.u.def.value; 13901 hend = hstart + h->size; 13902 13903 relstart = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL, TRUE); 13904 if (!relstart) 13905 return *(bfd_boolean *) okp = FALSE; 13906 bed = get_elf_backend_data (sec->owner); 13907 log_file_align = bed->s->log_file_align; 13908 13909 relend = relstart + sec->reloc_count; 13910 13911 for (rel = relstart; rel < relend; ++rel) 13912 if (rel->r_offset >= hstart && rel->r_offset < hend) 13913 { 13914 /* If the entry is in use, do nothing. */ 13915 if (h->u2.vtable->used 13916 && (rel->r_offset - hstart) < h->u2.vtable->size) 13917 { 13918 bfd_vma entry = (rel->r_offset - hstart) >> log_file_align; 13919 if (h->u2.vtable->used[entry]) 13920 continue; 13921 } 13922 /* Otherwise, kill it. */ 13923 rel->r_offset = rel->r_info = rel->r_addend = 0; 13924 } 13925 13926 return TRUE; 13927} 13928 13929/* Mark sections containing dynamically referenced symbols. When 13930 building shared libraries, we must assume that any visible symbol is 13931 referenced. */ 13932 13933bfd_boolean 13934bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry *h, void *inf) 13935{ 13936 struct bfd_link_info *info = (struct bfd_link_info *) inf; 13937 struct bfd_elf_dynamic_list *d = info->dynamic_list; 13938 13939 if ((h->root.type == bfd_link_hash_defined 13940 || h->root.type == bfd_link_hash_defweak) 13941 && ((h->ref_dynamic && !h->forced_local) 13942 || ((h->def_regular || ELF_COMMON_DEF_P (h)) 13943 && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL 13944 && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN 13945 && (!bfd_link_executable (info) 13946 || info->gc_keep_exported 13947 || info->export_dynamic 13948 || (h->dynamic 13949 && d != NULL 13950 && (*d->match) (&d->head, NULL, h->root.root.string))) 13951 && (h->versioned >= versioned 13952 || !bfd_hide_sym_by_version (info->version_info, 13953 h->root.root.string))))) 13954 h->root.u.def.section->flags |= SEC_KEEP; 13955 13956 return TRUE; 13957} 13958 13959/* Keep all sections containing symbols undefined on the command-line, 13960 and the section containing the entry symbol. */ 13961 13962void 13963_bfd_elf_gc_keep (struct bfd_link_info *info) 13964{ 13965 struct bfd_sym_chain *sym; 13966 13967 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next) 13968 { 13969 struct elf_link_hash_entry *h; 13970 13971 h = elf_link_hash_lookup (elf_hash_table (info), sym->name, 13972 FALSE, FALSE, FALSE); 13973 13974 if (h != NULL 13975 && (h->root.type == bfd_link_hash_defined 13976 || h->root.type == bfd_link_hash_defweak) 13977 && !bfd_is_const_section (h->root.u.def.section)) 13978 h->root.u.def.section->flags |= SEC_KEEP; 13979 } 13980} 13981 13982bfd_boolean 13983bfd_elf_parse_eh_frame_entries (bfd *abfd ATTRIBUTE_UNUSED, 13984 struct bfd_link_info *info) 13985{ 13986 bfd *ibfd = info->input_bfds; 13987 13988 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 13989 { 13990 asection *sec; 13991 struct elf_reloc_cookie cookie; 13992 13993 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour) 13994 continue; 13995 sec = ibfd->sections; 13996 if (sec == NULL || sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS) 13997 continue; 13998 13999 if (!init_reloc_cookie (&cookie, info, ibfd)) 14000 return FALSE; 14001 14002 for (sec = ibfd->sections; sec; sec = sec->next) 14003 { 14004 if (CONST_STRNEQ (bfd_section_name (sec), ".eh_frame_entry") 14005 && init_reloc_cookie_rels (&cookie, info, ibfd, sec)) 14006 { 14007 _bfd_elf_parse_eh_frame_entry (info, sec, &cookie); 14008 fini_reloc_cookie_rels (&cookie, sec); 14009 } 14010 } 14011 } 14012 return TRUE; 14013} 14014 14015/* Do mark and sweep of unused sections. */ 14016 14017bfd_boolean 14018bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info) 14019{ 14020 bfd_boolean ok = TRUE; 14021 bfd *sub; 14022 elf_gc_mark_hook_fn gc_mark_hook; 14023 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 14024 struct elf_link_hash_table *htab; 14025 14026 if (!bed->can_gc_sections 14027 || !is_elf_hash_table (info->hash)) 14028 { 14029 _bfd_error_handler(_("warning: gc-sections option ignored")); 14030 return TRUE; 14031 } 14032 14033 bed->gc_keep (info); 14034 htab = elf_hash_table (info); 14035 14036 /* Try to parse each bfd's .eh_frame section. Point elf_eh_frame_section 14037 at the .eh_frame section if we can mark the FDEs individually. */ 14038 for (sub = info->input_bfds; 14039 info->eh_frame_hdr_type != COMPACT_EH_HDR && sub != NULL; 14040 sub = sub->link.next) 14041 { 14042 asection *sec; 14043 struct elf_reloc_cookie cookie; 14044 14045 sec = sub->sections; 14046 if (sec == NULL || sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS) 14047 continue; 14048 sec = bfd_get_section_by_name (sub, ".eh_frame"); 14049 while (sec && init_reloc_cookie_for_section (&cookie, info, sec)) 14050 { 14051 _bfd_elf_parse_eh_frame (sub, info, sec, &cookie); 14052 if (elf_section_data (sec)->sec_info 14053 && (sec->flags & SEC_LINKER_CREATED) == 0) 14054 elf_eh_frame_section (sub) = sec; 14055 fini_reloc_cookie_for_section (&cookie, sec); 14056 sec = bfd_get_next_section_by_name (NULL, sec); 14057 } 14058 } 14059 14060 /* Apply transitive closure to the vtable entry usage info. */ 14061 elf_link_hash_traverse (htab, elf_gc_propagate_vtable_entries_used, &ok); 14062 if (!ok) 14063 return FALSE; 14064 14065 /* Kill the vtable relocations that were not used. */ 14066 elf_link_hash_traverse (htab, elf_gc_smash_unused_vtentry_relocs, &ok); 14067 if (!ok) 14068 return FALSE; 14069 14070 /* Mark dynamically referenced symbols. */ 14071 if (htab->dynamic_sections_created || info->gc_keep_exported) 14072 elf_link_hash_traverse (htab, bed->gc_mark_dynamic_ref, info); 14073 14074 /* Grovel through relocs to find out who stays ... */ 14075 gc_mark_hook = bed->gc_mark_hook; 14076 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next) 14077 { 14078 asection *o; 14079 14080 if (bfd_get_flavour (sub) != bfd_target_elf_flavour 14081 || elf_object_id (sub) != elf_hash_table_id (htab) 14082 || !(*bed->relocs_compatible) (sub->xvec, abfd->xvec)) 14083 continue; 14084 14085 o = sub->sections; 14086 if (o == NULL || o->sec_info_type == SEC_INFO_TYPE_JUST_SYMS) 14087 continue; 14088 14089 /* Start at sections marked with SEC_KEEP (ref _bfd_elf_gc_keep). 14090 Also treat note sections as a root, if the section is not part 14091 of a group. We must keep all PREINIT_ARRAY, INIT_ARRAY as 14092 well as FINI_ARRAY sections for ld -r. */ 14093 for (o = sub->sections; o != NULL; o = o->next) 14094 if (!o->gc_mark 14095 && (o->flags & SEC_EXCLUDE) == 0 14096 && ((o->flags & SEC_KEEP) != 0 14097 || (bfd_link_relocatable (info) 14098 && ((elf_section_data (o)->this_hdr.sh_type 14099 == SHT_PREINIT_ARRAY) 14100 || (elf_section_data (o)->this_hdr.sh_type 14101 == SHT_INIT_ARRAY) 14102 || (elf_section_data (o)->this_hdr.sh_type 14103 == SHT_FINI_ARRAY))) 14104 || (elf_section_data (o)->this_hdr.sh_type == SHT_NOTE 14105 && elf_next_in_group (o) == NULL ))) 14106 { 14107 if (!_bfd_elf_gc_mark (info, o, gc_mark_hook)) 14108 return FALSE; 14109 } 14110 } 14111 14112 /* Allow the backend to mark additional target specific sections. */ 14113 bed->gc_mark_extra_sections (info, gc_mark_hook); 14114 14115 /* ... and mark SEC_EXCLUDE for those that go. */ 14116 return elf_gc_sweep (abfd, info); 14117} 14118 14119/* Called from check_relocs to record the existence of a VTINHERIT reloc. */ 14120 14121bfd_boolean 14122bfd_elf_gc_record_vtinherit (bfd *abfd, 14123 asection *sec, 14124 struct elf_link_hash_entry *h, 14125 bfd_vma offset) 14126{ 14127 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end; 14128 struct elf_link_hash_entry **search, *child; 14129 size_t extsymcount; 14130 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 14131 14132 /* The sh_info field of the symtab header tells us where the 14133 external symbols start. We don't care about the local symbols at 14134 this point. */ 14135 extsymcount = elf_tdata (abfd)->symtab_hdr.sh_size / bed->s->sizeof_sym; 14136 if (!elf_bad_symtab (abfd)) 14137 extsymcount -= elf_tdata (abfd)->symtab_hdr.sh_info; 14138 14139 sym_hashes = elf_sym_hashes (abfd); 14140 sym_hashes_end = sym_hashes + extsymcount; 14141 14142 /* Hunt down the child symbol, which is in this section at the same 14143 offset as the relocation. */ 14144 for (search = sym_hashes; search != sym_hashes_end; ++search) 14145 { 14146 if ((child = *search) != NULL 14147 && (child->root.type == bfd_link_hash_defined 14148 || child->root.type == bfd_link_hash_defweak) 14149 && child->root.u.def.section == sec 14150 && child->root.u.def.value == offset) 14151 goto win; 14152 } 14153 14154 /* xgettext:c-format */ 14155 _bfd_error_handler (_("%pB: %pA+%#" PRIx64 ": no symbol found for INHERIT"), 14156 abfd, sec, (uint64_t) offset); 14157 bfd_set_error (bfd_error_invalid_operation); 14158 return FALSE; 14159 14160 win: 14161 if (!child->u2.vtable) 14162 { 14163 child->u2.vtable = ((struct elf_link_virtual_table_entry *) 14164 bfd_zalloc (abfd, sizeof (*child->u2.vtable))); 14165 if (!child->u2.vtable) 14166 return FALSE; 14167 } 14168 if (!h) 14169 { 14170 /* This *should* only be the absolute section. It could potentially 14171 be that someone has defined a non-global vtable though, which 14172 would be bad. It isn't worth paging in the local symbols to be 14173 sure though; that case should simply be handled by the assembler. */ 14174 14175 child->u2.vtable->parent = (struct elf_link_hash_entry *) -1; 14176 } 14177 else 14178 child->u2.vtable->parent = h; 14179 14180 return TRUE; 14181} 14182 14183/* Called from check_relocs to record the existence of a VTENTRY reloc. */ 14184 14185bfd_boolean 14186bfd_elf_gc_record_vtentry (bfd *abfd, asection *sec, 14187 struct elf_link_hash_entry *h, 14188 bfd_vma addend) 14189{ 14190 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 14191 unsigned int log_file_align = bed->s->log_file_align; 14192 14193 if (!h) 14194 { 14195 /* xgettext:c-format */ 14196 _bfd_error_handler (_("%pB: section '%pA': corrupt VTENTRY entry"), 14197 abfd, sec); 14198 bfd_set_error (bfd_error_bad_value); 14199 return FALSE; 14200 } 14201 14202 if (!h->u2.vtable) 14203 { 14204 h->u2.vtable = ((struct elf_link_virtual_table_entry *) 14205 bfd_zalloc (abfd, sizeof (*h->u2.vtable))); 14206 if (!h->u2.vtable) 14207 return FALSE; 14208 } 14209 14210 if (addend >= h->u2.vtable->size) 14211 { 14212 size_t size, bytes, file_align; 14213 bfd_boolean *ptr = h->u2.vtable->used; 14214 14215 /* While the symbol is undefined, we have to be prepared to handle 14216 a zero size. */ 14217 file_align = 1 << log_file_align; 14218 if (h->root.type == bfd_link_hash_undefined) 14219 size = addend + file_align; 14220 else 14221 { 14222 size = h->size; 14223 if (addend >= size) 14224 { 14225 /* Oops! We've got a reference past the defined end of 14226 the table. This is probably a bug -- shall we warn? */ 14227 size = addend + file_align; 14228 } 14229 } 14230 size = (size + file_align - 1) & -file_align; 14231 14232 /* Allocate one extra entry for use as a "done" flag for the 14233 consolidation pass. */ 14234 bytes = ((size >> log_file_align) + 1) * sizeof (bfd_boolean); 14235 14236 if (ptr) 14237 { 14238 ptr = (bfd_boolean *) bfd_realloc (ptr - 1, bytes); 14239 14240 if (ptr != NULL) 14241 { 14242 size_t oldbytes; 14243 14244 oldbytes = (((h->u2.vtable->size >> log_file_align) + 1) 14245 * sizeof (bfd_boolean)); 14246 memset (((char *) ptr) + oldbytes, 0, bytes - oldbytes); 14247 } 14248 } 14249 else 14250 ptr = (bfd_boolean *) bfd_zmalloc (bytes); 14251 14252 if (ptr == NULL) 14253 return FALSE; 14254 14255 /* And arrange for that done flag to be at index -1. */ 14256 h->u2.vtable->used = ptr + 1; 14257 h->u2.vtable->size = size; 14258 } 14259 14260 h->u2.vtable->used[addend >> log_file_align] = TRUE; 14261 14262 return TRUE; 14263} 14264 14265/* Map an ELF section header flag to its corresponding string. */ 14266typedef struct 14267{ 14268 char *flag_name; 14269 flagword flag_value; 14270} elf_flags_to_name_table; 14271 14272static elf_flags_to_name_table elf_flags_to_names [] = 14273{ 14274 { "SHF_WRITE", SHF_WRITE }, 14275 { "SHF_ALLOC", SHF_ALLOC }, 14276 { "SHF_EXECINSTR", SHF_EXECINSTR }, 14277 { "SHF_MERGE", SHF_MERGE }, 14278 { "SHF_STRINGS", SHF_STRINGS }, 14279 { "SHF_INFO_LINK", SHF_INFO_LINK}, 14280 { "SHF_LINK_ORDER", SHF_LINK_ORDER}, 14281 { "SHF_OS_NONCONFORMING", SHF_OS_NONCONFORMING}, 14282 { "SHF_GROUP", SHF_GROUP }, 14283 { "SHF_TLS", SHF_TLS }, 14284 { "SHF_MASKOS", SHF_MASKOS }, 14285 { "SHF_EXCLUDE", SHF_EXCLUDE }, 14286}; 14287 14288/* Returns TRUE if the section is to be included, otherwise FALSE. */ 14289bfd_boolean 14290bfd_elf_lookup_section_flags (struct bfd_link_info *info, 14291 struct flag_info *flaginfo, 14292 asection *section) 14293{ 14294 const bfd_vma sh_flags = elf_section_flags (section); 14295 14296 if (!flaginfo->flags_initialized) 14297 { 14298 bfd *obfd = info->output_bfd; 14299 const struct elf_backend_data *bed = get_elf_backend_data (obfd); 14300 struct flag_info_list *tf = flaginfo->flag_list; 14301 int with_hex = 0; 14302 int without_hex = 0; 14303 14304 for (tf = flaginfo->flag_list; tf != NULL; tf = tf->next) 14305 { 14306 unsigned i; 14307 flagword (*lookup) (char *); 14308 14309 lookup = bed->elf_backend_lookup_section_flags_hook; 14310 if (lookup != NULL) 14311 { 14312 flagword hexval = (*lookup) ((char *) tf->name); 14313 14314 if (hexval != 0) 14315 { 14316 if (tf->with == with_flags) 14317 with_hex |= hexval; 14318 else if (tf->with == without_flags) 14319 without_hex |= hexval; 14320 tf->valid = TRUE; 14321 continue; 14322 } 14323 } 14324 for (i = 0; i < ARRAY_SIZE (elf_flags_to_names); ++i) 14325 { 14326 if (strcmp (tf->name, elf_flags_to_names[i].flag_name) == 0) 14327 { 14328 if (tf->with == with_flags) 14329 with_hex |= elf_flags_to_names[i].flag_value; 14330 else if (tf->with == without_flags) 14331 without_hex |= elf_flags_to_names[i].flag_value; 14332 tf->valid = TRUE; 14333 break; 14334 } 14335 } 14336 if (!tf->valid) 14337 { 14338 info->callbacks->einfo 14339 (_("unrecognized INPUT_SECTION_FLAG %s\n"), tf->name); 14340 return FALSE; 14341 } 14342 } 14343 flaginfo->flags_initialized = TRUE; 14344 flaginfo->only_with_flags |= with_hex; 14345 flaginfo->not_with_flags |= without_hex; 14346 } 14347 14348 if ((flaginfo->only_with_flags & sh_flags) != flaginfo->only_with_flags) 14349 return FALSE; 14350 14351 if ((flaginfo->not_with_flags & sh_flags) != 0) 14352 return FALSE; 14353 14354 return TRUE; 14355} 14356 14357struct alloc_got_off_arg { 14358 bfd_vma gotoff; 14359 struct bfd_link_info *info; 14360}; 14361 14362/* We need a special top-level link routine to convert got reference counts 14363 to real got offsets. */ 14364 14365static bfd_boolean 14366elf_gc_allocate_got_offsets (struct elf_link_hash_entry *h, void *arg) 14367{ 14368 struct alloc_got_off_arg *gofarg = (struct alloc_got_off_arg *) arg; 14369 bfd *obfd = gofarg->info->output_bfd; 14370 const struct elf_backend_data *bed = get_elf_backend_data (obfd); 14371 14372 if (h->got.refcount > 0) 14373 { 14374 h->got.offset = gofarg->gotoff; 14375 gofarg->gotoff += bed->got_elt_size (obfd, gofarg->info, h, NULL, 0); 14376 } 14377 else 14378 h->got.offset = (bfd_vma) -1; 14379 14380 return TRUE; 14381} 14382 14383/* And an accompanying bit to work out final got entry offsets once 14384 we're done. Should be called from final_link. */ 14385 14386bfd_boolean 14387bfd_elf_gc_common_finalize_got_offsets (bfd *abfd, 14388 struct bfd_link_info *info) 14389{ 14390 bfd *i; 14391 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 14392 bfd_vma gotoff; 14393 struct alloc_got_off_arg gofarg; 14394 14395 BFD_ASSERT (abfd == info->output_bfd); 14396 14397 if (! is_elf_hash_table (info->hash)) 14398 return FALSE; 14399 14400 /* The GOT offset is relative to the .got section, but the GOT header is 14401 put into the .got.plt section, if the backend uses it. */ 14402 if (bed->want_got_plt) 14403 gotoff = 0; 14404 else 14405 gotoff = bed->got_header_size; 14406 14407 /* Do the local .got entries first. */ 14408 for (i = info->input_bfds; i; i = i->link.next) 14409 { 14410 bfd_signed_vma *local_got; 14411 size_t j, locsymcount; 14412 Elf_Internal_Shdr *symtab_hdr; 14413 14414 if (bfd_get_flavour (i) != bfd_target_elf_flavour) 14415 continue; 14416 14417 local_got = elf_local_got_refcounts (i); 14418 if (!local_got) 14419 continue; 14420 14421 symtab_hdr = &elf_tdata (i)->symtab_hdr; 14422 if (elf_bad_symtab (i)) 14423 locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym; 14424 else 14425 locsymcount = symtab_hdr->sh_info; 14426 14427 for (j = 0; j < locsymcount; ++j) 14428 { 14429 if (local_got[j] > 0) 14430 { 14431 local_got[j] = gotoff; 14432 gotoff += bed->got_elt_size (abfd, info, NULL, i, j); 14433 } 14434 else 14435 local_got[j] = (bfd_vma) -1; 14436 } 14437 } 14438 14439 /* Then the global .got entries. .plt refcounts are handled by 14440 adjust_dynamic_symbol */ 14441 gofarg.gotoff = gotoff; 14442 gofarg.info = info; 14443 elf_link_hash_traverse (elf_hash_table (info), 14444 elf_gc_allocate_got_offsets, 14445 &gofarg); 14446 return TRUE; 14447} 14448 14449/* Many folk need no more in the way of final link than this, once 14450 got entry reference counting is enabled. */ 14451 14452bfd_boolean 14453bfd_elf_gc_common_final_link (bfd *abfd, struct bfd_link_info *info) 14454{ 14455 if (!bfd_elf_gc_common_finalize_got_offsets (abfd, info)) 14456 return FALSE; 14457 14458 /* Invoke the regular ELF backend linker to do all the work. */ 14459 return bfd_elf_final_link (abfd, info); 14460} 14461 14462bfd_boolean 14463bfd_elf_reloc_symbol_deleted_p (bfd_vma offset, void *cookie) 14464{ 14465 struct elf_reloc_cookie *rcookie = (struct elf_reloc_cookie *) cookie; 14466 14467 if (rcookie->bad_symtab) 14468 rcookie->rel = rcookie->rels; 14469 14470 for (; rcookie->rel < rcookie->relend; rcookie->rel++) 14471 { 14472 unsigned long r_symndx; 14473 14474 if (! rcookie->bad_symtab) 14475 if (rcookie->rel->r_offset > offset) 14476 return FALSE; 14477 if (rcookie->rel->r_offset != offset) 14478 continue; 14479 14480 r_symndx = rcookie->rel->r_info >> rcookie->r_sym_shift; 14481 if (r_symndx == STN_UNDEF) 14482 return TRUE; 14483 14484 if (r_symndx >= rcookie->locsymcount 14485 || ELF_ST_BIND (rcookie->locsyms[r_symndx].st_info) != STB_LOCAL) 14486 { 14487 struct elf_link_hash_entry *h; 14488 14489 h = rcookie->sym_hashes[r_symndx - rcookie->extsymoff]; 14490 14491 while (h->root.type == bfd_link_hash_indirect 14492 || h->root.type == bfd_link_hash_warning) 14493 h = (struct elf_link_hash_entry *) h->root.u.i.link; 14494 14495 if ((h->root.type == bfd_link_hash_defined 14496 || h->root.type == bfd_link_hash_defweak) 14497 && (h->root.u.def.section->owner != rcookie->abfd 14498 || h->root.u.def.section->kept_section != NULL 14499 || discarded_section (h->root.u.def.section))) 14500 return TRUE; 14501 } 14502 else 14503 { 14504 /* It's not a relocation against a global symbol, 14505 but it could be a relocation against a local 14506 symbol for a discarded section. */ 14507 asection *isec; 14508 Elf_Internal_Sym *isym; 14509 14510 /* Need to: get the symbol; get the section. */ 14511 isym = &rcookie->locsyms[r_symndx]; 14512 isec = bfd_section_from_elf_index (rcookie->abfd, isym->st_shndx); 14513 if (isec != NULL 14514 && (isec->kept_section != NULL 14515 || discarded_section (isec))) 14516 return TRUE; 14517 } 14518 return FALSE; 14519 } 14520 return FALSE; 14521} 14522 14523/* Discard unneeded references to discarded sections. 14524 Returns -1 on error, 1 if any section's size was changed, 0 if 14525 nothing changed. This function assumes that the relocations are in 14526 sorted order, which is true for all known assemblers. */ 14527 14528int 14529bfd_elf_discard_info (bfd *output_bfd, struct bfd_link_info *info) 14530{ 14531 struct elf_reloc_cookie cookie; 14532 asection *o; 14533 bfd *abfd; 14534 int changed = 0; 14535 14536 if (info->traditional_format 14537 || !is_elf_hash_table (info->hash)) 14538 return 0; 14539 14540 o = bfd_get_section_by_name (output_bfd, ".stab"); 14541 if (o != NULL) 14542 { 14543 asection *i; 14544 14545 for (i = o->map_head.s; i != NULL; i = i->map_head.s) 14546 { 14547 if (i->size == 0 14548 || i->reloc_count == 0 14549 || i->sec_info_type != SEC_INFO_TYPE_STABS) 14550 continue; 14551 14552 abfd = i->owner; 14553 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour) 14554 continue; 14555 14556 if (!init_reloc_cookie_for_section (&cookie, info, i)) 14557 return -1; 14558 14559 if (_bfd_discard_section_stabs (abfd, i, 14560 elf_section_data (i)->sec_info, 14561 bfd_elf_reloc_symbol_deleted_p, 14562 &cookie)) 14563 changed = 1; 14564 14565 fini_reloc_cookie_for_section (&cookie, i); 14566 } 14567 } 14568 14569 o = NULL; 14570 if (info->eh_frame_hdr_type != COMPACT_EH_HDR) 14571 o = bfd_get_section_by_name (output_bfd, ".eh_frame"); 14572 if (o != NULL) 14573 { 14574 asection *i; 14575 int eh_changed = 0; 14576 unsigned int eh_alignment; /* Octets. */ 14577 14578 for (i = o->map_head.s; i != NULL; i = i->map_head.s) 14579 { 14580 if (i->size == 0) 14581 continue; 14582 14583 abfd = i->owner; 14584 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour) 14585 continue; 14586 14587 if (!init_reloc_cookie_for_section (&cookie, info, i)) 14588 return -1; 14589 14590 _bfd_elf_parse_eh_frame (abfd, info, i, &cookie); 14591 if (_bfd_elf_discard_section_eh_frame (abfd, info, i, 14592 bfd_elf_reloc_symbol_deleted_p, 14593 &cookie)) 14594 { 14595 eh_changed = 1; 14596 if (i->size != i->rawsize) 14597 changed = 1; 14598 } 14599 14600 fini_reloc_cookie_for_section (&cookie, i); 14601 } 14602 14603 eh_alignment = ((1 << o->alignment_power) 14604 * bfd_octets_per_byte (output_bfd, o)); 14605 /* Skip over zero terminator, and prevent empty sections from 14606 adding alignment padding at the end. */ 14607 for (i = o->map_tail.s; i != NULL; i = i->map_tail.s) 14608 if (i->size == 0) 14609 i->flags |= SEC_EXCLUDE; 14610 else if (i->size > 4) 14611 break; 14612 /* The last non-empty eh_frame section doesn't need padding. */ 14613 if (i != NULL) 14614 i = i->map_tail.s; 14615 /* Any prior sections must pad the last FDE out to the output 14616 section alignment. Otherwise we might have zero padding 14617 between sections, which would be seen as a terminator. */ 14618 for (; i != NULL; i = i->map_tail.s) 14619 if (i->size == 4) 14620 /* All but the last zero terminator should have been removed. */ 14621 BFD_FAIL (); 14622 else 14623 { 14624 bfd_size_type size 14625 = (i->size + eh_alignment - 1) & -eh_alignment; 14626 if (i->size != size) 14627 { 14628 i->size = size; 14629 changed = 1; 14630 eh_changed = 1; 14631 } 14632 } 14633 if (eh_changed) 14634 elf_link_hash_traverse (elf_hash_table (info), 14635 _bfd_elf_adjust_eh_frame_global_symbol, NULL); 14636 } 14637 14638 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next) 14639 { 14640 const struct elf_backend_data *bed; 14641 asection *s; 14642 14643 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour) 14644 continue; 14645 s = abfd->sections; 14646 if (s == NULL || s->sec_info_type == SEC_INFO_TYPE_JUST_SYMS) 14647 continue; 14648 14649 bed = get_elf_backend_data (abfd); 14650 14651 if (bed->elf_backend_discard_info != NULL) 14652 { 14653 if (!init_reloc_cookie (&cookie, info, abfd)) 14654 return -1; 14655 14656 if ((*bed->elf_backend_discard_info) (abfd, &cookie, info)) 14657 changed = 1; 14658 14659 fini_reloc_cookie (&cookie, abfd); 14660 } 14661 } 14662 14663 if (info->eh_frame_hdr_type == COMPACT_EH_HDR) 14664 _bfd_elf_end_eh_frame_parsing (info); 14665 14666 if (info->eh_frame_hdr_type 14667 && !bfd_link_relocatable (info) 14668 && _bfd_elf_discard_section_eh_frame_hdr (output_bfd, info)) 14669 changed = 1; 14670 14671 return changed; 14672} 14673 14674bfd_boolean 14675_bfd_elf_section_already_linked (bfd *abfd, 14676 asection *sec, 14677 struct bfd_link_info *info) 14678{ 14679 flagword flags; 14680 const char *name, *key; 14681 struct bfd_section_already_linked *l; 14682 struct bfd_section_already_linked_hash_entry *already_linked_list; 14683 14684 if (sec->output_section == bfd_abs_section_ptr) 14685 return FALSE; 14686 14687 flags = sec->flags; 14688 14689 /* Return if it isn't a linkonce section. A comdat group section 14690 also has SEC_LINK_ONCE set. */ 14691 if ((flags & SEC_LINK_ONCE) == 0) 14692 return FALSE; 14693 14694 /* Don't put group member sections on our list of already linked 14695 sections. They are handled as a group via their group section. */ 14696 if (elf_sec_group (sec) != NULL) 14697 return FALSE; 14698 14699 /* For a SHT_GROUP section, use the group signature as the key. */ 14700 name = sec->name; 14701 if ((flags & SEC_GROUP) != 0 14702 && elf_next_in_group (sec) != NULL 14703 && elf_group_name (elf_next_in_group (sec)) != NULL) 14704 key = elf_group_name (elf_next_in_group (sec)); 14705 else 14706 { 14707 /* Otherwise we should have a .gnu.linkonce.<type>.<key> section. */ 14708 if (CONST_STRNEQ (name, ".gnu.linkonce.") 14709 && (key = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL) 14710 key++; 14711 else 14712 /* Must be a user linkonce section that doesn't follow gcc's 14713 naming convention. In this case we won't be matching 14714 single member groups. */ 14715 key = name; 14716 } 14717 14718 already_linked_list = bfd_section_already_linked_table_lookup (key); 14719 14720 for (l = already_linked_list->entry; l != NULL; l = l->next) 14721 { 14722 /* We may have 2 different types of sections on the list: group 14723 sections with a signature of <key> (<key> is some string), 14724 and linkonce sections named .gnu.linkonce.<type>.<key>. 14725 Match like sections. LTO plugin sections are an exception. 14726 They are always named .gnu.linkonce.t.<key> and match either 14727 type of section. */ 14728 if (((flags & SEC_GROUP) == (l->sec->flags & SEC_GROUP) 14729 && ((flags & SEC_GROUP) != 0 14730 || strcmp (name, l->sec->name) == 0)) 14731 || (l->sec->owner->flags & BFD_PLUGIN) != 0 14732 || (sec->owner->flags & BFD_PLUGIN) != 0) 14733 { 14734 /* The section has already been linked. See if we should 14735 issue a warning. */ 14736 if (!_bfd_handle_already_linked (sec, l, info)) 14737 return FALSE; 14738 14739 if (flags & SEC_GROUP) 14740 { 14741 asection *first = elf_next_in_group (sec); 14742 asection *s = first; 14743 14744 while (s != NULL) 14745 { 14746 s->output_section = bfd_abs_section_ptr; 14747 /* Record which group discards it. */ 14748 s->kept_section = l->sec; 14749 s = elf_next_in_group (s); 14750 /* These lists are circular. */ 14751 if (s == first) 14752 break; 14753 } 14754 } 14755 14756 return TRUE; 14757 } 14758 } 14759 14760 /* A single member comdat group section may be discarded by a 14761 linkonce section and vice versa. */ 14762 if ((flags & SEC_GROUP) != 0) 14763 { 14764 asection *first = elf_next_in_group (sec); 14765 14766 if (first != NULL && elf_next_in_group (first) == first) 14767 /* Check this single member group against linkonce sections. */ 14768 for (l = already_linked_list->entry; l != NULL; l = l->next) 14769 if ((l->sec->flags & SEC_GROUP) == 0 14770 && bfd_elf_match_symbols_in_sections (l->sec, first, info)) 14771 { 14772 first->output_section = bfd_abs_section_ptr; 14773 first->kept_section = l->sec; 14774 sec->output_section = bfd_abs_section_ptr; 14775 break; 14776 } 14777 } 14778 else 14779 /* Check this linkonce section against single member groups. */ 14780 for (l = already_linked_list->entry; l != NULL; l = l->next) 14781 if (l->sec->flags & SEC_GROUP) 14782 { 14783 asection *first = elf_next_in_group (l->sec); 14784 14785 if (first != NULL 14786 && elf_next_in_group (first) == first 14787 && bfd_elf_match_symbols_in_sections (first, sec, info)) 14788 { 14789 sec->output_section = bfd_abs_section_ptr; 14790 sec->kept_section = first; 14791 break; 14792 } 14793 } 14794 14795 /* Do not complain on unresolved relocations in `.gnu.linkonce.r.F' 14796 referencing its discarded `.gnu.linkonce.t.F' counterpart - g++-3.4 14797 specific as g++-4.x is using COMDAT groups (without the `.gnu.linkonce' 14798 prefix) instead. `.gnu.linkonce.r.*' were the `.rodata' part of its 14799 matching `.gnu.linkonce.t.*'. If `.gnu.linkonce.r.F' is not discarded 14800 but its `.gnu.linkonce.t.F' is discarded means we chose one-only 14801 `.gnu.linkonce.t.F' section from a different bfd not requiring any 14802 `.gnu.linkonce.r.F'. Thus `.gnu.linkonce.r.F' should be discarded. 14803 The reverse order cannot happen as there is never a bfd with only the 14804 `.gnu.linkonce.r.F' section. The order of sections in a bfd does not 14805 matter as here were are looking only for cross-bfd sections. */ 14806 14807 if ((flags & SEC_GROUP) == 0 && CONST_STRNEQ (name, ".gnu.linkonce.r.")) 14808 for (l = already_linked_list->entry; l != NULL; l = l->next) 14809 if ((l->sec->flags & SEC_GROUP) == 0 14810 && CONST_STRNEQ (l->sec->name, ".gnu.linkonce.t.")) 14811 { 14812 if (abfd != l->sec->owner) 14813 sec->output_section = bfd_abs_section_ptr; 14814 break; 14815 } 14816 14817 /* This is the first section with this name. Record it. */ 14818 if (!bfd_section_already_linked_table_insert (already_linked_list, sec)) 14819 info->callbacks->einfo (_("%F%P: already_linked_table: %E\n")); 14820 return sec->output_section == bfd_abs_section_ptr; 14821} 14822 14823bfd_boolean 14824_bfd_elf_common_definition (Elf_Internal_Sym *sym) 14825{ 14826 return sym->st_shndx == SHN_COMMON; 14827} 14828 14829unsigned int 14830_bfd_elf_common_section_index (asection *sec ATTRIBUTE_UNUSED) 14831{ 14832 return SHN_COMMON; 14833} 14834 14835asection * 14836_bfd_elf_common_section (asection *sec ATTRIBUTE_UNUSED) 14837{ 14838 return bfd_com_section_ptr; 14839} 14840 14841bfd_vma 14842_bfd_elf_default_got_elt_size (bfd *abfd, 14843 struct bfd_link_info *info ATTRIBUTE_UNUSED, 14844 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED, 14845 bfd *ibfd ATTRIBUTE_UNUSED, 14846 unsigned long symndx ATTRIBUTE_UNUSED) 14847{ 14848 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 14849 return bed->s->arch_size / 8; 14850} 14851 14852/* Routines to support the creation of dynamic relocs. */ 14853 14854/* Returns the name of the dynamic reloc section associated with SEC. */ 14855 14856static const char * 14857get_dynamic_reloc_section_name (bfd * abfd, 14858 asection * sec, 14859 bfd_boolean is_rela) 14860{ 14861 char *name; 14862 const char *old_name = bfd_section_name (sec); 14863 const char *prefix = is_rela ? ".rela" : ".rel"; 14864 14865 if (old_name == NULL) 14866 return NULL; 14867 14868 name = bfd_alloc (abfd, strlen (prefix) + strlen (old_name) + 1); 14869 sprintf (name, "%s%s", prefix, old_name); 14870 14871 return name; 14872} 14873 14874/* Returns the dynamic reloc section associated with SEC. 14875 If necessary compute the name of the dynamic reloc section based 14876 on SEC's name (looked up in ABFD's string table) and the setting 14877 of IS_RELA. */ 14878 14879asection * 14880_bfd_elf_get_dynamic_reloc_section (bfd * abfd, 14881 asection * sec, 14882 bfd_boolean is_rela) 14883{ 14884 asection * reloc_sec = elf_section_data (sec)->sreloc; 14885 14886 if (reloc_sec == NULL) 14887 { 14888 const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela); 14889 14890 if (name != NULL) 14891 { 14892 reloc_sec = bfd_get_linker_section (abfd, name); 14893 14894 if (reloc_sec != NULL) 14895 elf_section_data (sec)->sreloc = reloc_sec; 14896 } 14897 } 14898 14899 return reloc_sec; 14900} 14901 14902/* Returns the dynamic reloc section associated with SEC. If the 14903 section does not exist it is created and attached to the DYNOBJ 14904 bfd and stored in the SRELOC field of SEC's elf_section_data 14905 structure. 14906 14907 ALIGNMENT is the alignment for the newly created section and 14908 IS_RELA defines whether the name should be .rela.<SEC's name> 14909 or .rel.<SEC's name>. The section name is looked up in the 14910 string table associated with ABFD. */ 14911 14912asection * 14913_bfd_elf_make_dynamic_reloc_section (asection *sec, 14914 bfd *dynobj, 14915 unsigned int alignment, 14916 bfd *abfd, 14917 bfd_boolean is_rela) 14918{ 14919 asection * reloc_sec = elf_section_data (sec)->sreloc; 14920 14921 if (reloc_sec == NULL) 14922 { 14923 const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela); 14924 14925 if (name == NULL) 14926 return NULL; 14927 14928 reloc_sec = bfd_get_linker_section (dynobj, name); 14929 14930 if (reloc_sec == NULL) 14931 { 14932 flagword flags = (SEC_HAS_CONTENTS | SEC_READONLY 14933 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 14934 if ((sec->flags & SEC_ALLOC) != 0) 14935 flags |= SEC_ALLOC | SEC_LOAD; 14936 14937 reloc_sec = bfd_make_section_anyway_with_flags (dynobj, name, flags); 14938 if (reloc_sec != NULL) 14939 { 14940 /* _bfd_elf_get_sec_type_attr chooses a section type by 14941 name. Override as it may be wrong, eg. for a user 14942 section named "auto" we'll get ".relauto" which is 14943 seen to be a .rela section. */ 14944 elf_section_type (reloc_sec) = is_rela ? SHT_RELA : SHT_REL; 14945 if (!bfd_set_section_alignment (reloc_sec, alignment)) 14946 reloc_sec = NULL; 14947 } 14948 } 14949 14950 elf_section_data (sec)->sreloc = reloc_sec; 14951 } 14952 14953 return reloc_sec; 14954} 14955 14956/* Copy the ELF symbol type and other attributes for a linker script 14957 assignment from HSRC to HDEST. Generally this should be treated as 14958 if we found a strong non-dynamic definition for HDEST (except that 14959 ld ignores multiple definition errors). */ 14960void 14961_bfd_elf_copy_link_hash_symbol_type (bfd *abfd, 14962 struct bfd_link_hash_entry *hdest, 14963 struct bfd_link_hash_entry *hsrc) 14964{ 14965 struct elf_link_hash_entry *ehdest = (struct elf_link_hash_entry *) hdest; 14966 struct elf_link_hash_entry *ehsrc = (struct elf_link_hash_entry *) hsrc; 14967 Elf_Internal_Sym isym; 14968 14969 ehdest->type = ehsrc->type; 14970 ehdest->target_internal = ehsrc->target_internal; 14971 14972 isym.st_other = ehsrc->other; 14973 elf_merge_st_other (abfd, ehdest, &isym, NULL, TRUE, FALSE); 14974} 14975 14976/* Append a RELA relocation REL to section S in BFD. */ 14977 14978void 14979elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel) 14980{ 14981 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 14982 bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela); 14983 BFD_ASSERT (loc + bed->s->sizeof_rela <= s->contents + s->size); 14984 bed->s->swap_reloca_out (abfd, rel, loc); 14985} 14986 14987/* Append a REL relocation REL to section S in BFD. */ 14988 14989void 14990elf_append_rel (bfd *abfd, asection *s, Elf_Internal_Rela *rel) 14991{ 14992 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 14993 bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rel); 14994 BFD_ASSERT (loc + bed->s->sizeof_rel <= s->contents + s->size); 14995 bed->s->swap_reloc_out (abfd, rel, loc); 14996} 14997 14998/* Define __start, __stop, .startof. or .sizeof. symbol. */ 14999 15000struct bfd_link_hash_entry * 15001bfd_elf_define_start_stop (struct bfd_link_info *info, 15002 const char *symbol, asection *sec) 15003{ 15004 struct elf_link_hash_entry *h; 15005 15006 h = elf_link_hash_lookup (elf_hash_table (info), symbol, 15007 FALSE, FALSE, TRUE); 15008 /* NB: Common symbols will be turned into definition later. */ 15009 if (h != NULL 15010 && (h->root.type == bfd_link_hash_undefined 15011 || h->root.type == bfd_link_hash_undefweak 15012 || ((h->ref_regular || h->def_dynamic) 15013 && !h->def_regular 15014 && h->root.type != bfd_link_hash_common))) 15015 { 15016 bfd_boolean was_dynamic = h->ref_dynamic || h->def_dynamic; 15017 h->verinfo.verdef = NULL; 15018 h->root.type = bfd_link_hash_defined; 15019 h->root.u.def.section = sec; 15020 h->root.u.def.value = 0; 15021 h->def_regular = 1; 15022 h->def_dynamic = 0; 15023 h->start_stop = 1; 15024 h->u2.start_stop_section = sec; 15025 if (symbol[0] == '.') 15026 { 15027 /* .startof. and .sizeof. symbols are local. */ 15028 const struct elf_backend_data *bed; 15029 bed = get_elf_backend_data (info->output_bfd); 15030 (*bed->elf_backend_hide_symbol) (info, h, TRUE); 15031 } 15032 else 15033 { 15034 if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) 15035 h->other = ((h->other & ~ELF_ST_VISIBILITY (-1)) 15036 | info->start_stop_visibility); 15037 if (was_dynamic) 15038 bfd_elf_link_record_dynamic_symbol (info, h); 15039 } 15040 return &h->root; 15041 } 15042 return NULL; 15043} 15044 15045/* Find dynamic relocs for H that apply to read-only sections. */ 15046 15047asection * 15048_bfd_elf_readonly_dynrelocs (struct elf_link_hash_entry *h) 15049{ 15050 struct elf_dyn_relocs *p; 15051 15052 for (p = h->dyn_relocs; p != NULL; p = p->next) 15053 { 15054 asection *s = p->sec->output_section; 15055 15056 if (s != NULL && (s->flags & SEC_READONLY) != 0) 15057 return p->sec; 15058 } 15059 return NULL; 15060} 15061 15062/* Set DF_TEXTREL if we find any dynamic relocs that apply to 15063 read-only sections. */ 15064 15065bfd_boolean 15066_bfd_elf_maybe_set_textrel (struct elf_link_hash_entry *h, void *inf) 15067{ 15068 asection *sec; 15069 15070 if (h->root.type == bfd_link_hash_indirect) 15071 return TRUE; 15072 15073 sec = _bfd_elf_readonly_dynrelocs (h); 15074 if (sec != NULL) 15075 { 15076 struct bfd_link_info *info = (struct bfd_link_info *) inf; 15077 15078 info->flags |= DF_TEXTREL; 15079 /* xgettext:c-format */ 15080 info->callbacks->minfo (_("%pB: dynamic relocation against `%pT' " 15081 "in read-only section `%pA'\n"), 15082 sec->owner, h->root.root.string, sec); 15083 15084 if (bfd_link_textrel_check (info)) 15085 /* xgettext:c-format */ 15086 info->callbacks->einfo (_("%P: %pB: warning: relocation against `%s' " 15087 "in read-only section `%pA'\n"), 15088 sec->owner, h->root.root.string, sec); 15089 15090 /* Not an error, just cut short the traversal. */ 15091 return FALSE; 15092 } 15093 return TRUE; 15094} 15095 15096/* Add dynamic tags. */ 15097 15098bfd_boolean 15099_bfd_elf_add_dynamic_tags (bfd *output_bfd, struct bfd_link_info *info, 15100 bfd_boolean need_dynamic_reloc) 15101{ 15102 struct elf_link_hash_table *htab = elf_hash_table (info); 15103 15104 if (htab->dynamic_sections_created) 15105 { 15106 /* Add some entries to the .dynamic section. We fill in the 15107 values later, in finish_dynamic_sections, but we must add 15108 the entries now so that we get the correct size for the 15109 .dynamic section. The DT_DEBUG entry is filled in by the 15110 dynamic linker and used by the debugger. */ 15111#define add_dynamic_entry(TAG, VAL) \ 15112 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 15113 15114 const struct elf_backend_data *bed 15115 = get_elf_backend_data (output_bfd); 15116 15117 if (bfd_link_executable (info)) 15118 { 15119 if (!add_dynamic_entry (DT_DEBUG, 0)) 15120 return FALSE; 15121 } 15122 15123 if (htab->dt_pltgot_required || htab->splt->size != 0) 15124 { 15125 /* DT_PLTGOT is used by prelink even if there is no PLT 15126 relocation. */ 15127 if (!add_dynamic_entry (DT_PLTGOT, 0)) 15128 return FALSE; 15129 } 15130 15131 if (htab->dt_jmprel_required || htab->srelplt->size != 0) 15132 { 15133 if (!add_dynamic_entry (DT_PLTRELSZ, 0) 15134 || !add_dynamic_entry (DT_PLTREL, 15135 (bed->rela_plts_and_copies_p 15136 ? DT_RELA : DT_REL)) 15137 || !add_dynamic_entry (DT_JMPREL, 0)) 15138 return FALSE; 15139 } 15140 15141 if (htab->tlsdesc_plt 15142 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0) 15143 || !add_dynamic_entry (DT_TLSDESC_GOT, 0))) 15144 return FALSE; 15145 15146 if (need_dynamic_reloc) 15147 { 15148 if (bed->rela_plts_and_copies_p) 15149 { 15150 if (!add_dynamic_entry (DT_RELA, 0) 15151 || !add_dynamic_entry (DT_RELASZ, 0) 15152 || !add_dynamic_entry (DT_RELAENT, 15153 bed->s->sizeof_rela)) 15154 return FALSE; 15155 } 15156 else 15157 { 15158 if (!add_dynamic_entry (DT_REL, 0) 15159 || !add_dynamic_entry (DT_RELSZ, 0) 15160 || !add_dynamic_entry (DT_RELENT, 15161 bed->s->sizeof_rel)) 15162 return FALSE; 15163 } 15164 15165 /* If any dynamic relocs apply to a read-only section, 15166 then we need a DT_TEXTREL entry. */ 15167 if ((info->flags & DF_TEXTREL) == 0) 15168 elf_link_hash_traverse (htab, _bfd_elf_maybe_set_textrel, 15169 info); 15170 15171 if ((info->flags & DF_TEXTREL) != 0) 15172 { 15173 if (htab->ifunc_resolvers) 15174 info->callbacks->einfo 15175 (_("%P: warning: GNU indirect functions with DT_TEXTREL " 15176 "may result in a segfault at runtime; recompile with %s\n"), 15177 bfd_link_dll (info) ? "-fPIC" : "-fPIE"); 15178 15179 if (!add_dynamic_entry (DT_TEXTREL, 0)) 15180 return FALSE; 15181 } 15182 } 15183 } 15184#undef add_dynamic_entry 15185 15186 return TRUE; 15187} 15188