X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=bfd%2Felfxx-x86.c;h=7ccfd2581526ea4e71044bef1fb1f127537c1d6b;hb=b7dc48b4a8006abb552c5e7d22f9841c86f2537d;hp=874799ea0253c62175e2da8c1cacb359cc672ac1;hpb=5e2ac45d561dffec63af4c83a545b46db032c70c;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/elfxx-x86.c b/bfd/elfxx-x86.c index 874799ea02..7ccfd25815 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-2018 Free Software Foundation, Inc. This file is part of BFD, the Binary File Descriptor library. @@ -83,8 +83,7 @@ _bfd_x86_elf_dtpoff_base (struct bfd_link_info *info) dynamic relocs. */ static bfd_boolean -elf_x86_allocate_dynrelocs (struct elf_link_hash_entry *h, - void *inf) +elf_x86_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) { struct bfd_link_info *info; struct elf_x86_link_hash_table *htab; @@ -107,15 +106,7 @@ elf_x86_allocate_dynrelocs (struct elf_link_hash_entry *h, plt_entry_size = htab->plt.plt_entry_size; - resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, - bed->target_id, - eh->has_got_reloc, - eh); - - /* Clear the reference count of function pointer relocations if - symbol isn't a normal function. */ - if (h->type != STT_FUNC) - eh->func_pointer_refcount = 0; + 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 @@ -128,7 +119,7 @@ elf_x86_allocate_dynrelocs (struct elf_link_hash_entry *h, && h->got.refcount > 0) { /* Don't use the regular PLT if there are both GOT and GOTPLT - reloctions. */ + reloctions. */ h->plt.offset = (bfd_vma) -1; /* Use the GOT PLT. */ @@ -166,15 +157,11 @@ elf_x86_allocate_dynrelocs (struct elf_link_hash_entry *h, /* 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 > eh->func_pointer_refcount + && (h->plt.refcount > 0 || eh->plt_got.refcount > 0)) { bfd_boolean use_plt_got = eh->plt_got.refcount > 0; - /* Clear the reference count of function pointer relocations - if PLT is used. */ - eh->func_pointer_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 @@ -192,6 +179,7 @@ elf_x86_allocate_dynrelocs (struct elf_link_hash_entry *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 @@ -209,12 +197,19 @@ elf_x86_allocate_dynrelocs (struct elf_link_hash_entry *h, } /* If this symbol is not defined in a regular file, and we are - not generating a shared library, then set the symbol to this - location in the .plt. This is required to make function - pointers compare as equal between the normal executable and - the shared library. */ - if (! bfd_link_pic (info) - && !h->def_regular) + 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) { @@ -265,7 +260,7 @@ elf_x86_allocate_dynrelocs (struct elf_link_hash_entry *h, } } - if (htab->is_vxworks && !bfd_link_pic (info)) + 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, @@ -368,7 +363,11 @@ elf_x86_allocate_dynrelocs (struct elf_link_hash_entry *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; + { + 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; @@ -405,7 +404,7 @@ elf_x86_allocate_dynrelocs (struct elf_link_hash_entry *h, } } - if (htab->is_vxworks) + if (htab->target_os == is_vxworks) { struct elf_dyn_relocs **pp; for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) @@ -488,7 +487,6 @@ elf_x86_allocate_dynrelocs (struct elf_link_hash_entry *h, pointer initialization. */ if ((!h->non_got_ref - || eh->func_pointer_refcount > 0 || (h->root.type == bfd_link_hash_undefweak && !resolved_to_zero)) && ((h->def_dynamic @@ -513,7 +511,6 @@ elf_x86_allocate_dynrelocs (struct elf_link_hash_entry *h, } eh->dyn_relocs = NULL; - eh->func_pointer_refcount = 0; keep: ; } @@ -532,40 +529,58 @@ elf_x86_allocate_dynrelocs (struct elf_link_hash_entry *h, return TRUE; } -/* Find any dynamic relocs that apply to read-only sections. */ +/* Find dynamic relocs for H that apply to read-only sections. */ -bfd_boolean -_bfd_x86_elf_readonly_dynrelocs (struct elf_link_hash_entry *h, - void *inf) +static asection * +readonly_dynrelocs (struct elf_link_hash_entry *h) { - struct elf_x86_link_hash_entry *eh; struct elf_dyn_relocs *p; - /* Skip local IFUNC symbols. */ - if (h->forced_local && h->type == STT_GNU_IFUNC) - return TRUE; - - eh = (struct elf_x86_link_hash_entry *) h; - for (p = eh->dyn_relocs; p != NULL; p = p->next) + for (p = elf_x86_hash_entry (h)->dyn_relocs; p != NULL; p = p->next) { asection *s = p->sec->output_section; if (s != NULL && (s->flags & SEC_READONLY) != 0) - { - struct bfd_link_info *info = (struct bfd_link_info *) inf; + return p->sec; + } + return NULL; +} - info->flags |= DF_TEXTREL; +/* Set DF_TEXTREL if we find any dynamic relocs that apply to + read-only sections. */ - 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); +static bfd_boolean +maybe_set_textrel (struct elf_link_hash_entry *h, void *inf) +{ + asection *sec; - /* Not an error, just cut short the traversal. */ - return FALSE; - } + if (h->root.type == bfd_link_hash_indirect) + return TRUE; + + /* Skip local IFUNC symbols. */ + if (h->forced_local && h->type == STT_GNU_IFUNC) + return TRUE; + + sec = readonly_dynrelocs (h); + if (sec != NULL) + { + struct bfd_link_info *info = (struct bfd_link_info *) inf; + + info->flags |= DF_TEXTREL; + /* xgettext:c-format */ + info->callbacks->minfo (_("%pB: dynamic relocation against `%pT' " + "in read-only section `%pA'\n"), + sec->owner, h->root.root.string, sec); + + if ((info->warn_shared_textrel && bfd_link_pic (info)) + || info->error_textrel) + /* xgettext:c-format */ + info->callbacks->einfo (_("%P: %pB: warning: relocation against `%s' " + "in read-only section `%pA'\n"), + sec->owner, h->root.root.string, sec); + + /* Not an error, just cut short the traversal. */ + return FALSE; } return TRUE; } @@ -675,6 +690,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; @@ -727,13 +743,11 @@ elf_i386_is_reloc_section (const char *secname) return CONST_STRNEQ (secname, ".rel"); } -#ifdef BFD64 static bfd_boolean elf_x86_64_is_reloc_section (const char *secname) { return CONST_STRNEQ (secname, ".rela"); } -#endif /* Create an x86 ELF linker hash table. */ @@ -758,32 +772,25 @@ _bfd_x86_elf_link_hash_table_create (bfd *abfd) return NULL; } -#ifdef BFD64 - /* NB: If BFD64 isn't defined, only i386 will be supported. */ if (bed->target_id == X86_64_ELF_DATA) { - ret->convert_load = _bfd_x86_64_elf_convert_load; 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 { - ret->r_info = elf32_r_info; - ret->r_sym = elf32_r_sym; if (bed->target_id == X86_64_ELF_DATA) { ret->sizeof_reloc = sizeof (Elf32_External_Rela); @@ -791,17 +798,16 @@ _bfd_x86_elf_link_hash_table_create (bfd *abfd) ret->dynamic_interpreter = ELFX32_DYNAMIC_INTERPRETER; ret->dynamic_interpreter_size = sizeof ELFX32_DYNAMIC_INTERPRETER; - ret->tls_get_addr = "__tls_get_addr"; } else { - ret->convert_load = _bfd_i386_elf_convert_load; 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 @@ -810,6 +816,7 @@ _bfd_x86_elf_link_hash_table_create (bfd *abfd) } } 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, @@ -842,6 +849,54 @@ _bfd_x86_elf_compare_relocs (const void *ap, const void *bp) 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) { @@ -853,12 +908,43 @@ _bfd_x86_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info) htab = elf_x86_hash_table (info, bed->target_id); if (htab) { - struct elf_link_hash_entry *h - = elf_link_hash_lookup (elf_hash_table (info), + 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) - ((struct elf_x86_link_hash_entry *) h)->tls_get_addr = 1; + { + 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"); + } } } @@ -906,9 +992,6 @@ _bfd_x86_elf_size_dynamic_sections (bfd *output_bfd, { struct elf_dyn_relocs *p; - if (!htab->convert_load (ibfd, s, info)) - return FALSE; - for (p = ((struct elf_dyn_relocs *) elf_section_data (s)->local_dynrel); p != NULL; @@ -922,7 +1005,7 @@ _bfd_x86_elf_size_dynamic_sections (bfd *output_bfd, linker script /DISCARD/, so we'll be discarding the relocs too. */ } - else if (htab->is_vxworks + else if (htab->target_os == is_vxworks && strcmp (p->sec->output_section->name, ".tls_vars") == 0) { @@ -940,8 +1023,10 @@ _bfd_x86_elf_size_dynamic_sections (bfd *output_bfd, if ((info->warn_shared_textrel && bfd_link_pic (info)) || info->error_textrel) /* xgettext:c-format */ - info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"), - p->sec->owner, p->sec); + info->callbacks->einfo + (_("%P: %pB: warning: relocation " + "in read-only section `%pA'\n"), + p->sec->owner, p->sec); } } } @@ -1005,7 +1090,7 @@ _bfd_x86_elf_size_dynamic_sections (bfd *output_bfd, 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. */ + 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; @@ -1065,7 +1150,7 @@ _bfd_x86_elf_size_dynamic_sections (bfd *output_bfd, /* 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->elf.hgot->ref_regular_nonweak) + || !htab->got_referenced) && (htab->elf.sgotplt->size == bed->got_header_size) && (htab->elf.splt == NULL || htab->elf.splt->size == 0) @@ -1075,7 +1160,22 @@ _bfd_x86_elf_size_dynamic_sections (bfd *output_bfd, || htab->elf.iplt->size == 0) && (htab->elf.igotplt == NULL || htab->elf.igotplt->size == 0)) - htab->elf.sgotplt->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)) @@ -1265,16 +1365,15 @@ _bfd_x86_elf_size_dynamic_sections (bfd *output_bfd, /* 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_x86_elf_readonly_dynrelocs, - info); + elf_link_hash_traverse (&htab->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 -fPIC\n")); + (_("%P%X: read-only segment has dynamic IFUNC relocations;" + " recompile with -fPIC\n")); bfd_set_error (bfd_error_bad_value); return FALSE; } @@ -1283,7 +1382,7 @@ _bfd_x86_elf_size_dynamic_sections (bfd *output_bfd, return FALSE; } } - if (htab->is_vxworks + if (htab->target_os == is_vxworks && !elf_vxworks_add_dynamic_entries (output_bfd, info)) return FALSE; } @@ -1292,6 +1391,224 @@ _bfd_x86_elf_size_dynamic_sections (bfd *output_bfd, 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) + { + 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) + { + 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); + } + + if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME) + { + if (! _bfd_elf_write_section_eh_frame (output_bfd, info, + htab->plt_eh_frame, + htab->plt_eh_frame->contents)) + return NULL; + } + } + + /* Adjust .eh_frame for .plt.got section. */ + if (htab->plt_got_eh_frame != NULL + && htab->plt_got_eh_frame->contents != 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; + } + } + + /* Adjust .eh_frame for the second PLT section. */ + if (htab->plt_second_eh_frame != NULL + && htab->plt_second_eh_frame->contents != NULL) + { + 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) + { + 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; + } + } + + 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) @@ -1405,8 +1722,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 @@ -1423,15 +1739,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 @@ -1441,21 +1749,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) + { + 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 { - h->dynindx = -1; - _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr, - h->dynstr_index); + 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. */ @@ -1571,19 +1918,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; } @@ -1623,19 +1970,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 (!readonly_dynrelocs (h)) { h->non_got_ref = 0; return TRUE; @@ -1674,6 +2014,70 @@ _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info *info, 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. */ @@ -1767,6 +2171,8 @@ _bfd_x86_elf_get_synthetic_symtab (bfd *abfd, dynrelcount = bfd_canonicalize_dynamic_reloc (abfd, dynrelbuf, dynsyms); + if (dynrelcount <= 0) + return -1; /* Sort the relocs by address. */ qsort (dynrelbuf, dynrelcount, sizeof (arelent *), @@ -1920,6 +2326,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; } @@ -1960,10 +2370,10 @@ _bfd_x86_elf_parse_gnu_properties (bfd *abfd, unsigned int type, { _bfd_error_handler ((type == GNU_PROPERTY_X86_ISA_1_USED - ? _("error: %B: ") + ? _("error: %pB: ") : (type == GNU_PROPERTY_X86_ISA_1_NEEDED - ? _("error: %B: ") - : _("error: %B: "))), + ? _("error: %pB: ") + : _("error: %pB: "))), abfd, datasz); return property_corrupt; } @@ -1997,18 +2407,54 @@ _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info *info, switch (pr_type) { case GNU_PROPERTY_X86_ISA_1_USED: + 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; + } + break; + } + goto or_property; + case GNU_PROPERTY_X86_ISA_1_NEEDED: if (aprop != NULL && bprop != NULL) { +or_property: number = aprop->u.number; aprop->u.number = number | bprop->u.number; - updated = number != (unsigned int) aprop->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; @@ -2078,8 +2524,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; @@ -2094,6 +2539,7 @@ _bfd_x86_elf_link_setup_gnu_properties const struct elf_backend_data *bed; unsigned int class_align = ABI_64_P (info->output_bfd) ? 3 : 2; unsigned int got_align; + bfd_boolean has_text = FALSE; features = 0; if (info->ibt) @@ -2108,24 +2554,59 @@ _bfd_x86_elf_link_setup_gnu_properties if (bfd_get_flavour (pbfd) == bfd_target_elf_flavour && bfd_count_sections (pbfd) != 0) { + if (!has_text) + { + /* Check if there is no non-empty text section. */ + sec = bfd_get_section_by_name (pbfd, ".text"); + if (sec != NULL && sec->size != 0) + has_text = TRUE; + } + ebfd = pbfd; if (elf_properties (pbfd) != NULL) 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; + + if (ebfd != NULL) { - /* 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; + 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; + } + else if (has_text + && elf_properties (ebfd) == NULL + && elf_tdata (info->output_bfd)->o->build_id.sec == NULL + && !htab->elf.dynamic_sections_created + && !info->traditional_format + && (info->output_bfd->flags & D_PAGED) != 0 + && info->separate_code) + { + /* If the separate code program header is needed, make sure + that the first read-only PT_LOAD segment has no code by + adding a GNU_PROPERTY_X86_ISA_1_NEEDED note. */ + prop = _bfd_elf_get_property (ebfd, + GNU_PROPERTY_X86_ISA_1_NEEDED, + 4); + prop->u.number = GNU_PROPERTY_X86_ISA_1_486; + 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, @@ -2136,12 +2617,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)) { error_alignment: - info->callbacks->einfo (_("%F%A: failed to align section\n"), + info->callbacks->einfo (_("%F%pA: failed to align section\n"), sec); } @@ -2151,16 +2632,13 @@ error_alignment: pbfd = _bfd_elf_link_setup_gnu_properties (info); - if (bfd_link_relocatable (info)) - return pbfd; - - bed = get_elf_backend_data (info->output_bfd); + htab->r_info = init_table->r_info; + htab->r_sym = init_table->r_sym; - htab = elf_x86_hash_table (info, bed->target_id); - if (htab == NULL) + 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; if (!use_ibt_plt && pbfd != NULL) @@ -2204,7 +2682,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; @@ -2213,28 +2693,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; } @@ -2280,15 +2764,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; } @@ -2297,7 +2777,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; @@ -2315,7 +2795,7 @@ 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); @@ -2356,7 +2836,7 @@ 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)) @@ -2377,7 +2857,7 @@ 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)) @@ -2392,7 +2872,7 @@ 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)) @@ -2413,7 +2893,7 @@ 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)) goto error_alignment; @@ -2426,7 +2906,7 @@ 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)) goto error_alignment; @@ -2440,7 +2920,7 @@ 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)) goto error_alignment;