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