/* 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) \
+#define X86_PCREL_TYPE_P(TYPE) \
( ((TYPE) == R_X86_64_PC8) \
|| ((TYPE) == R_X86_64_PC16) \
|| ((TYPE) == R_X86_64_PC32) \
&& 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);
}
\f
/* Support for core dump NOTE sections. */
{
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
/* 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,
static bfd_boolean
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,
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 roff = irel->r_offset;
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)
{
/* 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
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
bfd_put_8 (abfd, opcode, contents + roff - 2);
}
+ *r_type_p = r_type;
irel->r_info = htab->r_info (r_symndx,
r_type | R_X86_64_converted_reloc_bit);
const Elf_Internal_Rela *rel_end;
asection *sreloc;
bfd_byte *contents;
+ bfd_boolean converted;
if (bfd_link_relocatable (info))
return TRUE;
symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
+ converted = FALSE;
+
sreloc = NULL;
rel_end = relocs + sec->reloc_count;
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);
|= 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,
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
size_reloc = FALSE;
do_size:
- /* If we are creating a shared library, and this is a reloc
- against a global symbol, or a non PC relative reloc
- against a local symbol, then we need to copy the reloc
- into the shared library. However, if we are linking with
- -Bsymbolic, we do not need to copy a reloc against a
- global symbol which is defined in an object we are
- including in the link (i.e., DEF_REGULAR is set). At
- this point we have not seen all the input files, so it is
- possible that DEF_REGULAR is not set now but will be set
- later (it is never cleared). In case of a weak definition,
- DEF_REGULAR may be cleared later by a strong definition in
- a shared library. We account for that possibility below by
- storing information in the relocs_copied field of the hash
- table entry. A similar situation occurs when creating
- shared libraries and symbol visibility changes render the
- symbol local.
-
- If on the other hand, we are creating an executable, we
- may need to keep relocations for symbols satisfied by a
- dynamic library if we manage to avoid copy relocs for the
- symbol.
-
- Generate dynamic pointer relocation against STT_GNU_IFUNC
- symbol in the non-code section. */
- if ((bfd_link_pic (info)
- && (! IS_X86_64_PCREL_TYPE (r_type)
- || (h != NULL
- && (! (bfd_link_pie (info)
- || SYMBOLIC_BIND (info, h))
- || h->root.type == bfd_link_hash_defweak
- || !h->def_regular))))
- || (h != NULL
- && h->type == STT_GNU_IFUNC
- && r_type == htab->pointer_r_type
- && (sec->flags & SEC_CODE) == 0)
- || (ELIMINATE_COPY_RELOCS
- && !bfd_link_pic (info)
- && h != NULL
- && (h->root.type == bfd_link_hash_defweak
- || !h->def_regular)))
+ if (NEED_DYNAMIC_RELOCATION_P (info, h, sec, r_type,
+ htab->pointer_r_type))
{
struct elf_dyn_relocs *p;
struct elf_dyn_relocs **head;
p->count += 1;
/* Count size relocation as PC-relative relocation. */
- if (IS_X86_64_PCREL_TYPE (r_type) || size_reloc)
+ if (X86_PCREL_TYPE_P (r_type) || size_reloc)
p->pc_count += 1;
}
break;
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:
return FALSE;
}
-/* Convert load via the GOT slot to load immediate. */
-
-bfd_boolean
-_bfd_x86_64_elf_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, 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;
-}
-
/* Return the relocation value for @tpoff relocation
if STT_TLS virtual address is ADDRESS. */
}
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. */
relative_reloc = FALSE;
if (h != NULL)
{
- bfd_boolean dyn;
-
off = h->got.offset;
if (h->needs_plt
&& h->plt.offset != (bfd_vma)-1
base_got = htab->elf.sgotplt;
}
- dyn = htab->elf.dynamic_sections_created;
-
- if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
- || (bfd_link_pic (info)
- && SYMBOL_REFERENCES_LOCAL (info, h))
- || (ELF_ST_VISIBILITY (h->other)
- && h->root.type == bfd_link_hash_undefweak))
+ if (RESOLVED_LOCALLY_P (info, h, htab))
{
- /* This is actually a static link, or it is a -Bsymbolic
- link and the symbol is defined locally, or the symbol
- was forced to be local because of a version file. We
- must initialize this entry in the global offset table.
- Since the offset must always be a multiple of 8, we
- use the least significant bit to record whether we
- have initialized it already.
+ /* We must initialize this entry in the global offset
+ table. Since the offset must always be a multiple
+ of 8, we use the least significant bit to record
+ whether we have initialized it already.
When doing a dynamic link, we create a .rela.got
relocation entry to initialize the value. This is
as -1 | 1 still is -1. */
h->got.offset |= 1;
- if (h->dynindx == -1
- && !h->forced_local
- && h->root.type != bfd_link_hash_undefweak
- && bfd_link_pic (info))
+ if (GENERATE_RELATIVE_RELOC_P (info, h))
{
/* If this symbol isn't dynamic in PIC,
generate R_X86_64_RELATIVE here. */
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)
|| 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. */
&& (h->needs_copy
|| eh->needs_copy
|| h->root.type == bfd_link_hash_undefined)
- && (IS_X86_64_PCREL_TYPE (r_type)
+ && (X86_PCREL_TYPE_P (r_type)
|| r_type == R_X86_64_SIZE32
|| r_type == R_X86_64_SIZE64))
&& (h == NULL
|| ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
&& !resolved_to_zero)
|| h->root.type != bfd_link_hash_undefweak))
- && ((! IS_X86_64_PCREL_TYPE (r_type)
+ && ((! X86_PCREL_TYPE_P (r_type)
&& r_type != R_X86_64_SIZE32
&& r_type != R_X86_64_SIZE64)
|| ! SYMBOL_CALLS_LOCAL (info, h)))
become local. */
else if (h != NULL
&& h->dynindx != -1
- && (IS_X86_64_PCREL_TYPE (r_type)
+ && (X86_PCREL_TYPE_P (r_type)
|| !(bfd_link_executable (info)
|| SYMBOLIC_BIND (info, h))
|| ! h->def_regular))
/* 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)
{
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);
}
}
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;
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_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