X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=bfd%2Felf64-x86-64.c;h=1bad4d2dff686edecb7adcf9e2aa9177dac1e6da;hb=51537393bd939e79f6e9291629fb65a17e6f19da;hp=7a6e1f1e829ad3550e2e93e3160b713c75744a29;hpb=fe53b4a4c47df9c0bb2fa7f0de5a241f21cf352c;p=binutils-gdb.git diff --git a/bfd/elf64-x86-64.c b/bfd/elf64-x86-64.c index 7a6e1f1e829..1bad4d2dff6 100644 --- a/bfd/elf64-x86-64.c +++ b/bfd/elf64-x86-64.c @@ -196,6 +196,9 @@ static reloc_howto_type x86_64_elf_howto_table[] = FALSE) }; +/* Set if a relocation is converted from a GOTPCREL relocation. */ +#define R_X86_64_converted_reloc_bit (1 << 7) + #define IS_X86_64_PCREL_TYPE(TYPE) \ ( ((TYPE) == R_X86_64_PC8) \ || ((TYPE) == R_X86_64_PC16) \ @@ -337,8 +340,12 @@ elf_x86_64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr, unsigned r_type; r_type = ELF32_R_TYPE (dst->r_info); + if (r_type != (unsigned int) R_X86_64_GNU_VTINHERIT + && r_type != (unsigned int) R_X86_64_GNU_VTENTRY) + r_type &= ~R_X86_64_converted_reloc_bit; cache_ptr->howto = elf_x86_64_rtype_to_howto (abfd, r_type); - BFD_ASSERT (r_type == cache_ptr->howto->type); + + BFD_ASSERT (r_type == cache_ptr->howto->type || cache_ptr->howto->type == R_X86_64_NONE); } /* Support for core dump NOTE sections. */ @@ -647,10 +654,6 @@ static const bfd_byte elf_x32_non_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] = static const bfd_byte elf_x86_64_eh_frame_lazy_plt[] = { -#define PLT_CIE_LENGTH 20 -#define PLT_FDE_LENGTH 36 -#define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8 -#define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */ 0, 0, 0, 0, /* CIE ID */ 1, /* CIE version */ @@ -1149,13 +1152,17 @@ elf_x86_64_check_tls_transition (bfd *abfd, if (h == NULL || !((struct elf_x86_link_hash_entry *) h)->tls_get_addr) return FALSE; - else if (largepic) - return ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PLTOFF64; - else if (indirect_call) - return ELF32_R_TYPE (rel[1].r_info) == R_X86_64_GOTPCRELX; else - return (ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PC32 - || ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PLT32); + { + r_type = (ELF32_R_TYPE (rel[1].r_info) + & ~R_X86_64_converted_reloc_bit); + if (largepic) + return r_type == R_X86_64_PLTOFF64; + else if (indirect_call) + return r_type == R_X86_64_GOTPCRELX; + else + return (r_type == R_X86_64_PC32 || r_type == R_X86_64_PLT32); + } case R_X86_64_GOTTPOFF: /* Check transition from IE access model: @@ -1274,10 +1281,7 @@ elf_x86_64_tls_transition (struct bfd_link_info *info, bfd *abfd, { unsigned int new_to_type = to_type; - if (bfd_link_executable (info) - && h != NULL - && h->dynindx == -1 - && tls_type == GOT_TLS_IE) + if (TLS_TRANSITION_IE_TO_LE_P (info, h, tls_type)) new_to_type = R_X86_64_TPOFF32; if (to_type == R_X86_64_TLSGD @@ -1356,8 +1360,7 @@ elf_x86_64_tls_transition (struct bfd_link_info *info, bfd *abfd, /* Rename some of the generic section flags to better document how they are used here. */ -#define need_convert_load sec_flg0 -#define check_relocs_failed sec_flg1 +#define check_relocs_failed sec_flg0 static bfd_boolean elf_x86_64_need_pic (struct bfd_link_info *info, @@ -1442,8 +1445,9 @@ elf_x86_64_need_pic (struct bfd_link_info *info, instructions. */ static bfd_boolean -elf_x86_64_convert_load_reloc (bfd *abfd, asection *sec, +elf_x86_64_convert_load_reloc (bfd *abfd, bfd_byte *contents, + unsigned int *r_type_p, Elf_Internal_Rela *irel, struct elf_link_hash_entry *h, bfd_boolean *converted, @@ -1451,17 +1455,15 @@ elf_x86_64_convert_load_reloc (bfd *abfd, asection *sec, { struct elf_x86_link_hash_table *htab; bfd_boolean is_pic; - bfd_boolean require_reloc_pc32; + bfd_boolean no_overflow; bfd_boolean relocx; bfd_boolean to_reloc_pc32; asection *tsec; - char symtype; bfd_signed_vma raddend; unsigned int opcode; unsigned int modrm; - unsigned int r_type = ELF32_R_TYPE (irel->r_info); + unsigned int r_type = *r_type_p; unsigned int r_symndx; - bfd_vma toff; bfd_vma roff = irel->r_offset; if (roff < (r_type == R_X86_64_REX_GOTPCRELX ? 3 : 2)) @@ -1478,10 +1480,8 @@ elf_x86_64_convert_load_reloc (bfd *abfd, asection *sec, relocx = (r_type == R_X86_64_GOTPCRELX || r_type == R_X86_64_REX_GOTPCRELX); - /* TRUE if we can convert only to R_X86_64_PC32. Enable it for - --no-relax. */ - require_reloc_pc32 - = link_info->disable_target_specific_optimizations > 1; + /* TRUE if --no-relax is used. */ + no_overflow = link_info->disable_target_specific_optimizations > 1; r_symndx = htab->r_sym (irel->r_info); @@ -1500,12 +1500,12 @@ elf_x86_64_convert_load_reloc (bfd *abfd, asection *sec, /* We convert only to R_X86_64_PC32: 1. Branch. 2. R_X86_64_GOTPCREL since we can't modify REX byte. - 3. require_reloc_pc32 is true. + 3. no_overflow is true. 4. PIC. */ to_reloc_pc32 = (opcode == 0xff || !relocx - || require_reloc_pc32 + || no_overflow || is_pic); /* Get the symbol referred to by the reloc. */ @@ -1518,8 +1518,6 @@ elf_x86_64_convert_load_reloc (bfd *abfd, asection *sec, if (isym->st_shndx == SHN_UNDEF) return TRUE; - symtype = ELF_ST_TYPE (isym->st_info); - if (isym->st_shndx == SHN_ABS) tsec = bfd_abs_section_ptr; else if (isym->st_shndx == SHN_COMMON) @@ -1528,8 +1526,6 @@ elf_x86_64_convert_load_reloc (bfd *abfd, asection *sec, tsec = &_bfd_elf_large_com_section; else tsec = bfd_section_from_elf_index (abfd, isym->st_shndx); - - toff = isym->st_value; } else { @@ -1539,17 +1535,21 @@ elf_x86_64_convert_load_reloc (bfd *abfd, asection *sec, GOTPCRELX relocations since we need to modify REX byte. It is OK convert mov with R_X86_64_GOTPCREL to R_X86_64_PC32. */ + bfd_boolean local_ref; + struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h); + + /* NB: Also set linker_def via SYMBOL_REFERENCES_LOCAL_P. */ + local_ref = SYMBOL_REFERENCES_LOCAL_P (link_info, h); if ((relocx || opcode == 0x8b) - && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info, - X86_64_ELF_DATA, - TRUE, - elf_x86_hash_entry (h))) + && (h->root.type == bfd_link_hash_undefweak + && !eh->linker_def + && local_ref)) { if (opcode == 0xff) { /* Skip for branch instructions since R_X86_64_PC32 may overflow. */ - if (require_reloc_pc32) + if (no_overflow) return TRUE; } else if (relocx) @@ -1570,11 +1570,12 @@ elf_x86_64_convert_load_reloc (bfd *abfd, asection *sec, /* Avoid optimizing GOTPCREL relocations againt _DYNAMIC since ld.so may use its link-time address. */ else if (h->start_stop + || eh->linker_def || ((h->def_regular || h->root.type == bfd_link_hash_defined || h->root.type == bfd_link_hash_defweak) && h != htab->elf.hdynamic - && SYMBOL_REFERENCES_LOCAL (link_info, h))) + && local_ref)) { /* bfd_link_hash_new or bfd_link_hash_undefined is set by an assignment in a linker script in @@ -1582,6 +1583,7 @@ elf_x86_64_convert_load_reloc (bfd *abfd, asection *sec, on __start_SECNAME/__stop_SECNAME which mark section SECNAME. */ if (h->start_stop + || eh->linker_def || (h->def_regular && (h->root.type == bfd_link_hash_new || h->root.type == bfd_link_hash_undefined @@ -1590,13 +1592,11 @@ elf_x86_64_convert_load_reloc (bfd *abfd, asection *sec, && h->root.u.def.section == bfd_und_section_ptr)))) { /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */ - if (require_reloc_pc32) + if (no_overflow) return TRUE; goto convert; } tsec = h->root.u.def.section; - toff = h->root.u.def.value; - symtype = h->type; } else return TRUE; @@ -1607,92 +1607,9 @@ elf_x86_64_convert_load_reloc (bfd *abfd, asection *sec, && (elf_section_flags (tsec) & SHF_X86_64_LARGE) != 0) return TRUE; - /* We can only estimate relocation overflow for R_X86_64_PC32. */ - if (!to_reloc_pc32) - goto convert; - - if (tsec->sec_info_type == SEC_INFO_TYPE_MERGE) - { - /* At this stage in linking, no SEC_MERGE symbol has been - adjusted, so all references to such symbols need to be - passed through _bfd_merged_section_offset. (Later, in - relocate_section, all SEC_MERGE symbols *except* for - section symbols have been adjusted.) - - gas may reduce relocations against symbols in SEC_MERGE - sections to a relocation against the section symbol when - the original addend was zero. When the reloc is against - a section symbol we should include the addend in the - offset passed to _bfd_merged_section_offset, since the - location of interest is the original symbol. On the - other hand, an access to "sym+addend" where "sym" is not - a section symbol should not include the addend; Such an - access is presumed to be an offset from "sym"; The - location of interest is just "sym". */ - if (symtype == STT_SECTION) - toff += raddend; - - toff = _bfd_merged_section_offset (abfd, &tsec, - elf_section_data (tsec)->sec_info, - toff); - - if (symtype != STT_SECTION) - toff += raddend; - } - else - toff += raddend; - - /* Don't convert if R_X86_64_PC32 relocation overflows. */ - if (tsec->output_section == sec->output_section) - { - if ((toff - roff + 0x80000000) > 0xffffffff) - return TRUE; - } - else - { - bfd_signed_vma distance; - - /* At this point, we don't know the load addresses of TSEC - section nor SEC section. We estimate the distrance between - SEC and TSEC. We store the estimated distances in the - compressed_size field of the output section, which is only - used to decompress the compressed input section. */ - if (sec->output_section->compressed_size == 0) - { - asection *asect; - bfd_size_type size = 0; - for (asect = link_info->output_bfd->sections; - asect != NULL; - asect = asect->next) - /* Skip debug sections since compressed_size is used to - compress debug sections. */ - if ((asect->flags & SEC_DEBUGGING) == 0) - { - asection *i; - for (i = asect->map_head.s; - i != NULL; - i = i->map_head.s) - { - size = align_power (size, i->alignment_power); - size += i->size; - } - asect->compressed_size = size; - } - } - - /* Don't convert GOTPCREL relocations if TSEC isn't placed - after SEC. */ - distance = (tsec->output_section->compressed_size - - sec->output_section->compressed_size); - if (distance < 0) - return TRUE; - - /* Take PT_GNU_RELRO segment into account by adding - maxpagesize. */ - if ((toff + distance + get_elf_backend_data (abfd)->maxpagesize - - roff + 0x80000000) > 0xffffffff) - return TRUE; - } + /* Skip since R_X86_64_PC32/R_X86_64_32/R_X86_64_32S may overflow. */ + if (no_overflow) + return TRUE; convert: if (opcode == 0xff) @@ -1836,7 +1753,9 @@ rewrite_modrm_rex: bfd_put_8 (abfd, opcode, contents + roff - 2); } - irel->r_info = htab->r_info (r_symndx, r_type); + *r_type_p = r_type; + irel->r_info = htab->r_info (r_symndx, + r_type | R_X86_64_converted_reloc_bit); *converted = TRUE; @@ -1859,6 +1778,7 @@ elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, const Elf_Internal_Rela *rel_end; asection *sreloc; bfd_byte *contents; + bfd_boolean converted; if (bfd_link_relocatable (info)) return TRUE; @@ -1893,6 +1813,8 @@ elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, symtab_hdr = &elf_symtab_hdr (abfd); sym_hashes = elf_sym_hashes (abfd); + converted = FALSE; + sreloc = NULL; rel_end = relocs + sec->reloc_count; @@ -1905,6 +1827,7 @@ elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, Elf_Internal_Sym *isym; const char *name; bfd_boolean size_reloc; + bfd_boolean converted_reloc; r_symndx = htab->r_sym (rel->r_info); r_type = ELF32_R_TYPE (rel->r_info); @@ -1998,6 +1921,22 @@ elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, |= elf_gnu_symbol_ifunc; } + converted_reloc = FALSE; + if ((r_type == R_X86_64_GOTPCREL + || r_type == R_X86_64_GOTPCRELX + || r_type == R_X86_64_REX_GOTPCRELX) + && (h == NULL || h->type != STT_GNU_IFUNC)) + { + Elf_Internal_Rela *irel = (Elf_Internal_Rela *) rel; + if (!elf_x86_64_convert_load_reloc (abfd, contents, &r_type, + irel, h, &converted_reloc, + info)) + goto error_return; + + if (converted_reloc) + converted = TRUE; + } + if (! elf_x86_64_tls_transition (info, abfd, sec, contents, symtab_hdr, sym_hashes, &r_type, GOT_UNKNOWN, @@ -2173,6 +2112,7 @@ elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, sections we don't care about, such as debug sections or when relocation overflow check is disabled. */ if (!info->no_reloc_overflow_check + && !converted_reloc && (bfd_link_pic (info) || (bfd_link_executable (info) && h != NULL @@ -2366,25 +2306,24 @@ do_size: default: break; } - - if ((r_type == R_X86_64_GOTPCREL - || r_type == R_X86_64_GOTPCRELX - || r_type == R_X86_64_REX_GOTPCRELX) - && (h == NULL || h->type != STT_GNU_IFUNC)) - sec->need_convert_load = 1; } if (elf_section_data (sec)->this_hdr.contents != contents) { - if (!info->keep_memory) + if (!converted && !info->keep_memory) free (contents); else { - /* Cache the section contents for elf_link_input_bfd. */ + /* Cache the section contents for elf_link_input_bfd if any + load is converted or --no-keep-memory isn't used. */ elf_section_data (sec)->this_hdr.contents = contents; } } + /* Cache relocations if any load is converted. */ + if (elf_section_data (sec)->relocs != relocs && converted) + elf_section_data (sec)->relocs = (Elf_Internal_Rela *) relocs; + return TRUE; error_return: @@ -2394,943 +2333,6 @@ error_return: return FALSE; } -/* Allocate space in .plt, .got and associated reloc sections for - dynamic relocs. */ - -static bfd_boolean -elf_x86_64_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; - const struct elf_backend_data *bed; - unsigned int plt_entry_size; - bfd_boolean resolved_to_zero; - - if (h->root.type == bfd_link_hash_indirect) - return TRUE; - - eh = (struct elf_x86_link_hash_entry *) h; - - info = (struct bfd_link_info *) inf; - htab = elf_x86_hash_table (info, X86_64_ELF_DATA); - if (htab == NULL) - return FALSE; - bed = get_elf_backend_data (info->output_bfd); - - plt_entry_size = htab->plt.plt_entry_size; - - resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, - X86_64_ELF_DATA, - eh->has_got_reloc, - 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) - { - /* 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; - } - - /* 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; - - /* 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, - &eh->dyn_relocs, - &htab->readonly_dynrelocs_against_ifunc, - plt_entry_size, - (htab->plt.has_plt0 - * plt_entry_size), - GOT_ENTRY_SIZE, TRUE)) - { - 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; - - /* Make room for this entry in the second PLT section. */ - s->size += htab->non_lazy_plt->plt_entry_size; - } - - 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 > eh->func_pointer_refcount - || 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 - && !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; - - /* 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 - 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) - { - 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 += 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 .rela.plt - section. */ - htab->elf.srelplt->size += bed->s->sizeof_rela; - htab->elf.srelplt->reloc_count++; - } - } - } - 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; - - /* 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; - } - - 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 * GOT_ENTRY_SIZE; - h->got.offset = (bfd_vma) -2; - } - if (! GOT_TLS_GDESC_P (tls_type) - || GOT_TLS_GD_P (tls_type)) - { - s = htab->elf.sgot; - h->got.offset = s->size; - s->size += GOT_ENTRY_SIZE; - if (GOT_TLS_GD_P (tls_type)) - s->size += GOT_ENTRY_SIZE; - } - dyn = htab->elf.dynamic_sections_created; - /* R_X86_64_TLSGD needs one dynamic relocation if local symbol - and two if global. R_X86_64_GOTTPOFF needs one dynamic - relocation. No dynamic relocation against resolved undefined - weak symbol in executable. */ - if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1) - || tls_type == GOT_TLS_IE) - htab->elf.srelgot->size += bed->s->sizeof_rela; - else if (GOT_TLS_GD_P (tls_type)) - htab->elf.srelgot->size += 2 * bed->s->sizeof_rela; - 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) - || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))) - htab->elf.srelgot->size += bed->s->sizeof_rela; - if (GOT_TLS_GDESC_P (tls_type)) - { - htab->elf.srelplt->size += bed->s->sizeof_rela; - htab->tlsdesc_plt = (bfd_vma) -1; - } - } - else - h->got.offset = (bfd_vma) -1; - - if (eh->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 = &eh->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; - } - } - - /* Also discard relocs on undefined weak syms with non-default - visibility or in PIE. */ - if (eh->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) - eh->dyn_relocs = NULL; - else if (h->dynindx == -1 - && ! h->forced_local - && ! bfd_elf_link_record_dynamic_symbol (info, h)) - return FALSE; - } - /* For PIE, discard space for pc-relative relocs against - symbols which turn out to need copy relocs. */ - else if (bfd_link_executable (info) - && (h->needs_copy || eh->needs_copy) - && h->def_dynamic - && !h->def_regular) - { - struct elf_dyn_relocs **pp; - - for (pp = &eh->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 - || eh->func_pointer_refcount > 0 - || (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; - - /* If that succeeded, we know we'll be keeping all the - relocs. */ - if (h->dynindx != -1) - goto keep; - } - - eh->dyn_relocs = NULL; - eh->func_pointer_refcount = 0; - - keep: ; - } - - /* Finally, allocate space. */ - for (p = eh->dyn_relocs; p != NULL; p = p->next) - { - asection * sreloc; - - sreloc = elf_section_data (p->sec)->sreloc; - - BFD_ASSERT (sreloc != NULL); - - sreloc->size += p->count * bed->s->sizeof_rela; - } - - return TRUE; -} - -/* Allocate space in .plt, .got and associated reloc sections for - local dynamic relocs. */ - -static bfd_boolean -elf_x86_64_allocate_local_dynrelocs (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_64_allocate_dynrelocs (h, inf); -} - -/* Convert load via the GOT slot to load immediate. */ - -static bfd_boolean -elf_x86_64_convert_load (bfd *abfd, asection *sec, - struct bfd_link_info *link_info) -{ - Elf_Internal_Shdr *symtab_hdr; - Elf_Internal_Rela *internal_relocs; - Elf_Internal_Rela *irel, *irelend; - bfd_byte *contents; - struct elf_x86_link_hash_table *htab; - bfd_boolean changed; - bfd_signed_vma *local_got_refcounts; - - /* Don't even try to convert non-ELF outputs. */ - if (!is_elf_hash_table (link_info->hash)) - return FALSE; - - /* Nothing to do if there is no need or no output. */ - if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC) - || sec->need_convert_load == 0 - || bfd_is_abs_section (sec->output_section)) - return TRUE; - - symtab_hdr = &elf_tdata (abfd)->symtab_hdr; - - /* Load the relocations for this section. */ - internal_relocs = (_bfd_elf_link_read_relocs - (abfd, sec, NULL, (Elf_Internal_Rela *) NULL, - link_info->keep_memory)); - if (internal_relocs == NULL) - return FALSE; - - changed = FALSE; - htab = elf_x86_hash_table (link_info, X86_64_ELF_DATA); - local_got_refcounts = elf_local_got_refcounts (abfd); - - /* Get the section contents. */ - if (elf_section_data (sec)->this_hdr.contents != NULL) - contents = elf_section_data (sec)->this_hdr.contents; - else - { - if (!bfd_malloc_and_get_section (abfd, sec, &contents)) - goto error_return; - } - - irelend = internal_relocs + sec->reloc_count; - for (irel = internal_relocs; irel < irelend; irel++) - { - unsigned int r_type = ELF32_R_TYPE (irel->r_info); - unsigned int r_symndx; - struct elf_link_hash_entry *h; - bfd_boolean converted; - - if (r_type != R_X86_64_GOTPCRELX - && r_type != R_X86_64_REX_GOTPCRELX - && r_type != R_X86_64_GOTPCREL) - continue; - - r_symndx = htab->r_sym (irel->r_info); - if (r_symndx < symtab_hdr->sh_info) - h = _bfd_elf_x86_get_local_sym_hash (htab, sec->owner, - (const Elf_Internal_Rela *) irel, - FALSE); - else - { - h = elf_sym_hashes (abfd)[r_symndx - symtab_hdr->sh_info]; - while (h->root.type == bfd_link_hash_indirect - || h->root.type == bfd_link_hash_warning) - h = (struct elf_link_hash_entry *) h->root.u.i.link; - } - - /* STT_GNU_IFUNC must keep GOTPCREL relocations. */ - if (h != NULL && h->type == STT_GNU_IFUNC) - continue; - - converted = FALSE; - if (!elf_x86_64_convert_load_reloc (abfd, sec, contents, irel, h, - &converted, link_info)) - goto error_return; - - if (converted) - { - changed = converted; - if (h) - { - if (h->got.refcount > 0) - h->got.refcount -= 1; - } - else - { - if (local_got_refcounts != NULL - && local_got_refcounts[r_symndx] > 0) - local_got_refcounts[r_symndx] -= 1; - } - } - } - - if (contents != NULL - && elf_section_data (sec)->this_hdr.contents != contents) - { - if (!changed && !link_info->keep_memory) - free (contents); - else - { - /* Cache the section contents for elf_link_input_bfd. */ - elf_section_data (sec)->this_hdr.contents = contents; - } - } - - if (elf_section_data (sec)->relocs != internal_relocs) - { - if (!changed) - free (internal_relocs); - else - elf_section_data (sec)->relocs = internal_relocs; - } - - return TRUE; - - error_return: - if (contents != NULL - && elf_section_data (sec)->this_hdr.contents != contents) - free (contents); - if (internal_relocs != NULL - && elf_section_data (sec)->relocs != internal_relocs) - free (internal_relocs); - return FALSE; -} - -/* Set the sizes of the dynamic sections. */ - -static bfd_boolean -elf_x86_64_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; - - htab = elf_x86_hash_table (info, X86_64_ELF_DATA); - if (htab == NULL) - return FALSE; - bed = get_elf_backend_data (output_bfd); - - 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; - - if (!elf_x86_64_convert_load (ibfd, s, info)) - return FALSE; - - 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 (p->count != 0) - { - srel = elf_section_data (p->sec)->sreloc; - srel->size += p->count * bed->s->sizeof_rela; - if ((p->sec->output_section->flags & SEC_READONLY) != 0 - && (info->flags & DF_TEXTREL) == 0) - { - info->flags |= DF_TEXTREL; - 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); - } - } - } - } - - 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 * 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 += GOT_ENTRY_SIZE; - if (GOT_TLS_GD_P (*local_tls_type)) - s->size += GOT_ENTRY_SIZE; - } - if (bfd_link_pic (info) - || GOT_TLS_GD_ANY_P (*local_tls_type) - || *local_tls_type == GOT_TLS_IE) - { - if (GOT_TLS_GDESC_P (*local_tls_type)) - { - htab->elf.srelplt->size - += bed->s->sizeof_rela; - htab->tlsdesc_plt = (bfd_vma) -1; - } - if (! GOT_TLS_GDESC_P (*local_tls_type) - || GOT_TLS_GD_P (*local_tls_type)) - srel->size += bed->s->sizeof_rela; - } - } - 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_X86_64_TLSLD - relocs. */ - htab->tls_ld_or_ldm_got.offset = htab->elf.sgot->size; - htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE; - htab->elf.srelgot->size += bed->s->sizeof_rela; - } - 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_64_allocate_dynrelocs, - info); - - /* Allocate .plt and .got entries, and space for local symbols. */ - htab_traverse (htab->loc_hash_table, - elf_x86_64_allocate_local_dynrelocs, - 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_X86_64_IRELATIVE entries come last. */ - if (htab->elf.srelplt) - { - 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) - { - /* 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 += 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 refeence to _GLOBAL_OFFSET_TABLE_. */ - if ((htab->elf.hgot == NULL - || !htab->elf.hgot->ref_regular_nonweak) - && (htab->elf.sgotplt->size - == get_elf_backend_data (output_bfd)->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; - } - - 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) - { - if ((s->flags & SEC_LINKER_CREATED) == 0) - continue; - - if (s == htab->elf.splt - || s == htab->elf.sgot - || 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 this section if we don't need it; see the - comment below. */ - } - else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela")) - { - if (s->size != 0 && s != htab->elf.srelplt) - 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 .rela.bss and - .rela.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. */ - - s->flags |= SEC_EXCLUDE; - continue; - } - - if ((s->flags & SEC_HAS_CONTENTS) == 0) - continue; - - /* 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_X86_64_NONE reloc instead - of garbage. */ - s->contents = (bfd_byte *) 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_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, DT_RELA) - || !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 (DT_RELA, 0) - || !add_dynamic_entry (DT_RELASZ, 0) - || !add_dynamic_entry (DT_RELAENT, bed->s->sizeof_rela)) - 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_x86_elf_readonly_dynrelocs, - 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")); - bfd_set_error (bfd_error_bad_value); - return FALSE; - } - - if (!add_dynamic_entry (DT_TEXTREL, 0)) - return FALSE; - } - } - } -#undef add_dynamic_entry - - return TRUE; -} - /* Return the relocation value for @tpoff relocation if STT_TLS virtual address is ADDRESS. */ @@ -3412,7 +2414,7 @@ elf_x86_64_relocate_section (bfd *output_bfd, relend = relocs + input_section->reloc_count; for (; rel < relend; wrel++, rel++) { - unsigned int r_type; + unsigned int r_type, r_type_tls; reloc_howto_type *howto; unsigned long r_symndx; struct elf_link_hash_entry *h; @@ -3428,6 +2430,7 @@ elf_x86_64_relocate_section (bfd *output_bfd, bfd_vma st_size; bfd_boolean resolved_to_zero; bfd_boolean relative_reloc; + bfd_boolean converted_reloc; r_type = ELF32_R_TYPE (rel->r_info); if (r_type == (int) R_X86_64_GNU_VTINHERIT @@ -3438,6 +2441,9 @@ elf_x86_64_relocate_section (bfd *output_bfd, continue; } + converted_reloc = (r_type & R_X86_64_converted_reloc_bit) != 0; + r_type &= ~R_X86_64_converted_reloc_bit; + if (r_type >= (int) R_X86_64_standard) return _bfd_unrecognized_reloc (input_bfd, input_section, r_type); @@ -3769,10 +2775,7 @@ do_ifunc_pointer: } resolved_to_zero = (eh != NULL - && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, - X86_64_ELF_DATA, - eh->has_got_reloc, - eh)); + && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh)); /* When generating a shared object, the relocations handled here are copied into the output file to be resolved at run time. */ @@ -3818,7 +2821,7 @@ do_ifunc_pointer: if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h) || (bfd_link_pic (info) - && SYMBOL_REFERENCES_LOCAL (info, h)) + && SYMBOL_REFERENCES_LOCAL_P (info, h)) || (ELF_ST_VISIBILITY (h->other) && h->root.type == bfd_link_hash_undefweak)) { @@ -3953,7 +2956,7 @@ do_ifunc_pointer: return FALSE; } else if (!bfd_link_executable (info) - && !SYMBOL_REFERENCES_LOCAL (info, h) + && !SYMBOL_REFERENCES_LOCAL_P (info, h) && (h->type == STT_FUNC || h->type == STT_OBJECT) && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED) @@ -4101,7 +3104,7 @@ do_ifunc_pointer: || r_type == R_X86_64_PC32_BND) && is_32bit_relative_branch (contents, rel->r_offset)); - if (SYMBOL_REFERENCES_LOCAL (info, h)) + if (SYMBOL_REFERENCES_LOCAL_P (info, h)) { /* Symbol is referenced locally. Make sure it is defined locally or for a branch. */ @@ -4314,20 +3317,21 @@ direct: else if (h != NULL) tls_type = elf_x86_hash_entry (h)->tls_type; + r_type_tls = r_type; if (! elf_x86_64_tls_transition (info, input_bfd, input_section, contents, symtab_hdr, sym_hashes, - &r_type, tls_type, rel, + &r_type_tls, tls_type, rel, relend, h, r_symndx, TRUE)) return FALSE; - if (r_type == R_X86_64_TPOFF32) + if (r_type_tls == R_X86_64_TPOFF32) { bfd_vma roff = rel->r_offset; BFD_ASSERT (! unresolved_reloc); - if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD) + if (r_type == R_X86_64_TLSGD) { /* GD->LE transition. For 64bit, change .byte 0x66; leaq foo@tlsgd(%rip), %rdi @@ -4390,7 +3394,7 @@ direct: wrel++; continue; } - else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC) + else if (r_type == R_X86_64_GOTPC32_TLSDESC) { /* GDesc -> LE transition. It's originally something like: @@ -4413,7 +3417,7 @@ direct: contents + roff); continue; } - else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL) + else if (r_type == R_X86_64_TLSDESC_CALL) { /* GDesc -> LE transition. It's originally: @@ -4424,7 +3428,7 @@ direct: bfd_put_8 (output_bfd, 0x90, contents + roff + 1); continue; } - else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTTPOFF) + else if (r_type == R_X86_64_GOTTPOFF) { /* IE->LE transition: For 64bit, originally it can be one of: @@ -4602,7 +3606,7 @@ direct: if (off >= (bfd_vma) -2 && ! GOT_TLS_GDESC_P (tls_type)) abort (); - if (r_type == ELF32_R_TYPE (rel->r_info)) + if (r_type_tls == r_type) { if (r_type == R_X86_64_GOTPC32_TLSDESC || r_type == R_X86_64_TLSDESC_CALL) @@ -4618,7 +3622,7 @@ direct: { bfd_vma roff = rel->r_offset; - if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD) + if (r_type == R_X86_64_TLSGD) { /* GD->IE transition. For 64bit, change .byte 0x66; leaq foo@tlsgd(%rip), %rdi @@ -4687,7 +3691,7 @@ direct: wrel++; continue; } - else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC) + else if (r_type == R_X86_64_GOTPC32_TLSDESC) { /* GDesc -> IE transition. It's originally something like: @@ -4712,7 +3716,7 @@ direct: contents + roff); continue; } - else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL) + else if (r_type == R_X86_64_TLSDESC_CALL) { /* GDesc -> IE transition. It's originally: @@ -4910,9 +3914,17 @@ check_relocation_error: } if (r == bfd_reloc_overflow) - (*info->callbacks->reloc_overflow) - (info, (h ? &h->root : NULL), name, howto->name, - (bfd_vma) 0, input_bfd, input_section, rel->r_offset); + { + if (converted_reloc) + { + info->callbacks->einfo + (_("%F%P: failed to convert GOTPCREL relocation; relink with --no-relax\n")); + return FALSE; + } + (*info->callbacks->reloc_overflow) + (info, (h ? &h->root : NULL), name, howto->name, + (bfd_vma) 0, input_bfd, input_section, rel->r_offset); + } else { _bfd_error_handler @@ -4979,10 +3991,7 @@ elf_x86_64_finish_dynamic_symbol (bfd *output_bfd, /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for resolved undefined weak symbols in executable so that their references have value 0 at run-time. */ - local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, - X86_64_ELF_DATA, - eh->has_got_reloc, - eh); + local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh); if (h->plt.offset != (bfd_vma) -1) { @@ -5259,10 +4268,9 @@ elf_x86_64_finish_dynamic_symbol (bfd *output_bfd, in static executable. */ relgot = htab->elf.irelplt; } - if (SYMBOL_REFERENCES_LOCAL (info, h)) + if (SYMBOL_REFERENCES_LOCAL_P (info, h)) { info->callbacks->minfo (_("Local IFUNC function `%s' in %B\n"), - output_bfd, h->root.root.string, h->root.u.def.section->owner); @@ -5309,7 +4317,7 @@ elf_x86_64_finish_dynamic_symbol (bfd *output_bfd, } } else if (bfd_link_pic (info) - && SYMBOL_REFERENCES_LOCAL (info, h)) + && SYMBOL_REFERENCES_LOCAL_P (info, h)) { if (!(h->def_regular || ELF_COMMON_DEF_P (h))) return FALSE; @@ -6140,44 +5148,63 @@ elf_x86_64_relocs_compatible (const bfd_target *input, static bfd * elf_x86_64_link_setup_gnu_properties (struct bfd_link_info *info) { - struct elf_x86_plt_layout_table plt_layout; + struct elf_x86_init_table init_table; + + if ((int) R_X86_64_standard >= (int) R_X86_64_converted_reloc_bit + || (int) R_X86_64_max <= (int) R_X86_64_converted_reloc_bit + || ((int) (R_X86_64_GNU_VTINHERIT | R_X86_64_converted_reloc_bit) + != (int) R_X86_64_GNU_VTINHERIT) + || ((int) (R_X86_64_GNU_VTENTRY | R_X86_64_converted_reloc_bit) + != (int) R_X86_64_GNU_VTENTRY)) + abort (); - plt_layout.is_vxworks = FALSE; + init_table.is_vxworks = FALSE; if (get_elf_x86_64_backend_data (info->output_bfd)->os == is_normal) { if (info->bndplt) { - plt_layout.lazy_plt = &elf_x86_64_lazy_bnd_plt; - plt_layout.non_lazy_plt = &elf_x86_64_non_lazy_bnd_plt; + init_table.lazy_plt = &elf_x86_64_lazy_bnd_plt; + init_table.non_lazy_plt = &elf_x86_64_non_lazy_bnd_plt; } else { - plt_layout.lazy_plt = &elf_x86_64_lazy_plt; - plt_layout.non_lazy_plt = &elf_x86_64_non_lazy_plt; + init_table.lazy_plt = &elf_x86_64_lazy_plt; + init_table.non_lazy_plt = &elf_x86_64_non_lazy_plt; } if (ABI_64_P (info->output_bfd)) { - plt_layout.lazy_ibt_plt = &elf_x86_64_lazy_ibt_plt; - plt_layout.non_lazy_ibt_plt = &elf_x86_64_non_lazy_ibt_plt; + init_table.lazy_ibt_plt = &elf_x86_64_lazy_ibt_plt; + init_table.non_lazy_ibt_plt = &elf_x86_64_non_lazy_ibt_plt; } else { - plt_layout.lazy_ibt_plt = &elf_x32_lazy_ibt_plt; - plt_layout.non_lazy_ibt_plt = &elf_x32_non_lazy_ibt_plt; + init_table.lazy_ibt_plt = &elf_x32_lazy_ibt_plt; + init_table.non_lazy_ibt_plt = &elf_x32_non_lazy_ibt_plt; } - plt_layout.normal_target = TRUE; + init_table.normal_target = TRUE; + } + else + { + init_table.lazy_plt = &elf_x86_64_nacl_plt; + init_table.non_lazy_plt = NULL; + init_table.lazy_ibt_plt = NULL; + init_table.non_lazy_ibt_plt = NULL; + init_table.normal_target = FALSE; + } + + if (ABI_64_P (info->output_bfd)) + { + init_table.r_info = elf64_r_info; + init_table.r_sym = elf64_r_sym; } else { - plt_layout.lazy_plt = &elf_x86_64_nacl_plt; - plt_layout.non_lazy_plt = NULL; - plt_layout.lazy_ibt_plt = NULL; - plt_layout.non_lazy_ibt_plt = NULL; - plt_layout.normal_target = FALSE; + init_table.r_info = elf32_r_info; + init_table.r_sym = elf32_r_sym; } - return _bfd_x86_elf_link_setup_gnu_properties (info, &plt_layout); + return _bfd_x86_elf_link_setup_gnu_properties (info, &init_table); } static const struct bfd_elf_special_section @@ -6233,7 +5260,6 @@ elf_x86_64_special_sections[]= #endif #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class #define elf_backend_relocate_section elf_x86_64_relocate_section -#define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections #define elf_backend_init_index_section _bfd_elf_init_1_index_section #define elf_backend_object_p elf64_x86_64_elf_object_p #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab