2009-06-16 H.J. Lu <hongjiu.lu@intel.com>
* configure.in (elf): Add elf-ifunc.lo.
* configure: Regenerated.
* Makefile.in: Likewise.
* elf-bfd.h (elf_link_hash_table): Add sgot, sgotplt,
srelgot, splt, srelplt, igotplt, iplt, irelplt and irelifunc.
* elf32-i386.c (elf_i386_link_hash_table): Remove sgot,
sgotplt, srelgot, splt, srelplt, igotplt, iplt, irelplt and
irelifunc.
(elf_i386_link_hash_table_create): Likewise.
(elf_i386_create_dynamic_sections): Likewise.
(elf_i386_check_relocs): Likewise.
(elf_i386_allocate_dynrelocs): Likewise.
(elf_i386_size_dynamic_sections): Likewise.
(elf_i386_relocate_section): Likewise.
(elf_i386_finish_dynamic_symbol): Likewise.
(elf_i386_finish_dynamic_sections): Likewise.
(elf_i386_create_got_section): Removed.
* elf64-x86-64.c (elf64_x86_64_link_hash_table): Remove sgot,
sgotplt, srelgot, splt, srelplt, igotplt, iplt, irelplt and
irelifunc.
(elf64_x86_64_compute_jump_table_size): Updated.
(elf64_x86_64_link_hash_table_create): Likewise.
(elf64_x86_64_create_dynamic_sections): Likewise.
(elf64_x86_64_check_relocs): Likewise.
(elf64_x86_64_allocate_dynrelocs): Likewise.
(elf64_x86_64_size_dynamic_sections): Likewise.
(elf64_x86_64_relocate_section): Likewise.
(elf64_x86_64_finish_dynamic_symbol): Likewise.
(elf64_x86_64_finish_dynamic_sections): Likewise.
(elf64_x86_64_create_got_section): Removed.
* elflink.c (_bfd_elf_create_got_section): Use log_file_align
for pointer alignment. Set up section pointers.
(_bfd_elf_create_dynamic_sections): Likewise.
(_bfd_elf_create_ifunc_sections): Moved to ...
* elf-ifunc.c: Here. New.
* Makefile.am (BFD32_BACKENDS): Add elf-ifunc.lo.
(BFD32_BACKENDS_CFILES): Add elf-ifunc.c.
Run "make dep-am".
2009-06-16 13:41:10 +00:00
|
|
|
/* ELF STT_GNU_IFUNC support.
|
2015-01-01 14:15:26 +00:00
|
|
|
Copyright (C) 2009-2015 Free Software Foundation, Inc.
|
2009-06-16 H.J. Lu <hongjiu.lu@intel.com>
* configure.in (elf): Add elf-ifunc.lo.
* configure: Regenerated.
* Makefile.in: Likewise.
* elf-bfd.h (elf_link_hash_table): Add sgot, sgotplt,
srelgot, splt, srelplt, igotplt, iplt, irelplt and irelifunc.
* elf32-i386.c (elf_i386_link_hash_table): Remove sgot,
sgotplt, srelgot, splt, srelplt, igotplt, iplt, irelplt and
irelifunc.
(elf_i386_link_hash_table_create): Likewise.
(elf_i386_create_dynamic_sections): Likewise.
(elf_i386_check_relocs): Likewise.
(elf_i386_allocate_dynrelocs): Likewise.
(elf_i386_size_dynamic_sections): Likewise.
(elf_i386_relocate_section): Likewise.
(elf_i386_finish_dynamic_symbol): Likewise.
(elf_i386_finish_dynamic_sections): Likewise.
(elf_i386_create_got_section): Removed.
* elf64-x86-64.c (elf64_x86_64_link_hash_table): Remove sgot,
sgotplt, srelgot, splt, srelplt, igotplt, iplt, irelplt and
irelifunc.
(elf64_x86_64_compute_jump_table_size): Updated.
(elf64_x86_64_link_hash_table_create): Likewise.
(elf64_x86_64_create_dynamic_sections): Likewise.
(elf64_x86_64_check_relocs): Likewise.
(elf64_x86_64_allocate_dynrelocs): Likewise.
(elf64_x86_64_size_dynamic_sections): Likewise.
(elf64_x86_64_relocate_section): Likewise.
(elf64_x86_64_finish_dynamic_symbol): Likewise.
(elf64_x86_64_finish_dynamic_sections): Likewise.
(elf64_x86_64_create_got_section): Removed.
* elflink.c (_bfd_elf_create_got_section): Use log_file_align
for pointer alignment. Set up section pointers.
(_bfd_elf_create_dynamic_sections): Likewise.
(_bfd_elf_create_ifunc_sections): Moved to ...
* elf-ifunc.c: Here. New.
* Makefile.am (BFD32_BACKENDS): Add elf-ifunc.lo.
(BFD32_BACKENDS_CFILES): Add elf-ifunc.c.
Run "make dep-am".
2009-06-16 13:41:10 +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;
|
|
|
|
|
|
|
|
if (info->shared)
|
|
|
|
{
|
|
|
|
/* We need to create .rel[a].ifunc for shared objects. */
|
|
|
|
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;
|
|
|
|
}
|
2009-06-18 00:45:14 +00:00
|
|
|
|
|
|
|
/* 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,
|
|
|
|
unsigned int plt_entry_size,
|
2013-05-07 17:03:52 +00:00
|
|
|
unsigned int plt_header_size,
|
2009-06-18 00:45:14 +00:00
|
|
|
unsigned int got_entry_size)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
|
|
|
/* When a shared library references a STT_GNU_IFUNC symbol defined
|
|
|
|
in executable, the address of the resolved function may be used.
|
|
|
|
But in non-shared executable, the address of its .plt slot may
|
|
|
|
be used. Pointer equality may not work correctly. PIE should
|
|
|
|
be used if pointer equality is required here. */
|
|
|
|
if (!info->shared
|
|
|
|
&& (h->dynindx != -1
|
|
|
|
|| info->export_dynamic)
|
|
|
|
&& h->pointer_equality_needed)
|
|
|
|
{
|
2013-01-10 20:03:55 +00:00
|
|
|
info->callbacks->einfo
|
2009-06-18 00:45:14 +00:00
|
|
|
(_("%F%P: dynamic STT_GNU_IFUNC symbol `%s' with pointer "
|
|
|
|
"equality in `%B' can not be used when making an "
|
|
|
|
"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;
|
|
|
|
}
|
|
|
|
|
2009-08-03 15:50:51 +00:00
|
|
|
htab = elf_hash_table (info);
|
|
|
|
|
Check regular reference without non-GOT reference
non_got_ref may not be set when building shared library. We need to set
non_got_ref if there are any non-PIC relocations. But we only did this
when there were no PLT/GOT relocations. It failed when there is a PLT
relocation. This checkin moves the non_got_ref check out.
bfd/
2013-04-15 H.J. Lu <hongjiu.lu@intel.com>
PR ld/15371
* elf-ifunc.c (_bfd_elf_allocate_ifunc_dyn_relocs): Check
regular reference without non-GOT reference when building
shared library.
ld/testsuite/
2013-04-15 H.J. Lu <hongjiu.lu@intel.com>
PR ld/15371
* ld-ifunc/ifunc-20-i386.d: New file.
* ld-ifunc/ifunc-20-x86-64.d: Likewise.
* ld-ifunc/ifunc-20.s: Likewise.
diff --git a/bfd/elf-ifunc.c b/bfd/elf-ifunc.c
index e56427d..7e7ec36 100644
--- a/bfd/elf-ifunc.c
+++ b/bfd/elf-ifunc.c
@@ -187,23 +187,20 @@ _bfd_elf_allocate_ifunc_dyn_relocs (struct bfd_link_info *info,
htab = elf_hash_table (info);
+ /* When building shared library, we need to handle the case where it is
+ marked with regular reference, but not non-GOT reference since the
+ non-GOT reference bit may not be set here. */
+ if (info->shared && !h->non_got_ref && h->ref_regular)
+ for (p = *head; p != NULL; p = p->next)
+ if (p->count)
+ {
+ h->non_got_ref = 1;
+ goto keep;
+ }
+
/* Support garbage collection against STT_GNU_IFUNC symbols. */
if (h->plt.refcount <= 0 && h->got.refcount <= 0)
{
- /* When building shared library, we need to handle the case
- where it is marked with regular reference, but not non-GOT
- reference. It may happen if we didn't see STT_GNU_IFUNC
- symbol at the time when checking relocations. */
- if (info->shared
- && !h->non_got_ref
- && h->ref_regular)
- for (p = *head; p != NULL; p = p->next)
- if (p->count)
- {
- h->non_got_ref = 1;
- goto keep;
- }
-
h->got = htab->init_got_offset;
h->plt = htab->init_plt_offset;
*head = NULL;
diff --git a/ld/testsuite/ld-ifunc/ifunc-20-i386.d b/ld/testsuite/ld-ifunc/ifunc-20-i386.d
new file mode 100644
index 0000000..9373fcf
--- /dev/null
+++ b/ld/testsuite/ld-ifunc/ifunc-20-i386.d
@@ -0,0 +1,13 @@
+#source: ifunc-20.s
+#ld: -shared -m elf_i386 -z nocombreloc
+#as: --32
+#readelf: -r --wide
+#target: x86_64-*-* i?86-*-*
+
+Relocation section '.rel.ifunc' at offset 0x[0-9a-f]+ contains 1 entries:
+[ ]+Offset[ ]+Info[ ]+Type[ ]+.*
+[0-9a-f]+[ ]+[0-9a-f]+[ ]+R_386_32[ ]+ifunc\(\)[ ]+ifunc
+
+Relocation section '.rel.plt' at offset 0x[0-9a-f]+ contains 1 entries:
+[ ]+Offset[ ]+Info[ ]+Type[ ]+.*
+[0-9a-f]+[ ]+[0-9a-f]+[ ]+R_386_JUMP_SLOT[ ]+ifunc\(\)[ ]+ifunc
diff --git a/ld/testsuite/ld-ifunc/ifunc-20-x86-64.d b/ld/testsuite/ld-ifunc/ifunc-20-x86-64.d
new file mode 100644
index 0000000..39492d4
--- /dev/null
+++ b/ld/testsuite/ld-ifunc/ifunc-20-x86-64.d
@@ -0,0 +1,13 @@
+#source: ifunc-20.s
+#ld: -shared -m elf_x86_64 -z nocombreloc
+#as: --64
+#readelf: -r --wide
+#target: x86_64-*-*
+
+Relocation section '.rela.ifunc' at offset 0x[0-9a-f]+ contains 1 entries:
+[ ]+Offset[ ]+Info[ ]+Type[ ]+.*
+[0-9a-f]+[ ]+[0-9a-f]+[ ]+R_X86_64_64[ ]+ifunc\(\)[ ]+ifunc \+ 0
+
+Relocation section '.rela.plt' at offset 0x[0-9a-f]+ contains 1 entries:
+[ ]+Offset[ ]+Info[ ]+Type[ ]+.*
+[0-9a-f]+[ ]+[0-9a-f]+[ ]+R_X86_64_JUMP_SLOT[ ]+ifunc\(\)[ ]+ifunc \+ 0
diff --git a/ld/testsuite/ld-ifunc/ifunc-20.s b/ld/testsuite/ld-ifunc/ifunc-20.s
new file mode 100644
index 0000000..9d45455
--- /dev/null
+++ b/ld/testsuite/ld-ifunc/ifunc-20.s
@@ -0,0 +1,16 @@
+ .section .data.rel,"aw",@progbits
+ .globl ifunc_ptrt
+ .type ifunc_ptr, @object
+ifunc_ptr:
+ .dc.a ifunc
+ .text
+ .type ifunc, @gnu_indirect_function
+ .globl ifunc
+ifunc:
+ ret
+ .size ifunc, .-ifunc
+ .type bar, @function
+ .globl bar
+bar:
+ call ifunc@PLT
+ .size bar, .-bar
2013-04-15 21:16:18 +00:00
|
|
|
/* When building shared library, we need to handle the case where it is
|
|
|
|
marked with regular reference, but not non-GOT reference since the
|
|
|
|
non-GOT reference bit may not be set here. */
|
|
|
|
if (info->shared && !h->non_got_ref && h->ref_regular)
|
|
|
|
for (p = *head; p != NULL; p = p->next)
|
|
|
|
if (p->count)
|
|
|
|
{
|
|
|
|
h->non_got_ref = 1;
|
|
|
|
goto keep;
|
|
|
|
}
|
|
|
|
|
2010-07-13 16:59:14 +00:00
|
|
|
/* Support garbage collection against STT_GNU_IFUNC symbols. */
|
|
|
|
if (h->plt.refcount <= 0 && h->got.refcount <= 0)
|
|
|
|
{
|
2011-01-07 03:34:23 +00:00
|
|
|
h->got = htab->init_got_offset;
|
|
|
|
h->plt = htab->init_plt_offset;
|
|
|
|
*head = NULL;
|
|
|
|
return TRUE;
|
2010-07-13 16:59:14 +00:00
|
|
|
}
|
|
|
|
|
2009-06-18 00:45:14 +00:00
|
|
|
/* Return and discard space for dynamic relocations against it if
|
|
|
|
it is never referenced in a non-shared object. */
|
|
|
|
if (!h->ref_regular)
|
|
|
|
{
|
|
|
|
if (h->plt.refcount > 0
|
|
|
|
|| h->got.refcount > 0)
|
|
|
|
abort ();
|
2009-08-03 15:50:51 +00:00
|
|
|
h->got = htab->init_got_offset;
|
|
|
|
h->plt = htab->init_plt_offset;
|
2009-06-18 00:45:14 +00:00
|
|
|
*head = NULL;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2011-01-07 03:34:23 +00:00
|
|
|
keep:
|
2009-06-18 00:45:14 +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;
|
|
|
|
|
|
|
|
/* If this is the first .plt entry, make room for the special
|
|
|
|
first entry. */
|
|
|
|
if (plt->size == 0)
|
2013-05-07 17:03:52 +00:00
|
|
|
plt->size += plt_header_size;
|
2009-06-18 00:45:14 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
plt = htab->iplt;
|
|
|
|
gotplt = htab->igotplt;
|
|
|
|
relplt = htab->irelplt;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Don't update value of STT_GNU_IFUNC symbol to PLT. We need
|
2013-01-10 20:03:55 +00:00
|
|
|
the original value for R_*_IRELATIVE. */
|
2009-06-18 00:45:14 +00:00
|
|
|
h->plt.offset = plt->size;
|
|
|
|
|
|
|
|
/* Make room for this entry in the .plt/.iplt section. */
|
|
|
|
plt->size += plt_entry_size;
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
|
|
|
/* We also need to make an entry in the .rel[a].plt/.rel[a].iplt
|
|
|
|
section. */
|
|
|
|
relplt->size += sizeof_reloc;
|
|
|
|
relplt->reloc_count++;
|
|
|
|
|
|
|
|
/* We need dynamic relocation for STT_GNU_IFUNC symbol only when
|
|
|
|
there is a non-GOT reference in a shared object. */
|
|
|
|
if (!info->shared
|
|
|
|
|| !h->non_got_ref)
|
|
|
|
*head = NULL;
|
|
|
|
|
|
|
|
/* Finally, allocate space. */
|
2011-01-07 03:34:23 +00:00
|
|
|
p = *head;
|
|
|
|
if (p != NULL)
|
|
|
|
{
|
|
|
|
bfd_size_type count = 0;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
count += p->count;
|
|
|
|
p = p->next;
|
|
|
|
}
|
|
|
|
while (p != NULL);
|
|
|
|
htab->irelifunc->size += count * sizeof_reloc;
|
|
|
|
}
|
2009-06-18 00:45:14 +00:00
|
|
|
|
2011-01-07 03:34:23 +00:00
|
|
|
/* For STT_GNU_IFUNC symbol, .got.plt has the real function address
|
2009-06-18 00:45:14 +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
|
|
|
|
branch, it uses .got.plt. For symbol value,
|
|
|
|
1. Use .got.plt in a shared object if it is forced local or not
|
|
|
|
dynamic.
|
|
|
|
2. Use .got.plt in a non-shared object if pointer equality isn't
|
|
|
|
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.
|
|
|
|
We only need to relocate .got entry in shared object. */
|
2011-09-12 18:17:36 +00:00
|
|
|
if (h->got.refcount <= 0
|
|
|
|
|| (info->shared
|
|
|
|
&& (h->dynindx == -1
|
|
|
|
|| h->forced_local))
|
2009-06-18 00:45:14 +00:00
|
|
|
|| (!info->shared
|
|
|
|
&& !h->pointer_equality_needed)
|
|
|
|
|| (info->executable && info->shared)
|
|
|
|
|| htab->sgot == NULL)
|
|
|
|
{
|
|
|
|
/* Use .got.plt. */
|
|
|
|
h->got.offset = (bfd_vma) -1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
h->got.offset = htab->sgot->size;
|
|
|
|
htab->sgot->size += got_entry_size;
|
|
|
|
if (info->shared)
|
|
|
|
htab->srelgot->size += sizeof_reloc;
|
|
|
|
}
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
2014-12-04 22:19:41 +00:00
|
|
|
|
|
|
|
/* Similar to _bfd_elf_get_synthetic_symtab, optimized for unsorted PLT
|
|
|
|
entries. PLT is the PLT section. PLT_SYM_VAL is a function pointer
|
|
|
|
which returns an array of PLT entry symbol values. */
|
|
|
|
|
|
|
|
long
|
|
|
|
_bfd_elf_ifunc_get_synthetic_symtab
|
|
|
|
(bfd *abfd, long symcount ATTRIBUTE_UNUSED,
|
|
|
|
asymbol **syms ATTRIBUTE_UNUSED, long dynsymcount, asymbol **dynsyms,
|
|
|
|
asymbol **ret, asection *plt,
|
|
|
|
bfd_vma *(*get_plt_sym_val) (bfd *, asymbol **, asection *, asection *))
|
|
|
|
{
|
|
|
|
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
|
|
|
|
asection *relplt;
|
|
|
|
asymbol *s;
|
|
|
|
const char *relplt_name;
|
|
|
|
bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
|
|
|
|
arelent *p;
|
|
|
|
long count, i, n;
|
|
|
|
size_t size;
|
|
|
|
Elf_Internal_Shdr *hdr;
|
|
|
|
char *names;
|
|
|
|
bfd_vma *plt_sym_val;
|
|
|
|
|
|
|
|
*ret = NULL;
|
|
|
|
|
|
|
|
if (plt == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (dynsymcount <= 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
relplt_name = bed->relplt_name;
|
|
|
|
if (relplt_name == NULL)
|
|
|
|
relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt";
|
|
|
|
relplt = bfd_get_section_by_name (abfd, relplt_name);
|
|
|
|
if (relplt == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
hdr = &elf_section_data (relplt)->this_hdr;
|
|
|
|
if (hdr->sh_link != elf_dynsymtab (abfd)
|
|
|
|
|| (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
|
|
|
|
if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
count = relplt->size / hdr->sh_entsize;
|
|
|
|
size = count * sizeof (asymbol);
|
|
|
|
p = relplt->relocation;
|
|
|
|
for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
|
|
|
|
{
|
|
|
|
size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
|
|
|
|
if (p->addend != 0)
|
|
|
|
{
|
|
|
|
#ifdef BFD64
|
|
|
|
size += sizeof ("+0x") - 1 + 8 + 8 * (bed->s->elfclass == ELFCLASS64);
|
|
|
|
#else
|
|
|
|
size += sizeof ("+0x") - 1 + 8;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
plt_sym_val = get_plt_sym_val (abfd, dynsyms, plt, relplt);
|
|
|
|
if (plt_sym_val == NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
s = *ret = (asymbol *) bfd_malloc (size);
|
|
|
|
if (s == NULL)
|
|
|
|
{
|
|
|
|
free (plt_sym_val);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
names = (char *) (s + count);
|
|
|
|
p = relplt->relocation;
|
|
|
|
n = 0;
|
|
|
|
for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
|
|
|
|
{
|
|
|
|
size_t len;
|
|
|
|
bfd_vma addr;
|
|
|
|
|
|
|
|
addr = plt_sym_val[i];
|
|
|
|
if (addr == (bfd_vma) -1)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
*s = **p->sym_ptr_ptr;
|
|
|
|
/* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
|
|
|
|
we are defining a symbol, ensure one of them is set. */
|
|
|
|
if ((s->flags & BSF_LOCAL) == 0)
|
|
|
|
s->flags |= BSF_GLOBAL;
|
|
|
|
s->flags |= BSF_SYNTHETIC;
|
|
|
|
s->section = plt;
|
|
|
|
s->value = addr - plt->vma;
|
|
|
|
s->name = names;
|
|
|
|
s->udata.p = NULL;
|
|
|
|
len = strlen ((*p->sym_ptr_ptr)->name);
|
|
|
|
memcpy (names, (*p->sym_ptr_ptr)->name, len);
|
|
|
|
names += len;
|
|
|
|
if (p->addend != 0)
|
|
|
|
{
|
|
|
|
char buf[30], *a;
|
|
|
|
|
|
|
|
memcpy (names, "+0x", sizeof ("+0x") - 1);
|
|
|
|
names += sizeof ("+0x") - 1;
|
|
|
|
bfd_sprintf_vma (abfd, buf, p->addend);
|
|
|
|
for (a = buf; *a == '0'; ++a)
|
|
|
|
;
|
|
|
|
len = strlen (a);
|
|
|
|
memcpy (names, a, len);
|
|
|
|
names += len;
|
|
|
|
}
|
|
|
|
memcpy (names, "@plt", sizeof ("@plt"));
|
|
|
|
names += sizeof ("@plt");
|
|
|
|
++s, ++n;
|
|
|
|
}
|
|
|
|
|
|
|
|
free (plt_sym_val);
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|