Retro68/binutils/bfd/elf-ifunc.c

365 lines
11 KiB
C
Raw Normal View History

2012-03-26 19:18:29 +00:00
/* ELF STT_GNU_IFUNC support.
2018-12-28 15:25:28 +00:00
Copyright (C) 2009-2018 Free Software Foundation, Inc.
2012-03-26 19:18:29 +00:00
This file is part of BFD, the Binary File Descriptor library.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
MA 02110-1301, USA. */
#include "sysdep.h"
#include "bfd.h"
#include "bfdlink.h"
#include "libbfd.h"
#define ARCH_SIZE 0
#include "elf-bfd.h"
#include "safe-ctype.h"
#include "libiberty.h"
#include "objalloc.h"
/* Create sections needed by STT_GNU_IFUNC symbol. */
bfd_boolean
_bfd_elf_create_ifunc_sections (bfd *abfd, struct bfd_link_info *info)
{
flagword flags, pltflags;
asection *s;
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf_link_hash_table *htab = elf_hash_table (info);
if (htab->irelifunc != NULL || htab->iplt != NULL)
return TRUE;
flags = bed->dynamic_sec_flags;
pltflags = flags;
if (bed->plt_not_loaded)
/* We do not clear SEC_ALLOC here because we still want the OS to
allocate space for the section; it's just that there's nothing
to read in from the object file. */
pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
else
pltflags |= SEC_ALLOC | SEC_CODE | SEC_LOAD;
if (bed->plt_readonly)
pltflags |= SEC_READONLY;
2017-04-10 11:32:00 +00:00
if (bfd_link_pic (info))
2012-03-26 19:18:29 +00:00
{
2017-04-10 11:32:00 +00:00
/* We need to create .rel[a].ifunc for PIC objects. */
2012-03-26 19:18:29 +00:00
const char *rel_sec = (bed->rela_plts_and_copies_p
? ".rela.ifunc" : ".rel.ifunc");
s = bfd_make_section_with_flags (abfd, rel_sec,
flags | SEC_READONLY);
if (s == NULL
|| ! bfd_set_section_alignment (abfd, s,
bed->s->log_file_align))
return FALSE;
htab->irelifunc = s;
}
else
{
/* We need to create .iplt, .rel[a].iplt, .igot and .igot.plt
for static executables. */
s = bfd_make_section_with_flags (abfd, ".iplt", pltflags);
if (s == NULL
|| ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
return FALSE;
htab->iplt = s;
s = bfd_make_section_with_flags (abfd,
(bed->rela_plts_and_copies_p
? ".rela.iplt" : ".rel.iplt"),
flags | SEC_READONLY);
if (s == NULL
|| ! bfd_set_section_alignment (abfd, s,
bed->s->log_file_align))
return FALSE;
htab->irelplt = s;
/* We don't need the .igot section if we have the .igot.plt
section. */
if (bed->want_got_plt)
s = bfd_make_section_with_flags (abfd, ".igot.plt", flags);
else
s = bfd_make_section_with_flags (abfd, ".igot", flags);
if (s == NULL
|| !bfd_set_section_alignment (abfd, s,
bed->s->log_file_align))
return FALSE;
htab->igotplt = s;
}
return TRUE;
}
/* Allocate space in .plt, .got and associated reloc sections for
dynamic relocs against a STT_GNU_IFUNC symbol definition. */
bfd_boolean
_bfd_elf_allocate_ifunc_dyn_relocs (struct bfd_link_info *info,
struct elf_link_hash_entry *h,
struct elf_dyn_relocs **head,
2017-04-10 11:32:00 +00:00
bfd_boolean *readonly_dynrelocs_against_ifunc_p,
2012-03-26 19:18:29 +00:00
unsigned int plt_entry_size,
unsigned int plt_header_size,
2017-04-10 11:32:00 +00:00
unsigned int got_entry_size,
bfd_boolean avoid_plt)
2012-03-26 19:18:29 +00:00
{
asection *plt, *gotplt, *relplt;
struct elf_dyn_relocs *p;
unsigned int sizeof_reloc;
const struct elf_backend_data *bed;
struct elf_link_hash_table *htab;
2017-04-10 11:32:00 +00:00
bfd_boolean readonly_dynrelocs_against_ifunc;
/* If AVOID_PLT is TRUE, don't use PLT if possible. */
bfd_boolean use_plt = !avoid_plt || h->plt.refcount > 0;
bfd_boolean need_dynreloc = !use_plt || bfd_link_pic (info);
/* When a PIC object references a STT_GNU_IFUNC symbol defined
in executable or it isn't referenced via PLT, the address of
the resolved function may be used. But in non-PIC executable,
the address of its .plt slot may be used. Pointer equality may
not work correctly. PIE or non-PLT reference should be used if
2018-12-28 15:25:28 +00:00
pointer equality is required here.
If STT_GNU_IFUNC symbol is defined in position-dependent executable,
backend should change it to the normal function and set its address
to its PLT entry which should be resolved by R_*_IRELATIVE at
run-time. All external references should be resolved to its PLT in
executable. */
2017-04-10 11:32:00 +00:00
if (!need_dynreloc
2018-12-28 15:25:28 +00:00
&& !(bfd_link_pde (info) && h->def_regular)
2012-03-26 19:18:29 +00:00
&& (h->dynindx != -1
|| info->export_dynamic)
&& h->pointer_equality_needed)
{
info->callbacks->einfo
2017-04-10 11:32:00 +00:00
/* xgettext:c-format */
2012-03-26 19:18:29 +00:00
(_("%F%P: dynamic STT_GNU_IFUNC symbol `%s' with pointer "
2018-12-28 15:25:28 +00:00
"equality in `%pB' can not be used when making an "
2012-03-26 19:18:29 +00:00
"executable; recompile with -fPIE and relink with -pie\n"),
h->root.root.string,
h->root.u.def.section->owner);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
htab = elf_hash_table (info);
2017-04-10 11:32:00 +00:00
/* When the symbol is marked with regular reference, if PLT isn't used
or we are building a PIC object, we must keep dynamic relocation
if there is non-GOT reference and use PLT if there is PC-relative
reference. */
if (need_dynreloc && h->ref_regular)
{
bfd_boolean keep = FALSE;
for (p = *head; p != NULL; p = p->next)
if (p->count)
{
h->non_got_ref = 1;
/* Need dynamic relocations for non-GOT reference. */
keep = TRUE;
if (p->pc_count)
{
/* Must use PLT for PC-relative reference. */
use_plt = TRUE;
need_dynreloc = bfd_link_pic (info);
break;
}
}
if (keep)
goto keep;
}
/* Support garbage collection against STT_GNU_IFUNC symbols. */
if (h->plt.refcount <= 0 && h->got.refcount <= 0)
{
h->got = htab->init_got_offset;
h->plt = htab->init_plt_offset;
*head = NULL;
return TRUE;
}
2012-03-26 19:18:29 +00:00
/* Return and discard space for dynamic relocations against it if
2017-04-10 11:32:00 +00:00
it is never referenced. */
2012-03-26 19:18:29 +00:00
if (!h->ref_regular)
{
if (h->plt.refcount > 0
|| h->got.refcount > 0)
abort ();
h->got = htab->init_got_offset;
h->plt = htab->init_plt_offset;
*head = NULL;
return TRUE;
}
keep:
2012-03-26 19:18:29 +00:00
bed = get_elf_backend_data (info->output_bfd);
if (bed->rela_plts_and_copies_p)
sizeof_reloc = bed->s->sizeof_rela;
else
sizeof_reloc = bed->s->sizeof_rel;
/* When building a static executable, use .iplt, .igot.plt and
.rel[a].iplt sections for STT_GNU_IFUNC symbols. */
if (htab->splt != NULL)
{
plt = htab->splt;
gotplt = htab->sgotplt;
relplt = htab->srelplt;
2017-04-10 11:32:00 +00:00
/* If this is the first .plt entry and PLT is used, make room for
the special first entry. */
if (plt->size == 0 && use_plt)
plt->size += plt_header_size;
2012-03-26 19:18:29 +00:00
}
else
{
plt = htab->iplt;
gotplt = htab->igotplt;
relplt = htab->irelplt;
}
2017-04-10 11:32:00 +00:00
if (use_plt)
{
/* Don't update value of STT_GNU_IFUNC symbol to PLT. We need
the original value for R_*_IRELATIVE. */
h->plt.offset = plt->size;
2012-03-26 19:18:29 +00:00
2017-04-10 11:32:00 +00:00
/* Make room for this entry in the .plt/.iplt section. */
plt->size += plt_entry_size;
2012-03-26 19:18:29 +00:00
2017-04-10 11:32:00 +00:00
/* We also need to make an entry in the .got.plt/.got.iplt section,
which will be placed in the .got section by the linker script. */
gotplt->size += got_entry_size;
}
2012-03-26 19:18:29 +00:00
/* We also need to make an entry in the .rel[a].plt/.rel[a].iplt
2017-04-10 11:32:00 +00:00
section for GOTPLT relocation if PLT is used. */
if (use_plt)
{
relplt->size += sizeof_reloc;
relplt->reloc_count++;
}
2012-03-26 19:18:29 +00:00
/* We need dynamic relocation for STT_GNU_IFUNC symbol only when
2017-04-10 11:32:00 +00:00
there is a non-GOT reference in a PIC object or PLT isn't used. */
if (!need_dynreloc || !h->non_got_ref)
2012-03-26 19:18:29 +00:00
*head = NULL;
2017-04-10 11:32:00 +00:00
readonly_dynrelocs_against_ifunc = FALSE;
2012-03-26 19:18:29 +00:00
/* Finally, allocate space. */
p = *head;
if (p != NULL)
{
bfd_size_type count = 0;
do
{
2017-04-10 11:32:00 +00:00
if (!readonly_dynrelocs_against_ifunc)
{
asection *s = p->sec->output_section;
if (s != NULL && (s->flags & SEC_READONLY) != 0)
readonly_dynrelocs_against_ifunc = TRUE;
}
count += p->count;
p = p->next;
}
while (p != NULL);
2017-04-10 11:32:00 +00:00
/* Dynamic relocations are stored in
1. .rel[a].ifunc section in PIC object.
2. .rel[a].got section in dynamic executable.
3. .rel[a].iplt section in static executable. */
if (bfd_link_pic (info))
htab->irelifunc->size += count * sizeof_reloc;
else if (htab->splt != NULL)
htab->srelgot->size += count * sizeof_reloc;
else
{
relplt->size += count * sizeof_reloc;
relplt->reloc_count += count;
}
}
2012-03-26 19:18:29 +00:00
2017-04-10 11:32:00 +00:00
if (readonly_dynrelocs_against_ifunc_p)
*readonly_dynrelocs_against_ifunc_p = readonly_dynrelocs_against_ifunc;
/* For STT_GNU_IFUNC symbol, .got.plt has the real function address
2012-03-26 19:18:29 +00:00
and .got has the PLT entry adddress. We will load the GOT entry
with the PLT entry in finish_dynamic_symbol if it is used. For
2017-04-10 11:32:00 +00:00
branch, it uses .got.plt. For symbol value, if PLT is used,
1. Use .got.plt in a PIC object if it is forced local or not
2012-03-26 19:18:29 +00:00
dynamic.
2017-04-10 11:32:00 +00:00
2. Use .got.plt in a non-PIC object if pointer equality isn't
2012-03-26 19:18:29 +00:00
needed.
3. Use .got.plt in PIE.
4. Use .got.plt if .got isn't used.
5. Otherwise use .got so that it can be shared among different
objects at run-time.
2017-04-10 11:32:00 +00:00
If PLT isn't used, always use .got for symbol value.
We only need to relocate .got entry in PIC object or in dynamic
executable without PLT. */
if (use_plt
&& (h->got.refcount <= 0
|| (bfd_link_pic (info)
&& (h->dynindx == -1
|| h->forced_local))
|| (!bfd_link_pic (info)
&& !h->pointer_equality_needed)
|| bfd_link_pie (info)
|| htab->sgot == NULL))
2012-03-26 19:18:29 +00:00
{
/* Use .got.plt. */
h->got.offset = (bfd_vma) -1;
}
else
{
2017-04-10 11:32:00 +00:00
if (!use_plt)
{
/* PLT isn't used. */
h->plt.offset = (bfd_vma) -1;
}
if (h->got.refcount <= 0)
{
/* GOT isn't need when there are only relocations for static
pointers. */
h->got.offset = (bfd_vma) -1;
}
else
{
h->got.offset = htab->sgot->size;
htab->sgot->size += got_entry_size;
/* Need to relocate the GOT entry in a PIC object or PLT isn't
used. Otherwise, the GOT entry will be filled with the PLT
entry and dynamic GOT relocation isn't needed. */
if (need_dynreloc)
{
/* For non-static executable, dynamic GOT relocation is in
.rel[a].got section, but for static executable, it is
in .rel[a].iplt section. */
if (htab->splt != NULL)
htab->srelgot->size += sizeof_reloc;
else
{
relplt->size += sizeof_reloc;
relplt->reloc_count++;
}
}
}
2012-03-26 19:18:29 +00:00
}
return TRUE;
}