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