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