elfxx-x86.c revision 1.1
1 /* x86 specific support for ELF 2 Copyright (C) 2017-2019 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 /* 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->owner, s, 1284 htab->plt.iplt_alignment); 1285 1286 /* Allocate memory for the section contents. We use bfd_zalloc 1287 here in case unused entries are not reclaimed before the 1288 section's contents are written out. This should not happen, 1289 but this way if it does, we get a R_386_NONE or R_X86_64_NONE 1290 reloc instead of garbage. */ 1291 s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size); 1292 if (s->contents == NULL) 1293 return FALSE; 1294 } 1295 1296 if (htab->plt_eh_frame != NULL 1297 && htab->plt_eh_frame->contents != NULL) 1298 { 1299 memcpy (htab->plt_eh_frame->contents, 1300 htab->plt.eh_frame_plt, 1301 htab->plt_eh_frame->size); 1302 bfd_put_32 (dynobj, htab->elf.splt->size, 1303 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET); 1304 } 1305 1306 if (htab->plt_got_eh_frame != NULL 1307 && htab->plt_got_eh_frame->contents != NULL) 1308 { 1309 memcpy (htab->plt_got_eh_frame->contents, 1310 htab->non_lazy_plt->eh_frame_plt, 1311 htab->plt_got_eh_frame->size); 1312 bfd_put_32 (dynobj, htab->plt_got->size, 1313 (htab->plt_got_eh_frame->contents 1314 + PLT_FDE_LEN_OFFSET)); 1315 } 1316 1317 if (htab->plt_second_eh_frame != NULL 1318 && htab->plt_second_eh_frame->contents != NULL) 1319 { 1320 memcpy (htab->plt_second_eh_frame->contents, 1321 htab->non_lazy_plt->eh_frame_plt, 1322 htab->plt_second_eh_frame->size); 1323 bfd_put_32 (dynobj, htab->plt_second->size, 1324 (htab->plt_second_eh_frame->contents 1325 + PLT_FDE_LEN_OFFSET)); 1326 } 1327 1328 if (htab->elf.dynamic_sections_created) 1329 { 1330 /* Add some entries to the .dynamic section. We fill in the 1331 values later, in elf_{i386,x86_64}_finish_dynamic_sections, 1332 but we must add the entries now so that we get the correct 1333 size for the .dynamic section. The DT_DEBUG entry is filled 1334 in by the dynamic linker and used by the debugger. */ 1335 #define add_dynamic_entry(TAG, VAL) \ 1336 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 1337 1338 if (bfd_link_executable (info)) 1339 { 1340 if (!add_dynamic_entry (DT_DEBUG, 0)) 1341 return FALSE; 1342 } 1343 1344 if (htab->elf.splt->size != 0) 1345 { 1346 /* DT_PLTGOT is used by prelink even if there is no PLT 1347 relocation. */ 1348 if (!add_dynamic_entry (DT_PLTGOT, 0)) 1349 return FALSE; 1350 } 1351 1352 if (htab->elf.srelplt->size != 0) 1353 { 1354 if (!add_dynamic_entry (DT_PLTRELSZ, 0) 1355 || !add_dynamic_entry (DT_PLTREL, htab->dt_reloc) 1356 || !add_dynamic_entry (DT_JMPREL, 0)) 1357 return FALSE; 1358 } 1359 1360 if (htab->tlsdesc_plt 1361 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0) 1362 || !add_dynamic_entry (DT_TLSDESC_GOT, 0))) 1363 return FALSE; 1364 1365 if (relocs) 1366 { 1367 if (!add_dynamic_entry (htab->dt_reloc, 0) 1368 || !add_dynamic_entry (htab->dt_reloc_sz, 0) 1369 || !add_dynamic_entry (htab->dt_reloc_ent, 1370 htab->sizeof_reloc)) 1371 return FALSE; 1372 1373 /* If any dynamic relocs apply to a read-only section, 1374 then we need a DT_TEXTREL entry. */ 1375 if ((info->flags & DF_TEXTREL) == 0) 1376 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info); 1377 1378 if ((info->flags & DF_TEXTREL) != 0) 1379 { 1380 if (htab->readonly_dynrelocs_against_ifunc) 1381 { 1382 info->callbacks->einfo 1383 (_("%P%X: read-only segment has dynamic IFUNC relocations;" 1384 " recompile with -fPIC\n")); 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 if (count == 0) 2174 return -1; 2175 2176 dynrelbuf = (arelent **) bfd_malloc (relsize); 2177 if (dynrelbuf == NULL) 2178 return -1; 2179 2180 dynrelcount = bfd_canonicalize_dynamic_reloc (abfd, dynrelbuf, 2181 dynsyms); 2182 if (dynrelcount <= 0) 2183 return -1; 2184 2185 /* Sort the relocs by address. */ 2186 qsort (dynrelbuf, dynrelcount, sizeof (arelent *), 2187 _bfd_x86_elf_compare_relocs); 2188 2189 size = count * sizeof (asymbol); 2190 2191 /* Allocate space for @plt suffixes. */ 2192 n = 0; 2193 for (i = 0; i < dynrelcount; i++) 2194 { 2195 p = dynrelbuf[i]; 2196 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt"); 2197 if (p->addend != 0) 2198 size += sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd); 2199 } 2200 2201 s = *ret = (asymbol *) bfd_zmalloc (size); 2202 if (s == NULL) 2203 goto bad_return; 2204 2205 bed = get_elf_backend_data (abfd); 2206 2207 if (bed->target_id == X86_64_ELF_DATA) 2208 { 2209 get_plt_got_vma = elf_x86_64_get_plt_got_vma; 2210 valid_plt_reloc_p = elf_x86_64_valid_plt_reloc_p; 2211 } 2212 else 2213 { 2214 get_plt_got_vma = elf_i386_get_plt_got_vma; 2215 valid_plt_reloc_p = elf_i386_valid_plt_reloc_p; 2216 if (got_addr) 2217 { 2218 /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_ 2219 address. */ 2220 asection *sec = bfd_get_section_by_name (abfd, ".got.plt"); 2221 if (sec != NULL) 2222 got_addr = sec->vma; 2223 else 2224 { 2225 sec = bfd_get_section_by_name (abfd, ".got"); 2226 if (sec != NULL) 2227 got_addr = sec->vma; 2228 } 2229 2230 if (got_addr == (bfd_vma) -1) 2231 goto bad_return; 2232 } 2233 } 2234 2235 /* Check for each PLT section. */ 2236 names = (char *) (s + count); 2237 size = 0; 2238 n = 0; 2239 for (j = 0; plts[j].name != NULL; j++) 2240 if ((plt_contents = plts[j].contents) != NULL) 2241 { 2242 long k; 2243 bfd_vma offset; 2244 asection *plt; 2245 struct elf_x86_plt *plt_p = &plts[j]; 2246 2247 plt_got_offset = plt_p->plt_got_offset; 2248 plt_entry_size = plt_p->plt_entry_size; 2249 2250 plt = plt_p->sec; 2251 2252 if ((plt_p->type & plt_lazy)) 2253 { 2254 /* Skip PLT0 in lazy PLT. */ 2255 k = 1; 2256 offset = plt_entry_size; 2257 } 2258 else 2259 { 2260 k = 0; 2261 offset = 0; 2262 } 2263 2264 /* Check each PLT entry against dynamic relocations. */ 2265 for (; k < plt_p->count; k++) 2266 { 2267 int off; 2268 bfd_vma got_vma; 2269 long min, max, mid; 2270 2271 /* Get the GOT offset for i386 or the PC-relative offset 2272 for x86-64, a signed 32-bit integer. */ 2273 off = H_GET_32 (abfd, (plt_contents + offset 2274 + plt_got_offset)); 2275 got_vma = get_plt_got_vma (plt_p, off, offset, got_addr); 2276 2277 /* Binary search. */ 2278 p = dynrelbuf[0]; 2279 min = 0; 2280 max = dynrelcount; 2281 while ((min + 1) < max) 2282 { 2283 arelent *r; 2284 2285 mid = (min + max) / 2; 2286 r = dynrelbuf[mid]; 2287 if (got_vma > r->address) 2288 min = mid; 2289 else if (got_vma < r->address) 2290 max = mid; 2291 else 2292 { 2293 p = r; 2294 break; 2295 } 2296 } 2297 2298 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */ 2299 if (got_vma == p->address 2300 && p->howto != NULL 2301 && valid_plt_reloc_p (p->howto->type)) 2302 { 2303 *s = **p->sym_ptr_ptr; 2304 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL 2305 set. Since we are defining a symbol, ensure one 2306 of them is set. */ 2307 if ((s->flags & BSF_LOCAL) == 0) 2308 s->flags |= BSF_GLOBAL; 2309 s->flags |= BSF_SYNTHETIC; 2310 /* This is no longer a section symbol. */ 2311 s->flags &= ~BSF_SECTION_SYM; 2312 s->section = plt; 2313 s->the_bfd = plt->owner; 2314 s->value = offset; 2315 s->udata.p = NULL; 2316 s->name = names; 2317 len = strlen ((*p->sym_ptr_ptr)->name); 2318 memcpy (names, (*p->sym_ptr_ptr)->name, len); 2319 names += len; 2320 if (p->addend != 0) 2321 { 2322 char buf[30], *a; 2323 2324 memcpy (names, "+0x", sizeof ("+0x") - 1); 2325 names += sizeof ("+0x") - 1; 2326 bfd_sprintf_vma (abfd, buf, p->addend); 2327 for (a = buf; *a == '0'; ++a) 2328 ; 2329 size = strlen (a); 2330 memcpy (names, a, size); 2331 names += size; 2332 } 2333 memcpy (names, "@plt", sizeof ("@plt")); 2334 names += sizeof ("@plt"); 2335 n++; 2336 s++; 2337 /* There should be only one entry in PLT for a given 2338 symbol. Set howto to NULL after processing a PLT 2339 entry to guard against corrupted PLT. */ 2340 p->howto = NULL; 2341 } 2342 offset += plt_entry_size; 2343 } 2344 } 2345 2346 /* PLT entries with R_386_TLS_DESC relocations are skipped. */ 2347 if (n == 0) 2348 { 2349 bad_return: 2350 count = -1; 2351 } 2352 else 2353 count = n; 2354 2355 for (j = 0; plts[j].name != NULL; j++) 2356 if (plts[j].contents != NULL) 2357 free (plts[j].contents); 2358 2359 free (dynrelbuf); 2360 2361 return count; 2362 } 2363 2364 /* Parse x86 GNU properties. */ 2365 2366 enum elf_property_kind 2367 _bfd_x86_elf_parse_gnu_properties (bfd *abfd, unsigned int type, 2368 bfd_byte *ptr, unsigned int datasz) 2369 { 2370 elf_property *prop; 2371 2372 if (type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED 2373 || type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED 2374 || (type >= GNU_PROPERTY_X86_UINT32_AND_LO 2375 && type <= GNU_PROPERTY_X86_UINT32_AND_HI) 2376 || (type >= GNU_PROPERTY_X86_UINT32_OR_LO 2377 && type <= GNU_PROPERTY_X86_UINT32_OR_HI) 2378 || (type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO 2379 && type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI)) 2380 { 2381 if (datasz != 4) 2382 { 2383 _bfd_error_handler 2384 (_("error: %pB: <corrupt x86 property (0x%x) size: 0x%x>"), 2385 abfd, type, datasz); 2386 return property_corrupt; 2387 } 2388 prop = _bfd_elf_get_property (abfd, type, datasz); 2389 prop->u.number |= bfd_h_get_32 (abfd, ptr); 2390 prop->pr_kind = property_number; 2391 return property_number; 2392 } 2393 2394 return property_ignored; 2395 } 2396 2397 /* Merge x86 GNU property BPROP with APROP. If APROP isn't NULL, 2398 return TRUE if APROP is updated. Otherwise, return TRUE if BPROP 2399 should be merged with ABFD. */ 2400 2401 bfd_boolean 2402 _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info *info, 2403 bfd *abfd ATTRIBUTE_UNUSED, 2404 elf_property *aprop, 2405 elf_property *bprop) 2406 { 2407 unsigned int number, features; 2408 bfd_boolean updated = FALSE; 2409 unsigned int pr_type = aprop != NULL ? aprop->pr_type : bprop->pr_type; 2410 2411 if (pr_type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED 2412 || (pr_type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO 2413 && pr_type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI)) 2414 { 2415 if (aprop == NULL || bprop == NULL) 2416 { 2417 /* Only one of APROP and BPROP can be NULL. */ 2418 if (aprop != NULL) 2419 { 2420 /* Remove this property since the other input file doesn't 2421 have it. */ 2422 aprop->pr_kind = property_remove; 2423 updated = TRUE; 2424 } 2425 } 2426 else 2427 { 2428 number = aprop->u.number; 2429 aprop->u.number = number | bprop->u.number; 2430 updated = number != (unsigned int) aprop->u.number; 2431 } 2432 return updated; 2433 } 2434 else if (pr_type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED 2435 || (pr_type >= GNU_PROPERTY_X86_UINT32_OR_LO 2436 && pr_type <= GNU_PROPERTY_X86_UINT32_OR_HI)) 2437 { 2438 if (aprop != NULL && bprop != NULL) 2439 { 2440 number = aprop->u.number; 2441 aprop->u.number = number | bprop->u.number; 2442 /* Remove the property if all bits are empty. */ 2443 if (aprop->u.number == 0) 2444 { 2445 aprop->pr_kind = property_remove; 2446 updated = TRUE; 2447 } 2448 else 2449 updated = number != (unsigned int) aprop->u.number; 2450 } 2451 else 2452 { 2453 /* Only one of APROP and BPROP can be NULL. */ 2454 if (aprop != NULL) 2455 { 2456 if (aprop->u.number == 0) 2457 { 2458 /* Remove APROP if all bits are empty. */ 2459 aprop->pr_kind = property_remove; 2460 updated = TRUE; 2461 } 2462 } 2463 else 2464 { 2465 /* Return TRUE if APROP is NULL and all bits of BPROP 2466 aren't empty to indicate that BPROP should be added 2467 to ABFD. */ 2468 updated = bprop->u.number != 0; 2469 } 2470 } 2471 return updated; 2472 } 2473 else if (pr_type >= GNU_PROPERTY_X86_UINT32_AND_LO 2474 && pr_type <= GNU_PROPERTY_X86_UINT32_AND_HI) 2475 { 2476 /* Only one of APROP and BPROP can be NULL: 2477 1. APROP & BPROP when both APROP and BPROP aren't NULL. 2478 2. If APROP is NULL, remove x86 feature. 2479 3. Otherwise, do nothing. 2480 */ 2481 if (aprop != NULL && bprop != NULL) 2482 { 2483 features = 0; 2484 if (info->ibt) 2485 features = GNU_PROPERTY_X86_FEATURE_1_IBT; 2486 if (info->shstk) 2487 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK; 2488 number = aprop->u.number; 2489 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and 2490 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */ 2491 aprop->u.number = (number & bprop->u.number) | features; 2492 updated = number != (unsigned int) aprop->u.number; 2493 /* Remove the property if all feature bits are cleared. */ 2494 if (aprop->u.number == 0) 2495 aprop->pr_kind = property_remove; 2496 } 2497 else 2498 { 2499 features = 0; 2500 if (info->ibt) 2501 features = GNU_PROPERTY_X86_FEATURE_1_IBT; 2502 if (info->shstk) 2503 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK; 2504 if (features) 2505 { 2506 /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and 2507 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */ 2508 if (aprop != NULL) 2509 { 2510 number = aprop->u.number; 2511 aprop->u.number = number | features; 2512 updated = number != (unsigned int) aprop->u.number; 2513 } 2514 else 2515 { 2516 bprop->u.number |= features; 2517 updated = TRUE; 2518 } 2519 } 2520 else if (aprop != NULL) 2521 { 2522 aprop->pr_kind = property_remove; 2523 updated = TRUE; 2524 } 2525 } 2526 return updated; 2527 } 2528 else 2529 { 2530 /* Never should happen. */ 2531 abort (); 2532 } 2533 2534 return updated; 2535 } 2536 2537 /* Set up x86 GNU properties. Return the first relocatable ELF input 2538 with GNU properties if found. Otherwise, return NULL. */ 2539 2540 bfd * 2541 _bfd_x86_elf_link_setup_gnu_properties 2542 (struct bfd_link_info *info, struct elf_x86_init_table *init_table) 2543 { 2544 bfd_boolean normal_target; 2545 bfd_boolean lazy_plt; 2546 asection *sec, *pltsec; 2547 bfd *dynobj; 2548 bfd_boolean use_ibt_plt; 2549 unsigned int plt_alignment, features; 2550 struct elf_x86_link_hash_table *htab; 2551 bfd *pbfd; 2552 bfd *ebfd = NULL; 2553 elf_property *prop; 2554 const struct elf_backend_data *bed; 2555 unsigned int class_align = ABI_64_P (info->output_bfd) ? 3 : 2; 2556 unsigned int got_align; 2557 2558 features = 0; 2559 if (info->ibt) 2560 features = GNU_PROPERTY_X86_FEATURE_1_IBT; 2561 if (info->shstk) 2562 features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK; 2563 2564 /* Find a normal input file with GNU property note. */ 2565 for (pbfd = info->input_bfds; 2566 pbfd != NULL; 2567 pbfd = pbfd->link.next) 2568 if (bfd_get_flavour (pbfd) == bfd_target_elf_flavour 2569 && bfd_count_sections (pbfd) != 0) 2570 { 2571 ebfd = pbfd; 2572 2573 if (elf_properties (pbfd) != NULL) 2574 break; 2575 } 2576 2577 bed = get_elf_backend_data (info->output_bfd); 2578 2579 htab = elf_x86_hash_table (info, bed->target_id); 2580 if (htab == NULL) 2581 return pbfd; 2582 2583 if (ebfd != NULL) 2584 { 2585 prop = NULL; 2586 if (features) 2587 { 2588 /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and 2589 GNU_PROPERTY_X86_FEATURE_1_SHSTK. */ 2590 prop = _bfd_elf_get_property (ebfd, 2591 GNU_PROPERTY_X86_FEATURE_1_AND, 2592 4); 2593 prop->u.number |= features; 2594 prop->pr_kind = property_number; 2595 } 2596 2597 /* Create the GNU property note section if needed. */ 2598 if (prop != NULL && pbfd == NULL) 2599 { 2600 sec = bfd_make_section_with_flags (ebfd, 2601 NOTE_GNU_PROPERTY_SECTION_NAME, 2602 (SEC_ALLOC 2603 | SEC_LOAD 2604 | SEC_IN_MEMORY 2605 | SEC_READONLY 2606 | SEC_HAS_CONTENTS 2607 | SEC_DATA)); 2608 if (sec == NULL) 2609 info->callbacks->einfo (_("%F%P: failed to create GNU property section\n")); 2610 2611 if (!bfd_set_section_alignment (ebfd, sec, class_align)) 2612 { 2613 error_alignment: 2614 info->callbacks->einfo (_("%F%pA: failed to align section\n"), 2615 sec); 2616 } 2617 2618 elf_section_type (sec) = SHT_NOTE; 2619 } 2620 } 2621 2622 pbfd = _bfd_elf_link_setup_gnu_properties (info); 2623 2624 htab->r_info = init_table->r_info; 2625 htab->r_sym = init_table->r_sym; 2626 2627 if (bfd_link_relocatable (info)) 2628 return pbfd; 2629 2630 htab->plt0_pad_byte = init_table->plt0_pad_byte; 2631 2632 use_ibt_plt = info->ibtplt || info->ibt; 2633 if (!use_ibt_plt && pbfd != NULL) 2634 { 2635 /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */ 2636 elf_property_list *p; 2637 2638 /* The property list is sorted in order of type. */ 2639 for (p = elf_properties (pbfd); p; p = p->next) 2640 { 2641 if (GNU_PROPERTY_X86_FEATURE_1_AND == p->property.pr_type) 2642 { 2643 use_ibt_plt = !!(p->property.u.number 2644 & GNU_PROPERTY_X86_FEATURE_1_IBT); 2645 break; 2646 } 2647 else if (GNU_PROPERTY_X86_FEATURE_1_AND < p->property.pr_type) 2648 break; 2649 } 2650 } 2651 2652 dynobj = htab->elf.dynobj; 2653 2654 /* Set htab->elf.dynobj here so that there is no need to check and 2655 set it in check_relocs. */ 2656 if (dynobj == NULL) 2657 { 2658 if (pbfd != NULL) 2659 { 2660 htab->elf.dynobj = pbfd; 2661 dynobj = pbfd; 2662 } 2663 else 2664 { 2665 bfd *abfd; 2666 2667 /* Find a normal input file to hold linker created 2668 sections. */ 2669 for (abfd = info->input_bfds; 2670 abfd != NULL; 2671 abfd = abfd->link.next) 2672 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour 2673 && (abfd->flags 2674 & (DYNAMIC | BFD_LINKER_CREATED | BFD_PLUGIN)) == 0 2675 && bed->relocs_compatible (abfd->xvec, 2676 info->output_bfd->xvec)) 2677 { 2678 htab->elf.dynobj = abfd; 2679 dynobj = abfd; 2680 break; 2681 } 2682 } 2683 } 2684 2685 /* Return if there are no normal input files. */ 2686 if (dynobj == NULL) 2687 return pbfd; 2688 2689 /* Even when lazy binding is disabled by "-z now", the PLT0 entry may 2690 still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for 2691 canonical function address. */ 2692 htab->plt.has_plt0 = 1; 2693 normal_target = htab->target_os == is_normal; 2694 2695 if (normal_target) 2696 { 2697 if (use_ibt_plt) 2698 { 2699 htab->lazy_plt = init_table->lazy_ibt_plt; 2700 htab->non_lazy_plt = init_table->non_lazy_ibt_plt; 2701 } 2702 else 2703 { 2704 htab->lazy_plt = init_table->lazy_plt; 2705 htab->non_lazy_plt = init_table->non_lazy_plt; 2706 } 2707 } 2708 else 2709 { 2710 htab->lazy_plt = init_table->lazy_plt; 2711 htab->non_lazy_plt = NULL; 2712 } 2713 2714 pltsec = htab->elf.splt; 2715 2716 /* If the non-lazy PLT is available, use it for all PLT entries if 2717 there are no PLT0 or no .plt section. */ 2718 if (htab->non_lazy_plt != NULL 2719 && (!htab->plt.has_plt0 || pltsec == NULL)) 2720 { 2721 lazy_plt = FALSE; 2722 if (bfd_link_pic (info)) 2723 htab->plt.plt_entry = htab->non_lazy_plt->pic_plt_entry; 2724 else 2725 htab->plt.plt_entry = htab->non_lazy_plt->plt_entry; 2726 htab->plt.plt_entry_size = htab->non_lazy_plt->plt_entry_size; 2727 htab->plt.plt_got_offset = htab->non_lazy_plt->plt_got_offset; 2728 htab->plt.plt_got_insn_size 2729 = htab->non_lazy_plt->plt_got_insn_size; 2730 htab->plt.eh_frame_plt_size 2731 = htab->non_lazy_plt->eh_frame_plt_size; 2732 htab->plt.eh_frame_plt = htab->non_lazy_plt->eh_frame_plt; 2733 } 2734 else 2735 { 2736 lazy_plt = TRUE; 2737 if (bfd_link_pic (info)) 2738 { 2739 htab->plt.plt0_entry = htab->lazy_plt->pic_plt0_entry; 2740 htab->plt.plt_entry = htab->lazy_plt->pic_plt_entry; 2741 } 2742 else 2743 { 2744 htab->plt.plt0_entry = htab->lazy_plt->plt0_entry; 2745 htab->plt.plt_entry = htab->lazy_plt->plt_entry; 2746 } 2747 htab->plt.plt_entry_size = htab->lazy_plt->plt_entry_size; 2748 htab->plt.plt_got_offset = htab->lazy_plt->plt_got_offset; 2749 htab->plt.plt_got_insn_size 2750 = htab->lazy_plt->plt_got_insn_size; 2751 htab->plt.eh_frame_plt_size 2752 = htab->lazy_plt->eh_frame_plt_size; 2753 htab->plt.eh_frame_plt = htab->lazy_plt->eh_frame_plt; 2754 } 2755 2756 if (htab->target_os == is_vxworks 2757 && !elf_vxworks_create_dynamic_sections (dynobj, info, 2758 &htab->srelplt2)) 2759 { 2760 info->callbacks->einfo (_("%F%P: failed to create VxWorks dynamic sections\n")); 2761 return pbfd; 2762 } 2763 2764 /* Since create_dynamic_sections isn't always called, but GOT 2765 relocations need GOT relocations, create them here so that we 2766 don't need to do it in check_relocs. */ 2767 if (htab->elf.sgot == NULL 2768 && !_bfd_elf_create_got_section (dynobj, info)) 2769 info->callbacks->einfo (_("%F%P: failed to create GOT sections\n")); 2770 2771 got_align = (bed->target_id == X86_64_ELF_DATA) ? 3 : 2; 2772 2773 /* Align .got and .got.plt sections to their entry size. Do it here 2774 instead of in create_dynamic_sections so that they are always 2775 properly aligned even if create_dynamic_sections isn't called. */ 2776 sec = htab->elf.sgot; 2777 if (!bfd_set_section_alignment (dynobj, sec, got_align)) 2778 goto error_alignment; 2779 2780 sec = htab->elf.sgotplt; 2781 if (!bfd_set_section_alignment (dynobj, sec, got_align)) 2782 goto error_alignment; 2783 2784 /* Create the ifunc sections here so that check_relocs can be 2785 simplified. */ 2786 if (!_bfd_elf_create_ifunc_sections (dynobj, info)) 2787 info->callbacks->einfo (_("%F%P: failed to create ifunc sections\n")); 2788 2789 plt_alignment = bfd_log2 (htab->plt.plt_entry_size); 2790 2791 if (pltsec != NULL) 2792 { 2793 /* Whe creating executable, set the contents of the .interp 2794 section to the interpreter. */ 2795 if (bfd_link_executable (info) && !info->nointerp) 2796 { 2797 asection *s = bfd_get_linker_section (dynobj, ".interp"); 2798 if (s == NULL) 2799 abort (); 2800 s->size = htab->dynamic_interpreter_size; 2801 s->contents = (unsigned char *) htab->dynamic_interpreter; 2802 htab->interp = s; 2803 } 2804 2805 /* Don't change PLT section alignment for NaCl since it uses 2806 64-byte PLT entry and sets PLT section alignment to 32 2807 bytes. Don't create additional PLT sections for NaCl. */ 2808 if (normal_target) 2809 { 2810 flagword pltflags = (bed->dynamic_sec_flags 2811 | SEC_ALLOC 2812 | SEC_CODE 2813 | SEC_LOAD 2814 | SEC_READONLY); 2815 unsigned int non_lazy_plt_alignment 2816 = bfd_log2 (htab->non_lazy_plt->plt_entry_size); 2817 2818 sec = pltsec; 2819 if (!bfd_set_section_alignment (sec->owner, sec, 2820 plt_alignment)) 2821 goto error_alignment; 2822 2823 /* Create the GOT procedure linkage table. */ 2824 sec = bfd_make_section_anyway_with_flags (dynobj, 2825 ".plt.got", 2826 pltflags); 2827 if (sec == NULL) 2828 info->callbacks->einfo (_("%F%P: failed to create GOT PLT section\n")); 2829 2830 if (!bfd_set_section_alignment (dynobj, sec, 2831 non_lazy_plt_alignment)) 2832 goto error_alignment; 2833 2834 htab->plt_got = sec; 2835 2836 if (lazy_plt) 2837 { 2838 sec = NULL; 2839 2840 if (use_ibt_plt) 2841 { 2842 /* Create the second PLT for Intel IBT support. IBT 2843 PLT is supported only for non-NaCl target and is 2844 is needed only for lazy binding. */ 2845 sec = bfd_make_section_anyway_with_flags (dynobj, 2846 ".plt.sec", 2847 pltflags); 2848 if (sec == NULL) 2849 info->callbacks->einfo (_("%F%P: failed to create IBT-enabled PLT section\n")); 2850 2851 if (!bfd_set_section_alignment (dynobj, sec, 2852 plt_alignment)) 2853 goto error_alignment; 2854 } 2855 else if (info->bndplt && ABI_64_P (dynobj)) 2856 { 2857 /* Create the second PLT for Intel MPX support. MPX 2858 PLT is supported only for non-NaCl target in 64-bit 2859 mode and is needed only for lazy binding. */ 2860 sec = bfd_make_section_anyway_with_flags (dynobj, 2861 ".plt.sec", 2862 pltflags); 2863 if (sec == NULL) 2864 info->callbacks->einfo (_("%F%P: failed to create BND PLT section\n")); 2865 2866 if (!bfd_set_section_alignment (dynobj, sec, 2867 non_lazy_plt_alignment)) 2868 goto error_alignment; 2869 } 2870 2871 htab->plt_second = sec; 2872 } 2873 } 2874 2875 if (!info->no_ld_generated_unwind_info) 2876 { 2877 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY 2878 | SEC_HAS_CONTENTS | SEC_IN_MEMORY 2879 | SEC_LINKER_CREATED); 2880 2881 sec = bfd_make_section_anyway_with_flags (dynobj, 2882 ".eh_frame", 2883 flags); 2884 if (sec == NULL) 2885 info->callbacks->einfo (_("%F%P: failed to create PLT .eh_frame section\n")); 2886 2887 if (!bfd_set_section_alignment (dynobj, sec, class_align)) 2888 goto error_alignment; 2889 2890 htab->plt_eh_frame = sec; 2891 2892 if (htab->plt_got != NULL) 2893 { 2894 sec = bfd_make_section_anyway_with_flags (dynobj, 2895 ".eh_frame", 2896 flags); 2897 if (sec == NULL) 2898 info->callbacks->einfo (_("%F%P: failed to create GOT PLT .eh_frame section\n")); 2899 2900 if (!bfd_set_section_alignment (dynobj, sec, class_align)) 2901 goto error_alignment; 2902 2903 htab->plt_got_eh_frame = sec; 2904 } 2905 2906 if (htab->plt_second != NULL) 2907 { 2908 sec = bfd_make_section_anyway_with_flags (dynobj, 2909 ".eh_frame", 2910 flags); 2911 if (sec == NULL) 2912 info->callbacks->einfo (_("%F%P: failed to create the second PLT .eh_frame section\n")); 2913 2914 if (!bfd_set_section_alignment (dynobj, sec, class_align)) 2915 goto error_alignment; 2916 2917 htab->plt_second_eh_frame = sec; 2918 } 2919 } 2920 } 2921 2922 /* The .iplt section is used for IFUNC symbols in static 2923 executables. */ 2924 sec = htab->elf.iplt; 2925 if (sec != NULL) 2926 { 2927 /* NB: Delay setting its alignment until we know it is non-empty. 2928 Otherwise an empty iplt section may change vma and lma of the 2929 following sections, which triggers moving dot of the following 2930 section backwards, resulting in a warning and section lma not 2931 being set properly. It later leads to a "File truncated" 2932 error. */ 2933 if (!bfd_set_section_alignment (sec->owner, sec, 0)) 2934 goto error_alignment; 2935 2936 htab->plt.iplt_alignment = (normal_target 2937 ? plt_alignment 2938 : bed->plt_alignment); 2939 } 2940 2941 return pbfd; 2942 } 2943 2944 /* Fix up x86 GNU properties. */ 2945 2946 void 2947 _bfd_x86_elf_link_fixup_gnu_properties 2948 (struct bfd_link_info *info ATTRIBUTE_UNUSED, 2949 elf_property_list **listp) 2950 { 2951 elf_property_list *p; 2952 2953 for (p = *listp; p; p = p->next) 2954 { 2955 unsigned int type = p->property.pr_type; 2956 if (type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED 2957 || type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED 2958 || (type >= GNU_PROPERTY_X86_UINT32_AND_LO 2959 && type <= GNU_PROPERTY_X86_UINT32_AND_HI) 2960 || (type >= GNU_PROPERTY_X86_UINT32_OR_LO 2961 && type <= GNU_PROPERTY_X86_UINT32_OR_HI) 2962 || (type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO 2963 && type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI)) 2964 { 2965 if (p->property.u.number == 0 2966 && (type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED 2967 || (type >= GNU_PROPERTY_X86_UINT32_AND_LO 2968 && type <= GNU_PROPERTY_X86_UINT32_AND_HI) 2969 || (type >= GNU_PROPERTY_X86_UINT32_OR_LO 2970 && type <= GNU_PROPERTY_X86_UINT32_OR_HI))) 2971 { 2972 /* Remove empty property. */ 2973 *listp = p->next; 2974 continue; 2975 } 2976 2977 listp = &p->next; 2978 } 2979 else if (type > GNU_PROPERTY_HIPROC) 2980 { 2981 /* The property list is sorted in order of type. */ 2982 break; 2983 } 2984 } 2985 } 2986
Indexes created Thu May 07 00:24:58 UTC 2026