elfxx-x86.c revision 1.1.1.3
1 /* x86 specific support for ELF 2 Copyright (C) 2017-2020 Free Software Foundation, Inc. 3 4 This file is part of BFD, the Binary File Descriptor library. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 19 MA 02110-1301, USA. */ 20 21 #include "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_section_name (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 /* NB: Initially, the iplt section has minimal alignment to 1279 avoid moving dot of the following section backwards when 1280 it is empty. Update its section alignment now since it 1281 is non-empty. */ 1282 if (s == htab->elf.iplt) 1283 bfd_set_section_alignment (s, htab->plt.iplt_alignment); 1284 1285 /* Allocate memory for the section contents. We use bfd_zalloc 1286 here in case unused entries are not reclaimed before the 1287 section's contents are written out. This should not happen, 1288 but this way if it does, we get a R_386_NONE or R_X86_64_NONE 1289 reloc instead of garbage. */ 1290 s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size); 1291 if (s->contents == NULL) 1292 return FALSE; 1293 } 1294 1295 if (htab->plt_eh_frame != NULL 1296 && htab->plt_eh_frame->contents != NULL) 1297 { 1298 memcpy (htab->plt_eh_frame->contents, 1299 htab->plt.eh_frame_plt, 1300 htab->plt_eh_frame->size); 1301 bfd_put_32 (dynobj, htab->elf.splt->size, 1302 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET); 1303 } 1304 1305 if (htab->plt_got_eh_frame != NULL 1306 && htab->plt_got_eh_frame->contents != NULL) 1307 { 1308 memcpy (htab->plt_got_eh_frame->contents, 1309 htab->non_lazy_plt->eh_frame_plt, 1310 htab->plt_got_eh_frame->size); 1311 bfd_put_32 (dynobj, htab->plt_got->size, 1312 (htab->plt_got_eh_frame->contents 1313 + PLT_FDE_LEN_OFFSET)); 1314 } 1315 1316 if (htab->plt_second_eh_frame != NULL 1317 && htab->plt_second_eh_frame->contents != NULL) 1318 { 1319 memcpy (htab->plt_second_eh_frame->contents, 1320 htab->non_lazy_plt->eh_frame_plt, 1321 htab->plt_second_eh_frame->size); 1322 bfd_put_32 (dynobj, htab->plt_second->size, 1323 (htab->plt_second_eh_frame->contents 1324 + PLT_FDE_LEN_OFFSET)); 1325 } 1326 1327 if (htab->elf.dynamic_sections_created) 1328 { 1329 /* Add some entries to the .dynamic section. We fill in the 1330 values later, in elf_{i386,x86_64}_finish_dynamic_sections, 1331 but we must add the entries now so that we get the correct 1332 size for the .dynamic section. The DT_DEBUG entry is filled 1333 in by the dynamic linker and used by the debugger. */ 1334 #define add_dynamic_entry(TAG, VAL) \ 1335 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 1336 1337 if (bfd_link_executable (info)) 1338 { 1339 if (!add_dynamic_entry (DT_DEBUG, 0)) 1340 return FALSE; 1341 } 1342 1343 if (htab->elf.splt->size != 0) 1344 { 1345 /* DT_PLTGOT is used by prelink even if there is no PLT 1346 relocation. */ 1347 if (!add_dynamic_entry (DT_PLTGOT, 0)) 1348 return FALSE; 1349 } 1350 1351 if (htab->elf.srelplt->size != 0) 1352 { 1353 if (!add_dynamic_entry (DT_PLTRELSZ, 0) 1354 || !add_dynamic_entry (DT_PLTREL, htab->dt_reloc) 1355 || !add_dynamic_entry (DT_JMPREL, 0)) 1356 return FALSE; 1357 } 1358 1359 if (htab->tlsdesc_plt 1360 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0) 1361 || !add_dynamic_entry (DT_TLSDESC_GOT, 0))) 1362 return FALSE; 1363 1364 if (relocs) 1365 { 1366 if (!add_dynamic_entry (htab->dt_reloc, 0) 1367 || !add_dynamic_entry (htab->dt_reloc_sz, 0) 1368 || !add_dynamic_entry (htab->dt_reloc_ent, 1369 htab->sizeof_reloc)) 1370 return FALSE; 1371 1372 /* If any dynamic relocs apply to a read-only section, 1373 then we need a DT_TEXTREL entry. */ 1374 if ((info->flags & DF_TEXTREL) == 0) 1375 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info); 1376 1377 if ((info->flags & DF_TEXTREL) != 0) 1378 { 1379 if (htab->readonly_dynrelocs_against_ifunc) 1380 { 1381 info->callbacks->einfo 1382 (_("%P%X: read-only segment has dynamic IFUNC relocations;" 1383 " recompile with %s\n"), 1384 bfd_link_dll (info) ? "-fPIC" : "-fPIE"); 1385 bfd_set_error (bfd_error_bad_value); 1386 return FALSE; 1387 } 1388 1389 if (!add_dynamic_entry (DT_TEXTREL, 0)) 1390 return FALSE; 1391 } 1392 } 1393 if (htab->target_os == is_vxworks 1394 && !elf_vxworks_add_dynamic_entries (output_bfd, info)) 1395 return FALSE; 1396 } 1397 #undef add_dynamic_entry 1398 1399 return TRUE; 1400 } 1401 1402 /* Finish up the x86 dynamic sections. */ 1403 1404 struct elf_x86_link_hash_table * 1405 _bfd_x86_elf_finish_dynamic_sections (bfd *output_bfd, 1406 struct bfd_link_info *info) 1407 { 1408 struct elf_x86_link_hash_table *htab; 1409 const struct elf_backend_data *bed; 1410 bfd *dynobj; 1411 asection *sdyn; 1412 bfd_byte *dyncon, *dynconend; 1413 bfd_size_type sizeof_dyn; 1414 1415 bed = get_elf_backend_data (output_bfd); 1416 htab = elf_x86_hash_table (info, bed->target_id); 1417 if (htab == NULL) 1418 return htab; 1419 1420 dynobj = htab->elf.dynobj; 1421 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 1422 1423 /* GOT is always created in setup_gnu_properties. But it may not be 1424 needed. .got.plt section may be needed for static IFUNC. */ 1425 if (htab->elf.sgotplt && htab->elf.sgotplt->size > 0) 1426 { 1427 bfd_vma dynamic_addr; 1428 1429 if (bfd_is_abs_section (htab->elf.sgotplt->output_section)) 1430 { 1431 _bfd_error_handler 1432 (_("discarded output section: `%pA'"), htab->elf.sgotplt); 1433 return NULL; 1434 } 1435 1436 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize 1437 = htab->got_entry_size; 1438 1439 dynamic_addr = (sdyn == NULL 1440 ? (bfd_vma) 0 1441 : sdyn->output_section->vma + sdyn->output_offset); 1442 1443 /* Set the first entry in the global offset table to the address 1444 of the dynamic section. Write GOT[1] and GOT[2], needed for 1445 the dynamic linker. */ 1446 if (htab->got_entry_size == 8) 1447 { 1448 bfd_put_64 (output_bfd, dynamic_addr, 1449 htab->elf.sgotplt->contents); 1450 bfd_put_64 (output_bfd, (bfd_vma) 0, 1451 htab->elf.sgotplt->contents + 8); 1452 bfd_put_64 (output_bfd, (bfd_vma) 0, 1453 htab->elf.sgotplt->contents + 8*2); 1454 } 1455 else 1456 { 1457 bfd_put_32 (output_bfd, dynamic_addr, 1458 htab->elf.sgotplt->contents); 1459 bfd_put_32 (output_bfd, 0, 1460 htab->elf.sgotplt->contents + 4); 1461 bfd_put_32 (output_bfd, 0, 1462 htab->elf.sgotplt->contents + 4*2); 1463 } 1464 } 1465 1466 if (!htab->elf.dynamic_sections_created) 1467 return htab; 1468 1469 if (sdyn == NULL || htab->elf.sgot == NULL) 1470 abort (); 1471 1472 sizeof_dyn = bed->s->sizeof_dyn; 1473 dyncon = sdyn->contents; 1474 dynconend = sdyn->contents + sdyn->size; 1475 for (; dyncon < dynconend; dyncon += sizeof_dyn) 1476 { 1477 Elf_Internal_Dyn dyn; 1478 asection *s; 1479 1480 (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn); 1481 1482 switch (dyn.d_tag) 1483 { 1484 default: 1485 if (htab->target_os == is_vxworks 1486 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn)) 1487 break; 1488 continue; 1489 1490 case DT_PLTGOT: 1491 s = htab->elf.sgotplt; 1492 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 1493 break; 1494 1495 case DT_JMPREL: 1496 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma; 1497 break; 1498 1499 case DT_PLTRELSZ: 1500 s = htab->elf.srelplt->output_section; 1501 dyn.d_un.d_val = s->size; 1502 break; 1503 1504 case DT_TLSDESC_PLT: 1505 s = htab->elf.splt; 1506 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset 1507 + htab->tlsdesc_plt; 1508 break; 1509 1510 case DT_TLSDESC_GOT: 1511 s = htab->elf.sgot; 1512 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset 1513 + htab->tlsdesc_got; 1514 break; 1515 } 1516 1517 (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon); 1518 } 1519 1520 if (htab->plt_got != NULL && htab->plt_got->size > 0) 1521 elf_section_data (htab->plt_got->output_section) 1522 ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size; 1523 1524 if (htab->plt_second != NULL && htab->plt_second->size > 0) 1525 elf_section_data (htab->plt_second->output_section) 1526 ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size; 1527 1528 /* Adjust .eh_frame for .plt section. */ 1529 if (htab->plt_eh_frame != NULL 1530 && htab->plt_eh_frame->contents != NULL) 1531 { 1532 if (htab->elf.splt != NULL 1533 && htab->elf.splt->size != 0 1534 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0 1535 && htab->elf.splt->output_section != NULL 1536 && htab->plt_eh_frame->output_section != NULL) 1537 { 1538 bfd_vma plt_start = htab->elf.splt->output_section->vma; 1539 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma 1540 + htab->plt_eh_frame->output_offset 1541 + PLT_FDE_START_OFFSET; 1542 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start, 1543 htab->plt_eh_frame->contents 1544 + PLT_FDE_START_OFFSET); 1545 } 1546 1547 if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME) 1548 { 1549 if (! _bfd_elf_write_section_eh_frame (output_bfd, info, 1550 htab->plt_eh_frame, 1551 htab->plt_eh_frame->contents)) 1552 return NULL; 1553 } 1554 } 1555 1556 /* Adjust .eh_frame for .plt.got section. */ 1557 if (htab->plt_got_eh_frame != NULL 1558 && htab->plt_got_eh_frame->contents != NULL) 1559 { 1560 if (htab->plt_got != NULL 1561 && htab->plt_got->size != 0 1562 && (htab->plt_got->flags & SEC_EXCLUDE) == 0 1563 && htab->plt_got->output_section != NULL 1564 && htab->plt_got_eh_frame->output_section != NULL) 1565 { 1566 bfd_vma plt_start = htab->plt_got->output_section->vma; 1567 bfd_vma eh_frame_start = htab->plt_got_eh_frame->output_section->vma 1568 + htab->plt_got_eh_frame->output_offset 1569 + PLT_FDE_START_OFFSET; 1570 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start, 1571 htab->plt_got_eh_frame->contents 1572 + PLT_FDE_START_OFFSET); 1573 } 1574 if (htab->plt_got_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME) 1575 { 1576 if (! _bfd_elf_write_section_eh_frame (output_bfd, info, 1577 htab->plt_got_eh_frame, 1578 htab->plt_got_eh_frame->contents)) 1579 return NULL; 1580 } 1581 } 1582 1583 /* Adjust .eh_frame for the second PLT section. */ 1584 if (htab->plt_second_eh_frame != NULL 1585 && htab->plt_second_eh_frame->contents != NULL) 1586 { 1587 if (htab->plt_second != NULL 1588 && htab->plt_second->size != 0 1589 && (htab->plt_second->flags & SEC_EXCLUDE) == 0 1590 && htab->plt_second->output_section != NULL 1591 && htab->plt_second_eh_frame->output_section != NULL) 1592 { 1593 bfd_vma plt_start = htab->plt_second->output_section->vma; 1594 bfd_vma eh_frame_start 1595 = (htab->plt_second_eh_frame->output_section->vma 1596 + htab->plt_second_eh_frame->output_offset 1597 + PLT_FDE_START_OFFSET); 1598 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start, 1599 htab->plt_second_eh_frame->contents 1600 + PLT_FDE_START_OFFSET); 1601 } 1602 if (htab->plt_second_eh_frame->sec_info_type 1603 == SEC_INFO_TYPE_EH_FRAME) 1604 { 1605 if (! _bfd_elf_write_section_eh_frame (output_bfd, info, 1606 htab->plt_second_eh_frame, 1607 htab->plt_second_eh_frame->contents)) 1608 return NULL; 1609 } 1610 } 1611 1612 if (htab->elf.sgot && htab->elf.sgot->size > 0) 1613 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize 1614 = htab->got_entry_size; 1615 1616 return htab; 1617 } 1618 1619 1620 bfd_boolean 1621 _bfd_x86_elf_always_size_sections (bfd *output_bfd, 1622 struct bfd_link_info *info) 1623 { 1624 asection *tls_sec = elf_hash_table (info)->tls_sec; 1625 1626 if (tls_sec) 1627 { 1628 struct elf_link_hash_entry *tlsbase; 1629 1630 tlsbase = elf_link_hash_lookup (elf_hash_table (info), 1631 "_TLS_MODULE_BASE_", 1632 FALSE, FALSE, FALSE); 1633 1634 if (tlsbase && tlsbase->type == STT_TLS) 1635 { 1636 struct elf_x86_link_hash_table *htab; 1637 struct bfd_link_hash_entry *bh = NULL; 1638 const struct elf_backend_data *bed 1639 = get_elf_backend_data (output_bfd); 1640 1641 htab = elf_x86_hash_table (info, bed->target_id); 1642 if (htab == NULL) 1643 return FALSE; 1644 1645 if (!(_bfd_generic_link_add_one_symbol 1646 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL, 1647 tls_sec, 0, NULL, FALSE, 1648 bed->collect, &bh))) 1649 return FALSE; 1650 1651 htab->tls_module_base = bh; 1652 1653 tlsbase = (struct elf_link_hash_entry *)bh; 1654 tlsbase->def_regular = 1; 1655 tlsbase->other = STV_HIDDEN; 1656 tlsbase->root.linker_def = 1; 1657 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE); 1658 } 1659 } 1660 1661 return TRUE; 1662 } 1663 1664 void 1665 _bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry *h, 1666 const Elf_Internal_Sym *isym, 1667 bfd_boolean definition, 1668 bfd_boolean dynamic ATTRIBUTE_UNUSED) 1669 { 1670 if (definition) 1671 { 1672 struct elf_x86_link_hash_entry *eh 1673 = (struct elf_x86_link_hash_entry *) h; 1674 eh->def_protected = (ELF_ST_VISIBILITY (isym->st_other) 1675 == STV_PROTECTED); 1676 } 1677 } 1678 1679 /* Copy the extra info we tack onto an elf_link_hash_entry. */ 1680 1681 void 1682 _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info *info, 1683 struct elf_link_hash_entry *dir, 1684 struct elf_link_hash_entry *ind) 1685 { 1686 struct elf_x86_link_hash_entry *edir, *eind; 1687 1688 edir = (struct elf_x86_link_hash_entry *) dir; 1689 eind = (struct elf_x86_link_hash_entry *) ind; 1690 1691 if (eind->dyn_relocs != NULL) 1692 { 1693 if (edir->dyn_relocs != NULL) 1694 { 1695 struct elf_dyn_relocs **pp; 1696 struct elf_dyn_relocs *p; 1697 1698 /* Add reloc counts against the indirect sym to the direct sym 1699 list. Merge any entries against the same section. */ 1700 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; ) 1701 { 1702 struct elf_dyn_relocs *q; 1703 1704 for (q = edir->dyn_relocs; q != NULL; q = q->next) 1705 if (q->sec == p->sec) 1706 { 1707 q->pc_count += p->pc_count; 1708 q->count += p->count; 1709 *pp = p->next; 1710 break; 1711 } 1712 if (q == NULL) 1713 pp = &p->next; 1714 } 1715 *pp = edir->dyn_relocs; 1716 } 1717 1718 edir->dyn_relocs = eind->dyn_relocs; 1719 eind->dyn_relocs = NULL; 1720 } 1721 1722 if (ind->root.type == bfd_link_hash_indirect 1723 && dir->got.refcount <= 0) 1724 { 1725 edir->tls_type = eind->tls_type; 1726 eind->tls_type = GOT_UNKNOWN; 1727 } 1728 1729 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will 1730 generate a R_386_COPY reloc. */ 1731 edir->gotoff_ref |= eind->gotoff_ref; 1732 1733 edir->zero_undefweak |= eind->zero_undefweak; 1734 1735 if (ELIMINATE_COPY_RELOCS 1736 && ind->root.type != bfd_link_hash_indirect 1737 && dir->dynamic_adjusted) 1738 { 1739 /* If called to transfer flags for a weakdef during processing 1740 of elf_adjust_dynamic_symbol, don't copy non_got_ref. 1741 We clear it ourselves for ELIMINATE_COPY_RELOCS. */ 1742 if (dir->versioned != versioned_hidden) 1743 dir->ref_dynamic |= ind->ref_dynamic; 1744 dir->ref_regular |= ind->ref_regular; 1745 dir->ref_regular_nonweak |= ind->ref_regular_nonweak; 1746 dir->needs_plt |= ind->needs_plt; 1747 dir->pointer_equality_needed |= ind->pointer_equality_needed; 1748 } 1749 else 1750 _bfd_elf_link_hash_copy_indirect (info, dir, ind); 1751 } 1752 1753 /* Remove undefined weak symbol from the dynamic symbol table if it 1754 is resolved to 0. */ 1755 1756 bfd_boolean 1757 _bfd_x86_elf_fixup_symbol (struct bfd_link_info *info, 1758 struct elf_link_hash_entry *h) 1759 { 1760 if (h->dynindx != -1 1761 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, elf_x86_hash_entry (h))) 1762 { 1763 h->dynindx = -1; 1764 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr, 1765 h->dynstr_index); 1766 } 1767 return TRUE; 1768 } 1769 1770 /* Change the STT_GNU_IFUNC symbol defined in position-dependent 1771 executable into the normal function symbol and set its address 1772 to its PLT entry, which should be resolved by R_*_IRELATIVE at 1773 run-time. */ 1774 1775 void 1776 _bfd_x86_elf_link_fixup_ifunc_symbol (struct bfd_link_info *info, 1777 struct elf_x86_link_hash_table *htab, 1778 struct elf_link_hash_entry *h, 1779 Elf_Internal_Sym *sym) 1780 { 1781 if (bfd_link_pde (info) 1782 && h->def_regular 1783 && h->dynindx != -1 1784 && h->plt.offset != (bfd_vma) -1 1785 && h->type == STT_GNU_IFUNC 1786 && h->pointer_equality_needed) 1787 { 1788 asection *plt_s; 1789 bfd_vma plt_offset; 1790 bfd *output_bfd = info->output_bfd; 1791 1792 if (htab->plt_second) 1793 { 1794 struct elf_x86_link_hash_entry *eh 1795 = (struct elf_x86_link_hash_entry *) h; 1796 1797 plt_s = htab->plt_second; 1798 plt_offset = eh->plt_second.offset; 1799 } 1800 else 1801 { 1802 plt_s = htab->elf.splt; 1803 plt_offset = h->plt.offset; 1804 } 1805 1806 sym->st_size = 0; 1807 sym->st_info = ELF_ST_INFO (ELF_ST_BIND (sym->st_info), STT_FUNC); 1808 sym->st_shndx 1809 = _bfd_elf_section_from_bfd_section (output_bfd, 1810 plt_s->output_section); 1811 sym->st_value = (plt_s->output_section->vma 1812 + plt_s->output_offset + plt_offset); 1813 } 1814 } 1815 1816 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */ 1817 1818 bfd_boolean 1819 _bfd_x86_elf_hash_symbol (struct elf_link_hash_entry *h) 1820 { 1821 if (h->plt.offset != (bfd_vma) -1 1822 && !h->def_regular 1823 && !h->pointer_equality_needed) 1824 return FALSE; 1825 1826 return _bfd_elf_hash_symbol (h); 1827 } 1828 1829 /* Adjust a symbol defined by a dynamic object and referenced by a 1830 regular object. The current definition is in some section of the 1831 dynamic object, but we're not including those sections. We have to 1832 change the definition to something the rest of the link can 1833 understand. */ 1834 1835 bfd_boolean 1836 _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info *info, 1837 struct elf_link_hash_entry *h) 1838 { 1839 struct elf_x86_link_hash_table *htab; 1840 asection *s, *srel; 1841 struct elf_x86_link_hash_entry *eh; 1842 struct elf_dyn_relocs *p; 1843 const struct elf_backend_data *bed 1844 = get_elf_backend_data (info->output_bfd); 1845 1846 /* STT_GNU_IFUNC symbol must go through PLT. */ 1847 if (h->type == STT_GNU_IFUNC) 1848 { 1849 /* All local STT_GNU_IFUNC references must be treate as local 1850 calls via local PLT. */ 1851 if (h->ref_regular 1852 && SYMBOL_CALLS_LOCAL (info, h)) 1853 { 1854 bfd_size_type pc_count = 0, count = 0; 1855 struct elf_dyn_relocs **pp; 1856 1857 eh = (struct elf_x86_link_hash_entry *) h; 1858 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 1859 { 1860 pc_count += p->pc_count; 1861 p->count -= p->pc_count; 1862 p->pc_count = 0; 1863 count += p->count; 1864 if (p->count == 0) 1865 *pp = p->next; 1866 else 1867 pp = &p->next; 1868 } 1869 1870 if (pc_count || count) 1871 { 1872 h->non_got_ref = 1; 1873 if (pc_count) 1874 { 1875 /* Increment PLT reference count only for PC-relative 1876 references. */ 1877 h->needs_plt = 1; 1878 if (h->plt.refcount <= 0) 1879 h->plt.refcount = 1; 1880 else 1881 h->plt.refcount += 1; 1882 } 1883 } 1884 } 1885 1886 if (h->plt.refcount <= 0) 1887 { 1888 h->plt.offset = (bfd_vma) -1; 1889 h->needs_plt = 0; 1890 } 1891 return TRUE; 1892 } 1893 1894 /* If this is a function, put it in the procedure linkage table. We 1895 will fill in the contents of the procedure linkage table later, 1896 when we know the address of the .got section. */ 1897 if (h->type == STT_FUNC 1898 || h->needs_plt) 1899 { 1900 if (h->plt.refcount <= 0 1901 || SYMBOL_CALLS_LOCAL (info, h) 1902 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 1903 && h->root.type == bfd_link_hash_undefweak)) 1904 { 1905 /* This case can occur if we saw a PLT32 reloc in an input 1906 file, but the symbol was never referred to by a dynamic 1907 object, or if all references were garbage collected. In 1908 such a case, we don't actually need to build a procedure 1909 linkage table, and we can just do a PC32 reloc instead. */ 1910 h->plt.offset = (bfd_vma) -1; 1911 h->needs_plt = 0; 1912 } 1913 1914 return TRUE; 1915 } 1916 else 1917 /* It's possible that we incorrectly decided a .plt reloc was needed 1918 * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in 1919 check_relocs. We can't decide accurately between function and 1920 non-function syms in check-relocs; Objects loaded later in 1921 the link may change h->type. So fix it now. */ 1922 h->plt.offset = (bfd_vma) -1; 1923 1924 eh = (struct elf_x86_link_hash_entry *) h; 1925 1926 /* If this is a weak symbol, and there is a real definition, the 1927 processor independent code will have arranged for us to see the 1928 real definition first, and we can just use the same value. */ 1929 if (h->is_weakalias) 1930 { 1931 struct elf_link_hash_entry *def = weakdef (h); 1932 BFD_ASSERT (def->root.type == bfd_link_hash_defined); 1933 h->root.u.def.section = def->root.u.def.section; 1934 h->root.u.def.value = def->root.u.def.value; 1935 if (ELIMINATE_COPY_RELOCS 1936 || info->nocopyreloc 1937 || SYMBOL_NO_COPYRELOC (info, eh)) 1938 { 1939 /* NB: needs_copy is always 0 for i386. */ 1940 h->non_got_ref = def->non_got_ref; 1941 eh->needs_copy = def->needs_copy; 1942 } 1943 return TRUE; 1944 } 1945 1946 /* This is a reference to a symbol defined by a dynamic object which 1947 is not a function. */ 1948 1949 /* If we are creating a shared library, we must presume that the 1950 only references to the symbol are via the global offset table. 1951 For such cases we need not do anything here; the relocations will 1952 be handled correctly by relocate_section. */ 1953 if (!bfd_link_executable (info)) 1954 return TRUE; 1955 1956 /* If there are no references to this symbol that do not use the 1957 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy 1958 reloc. NB: gotoff_ref is always 0 for x86-64. */ 1959 if (!h->non_got_ref && !eh->gotoff_ref) 1960 return TRUE; 1961 1962 /* If -z nocopyreloc was given, we won't generate them either. */ 1963 if (info->nocopyreloc || SYMBOL_NO_COPYRELOC (info, eh)) 1964 { 1965 h->non_got_ref = 0; 1966 return TRUE; 1967 } 1968 1969 htab = elf_x86_hash_table (info, bed->target_id); 1970 if (htab == NULL) 1971 return FALSE; 1972 1973 /* If there aren't any dynamic relocs in read-only sections nor 1974 R_386_GOTOFF relocation, then we can keep the dynamic relocs and 1975 avoid the copy reloc. This doesn't work on VxWorks, where we can 1976 not have dynamic relocations (other than copy and jump slot 1977 relocations) in an executable. */ 1978 if (ELIMINATE_COPY_RELOCS 1979 && (bed->target_id == X86_64_ELF_DATA 1980 || (!eh->gotoff_ref 1981 && htab->target_os != is_vxworks))) 1982 { 1983 /* If we don't find any dynamic relocs in read-only sections, 1984 then we'll be keeping the dynamic relocs and avoiding the copy 1985 reloc. */ 1986 if (!readonly_dynrelocs (h)) 1987 { 1988 h->non_got_ref = 0; 1989 return TRUE; 1990 } 1991 } 1992 1993 /* We must allocate the symbol in our .dynbss section, which will 1994 become part of the .bss section of the executable. There will be 1995 an entry for this symbol in the .dynsym section. The dynamic 1996 object will contain position independent code, so all references 1997 from the dynamic object to this symbol will go through the global 1998 offset table. The dynamic linker will use the .dynsym entry to 1999 determine the address it must put in the global offset table, so 2000 both the dynamic object and the regular object will refer to the 2001 same memory location for the variable. */ 2002 2003 /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the 2004 dynamic linker to copy the initial value out of the dynamic object 2005 and into the runtime process image. */ 2006 if ((h->root.u.def.section->flags & SEC_READONLY) != 0) 2007 { 2008 s = htab->elf.sdynrelro; 2009 srel = htab->elf.sreldynrelro; 2010 } 2011 else 2012 { 2013 s = htab->elf.sdynbss; 2014 srel = htab->elf.srelbss; 2015 } 2016 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0) 2017 { 2018 srel->size += htab->sizeof_reloc; 2019 h->needs_copy = 1; 2020 } 2021 2022 return _bfd_elf_adjust_dynamic_copy (info, h, s); 2023 } 2024 2025 void 2026 _bfd_x86_elf_hide_symbol (struct bfd_link_info *info, 2027 struct elf_link_hash_entry *h, 2028 bfd_boolean force_local) 2029 { 2030 if (h->root.type == bfd_link_hash_undefweak 2031 && info->nointerp 2032 && bfd_link_pie (info)) 2033 { 2034 /* When there is no dynamic interpreter in PIE, make the undefined 2035 weak symbol dynamic so that PC relative branch to the undefined 2036 weak symbol will land to address 0. */ 2037 struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h); 2038 if (h->plt.refcount > 0 2039 || eh->plt_got.refcount > 0) 2040 return; 2041 } 2042 2043 _bfd_elf_link_hash_hide_symbol (info, h, force_local); 2044 } 2045 2046 /* Return TRUE if a symbol is referenced locally. It is similar to 2047 SYMBOL_REFERENCES_LOCAL, but it also checks version script. It 2048 works in check_relocs. */ 2049 2050 bfd_boolean 2051 _bfd_x86_elf_link_symbol_references_local (struct bfd_link_info *info, 2052 struct elf_link_hash_entry *h) 2053 { 2054 struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h); 2055 struct elf_x86_link_hash_table *htab 2056 = (struct elf_x86_link_hash_table *) info->hash; 2057 2058 if (eh->local_ref > 1) 2059 return TRUE; 2060 2061 if (eh->local_ref == 1) 2062 return FALSE; 2063 2064 /* Unversioned symbols defined in regular objects can be forced local 2065 by linker version script. A weak undefined symbol is forced local 2066 if 2067 1. It has non-default visibility. Or 2068 2. When building executable, there is no dynamic linker. Or 2069 3. or "-z nodynamic-undefined-weak" is used. 2070 */ 2071 if (SYMBOL_REFERENCES_LOCAL (info, h) 2072 || (h->root.type == bfd_link_hash_undefweak 2073 && (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 2074 || (bfd_link_executable (info) 2075 && htab->interp == NULL) 2076 || info->dynamic_undefined_weak == 0)) 2077 || ((h->def_regular || ELF_COMMON_DEF_P (h)) 2078 && info->version_info != NULL 2079 && _bfd_elf_link_hide_sym_by_version (info, h))) 2080 { 2081 eh->local_ref = 2; 2082 return TRUE; 2083 } 2084 2085 eh->local_ref = 1; 2086 return FALSE; 2087 } 2088 2089 /* Return the section that should be marked against GC for a given 2090 relocation. */ 2091 2092 asection * 2093 _bfd_x86_elf_gc_mark_hook (asection *sec, 2094 struct bfd_link_info *info, 2095 Elf_Internal_Rela *rel, 2096 struct elf_link_hash_entry *h, 2097 Elf_Internal_Sym *sym) 2098 { 2099 /* Compiler should optimize this out. */ 2100 if (((unsigned int) R_X86_64_GNU_VTINHERIT 2101 != (unsigned int) R_386_GNU_VTINHERIT) 2102 || ((unsigned int) R_X86_64_GNU_VTENTRY 2103 != (unsigned int) R_386_GNU_VTENTRY)) 2104 abort (); 2105 2106 if (h != NULL) 2107 switch (ELF32_R_TYPE (rel->r_info)) 2108 { 2109 case R_X86_64_GNU_VTINHERIT: 2110 case R_X86_64_GNU_VTENTRY: 2111 return NULL; 2112 } 2113 2114 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 2115 } 2116 2117 static bfd_vma 2118 elf_i386_get_plt_got_vma (struct elf_x86_plt *plt_p ATTRIBUTE_UNUSED, 2119 bfd_vma off, 2120 bfd_vma offset ATTRIBUTE_UNUSED, 2121 bfd_vma got_addr) 2122 { 2123 return got_addr + off; 2124 } 2125 2126 static bfd_vma 2127 elf_x86_64_get_plt_got_vma (struct elf_x86_plt *plt_p, 2128 bfd_vma off, 2129 bfd_vma offset, 2130 bfd_vma got_addr ATTRIBUTE_UNUSED) 2131 { 2132 return plt_p->sec->vma + offset + off + plt_p->plt_got_insn_size; 2133 } 2134 2135 static bfd_boolean 2136 elf_i386_valid_plt_reloc_p (unsigned int type) 2137 { 2138 return (type == R_386_JUMP_SLOT 2139 || type == R_386_GLOB_DAT 2140 || type == R_386_IRELATIVE); 2141 } 2142 2143 static bfd_boolean 2144 elf_x86_64_valid_plt_reloc_p (unsigned int type) 2145 { 2146 return (type == R_X86_64_JUMP_SLOT 2147 || type == R_X86_64_GLOB_DAT 2148 || type == R_X86_64_IRELATIVE); 2149 } 2150 2151 long 2152 _bfd_x86_elf_get_synthetic_symtab (bfd *abfd, 2153 long count, 2154 long relsize, 2155 bfd_vma got_addr, 2156 struct elf_x86_plt plts[], 2157 asymbol **dynsyms, 2158 asymbol **ret) 2159 { 2160 long size, i, n, len; 2161 int j; 2162 unsigned int plt_got_offset, plt_entry_size; 2163 asymbol *s; 2164 bfd_byte *plt_contents; 2165 long dynrelcount; 2166 arelent **dynrelbuf, *p; 2167 char *names; 2168 const struct elf_backend_data *bed; 2169 bfd_vma (*get_plt_got_vma) (struct elf_x86_plt *, bfd_vma, bfd_vma, 2170 bfd_vma); 2171 bfd_boolean (*valid_plt_reloc_p) (unsigned int); 2172 2173 dynrelbuf = NULL; 2174 if (count == 0) 2175 goto bad_return; 2176 2177 dynrelbuf = (arelent **) bfd_malloc (relsize); 2178 if (dynrelbuf == NULL) 2179 goto bad_return; 2180 2181 dynrelcount = bfd_canonicalize_dynamic_reloc (abfd, dynrelbuf, 2182 dynsyms); 2183 if (dynrelcount <= 0) 2184 goto bad_return; 2185 2186 /* Sort the relocs by address. */ 2187 qsort (dynrelbuf, dynrelcount, sizeof (arelent *), 2188 _bfd_x86_elf_compare_relocs); 2189 2190 size = count * sizeof (asymbol); 2191 2192 /* Allocate space for @plt suffixes. */ 2193 n = 0; 2194 for (i = 0; i < dynrelcount; i++) 2195 { 2196 p = dynrelbuf[i]; 2197 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt"); 2198 if (p->addend != 0) 2199 size += sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd); 2200 } 2201 2202 s = *ret = (asymbol *) bfd_zmalloc (size); 2203 if (s == NULL) 2204 goto bad_return; 2205 2206 bed = get_elf_backend_data (abfd); 2207 2208 if (bed->target_id == X86_64_ELF_DATA) 2209 { 2210 get_plt_got_vma = elf_x86_64_get_plt_got_vma; 2211 valid_plt_reloc_p = elf_x86_64_valid_plt_reloc_p; 2212 } 2213 else 2214 { 2215 get_plt_got_vma = elf_i386_get_plt_got_vma; 2216 valid_plt_reloc_p = elf_i386_valid_plt_reloc_p; 2217 if (got_addr) 2218 { 2219 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_ 2220 address. */ 2221 asection *sec = bfd_get_section_by_name (abfd, ".got.plt"); 2222 if (sec != NULL) 2223 got_addr = sec->vma; 2224 else 2225 { 2226 sec = bfd_get_section_by_name (abfd, ".got"); 2227 if (sec != NULL) 2228 got_addr = sec->vma; 2229 } 2230 2231 if (got_addr == (bfd_vma) -1) 2232 goto bad_return; 2233 } 2234 } 2235 2236 /* Check for each PLT section. */ 2237 names = (char *) (s + count); 2238 size = 0; 2239 n = 0; 2240 for (j = 0; plts[j].name != NULL; j++) 2241 if ((plt_contents = plts[j].contents) != NULL) 2242 { 2243 long k; 2244 bfd_vma offset; 2245 asection *plt; 2246 struct elf_x86_plt *plt_p = &plts[j]; 2247 2248 plt_got_offset = plt_p->plt_got_offset; 2249 plt_entry_size = plt_p->plt_entry_size; 2250 2251 plt = plt_p->sec; 2252 2253 if ((plt_p->type & plt_lazy)) 2254 { 2255 /* Skip PLT0 in lazy PLT. */ 2256 k = 1; 2257 offset = plt_entry_size; 2258 } 2259 else 2260 { 2261 k = 0; 2262 offset = 0; 2263 } 2264 2265 /* Check each PLT entry against dynamic relocations. */ 2266 for (; k < plt_p->count; k++) 2267 { 2268 int off; 2269 bfd_vma got_vma; 2270 long min, max, mid; 2271 2272 /* Get the GOT offset for i386 or the PC-relative offset 2273 for x86-64, a signed 32-bit integer. */ 2274 off = H_GET_32 (abfd, (plt_contents + offset 2275 + plt_got_offset)); 2276 got_vma = get_plt_got_vma (plt_p, off, offset, got_addr); 2277 2278 /* Binary search. */ 2279 p = dynrelbuf[0]; 2280 min = 0; 2281 max = dynrelcount; 2282 while ((min + 1) < max) 2283 { 2284 arelent *r; 2285 2286 mid = (min + max) / 2; 2287 r = dynrelbuf[mid]; 2288 if (got_vma > r->address) 2289 min = mid; 2290 else if (got_vma < r->address) 2291 max = mid; 2292 else 2293 { 2294 p = r; 2295 break; 2296 } 2297 } 2298 2299 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */ 2300 if (got_vma == p->address 2301 && p->howto != NULL 2302 && valid_plt_reloc_p (p->howto->type)) 2303 { 2304 *s = **p->sym_ptr_ptr; 2305 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL 2306 set. Since we are defining a symbol, ensure one 2307 of them is set. */ 2308 if ((s->flags & BSF_LOCAL) == 0) 2309 s->flags |= BSF_GLOBAL; 2310 s->flags |= BSF_SYNTHETIC; 2311 /* This is no longer a section symbol. */ 2312 s->flags &= ~BSF_SECTION_SYM; 2313 s->section = plt; 2314 s->the_bfd = plt->owner; 2315 s->value = offset; 2316 s->udata.p = NULL; 2317 s->name = names; 2318 len = strlen ((*p->sym_ptr_ptr)->name); 2319 memcpy (names, (*p->sym_ptr_ptr)->name, len); 2320 names += len; 2321 if (p->addend != 0) 2322 { 2323 char buf[30], *a; 2324 2325 memcpy (names, "+0x", sizeof ("+0x") - 1); 2326 names += sizeof ("+0x") - 1; 2327 bfd_sprintf_vma (abfd, buf, p->addend); 2328 for (a = buf; *a == '0'; ++a) 2329 ; 2330 size = strlen (a); 2331 memcpy (names, a, size); 2332 names += size; 2333 } 2334 memcpy (names, "@plt", sizeof ("@plt")); 2335 names += sizeof ("@plt"); 2336 n++; 2337 s++; 2338 /* There should be only one entry in PLT for a given 2339 symbol. Set howto to NULL after processing a PLT 2340 entry to guard against corrupted PLT. */ 2341 p->howto = NULL; 2342 } 2343 offset += plt_entry_size; 2344 } 2345 } 2346 2347 /* PLT entries with R_386_TLS_DESC relocations are skipped. */ 2348 if (n == 0) 2349 { 2350 bad_return: 2351 count = -1; 2352 } 2353 else 2354 count = n; 2355 2356 for (j = 0; plts[j].name != NULL; j++) 2357 if (plts[j].contents != NULL) 2358 free (plts[j].contents); 2359 2360 free (dynrelbuf); 2361 2362 return count; 2363 } 2364 2365 /* Parse x86 GNU properties. */ 2366 2367 enum elf_property_kind 2368 _bfd_x86_elf_parse_gnu_properties (bfd *abfd, unsigned int type, 2369 bfd_byte *ptr, unsigned int datasz) 2370 { 2371 elf_property *prop; 2372 2373 if (type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED 2374 || type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED 2375 || (type >= GNU_PROPERTY_X86_UINT32_AND_LO 2376 && type <= GNU_PROPERTY_X86_UINT32_AND_HI) 2377 || (type >= GNU_PROPERTY_X86_UINT32_OR_LO 2378 && type <= GNU_PROPERTY_X86_UINT32_OR_HI) 2379 || (type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO 2380 && type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI)) 2381 { 2382 if (datasz != 4) 2383 { 2384 _bfd_error_handler 2385 (_("error: %pB: <corrupt x86 property (0x%x) size: 0x%x>"), 2386 abfd, type, datasz); 2387 return property_corrupt; 2388 } 2389 prop = _bfd_elf_get_property (abfd, type, datasz); 2390 prop->u.number |= bfd_h_get_32 (abfd, ptr); 2391 prop->pr_kind = property_number; 2392 return property_number; 2393 } 2394 2395 return property_ignored; 2396 } 2397 2398 /* Merge x86 GNU property BPROP with APROP. If APROP isn't NULL, 2399 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP 2400 should be merged with ABFD. */ 2401 2402 bfd_boolean 2403 _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info *info, 2404 bfd *abfd ATTRIBUTE_UNUSED, 2405 bfd *bbfd ATTRIBUTE_UNUSED, 2406 elf_property *aprop, 2407 elf_property *bprop) 2408 { 2409 unsigned int number, features; 2410 bfd_boolean updated = FALSE; 2411 unsigned int pr_type = aprop != NULL ? aprop->pr_type : bprop->pr_type; 2412 2413 if (pr_type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED 2414 || (pr_type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO 2415 && pr_type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI)) 2416 { 2417 if (aprop == NULL || bprop == NULL) 2418 { 2419 /* Only one of APROP and BPROP can be NULL. */ 2420 if (aprop != NULL) 2421 { 2422 /* Remove this property since the other input file doesn't 2423 have it. */ 2424 aprop->pr_kind = property_remove; 2425 updated = TRUE; 2426 } 2427 } 2428 else 2429 { 2430 number = aprop->u.number; 2431 aprop->u.number = number | bprop->u.number; 2432 updated = number != (unsigned int) aprop->u.number; 2433 } 2434 return updated; 2435 } 2436 else if (pr_type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED 2437 || (pr_type >= GNU_PROPERTY_X86_UINT32_OR_LO 2438 && pr_type <= GNU_PROPERTY_X86_UINT32_OR_HI)) 2439 { 2440 if (aprop != NULL && bprop != NULL) 2441 { 2442 number = aprop->u.number; 2443 aprop->u.number = number | bprop->u.number; 2444 /* Remove the property if all bits are empty. */ 2445 if (aprop->u.number == 0) 2446 { 2447 aprop->pr_kind = property_remove; 2448 updated = TRUE; 2449 } 2450 else 2451 updated = number != (unsigned int) aprop->u.number; 2452 } 2453 else 2454 { 2455 /* Only one of APROP and BPROP can be NULL. */ 2456 if (aprop != NULL) 2457 { 2458 if (aprop->u.number == 0) 2459 { 2460 /* Remove APROP if all bits are empty. */ 2461 aprop->pr_kind = property_remove; 2462 updated = TRUE; 2463 } 2464 } 2465 else 2466 { 2467 /* Return TRUE if APROP is NULL and all bits of BPROP 2468 aren't empty to indicate that BPROP should be added 2469 to ABFD. */ 2470 updated = bprop->u.number != 0; 2471 } 2472 } 2473 return updated; 2474 } 2475 else if (pr_type >= GNU_PROPERTY_X86_UINT32_AND_LO 2476 && pr_type <= GNU_PROPERTY_X86_UINT32_AND_HI) 2477 { 2478 /* Only one of APROP and BPROP can be NULL: 2479 1. APROP & BPROP when both APROP and BPROP aren't NULL. 2480 2. If APROP is NULL, remove x86 feature. 2481 3. Otherwise, do nothing. 2482 */ 2483 const struct elf_backend_data *bed 2484 = get_elf_backend_data (info->output_bfd); 2485 struct elf_x86_link_hash_table *htab 2486 = elf_x86_hash_table (info, bed->target_id); 2487 if (!htab) 2488 abort (); 2489 if (aprop != NULL && bprop != NULL) 2490 { 2491 features = 0; 2492 if (htab->params->ibt) 2493 features = GNU_PROPERTY_X86_FEATURE_1_IBT; 2494 if (htab->params->shstk) 2495 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK; 2496 number = aprop->u.number; 2497 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and 2498 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */ 2499 aprop->u.number = (number & bprop->u.number) | features; 2500 updated = number != (unsigned int) aprop->u.number; 2501 /* Remove the property if all feature bits are cleared. */ 2502 if (aprop->u.number == 0) 2503 aprop->pr_kind = property_remove; 2504 } 2505 else 2506 { 2507 /* There should be no AND properties since some input doesn't 2508 have them. Set IBT and SHSTK properties for -z ibt and -z 2509 shstk if needed. */ 2510 features = 0; 2511 if (htab->params->ibt) 2512 features = GNU_PROPERTY_X86_FEATURE_1_IBT; 2513 if (htab->params->shstk) 2514 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK; 2515 if (features) 2516 { 2517 if (aprop != NULL) 2518 { 2519 updated = features != (unsigned int) aprop->u.number; 2520 aprop->u.number = features; 2521 } 2522 else 2523 { 2524 updated = TRUE; 2525 bprop->u.number = features; 2526 } 2527 } 2528 else if (aprop != NULL) 2529 { 2530 aprop->pr_kind = property_remove; 2531 updated = TRUE; 2532 } 2533 } 2534 return updated; 2535 } 2536 else 2537 { 2538 /* Never should happen. */ 2539 abort (); 2540 } 2541 2542 return updated; 2543 } 2544 2545 /* Set up x86 GNU properties. Return the first relocatable ELF input 2546 with GNU properties if found. Otherwise, return NULL. */ 2547 2548 bfd * 2549 _bfd_x86_elf_link_setup_gnu_properties 2550 (struct bfd_link_info *info, struct elf_x86_init_table *init_table) 2551 { 2552 bfd_boolean normal_target; 2553 bfd_boolean lazy_plt; 2554 asection *sec, *pltsec; 2555 bfd *dynobj; 2556 bfd_boolean use_ibt_plt; 2557 unsigned int plt_alignment, features; 2558 struct elf_x86_link_hash_table *htab; 2559 bfd *pbfd; 2560 bfd *ebfd = NULL; 2561 elf_property *prop; 2562 const struct elf_backend_data *bed; 2563 unsigned int class_align = ABI_64_P (info->output_bfd) ? 3 : 2; 2564 unsigned int got_align; 2565 2566 /* Find a normal input file with GNU property note. */ 2567 for (pbfd = info->input_bfds; 2568 pbfd != NULL; 2569 pbfd = pbfd->link.next) 2570 if (bfd_get_flavour (pbfd) == bfd_target_elf_flavour 2571 && bfd_count_sections (pbfd) != 0) 2572 { 2573 ebfd = pbfd; 2574 2575 if (elf_properties (pbfd) != NULL) 2576 break; 2577 } 2578 2579 bed = get_elf_backend_data (info->output_bfd); 2580 2581 htab = elf_x86_hash_table (info, bed->target_id); 2582 if (htab == NULL) 2583 return pbfd; 2584 2585 features = 0; 2586 if (htab->params->ibt) 2587 { 2588 features = GNU_PROPERTY_X86_FEATURE_1_IBT; 2589 htab->params->cet_report &= ~cet_report_ibt; 2590 } 2591 if (htab->params->shstk) 2592 { 2593 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK; 2594 htab->params->cet_report &= ~cet_report_shstk; 2595 } 2596 if (!(htab->params->cet_report & (cet_report_ibt | cet_report_shstk))) 2597 htab->params->cet_report = cet_report_none; 2598 2599 if (ebfd != NULL) 2600 { 2601 prop = NULL; 2602 if (features) 2603 { 2604 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and 2605 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */ 2606 prop = _bfd_elf_get_property (ebfd, 2607 GNU_PROPERTY_X86_FEATURE_1_AND, 2608 4); 2609 prop->u.number |= features; 2610 prop->pr_kind = property_number; 2611 } 2612 2613 /* Create the GNU property note section if needed. */ 2614 if (prop != NULL && pbfd == NULL) 2615 { 2616 sec = bfd_make_section_with_flags (ebfd, 2617 NOTE_GNU_PROPERTY_SECTION_NAME, 2618 (SEC_ALLOC 2619 | SEC_LOAD 2620 | SEC_IN_MEMORY 2621 | SEC_READONLY 2622 | SEC_HAS_CONTENTS 2623 | SEC_DATA)); 2624 if (sec == NULL) 2625 info->callbacks->einfo (_("%F%P: failed to create GNU property section\n")); 2626 2627 if (!bfd_set_section_alignment (sec, class_align)) 2628 { 2629 error_alignment: 2630 info->callbacks->einfo (_("%F%pA: failed to align section\n"), 2631 sec); 2632 } 2633 2634 elf_section_type (sec) = SHT_NOTE; 2635 } 2636 } 2637 2638 if (htab->params->cet_report) 2639 { 2640 /* Report missing IBT and SHSTK properties. */ 2641 bfd *abfd; 2642 const char *msg; 2643 elf_property_list *p; 2644 bfd_boolean missing_ibt, missing_shstk; 2645 bfd_boolean check_ibt 2646 = !!(htab->params->cet_report & cet_report_ibt); 2647 bfd_boolean check_shstk 2648 = !!(htab->params->cet_report & cet_report_shstk); 2649 2650 if ((htab->params->cet_report & cet_report_warning)) 2651 msg = _("%P: %pB: warning: missing %s\n"); 2652 else 2653 msg = _("%X%P: %pB: error: missing %s\n"); 2654 2655 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next) 2656 if (!(abfd->flags & (DYNAMIC | BFD_PLUGIN | BFD_LINKER_CREATED)) 2657 && bfd_get_flavour (abfd) == bfd_target_elf_flavour) 2658 { 2659 for (p = elf_properties (abfd); p; p = p->next) 2660 if (p->property.pr_type == GNU_PROPERTY_X86_FEATURE_1_AND) 2661 break; 2662 2663 missing_ibt = check_ibt; 2664 missing_shstk = check_shstk; 2665 if (p) 2666 { 2667 missing_ibt &= !(p->property.u.number 2668 & GNU_PROPERTY_X86_FEATURE_1_IBT); 2669 missing_shstk &= !(p->property.u.number 2670 & GNU_PROPERTY_X86_FEATURE_1_SHSTK); 2671 } 2672 if (missing_ibt || missing_shstk) 2673 { 2674 const char *missing; 2675 if (missing_ibt && missing_shstk) 2676 missing = _("IBT and SHSTK properties"); 2677 else if (missing_ibt) 2678 missing = _("IBT property"); 2679 else 2680 missing = _("SHSTK property"); 2681 info->callbacks->einfo (msg, abfd, missing); 2682 } 2683 } 2684 } 2685 2686 pbfd = _bfd_elf_link_setup_gnu_properties (info); 2687 2688 htab->r_info = init_table->r_info; 2689 htab->r_sym = init_table->r_sym; 2690 2691 if (bfd_link_relocatable (info)) 2692 return pbfd; 2693 2694 htab->plt0_pad_byte = init_table->plt0_pad_byte; 2695 2696 use_ibt_plt = htab->params->ibtplt || htab->params->ibt; 2697 if (!use_ibt_plt && pbfd != NULL) 2698 { 2699 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */ 2700 elf_property_list *p; 2701 2702 /* The property list is sorted in order of type. */ 2703 for (p = elf_properties (pbfd); p; p = p->next) 2704 { 2705 if (GNU_PROPERTY_X86_FEATURE_1_AND == p->property.pr_type) 2706 { 2707 use_ibt_plt = !!(p->property.u.number 2708 & GNU_PROPERTY_X86_FEATURE_1_IBT); 2709 break; 2710 } 2711 else if (GNU_PROPERTY_X86_FEATURE_1_AND < p->property.pr_type) 2712 break; 2713 } 2714 } 2715 2716 dynobj = htab->elf.dynobj; 2717 2718 /* Set htab->elf.dynobj here so that there is no need to check and 2719 set it in check_relocs. */ 2720 if (dynobj == NULL) 2721 { 2722 if (pbfd != NULL) 2723 { 2724 htab->elf.dynobj = pbfd; 2725 dynobj = pbfd; 2726 } 2727 else 2728 { 2729 bfd *abfd; 2730 2731 /* Find a normal input file to hold linker created 2732 sections. */ 2733 for (abfd = info->input_bfds; 2734 abfd != NULL; 2735 abfd = abfd->link.next) 2736 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour 2737 && (abfd->flags 2738 & (DYNAMIC | BFD_LINKER_CREATED | BFD_PLUGIN)) == 0 2739 && bed->relocs_compatible (abfd->xvec, 2740 info->output_bfd->xvec)) 2741 { 2742 htab->elf.dynobj = abfd; 2743 dynobj = abfd; 2744 break; 2745 } 2746 } 2747 } 2748 2749 /* Return if there are no normal input files. */ 2750 if (dynobj == NULL) 2751 return pbfd; 2752 2753 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may 2754 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for 2755 canonical function address. */ 2756 htab->plt.has_plt0 = 1; 2757 normal_target = htab->target_os == is_normal; 2758 2759 if (normal_target) 2760 { 2761 if (use_ibt_plt) 2762 { 2763 htab->lazy_plt = init_table->lazy_ibt_plt; 2764 htab->non_lazy_plt = init_table->non_lazy_ibt_plt; 2765 } 2766 else 2767 { 2768 htab->lazy_plt = init_table->lazy_plt; 2769 htab->non_lazy_plt = init_table->non_lazy_plt; 2770 } 2771 } 2772 else 2773 { 2774 htab->lazy_plt = init_table->lazy_plt; 2775 htab->non_lazy_plt = NULL; 2776 } 2777 2778 pltsec = htab->elf.splt; 2779 2780 /* If the non-lazy PLT is available, use it for all PLT entries if 2781 there are no PLT0 or no .plt section. */ 2782 if (htab->non_lazy_plt != NULL 2783 && (!htab->plt.has_plt0 || pltsec == NULL)) 2784 { 2785 lazy_plt = FALSE; 2786 if (bfd_link_pic (info)) 2787 htab->plt.plt_entry = htab->non_lazy_plt->pic_plt_entry; 2788 else 2789 htab->plt.plt_entry = htab->non_lazy_plt->plt_entry; 2790 htab->plt.plt_entry_size = htab->non_lazy_plt->plt_entry_size; 2791 htab->plt.plt_got_offset = htab->non_lazy_plt->plt_got_offset; 2792 htab->plt.plt_got_insn_size 2793 = htab->non_lazy_plt->plt_got_insn_size; 2794 htab->plt.eh_frame_plt_size 2795 = htab->non_lazy_plt->eh_frame_plt_size; 2796 htab->plt.eh_frame_plt = htab->non_lazy_plt->eh_frame_plt; 2797 } 2798 else 2799 { 2800 lazy_plt = TRUE; 2801 if (bfd_link_pic (info)) 2802 { 2803 htab->plt.plt0_entry = htab->lazy_plt->pic_plt0_entry; 2804 htab->plt.plt_entry = htab->lazy_plt->pic_plt_entry; 2805 } 2806 else 2807 { 2808 htab->plt.plt0_entry = htab->lazy_plt->plt0_entry; 2809 htab->plt.plt_entry = htab->lazy_plt->plt_entry; 2810 } 2811 htab->plt.plt_entry_size = htab->lazy_plt->plt_entry_size; 2812 htab->plt.plt_got_offset = htab->lazy_plt->plt_got_offset; 2813 htab->plt.plt_got_insn_size 2814 = htab->lazy_plt->plt_got_insn_size; 2815 htab->plt.eh_frame_plt_size 2816 = htab->lazy_plt->eh_frame_plt_size; 2817 htab->plt.eh_frame_plt = htab->lazy_plt->eh_frame_plt; 2818 } 2819 2820 if (htab->target_os == is_vxworks 2821 && !elf_vxworks_create_dynamic_sections (dynobj, info, 2822 &htab->srelplt2)) 2823 { 2824 info->callbacks->einfo (_("%F%P: failed to create VxWorks dynamic sections\n")); 2825 return pbfd; 2826 } 2827 2828 /* Since create_dynamic_sections isn't always called, but GOT 2829 relocations need GOT relocations, create them here so that we 2830 don't need to do it in check_relocs. */ 2831 if (htab->elf.sgot == NULL 2832 && !_bfd_elf_create_got_section (dynobj, info)) 2833 info->callbacks->einfo (_("%F%P: failed to create GOT sections\n")); 2834 2835 got_align = (bed->target_id == X86_64_ELF_DATA) ? 3 : 2; 2836 2837 /* Align .got and .got.plt sections to their entry size. Do it here 2838 instead of in create_dynamic_sections so that they are always 2839 properly aligned even if create_dynamic_sections isn't called. */ 2840 sec = htab->elf.sgot; 2841 if (!bfd_set_section_alignment (sec, got_align)) 2842 goto error_alignment; 2843 2844 sec = htab->elf.sgotplt; 2845 if (!bfd_set_section_alignment (sec, got_align)) 2846 goto error_alignment; 2847 2848 /* Create the ifunc sections here so that check_relocs can be 2849 simplified. */ 2850 if (!_bfd_elf_create_ifunc_sections (dynobj, info)) 2851 info->callbacks->einfo (_("%F%P: failed to create ifunc sections\n")); 2852 2853 plt_alignment = bfd_log2 (htab->plt.plt_entry_size); 2854 2855 if (pltsec != NULL) 2856 { 2857 /* Whe creating executable, set the contents of the .interp 2858 section to the interpreter. */ 2859 if (bfd_link_executable (info) && !info->nointerp) 2860 { 2861 asection *s = bfd_get_linker_section (dynobj, ".interp"); 2862 if (s == NULL) 2863 abort (); 2864 s->size = htab->dynamic_interpreter_size; 2865 s->contents = (unsigned char *) htab->dynamic_interpreter; 2866 htab->interp = s; 2867 } 2868 2869 /* Don't change PLT section alignment for NaCl since it uses 2870 64-byte PLT entry and sets PLT section alignment to 32 2871 bytes. Don't create additional PLT sections for NaCl. */ 2872 if (normal_target) 2873 { 2874 flagword pltflags = (bed->dynamic_sec_flags 2875 | SEC_ALLOC 2876 | SEC_CODE 2877 | SEC_LOAD 2878 | SEC_READONLY); 2879 unsigned int non_lazy_plt_alignment 2880 = bfd_log2 (htab->non_lazy_plt->plt_entry_size); 2881 2882 sec = pltsec; 2883 if (!bfd_set_section_alignment (sec, plt_alignment)) 2884 goto error_alignment; 2885 2886 /* Create the GOT procedure linkage table. */ 2887 sec = bfd_make_section_anyway_with_flags (dynobj, 2888 ".plt.got", 2889 pltflags); 2890 if (sec == NULL) 2891 info->callbacks->einfo (_("%F%P: failed to create GOT PLT section\n")); 2892 2893 if (!bfd_set_section_alignment (sec, non_lazy_plt_alignment)) 2894 goto error_alignment; 2895 2896 htab->plt_got = sec; 2897 2898 if (lazy_plt) 2899 { 2900 sec = NULL; 2901 2902 if (use_ibt_plt) 2903 { 2904 /* Create the second PLT for Intel IBT support. IBT 2905 PLT is supported only for non-NaCl target and is 2906 is needed only for lazy binding. */ 2907 sec = bfd_make_section_anyway_with_flags (dynobj, 2908 ".plt.sec", 2909 pltflags); 2910 if (sec == NULL) 2911 info->callbacks->einfo (_("%F%P: failed to create IBT-enabled PLT section\n")); 2912 2913 if (!bfd_set_section_alignment (sec, plt_alignment)) 2914 goto error_alignment; 2915 } 2916 else if (htab->params->bndplt && ABI_64_P (dynobj)) 2917 { 2918 /* Create the second PLT for Intel MPX support. MPX 2919 PLT is supported only for non-NaCl target in 64-bit 2920 mode and is needed only for lazy binding. */ 2921 sec = bfd_make_section_anyway_with_flags (dynobj, 2922 ".plt.sec", 2923 pltflags); 2924 if (sec == NULL) 2925 info->callbacks->einfo (_("%F%P: failed to create BND PLT section\n")); 2926 2927 if (!bfd_set_section_alignment (sec, non_lazy_plt_alignment)) 2928 goto error_alignment; 2929 } 2930 2931 htab->plt_second = sec; 2932 } 2933 } 2934 2935 if (!info->no_ld_generated_unwind_info) 2936 { 2937 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY 2938 | SEC_HAS_CONTENTS | SEC_IN_MEMORY 2939 | SEC_LINKER_CREATED); 2940 2941 sec = bfd_make_section_anyway_with_flags (dynobj, 2942 ".eh_frame", 2943 flags); 2944 if (sec == NULL) 2945 info->callbacks->einfo (_("%F%P: failed to create PLT .eh_frame section\n")); 2946 2947 if (!bfd_set_section_alignment (sec, class_align)) 2948 goto error_alignment; 2949 2950 htab->plt_eh_frame = sec; 2951 2952 if (htab->plt_got != NULL) 2953 { 2954 sec = bfd_make_section_anyway_with_flags (dynobj, 2955 ".eh_frame", 2956 flags); 2957 if (sec == NULL) 2958 info->callbacks->einfo (_("%F%P: failed to create GOT PLT .eh_frame section\n")); 2959 2960 if (!bfd_set_section_alignment (sec, class_align)) 2961 goto error_alignment; 2962 2963 htab->plt_got_eh_frame = sec; 2964 } 2965 2966 if (htab->plt_second != NULL) 2967 { 2968 sec = bfd_make_section_anyway_with_flags (dynobj, 2969 ".eh_frame", 2970 flags); 2971 if (sec == NULL) 2972 info->callbacks->einfo (_("%F%P: failed to create the second PLT .eh_frame section\n")); 2973 2974 if (!bfd_set_section_alignment (sec, class_align)) 2975 goto error_alignment; 2976 2977 htab->plt_second_eh_frame = sec; 2978 } 2979 } 2980 } 2981 2982 /* The .iplt section is used for IFUNC symbols in static 2983 executables. */ 2984 sec = htab->elf.iplt; 2985 if (sec != NULL) 2986 { 2987 /* NB: Delay setting its alignment until we know it is non-empty. 2988 Otherwise an empty iplt section may change vma and lma of the 2989 following sections, which triggers moving dot of the following 2990 section backwards, resulting in a warning and section lma not 2991 being set properly. It later leads to a "File truncated" 2992 error. */ 2993 if (!bfd_set_section_alignment (sec, 0)) 2994 goto error_alignment; 2995 2996 htab->plt.iplt_alignment = (normal_target 2997 ? plt_alignment 2998 : bed->plt_alignment); 2999 } 3000 3001 return pbfd; 3002 } 3003 3004 /* Fix up x86 GNU properties. */ 3005 3006 void 3007 _bfd_x86_elf_link_fixup_gnu_properties 3008 (struct bfd_link_info *info ATTRIBUTE_UNUSED, 3009 elf_property_list **listp) 3010 { 3011 elf_property_list *p; 3012 3013 for (p = *listp; p; p = p->next) 3014 { 3015 unsigned int type = p->property.pr_type; 3016 if (type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED 3017 || type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED 3018 || (type >= GNU_PROPERTY_X86_UINT32_AND_LO 3019 && type <= GNU_PROPERTY_X86_UINT32_AND_HI) 3020 || (type >= GNU_PROPERTY_X86_UINT32_OR_LO 3021 && type <= GNU_PROPERTY_X86_UINT32_OR_HI) 3022 || (type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO 3023 && type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI)) 3024 { 3025 if (p->property.u.number == 0 3026 && (type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED 3027 || (type >= GNU_PROPERTY_X86_UINT32_AND_LO 3028 && type <= GNU_PROPERTY_X86_UINT32_AND_HI) 3029 || (type >= GNU_PROPERTY_X86_UINT32_OR_LO 3030 && type <= GNU_PROPERTY_X86_UINT32_OR_HI))) 3031 { 3032 /* Remove empty property. */ 3033 *listp = p->next; 3034 continue; 3035 } 3036 3037 listp = &p->next; 3038 } 3039 else if (type > GNU_PROPERTY_HIPROC) 3040 { 3041 /* The property list is sorted in order of type. */ 3042 break; 3043 } 3044 } 3045 } 3046 3047 void 3048 _bfd_elf_linker_x86_set_options (struct bfd_link_info * info, 3049 struct elf_linker_x86_params *params) 3050 { 3051 const struct elf_backend_data *bed 3052 = get_elf_backend_data (info->output_bfd); 3053 struct elf_x86_link_hash_table *htab 3054 = elf_x86_hash_table (info, bed->target_id); 3055 if (htab != NULL) 3056 htab->params = params; 3057 } 3058
Indexes created Thu Apr 16 00:22:31 UTC 2026