X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bfd%2Felfxx-x86.c;h=035b5c5c64c4207018accb279d7957064336700c;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=50d945ef0ac844e347b6e6184fb487fc83c2c6b6;hpb=4f501a245f67d0b43f245b09515c87bfeec983ec;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/elfxx-x86.c b/bfd/elfxx-x86.c index 50d945ef0a..035b5c5c64 100644 --- a/bfd/elfxx-x86.c +++ b/bfd/elfxx-x86.c @@ -1,5 +1,5 @@ /* x86 specific support for ELF - Copyright (C) 2017 Free Software Foundation, Inc. + Copyright (C) 2017-2020 Free Software Foundation, Inc. This file is part of BFD, the Binary File Descriptor library. @@ -79,44 +79,478 @@ _bfd_x86_elf_dtpoff_base (struct bfd_link_info *info) return elf_hash_table (info)->tls_sec->vma; } -/* Find any dynamic relocs that apply to read-only sections. */ +/* Allocate space in .plt, .got and associated reloc sections for + dynamic relocs. */ -bfd_boolean -_bfd_x86_elf_readonly_dynrelocs (struct elf_link_hash_entry *h, - void *inf) +static bfd_boolean +elf_x86_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) { + struct bfd_link_info *info; + struct elf_x86_link_hash_table *htab; struct elf_x86_link_hash_entry *eh; struct elf_dyn_relocs *p; + unsigned int plt_entry_size; + bfd_boolean resolved_to_zero; + const struct elf_backend_data *bed; - /* Skip local IFUNC symbols. */ - if (h->forced_local && h->type == STT_GNU_IFUNC) + if (h->root.type == bfd_link_hash_indirect) return TRUE; eh = (struct elf_x86_link_hash_entry *) h; - for (p = eh->dyn_relocs; p != NULL; p = p->next) + + info = (struct bfd_link_info *) inf; + bed = get_elf_backend_data (info->output_bfd); + htab = elf_x86_hash_table (info, bed->target_id); + if (htab == NULL) + return FALSE; + + plt_entry_size = htab->plt.plt_entry_size; + + resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh); + + /* We can't use the GOT PLT if pointer equality is needed since + finish_dynamic_symbol won't clear symbol value and the dynamic + linker won't update the GOT slot. We will get into an infinite + loop at run-time. */ + if (htab->plt_got != NULL + && h->type != STT_GNU_IFUNC + && !h->pointer_equality_needed + && h->plt.refcount > 0 + && h->got.refcount > 0) { - asection *s = p->sec->output_section; + /* Don't use the regular PLT if there are both GOT and GOTPLT + reloctions. */ + h->plt.offset = (bfd_vma) -1; + + /* Use the GOT PLT. */ + eh->plt_got.refcount = 1; + } - if (s != NULL && (s->flags & SEC_READONLY) != 0) + /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it + here if it is defined and referenced in a non-shared object. */ + if (h->type == STT_GNU_IFUNC + && h->def_regular) + { + if (_bfd_elf_allocate_ifunc_dyn_relocs (info, h, &h->dyn_relocs, + &htab->readonly_dynrelocs_against_ifunc, + plt_entry_size, + (htab->plt.has_plt0 + * plt_entry_size), + htab->got_entry_size, + TRUE)) { - struct bfd_link_info *info = (struct bfd_link_info *) inf; + asection *s = htab->plt_second; + if (h->plt.offset != (bfd_vma) -1 && s != NULL) + { + /* Use the second PLT section if it is created. */ + eh->plt_second.offset = s->size; - info->flags |= DF_TEXTREL; + /* Make room for this entry in the second PLT section. */ + s->size += htab->non_lazy_plt->plt_entry_size; + } - if ((info->warn_shared_textrel && bfd_link_pic (info)) - || info->error_textrel) - /* xgettext:c-format */ - info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"), - p->sec->owner, h->root.root.string, - p->sec); + return TRUE; + } + else + return FALSE; + } + /* Don't create the PLT entry if there are only function pointer + relocations which can be resolved at run-time. */ + else if (htab->elf.dynamic_sections_created + && (h->plt.refcount > 0 + || eh->plt_got.refcount > 0)) + { + bfd_boolean use_plt_got = eh->plt_got.refcount > 0; + + /* Make sure this symbol is output as a dynamic symbol. + Undefined weak syms won't yet be marked as dynamic. */ + if (h->dynindx == -1 + && !h->forced_local + && !resolved_to_zero + && h->root.type == bfd_link_hash_undefweak) + { + if (! bfd_elf_link_record_dynamic_symbol (info, h)) + return FALSE; + } + + if (bfd_link_pic (info) + || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h)) + { + asection *s = htab->elf.splt; + asection *second_s = htab->plt_second; + asection *got_s = htab->plt_got; + bfd_boolean use_plt; + + /* If this is the first .plt entry, make room for the special + first entry. The .plt section is used by prelink to undo + prelinking for dynamic relocations. */ + if (s->size == 0) + s->size = htab->plt.has_plt0 * plt_entry_size; + + if (use_plt_got) + eh->plt_got.offset = got_s->size; + else + { + h->plt.offset = s->size; + if (second_s) + eh->plt_second.offset = second_s->size; + } + + /* If this symbol is not defined in a regular file, and we are + generating PDE, then set the symbol to this location in the + .plt. This is required to make function pointers compare + as equal between PDE and the shared library. + + NB: If PLT is PC-relative, we can use the .plt in PIE for + function address. */ + if (h->def_regular) + use_plt = FALSE; + else if (htab->pcrel_plt) + use_plt = ! bfd_link_dll (info); + else + use_plt = bfd_link_pde (info); + if (use_plt) + { + if (use_plt_got) + { + /* We need to make a call to the entry of the GOT PLT + instead of regular PLT entry. */ + h->root.u.def.section = got_s; + h->root.u.def.value = eh->plt_got.offset; + } + else + { + if (second_s) + { + /* We need to make a call to the entry of the + second PLT instead of regular PLT entry. */ + h->root.u.def.section = second_s; + h->root.u.def.value = eh->plt_second.offset; + } + else + { + h->root.u.def.section = s; + h->root.u.def.value = h->plt.offset; + } + } + } + + /* Make room for this entry. */ + if (use_plt_got) + got_s->size += htab->non_lazy_plt->plt_entry_size; + else + { + s->size += plt_entry_size; + if (second_s) + second_s->size += htab->non_lazy_plt->plt_entry_size; + + /* We also need to make an entry in the .got.plt section, + which will be placed in the .got section by the linker + script. */ + htab->elf.sgotplt->size += htab->got_entry_size; + + /* There should be no PLT relocation against resolved + undefined weak symbol in executable. */ + if (!resolved_to_zero) + { + /* We also need to make an entry in the .rel.plt + section. */ + htab->elf.srelplt->size += htab->sizeof_reloc; + htab->elf.srelplt->reloc_count++; + } + } + + if (htab->target_os == is_vxworks && !bfd_link_pic (info)) + { + /* VxWorks has a second set of relocations for each PLT entry + in executables. They go in a separate relocation section, + which is processed by the kernel loader. */ + + /* There are two relocations for the initial PLT entry: an + R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an + R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */ + + asection *srelplt2 = htab->srelplt2; + if (h->plt.offset == plt_entry_size) + srelplt2->size += (htab->sizeof_reloc * 2); + + /* There are two extra relocations for each subsequent PLT entry: + an R_386_32 relocation for the GOT entry, and an R_386_32 + relocation for the PLT entry. */ + + srelplt2->size += (htab->sizeof_reloc * 2); + } + } + else + { + eh->plt_got.offset = (bfd_vma) -1; + h->plt.offset = (bfd_vma) -1; + h->needs_plt = 0; + } + } + else + { + eh->plt_got.offset = (bfd_vma) -1; + h->plt.offset = (bfd_vma) -1; + h->needs_plt = 0; + } + + eh->tlsdesc_got = (bfd_vma) -1; + + /* For i386, if R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the + binary, make it a R_386_TLS_LE_32 requiring no TLS entry. For + x86-64, if R_X86_64_GOTTPOFF symbol is now local to the binary, + make it a R_X86_64_TPOFF32 requiring no GOT entry. */ + if (h->got.refcount > 0 + && bfd_link_executable (info) + && h->dynindx == -1 + && (elf_x86_hash_entry (h)->tls_type & GOT_TLS_IE)) + h->got.offset = (bfd_vma) -1; + else if (h->got.refcount > 0) + { + asection *s; + bfd_boolean dyn; + int tls_type = elf_x86_hash_entry (h)->tls_type; + + /* Make sure this symbol is output as a dynamic symbol. + Undefined weak syms won't yet be marked as dynamic. */ + if (h->dynindx == -1 + && !h->forced_local + && !resolved_to_zero + && h->root.type == bfd_link_hash_undefweak) + { + if (! bfd_elf_link_record_dynamic_symbol (info, h)) + return FALSE; + } + + s = htab->elf.sgot; + if (GOT_TLS_GDESC_P (tls_type)) + { + eh->tlsdesc_got = htab->elf.sgotplt->size + - elf_x86_compute_jump_table_size (htab); + htab->elf.sgotplt->size += 2 * htab->got_entry_size; + h->got.offset = (bfd_vma) -2; + } + if (! GOT_TLS_GDESC_P (tls_type) + || GOT_TLS_GD_P (tls_type)) + { + h->got.offset = s->size; + s->size += htab->got_entry_size; + /* R_386_TLS_GD and R_X86_64_TLSGD need 2 consecutive GOT + slots. */ + if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH) + s->size += htab->got_entry_size; + } + dyn = htab->elf.dynamic_sections_created; + /* R_386_TLS_IE_32 needs one dynamic relocation, + R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation, + (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we + need two), R_386_TLS_GD and R_X86_64_TLSGD need one if local + symbol and two if global. No dynamic relocation against + resolved undefined weak symbol in executable. No dynamic + relocation against non-preemptible absolute symbol. */ + if (tls_type == GOT_TLS_IE_BOTH) + htab->elf.srelgot->size += 2 * htab->sizeof_reloc; + else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1) + || (tls_type & GOT_TLS_IE)) + htab->elf.srelgot->size += htab->sizeof_reloc; + else if (GOT_TLS_GD_P (tls_type)) + htab->elf.srelgot->size += 2 * htab->sizeof_reloc; + else if (! GOT_TLS_GDESC_P (tls_type) + && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT + && !resolved_to_zero) + || h->root.type != bfd_link_hash_undefweak) + && ((bfd_link_pic (info) + && !(h->dynindx == -1 + && ABS_SYMBOL_P (h))) + || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))) + htab->elf.srelgot->size += htab->sizeof_reloc; + if (GOT_TLS_GDESC_P (tls_type)) + { + htab->elf.srelplt->size += htab->sizeof_reloc; + if (bed->target_id == X86_64_ELF_DATA) + htab->tlsdesc_plt = (bfd_vma) -1; + } + } + else + h->got.offset = (bfd_vma) -1; + + if (h->dyn_relocs == NULL) + return TRUE; + + /* In the shared -Bsymbolic case, discard space allocated for + dynamic pc-relative relocs against symbols which turn out to be + defined in regular objects. For the normal shared case, discard + space for pc-relative relocs that have become local due to symbol + visibility changes. */ + + if (bfd_link_pic (info)) + { + /* Relocs that use pc_count are those that appear on a call + insn, or certain REL relocs that can generated via assembly. + We want calls to protected symbols to resolve directly to the + function rather than going via the plt. If people want + function pointer comparisons to work as expected then they + should avoid writing weird assembly. */ + if (SYMBOL_CALLS_LOCAL (info, h)) + { + struct elf_dyn_relocs **pp; + + for (pp = &h->dyn_relocs; (p = *pp) != NULL; ) + { + p->count -= p->pc_count; + p->pc_count = 0; + if (p->count == 0) + *pp = p->next; + else + pp = &p->next; + } + } + + if (htab->target_os == is_vxworks) + { + struct elf_dyn_relocs **pp; + for (pp = &h->dyn_relocs; (p = *pp) != NULL; ) + { + if (strcmp (p->sec->output_section->name, ".tls_vars") == 0) + *pp = p->next; + else + pp = &p->next; + } + } + + /* Also discard relocs on undefined weak syms with non-default + visibility or in PIE. */ + if (h->dyn_relocs != NULL) + { + if (h->root.type == bfd_link_hash_undefweak) + { + /* Undefined weak symbol is never bound locally in shared + library. */ + if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT + || resolved_to_zero) + { + if (bed->target_id == I386_ELF_DATA + && h->non_got_ref) + { + /* Keep dynamic non-GOT/non-PLT relocation so + that we can branch to 0 without PLT. */ + struct elf_dyn_relocs **pp; + + for (pp = &h->dyn_relocs; (p = *pp) != NULL; ) + if (p->pc_count == 0) + *pp = p->next; + else + { + /* Remove non-R_386_PC32 relocation. */ + p->count = p->pc_count; + pp = &p->next; + } + + /* Make sure undefined weak symbols are output + as dynamic symbols in PIEs for dynamic non-GOT + non-PLT reloations. */ + if (h->dyn_relocs != NULL + && !bfd_elf_link_record_dynamic_symbol (info, h)) + return FALSE; + } + else + h->dyn_relocs = NULL; + } + else if (h->dynindx == -1 + && !h->forced_local + && !bfd_elf_link_record_dynamic_symbol (info, h)) + return FALSE; + } + else if (bfd_link_executable (info) + && (h->needs_copy || eh->needs_copy) + && h->def_dynamic + && !h->def_regular) + { + /* NB: needs_copy is set only for x86-64. For PIE, + discard space for pc-relative relocs against symbols + which turn out to need copy relocs. */ + struct elf_dyn_relocs **pp; + + for (pp = &h->dyn_relocs; (p = *pp) != NULL; ) + { + if (p->pc_count != 0) + *pp = p->next; + else + pp = &p->next; + } + } + } + } + else if (ELIMINATE_COPY_RELOCS) + { + /* For the non-shared case, discard space for relocs against + symbols which turn out to need copy relocs or are not + dynamic. Keep dynamic relocations for run-time function + pointer initialization. */ + + if ((!h->non_got_ref + || (h->root.type == bfd_link_hash_undefweak + && !resolved_to_zero)) + && ((h->def_dynamic + && !h->def_regular) + || (htab->elf.dynamic_sections_created + && (h->root.type == bfd_link_hash_undefweak + || h->root.type == bfd_link_hash_undefined)))) + { + /* Make sure this symbol is output as a dynamic symbol. + Undefined weak syms won't yet be marked as dynamic. */ + if (h->dynindx == -1 + && !h->forced_local + && !resolved_to_zero + && h->root.type == bfd_link_hash_undefweak + && ! bfd_elf_link_record_dynamic_symbol (info, h)) + return FALSE; - /* Not an error, just cut short the traversal. */ - return FALSE; + /* If that succeeded, we know we'll be keeping all the + relocs. */ + if (h->dynindx != -1) + goto keep; } + + h->dyn_relocs = NULL; + + keep: ; } + + /* Finally, allocate space. */ + for (p = h->dyn_relocs; p != NULL; p = p->next) + { + asection *sreloc; + + sreloc = elf_section_data (p->sec)->sreloc; + + BFD_ASSERT (sreloc != NULL); + sreloc->size += p->count * htab->sizeof_reloc; + } + return TRUE; } +/* Allocate space in .plt, .got and associated reloc sections for + local dynamic relocs. */ + +static bfd_boolean +elf_x86_allocate_local_dynreloc (void **slot, void *inf) +{ + struct elf_link_hash_entry *h + = (struct elf_link_hash_entry *) *slot; + + if (h->type != STT_GNU_IFUNC + || !h->def_regular + || !h->ref_regular + || !h->forced_local + || h->root.type != bfd_link_hash_defined) + abort (); + + return elf_x86_allocate_dynrelocs (h, inf); +} + /* Find and/or create a hash entry for local symbol. */ struct elf_link_hash_entry * @@ -203,6 +637,7 @@ _bfd_x86_elf_link_hash_newfunc (struct bfd_hash_entry *entry, eh->plt_second.offset = (bfd_vma) -1; eh->plt_got.offset = (bfd_vma) -1; eh->tlsdesc_got = (bfd_vma) -1; + eh->zero_undefweak = 1; } return entry; @@ -249,6 +684,18 @@ elf_x86_link_hash_table_free (bfd *obfd) _bfd_elf_link_hash_table_free (obfd); } +static bfd_boolean +elf_i386_is_reloc_section (const char *secname) +{ + return CONST_STRNEQ (secname, ".rel"); +} + +static bfd_boolean +elf_x86_64_is_reloc_section (const char *secname) +{ + return CONST_STRNEQ (secname, ".rela"); +} + /* Create an x86 ELF linker hash table. */ struct bfd_link_hash_table * @@ -256,7 +703,7 @@ _bfd_x86_elf_link_hash_table_create (bfd *abfd) { struct elf_x86_link_hash_table *ret; const struct elf_backend_data *bed; - bfd_size_type amt = sizeof (struct elf_x86_link_hash_table); + size_t amt = sizeof (struct elf_x86_link_hash_table); ret = (struct elf_x86_link_hash_table *) bfd_zmalloc (amt); if (ret == NULL) @@ -272,94 +719,945 @@ _bfd_x86_elf_link_hash_table_create (bfd *abfd) return NULL; } -#ifdef BFD64 + if (bed->target_id == X86_64_ELF_DATA) + { + ret->is_reloc_section = elf_x86_64_is_reloc_section; + ret->dt_reloc = DT_RELA; + ret->dt_reloc_sz = DT_RELASZ; + ret->dt_reloc_ent = DT_RELAENT; + ret->got_entry_size = 8; + ret->pcrel_plt = TRUE; + ret->tls_get_addr = "__tls_get_addr"; + } if (ABI_64_P (abfd)) { - ret->r_info = elf64_r_info; - ret->r_sym = elf64_r_sym; + ret->sizeof_reloc = sizeof (Elf64_External_Rela); ret->pointer_r_type = R_X86_64_64; ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER; ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER; - ret->tls_get_addr = "__tls_get_addr"; } - else -#endif + else + { + if (bed->target_id == X86_64_ELF_DATA) + { + ret->sizeof_reloc = sizeof (Elf32_External_Rela); + ret->pointer_r_type = R_X86_64_32; + ret->dynamic_interpreter = ELFX32_DYNAMIC_INTERPRETER; + ret->dynamic_interpreter_size + = sizeof ELFX32_DYNAMIC_INTERPRETER; + } + else + { + ret->is_reloc_section = elf_i386_is_reloc_section; + ret->dt_reloc = DT_REL; + ret->dt_reloc_sz = DT_RELSZ; + ret->dt_reloc_ent = DT_RELENT; + ret->sizeof_reloc = sizeof (Elf32_External_Rel); + ret->got_entry_size = 4; + ret->pcrel_plt = FALSE; + ret->pointer_r_type = R_386_32; + ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER; + ret->dynamic_interpreter_size + = sizeof ELF32_DYNAMIC_INTERPRETER; + ret->tls_get_addr = "___tls_get_addr"; + } + } + ret->target_id = bed->target_id; + ret->target_os = get_elf_x86_backend_data (abfd)->target_os; + + ret->loc_hash_table = htab_try_create (1024, + _bfd_x86_elf_local_htab_hash, + _bfd_x86_elf_local_htab_eq, + NULL); + ret->loc_hash_memory = objalloc_create (); + if (!ret->loc_hash_table || !ret->loc_hash_memory) + { + elf_x86_link_hash_table_free (abfd); + return NULL; + } + ret->elf.root.hash_table_free = elf_x86_link_hash_table_free; + + return &ret->elf.root; +} + +/* Sort relocs into address order. */ + +int +_bfd_x86_elf_compare_relocs (const void *ap, const void *bp) +{ + const arelent *a = * (const arelent **) ap; + const arelent *b = * (const arelent **) bp; + + if (a->address > b->address) + return 1; + else if (a->address < b->address) + return -1; + else + return 0; +} + +/* Mark symbol, NAME, as locally defined by linker if it is referenced + and not defined in a relocatable object file. */ + +static void +elf_x86_linker_defined (struct bfd_link_info *info, const char *name) +{ + struct elf_link_hash_entry *h; + + h = elf_link_hash_lookup (elf_hash_table (info), name, + FALSE, FALSE, FALSE); + if (h == NULL) + return; + + while (h->root.type == bfd_link_hash_indirect) + h = (struct elf_link_hash_entry *) h->root.u.i.link; + + if (h->root.type == bfd_link_hash_new + || h->root.type == bfd_link_hash_undefined + || h->root.type == bfd_link_hash_undefweak + || h->root.type == bfd_link_hash_common + || (!h->def_regular && h->def_dynamic)) + { + elf_x86_hash_entry (h)->local_ref = 2; + elf_x86_hash_entry (h)->linker_def = 1; + } +} + +/* Hide a linker-defined symbol, NAME, with hidden visibility. */ + +static void +elf_x86_hide_linker_defined (struct bfd_link_info *info, + const char *name) +{ + struct elf_link_hash_entry *h; + + h = elf_link_hash_lookup (elf_hash_table (info), name, + FALSE, FALSE, FALSE); + if (h == NULL) + return; + + while (h->root.type == bfd_link_hash_indirect) + h = (struct elf_link_hash_entry *) h->root.u.i.link; + + if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL + || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN) + _bfd_elf_link_hash_hide_symbol (info, h, TRUE); +} + +bfd_boolean +_bfd_x86_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info) +{ + if (!bfd_link_relocatable (info)) + { + /* Check for __tls_get_addr reference. */ + struct elf_x86_link_hash_table *htab; + const struct elf_backend_data *bed = get_elf_backend_data (abfd); + htab = elf_x86_hash_table (info, bed->target_id); + if (htab) + { + struct elf_link_hash_entry *h; + + h = elf_link_hash_lookup (elf_hash_table (info), + htab->tls_get_addr, + FALSE, FALSE, FALSE); + if (h != NULL) + { + elf_x86_hash_entry (h)->tls_get_addr = 1; + + /* Check the versioned __tls_get_addr symbol. */ + while (h->root.type == bfd_link_hash_indirect) + { + h = (struct elf_link_hash_entry *) h->root.u.i.link; + elf_x86_hash_entry (h)->tls_get_addr = 1; + } + } + + /* "__ehdr_start" will be defined by linker as a hidden symbol + later if it is referenced and not defined. */ + elf_x86_linker_defined (info, "__ehdr_start"); + + if (bfd_link_executable (info)) + { + /* References to __bss_start, _end and _edata should be + locally resolved within executables. */ + elf_x86_linker_defined (info, "__bss_start"); + elf_x86_linker_defined (info, "_end"); + elf_x86_linker_defined (info, "_edata"); + } + else + { + /* Hide hidden __bss_start, _end and _edata in shared + libraries. */ + elf_x86_hide_linker_defined (info, "__bss_start"); + elf_x86_hide_linker_defined (info, "_end"); + elf_x86_hide_linker_defined (info, "_edata"); + } + } + } + + /* Invoke the regular ELF backend linker to do all the work. */ + return _bfd_elf_link_check_relocs (abfd, info); +} + +bfd_boolean +_bfd_elf_x86_valid_reloc_p (asection *input_section, + struct bfd_link_info *info, + struct elf_x86_link_hash_table *htab, + const Elf_Internal_Rela *rel, + struct elf_link_hash_entry *h, + Elf_Internal_Sym *sym, + Elf_Internal_Shdr *symtab_hdr, + bfd_boolean *no_dynreloc_p) +{ + bfd_boolean valid_p = TRUE; + + *no_dynreloc_p = FALSE; + + /* Check If relocation against non-preemptible absolute symbol is + valid in PIC. FIXME: Can't use SYMBOL_REFERENCES_LOCAL_P since + it may call _bfd_elf_link_hide_sym_by_version and result in + ld-elfvers/ vers21 test failure. */ + if (bfd_link_pic (info) + && (h == NULL || SYMBOL_REFERENCES_LOCAL (info, h))) + { + const struct elf_backend_data *bed; + unsigned int r_type; + Elf_Internal_Rela irel; + + /* Skip non-absolute symbol. */ + if (h) + { + if (!ABS_SYMBOL_P (h)) + return valid_p; + } + else if (sym->st_shndx != SHN_ABS) + return valid_p; + + bed = get_elf_backend_data (input_section->owner); + r_type = ELF32_R_TYPE (rel->r_info); + irel = *rel; + + /* Only allow relocations against absolute symbol, which can be + resolved as absolute value + addend. GOTPCREL relocations + are allowed since absolute value + addend is stored in the + GOT slot. */ + if (bed->target_id == X86_64_ELF_DATA) + { + r_type &= ~R_X86_64_converted_reloc_bit; + valid_p = (r_type == R_X86_64_64 + || r_type == R_X86_64_32 + || r_type == R_X86_64_32S + || r_type == R_X86_64_16 + || r_type == R_X86_64_8 + || r_type == R_X86_64_GOTPCREL + || r_type == R_X86_64_GOTPCRELX + || r_type == R_X86_64_REX_GOTPCRELX); + if (!valid_p) + { + unsigned int r_symndx = htab->r_sym (rel->r_info); + irel.r_info = htab->r_info (r_symndx, r_type); + } + } + else + valid_p = (r_type == R_386_32 + || r_type == R_386_16 + || r_type == R_386_8); + + if (valid_p) + *no_dynreloc_p = TRUE; + else + { + const char *name; + arelent internal_reloc; + + if (!bed->elf_info_to_howto (input_section->owner, + &internal_reloc, &irel) + || internal_reloc.howto == NULL) + abort (); + + if (h) + name = h->root.root.string; + else + name = bfd_elf_sym_name (input_section->owner, symtab_hdr, + sym, NULL); + info->callbacks->einfo + /* xgettext:c-format */ + (_("%F%P: %pB: relocation %s against absolute symbol " + "`%s' in section `%pA' is disallowed\n"), + input_section->owner, internal_reloc.howto->name, name, + input_section); + bfd_set_error (bfd_error_bad_value); + } + } + + return valid_p; +} + +/* Set the sizes of the dynamic sections. */ + +bfd_boolean +_bfd_x86_elf_size_dynamic_sections (bfd *output_bfd, + struct bfd_link_info *info) +{ + struct elf_x86_link_hash_table *htab; + bfd *dynobj; + asection *s; + bfd_boolean relocs; + bfd *ibfd; + const struct elf_backend_data *bed + = get_elf_backend_data (output_bfd); + + htab = elf_x86_hash_table (info, bed->target_id); + if (htab == NULL) + return FALSE; + dynobj = htab->elf.dynobj; + if (dynobj == NULL) + abort (); + + /* Set up .got offsets for local syms, and space for local dynamic + relocs. */ + for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) + { + bfd_signed_vma *local_got; + bfd_signed_vma *end_local_got; + char *local_tls_type; + bfd_vma *local_tlsdesc_gotent; + bfd_size_type locsymcount; + Elf_Internal_Shdr *symtab_hdr; + asection *srel; + + if (! is_x86_elf (ibfd, htab)) + continue; + + for (s = ibfd->sections; s != NULL; s = s->next) + { + struct elf_dyn_relocs *p; + + for (p = ((struct elf_dyn_relocs *) + elf_section_data (s)->local_dynrel); + p != NULL; + p = p->next) + { + if (!bfd_is_abs_section (p->sec) + && bfd_is_abs_section (p->sec->output_section)) + { + /* Input section has been discarded, either because + it is a copy of a linkonce section or due to + linker script /DISCARD/, so we'll be discarding + the relocs too. */ + } + else if (htab->target_os == is_vxworks + && strcmp (p->sec->output_section->name, + ".tls_vars") == 0) + { + /* Relocations in vxworks .tls_vars sections are + handled specially by the loader. */ + } + else if (p->count != 0) + { + srel = elf_section_data (p->sec)->sreloc; + srel->size += p->count * htab->sizeof_reloc; + if ((p->sec->output_section->flags & SEC_READONLY) != 0 + && (info->flags & DF_TEXTREL) == 0) + { + info->flags |= DF_TEXTREL; + if (bfd_link_textrel_check (info)) + /* xgettext:c-format */ + info->callbacks->einfo + (_("%P: %pB: warning: relocation " + "in read-only section `%pA'\n"), + p->sec->owner, p->sec); + } + } + } + } + + local_got = elf_local_got_refcounts (ibfd); + if (!local_got) + continue; + + symtab_hdr = &elf_symtab_hdr (ibfd); + locsymcount = symtab_hdr->sh_info; + end_local_got = local_got + locsymcount; + local_tls_type = elf_x86_local_got_tls_type (ibfd); + local_tlsdesc_gotent = elf_x86_local_tlsdesc_gotent (ibfd); + s = htab->elf.sgot; + srel = htab->elf.srelgot; + for (; local_got < end_local_got; + ++local_got, ++local_tls_type, ++local_tlsdesc_gotent) + { + *local_tlsdesc_gotent = (bfd_vma) -1; + if (*local_got > 0) + { + if (GOT_TLS_GDESC_P (*local_tls_type)) + { + *local_tlsdesc_gotent = htab->elf.sgotplt->size + - elf_x86_compute_jump_table_size (htab); + htab->elf.sgotplt->size += 2 * htab->got_entry_size; + *local_got = (bfd_vma) -2; + } + if (! GOT_TLS_GDESC_P (*local_tls_type) + || GOT_TLS_GD_P (*local_tls_type)) + { + *local_got = s->size; + s->size += htab->got_entry_size; + if (GOT_TLS_GD_P (*local_tls_type) + || *local_tls_type == GOT_TLS_IE_BOTH) + s->size += htab->got_entry_size; + } + if ((bfd_link_pic (info) && *local_tls_type != GOT_ABS) + || GOT_TLS_GD_ANY_P (*local_tls_type) + || (*local_tls_type & GOT_TLS_IE)) + { + if (*local_tls_type == GOT_TLS_IE_BOTH) + srel->size += 2 * htab->sizeof_reloc; + else if (GOT_TLS_GD_P (*local_tls_type) + || ! GOT_TLS_GDESC_P (*local_tls_type)) + srel->size += htab->sizeof_reloc; + if (GOT_TLS_GDESC_P (*local_tls_type)) + { + htab->elf.srelplt->size += htab->sizeof_reloc; + if (bed->target_id == X86_64_ELF_DATA) + htab->tlsdesc_plt = (bfd_vma) -1; + } + } + } + else + *local_got = (bfd_vma) -1; + } + } + + if (htab->tls_ld_or_ldm_got.refcount > 0) + { + /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM + or R_X86_64_TLSLD relocs. */ + htab->tls_ld_or_ldm_got.offset = htab->elf.sgot->size; + htab->elf.sgot->size += 2 * htab->got_entry_size; + htab->elf.srelgot->size += htab->sizeof_reloc; + } + else + htab->tls_ld_or_ldm_got.offset = -1; + + /* Allocate global sym .plt and .got entries, and space for global + sym dynamic relocs. */ + elf_link_hash_traverse (&htab->elf, elf_x86_allocate_dynrelocs, + info); + + /* Allocate .plt and .got entries, and space for local symbols. */ + htab_traverse (htab->loc_hash_table, elf_x86_allocate_local_dynreloc, + info); + + /* For every jump slot reserved in the sgotplt, reloc_count is + incremented. However, when we reserve space for TLS descriptors, + it's not incremented, so in order to compute the space reserved + for them, it suffices to multiply the reloc count by the jump + slot size. + + PR ld/13302: We start next_irelative_index at the end of .rela.plt + so that R_{386,X86_64}_IRELATIVE entries come last. */ + if (htab->elf.srelplt) + { + htab->next_tls_desc_index = htab->elf.srelplt->reloc_count; + htab->sgotplt_jump_table_size + = elf_x86_compute_jump_table_size (htab); + htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1; + } + else if (htab->elf.irelplt) + htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1; + + if (htab->tlsdesc_plt) + { + /* NB: tlsdesc_plt is set only for x86-64. If we're not using + lazy TLS relocations, don't generate the PLT and GOT entries + they require. */ + if ((info->flags & DF_BIND_NOW)) + htab->tlsdesc_plt = 0; + else + { + htab->tlsdesc_got = htab->elf.sgot->size; + htab->elf.sgot->size += htab->got_entry_size; + /* Reserve room for the initial entry. + FIXME: we could probably do away with it in this case. */ + if (htab->elf.splt->size == 0) + htab->elf.splt->size = htab->plt.plt_entry_size; + htab->tlsdesc_plt = htab->elf.splt->size; + htab->elf.splt->size += htab->plt.plt_entry_size; + } + } + + if (htab->elf.sgotplt) + { + /* Don't allocate .got.plt section if there are no GOT nor PLT + entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */ + if ((htab->elf.hgot == NULL + || !htab->got_referenced) + && (htab->elf.sgotplt->size == bed->got_header_size) + && (htab->elf.splt == NULL + || htab->elf.splt->size == 0) + && (htab->elf.sgot == NULL + || htab->elf.sgot->size == 0) + && (htab->elf.iplt == NULL + || htab->elf.iplt->size == 0) + && (htab->elf.igotplt == NULL + || htab->elf.igotplt->size == 0)) + { + htab->elf.sgotplt->size = 0; + /* Solaris requires to keep _GLOBAL_OFFSET_TABLE_ even if it + isn't used. */ + if (htab->elf.hgot != NULL && htab->target_os != is_solaris) + { + /* Remove the unused _GLOBAL_OFFSET_TABLE_ from symbol + table. */ + htab->elf.hgot->root.type = bfd_link_hash_undefined; + htab->elf.hgot->root.u.undef.abfd + = htab->elf.hgot->root.u.def.section->owner; + htab->elf.hgot->root.linker_def = 0; + htab->elf.hgot->ref_regular = 0; + htab->elf.hgot->def_regular = 0; + } + } + } + + if (_bfd_elf_eh_frame_present (info)) + { + if (htab->plt_eh_frame != NULL + && htab->elf.splt != NULL + && htab->elf.splt->size != 0 + && !bfd_is_abs_section (htab->elf.splt->output_section)) + htab->plt_eh_frame->size = htab->plt.eh_frame_plt_size; + + if (htab->plt_got_eh_frame != NULL + && htab->plt_got != NULL + && htab->plt_got->size != 0 + && !bfd_is_abs_section (htab->plt_got->output_section)) + htab->plt_got_eh_frame->size + = htab->non_lazy_plt->eh_frame_plt_size; + + /* Unwind info for the second PLT and .plt.got sections are + identical. */ + if (htab->plt_second_eh_frame != NULL + && htab->plt_second != NULL + && htab->plt_second->size != 0 + && !bfd_is_abs_section (htab->plt_second->output_section)) + htab->plt_second_eh_frame->size + = htab->non_lazy_plt->eh_frame_plt_size; + } + + /* We now have determined the sizes of the various dynamic sections. + Allocate memory for them. */ + relocs = FALSE; + for (s = dynobj->sections; s != NULL; s = s->next) + { + bfd_boolean strip_section = TRUE; + + if ((s->flags & SEC_LINKER_CREATED) == 0) + continue; + + if (s == htab->elf.splt + || s == htab->elf.sgot) + { + /* Strip this section if we don't need it; see the + comment below. */ + /* We'd like to strip these sections if they aren't needed, but if + we've exported dynamic symbols from them we must leave them. + It's too late to tell BFD to get rid of the symbols. */ + + if (htab->elf.hplt != NULL) + strip_section = FALSE; + } + else if (s == htab->elf.sgotplt + || s == htab->elf.iplt + || s == htab->elf.igotplt + || s == htab->plt_second + || s == htab->plt_got + || s == htab->plt_eh_frame + || s == htab->plt_got_eh_frame + || s == htab->plt_second_eh_frame + || s == htab->elf.sdynbss + || s == htab->elf.sdynrelro) + { + /* Strip these too. */ + } + else if (htab->is_reloc_section (bfd_section_name (s))) + { + if (s->size != 0 + && s != htab->elf.srelplt + && s != htab->srelplt2) + relocs = TRUE; + + /* We use the reloc_count field as a counter if we need + to copy relocs into the output file. */ + if (s != htab->elf.srelplt) + s->reloc_count = 0; + } + else + { + /* It's not one of our sections, so don't allocate space. */ + continue; + } + + if (s->size == 0) + { + /* If we don't need this section, strip it from the + output file. This is mostly to handle .rel.bss and + .rel.plt. We must create both sections in + create_dynamic_sections, because they must be created + before the linker maps input sections to output + sections. The linker does that before + adjust_dynamic_symbol is called, and it is that + function which decides whether anything needs to go + into these sections. */ + if (strip_section) + s->flags |= SEC_EXCLUDE; + continue; + } + + if ((s->flags & SEC_HAS_CONTENTS) == 0) + continue; + + /* NB: Initially, the iplt section has minimal alignment to + avoid moving dot of the following section backwards when + it is empty. Update its section alignment now since it + is non-empty. */ + if (s == htab->elf.iplt) + bfd_set_section_alignment (s, htab->plt.iplt_alignment); + + /* Allocate memory for the section contents. We use bfd_zalloc + here in case unused entries are not reclaimed before the + section's contents are written out. This should not happen, + but this way if it does, we get a R_386_NONE or R_X86_64_NONE + reloc instead of garbage. */ + s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size); + if (s->contents == NULL) + return FALSE; + } + + if (htab->plt_eh_frame != NULL + && htab->plt_eh_frame->contents != NULL) + { + memcpy (htab->plt_eh_frame->contents, + htab->plt.eh_frame_plt, + htab->plt_eh_frame->size); + bfd_put_32 (dynobj, htab->elf.splt->size, + htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET); + } + + if (htab->plt_got_eh_frame != NULL + && htab->plt_got_eh_frame->contents != NULL) + { + memcpy (htab->plt_got_eh_frame->contents, + htab->non_lazy_plt->eh_frame_plt, + htab->plt_got_eh_frame->size); + bfd_put_32 (dynobj, htab->plt_got->size, + (htab->plt_got_eh_frame->contents + + PLT_FDE_LEN_OFFSET)); + } + + if (htab->plt_second_eh_frame != NULL + && htab->plt_second_eh_frame->contents != NULL) + { + memcpy (htab->plt_second_eh_frame->contents, + htab->non_lazy_plt->eh_frame_plt, + htab->plt_second_eh_frame->size); + bfd_put_32 (dynobj, htab->plt_second->size, + (htab->plt_second_eh_frame->contents + + PLT_FDE_LEN_OFFSET)); + } + + if (htab->elf.dynamic_sections_created) + { + /* Add some entries to the .dynamic section. We fill in the + values later, in elf_{i386,x86_64}_finish_dynamic_sections, + but we must add the entries now so that we get the correct + size for the .dynamic section. The DT_DEBUG entry is filled + in by the dynamic linker and used by the debugger. */ +#define add_dynamic_entry(TAG, VAL) \ + _bfd_elf_add_dynamic_entry (info, TAG, VAL) + + if (bfd_link_executable (info)) + { + if (!add_dynamic_entry (DT_DEBUG, 0)) + return FALSE; + } + + if (htab->elf.splt->size != 0) + { + /* DT_PLTGOT is used by prelink even if there is no PLT + relocation. */ + if (!add_dynamic_entry (DT_PLTGOT, 0)) + return FALSE; + } + + if (htab->elf.srelplt->size != 0) + { + if (!add_dynamic_entry (DT_PLTRELSZ, 0) + || !add_dynamic_entry (DT_PLTREL, htab->dt_reloc) + || !add_dynamic_entry (DT_JMPREL, 0)) + return FALSE; + } + + if (htab->tlsdesc_plt + && (!add_dynamic_entry (DT_TLSDESC_PLT, 0) + || !add_dynamic_entry (DT_TLSDESC_GOT, 0))) + return FALSE; + + if (relocs) + { + if (!add_dynamic_entry (htab->dt_reloc, 0) + || !add_dynamic_entry (htab->dt_reloc_sz, 0) + || !add_dynamic_entry (htab->dt_reloc_ent, + htab->sizeof_reloc)) + return FALSE; + + /* If any dynamic relocs apply to a read-only section, + then we need a DT_TEXTREL entry. */ + if ((info->flags & DF_TEXTREL) == 0) + elf_link_hash_traverse (&htab->elf, + _bfd_elf_maybe_set_textrel, info); + + if ((info->flags & DF_TEXTREL) != 0) + { + if (htab->readonly_dynrelocs_against_ifunc) + { + info->callbacks->einfo + (_("%P%X: read-only segment has dynamic IFUNC relocations;" + " recompile with %s\n"), + bfd_link_dll (info) ? "-fPIC" : "-fPIE"); + bfd_set_error (bfd_error_bad_value); + return FALSE; + } + + if (!add_dynamic_entry (DT_TEXTREL, 0)) + return FALSE; + } + } + if (htab->target_os == is_vxworks + && !elf_vxworks_add_dynamic_entries (output_bfd, info)) + return FALSE; + } +#undef add_dynamic_entry + + return TRUE; +} + +/* Finish up the x86 dynamic sections. */ + +struct elf_x86_link_hash_table * +_bfd_x86_elf_finish_dynamic_sections (bfd *output_bfd, + struct bfd_link_info *info) +{ + struct elf_x86_link_hash_table *htab; + const struct elf_backend_data *bed; + bfd *dynobj; + asection *sdyn; + bfd_byte *dyncon, *dynconend; + bfd_size_type sizeof_dyn; + + bed = get_elf_backend_data (output_bfd); + htab = elf_x86_hash_table (info, bed->target_id); + if (htab == NULL) + return htab; + + dynobj = htab->elf.dynobj; + sdyn = bfd_get_linker_section (dynobj, ".dynamic"); + + /* GOT is always created in setup_gnu_properties. But it may not be + needed. .got.plt section may be needed for static IFUNC. */ + if (htab->elf.sgotplt && htab->elf.sgotplt->size > 0) + { + bfd_vma dynamic_addr; + + if (bfd_is_abs_section (htab->elf.sgotplt->output_section)) + { + _bfd_error_handler + (_("discarded output section: `%pA'"), htab->elf.sgotplt); + return NULL; + } + + elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize + = htab->got_entry_size; + + dynamic_addr = (sdyn == NULL + ? (bfd_vma) 0 + : sdyn->output_section->vma + sdyn->output_offset); + + /* Set the first entry in the global offset table to the address + of the dynamic section. Write GOT[1] and GOT[2], needed for + the dynamic linker. */ + if (htab->got_entry_size == 8) + { + bfd_put_64 (output_bfd, dynamic_addr, + htab->elf.sgotplt->contents); + bfd_put_64 (output_bfd, (bfd_vma) 0, + htab->elf.sgotplt->contents + 8); + bfd_put_64 (output_bfd, (bfd_vma) 0, + htab->elf.sgotplt->contents + 8*2); + } + else + { + bfd_put_32 (output_bfd, dynamic_addr, + htab->elf.sgotplt->contents); + bfd_put_32 (output_bfd, 0, + htab->elf.sgotplt->contents + 4); + bfd_put_32 (output_bfd, 0, + htab->elf.sgotplt->contents + 4*2); + } + } + + if (!htab->elf.dynamic_sections_created) + return htab; + + if (sdyn == NULL || htab->elf.sgot == NULL) + abort (); + + sizeof_dyn = bed->s->sizeof_dyn; + dyncon = sdyn->contents; + dynconend = sdyn->contents + sdyn->size; + for (; dyncon < dynconend; dyncon += sizeof_dyn) + { + Elf_Internal_Dyn dyn; + asection *s; + + (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn); + + switch (dyn.d_tag) + { + default: + if (htab->target_os == is_vxworks + && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn)) + break; + continue; + + case DT_PLTGOT: + s = htab->elf.sgotplt; + dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; + break; + + case DT_JMPREL: + dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma; + break; + + case DT_PLTRELSZ: + s = htab->elf.srelplt->output_section; + dyn.d_un.d_val = s->size; + break; + + case DT_TLSDESC_PLT: + s = htab->elf.splt; + dyn.d_un.d_ptr = s->output_section->vma + s->output_offset + + htab->tlsdesc_plt; + break; + + case DT_TLSDESC_GOT: + s = htab->elf.sgot; + dyn.d_un.d_ptr = s->output_section->vma + s->output_offset + + htab->tlsdesc_got; + break; + } + + (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon); + } + + if (htab->plt_got != NULL && htab->plt_got->size > 0) + elf_section_data (htab->plt_got->output_section) + ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size; + + if (htab->plt_second != NULL && htab->plt_second->size > 0) + elf_section_data (htab->plt_second->output_section) + ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size; + + /* Adjust .eh_frame for .plt section. */ + if (htab->plt_eh_frame != NULL + && htab->plt_eh_frame->contents != NULL) { - ret->r_info = elf32_r_info; - ret->r_sym = elf32_r_sym; - if (bed->target_id == X86_64_ELF_DATA) + if (htab->elf.splt != NULL + && htab->elf.splt->size != 0 + && (htab->elf.splt->flags & SEC_EXCLUDE) == 0 + && htab->elf.splt->output_section != NULL + && htab->plt_eh_frame->output_section != NULL) { - ret->pointer_r_type = R_X86_64_32; - ret->dynamic_interpreter = ELFX32_DYNAMIC_INTERPRETER; - ret->dynamic_interpreter_size - = sizeof ELFX32_DYNAMIC_INTERPRETER; - ret->tls_get_addr = "__tls_get_addr"; + bfd_vma plt_start = htab->elf.splt->output_section->vma; + bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma + + htab->plt_eh_frame->output_offset + + PLT_FDE_START_OFFSET; + bfd_put_signed_32 (dynobj, plt_start - eh_frame_start, + htab->plt_eh_frame->contents + + PLT_FDE_START_OFFSET); } - else + + if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME) { - ret->pointer_r_type = R_386_32; - ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER; - ret->dynamic_interpreter_size - = sizeof ELF32_DYNAMIC_INTERPRETER; - ret->tls_get_addr = "___tls_get_addr"; + if (! _bfd_elf_write_section_eh_frame (output_bfd, info, + htab->plt_eh_frame, + htab->plt_eh_frame->contents)) + return NULL; } } - ret->loc_hash_table = htab_try_create (1024, - _bfd_x86_elf_local_htab_hash, - _bfd_x86_elf_local_htab_eq, - NULL); - ret->loc_hash_memory = objalloc_create (); - if (!ret->loc_hash_table || !ret->loc_hash_memory) + /* Adjust .eh_frame for .plt.got section. */ + if (htab->plt_got_eh_frame != NULL + && htab->plt_got_eh_frame->contents != NULL) { - elf_x86_link_hash_table_free (abfd); - return NULL; + if (htab->plt_got != NULL + && htab->plt_got->size != 0 + && (htab->plt_got->flags & SEC_EXCLUDE) == 0 + && htab->plt_got->output_section != NULL + && htab->plt_got_eh_frame->output_section != NULL) + { + bfd_vma plt_start = htab->plt_got->output_section->vma; + bfd_vma eh_frame_start = htab->plt_got_eh_frame->output_section->vma + + htab->plt_got_eh_frame->output_offset + + PLT_FDE_START_OFFSET; + bfd_put_signed_32 (dynobj, plt_start - eh_frame_start, + htab->plt_got_eh_frame->contents + + PLT_FDE_START_OFFSET); + } + if (htab->plt_got_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME) + { + if (! _bfd_elf_write_section_eh_frame (output_bfd, info, + htab->plt_got_eh_frame, + htab->plt_got_eh_frame->contents)) + return NULL; + } } - ret->elf.root.hash_table_free = elf_x86_link_hash_table_free; - - return &ret->elf.root; -} - -/* Sort relocs into address order. */ - -int -_bfd_x86_elf_compare_relocs (const void *ap, const void *bp) -{ - const arelent *a = * (const arelent **) ap; - const arelent *b = * (const arelent **) bp; - - if (a->address > b->address) - return 1; - else if (a->address < b->address) - return -1; - else - return 0; -} -bfd_boolean -_bfd_x86_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info) -{ - if (!bfd_link_relocatable (info)) + /* Adjust .eh_frame for the second PLT section. */ + if (htab->plt_second_eh_frame != NULL + && htab->plt_second_eh_frame->contents != NULL) { - /* Check for __tls_get_addr reference. */ - struct elf_x86_link_hash_table *htab; - const struct elf_backend_data *bed = get_elf_backend_data (abfd); - htab = elf_x86_hash_table (info, bed->target_id); - if (htab) + if (htab->plt_second != NULL + && htab->plt_second->size != 0 + && (htab->plt_second->flags & SEC_EXCLUDE) == 0 + && htab->plt_second->output_section != NULL + && htab->plt_second_eh_frame->output_section != NULL) { - struct elf_link_hash_entry *h - = elf_link_hash_lookup (elf_hash_table (info), - htab->tls_get_addr, - FALSE, FALSE, FALSE); - if (h != NULL) - ((struct elf_x86_link_hash_entry *) h)->tls_get_addr = 1; + bfd_vma plt_start = htab->plt_second->output_section->vma; + bfd_vma eh_frame_start + = (htab->plt_second_eh_frame->output_section->vma + + htab->plt_second_eh_frame->output_offset + + PLT_FDE_START_OFFSET); + bfd_put_signed_32 (dynobj, plt_start - eh_frame_start, + htab->plt_second_eh_frame->contents + + PLT_FDE_START_OFFSET); + } + if (htab->plt_second_eh_frame->sec_info_type + == SEC_INFO_TYPE_EH_FRAME) + { + if (! _bfd_elf_write_section_eh_frame (output_bfd, info, + htab->plt_second_eh_frame, + htab->plt_second_eh_frame->contents)) + return NULL; } } - /* Invoke the regular ELF backend linker to do all the work. */ - return _bfd_elf_link_check_relocs (abfd, info); + if (htab->elf.sgot && htab->elf.sgot->size > 0) + elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize + = htab->got_entry_size; + + return htab; } + bfd_boolean _bfd_x86_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info) @@ -431,37 +1729,6 @@ _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info *info, edir = (struct elf_x86_link_hash_entry *) dir; eind = (struct elf_x86_link_hash_entry *) ind; - if (eind->dyn_relocs != NULL) - { - if (edir->dyn_relocs != NULL) - { - struct elf_dyn_relocs **pp; - struct elf_dyn_relocs *p; - - /* Add reloc counts against the indirect sym to the direct sym - list. Merge any entries against the same section. */ - for (pp = &eind->dyn_relocs; (p = *pp) != NULL; ) - { - struct elf_dyn_relocs *q; - - for (q = edir->dyn_relocs; q != NULL; q = q->next) - if (q->sec == p->sec) - { - q->pc_count += p->pc_count; - q->count += p->count; - *pp = p->next; - break; - } - if (q == NULL) - pp = &p->next; - } - *pp = edir->dyn_relocs; - } - - edir->dyn_relocs = eind->dyn_relocs; - eind->dyn_relocs = NULL; - } - if (ind->root.type == bfd_link_hash_indirect && dir->got.refcount <= 0) { @@ -473,8 +1740,7 @@ _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info *info, generate a R_386_COPY reloc. */ edir->gotoff_ref |= eind->gotoff_ref; - edir->has_got_reloc |= eind->has_got_reloc; - edir->has_non_got_reloc |= eind->has_non_got_reloc; + edir->zero_undefweak |= eind->zero_undefweak; if (ELIMINATE_COPY_RELOCS && ind->root.type != bfd_link_hash_indirect @@ -491,15 +1757,7 @@ _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info *info, dir->pointer_equality_needed |= ind->pointer_equality_needed; } else - { - if (eind->func_pointer_refcount > 0) - { - edir->func_pointer_refcount += eind->func_pointer_refcount; - eind->func_pointer_refcount = 0; - } - - _bfd_elf_link_hash_copy_indirect (info, dir, ind); - } + _bfd_elf_link_hash_copy_indirect (info, dir, ind); } /* Remove undefined weak symbol from the dynamic symbol table if it @@ -509,21 +1767,60 @@ bfd_boolean _bfd_x86_elf_fixup_symbol (struct bfd_link_info *info, struct elf_link_hash_entry *h) { - if (h->dynindx != -1) + if (h->dynindx != -1 + && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, elf_x86_hash_entry (h))) { - const struct elf_backend_data *bed - = get_elf_backend_data (info->output_bfd); - if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, - bed->target_id, - elf_x86_hash_entry (h)->has_got_reloc, - elf_x86_hash_entry (h))) + h->dynindx = -1; + _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr, + h->dynstr_index); + } + return TRUE; +} + +/* Change the STT_GNU_IFUNC symbol defined in position-dependent + executable into the normal function symbol and set its address + to its PLT entry, which should be resolved by R_*_IRELATIVE at + run-time. */ + +void +_bfd_x86_elf_link_fixup_ifunc_symbol (struct bfd_link_info *info, + struct elf_x86_link_hash_table *htab, + struct elf_link_hash_entry *h, + Elf_Internal_Sym *sym) +{ + if (bfd_link_pde (info) + && h->def_regular + && h->dynindx != -1 + && h->plt.offset != (bfd_vma) -1 + && h->type == STT_GNU_IFUNC + && h->pointer_equality_needed) + { + asection *plt_s; + bfd_vma plt_offset; + bfd *output_bfd = info->output_bfd; + + if (htab->plt_second) { - h->dynindx = -1; - _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr, - h->dynstr_index); + struct elf_x86_link_hash_entry *eh + = (struct elf_x86_link_hash_entry *) h; + + plt_s = htab->plt_second; + plt_offset = eh->plt_second.offset; + } + else + { + plt_s = htab->elf.splt; + plt_offset = h->plt.offset; } + + sym->st_size = 0; + sym->st_info = ELF_ST_INFO (ELF_ST_BIND (sym->st_info), STT_FUNC); + sym->st_shndx + = _bfd_elf_section_from_bfd_section (output_bfd, + plt_s->output_section); + sym->st_value = (plt_s->output_section->vma + + plt_s->output_offset + plt_offset); } - return TRUE; } /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */ @@ -568,7 +1865,7 @@ _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info *info, struct elf_dyn_relocs **pp; eh = (struct elf_x86_link_hash_entry *) h; - for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) + for (pp = &h->dyn_relocs; (p = *pp) != NULL; ) { pc_count += p->pc_count; p->count -= p->pc_count; @@ -639,19 +1936,19 @@ _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info *info, /* If this is a weak symbol, and there is a real definition, the processor independent code will have arranged for us to see the real definition first, and we can just use the same value. */ - if (h->u.weakdef != NULL) + if (h->is_weakalias) { - BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined - || h->u.weakdef->root.type == bfd_link_hash_defweak); - h->root.u.def.section = h->u.weakdef->root.u.def.section; - h->root.u.def.value = h->u.weakdef->root.u.def.value; + struct elf_link_hash_entry *def = weakdef (h); + BFD_ASSERT (def->root.type == bfd_link_hash_defined); + h->root.u.def.section = def->root.u.def.section; + h->root.u.def.value = def->root.u.def.value; if (ELIMINATE_COPY_RELOCS || info->nocopyreloc || SYMBOL_NO_COPYRELOC (info, eh)) { /* NB: needs_copy is always 0 for i386. */ - h->non_got_ref = h->u.weakdef->non_got_ref; - eh->needs_copy = h->u.weakdef->needs_copy; + h->non_got_ref = def->non_got_ref; + eh->needs_copy = def->needs_copy; } return TRUE; } @@ -691,19 +1988,12 @@ _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info *info, if (ELIMINATE_COPY_RELOCS && (bed->target_id == X86_64_ELF_DATA || (!eh->gotoff_ref - && !htab->is_vxworks))) + && htab->target_os != is_vxworks))) { - for (p = eh->dyn_relocs; p != NULL; p = p->next) - { - s = p->sec->output_section; - if (s != NULL && (s->flags & SEC_READONLY) != 0) - break; - } - - /* If we didn't find any dynamic relocs in read-only sections, + /* If we don't find any dynamic relocs in read-only sections, then we'll be keeping the dynamic relocs and avoiding the copy reloc. */ - if (p == NULL) + if (!_bfd_elf_readonly_dynrelocs (h)) { h->non_got_ref = 0; return TRUE; @@ -735,15 +2025,77 @@ _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info *info, } if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0) { - srel->size += ((bed->target_id == I386_ELF_DATA) - ? sizeof (Elf32_External_Rel) - : bed->s->sizeof_rela); + srel->size += htab->sizeof_reloc; h->needs_copy = 1; } return _bfd_elf_adjust_dynamic_copy (info, h, s); } +void +_bfd_x86_elf_hide_symbol (struct bfd_link_info *info, + struct elf_link_hash_entry *h, + bfd_boolean force_local) +{ + if (h->root.type == bfd_link_hash_undefweak + && info->nointerp + && bfd_link_pie (info)) + { + /* When there is no dynamic interpreter in PIE, make the undefined + weak symbol dynamic so that PC relative branch to the undefined + weak symbol will land to address 0. */ + struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h); + if (h->plt.refcount > 0 + || eh->plt_got.refcount > 0) + return; + } + + _bfd_elf_link_hash_hide_symbol (info, h, force_local); +} + +/* Return TRUE if a symbol is referenced locally. It is similar to + SYMBOL_REFERENCES_LOCAL, but it also checks version script. It + works in check_relocs. */ + +bfd_boolean +_bfd_x86_elf_link_symbol_references_local (struct bfd_link_info *info, + struct elf_link_hash_entry *h) +{ + struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h); + struct elf_x86_link_hash_table *htab + = (struct elf_x86_link_hash_table *) info->hash; + + if (eh->local_ref > 1) + return TRUE; + + if (eh->local_ref == 1) + return FALSE; + + /* Unversioned symbols defined in regular objects can be forced local + by linker version script. A weak undefined symbol is forced local + if + 1. It has non-default visibility. Or + 2. When building executable, there is no dynamic linker. Or + 3. or "-z nodynamic-undefined-weak" is used. + */ + if (SYMBOL_REFERENCES_LOCAL (info, h) + || (h->root.type == bfd_link_hash_undefweak + && (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT + || (bfd_link_executable (info) + && htab->interp == NULL) + || info->dynamic_undefined_weak == 0)) + || ((h->def_regular || ELF_COMMON_DEF_P (h)) + && info->version_info != NULL + && _bfd_elf_link_hide_sym_by_version (info, h))) + { + eh->local_ref = 2; + return TRUE; + } + + eh->local_ref = 1; + return FALSE; +} + /* Return the section that should be marked against GC for a given relocation. */ @@ -828,15 +2180,18 @@ _bfd_x86_elf_get_synthetic_symtab (bfd *abfd, bfd_vma); bfd_boolean (*valid_plt_reloc_p) (unsigned int); + dynrelbuf = NULL; if (count == 0) - return -1; + goto bad_return; dynrelbuf = (arelent **) bfd_malloc (relsize); if (dynrelbuf == NULL) - return -1; + goto bad_return; dynrelcount = bfd_canonicalize_dynamic_reloc (abfd, dynrelbuf, dynsyms); + if (dynrelcount <= 0) + goto bad_return; /* Sort the relocs by address. */ qsort (dynrelbuf, dynrelcount, sizeof (arelent *), @@ -990,6 +2345,10 @@ _bfd_x86_elf_get_synthetic_symtab (bfd *abfd, names += sizeof ("@plt"); n++; s++; + /* There should be only one entry in PLT for a given + symbol. Set howto to NULL after processing a PLT + entry to guard against corrupted PLT. */ + p->howto = NULL; } offset += plt_entry_size; } @@ -998,15 +2357,14 @@ _bfd_x86_elf_get_synthetic_symtab (bfd *abfd, /* PLT entries with R_386_TLS_DESC relocations are skipped. */ if (n == 0) { -bad_return: + bad_return: count = -1; } else count = n; for (j = 0; plts[j].name != NULL; j++) - if (plts[j].contents != NULL) - free (plts[j].contents); + free (plts[j].contents); free (dynrelbuf); @@ -1021,33 +2379,29 @@ _bfd_x86_elf_parse_gnu_properties (bfd *abfd, unsigned int type, { elf_property *prop; - switch (type) + if (type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED + || type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED + || (type >= GNU_PROPERTY_X86_UINT32_AND_LO + && type <= GNU_PROPERTY_X86_UINT32_AND_HI) + || (type >= GNU_PROPERTY_X86_UINT32_OR_LO + && type <= GNU_PROPERTY_X86_UINT32_OR_HI) + || (type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO + && type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI)) { - case GNU_PROPERTY_X86_ISA_1_USED: - case GNU_PROPERTY_X86_ISA_1_NEEDED: - case GNU_PROPERTY_X86_FEATURE_1_AND: if (datasz != 4) { _bfd_error_handler - ((type == GNU_PROPERTY_X86_ISA_1_USED - ? _("error: %B: ") - : (type == GNU_PROPERTY_X86_ISA_1_NEEDED - ? _("error: %B: ") - : _("error: %B: "))), - abfd, datasz); + (_("error: %pB: "), + abfd, type, datasz); return property_corrupt; } prop = _bfd_elf_get_property (abfd, type, datasz); - /* Combine properties of the same type. */ prop->u.number |= bfd_h_get_32 (abfd, ptr); prop->pr_kind = property_number; - break; - - default: - return property_ignored; + return property_number; } - return property_number; + return property_ignored; } /* Merge x86 GNU property BPROP with APROP. If APROP isn't NULL, @@ -1057,6 +2411,7 @@ _bfd_x86_elf_parse_gnu_properties (bfd *abfd, unsigned int type, bfd_boolean _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info *info, bfd *abfd ATTRIBUTE_UNUSED, + bfd *bbfd ATTRIBUTE_UNUSED, elf_property *aprop, elf_property *bprop) { @@ -1064,36 +2419,88 @@ _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info *info, bfd_boolean updated = FALSE; unsigned int pr_type = aprop != NULL ? aprop->pr_type : bprop->pr_type; - switch (pr_type) + if (pr_type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED + || (pr_type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO + && pr_type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI)) { - case GNU_PROPERTY_X86_ISA_1_USED: - case GNU_PROPERTY_X86_ISA_1_NEEDED: - if (aprop != NULL && bprop != NULL) + if (aprop == NULL || bprop == NULL) + { + /* Only one of APROP and BPROP can be NULL. */ + if (aprop != NULL) + { + /* Remove this property since the other input file doesn't + have it. */ + aprop->pr_kind = property_remove; + updated = TRUE; + } + } + else { number = aprop->u.number; aprop->u.number = number | bprop->u.number; updated = number != (unsigned int) aprop->u.number; } + return updated; + } + else if (pr_type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED + || (pr_type >= GNU_PROPERTY_X86_UINT32_OR_LO + && pr_type <= GNU_PROPERTY_X86_UINT32_OR_HI)) + { + if (aprop != NULL && bprop != NULL) + { + number = aprop->u.number; + aprop->u.number = number | bprop->u.number; + /* Remove the property if all bits are empty. */ + if (aprop->u.number == 0) + { + aprop->pr_kind = property_remove; + updated = TRUE; + } + else + updated = number != (unsigned int) aprop->u.number; + } else { - /* Return TRUE if APROP is NULL to indicate that BPROP should - be added to ABFD. */ - updated = aprop == NULL; + /* Only one of APROP and BPROP can be NULL. */ + if (aprop != NULL) + { + if (aprop->u.number == 0) + { + /* Remove APROP if all bits are empty. */ + aprop->pr_kind = property_remove; + updated = TRUE; + } + } + else + { + /* Return TRUE if APROP is NULL and all bits of BPROP + aren't empty to indicate that BPROP should be added + to ABFD. */ + updated = bprop->u.number != 0; + } } - break; - - case GNU_PROPERTY_X86_FEATURE_1_AND: + return updated; + } + else if (pr_type >= GNU_PROPERTY_X86_UINT32_AND_LO + && pr_type <= GNU_PROPERTY_X86_UINT32_AND_HI) + { /* Only one of APROP and BPROP can be NULL: 1. APROP & BPROP when both APROP and BPROP aren't NULL. 2. If APROP is NULL, remove x86 feature. 3. Otherwise, do nothing. */ + const struct elf_backend_data *bed + = get_elf_backend_data (info->output_bfd); + struct elf_x86_link_hash_table *htab + = elf_x86_hash_table (info, bed->target_id); + if (!htab) + abort (); if (aprop != NULL && bprop != NULL) { features = 0; - if (info->ibt) + if (htab->params->ibt) features = GNU_PROPERTY_X86_FEATURE_1_IBT; - if (info->shstk) + if (htab->params->shstk) features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK; number = aprop->u.number; /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and @@ -1106,25 +2513,25 @@ _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info *info, } else { + /* There should be no AND properties since some input doesn't + have them. Set IBT and SHSTK properties for -z ibt and -z + shstk if needed. */ features = 0; - if (info->ibt) + if (htab->params->ibt) features = GNU_PROPERTY_X86_FEATURE_1_IBT; - if (info->shstk) + if (htab->params->shstk) features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK; if (features) { - /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and - GNU_PROPERTY_X86_FEATURE_1_SHSTK. */ if (aprop != NULL) { - number = aprop->u.number; - aprop->u.number = number | features; - updated = number != (unsigned int) aprop->u.number; + updated = features != (unsigned int) aprop->u.number; + aprop->u.number = features; } else { - bprop->u.number |= features; updated = TRUE; + bprop->u.number = features; } } else if (aprop != NULL) @@ -1133,9 +2540,10 @@ _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info *info, updated = TRUE; } } - break; - - default: + return updated; + } + else + { /* Never should happen. */ abort (); } @@ -1148,8 +2556,7 @@ _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info *info, bfd * _bfd_x86_elf_link_setup_gnu_properties - (struct bfd_link_info *info, - struct elf_x86_plt_layout_table *plt_layout) + (struct bfd_link_info *info, struct elf_x86_init_table *init_table) { bfd_boolean normal_target; bfd_boolean lazy_plt; @@ -1165,12 +2572,6 @@ _bfd_x86_elf_link_setup_gnu_properties unsigned int class_align = ABI_64_P (info->output_bfd) ? 3 : 2; unsigned int got_align; - features = 0; - if (info->ibt) - features = GNU_PROPERTY_X86_FEATURE_1_IBT; - if (info->shstk) - features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK; - /* Find a normal input file with GNU property note. */ for (pbfd = info->input_bfds; pbfd != NULL; @@ -1184,18 +2585,42 @@ _bfd_x86_elf_link_setup_gnu_properties break; } - if (ebfd != NULL && features) + bed = get_elf_backend_data (info->output_bfd); + + htab = elf_x86_hash_table (info, bed->target_id); + if (htab == NULL) + return pbfd; + + features = 0; + if (htab->params->ibt) { - /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and - GNU_PROPERTY_X86_FEATURE_1_SHSTK. */ - prop = _bfd_elf_get_property (ebfd, - GNU_PROPERTY_X86_FEATURE_1_AND, - 4); - prop->u.number |= features; - prop->pr_kind = property_number; + features = GNU_PROPERTY_X86_FEATURE_1_IBT; + htab->params->cet_report &= ~cet_report_ibt; + } + if (htab->params->shstk) + { + features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK; + htab->params->cet_report &= ~cet_report_shstk; + } + if (!(htab->params->cet_report & (cet_report_ibt | cet_report_shstk))) + htab->params->cet_report = cet_report_none; + + if (ebfd != NULL) + { + prop = NULL; + if (features) + { + /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and + GNU_PROPERTY_X86_FEATURE_1_SHSTK. */ + prop = _bfd_elf_get_property (ebfd, + GNU_PROPERTY_X86_FEATURE_1_AND, + 4); + prop->u.number |= features; + prop->pr_kind = property_number; + } /* Create the GNU property note section if needed. */ - if (pbfd == NULL) + if (prop != NULL && pbfd == NULL) { sec = bfd_make_section_with_flags (ebfd, NOTE_GNU_PROPERTY_SECTION_NAME, @@ -1206,12 +2631,12 @@ _bfd_x86_elf_link_setup_gnu_properties | SEC_HAS_CONTENTS | SEC_DATA)); if (sec == NULL) - info->callbacks->einfo (_("%F: failed to create GNU property section\n")); + info->callbacks->einfo (_("%F%P: failed to create GNU property section\n")); - if (!bfd_set_section_alignment (ebfd, sec, class_align)) + if (!bfd_set_section_alignment (sec, class_align)) { -error_alignment: - info->callbacks->einfo (_("%F%A: failed to align section\n"), + error_alignment: + info->callbacks->einfo (_("%F%pA: failed to align section\n"), sec); } @@ -1219,20 +2644,65 @@ error_alignment: } } - pbfd = _bfd_elf_link_setup_gnu_properties (info); + if (htab->params->cet_report) + { + /* Report missing IBT and SHSTK properties. */ + bfd *abfd; + const char *msg; + elf_property_list *p; + bfd_boolean missing_ibt, missing_shstk; + bfd_boolean check_ibt + = !!(htab->params->cet_report & cet_report_ibt); + bfd_boolean check_shstk + = !!(htab->params->cet_report & cet_report_shstk); + + if ((htab->params->cet_report & cet_report_warning)) + msg = _("%P: %pB: warning: missing %s\n"); + else + msg = _("%X%P: %pB: error: missing %s\n"); - if (bfd_link_relocatable (info)) - return pbfd; + for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next) + if (!(abfd->flags & (DYNAMIC | BFD_PLUGIN | BFD_LINKER_CREATED)) + && bfd_get_flavour (abfd) == bfd_target_elf_flavour) + { + for (p = elf_properties (abfd); p; p = p->next) + if (p->property.pr_type == GNU_PROPERTY_X86_FEATURE_1_AND) + break; - bed = get_elf_backend_data (info->output_bfd); + missing_ibt = check_ibt; + missing_shstk = check_shstk; + if (p) + { + missing_ibt &= !(p->property.u.number + & GNU_PROPERTY_X86_FEATURE_1_IBT); + missing_shstk &= !(p->property.u.number + & GNU_PROPERTY_X86_FEATURE_1_SHSTK); + } + if (missing_ibt || missing_shstk) + { + const char *missing; + if (missing_ibt && missing_shstk) + missing = _("IBT and SHSTK properties"); + else if (missing_ibt) + missing = _("IBT property"); + else + missing = _("SHSTK property"); + info->callbacks->einfo (msg, abfd, missing); + } + } + } - htab = elf_x86_hash_table (info, bed->target_id); - if (htab == NULL) + pbfd = _bfd_elf_link_setup_gnu_properties (info); + + htab->r_info = init_table->r_info; + htab->r_sym = init_table->r_sym; + + if (bfd_link_relocatable (info)) return pbfd; - htab->is_vxworks = plt_layout->is_vxworks; + htab->plt0_pad_byte = init_table->plt0_pad_byte; - use_ibt_plt = info->ibtplt || info->ibt; + use_ibt_plt = htab->params->ibtplt || htab->params->ibt; if (!use_ibt_plt && pbfd != NULL) { /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on. */ @@ -1274,7 +2744,9 @@ error_alignment: abfd = abfd->link.next) if (bfd_get_flavour (abfd) == bfd_target_elf_flavour && (abfd->flags - & (DYNAMIC | BFD_LINKER_CREATED | BFD_PLUGIN)) == 0) + & (DYNAMIC | BFD_LINKER_CREATED | BFD_PLUGIN)) == 0 + && bed->relocs_compatible (abfd->xvec, + info->output_bfd->xvec)) { htab->elf.dynobj = abfd; dynobj = abfd; @@ -1283,28 +2755,32 @@ error_alignment: } } + /* Return if there are no normal input files. */ + if (dynobj == NULL) + return pbfd; + /* Even when lazy binding is disabled by "-z now", the PLT0 entry may still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for canonical function address. */ htab->plt.has_plt0 = 1; - normal_target = plt_layout->normal_target; + normal_target = htab->target_os == is_normal; if (normal_target) { if (use_ibt_plt) { - htab->lazy_plt = plt_layout->lazy_ibt_plt; - htab->non_lazy_plt = plt_layout->non_lazy_ibt_plt; + htab->lazy_plt = init_table->lazy_ibt_plt; + htab->non_lazy_plt = init_table->non_lazy_ibt_plt; } else { - htab->lazy_plt = plt_layout->lazy_plt; - htab->non_lazy_plt = plt_layout->non_lazy_plt; + htab->lazy_plt = init_table->lazy_plt; + htab->non_lazy_plt = init_table->non_lazy_plt; } } else { - htab->lazy_plt = plt_layout->lazy_plt; + htab->lazy_plt = init_table->lazy_plt; htab->non_lazy_plt = NULL; } @@ -1350,15 +2826,11 @@ error_alignment: htab->plt.eh_frame_plt = htab->lazy_plt->eh_frame_plt; } - /* Return if there are no normal input files. */ - if (dynobj == NULL) - return pbfd; - - if (htab->is_vxworks + if (htab->target_os == is_vxworks && !elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2)) { - info->callbacks->einfo (_("%F: failed to create VxWorks dynamic sections\n")); + info->callbacks->einfo (_("%F%P: failed to create VxWorks dynamic sections\n")); return pbfd; } @@ -1367,7 +2839,7 @@ error_alignment: don't need to do it in check_relocs. */ if (htab->elf.sgot == NULL && !_bfd_elf_create_got_section (dynobj, info)) - info->callbacks->einfo (_("%F: failed to create GOT sections\n")); + info->callbacks->einfo (_("%F%P: failed to create GOT sections\n")); got_align = (bed->target_id == X86_64_ELF_DATA) ? 3 : 2; @@ -1375,17 +2847,17 @@ error_alignment: instead of in create_dynamic_sections so that they are always properly aligned even if create_dynamic_sections isn't called. */ sec = htab->elf.sgot; - if (!bfd_set_section_alignment (dynobj, sec, got_align)) + if (!bfd_set_section_alignment (sec, got_align)) goto error_alignment; sec = htab->elf.sgotplt; - if (!bfd_set_section_alignment (dynobj, sec, got_align)) + if (!bfd_set_section_alignment (sec, got_align)) goto error_alignment; /* Create the ifunc sections here so that check_relocs can be simplified. */ if (!_bfd_elf_create_ifunc_sections (dynobj, info)) - info->callbacks->einfo (_("%F: failed to create ifunc sections\n")); + info->callbacks->einfo (_("%F%P: failed to create ifunc sections\n")); plt_alignment = bfd_log2 (htab->plt.plt_entry_size); @@ -1417,8 +2889,7 @@ error_alignment: = bfd_log2 (htab->non_lazy_plt->plt_entry_size); sec = pltsec; - if (!bfd_set_section_alignment (sec->owner, sec, - plt_alignment)) + if (!bfd_set_section_alignment (sec, plt_alignment)) goto error_alignment; /* Create the GOT procedure linkage table. */ @@ -1426,10 +2897,9 @@ error_alignment: ".plt.got", pltflags); if (sec == NULL) - info->callbacks->einfo (_("%F: failed to create GOT PLT section\n")); + info->callbacks->einfo (_("%F%P: failed to create GOT PLT section\n")); - if (!bfd_set_section_alignment (dynobj, sec, - non_lazy_plt_alignment)) + if (!bfd_set_section_alignment (sec, non_lazy_plt_alignment)) goto error_alignment; htab->plt_got = sec; @@ -1447,13 +2917,12 @@ error_alignment: ".plt.sec", pltflags); if (sec == NULL) - info->callbacks->einfo (_("%F: failed to create IBT-enabled PLT section\n")); + info->callbacks->einfo (_("%F%P: failed to create IBT-enabled PLT section\n")); - if (!bfd_set_section_alignment (dynobj, sec, - plt_alignment)) + if (!bfd_set_section_alignment (sec, plt_alignment)) goto error_alignment; } - else if (info->bndplt && ABI_64_P (dynobj)) + else if (htab->params->bndplt && ABI_64_P (dynobj)) { /* Create the second PLT for Intel MPX support. MPX PLT is supported only for non-NaCl target in 64-bit @@ -1462,10 +2931,9 @@ error_alignment: ".plt.sec", pltflags); if (sec == NULL) - info->callbacks->einfo (_("%F: failed to create BND PLT section\n")); + info->callbacks->einfo (_("%F%P: failed to create BND PLT section\n")); - if (!bfd_set_section_alignment (dynobj, sec, - non_lazy_plt_alignment)) + if (!bfd_set_section_alignment (sec, non_lazy_plt_alignment)) goto error_alignment; } @@ -1483,9 +2951,9 @@ error_alignment: ".eh_frame", flags); if (sec == NULL) - info->callbacks->einfo (_("%F: failed to create PLT .eh_frame section\n")); + info->callbacks->einfo (_("%F%P: failed to create PLT .eh_frame section\n")); - if (!bfd_set_section_alignment (dynobj, sec, class_align)) + if (!bfd_set_section_alignment (sec, class_align)) goto error_alignment; htab->plt_eh_frame = sec; @@ -1496,9 +2964,9 @@ error_alignment: ".eh_frame", flags); if (sec == NULL) - info->callbacks->einfo (_("%F: failed to create GOT PLT .eh_frame section\n")); + info->callbacks->einfo (_("%F%P: failed to create GOT PLT .eh_frame section\n")); - if (!bfd_set_section_alignment (dynobj, sec, class_align)) + if (!bfd_set_section_alignment (sec, class_align)) goto error_alignment; htab->plt_got_eh_frame = sec; @@ -1510,9 +2978,9 @@ error_alignment: ".eh_frame", flags); if (sec == NULL) - info->callbacks->einfo (_("%F: failed to create the second PLT .eh_frame section\n")); + info->callbacks->einfo (_("%F%P: failed to create the second PLT .eh_frame section\n")); - if (!bfd_set_section_alignment (dynobj, sec, class_align)) + if (!bfd_set_section_alignment (sec, class_align)) goto error_alignment; htab->plt_second_eh_frame = sec; @@ -1520,16 +2988,96 @@ error_alignment: } } - if (normal_target) + /* The .iplt section is used for IFUNC symbols in static + executables. */ + sec = htab->elf.iplt; + if (sec != NULL) { - /* The .iplt section is used for IFUNC symbols in static - executables. */ - sec = htab->elf.iplt; - if (sec != NULL - && !bfd_set_section_alignment (sec->owner, sec, - plt_alignment)) + /* NB: Delay setting its alignment until we know it is non-empty. + Otherwise an empty iplt section may change vma and lma of the + following sections, which triggers moving dot of the following + section backwards, resulting in a warning and section lma not + being set properly. It later leads to a "File truncated" + error. */ + if (!bfd_set_section_alignment (sec, 0)) goto error_alignment; + + htab->plt.iplt_alignment = (normal_target + ? plt_alignment + : bed->plt_alignment); + } + + if (bfd_link_executable (info) + && !info->nointerp + && !htab->params->has_dynamic_linker + && htab->params->static_before_all_inputs) + { + /* Report error for dynamic input objects if -static is passed at + command-line before all input files without --dynamic-linker + unless --no-dynamic-linker is used. */ + bfd *abfd; + + for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next) + if ((abfd->flags & DYNAMIC)) + info->callbacks->einfo + (_("%X%P: attempted static link of dynamic object `%pB'\n"), + abfd); } return pbfd; } + +/* Fix up x86 GNU properties. */ + +void +_bfd_x86_elf_link_fixup_gnu_properties + (struct bfd_link_info *info ATTRIBUTE_UNUSED, + elf_property_list **listp) +{ + elf_property_list *p; + + for (p = *listp; p; p = p->next) + { + unsigned int type = p->property.pr_type; + if (type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED + || type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED + || (type >= GNU_PROPERTY_X86_UINT32_AND_LO + && type <= GNU_PROPERTY_X86_UINT32_AND_HI) + || (type >= GNU_PROPERTY_X86_UINT32_OR_LO + && type <= GNU_PROPERTY_X86_UINT32_OR_HI) + || (type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO + && type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI)) + { + if (p->property.u.number == 0 + && (type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED + || (type >= GNU_PROPERTY_X86_UINT32_AND_LO + && type <= GNU_PROPERTY_X86_UINT32_AND_HI) + || (type >= GNU_PROPERTY_X86_UINT32_OR_LO + && type <= GNU_PROPERTY_X86_UINT32_OR_HI))) + { + /* Remove empty property. */ + *listp = p->next; + continue; + } + + listp = &p->next; + } + else if (type > GNU_PROPERTY_HIPROC) + { + /* The property list is sorted in order of type. */ + break; + } + } +} + +void +_bfd_elf_linker_x86_set_options (struct bfd_link_info * info, + struct elf_linker_x86_params *params) +{ + const struct elf_backend_data *bed + = get_elf_backend_data (info->output_bfd); + struct elf_x86_link_hash_table *htab + = elf_x86_hash_table (info, bed->target_id); + if (htab != NULL) + htab->params = params; +}