mirror of
https://sourceware.org/git/glibc.git
synced 2024-11-23 17:53:37 +08:00
490e6c62aa
dynamic-link.h is included more than once in some elf/ files (rtld.c,
dl-conflict.c, dl-reloc.c, dl-reloc-static-pie.c) and uses GCC nested
functions. This harms readability and the nested functions usage
is the biggest obstacle prevents Clang build (Clang doesn't support GCC
nested functions).
The key idea for unnesting is to add extra parameters (struct link_map
*and struct r_scope_elm *[]) to RESOLVE_MAP,
ELF_MACHINE_BEFORE_RTLD_RELOC, ELF_DYNAMIC_RELOCATE, elf_machine_rel[a],
elf_machine_lazy_rel, and elf_machine_runtime_setup. (This is inspired
by Stan Shebs' ppc64/x86-64 implementation in the
google/grte/v5-2.27/master which uses mixed extra parameters and static
variables.)
Future simplification:
* If mips elf_machine_runtime_setup no longer needs RESOLVE_GOTSYM,
elf_machine_runtime_setup can drop the `scope` parameter.
* If TLSDESC no longer need to be in elf_machine_lazy_rel,
elf_machine_lazy_rel can drop the `scope` parameter.
Tested on aarch64, i386, x86-64, powerpc64le, powerpc64, powerpc32,
sparc64, sparcv9, s390x, s390, hppa, ia64, armhf, alpha, and mips64.
In addition, tested build-many-glibcs.py with {arc,csky,microblaze,nios2}-linux-gnu
and riscv64-linux-gnu-rv64imafdc-lp64d.
Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>
192 lines
6.0 KiB
C
192 lines
6.0 KiB
C
/* Do relocations for ELF dynamic linking.
|
|
Copyright (C) 1995-2021 Free Software Foundation, Inc.
|
|
This file is part of the GNU C Library.
|
|
|
|
The GNU C Library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
|
The GNU C Library 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
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with the GNU C Library; if not, see
|
|
<https://www.gnu.org/licenses/>. */
|
|
|
|
/* This file may be included twice, to define both
|
|
`elf_dynamic_do_rel' and `elf_dynamic_do_rela'. */
|
|
|
|
#ifdef DO_RELA
|
|
# define elf_dynamic_do_Rel elf_dynamic_do_Rela
|
|
# define Rel Rela
|
|
# define elf_machine_rel elf_machine_rela
|
|
# define elf_machine_rel_relative elf_machine_rela_relative
|
|
#endif
|
|
|
|
#ifndef DO_ELF_MACHINE_REL_RELATIVE
|
|
# define DO_ELF_MACHINE_REL_RELATIVE(map, l_addr, relative) \
|
|
elf_machine_rel_relative (l_addr, relative, \
|
|
(void *) (l_addr + relative->r_offset))
|
|
#endif
|
|
|
|
/* Perform the relocations in MAP on the running program image as specified
|
|
by RELTAG, SZTAG. If LAZY is nonzero, this is the first pass on PLT
|
|
relocations; they should be set up to call _dl_runtime_resolve, rather
|
|
than fully resolved now. */
|
|
|
|
static inline void __attribute__ ((always_inline))
|
|
elf_dynamic_do_Rel (struct link_map *map, struct r_scope_elem *scope[],
|
|
ElfW(Addr) reladdr, ElfW(Addr) relsize,
|
|
__typeof (((ElfW(Dyn) *) 0)->d_un.d_val) nrelative,
|
|
int lazy, int skip_ifunc)
|
|
{
|
|
const ElfW(Rel) *r = (const void *) reladdr;
|
|
const ElfW(Rel) *end = (const void *) (reladdr + relsize);
|
|
ElfW(Addr) l_addr = map->l_addr;
|
|
# if defined ELF_MACHINE_IRELATIVE && !defined RTLD_BOOTSTRAP
|
|
const ElfW(Rel) *r2 = NULL;
|
|
const ElfW(Rel) *end2 = NULL;
|
|
# endif
|
|
|
|
#if (!defined DO_RELA || !defined ELF_MACHINE_PLT_REL) && !defined RTLD_BOOTSTRAP
|
|
/* We never bind lazily during ld.so bootstrap. Unfortunately gcc is
|
|
not clever enough to see through all the function calls to realize
|
|
that. */
|
|
if (lazy)
|
|
{
|
|
/* Doing lazy PLT relocations; they need very little info. */
|
|
for (; r < end; ++r)
|
|
# ifdef ELF_MACHINE_IRELATIVE
|
|
if (ELFW(R_TYPE) (r->r_info) == ELF_MACHINE_IRELATIVE)
|
|
{
|
|
if (r2 == NULL)
|
|
r2 = r;
|
|
end2 = r;
|
|
}
|
|
else
|
|
# endif
|
|
elf_machine_lazy_rel (map, scope, l_addr, r, skip_ifunc);
|
|
|
|
# ifdef ELF_MACHINE_IRELATIVE
|
|
if (r2 != NULL)
|
|
for (; r2 <= end2; ++r2)
|
|
if (ELFW(R_TYPE) (r2->r_info) == ELF_MACHINE_IRELATIVE)
|
|
elf_machine_lazy_rel (map, scope, l_addr, r2, skip_ifunc);
|
|
# endif
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
const ElfW(Sym) *const symtab =
|
|
(const void *) D_PTR (map, l_info[DT_SYMTAB]);
|
|
const ElfW(Rel) *relative = r;
|
|
r += nrelative;
|
|
|
|
#ifndef RTLD_BOOTSTRAP
|
|
/* This is defined in rtld.c, but nowhere in the static libc.a; make
|
|
the reference weak so static programs can still link. This
|
|
declaration cannot be done when compiling rtld.c (i.e. #ifdef
|
|
RTLD_BOOTSTRAP) because rtld.c contains the common defn for
|
|
_dl_rtld_map, which is incompatible with a weak decl in the same
|
|
file. */
|
|
# ifndef SHARED
|
|
weak_extern (GL(dl_rtld_map));
|
|
# endif
|
|
if (map != &GL(dl_rtld_map)) /* Already done in rtld itself. */
|
|
# if !defined DO_RELA || defined ELF_MACHINE_REL_RELATIVE
|
|
/* Rela platforms get the offset from r_addend and this must
|
|
be copied in the relocation address. Therefore we can skip
|
|
the relative relocations only if this is for rel
|
|
relocations or rela relocations if they are computed as
|
|
memory_loc += l_addr... */
|
|
if (l_addr != 0)
|
|
# else
|
|
/* ...or we know the object has been prelinked. */
|
|
if (l_addr != 0 || ! map->l_info[VALIDX(DT_GNU_PRELINKED)])
|
|
# endif
|
|
#endif
|
|
for (; relative < r; ++relative)
|
|
DO_ELF_MACHINE_REL_RELATIVE (map, l_addr, relative);
|
|
|
|
#ifdef RTLD_BOOTSTRAP
|
|
/* The dynamic linker always uses versioning. */
|
|
assert (map->l_info[VERSYMIDX (DT_VERSYM)] != NULL);
|
|
#else
|
|
if (map->l_info[VERSYMIDX (DT_VERSYM)])
|
|
#endif
|
|
{
|
|
const ElfW(Half) *const version =
|
|
(const void *) D_PTR (map, l_info[VERSYMIDX (DT_VERSYM)]);
|
|
|
|
for (; r < end; ++r)
|
|
{
|
|
#if defined ELF_MACHINE_IRELATIVE && !defined RTLD_BOOTSTRAP
|
|
if (ELFW(R_TYPE) (r->r_info) == ELF_MACHINE_IRELATIVE)
|
|
{
|
|
if (r2 == NULL)
|
|
r2 = r;
|
|
end2 = r;
|
|
continue;
|
|
}
|
|
#endif
|
|
|
|
ElfW(Half) ndx = version[ELFW(R_SYM) (r->r_info)] & 0x7fff;
|
|
elf_machine_rel (map, scope, r, &symtab[ELFW(R_SYM) (r->r_info)],
|
|
&map->l_versions[ndx],
|
|
(void *) (l_addr + r->r_offset), skip_ifunc);
|
|
}
|
|
|
|
#if defined ELF_MACHINE_IRELATIVE && !defined RTLD_BOOTSTRAP
|
|
if (r2 != NULL)
|
|
for (; r2 <= end2; ++r2)
|
|
if (ELFW(R_TYPE) (r2->r_info) == ELF_MACHINE_IRELATIVE)
|
|
{
|
|
ElfW(Half) ndx
|
|
= version[ELFW(R_SYM) (r2->r_info)] & 0x7fff;
|
|
elf_machine_rel (map, scope, r2,
|
|
&symtab[ELFW(R_SYM) (r2->r_info)],
|
|
&map->l_versions[ndx],
|
|
(void *) (l_addr + r2->r_offset),
|
|
skip_ifunc);
|
|
}
|
|
#endif
|
|
}
|
|
#ifndef RTLD_BOOTSTRAP
|
|
else
|
|
{
|
|
for (; r < end; ++r)
|
|
# ifdef ELF_MACHINE_IRELATIVE
|
|
if (ELFW(R_TYPE) (r->r_info) == ELF_MACHINE_IRELATIVE)
|
|
{
|
|
if (r2 == NULL)
|
|
r2 = r;
|
|
end2 = r;
|
|
}
|
|
else
|
|
# endif
|
|
elf_machine_rel (map, scope, r, &symtab[ELFW(R_SYM) (r->r_info)], NULL,
|
|
(void *) (l_addr + r->r_offset), skip_ifunc);
|
|
|
|
# ifdef ELF_MACHINE_IRELATIVE
|
|
if (r2 != NULL)
|
|
for (; r2 <= end2; ++r2)
|
|
if (ELFW(R_TYPE) (r2->r_info) == ELF_MACHINE_IRELATIVE)
|
|
elf_machine_rel (map, scope, r2, &symtab[ELFW(R_SYM) (r2->r_info)],
|
|
NULL, (void *) (l_addr + r2->r_offset),
|
|
skip_ifunc);
|
|
# endif
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
#undef elf_dynamic_do_Rel
|
|
#undef Rel
|
|
#undef elf_machine_rel
|
|
#undef elf_machine_rel_relative
|
|
#undef DO_ELF_MACHINE_REL_RELATIVE
|
|
#undef DO_RELA
|