elfxx-x86.c revision 1.1.1.1.4.1
1 /* x86 specific support for ELF 2 Copyright (C) 2017-2018 Free Software Foundation, Inc. 3 4 This file is part of BFD, the Binary File Descriptor library. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 19 MA 02110-1301, USA. */ 20 21 #include "elfxx-x86.h" 22 #include "elf-vxworks.h" 23 #include "objalloc.h" 24 #include "elf/i386.h" 25 #include "elf/x86-64.h" 26 27 /* The name of the dynamic interpreter. This is put in the .interp 28 section. */ 29 30 #define ELF32_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1" 31 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1" 32 #define ELFX32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1" 33 34 bfd_boolean 35 _bfd_x86_elf_mkobject (bfd *abfd) 36 { 37 return bfd_elf_allocate_object (abfd, 38 sizeof (struct elf_x86_obj_tdata), 39 get_elf_backend_data (abfd)->target_id); 40 } 41 42 /* _TLS_MODULE_BASE_ needs to be treated especially when linking 43 executables. Rather than setting it to the beginning of the TLS 44 section, we have to set it to the end. This function may be called 45 multiple times, it is idempotent. */ 46 47 void 48 _bfd_x86_elf_set_tls_module_base (struct bfd_link_info *info) 49 { 50 struct elf_x86_link_hash_table *htab; 51 struct bfd_link_hash_entry *base; 52 const struct elf_backend_data *bed; 53 54 if (!bfd_link_executable (info)) 55 return; 56 57 bed = get_elf_backend_data (info->output_bfd); 58 htab = elf_x86_hash_table (info, bed->target_id); 59 if (htab == NULL) 60 return; 61 62 base = htab->tls_module_base; 63 if (base == NULL) 64 return; 65 66 base->u.def.value = htab->elf.tls_size; 67 } 68 69 /* Return the base VMA address which should be subtracted from real addresses 70 when resolving @dtpoff relocation. 71 This is PT_TLS segment p_vaddr. */ 72 73 bfd_vma 74 _bfd_x86_elf_dtpoff_base (struct bfd_link_info *info) 75 { 76 /* If tls_sec is NULL, we should have signalled an error already. */ 77 if (elf_hash_table (info)->tls_sec == NULL) 78 return 0; 79 return elf_hash_table (info)->tls_sec->vma; 80 } 81 82 /* Allocate space in .plt, .got and associated reloc sections for 83 dynamic relocs. */ 84 85 static bfd_boolean 86 elf_x86_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) 87 { 88 struct bfd_link_info *info; 89 struct elf_x86_link_hash_table *htab; 90 struct elf_x86_link_hash_entry *eh; 91 struct elf_dyn_relocs *p; 92 unsigned int plt_entry_size; 93 bfd_boolean resolved_to_zero; 94 const struct elf_backend_data *bed; 95 96 if (h->root.type == bfd_link_hash_indirect) 97 return TRUE; 98 99 eh = (struct elf_x86_link_hash_entry *) h; 100 101 info = (struct bfd_link_info *) inf; 102 bed = get_elf_backend_data (info->output_bfd); 103 htab = elf_x86_hash_table (info, bed->target_id); 104 if (htab == NULL) 105 return FALSE; 106 107 plt_entry_size = htab->plt.plt_entry_size; 108 109 resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh); 110 111 /* We can't use the GOT PLT if pointer equality is needed since 112 finish_dynamic_symbol won't clear symbol value and the dynamic 113 linker won't update the GOT slot. We will get into an infinite 114 loop at run-time. */ 115 if (htab->plt_got != NULL 116 && h->type != STT_GNU_IFUNC 117 && !h->pointer_equality_needed 118 && h->plt.refcount > 0 119 && h->got.refcount > 0) 120 { 121 /* Don't use the regular PLT if there are both GOT and GOTPLT 122 reloctions. */ 123 h->plt.offset = (bfd_vma) -1; 124 125 /* Use the GOT PLT. */ 126 eh->plt_got.refcount = 1; 127 } 128 129 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it 130 here if it is defined and referenced in a non-shared object. */ 131 if (h->type == STT_GNU_IFUNC 132 && h->def_regular) 133 { 134 if (_bfd_elf_allocate_ifunc_dyn_relocs (info, h, &eh->dyn_relocs, 135 &htab->readonly_dynrelocs_against_ifunc, 136 plt_entry_size, 137 (htab->plt.has_plt0 138 * plt_entry_size), 139 htab->got_entry_size, 140 TRUE)) 141 { 142 asection *s = htab->plt_second; 143 if (h->plt.offset != (bfd_vma) -1 && s != NULL) 144 { 145 /* Use the second PLT section if it is created. */ 146 eh->plt_second.offset = s->size; 147 148 /* Make room for this entry in the second PLT section. */ 149 s->size += htab->non_lazy_plt->plt_entry_size; 150 } 151 152 return TRUE; 153 } 154 else 155 return FALSE; 156 } 157 /* Don't create the PLT entry if there are only function pointer 158 relocations which can be resolved at run-time. */ 159 else if (htab->elf.dynamic_sections_created 160 && (h->plt.refcount > 0 161 || eh->plt_got.refcount > 0)) 162 { 163 bfd_boolean use_plt_got = eh->plt_got.refcount > 0; 164 165 /* Make sure this symbol is output as a dynamic symbol. 166 Undefined weak syms won't yet be marked as dynamic. */ 167 if (h->dynindx == -1 168 && !h->forced_local 169 && !resolved_to_zero 170 && h->root.type == bfd_link_hash_undefweak) 171 { 172 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 173 return FALSE; 174 } 175 176 if (bfd_link_pic (info) 177 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h)) 178 { 179 asection *s = htab->elf.splt; 180 asection *second_s = htab->plt_second; 181 asection *got_s = htab->plt_got; 182 bfd_boolean use_plt; 183 184 /* If this is the first .plt entry, make room for the special 185 first entry. The .plt section is used by prelink to undo 186 prelinking for dynamic relocations. */ 187 if (s->size == 0) 188 s->size = htab->plt.has_plt0 * plt_entry_size; 189 190 if (use_plt_got) 191 eh->plt_got.offset = got_s->size; 192 else 193 { 194 h->plt.offset = s->size; 195 if (second_s) 196 eh->plt_second.offset = second_s->size; 197 } 198 199 /* If this symbol is not defined in a regular file, and we are 200 generating PDE, then set the symbol to this location in the 201 .plt. This is required to make function pointers compare 202 as equal between PDE and the shared library. 203 204 NB: If PLT is PC-relative, we can use the .plt in PIE for 205 function address. */ 206 if (h->def_regular) 207 use_plt = FALSE; 208 else if (htab->pcrel_plt) 209 use_plt = ! bfd_link_dll (info); 210 else 211 use_plt = bfd_link_pde (info); 212 if (use_plt) 213 { 214 if (use_plt_got) 215 { 216 /* We need to make a call to the entry of the GOT PLT 217 instead of regular PLT entry. */ 218 h->root.u.def.section = got_s; 219 h->root.u.def.value = eh->plt_got.offset; 220 } 221 else 222 { 223 if (second_s) 224 { 225 /* We need to make a call to the entry of the 226 second PLT instead of regular PLT entry. */ 227 h->root.u.def.section = second_s; 228 h->root.u.def.value = eh->plt_second.offset; 229 } 230 else 231 { 232 h->root.u.def.section = s; 233 h->root.u.def.value = h->plt.offset; 234 } 235 } 236 } 237 238 /* Make room for this entry. */ 239 if (use_plt_got) 240 got_s->size += htab->non_lazy_plt->plt_entry_size; 241 else 242 { 243 s->size += plt_entry_size; 244 if (second_s) 245 second_s->size += htab->non_lazy_plt->plt_entry_size; 246 247 /* We also need to make an entry in the .got.plt section, 248 which will be placed in the .got section by the linker 249 script. */ 250 htab->elf.sgotplt->size += htab->got_entry_size; 251 252 /* There should be no PLT relocation against resolved 253 undefined weak symbol in executable. */ 254 if (!resolved_to_zero) 255 { 256 /* We also need to make an entry in the .rel.plt 257 section. */ 258 htab->elf.srelplt->size += htab->sizeof_reloc; 259 htab->elf.srelplt->reloc_count++; 260 } 261 } 262 263 if (htab->target_os == is_vxworks && !bfd_link_pic (info)) 264 { 265 /* VxWorks has a second set of relocations for each PLT entry 266 in executables. They go in a separate relocation section, 267 which is processed by the kernel loader. */ 268 269 /* There are two relocations for the initial PLT entry: an 270 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an 271 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */ 272 273 asection *srelplt2 = htab->srelplt2; 274 if (h->plt.offset == plt_entry_size) 275 srelplt2->size += (htab->sizeof_reloc * 2); 276 277 /* There are two extra relocations for each subsequent PLT entry: 278 an R_386_32 relocation for the GOT entry, and an R_386_32 279 relocation for the PLT entry. */ 280 281 srelplt2->size += (htab->sizeof_reloc * 2); 282 } 283 } 284 else 285 { 286 eh->plt_got.offset = (bfd_vma) -1; 287 h->plt.offset = (bfd_vma) -1; 288 h->needs_plt = 0; 289 } 290 } 291 else 292 { 293 eh->plt_got.offset = (bfd_vma) -1; 294 h->plt.offset = (bfd_vma) -1; 295 h->needs_plt = 0; 296 } 297 298 eh->tlsdesc_got = (bfd_vma) -1; 299 300 /* For i386, if R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the 301 binary, make it a R_386_TLS_LE_32 requiring no TLS entry. For 302 x86-64, if R_X86_64_GOTTPOFF symbol is now local to the binary, 303 make it a R_X86_64_TPOFF32 requiring no GOT entry. */ 304 if (h->got.refcount > 0 305 && bfd_link_executable (info) 306 && h->dynindx == -1 307 && (elf_x86_hash_entry (h)->tls_type & GOT_TLS_IE)) 308 h->got.offset = (bfd_vma) -1; 309 else if (h->got.refcount > 0) 310 { 311 asection *s; 312 bfd_boolean dyn; 313 int tls_type = elf_x86_hash_entry (h)->tls_type; 314 315 /* Make sure this symbol is output as a dynamic symbol. 316 Undefined weak syms won't yet be marked as dynamic. */ 317 if (h->dynindx == -1 318 && !h->forced_local 319 && !resolved_to_zero 320 && h->root.type == bfd_link_hash_undefweak) 321 { 322 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 323 return FALSE; 324 } 325 326 s = htab->elf.sgot; 327 if (GOT_TLS_GDESC_P (tls_type)) 328 { 329 eh->tlsdesc_got = htab->elf.sgotplt->size 330 - elf_x86_compute_jump_table_size (htab); 331 htab->elf.sgotplt->size += 2 * htab->got_entry_size; 332 h->got.offset = (bfd_vma) -2; 333 } 334 if (! GOT_TLS_GDESC_P (tls_type) 335 || GOT_TLS_GD_P (tls_type)) 336 { 337 h->got.offset = s->size; 338 s->size += htab->got_entry_size; 339 /* R_386_TLS_GD and R_X86_64_TLSGD need 2 consecutive GOT 340 slots. */ 341 if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH) 342 s->size += htab->got_entry_size; 343 } 344 dyn = htab->elf.dynamic_sections_created; 345 /* R_386_TLS_IE_32 needs one dynamic relocation, 346 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation, 347 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we 348 need two), R_386_TLS_GD and R_X86_64_TLSGD need one if local 349 symbol and two if global. No dynamic relocation against 350 resolved undefined weak symbol in executable. */ 351 if (tls_type == GOT_TLS_IE_BOTH) 352 htab->elf.srelgot->size += 2 * htab->sizeof_reloc; 353 else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1) 354 || (tls_type & GOT_TLS_IE)) 355 htab->elf.srelgot->size += htab->sizeof_reloc; 356 else if (GOT_TLS_GD_P (tls_type)) 357 htab->elf.srelgot->size += 2 * htab->sizeof_reloc; 358 else if (! GOT_TLS_GDESC_P (tls_type) 359 && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 360 && !resolved_to_zero) 361 || h->root.type != bfd_link_hash_undefweak) 362 && (bfd_link_pic (info) 363 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))) 364 htab->elf.srelgot->size += htab->sizeof_reloc; 365 if (GOT_TLS_GDESC_P (tls_type)) 366 { 367 htab->elf.srelplt->size += htab->sizeof_reloc; 368 if (bed->target_id == X86_64_ELF_DATA) 369 htab->tlsdesc_plt = (bfd_vma) -1; 370 } 371 } 372 else 373 h->got.offset = (bfd_vma) -1; 374 375 if (eh->dyn_relocs == NULL) 376 return TRUE; 377 378 /* In the shared -Bsymbolic case, discard space allocated for 379 dynamic pc-relative relocs against symbols which turn out to be 380 defined in regular objects. For the normal shared case, discard 381 space for pc-relative relocs that have become local due to symbol 382 visibility changes. */ 383 384 if (bfd_link_pic (info)) 385 { 386 /* Relocs that use pc_count are those that appear on a call 387 insn, or certain REL relocs that can generated via assembly. 388 We want calls to protected symbols to resolve directly to the 389 function rather than going via the plt. If people want 390 function pointer comparisons to work as expected then they 391 should avoid writing weird assembly. */ 392 if (SYMBOL_CALLS_LOCAL (info, h)) 393 { 394 struct elf_dyn_relocs **pp; 395 396 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 397 { 398 p->count -= p->pc_count; 399 p->pc_count = 0; 400 if (p->count == 0) 401 *pp = p->next; 402 else 403 pp = &p->next; 404 } 405 } 406 407 if (htab->target_os == is_vxworks) 408 { 409 struct elf_dyn_relocs **pp; 410 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 411 { 412 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0) 413 *pp = p->next; 414 else 415 pp = &p->next; 416 } 417 } 418 419 /* Also discard relocs on undefined weak syms with non-default 420 visibility or in PIE. */ 421 if (eh->dyn_relocs != NULL) 422 { 423 if (h->root.type == bfd_link_hash_undefweak) 424 { 425 /* Undefined weak symbol is never bound locally in shared 426 library. */ 427 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 428 || resolved_to_zero) 429 { 430 if (bed->target_id == I386_ELF_DATA 431 && h->non_got_ref) 432 { 433 /* Keep dynamic non-GOT/non-PLT relocation so 434 that we can branch to 0 without PLT. */ 435 struct elf_dyn_relocs **pp; 436 437 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 438 if (p->pc_count == 0) 439 *pp = p->next; 440 else 441 { 442 /* Remove non-R_386_PC32 relocation. */ 443 p->count = p->pc_count; 444 pp = &p->next; 445 } 446 447 /* Make sure undefined weak symbols are output 448 as dynamic symbols in PIEs for dynamic non-GOT 449 non-PLT reloations. */ 450 if (eh->dyn_relocs != NULL 451 && !bfd_elf_link_record_dynamic_symbol (info, h)) 452 return FALSE; 453 } 454 else 455 eh->dyn_relocs = NULL; 456 } 457 else if (h->dynindx == -1 458 && !h->forced_local 459 && !bfd_elf_link_record_dynamic_symbol (info, h)) 460 return FALSE; 461 } 462 else if (bfd_link_executable (info) 463 && (h->needs_copy || eh->needs_copy) 464 && h->def_dynamic 465 && !h->def_regular) 466 { 467 /* NB: needs_copy is set only for x86-64. For PIE, 468 discard space for pc-relative relocs against symbols 469 which turn out to need copy relocs. */ 470 struct elf_dyn_relocs **pp; 471 472 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 473 { 474 if (p->pc_count != 0) 475 *pp = p->next; 476 else 477 pp = &p->next; 478 } 479 } 480 } 481 } 482 else if (ELIMINATE_COPY_RELOCS) 483 { 484 /* For the non-shared case, discard space for relocs against 485 symbols which turn out to need copy relocs or are not 486 dynamic. Keep dynamic relocations for run-time function 487 pointer initialization. */ 488 489 if ((!h->non_got_ref 490 || (h->root.type == bfd_link_hash_undefweak 491 && !resolved_to_zero)) 492 && ((h->def_dynamic 493 && !h->def_regular) 494 || (htab->elf.dynamic_sections_created 495 && (h->root.type == bfd_link_hash_undefweak 496 || h->root.type == bfd_link_hash_undefined)))) 497 { 498 /* Make sure this symbol is output as a dynamic symbol. 499 Undefined weak syms won't yet be marked as dynamic. */ 500 if (h->dynindx == -1 501 && !h->forced_local 502 && !resolved_to_zero 503 && h->root.type == bfd_link_hash_undefweak 504 && ! bfd_elf_link_record_dynamic_symbol (info, h)) 505 return FALSE; 506 507 /* If that succeeded, we know we'll be keeping all the 508 relocs. */ 509 if (h->dynindx != -1) 510 goto keep; 511 } 512 513 eh->dyn_relocs = NULL; 514 515 keep: ; 516 } 517 518 /* Finally, allocate space. */ 519 for (p = eh->dyn_relocs; p != NULL; p = p->next) 520 { 521 asection *sreloc; 522 523 sreloc = elf_section_data (p->sec)->sreloc; 524 525 BFD_ASSERT (sreloc != NULL); 526 sreloc->size += p->count * htab->sizeof_reloc; 527 } 528 529 return TRUE; 530 } 531 532 /* Find dynamic relocs for H that apply to read-only sections. */ 533 534 static asection * 535 readonly_dynrelocs (struct elf_link_hash_entry *h) 536 { 537 struct elf_dyn_relocs *p; 538 539 for (p = elf_x86_hash_entry (h)->dyn_relocs; p != NULL; p = p->next) 540 { 541 asection *s = p->sec->output_section; 542 543 if (s != NULL && (s->flags & SEC_READONLY) != 0) 544 return p->sec; 545 } 546 return NULL; 547 } 548 549 /* Set DF_TEXTREL if we find any dynamic relocs that apply to 550 read-only sections. */ 551 552 static bfd_boolean 553 maybe_set_textrel (struct elf_link_hash_entry *h, void *inf) 554 { 555 asection *sec; 556 557 if (h->root.type == bfd_link_hash_indirect) 558 return TRUE; 559 560 /* Skip local IFUNC symbols. */ 561 if (h->forced_local && h->type == STT_GNU_IFUNC) 562 return TRUE; 563 564 sec = readonly_dynrelocs (h); 565 if (sec != NULL) 566 { 567 struct bfd_link_info *info = (struct bfd_link_info *) inf; 568 569 info->flags |= DF_TEXTREL; 570 /* xgettext:c-format */ 571 info->callbacks->minfo (_("%pB: dynamic relocation against `%pT' " 572 "in read-only section `%pA'\n"), 573 sec->owner, h->root.root.string, sec); 574 575 if ((info->warn_shared_textrel && bfd_link_pic (info)) 576 || info->error_textrel) 577 /* xgettext:c-format */ 578 info->callbacks->einfo (_("%P: %pB: warning: relocation against `%s' " 579 "in read-only section `%pA'\n"), 580 sec->owner, h->root.root.string, sec); 581 582 /* Not an error, just cut short the traversal. */ 583 return FALSE; 584 } 585 return TRUE; 586 } 587 588 /* Allocate space in .plt, .got and associated reloc sections for 589 local dynamic relocs. */ 590 591 static bfd_boolean 592 elf_x86_allocate_local_dynreloc (void **slot, void *inf) 593 { 594 struct elf_link_hash_entry *h 595 = (struct elf_link_hash_entry *) *slot; 596 597 if (h->type != STT_GNU_IFUNC 598 || !h->def_regular 599 || !h->ref_regular 600 || !h->forced_local 601 || h->root.type != bfd_link_hash_defined) 602 abort (); 603 604 return elf_x86_allocate_dynrelocs (h, inf); 605 } 606 607 /* Find and/or create a hash entry for local symbol. */ 608 609 struct elf_link_hash_entry * 610 _bfd_elf_x86_get_local_sym_hash (struct elf_x86_link_hash_table *htab, 611 bfd *abfd, const Elf_Internal_Rela *rel, 612 bfd_boolean create) 613 { 614 struct elf_x86_link_hash_entry e, *ret; 615 asection *sec = abfd->sections; 616 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id, 617 htab->r_sym (rel->r_info)); 618 void **slot; 619 620 e.elf.indx = sec->id; 621 e.elf.dynstr_index = htab->r_sym (rel->r_info); 622 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h, 623 create ? INSERT : NO_INSERT); 624 625 if (!slot) 626 return NULL; 627 628 if (*slot) 629 { 630 ret = (struct elf_x86_link_hash_entry *) *slot; 631 return &ret->elf; 632 } 633 634 ret = (struct elf_x86_link_hash_entry *) 635 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory, 636 sizeof (struct elf_x86_link_hash_entry)); 637 if (ret) 638 { 639 memset (ret, 0, sizeof (*ret)); 640 ret->elf.indx = sec->id; 641 ret->elf.dynstr_index = htab->r_sym (rel->r_info); 642 ret->elf.dynindx = -1; 643 ret->plt_got.offset = (bfd_vma) -1; 644 *slot = ret; 645 } 646 return &ret->elf; 647 } 648 649 /* Create an entry in a x86 ELF linker hash table. NB: THIS MUST BE IN 650 SYNC WITH _bfd_elf_link_hash_newfunc. */ 651 652 struct bfd_hash_entry * 653 _bfd_x86_elf_link_hash_newfunc (struct bfd_hash_entry *entry, 654 struct bfd_hash_table *table, 655 const char *string) 656 { 657 /* Allocate the structure if it has not already been allocated by a 658 subclass. */ 659 if (entry == NULL) 660 { 661 entry = (struct bfd_hash_entry *) 662 bfd_hash_allocate (table, 663 sizeof (struct elf_x86_link_hash_entry)); 664 if (entry == NULL) 665 return entry; 666 } 667 668 /* Call the allocation method of the superclass. */ 669 entry = _bfd_link_hash_newfunc (entry, table, string); 670 if (entry != NULL) 671 { 672 struct elf_x86_link_hash_entry *eh 673 = (struct elf_x86_link_hash_entry *) entry; 674 struct elf_link_hash_table *htab 675 = (struct elf_link_hash_table *) table; 676 677 memset (&eh->elf.size, 0, 678 (sizeof (struct elf_x86_link_hash_entry) 679 - offsetof (struct elf_link_hash_entry, size))); 680 /* Set local fields. */ 681 eh->elf.indx = -1; 682 eh->elf.dynindx = -1; 683 eh->elf.got = htab->init_got_refcount; 684 eh->elf.plt = htab->init_plt_refcount; 685 /* Assume that we have been called by a non-ELF symbol reader. 686 This flag is then reset by the code which reads an ELF input 687 file. This ensures that a symbol created by a non-ELF symbol 688 reader will have the flag set correctly. */ 689 eh->elf.non_elf = 1; 690 eh->plt_second.offset = (bfd_vma) -1; 691 eh->plt_got.offset = (bfd_vma) -1; 692 eh->tlsdesc_got = (bfd_vma) -1; 693 eh->zero_undefweak = 1; 694 } 695 696 return entry; 697 } 698 699 /* Compute a hash of a local hash entry. We use elf_link_hash_entry 700 for local symbol so that we can handle local STT_GNU_IFUNC symbols 701 as global symbol. We reuse indx and dynstr_index for local symbol 702 hash since they aren't used by global symbols in this backend. */ 703 704 hashval_t 705 _bfd_x86_elf_local_htab_hash (const void *ptr) 706 { 707 struct elf_link_hash_entry *h 708 = (struct elf_link_hash_entry *) ptr; 709 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index); 710 } 711 712 /* Compare local hash entries. */ 713 714 int 715 _bfd_x86_elf_local_htab_eq (const void *ptr1, const void *ptr2) 716 { 717 struct elf_link_hash_entry *h1 718 = (struct elf_link_hash_entry *) ptr1; 719 struct elf_link_hash_entry *h2 720 = (struct elf_link_hash_entry *) ptr2; 721 722 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index; 723 } 724 725 /* Destroy an x86 ELF linker hash table. */ 726 727 static void 728 elf_x86_link_hash_table_free (bfd *obfd) 729 { 730 struct elf_x86_link_hash_table *htab 731 = (struct elf_x86_link_hash_table *) obfd->link.hash; 732 733 if (htab->loc_hash_table) 734 htab_delete (htab->loc_hash_table); 735 if (htab->loc_hash_memory) 736 objalloc_free ((struct objalloc *) htab->loc_hash_memory); 737 _bfd_elf_link_hash_table_free (obfd); 738 } 739 740 static bfd_boolean 741 elf_i386_is_reloc_section (const char *secname) 742 { 743 return CONST_STRNEQ (secname, ".rel"); 744 } 745 746 static bfd_boolean 747 elf_x86_64_is_reloc_section (const char *secname) 748 { 749 return CONST_STRNEQ (secname, ".rela"); 750 } 751 752 /* Create an x86 ELF linker hash table. */ 753 754 struct bfd_link_hash_table * 755 _bfd_x86_elf_link_hash_table_create (bfd *abfd) 756 { 757 struct elf_x86_link_hash_table *ret; 758 const struct elf_backend_data *bed; 759 bfd_size_type amt = sizeof (struct elf_x86_link_hash_table); 760 761 ret = (struct elf_x86_link_hash_table *) bfd_zmalloc (amt); 762 if (ret == NULL) 763 return NULL; 764 765 bed = get_elf_backend_data (abfd); 766 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, 767 _bfd_x86_elf_link_hash_newfunc, 768 sizeof (struct elf_x86_link_hash_entry), 769 bed->target_id)) 770 { 771 free (ret); 772 return NULL; 773 } 774 775 if (bed->target_id == X86_64_ELF_DATA) 776 { 777 ret->is_reloc_section = elf_x86_64_is_reloc_section; 778 ret->dt_reloc = DT_RELA; 779 ret->dt_reloc_sz = DT_RELASZ; 780 ret->dt_reloc_ent = DT_RELAENT; 781 ret->got_entry_size = 8; 782 ret->pcrel_plt = TRUE; 783 ret->tls_get_addr = "__tls_get_addr"; 784 } 785 if (ABI_64_P (abfd)) 786 { 787 ret->sizeof_reloc = sizeof (Elf64_External_Rela); 788 ret->pointer_r_type = R_X86_64_64; 789 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER; 790 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER; 791 } 792 else 793 { 794 if (bed->target_id == X86_64_ELF_DATA) 795 { 796 ret->sizeof_reloc = sizeof (Elf32_External_Rela); 797 ret->pointer_r_type = R_X86_64_32; 798 ret->dynamic_interpreter = ELFX32_DYNAMIC_INTERPRETER; 799 ret->dynamic_interpreter_size 800 = sizeof ELFX32_DYNAMIC_INTERPRETER; 801 } 802 else 803 { 804 ret->is_reloc_section = elf_i386_is_reloc_section; 805 ret->dt_reloc = DT_REL; 806 ret->dt_reloc_sz = DT_RELSZ; 807 ret->dt_reloc_ent = DT_RELENT; 808 ret->sizeof_reloc = sizeof (Elf32_External_Rel); 809 ret->got_entry_size = 4; 810 ret->pcrel_plt = FALSE; 811 ret->pointer_r_type = R_386_32; 812 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER; 813 ret->dynamic_interpreter_size 814 = sizeof ELF32_DYNAMIC_INTERPRETER; 815 ret->tls_get_addr = "___tls_get_addr"; 816 } 817 } 818 ret->target_id = bed->target_id; 819 ret->target_os = get_elf_x86_backend_data (abfd)->target_os; 820 821 ret->loc_hash_table = htab_try_create (1024, 822 _bfd_x86_elf_local_htab_hash, 823 _bfd_x86_elf_local_htab_eq, 824 NULL); 825 ret->loc_hash_memory = objalloc_create (); 826 if (!ret->loc_hash_table || !ret->loc_hash_memory) 827 { 828 elf_x86_link_hash_table_free (abfd); 829 return NULL; 830 } 831 ret->elf.root.hash_table_free = elf_x86_link_hash_table_free; 832 833 return &ret->elf.root; 834 } 835 836 /* Sort relocs into address order. */ 837 838 int 839 _bfd_x86_elf_compare_relocs (const void *ap, const void *bp) 840 { 841 const arelent *a = * (const arelent **) ap; 842 const arelent *b = * (const arelent **) bp; 843 844 if (a->address > b->address) 845 return 1; 846 else if (a->address < b->address) 847 return -1; 848 else 849 return 0; 850 } 851 852 /* Mark symbol, NAME, as locally defined by linker if it is referenced 853 and not defined in a relocatable object file. */ 854 855 static void 856 elf_x86_linker_defined (struct bfd_link_info *info, const char *name) 857 { 858 struct elf_link_hash_entry *h; 859 860 h = elf_link_hash_lookup (elf_hash_table (info), name, 861 FALSE, FALSE, FALSE); 862 if (h == NULL) 863 return; 864 865 while (h->root.type == bfd_link_hash_indirect) 866 h = (struct elf_link_hash_entry *) h->root.u.i.link; 867 868 if (h->root.type == bfd_link_hash_new 869 || h->root.type == bfd_link_hash_undefined 870 || h->root.type == bfd_link_hash_undefweak 871 || h->root.type == bfd_link_hash_common 872 || (!h->def_regular && h->def_dynamic)) 873 { 874 elf_x86_hash_entry (h)->local_ref = 2; 875 elf_x86_hash_entry (h)->linker_def = 1; 876 } 877 } 878 879 /* Hide a linker-defined symbol, NAME, with hidden visibility. */ 880 881 static void 882 elf_x86_hide_linker_defined (struct bfd_link_info *info, 883 const char *name) 884 { 885 struct elf_link_hash_entry *h; 886 887 h = elf_link_hash_lookup (elf_hash_table (info), name, 888 FALSE, FALSE, FALSE); 889 if (h == NULL) 890 return; 891 892 while (h->root.type == bfd_link_hash_indirect) 893 h = (struct elf_link_hash_entry *) h->root.u.i.link; 894 895 if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL 896 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN) 897 _bfd_elf_link_hash_hide_symbol (info, h, TRUE); 898 } 899 900 bfd_boolean 901 _bfd_x86_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info) 902 { 903 if (!bfd_link_relocatable (info)) 904 { 905 /* Check for __tls_get_addr reference. */ 906 struct elf_x86_link_hash_table *htab; 907 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 908 htab = elf_x86_hash_table (info, bed->target_id); 909 if (htab) 910 { 911 struct elf_link_hash_entry *h; 912 913 h = elf_link_hash_lookup (elf_hash_table (info), 914 htab->tls_get_addr, 915 FALSE, FALSE, FALSE); 916 if (h != NULL) 917 { 918 elf_x86_hash_entry (h)->tls_get_addr = 1; 919 920 /* Check the versioned __tls_get_addr symbol. */ 921 while (h->root.type == bfd_link_hash_indirect) 922 { 923 h = (struct elf_link_hash_entry *) h->root.u.i.link; 924 elf_x86_hash_entry (h)->tls_get_addr = 1; 925 } 926 } 927 928 /* "__ehdr_start" will be defined by linker as a hidden symbol 929 later if it is referenced and not defined. */ 930 elf_x86_linker_defined (info, "__ehdr_start"); 931 932 if (bfd_link_executable (info)) 933 { 934 /* References to __bss_start, _end and _edata should be 935 locally resolved within executables. */ 936 elf_x86_linker_defined (info, "__bss_start"); 937 elf_x86_linker_defined (info, "_end"); 938 elf_x86_linker_defined (info, "_edata"); 939 } 940 else 941 { 942 /* Hide hidden __bss_start, _end and _edata in shared 943 libraries. */ 944 elf_x86_hide_linker_defined (info, "__bss_start"); 945 elf_x86_hide_linker_defined (info, "_end"); 946 elf_x86_hide_linker_defined (info, "_edata"); 947 } 948 } 949 } 950 951 /* Invoke the regular ELF backend linker to do all the work. */ 952 return _bfd_elf_link_check_relocs (abfd, info); 953 } 954 955 /* Set the sizes of the dynamic sections. */ 956 957 bfd_boolean 958 _bfd_x86_elf_size_dynamic_sections (bfd *output_bfd, 959 struct bfd_link_info *info) 960 { 961 struct elf_x86_link_hash_table *htab; 962 bfd *dynobj; 963 asection *s; 964 bfd_boolean relocs; 965 bfd *ibfd; 966 const struct elf_backend_data *bed 967 = get_elf_backend_data (output_bfd); 968 969 htab = elf_x86_hash_table (info, bed->target_id); 970 if (htab == NULL) 971 return FALSE; 972 dynobj = htab->elf.dynobj; 973 if (dynobj == NULL) 974 abort (); 975 976 /* Set up .got offsets for local syms, and space for local dynamic 977 relocs. */ 978 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 979 { 980 bfd_signed_vma *local_got; 981 bfd_signed_vma *end_local_got; 982 char *local_tls_type; 983 bfd_vma *local_tlsdesc_gotent; 984 bfd_size_type locsymcount; 985 Elf_Internal_Shdr *symtab_hdr; 986 asection *srel; 987 988 if (! is_x86_elf (ibfd, htab)) 989 continue; 990 991 for (s = ibfd->sections; s != NULL; s = s->next) 992 { 993 struct elf_dyn_relocs *p; 994 995 for (p = ((struct elf_dyn_relocs *) 996 elf_section_data (s)->local_dynrel); 997 p != NULL; 998 p = p->next) 999 { 1000 if (!bfd_is_abs_section (p->sec) 1001 && bfd_is_abs_section (p->sec->output_section)) 1002 { 1003 /* Input section has been discarded, either because 1004 it is a copy of a linkonce section or due to 1005 linker script /DISCARD/, so we'll be discarding 1006 the relocs too. */ 1007 } 1008 else if (htab->target_os == is_vxworks 1009 && strcmp (p->sec->output_section->name, 1010 ".tls_vars") == 0) 1011 { 1012 /* Relocations in vxworks .tls_vars sections are 1013 handled specially by the loader. */ 1014 } 1015 else if (p->count != 0) 1016 { 1017 srel = elf_section_data (p->sec)->sreloc; 1018 srel->size += p->count * htab->sizeof_reloc; 1019 if ((p->sec->output_section->flags & SEC_READONLY) != 0 1020 && (info->flags & DF_TEXTREL) == 0) 1021 { 1022 info->flags |= DF_TEXTREL; 1023 if ((info->warn_shared_textrel && bfd_link_pic (info)) 1024 || info->error_textrel) 1025 /* xgettext:c-format */ 1026 info->callbacks->einfo 1027 (_("%P: %pB: warning: relocation " 1028 "in read-only section `%pA'\n"), 1029 p->sec->owner, p->sec); 1030 } 1031 } 1032 } 1033 } 1034 1035 local_got = elf_local_got_refcounts (ibfd); 1036 if (!local_got) 1037 continue; 1038 1039 symtab_hdr = &elf_symtab_hdr (ibfd); 1040 locsymcount = symtab_hdr->sh_info; 1041 end_local_got = local_got + locsymcount; 1042 local_tls_type = elf_x86_local_got_tls_type (ibfd); 1043 local_tlsdesc_gotent = elf_x86_local_tlsdesc_gotent (ibfd); 1044 s = htab->elf.sgot; 1045 srel = htab->elf.srelgot; 1046 for (; local_got < end_local_got; 1047 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent) 1048 { 1049 *local_tlsdesc_gotent = (bfd_vma) -1; 1050 if (*local_got > 0) 1051 { 1052 if (GOT_TLS_GDESC_P (*local_tls_type)) 1053 { 1054 *local_tlsdesc_gotent = htab->elf.sgotplt->size 1055 - elf_x86_compute_jump_table_size (htab); 1056 htab->elf.sgotplt->size += 2 * htab->got_entry_size; 1057 *local_got = (bfd_vma) -2; 1058 } 1059 if (! GOT_TLS_GDESC_P (*local_tls_type) 1060 || GOT_TLS_GD_P (*local_tls_type)) 1061 { 1062 *local_got = s->size; 1063 s->size += htab->got_entry_size; 1064 if (GOT_TLS_GD_P (*local_tls_type) 1065 || *local_tls_type == GOT_TLS_IE_BOTH) 1066 s->size += htab->got_entry_size; 1067 } 1068 if (bfd_link_pic (info) 1069 || GOT_TLS_GD_ANY_P (*local_tls_type) 1070 || (*local_tls_type & GOT_TLS_IE)) 1071 { 1072 if (*local_tls_type == GOT_TLS_IE_BOTH) 1073 srel->size += 2 * htab->sizeof_reloc; 1074 else if (GOT_TLS_GD_P (*local_tls_type) 1075 || ! GOT_TLS_GDESC_P (*local_tls_type)) 1076 srel->size += htab->sizeof_reloc; 1077 if (GOT_TLS_GDESC_P (*local_tls_type)) 1078 { 1079 htab->elf.srelplt->size += htab->sizeof_reloc; 1080 if (bed->target_id == X86_64_ELF_DATA) 1081 htab->tlsdesc_plt = (bfd_vma) -1; 1082 } 1083 } 1084 } 1085 else 1086 *local_got = (bfd_vma) -1; 1087 } 1088 } 1089 1090 if (htab->tls_ld_or_ldm_got.refcount > 0) 1091 { 1092 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM 1093 or R_X86_64_TLSLD relocs. */ 1094 htab->tls_ld_or_ldm_got.offset = htab->elf.sgot->size; 1095 htab->elf.sgot->size += 2 * htab->got_entry_size; 1096 htab->elf.srelgot->size += htab->sizeof_reloc; 1097 } 1098 else 1099 htab->tls_ld_or_ldm_got.offset = -1; 1100 1101 /* Allocate global sym .plt and .got entries, and space for global 1102 sym dynamic relocs. */ 1103 elf_link_hash_traverse (&htab->elf, elf_x86_allocate_dynrelocs, 1104 info); 1105 1106 /* Allocate .plt and .got entries, and space for local symbols. */ 1107 htab_traverse (htab->loc_hash_table, elf_x86_allocate_local_dynreloc, 1108 info); 1109 1110 /* For every jump slot reserved in the sgotplt, reloc_count is 1111 incremented. However, when we reserve space for TLS descriptors, 1112 it's not incremented, so in order to compute the space reserved 1113 for them, it suffices to multiply the reloc count by the jump 1114 slot size. 1115 1116 PR ld/13302: We start next_irelative_index at the end of .rela.plt 1117 so that R_{386,X86_64}_IRELATIVE entries come last. */ 1118 if (htab->elf.srelplt) 1119 { 1120 htab->next_tls_desc_index = htab->elf.srelplt->reloc_count; 1121 htab->sgotplt_jump_table_size 1122 = elf_x86_compute_jump_table_size (htab); 1123 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1; 1124 } 1125 else if (htab->elf.irelplt) 1126 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1; 1127 1128 if (htab->tlsdesc_plt) 1129 { 1130 /* NB: tlsdesc_plt is set only for x86-64. If we're not using 1131 lazy TLS relocations, don't generate the PLT and GOT entries 1132 they require. */ 1133 if ((info->flags & DF_BIND_NOW)) 1134 htab->tlsdesc_plt = 0; 1135 else 1136 { 1137 htab->tlsdesc_got = htab->elf.sgot->size; 1138 htab->elf.sgot->size += htab->got_entry_size; 1139 /* Reserve room for the initial entry. 1140 FIXME: we could probably do away with it in this case. */ 1141 if (htab->elf.splt->size == 0) 1142 htab->elf.splt->size = htab->plt.plt_entry_size; 1143 htab->tlsdesc_plt = htab->elf.splt->size; 1144 htab->elf.splt->size += htab->plt.plt_entry_size; 1145 } 1146 } 1147 1148 if (htab->elf.sgotplt) 1149 { 1150 /* Don't allocate .got.plt section if there are no GOT nor PLT 1151 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */ 1152 if ((htab->elf.hgot == NULL 1153 || !htab->got_referenced) 1154 && (htab->elf.sgotplt->size == bed->got_header_size) 1155 && (htab->elf.splt == NULL 1156 || htab->elf.splt->size == 0) 1157 && (htab->elf.sgot == NULL 1158 || htab->elf.sgot->size == 0) 1159 && (htab->elf.iplt == NULL 1160 || htab->elf.iplt->size == 0) 1161 && (htab->elf.igotplt == NULL 1162 || htab->elf.igotplt->size == 0)) 1163 { 1164 htab->elf.sgotplt->size = 0; 1165 /* Solaris requires to keep _GLOBAL_OFFSET_TABLE_ even if it 1166 isn't used. */ 1167 if (htab->elf.hgot != NULL && htab->target_os != is_solaris) 1168 { 1169 /* Remove the unused _GLOBAL_OFFSET_TABLE_ from symbol 1170 table. */ 1171 htab->elf.hgot->root.type = bfd_link_hash_undefined; 1172 htab->elf.hgot->root.u.undef.abfd 1173 = htab->elf.hgot->root.u.def.section->owner; 1174 htab->elf.hgot->root.linker_def = 0; 1175 htab->elf.hgot->ref_regular = 0; 1176 htab->elf.hgot->def_regular = 0; 1177 } 1178 } 1179 } 1180 1181 if (_bfd_elf_eh_frame_present (info)) 1182 { 1183 if (htab->plt_eh_frame != NULL 1184 && htab->elf.splt != NULL 1185 && htab->elf.splt->size != 0 1186 && !bfd_is_abs_section (htab->elf.splt->output_section)) 1187 htab->plt_eh_frame->size = htab->plt.eh_frame_plt_size; 1188 1189 if (htab->plt_got_eh_frame != NULL 1190 && htab->plt_got != NULL 1191 && htab->plt_got->size != 0 1192 && !bfd_is_abs_section (htab->plt_got->output_section)) 1193 htab->plt_got_eh_frame->size 1194 = htab->non_lazy_plt->eh_frame_plt_size; 1195 1196 /* Unwind info for the second PLT and .plt.got sections are 1197 identical. */ 1198 if (htab->plt_second_eh_frame != NULL 1199 && htab->plt_second != NULL 1200 && htab->plt_second->size != 0 1201 && !bfd_is_abs_section (htab->plt_second->output_section)) 1202 htab->plt_second_eh_frame->size 1203 = htab->non_lazy_plt->eh_frame_plt_size; 1204 } 1205 1206 /* We now have determined the sizes of the various dynamic sections. 1207 Allocate memory for them. */ 1208 relocs = FALSE; 1209 for (s = dynobj->sections; s != NULL; s = s->next) 1210 { 1211 bfd_boolean strip_section = TRUE; 1212 1213 if ((s->flags & SEC_LINKER_CREATED) == 0) 1214 continue; 1215 1216 if (s == htab->elf.splt 1217 || s == htab->elf.sgot) 1218 { 1219 /* Strip this section if we don't need it; see the 1220 comment below. */ 1221 /* We'd like to strip these sections if they aren't needed, but if 1222 we've exported dynamic symbols from them we must leave them. 1223 It's too late to tell BFD to get rid of the symbols. */ 1224 1225 if (htab->elf.hplt != NULL) 1226 strip_section = FALSE; 1227 } 1228 else if (s == htab->elf.sgotplt 1229 || s == htab->elf.iplt 1230 || s == htab->elf.igotplt 1231 || s == htab->plt_second 1232 || s == htab->plt_got 1233 || s == htab->plt_eh_frame 1234 || s == htab->plt_got_eh_frame 1235 || s == htab->plt_second_eh_frame 1236 || s == htab->elf.sdynbss 1237 || s == htab->elf.sdynrelro) 1238 { 1239 /* Strip these too. */ 1240 } 1241 else if (htab->is_reloc_section (bfd_get_section_name (dynobj, s))) 1242 { 1243 if (s->size != 0 1244 && s != htab->elf.srelplt 1245 && s != htab->srelplt2) 1246 relocs = TRUE; 1247 1248 /* We use the reloc_count field as a counter if we need 1249 to copy relocs into the output file. */ 1250 if (s != htab->elf.srelplt) 1251 s->reloc_count = 0; 1252 } 1253 else 1254 { 1255 /* It's not one of our sections, so don't allocate space. */ 1256 continue; 1257 } 1258 1259 if (s->size == 0) 1260 { 1261 /* If we don't need this section, strip it from the 1262 output file. This is mostly to handle .rel.bss and 1263 .rel.plt. We must create both sections in 1264 create_dynamic_sections, because they must be created 1265 before the linker maps input sections to output 1266 sections. The linker does that before 1267 adjust_dynamic_symbol is called, and it is that 1268 function which decides whether anything needs to go 1269 into these sections. */ 1270 if (strip_section) 1271 s->flags |= SEC_EXCLUDE; 1272 continue; 1273 } 1274 1275 if ((s->flags & SEC_HAS_CONTENTS) == 0) 1276 continue; 1277 1278 /* Allocate memory for the section contents. We use bfd_zalloc 1279 here in case unused entries are not reclaimed before the 1280 section's contents are written out. This should not happen, 1281 but this way if it does, we get a R_386_NONE or R_X86_64_NONE 1282 reloc instead of garbage. */ 1283 s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size); 1284 if (s->contents == NULL) 1285 return FALSE; 1286 } 1287 1288 if (htab->plt_eh_frame != NULL 1289 && htab->plt_eh_frame->contents != NULL) 1290 { 1291 memcpy (htab->plt_eh_frame->contents, 1292 htab->plt.eh_frame_plt, 1293 htab->plt_eh_frame->size); 1294 bfd_put_32 (dynobj, htab->elf.splt->size, 1295 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET); 1296 } 1297 1298 if (htab->plt_got_eh_frame != NULL 1299 && htab->plt_got_eh_frame->contents != NULL) 1300 { 1301 memcpy (htab->plt_got_eh_frame->contents, 1302 htab->non_lazy_plt->eh_frame_plt, 1303 htab->plt_got_eh_frame->size); 1304 bfd_put_32 (dynobj, htab->plt_got->size, 1305 (htab->plt_got_eh_frame->contents 1306 + PLT_FDE_LEN_OFFSET)); 1307 } 1308 1309 if (htab->plt_second_eh_frame != NULL 1310 && htab->plt_second_eh_frame->contents != NULL) 1311 { 1312 memcpy (htab->plt_second_eh_frame->contents, 1313 htab->non_lazy_plt->eh_frame_plt, 1314 htab->plt_second_eh_frame->size); 1315 bfd_put_32 (dynobj, htab->plt_second->size, 1316 (htab->plt_second_eh_frame->contents 1317 + PLT_FDE_LEN_OFFSET)); 1318 } 1319 1320 if (htab->elf.dynamic_sections_created) 1321 { 1322 /* Add some entries to the .dynamic section. We fill in the 1323 values later, in elf_{i386,x86_64}_finish_dynamic_sections, 1324 but we must add the entries now so that we get the correct 1325 size for the .dynamic section. The DT_DEBUG entry is filled 1326 in by the dynamic linker and used by the debugger. */ 1327 #define add_dynamic_entry(TAG, VAL) \ 1328 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 1329 1330 if (bfd_link_executable (info)) 1331 { 1332 if (!add_dynamic_entry (DT_DEBUG, 0)) 1333 return FALSE; 1334 } 1335 1336 if (htab->elf.splt->size != 0) 1337 { 1338 /* DT_PLTGOT is used by prelink even if there is no PLT 1339 relocation. */ 1340 if (!add_dynamic_entry (DT_PLTGOT, 0)) 1341 return FALSE; 1342 } 1343 1344 if (htab->elf.srelplt->size != 0) 1345 { 1346 if (!add_dynamic_entry (DT_PLTRELSZ, 0) 1347 || !add_dynamic_entry (DT_PLTREL, htab->dt_reloc) 1348 || !add_dynamic_entry (DT_JMPREL, 0)) 1349 return FALSE; 1350 } 1351 1352 if (htab->tlsdesc_plt 1353 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0) 1354 || !add_dynamic_entry (DT_TLSDESC_GOT, 0))) 1355 return FALSE; 1356 1357 if (relocs) 1358 { 1359 if (!add_dynamic_entry (htab->dt_reloc, 0) 1360 || !add_dynamic_entry (htab->dt_reloc_sz, 0) 1361 || !add_dynamic_entry (htab->dt_reloc_ent, 1362 htab->sizeof_reloc)) 1363 return FALSE; 1364 1365 /* If any dynamic relocs apply to a read-only section, 1366 then we need a DT_TEXTREL entry. */ 1367 if ((info->flags & DF_TEXTREL) == 0) 1368 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info); 1369 1370 if ((info->flags & DF_TEXTREL) != 0) 1371 { 1372 if (htab->readonly_dynrelocs_against_ifunc) 1373 { 1374 info->callbacks->einfo 1375 (_("%P%X: read-only segment has dynamic IFUNC relocations;" 1376 " recompile with -fPIC\n")); 1377 bfd_set_error (bfd_error_bad_value); 1378 return FALSE; 1379 } 1380 1381 if (!add_dynamic_entry (DT_TEXTREL, 0)) 1382 return FALSE; 1383 } 1384 } 1385 if (htab->target_os == is_vxworks 1386 && !elf_vxworks_add_dynamic_entries (output_bfd, info)) 1387 return FALSE; 1388 } 1389 #undef add_dynamic_entry 1390 1391 return TRUE; 1392 } 1393 1394 /* Finish up the x86 dynamic sections. */ 1395 1396 struct elf_x86_link_hash_table * 1397 _bfd_x86_elf_finish_dynamic_sections (bfd *output_bfd, 1398 struct bfd_link_info *info) 1399 { 1400 struct elf_x86_link_hash_table *htab; 1401 const struct elf_backend_data *bed; 1402 bfd *dynobj; 1403 asection *sdyn; 1404 bfd_byte *dyncon, *dynconend; 1405 bfd_size_type sizeof_dyn; 1406 1407 bed = get_elf_backend_data (output_bfd); 1408 htab = elf_x86_hash_table (info, bed->target_id); 1409 if (htab == NULL) 1410 return htab; 1411 1412 dynobj = htab->elf.dynobj; 1413 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 1414 1415 /* GOT is always created in setup_gnu_properties. But it may not be 1416 needed. .got.plt section may be needed for static IFUNC. */ 1417 if (htab->elf.sgotplt && htab->elf.sgotplt->size > 0) 1418 { 1419 bfd_vma dynamic_addr; 1420 1421 if (bfd_is_abs_section (htab->elf.sgotplt->output_section)) 1422 { 1423 _bfd_error_handler 1424 (_("discarded output section: `%pA'"), htab->elf.sgotplt); 1425 return NULL; 1426 } 1427 1428 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize 1429 = htab->got_entry_size; 1430 1431 dynamic_addr = (sdyn == NULL 1432 ? (bfd_vma) 0 1433 : sdyn->output_section->vma + sdyn->output_offset); 1434 1435 /* Set the first entry in the global offset table to the address 1436 of the dynamic section. Write GOT[1] and GOT[2], needed for 1437 the dynamic linker. */ 1438 if (htab->got_entry_size == 8) 1439 { 1440 bfd_put_64 (output_bfd, dynamic_addr, 1441 htab->elf.sgotplt->contents); 1442 bfd_put_64 (output_bfd, (bfd_vma) 0, 1443 htab->elf.sgotplt->contents + 8); 1444 bfd_put_64 (output_bfd, (bfd_vma) 0, 1445 htab->elf.sgotplt->contents + 8*2); 1446 } 1447 else 1448 { 1449 bfd_put_32 (output_bfd, dynamic_addr, 1450 htab->elf.sgotplt->contents); 1451 bfd_put_32 (output_bfd, 0, 1452 htab->elf.sgotplt->contents + 4); 1453 bfd_put_32 (output_bfd, 0, 1454 htab->elf.sgotplt->contents + 4*2); 1455 } 1456 } 1457 1458 if (!htab->elf.dynamic_sections_created) 1459 return htab; 1460 1461 if (sdyn == NULL || htab->elf.sgot == NULL) 1462 abort (); 1463 1464 sizeof_dyn = bed->s->sizeof_dyn; 1465 dyncon = sdyn->contents; 1466 dynconend = sdyn->contents + sdyn->size; 1467 for (; dyncon < dynconend; dyncon += sizeof_dyn) 1468 { 1469 Elf_Internal_Dyn dyn; 1470 asection *s; 1471 1472 (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn); 1473 1474 switch (dyn.d_tag) 1475 { 1476 default: 1477 if (htab->target_os == is_vxworks 1478 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn)) 1479 break; 1480 continue; 1481 1482 case DT_PLTGOT: 1483 s = htab->elf.sgotplt; 1484 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 1485 break; 1486 1487 case DT_JMPREL: 1488 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma; 1489 break; 1490 1491 case DT_PLTRELSZ: 1492 s = htab->elf.srelplt->output_section; 1493 dyn.d_un.d_val = s->size; 1494 break; 1495 1496 case DT_TLSDESC_PLT: 1497 s = htab->elf.splt; 1498 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset 1499 + htab->tlsdesc_plt; 1500 break; 1501 1502 case DT_TLSDESC_GOT: 1503 s = htab->elf.sgot; 1504 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset 1505 + htab->tlsdesc_got; 1506 break; 1507 } 1508 1509 (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon); 1510 } 1511 1512 if (htab->plt_got != NULL && htab->plt_got->size > 0) 1513 elf_section_data (htab->plt_got->output_section) 1514 ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size; 1515 1516 if (htab->plt_second != NULL && htab->plt_second->size > 0) 1517 elf_section_data (htab->plt_second->output_section) 1518 ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size; 1519 1520 /* Adjust .eh_frame for .plt section. */ 1521 if (htab->plt_eh_frame != NULL 1522 && htab->plt_eh_frame->contents != NULL) 1523 { 1524 if (htab->elf.splt != NULL 1525 && htab->elf.splt->size != 0 1526 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0 1527 && htab->elf.splt->output_section != NULL 1528 && htab->plt_eh_frame->output_section != NULL) 1529 { 1530 bfd_vma plt_start = htab->elf.splt->output_section->vma; 1531 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma 1532 + htab->plt_eh_frame->output_offset 1533 + PLT_FDE_START_OFFSET; 1534 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start, 1535 htab->plt_eh_frame->contents 1536 + PLT_FDE_START_OFFSET); 1537 } 1538 1539 if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME) 1540 { 1541 if (! _bfd_elf_write_section_eh_frame (output_bfd, info, 1542 htab->plt_eh_frame, 1543 htab->plt_eh_frame->contents)) 1544 return NULL; 1545 } 1546 } 1547 1548 /* Adjust .eh_frame for .plt.got section. */ 1549 if (htab->plt_got_eh_frame != NULL 1550 && htab->plt_got_eh_frame->contents != NULL) 1551 { 1552 if (htab->plt_got != NULL 1553 && htab->plt_got->size != 0 1554 && (htab->plt_got->flags & SEC_EXCLUDE) == 0 1555 && htab->plt_got->output_section != NULL 1556 && htab->plt_got_eh_frame->output_section != NULL) 1557 { 1558 bfd_vma plt_start = htab->plt_got->output_section->vma; 1559 bfd_vma eh_frame_start = htab->plt_got_eh_frame->output_section->vma 1560 + htab->plt_got_eh_frame->output_offset 1561 + PLT_FDE_START_OFFSET; 1562 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start, 1563 htab->plt_got_eh_frame->contents 1564 + PLT_FDE_START_OFFSET); 1565 } 1566 if (htab->plt_got_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME) 1567 { 1568 if (! _bfd_elf_write_section_eh_frame (output_bfd, info, 1569 htab->plt_got_eh_frame, 1570 htab->plt_got_eh_frame->contents)) 1571 return NULL; 1572 } 1573 } 1574 1575 /* Adjust .eh_frame for the second PLT section. */ 1576 if (htab->plt_second_eh_frame != NULL 1577 && htab->plt_second_eh_frame->contents != NULL) 1578 { 1579 if (htab->plt_second != NULL 1580 && htab->plt_second->size != 0 1581 && (htab->plt_second->flags & SEC_EXCLUDE) == 0 1582 && htab->plt_second->output_section != NULL 1583 && htab->plt_second_eh_frame->output_section != NULL) 1584 { 1585 bfd_vma plt_start = htab->plt_second->output_section->vma; 1586 bfd_vma eh_frame_start 1587 = (htab->plt_second_eh_frame->output_section->vma 1588 + htab->plt_second_eh_frame->output_offset 1589 + PLT_FDE_START_OFFSET); 1590 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start, 1591 htab->plt_second_eh_frame->contents 1592 + PLT_FDE_START_OFFSET); 1593 } 1594 if (htab->plt_second_eh_frame->sec_info_type 1595 == SEC_INFO_TYPE_EH_FRAME) 1596 { 1597 if (! _bfd_elf_write_section_eh_frame (output_bfd, info, 1598 htab->plt_second_eh_frame, 1599 htab->plt_second_eh_frame->contents)) 1600 return NULL; 1601 } 1602 } 1603 1604 if (htab->elf.sgot && htab->elf.sgot->size > 0) 1605 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize 1606 = htab->got_entry_size; 1607 1608 return htab; 1609 } 1610 1611 1612 bfd_boolean 1613 _bfd_x86_elf_always_size_sections (bfd *output_bfd, 1614 struct bfd_link_info *info) 1615 { 1616 asection *tls_sec = elf_hash_table (info)->tls_sec; 1617 1618 if (tls_sec) 1619 { 1620 struct elf_link_hash_entry *tlsbase; 1621 1622 tlsbase = elf_link_hash_lookup (elf_hash_table (info), 1623 "_TLS_MODULE_BASE_", 1624 FALSE, FALSE, FALSE); 1625 1626 if (tlsbase && tlsbase->type == STT_TLS) 1627 { 1628 struct elf_x86_link_hash_table *htab; 1629 struct bfd_link_hash_entry *bh = NULL; 1630 const struct elf_backend_data *bed 1631 = get_elf_backend_data (output_bfd); 1632 1633 htab = elf_x86_hash_table (info, bed->target_id); 1634 if (htab == NULL) 1635 return FALSE; 1636 1637 if (!(_bfd_generic_link_add_one_symbol 1638 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL, 1639 tls_sec, 0, NULL, FALSE, 1640 bed->collect, &bh))) 1641 return FALSE; 1642 1643 htab->tls_module_base = bh; 1644 1645 tlsbase = (struct elf_link_hash_entry *)bh; 1646 tlsbase->def_regular = 1; 1647 tlsbase->other = STV_HIDDEN; 1648 tlsbase->root.linker_def = 1; 1649 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE); 1650 } 1651 } 1652 1653 return TRUE; 1654 } 1655 1656 void 1657 _bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry *h, 1658 const Elf_Internal_Sym *isym, 1659 bfd_boolean definition, 1660 bfd_boolean dynamic ATTRIBUTE_UNUSED) 1661 { 1662 if (definition) 1663 { 1664 struct elf_x86_link_hash_entry *eh 1665 = (struct elf_x86_link_hash_entry *) h; 1666 eh->def_protected = (ELF_ST_VISIBILITY (isym->st_other) 1667 == STV_PROTECTED); 1668 } 1669 } 1670 1671 /* Copy the extra info we tack onto an elf_link_hash_entry. */ 1672 1673 void 1674 _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info *info, 1675 struct elf_link_hash_entry *dir, 1676 struct elf_link_hash_entry *ind) 1677 { 1678 struct elf_x86_link_hash_entry *edir, *eind; 1679 1680 edir = (struct elf_x86_link_hash_entry *) dir; 1681 eind = (struct elf_x86_link_hash_entry *) ind; 1682 1683 if (eind->dyn_relocs != NULL) 1684 { 1685 if (edir->dyn_relocs != NULL) 1686 { 1687 struct elf_dyn_relocs **pp; 1688 struct elf_dyn_relocs *p; 1689 1690 /* Add reloc counts against the indirect sym to the direct sym 1691 list. Merge any entries against the same section. */ 1692 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; ) 1693 { 1694 struct elf_dyn_relocs *q; 1695 1696 for (q = edir->dyn_relocs; q != NULL; q = q->next) 1697 if (q->sec == p->sec) 1698 { 1699 q->pc_count += p->pc_count; 1700 q->count += p->count; 1701 *pp = p->next; 1702 break; 1703 } 1704 if (q == NULL) 1705 pp = &p->next; 1706 } 1707 *pp = edir->dyn_relocs; 1708 } 1709 1710 edir->dyn_relocs = eind->dyn_relocs; 1711 eind->dyn_relocs = NULL; 1712 } 1713 1714 if (ind->root.type == bfd_link_hash_indirect 1715 && dir->got.refcount <= 0) 1716 { 1717 edir->tls_type = eind->tls_type; 1718 eind->tls_type = GOT_UNKNOWN; 1719 } 1720 1721 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will 1722 generate a R_386_COPY reloc. */ 1723 edir->gotoff_ref |= eind->gotoff_ref; 1724 1725 edir->zero_undefweak |= eind->zero_undefweak; 1726 1727 if (ELIMINATE_COPY_RELOCS 1728 && ind->root.type != bfd_link_hash_indirect 1729 && dir->dynamic_adjusted) 1730 { 1731 /* If called to transfer flags for a weakdef during processing 1732 of elf_adjust_dynamic_symbol, don't copy non_got_ref. 1733 We clear it ourselves for ELIMINATE_COPY_RELOCS. */ 1734 if (dir->versioned != versioned_hidden) 1735 dir->ref_dynamic |= ind->ref_dynamic; 1736 dir->ref_regular |= ind->ref_regular; 1737 dir->ref_regular_nonweak |= ind->ref_regular_nonweak; 1738 dir->needs_plt |= ind->needs_plt; 1739 dir->pointer_equality_needed |= ind->pointer_equality_needed; 1740 } 1741 else 1742 _bfd_elf_link_hash_copy_indirect (info, dir, ind); 1743 } 1744 1745 /* Remove undefined weak symbol from the dynamic symbol table if it 1746 is resolved to 0. */ 1747 1748 bfd_boolean 1749 _bfd_x86_elf_fixup_symbol (struct bfd_link_info *info, 1750 struct elf_link_hash_entry *h) 1751 { 1752 if (h->dynindx != -1 1753 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, elf_x86_hash_entry (h))) 1754 { 1755 h->dynindx = -1; 1756 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr, 1757 h->dynstr_index); 1758 } 1759 return TRUE; 1760 } 1761 1762 /* Change the STT_GNU_IFUNC symbol defined in position-dependent 1763 executable into the normal function symbol and set its address 1764 to its PLT entry, which should be resolved by R_*_IRELATIVE at 1765 run-time. */ 1766 1767 void 1768 _bfd_x86_elf_link_fixup_ifunc_symbol (struct bfd_link_info *info, 1769 struct elf_x86_link_hash_table *htab, 1770 struct elf_link_hash_entry *h, 1771 Elf_Internal_Sym *sym) 1772 { 1773 if (bfd_link_pde (info) 1774 && h->def_regular 1775 && h->dynindx != -1 1776 && h->plt.offset != (bfd_vma) -1 1777 && h->type == STT_GNU_IFUNC 1778 && h->pointer_equality_needed) 1779 { 1780 asection *plt_s; 1781 bfd_vma plt_offset; 1782 bfd *output_bfd = info->output_bfd; 1783 1784 if (htab->plt_second) 1785 { 1786 struct elf_x86_link_hash_entry *eh 1787 = (struct elf_x86_link_hash_entry *) h; 1788 1789 plt_s = htab->plt_second; 1790 plt_offset = eh->plt_second.offset; 1791 } 1792 else 1793 { 1794 plt_s = htab->elf.splt; 1795 plt_offset = h->plt.offset; 1796 } 1797 1798 sym->st_size = 0; 1799 sym->st_info = ELF_ST_INFO (ELF_ST_BIND (sym->st_info), STT_FUNC); 1800 sym->st_shndx 1801 = _bfd_elf_section_from_bfd_section (output_bfd, 1802 plt_s->output_section); 1803 sym->st_value = (plt_s->output_section->vma 1804 + plt_s->output_offset + plt_offset); 1805 } 1806 } 1807 1808 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */ 1809 1810 bfd_boolean 1811 _bfd_x86_elf_hash_symbol (struct elf_link_hash_entry *h) 1812 { 1813 if (h->plt.offset != (bfd_vma) -1 1814 && !h->def_regular 1815 && !h->pointer_equality_needed) 1816 return FALSE; 1817 1818 return _bfd_elf_hash_symbol (h); 1819 } 1820 1821 /* Adjust a symbol defined by a dynamic object and referenced by a 1822 regular object. The current definition is in some section of the 1823 dynamic object, but we're not including those sections. We have to 1824 change the definition to something the rest of the link can 1825 understand. */ 1826 1827 bfd_boolean 1828 _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info *info, 1829 struct elf_link_hash_entry *h) 1830 { 1831 struct elf_x86_link_hash_table *htab; 1832 asection *s, *srel; 1833 struct elf_x86_link_hash_entry *eh; 1834 struct elf_dyn_relocs *p; 1835 const struct elf_backend_data *bed 1836 = get_elf_backend_data (info->output_bfd); 1837 1838 /* STT_GNU_IFUNC symbol must go through PLT. */ 1839 if (h->type == STT_GNU_IFUNC) 1840 { 1841 /* All local STT_GNU_IFUNC references must be treate as local 1842 calls via local PLT. */ 1843 if (h->ref_regular 1844 && SYMBOL_CALLS_LOCAL (info, h)) 1845 { 1846 bfd_size_type pc_count = 0, count = 0; 1847 struct elf_dyn_relocs **pp; 1848 1849 eh = (struct elf_x86_link_hash_entry *) h; 1850 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 1851 { 1852 pc_count += p->pc_count; 1853 p->count -= p->pc_count; 1854 p->pc_count = 0; 1855 count += p->count; 1856 if (p->count == 0) 1857 *pp = p->next; 1858 else 1859 pp = &p->next; 1860 } 1861 1862 if (pc_count || count) 1863 { 1864 h->non_got_ref = 1; 1865 if (pc_count) 1866 { 1867 /* Increment PLT reference count only for PC-relative 1868 references. */ 1869 h->needs_plt = 1; 1870 if (h->plt.refcount <= 0) 1871 h->plt.refcount = 1; 1872 else 1873 h->plt.refcount += 1; 1874 } 1875 } 1876 } 1877 1878 if (h->plt.refcount <= 0) 1879 { 1880 h->plt.offset = (bfd_vma) -1; 1881 h->needs_plt = 0; 1882 } 1883 return TRUE; 1884 } 1885 1886 /* If this is a function, put it in the procedure linkage table. We 1887 will fill in the contents of the procedure linkage table later, 1888 when we know the address of the .got section. */ 1889 if (h->type == STT_FUNC 1890 || h->needs_plt) 1891 { 1892 if (h->plt.refcount <= 0 1893 || SYMBOL_CALLS_LOCAL (info, h) 1894 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 1895 && h->root.type == bfd_link_hash_undefweak)) 1896 { 1897 /* This case can occur if we saw a PLT32 reloc in an input 1898 file, but the symbol was never referred to by a dynamic 1899 object, or if all references were garbage collected. In 1900 such a case, we don't actually need to build a procedure 1901 linkage table, and we can just do a PC32 reloc instead. */ 1902 h->plt.offset = (bfd_vma) -1; 1903 h->needs_plt = 0; 1904 } 1905 1906 return TRUE; 1907 } 1908 else 1909 /* It's possible that we incorrectly decided a .plt reloc was needed 1910 * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in 1911 check_relocs. We can't decide accurately between function and 1912 non-function syms in check-relocs; Objects loaded later in 1913 the link may change h->type. So fix it now. */ 1914 h->plt.offset = (bfd_vma) -1; 1915 1916 eh = (struct elf_x86_link_hash_entry *) h; 1917 1918 /* If this is a weak symbol, and there is a real definition, the 1919 processor independent code will have arranged for us to see the 1920 real definition first, and we can just use the same value. */ 1921 if (h->is_weakalias) 1922 { 1923 struct elf_link_hash_entry *def = weakdef (h); 1924 BFD_ASSERT (def->root.type == bfd_link_hash_defined); 1925 h->root.u.def.section = def->root.u.def.section; 1926 h->root.u.def.value = def->root.u.def.value; 1927 if (ELIMINATE_COPY_RELOCS 1928 || info->nocopyreloc 1929 || SYMBOL_NO_COPYRELOC (info, eh)) 1930 { 1931 /* NB: needs_copy is always 0 for i386. */ 1932 h->non_got_ref = def->non_got_ref; 1933 eh->needs_copy = def->needs_copy; 1934 } 1935 return TRUE; 1936 } 1937 1938 /* This is a reference to a symbol defined by a dynamic object which 1939 is not a function. */ 1940 1941 /* If we are creating a shared library, we must presume that the 1942 only references to the symbol are via the global offset table. 1943 For such cases we need not do anything here; the relocations will 1944 be handled correctly by relocate_section. */ 1945 if (!bfd_link_executable (info)) 1946 return TRUE; 1947 1948 /* If there are no references to this symbol that do not use the 1949 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy 1950 reloc. NB: gotoff_ref is always 0 for x86-64. */ 1951 if (!h->non_got_ref && !eh->gotoff_ref) 1952 return TRUE; 1953 1954 /* If -z nocopyreloc was given, we won't generate them either. */ 1955 if (info->nocopyreloc || SYMBOL_NO_COPYRELOC (info, eh)) 1956 { 1957 h->non_got_ref = 0; 1958 return TRUE; 1959 } 1960 1961 htab = elf_x86_hash_table (info, bed->target_id); 1962 if (htab == NULL) 1963 return FALSE; 1964 1965 /* If there aren't any dynamic relocs in read-only sections nor 1966 R_386_GOTOFF relocation, then we can keep the dynamic relocs and 1967 avoid the copy reloc. This doesn't work on VxWorks, where we can 1968 not have dynamic relocations (other than copy and jump slot 1969 relocations) in an executable. */ 1970 if (ELIMINATE_COPY_RELOCS 1971 && (bed->target_id == X86_64_ELF_DATA 1972 || (!eh->gotoff_ref 1973 && htab->target_os != is_vxworks))) 1974 { 1975 /* If we don't find any dynamic relocs in read-only sections, 1976 then we'll be keeping the dynamic relocs and avoiding the copy 1977 reloc. */ 1978 if (!readonly_dynrelocs (h)) 1979 { 1980 h->non_got_ref = 0; 1981 return TRUE; 1982 } 1983 } 1984 1985 /* We must allocate the symbol in our .dynbss section, which will 1986 become part of the .bss section of the executable. There will be 1987 an entry for this symbol in the .dynsym section. The dynamic 1988 object will contain position independent code, so all references 1989 from the dynamic object to this symbol will go through the global 1990 offset table. The dynamic linker will use the .dynsym entry to 1991 determine the address it must put in the global offset table, so 1992 both the dynamic object and the regular object will refer to the 1993 same memory location for the variable. */ 1994 1995 /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the 1996 dynamic linker to copy the initial value out of the dynamic object 1997 and into the runtime process image. */ 1998 if ((h->root.u.def.section->flags & SEC_READONLY) != 0) 1999 { 2000 s = htab->elf.sdynrelro; 2001 srel = htab->elf.sreldynrelro; 2002 } 2003 else 2004 { 2005 s = htab->elf.sdynbss; 2006 srel = htab->elf.srelbss; 2007 } 2008 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0) 2009 { 2010 srel->size += htab->sizeof_reloc; 2011 h->needs_copy = 1; 2012 } 2013 2014 return _bfd_elf_adjust_dynamic_copy (info, h, s); 2015 } 2016 2017 void 2018 _bfd_x86_elf_hide_symbol (struct bfd_link_info *info, 2019 struct elf_link_hash_entry *h, 2020 bfd_boolean force_local) 2021 { 2022 if (h->root.type == bfd_link_hash_undefweak 2023 && info->nointerp 2024 && bfd_link_pie (info)) 2025 { 2026 /* When there is no dynamic interpreter in PIE, make the undefined 2027 weak symbol dynamic so that PC relative branch to the undefined 2028 weak symbol will land to address 0. */ 2029 struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h); 2030 if (h->plt.refcount > 0 2031 || eh->plt_got.refcount > 0) 2032 return; 2033 } 2034 2035 _bfd_elf_link_hash_hide_symbol (info, h, force_local); 2036 } 2037 2038 /* Return TRUE if a symbol is referenced locally. It is similar to 2039 SYMBOL_REFERENCES_LOCAL, but it also checks version script. It 2040 works in check_relocs. */ 2041 2042 bfd_boolean 2043 _bfd_x86_elf_link_symbol_references_local (struct bfd_link_info *info, 2044 struct elf_link_hash_entry *h) 2045 { 2046 struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h); 2047 struct elf_x86_link_hash_table *htab 2048 = (struct elf_x86_link_hash_table *) info->hash; 2049 2050 if (eh->local_ref > 1) 2051 return TRUE; 2052 2053 if (eh->local_ref == 1) 2054 return FALSE; 2055 2056 /* Unversioned symbols defined in regular objects can be forced local 2057 by linker version script. A weak undefined symbol is forced local 2058 if 2059 1. It has non-default visibility. Or 2060 2. When building executable, there is no dynamic linker. Or 2061 3. or "-z nodynamic-undefined-weak" is used. 2062 */ 2063 if (SYMBOL_REFERENCES_LOCAL (info, h) 2064 || (h->root.type == bfd_link_hash_undefweak 2065 && (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 2066 || (bfd_link_executable (info) 2067 && htab->interp == NULL) 2068 || info->dynamic_undefined_weak == 0)) 2069 || ((h->def_regular || ELF_COMMON_DEF_P (h)) 2070 && info->version_info != NULL 2071 && _bfd_elf_link_hide_sym_by_version (info, h))) 2072 { 2073 eh->local_ref = 2; 2074 return TRUE; 2075 } 2076 2077 eh->local_ref = 1; 2078 return FALSE; 2079 } 2080 2081 /* Return the section that should be marked against GC for a given 2082 relocation. */ 2083 2084 asection * 2085 _bfd_x86_elf_gc_mark_hook (asection *sec, 2086 struct bfd_link_info *info, 2087 Elf_Internal_Rela *rel, 2088 struct elf_link_hash_entry *h, 2089 Elf_Internal_Sym *sym) 2090 { 2091 /* Compiler should optimize this out. */ 2092 if (((unsigned int) R_X86_64_GNU_VTINHERIT 2093 != (unsigned int) R_386_GNU_VTINHERIT) 2094 || ((unsigned int) R_X86_64_GNU_VTENTRY 2095 != (unsigned int) R_386_GNU_VTENTRY)) 2096 abort (); 2097 2098 if (h != NULL) 2099 switch (ELF32_R_TYPE (rel->r_info)) 2100 { 2101 case R_X86_64_GNU_VTINHERIT: 2102 case R_X86_64_GNU_VTENTRY: 2103 return NULL; 2104 } 2105 2106 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 2107 } 2108 2109 static bfd_vma 2110 elf_i386_get_plt_got_vma (struct elf_x86_plt *plt_p ATTRIBUTE_UNUSED, 2111 bfd_vma off, 2112 bfd_vma offset ATTRIBUTE_UNUSED, 2113 bfd_vma got_addr) 2114 { 2115 return got_addr + off; 2116 } 2117 2118 static bfd_vma 2119 elf_x86_64_get_plt_got_vma (struct elf_x86_plt *plt_p, 2120 bfd_vma off, 2121 bfd_vma offset, 2122 bfd_vma got_addr ATTRIBUTE_UNUSED) 2123 { 2124 return plt_p->sec->vma + offset + off + plt_p->plt_got_insn_size; 2125 } 2126 2127 static bfd_boolean 2128 elf_i386_valid_plt_reloc_p (unsigned int type) 2129 { 2130 return (type == R_386_JUMP_SLOT 2131 || type == R_386_GLOB_DAT 2132 || type == R_386_IRELATIVE); 2133 } 2134 2135 static bfd_boolean 2136 elf_x86_64_valid_plt_reloc_p (unsigned int type) 2137 { 2138 return (type == R_X86_64_JUMP_SLOT 2139 || type == R_X86_64_GLOB_DAT 2140 || type == R_X86_64_IRELATIVE); 2141 } 2142 2143 long 2144 _bfd_x86_elf_get_synthetic_symtab (bfd *abfd, 2145 long count, 2146 long relsize, 2147 bfd_vma got_addr, 2148 struct elf_x86_plt plts[], 2149 asymbol **dynsyms, 2150 asymbol **ret) 2151 { 2152 long size, i, n, len; 2153 int j; 2154 unsigned int plt_got_offset, plt_entry_size; 2155 asymbol *s; 2156 bfd_byte *plt_contents; 2157 long dynrelcount; 2158 arelent **dynrelbuf, *p; 2159 char *names; 2160 const struct elf_backend_data *bed; 2161 bfd_vma (*get_plt_got_vma) (struct elf_x86_plt *, bfd_vma, bfd_vma, 2162 bfd_vma); 2163 bfd_boolean (*valid_plt_reloc_p) (unsigned int); 2164 2165 if (count == 0) 2166 return -1; 2167 2168 dynrelbuf = (arelent **) bfd_malloc (relsize); 2169 if (dynrelbuf == NULL) 2170 return -1; 2171 2172 dynrelcount = bfd_canonicalize_dynamic_reloc (abfd, dynrelbuf, 2173 dynsyms); 2174 if (dynrelcount <= 0) 2175 return -1; 2176 2177 /* Sort the relocs by address. */ 2178 qsort (dynrelbuf, dynrelcount, sizeof (arelent *), 2179 _bfd_x86_elf_compare_relocs); 2180 2181 size = count * sizeof (asymbol); 2182 2183 /* Allocate space for @plt suffixes. */ 2184 n = 0; 2185 for (i = 0; i < dynrelcount; i++) 2186 { 2187 p = dynrelbuf[i]; 2188 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt"); 2189 if (p->addend != 0) 2190 size += sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd); 2191 } 2192 2193 s = *ret = (asymbol *) bfd_zmalloc (size); 2194 if (s == NULL) 2195 goto bad_return; 2196 2197 bed = get_elf_backend_data (abfd); 2198 2199 if (bed->target_id == X86_64_ELF_DATA) 2200 { 2201 get_plt_got_vma = elf_x86_64_get_plt_got_vma; 2202 valid_plt_reloc_p = elf_x86_64_valid_plt_reloc_p; 2203 } 2204 else 2205 { 2206 get_plt_got_vma = elf_i386_get_plt_got_vma; 2207 valid_plt_reloc_p = elf_i386_valid_plt_reloc_p; 2208 if (got_addr) 2209 { 2210 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_ 2211 address. */ 2212 asection *sec = bfd_get_section_by_name (abfd, ".got.plt"); 2213 if (sec != NULL) 2214 got_addr = sec->vma; 2215 else 2216 { 2217 sec = bfd_get_section_by_name (abfd, ".got"); 2218 if (sec != NULL) 2219 got_addr = sec->vma; 2220 } 2221 2222 if (got_addr == (bfd_vma) -1) 2223 goto bad_return; 2224 } 2225 } 2226 2227 /* Check for each PLT section. */ 2228 names = (char *) (s + count); 2229 size = 0; 2230 n = 0; 2231 for (j = 0; plts[j].name != NULL; j++) 2232 if ((plt_contents = plts[j].contents) != NULL) 2233 { 2234 long k; 2235 bfd_vma offset; 2236 asection *plt; 2237 struct elf_x86_plt *plt_p = &plts[j]; 2238 2239 plt_got_offset = plt_p->plt_got_offset; 2240 plt_entry_size = plt_p->plt_entry_size; 2241 2242 plt = plt_p->sec; 2243 2244 if ((plt_p->type & plt_lazy)) 2245 { 2246 /* Skip PLT0 in lazy PLT. */ 2247 k = 1; 2248 offset = plt_entry_size; 2249 } 2250 else 2251 { 2252 k = 0; 2253 offset = 0; 2254 } 2255 2256 /* Check each PLT entry against dynamic relocations. */ 2257 for (; k < plt_p->count; k++) 2258 { 2259 int off; 2260 bfd_vma got_vma; 2261 long min, max, mid; 2262 2263 /* Get the GOT offset for i386 or the PC-relative offset 2264 for x86-64, a signed 32-bit integer. */ 2265 off = H_GET_32 (abfd, (plt_contents + offset 2266 + plt_got_offset)); 2267 got_vma = get_plt_got_vma (plt_p, off, offset, got_addr); 2268 2269 /* Binary search. */ 2270 p = dynrelbuf[0]; 2271 min = 0; 2272 max = dynrelcount; 2273 while ((min + 1) < max) 2274 { 2275 arelent *r; 2276 2277 mid = (min + max) / 2; 2278 r = dynrelbuf[mid]; 2279 if (got_vma > r->address) 2280 min = mid; 2281 else if (got_vma < r->address) 2282 max = mid; 2283 else 2284 { 2285 p = r; 2286 break; 2287 } 2288 } 2289 2290 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */ 2291 if (got_vma == p->address 2292 && p->howto != NULL 2293 && valid_plt_reloc_p (p->howto->type)) 2294 { 2295 *s = **p->sym_ptr_ptr; 2296 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL 2297 set. Since we are defining a symbol, ensure one 2298 of them is set. */ 2299 if ((s->flags & BSF_LOCAL) == 0) 2300 s->flags |= BSF_GLOBAL; 2301 s->flags |= BSF_SYNTHETIC; 2302 /* This is no longer a section symbol. */ 2303 s->flags &= ~BSF_SECTION_SYM; 2304 s->section = plt; 2305 s->the_bfd = plt->owner; 2306 s->value = offset; 2307 s->udata.p = NULL; 2308 s->name = names; 2309 len = strlen ((*p->sym_ptr_ptr)->name); 2310 memcpy (names, (*p->sym_ptr_ptr)->name, len); 2311 names += len; 2312 if (p->addend != 0) 2313 { 2314 char buf[30], *a; 2315 2316 memcpy (names, "+0x", sizeof ("+0x") - 1); 2317 names += sizeof ("+0x") - 1; 2318 bfd_sprintf_vma (abfd, buf, p->addend); 2319 for (a = buf; *a == '0'; ++a) 2320 ; 2321 size = strlen (a); 2322 memcpy (names, a, size); 2323 names += size; 2324 } 2325 memcpy (names, "@plt", sizeof ("@plt")); 2326 names += sizeof ("@plt"); 2327 n++; 2328 s++; 2329 /* There should be only one entry in PLT for a given 2330 symbol. Set howto to NULL after processing a PLT 2331 entry to guard against corrupted PLT. */ 2332 p->howto = NULL; 2333 } 2334 offset += plt_entry_size; 2335 } 2336 } 2337 2338 /* PLT entries with R_386_TLS_DESC relocations are skipped. */ 2339 if (n == 0) 2340 { 2341 bad_return: 2342 count = -1; 2343 } 2344 else 2345 count = n; 2346 2347 for (j = 0; plts[j].name != NULL; j++) 2348 if (plts[j].contents != NULL) 2349 free (plts[j].contents); 2350 2351 free (dynrelbuf); 2352 2353 return count; 2354 } 2355 2356 /* Parse x86 GNU properties. */ 2357 2358 enum elf_property_kind 2359 _bfd_x86_elf_parse_gnu_properties (bfd *abfd, unsigned int type, 2360 bfd_byte *ptr, unsigned int datasz) 2361 { 2362 elf_property *prop; 2363 2364 switch (type) 2365 { 2366 case GNU_PROPERTY_X86_ISA_1_USED: 2367 case GNU_PROPERTY_X86_ISA_1_NEEDED: 2368 case GNU_PROPERTY_X86_FEATURE_1_AND: 2369 if (datasz != 4) 2370 { 2371 _bfd_error_handler 2372 ((type == GNU_PROPERTY_X86_ISA_1_USED 2373 ? _("error: %pB: <corrupt x86 ISA used size: 0x%x>") 2374 : (type == GNU_PROPERTY_X86_ISA_1_NEEDED 2375 ? _("error: %pB: <corrupt x86 ISA needed size: 0x%x>") 2376 : _("error: %pB: <corrupt x86 feature size: 0x%x>"))), 2377 abfd, datasz); 2378 return property_corrupt; 2379 } 2380 prop = _bfd_elf_get_property (abfd, type, datasz); 2381 /* Combine properties of the same type. */ 2382 prop->u.number |= bfd_h_get_32 (abfd, ptr); 2383 prop->pr_kind = property_number; 2384 break; 2385 2386 default: 2387 return property_ignored; 2388 } 2389 2390 return property_number; 2391 } 2392 2393 /* Merge x86 GNU property BPROP with APROP. If APROP isn't NULL, 2394 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP 2395 should be merged with ABFD. */ 2396 2397 bfd_boolean 2398 _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info *info, 2399 bfd *abfd ATTRIBUTE_UNUSED, 2400 elf_property *aprop, 2401 elf_property *bprop) 2402 { 2403 unsigned int number, features; 2404 bfd_boolean updated = FALSE; 2405 unsigned int pr_type = aprop != NULL ? aprop->pr_type : bprop->pr_type; 2406 2407 switch (pr_type) 2408 { 2409 case GNU_PROPERTY_X86_ISA_1_USED: 2410 case GNU_PROPERTY_X86_ISA_1_NEEDED: 2411 if (aprop != NULL && bprop != NULL) 2412 { 2413 number = aprop->u.number; 2414 aprop->u.number = number | bprop->u.number; 2415 /* Remove the property if ISA bits are empty. */ 2416 if (aprop->u.number == 0) 2417 { 2418 aprop->pr_kind = property_remove; 2419 updated = TRUE; 2420 } 2421 else 2422 updated = number != (unsigned int) aprop->u.number; 2423 } 2424 else 2425 { 2426 /* Only one of APROP and BPROP can be NULL. */ 2427 if (aprop != NULL) 2428 { 2429 if (aprop->u.number == 0) 2430 { 2431 /* Remove APROP if ISA bits are empty. */ 2432 aprop->pr_kind = property_remove; 2433 updated = TRUE; 2434 } 2435 } 2436 else 2437 { 2438 /* Return TRUE if APROP is NULL and ISA bits of BPROP 2439 aren't empty to indicate that BPROP should be added 2440 to ABFD. */ 2441 updated = bprop->u.number != 0; 2442 } 2443 } 2444 break; 2445 2446 case GNU_PROPERTY_X86_FEATURE_1_AND: 2447 /* Only one of APROP and BPROP can be NULL: 2448 1. APROP & BPROP when both APROP and BPROP aren't NULL. 2449 2. If APROP is NULL, remove x86 feature. 2450 3. Otherwise, do nothing. 2451 */ 2452 if (aprop != NULL && bprop != NULL) 2453 { 2454 features = 0; 2455 if (info->ibt) 2456 features = GNU_PROPERTY_X86_FEATURE_1_IBT; 2457 if (info->shstk) 2458 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK; 2459 number = aprop->u.number; 2460 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and 2461 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */ 2462 aprop->u.number = (number & bprop->u.number) | features; 2463 updated = number != (unsigned int) aprop->u.number; 2464 /* Remove the property if all feature bits are cleared. */ 2465 if (aprop->u.number == 0) 2466 aprop->pr_kind = property_remove; 2467 } 2468 else 2469 { 2470 features = 0; 2471 if (info->ibt) 2472 features = GNU_PROPERTY_X86_FEATURE_1_IBT; 2473 if (info->shstk) 2474 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK; 2475 if (features) 2476 { 2477 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and 2478 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */ 2479 if (aprop != NULL) 2480 { 2481 number = aprop->u.number; 2482 aprop->u.number = number | features; 2483 updated = number != (unsigned int) aprop->u.number; 2484 } 2485 else 2486 { 2487 bprop->u.number |= features; 2488 updated = TRUE; 2489 } 2490 } 2491 else if (aprop != NULL) 2492 { 2493 aprop->pr_kind = property_remove; 2494 updated = TRUE; 2495 } 2496 } 2497 break; 2498 2499 default: 2500 /* Never should happen. */ 2501 abort (); 2502 } 2503 2504 return updated; 2505 } 2506 2507 /* Set up x86 GNU properties. Return the first relocatable ELF input 2508 with GNU properties if found. Otherwise, return NULL. */ 2509 2510 bfd * 2511 _bfd_x86_elf_link_setup_gnu_properties 2512 (struct bfd_link_info *info, struct elf_x86_init_table *init_table) 2513 { 2514 bfd_boolean normal_target; 2515 bfd_boolean lazy_plt; 2516 asection *sec, *pltsec; 2517 bfd *dynobj; 2518 bfd_boolean use_ibt_plt; 2519 unsigned int plt_alignment, features; 2520 struct elf_x86_link_hash_table *htab; 2521 bfd *pbfd; 2522 bfd *ebfd = NULL; 2523 elf_property *prop; 2524 const struct elf_backend_data *bed; 2525 unsigned int class_align = ABI_64_P (info->output_bfd) ? 3 : 2; 2526 unsigned int got_align; 2527 2528 features = 0; 2529 if (info->ibt) 2530 features = GNU_PROPERTY_X86_FEATURE_1_IBT; 2531 if (info->shstk) 2532 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK; 2533 2534 /* Find a normal input file with GNU property note. */ 2535 for (pbfd = info->input_bfds; 2536 pbfd != NULL; 2537 pbfd = pbfd->link.next) 2538 if (bfd_get_flavour (pbfd) == bfd_target_elf_flavour 2539 && bfd_count_sections (pbfd) != 0) 2540 { 2541 ebfd = pbfd; 2542 2543 if (elf_properties (pbfd) != NULL) 2544 break; 2545 } 2546 2547 if (ebfd != NULL && features) 2548 { 2549 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and 2550 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */ 2551 prop = _bfd_elf_get_property (ebfd, 2552 GNU_PROPERTY_X86_FEATURE_1_AND, 2553 4); 2554 prop->u.number |= features; 2555 prop->pr_kind = property_number; 2556 2557 /* Create the GNU property note section if needed. */ 2558 if (pbfd == NULL) 2559 { 2560 sec = bfd_make_section_with_flags (ebfd, 2561 NOTE_GNU_PROPERTY_SECTION_NAME, 2562 (SEC_ALLOC 2563 | SEC_LOAD 2564 | SEC_IN_MEMORY 2565 | SEC_READONLY 2566 | SEC_HAS_CONTENTS 2567 | SEC_DATA)); 2568 if (sec == NULL) 2569 info->callbacks->einfo (_("%F%P: failed to create GNU property section\n")); 2570 2571 if (!bfd_set_section_alignment (ebfd, sec, class_align)) 2572 { 2573 error_alignment: 2574 info->callbacks->einfo (_("%F%pA: failed to align section\n"), 2575 sec); 2576 } 2577 2578 elf_section_type (sec) = SHT_NOTE; 2579 } 2580 } 2581 2582 pbfd = _bfd_elf_link_setup_gnu_properties (info); 2583 2584 bed = get_elf_backend_data (info->output_bfd); 2585 2586 htab = elf_x86_hash_table (info, bed->target_id); 2587 if (htab == NULL) 2588 return pbfd; 2589 2590 htab->r_info = init_table->r_info; 2591 htab->r_sym = init_table->r_sym; 2592 2593 if (bfd_link_relocatable (info)) 2594 return pbfd; 2595 2596 htab->plt0_pad_byte = init_table->plt0_pad_byte; 2597 2598 use_ibt_plt = info->ibtplt || info->ibt; 2599 if (!use_ibt_plt && pbfd != NULL) 2600 { 2601 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */ 2602 elf_property_list *p; 2603 2604 /* The property list is sorted in order of type. */ 2605 for (p = elf_properties (pbfd); p; p = p->next) 2606 { 2607 if (GNU_PROPERTY_X86_FEATURE_1_AND == p->property.pr_type) 2608 { 2609 use_ibt_plt = !!(p->property.u.number 2610 & GNU_PROPERTY_X86_FEATURE_1_IBT); 2611 break; 2612 } 2613 else if (GNU_PROPERTY_X86_FEATURE_1_AND < p->property.pr_type) 2614 break; 2615 } 2616 } 2617 2618 dynobj = htab->elf.dynobj; 2619 2620 /* Set htab->elf.dynobj here so that there is no need to check and 2621 set it in check_relocs. */ 2622 if (dynobj == NULL) 2623 { 2624 if (pbfd != NULL) 2625 { 2626 htab->elf.dynobj = pbfd; 2627 dynobj = pbfd; 2628 } 2629 else 2630 { 2631 bfd *abfd; 2632 2633 /* Find a normal input file to hold linker created 2634 sections. */ 2635 for (abfd = info->input_bfds; 2636 abfd != NULL; 2637 abfd = abfd->link.next) 2638 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour 2639 && (abfd->flags 2640 & (DYNAMIC | BFD_LINKER_CREATED | BFD_PLUGIN)) == 0 2641 && bed->relocs_compatible (abfd->xvec, 2642 info->output_bfd->xvec)) 2643 { 2644 htab->elf.dynobj = abfd; 2645 dynobj = abfd; 2646 break; 2647 } 2648 } 2649 } 2650 2651 /* Return if there are no normal input files. */ 2652 if (dynobj == NULL) 2653 return pbfd; 2654 2655 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may 2656 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for 2657 canonical function address. */ 2658 htab->plt.has_plt0 = 1; 2659 normal_target = htab->target_os == is_normal; 2660 2661 if (normal_target) 2662 { 2663 if (use_ibt_plt) 2664 { 2665 htab->lazy_plt = init_table->lazy_ibt_plt; 2666 htab->non_lazy_plt = init_table->non_lazy_ibt_plt; 2667 } 2668 else 2669 { 2670 htab->lazy_plt = init_table->lazy_plt; 2671 htab->non_lazy_plt = init_table->non_lazy_plt; 2672 } 2673 } 2674 else 2675 { 2676 htab->lazy_plt = init_table->lazy_plt; 2677 htab->non_lazy_plt = NULL; 2678 } 2679 2680 pltsec = htab->elf.splt; 2681 2682 /* If the non-lazy PLT is available, use it for all PLT entries if 2683 there are no PLT0 or no .plt section. */ 2684 if (htab->non_lazy_plt != NULL 2685 && (!htab->plt.has_plt0 || pltsec == NULL)) 2686 { 2687 lazy_plt = FALSE; 2688 if (bfd_link_pic (info)) 2689 htab->plt.plt_entry = htab->non_lazy_plt->pic_plt_entry; 2690 else 2691 htab->plt.plt_entry = htab->non_lazy_plt->plt_entry; 2692 htab->plt.plt_entry_size = htab->non_lazy_plt->plt_entry_size; 2693 htab->plt.plt_got_offset = htab->non_lazy_plt->plt_got_offset; 2694 htab->plt.plt_got_insn_size 2695 = htab->non_lazy_plt->plt_got_insn_size; 2696 htab->plt.eh_frame_plt_size 2697 = htab->non_lazy_plt->eh_frame_plt_size; 2698 htab->plt.eh_frame_plt = htab->non_lazy_plt->eh_frame_plt; 2699 } 2700 else 2701 { 2702 lazy_plt = TRUE; 2703 if (bfd_link_pic (info)) 2704 { 2705 htab->plt.plt0_entry = htab->lazy_plt->pic_plt0_entry; 2706 htab->plt.plt_entry = htab->lazy_plt->pic_plt_entry; 2707 } 2708 else 2709 { 2710 htab->plt.plt0_entry = htab->lazy_plt->plt0_entry; 2711 htab->plt.plt_entry = htab->lazy_plt->plt_entry; 2712 } 2713 htab->plt.plt_entry_size = htab->lazy_plt->plt_entry_size; 2714 htab->plt.plt_got_offset = htab->lazy_plt->plt_got_offset; 2715 htab->plt.plt_got_insn_size 2716 = htab->lazy_plt->plt_got_insn_size; 2717 htab->plt.eh_frame_plt_size 2718 = htab->lazy_plt->eh_frame_plt_size; 2719 htab->plt.eh_frame_plt = htab->lazy_plt->eh_frame_plt; 2720 } 2721 2722 if (htab->target_os == is_vxworks 2723 && !elf_vxworks_create_dynamic_sections (dynobj, info, 2724 &htab->srelplt2)) 2725 { 2726 info->callbacks->einfo (_("%F%P: failed to create VxWorks dynamic sections\n")); 2727 return pbfd; 2728 } 2729 2730 /* Since create_dynamic_sections isn't always called, but GOT 2731 relocations need GOT relocations, create them here so that we 2732 don't need to do it in check_relocs. */ 2733 if (htab->elf.sgot == NULL 2734 && !_bfd_elf_create_got_section (dynobj, info)) 2735 info->callbacks->einfo (_("%F%P: failed to create GOT sections\n")); 2736 2737 got_align = (bed->target_id == X86_64_ELF_DATA) ? 3 : 2; 2738 2739 /* Align .got and .got.plt sections to their entry size. Do it here 2740 instead of in create_dynamic_sections so that they are always 2741 properly aligned even if create_dynamic_sections isn't called. */ 2742 sec = htab->elf.sgot; 2743 if (!bfd_set_section_alignment (dynobj, sec, got_align)) 2744 goto error_alignment; 2745 2746 sec = htab->elf.sgotplt; 2747 if (!bfd_set_section_alignment (dynobj, sec, got_align)) 2748 goto error_alignment; 2749 2750 /* Create the ifunc sections here so that check_relocs can be 2751 simplified. */ 2752 if (!_bfd_elf_create_ifunc_sections (dynobj, info)) 2753 info->callbacks->einfo (_("%F%P: failed to create ifunc sections\n")); 2754 2755 plt_alignment = bfd_log2 (htab->plt.plt_entry_size); 2756 2757 if (pltsec != NULL) 2758 { 2759 /* Whe creating executable, set the contents of the .interp 2760 section to the interpreter. */ 2761 if (bfd_link_executable (info) && !info->nointerp) 2762 { 2763 asection *s = bfd_get_linker_section (dynobj, ".interp"); 2764 if (s == NULL) 2765 abort (); 2766 s->size = htab->dynamic_interpreter_size; 2767 s->contents = (unsigned char *) htab->dynamic_interpreter; 2768 htab->interp = s; 2769 } 2770 2771 /* Don't change PLT section alignment for NaCl since it uses 2772 64-byte PLT entry and sets PLT section alignment to 32 2773 bytes. Don't create additional PLT sections for NaCl. */ 2774 if (normal_target) 2775 { 2776 flagword pltflags = (bed->dynamic_sec_flags 2777 | SEC_ALLOC 2778 | SEC_CODE 2779 | SEC_LOAD 2780 | SEC_READONLY); 2781 unsigned int non_lazy_plt_alignment 2782 = bfd_log2 (htab->non_lazy_plt->plt_entry_size); 2783 2784 sec = pltsec; 2785 if (!bfd_set_section_alignment (sec->owner, sec, 2786 plt_alignment)) 2787 goto error_alignment; 2788 2789 /* Create the GOT procedure linkage table. */ 2790 sec = bfd_make_section_anyway_with_flags (dynobj, 2791 ".plt.got", 2792 pltflags); 2793 if (sec == NULL) 2794 info->callbacks->einfo (_("%F%P: failed to create GOT PLT section\n")); 2795 2796 if (!bfd_set_section_alignment (dynobj, sec, 2797 non_lazy_plt_alignment)) 2798 goto error_alignment; 2799 2800 htab->plt_got = sec; 2801 2802 if (lazy_plt) 2803 { 2804 sec = NULL; 2805 2806 if (use_ibt_plt) 2807 { 2808 /* Create the second PLT for Intel IBT support. IBT 2809 PLT is supported only for non-NaCl target and is 2810 is needed only for lazy binding. */ 2811 sec = bfd_make_section_anyway_with_flags (dynobj, 2812 ".plt.sec", 2813 pltflags); 2814 if (sec == NULL) 2815 info->callbacks->einfo (_("%F%P: failed to create IBT-enabled PLT section\n")); 2816 2817 if (!bfd_set_section_alignment (dynobj, sec, 2818 plt_alignment)) 2819 goto error_alignment; 2820 } 2821 else if (info->bndplt && ABI_64_P (dynobj)) 2822 { 2823 /* Create the second PLT for Intel MPX support. MPX 2824 PLT is supported only for non-NaCl target in 64-bit 2825 mode and is needed only for lazy binding. */ 2826 sec = bfd_make_section_anyway_with_flags (dynobj, 2827 ".plt.sec", 2828 pltflags); 2829 if (sec == NULL) 2830 info->callbacks->einfo (_("%F%P: failed to create BND PLT section\n")); 2831 2832 if (!bfd_set_section_alignment (dynobj, sec, 2833 non_lazy_plt_alignment)) 2834 goto error_alignment; 2835 } 2836 2837 htab->plt_second = sec; 2838 } 2839 } 2840 2841 if (!info->no_ld_generated_unwind_info) 2842 { 2843 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY 2844 | SEC_HAS_CONTENTS | SEC_IN_MEMORY 2845 | SEC_LINKER_CREATED); 2846 2847 sec = bfd_make_section_anyway_with_flags (dynobj, 2848 ".eh_frame", 2849 flags); 2850 if (sec == NULL) 2851 info->callbacks->einfo (_("%F%P: failed to create PLT .eh_frame section\n")); 2852 2853 if (!bfd_set_section_alignment (dynobj, sec, class_align)) 2854 goto error_alignment; 2855 2856 htab->plt_eh_frame = sec; 2857 2858 if (htab->plt_got != NULL) 2859 { 2860 sec = bfd_make_section_anyway_with_flags (dynobj, 2861 ".eh_frame", 2862 flags); 2863 if (sec == NULL) 2864 info->callbacks->einfo (_("%F%P: failed to create GOT PLT .eh_frame section\n")); 2865 2866 if (!bfd_set_section_alignment (dynobj, sec, class_align)) 2867 goto error_alignment; 2868 2869 htab->plt_got_eh_frame = sec; 2870 } 2871 2872 if (htab->plt_second != NULL) 2873 { 2874 sec = bfd_make_section_anyway_with_flags (dynobj, 2875 ".eh_frame", 2876 flags); 2877 if (sec == NULL) 2878 info->callbacks->einfo (_("%F%P: failed to create the second PLT .eh_frame section\n")); 2879 2880 if (!bfd_set_section_alignment (dynobj, sec, class_align)) 2881 goto error_alignment; 2882 2883 htab->plt_second_eh_frame = sec; 2884 } 2885 } 2886 } 2887 2888 if (normal_target) 2889 { 2890 /* The .iplt section is used for IFUNC symbols in static 2891 executables. */ 2892 sec = htab->elf.iplt; 2893 if (sec != NULL 2894 && !bfd_set_section_alignment (sec->owner, sec, 2895 plt_alignment)) 2896 goto error_alignment; 2897 } 2898 2899 return pbfd; 2900 } 2901
Indexes created Thu Apr 23 00:23:13 UTC 2026