+2018-04-04 Maciej W. Rozycki <macro@mips.com>
+
+ [BZ #19818]
+ * sysdeps/generic/ldsodefs.h (LOOKUP_VALUE_ADDRESS): Add `set'
+ parameter.
+ (SYMBOL_ADDRESS): New macro.
+ [!ELF_FUNCTION_PTR_IS_SPECIAL] (DL_SYMBOL_ADDRESS): Use
+ SYMBOL_ADDRESS for symbol address calculation.
+ * elf/dl-runtime.c (_dl_fixup): Likewise.
+ (_dl_profile_fixup): Likewise.
+ * elf/dl-symaddr.c (_dl_symbol_address): Likewise.
+ * elf/rtld.c (dl_main): Likewise.
+ * sysdeps/aarch64/dl-machine.h (elf_machine_rela): Likewise.
+ * sysdeps/alpha/dl-machine.h (elf_machine_rela): Likewise.
+ * sysdeps/arm/dl-machine.h (elf_machine_rel): Likewise.
+ (elf_machine_rela): Likewise.
+ * sysdeps/hppa/dl-machine.h (elf_machine_rela): Likewise.
+ * sysdeps/hppa/dl-symaddr.c (_dl_symbol_address): Likewise.
+ * sysdeps/i386/dl-machine.h (elf_machine_rel): Likewise.
+ (elf_machine_rela): Likewise.
+ * sysdeps/ia64/dl-machine.h (elf_machine_rela): Likewise.
+ * sysdeps/m68k/dl-machine.h (elf_machine_rela): Likewise.
+ * sysdeps/microblaze/dl-machine.h (elf_machine_rela): Likewise.
+ * sysdeps/mips/dl-machine.h (ELF_MACHINE_BEFORE_RTLD_RELOC):
+ Likewise.
+ (elf_machine_reloc): Likewise.
+ (elf_machine_got_rel): Likewise.
+ * sysdeps/mips/dl-trampoline.c (__dl_runtime_resolve): Likewise.
+ * sysdeps/nios2/dl-machine.h (elf_machine_rela): Likewise.
+ * sysdeps/powerpc/powerpc32/dl-machine.h (elf_machine_rela):
+ Likewise.
+ * sysdeps/powerpc/powerpc64/dl-machine.h (elf_machine_rela):
+ Likewise.
+ * sysdeps/riscv/dl-machine.h (elf_machine_rela): Likewise.
+ * sysdeps/s390/s390-32/dl-machine.h (elf_machine_rela):
+ Likewise.
+ * sysdeps/s390/s390-64/dl-machine.h (elf_machine_rela):
+ Likewise.
+ * sysdeps/sh/dl-machine.h (elf_machine_rela): Likewise.
+ * sysdeps/sparc/sparc32/dl-machine.h (elf_machine_rela):
+ Likewise.
+ * sysdeps/sparc/sparc64/dl-machine.h (elf_machine_rela):
+ Likewise.
+ * sysdeps/tile/dl-machine.h (elf_machine_rela): Likewise.
+ * sysdeps/x86_64/dl-machine.h (elf_machine_rela): Likewise.
+
2018-04-04 Zack Weinberg <zackw@panix.com>
* sysdeps/generic/internal-signals.h: Include signal.h,
of the object that defines sym. Now add in the symbol
offset. */
value = DL_FIXUP_MAKE_VALUE (result,
- sym ? (LOOKUP_VALUE_ADDRESS (result)
- + sym->st_value) : 0);
+ SYMBOL_ADDRESS (result, sym, false));
}
else
{
/* We already found the symbol. The module (and therefore its load
address) is also known. */
- value = DL_FIXUP_MAKE_VALUE (l, l->l_addr + sym->st_value);
+ value = DL_FIXUP_MAKE_VALUE (l, SYMBOL_ADDRESS (l, sym, true));
result = l;
}
of the object that defines sym. Now add in the symbol
offset. */
value = DL_FIXUP_MAKE_VALUE (result,
- defsym != NULL
- ? LOOKUP_VALUE_ADDRESS (result)
- + defsym->st_value : 0);
+ SYMBOL_ADDRESS (result, defsym, false));
if (defsym != NULL
&& __builtin_expect (ELFW(ST_TYPE) (defsym->st_info)
{
/* We already found the symbol. The module (and therefore its load
address) is also known. */
- value = DL_FIXUP_MAKE_VALUE (l, l->l_addr + refsym->st_value);
+ value = DL_FIXUP_MAKE_VALUE (l, SYMBOL_ADDRESS (l, refsym, true));
if (__builtin_expect (ELFW(ST_TYPE) (refsym->st_info)
== STT_GNU_IFUNC, 0))
void *
_dl_symbol_address (struct link_map *map, const ElfW(Sym) *ref)
{
- ElfW(Addr) value = (map ? map->l_addr : 0) + ref->st_value;
+ ElfW(Addr) value = SYMBOL_ADDRESS (map, ref, false);
/* Return the pointer to function descriptor. */
if (ELFW(ST_TYPE) (ref->st_info) == STT_FUNC)
NULL, ELF_RTYPE_CLASS_PLT,
DL_LOOKUP_ADD_DEPENDENCY, NULL);
- loadbase = LOOKUP_VALUE_ADDRESS (result);
+ loadbase = LOOKUP_VALUE_ADDRESS (result, false);
_dl_printf ("%s found at 0x%0*Zd in object at 0x%0*Zd\n",
_dl_argv[i],
{
const ElfW(Sym) *const refsym = sym;
struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
- ElfW(Addr) value = sym_map == NULL ? 0 : sym_map->l_addr + sym->st_value;
+ ElfW(Addr) value = SYMBOL_ADDRESS (sym_map, sym, true);
if (sym != NULL
&& __glibc_unlikely (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC)
if (sym_map)
{
sym_raw_value += sym->st_value;
- sym_value = sym_raw_value + sym_map->l_addr;
+ sym_value += SYMBOL_ADDRESS (sym_map, sym, true);
}
if (r_type == R_ALPHA_GLOB_DAT)
{
const Elf32_Sym *const refsym = sym;
struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
- Elf32_Addr value = sym_map == NULL ? 0 : sym_map->l_addr + sym->st_value;
+ Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
if (sym != NULL
&& __builtin_expect (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC, 0)
binding found in the user program or a loaded library
rather than the dynamic linker's built-in definitions
used while loading those libraries. */
- value -= map->l_addr + refsym->st_value;
+ value -= SYMBOL_ADDRESS (map, refsym, true);
# endif
/* Support relocations on mis-aligned offsets. */
((struct unaligned *) reloc_addr)->x += value;
const Elf32_Sym *const refsym = sym;
# endif
struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
- Elf32_Addr value = sym_map == NULL ? 0 : sym_map->l_addr + sym->st_value;
+ Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
if (sym != NULL
&& __builtin_expect (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC, 0)
/* Result of the lookup functions and how to retrieve the base address. */
typedef struct link_map *lookup_t;
#define LOOKUP_VALUE(map) map
-#define LOOKUP_VALUE_ADDRESS(map) ((map) ? (map)->l_addr : 0)
+#define LOOKUP_VALUE_ADDRESS(map, set) ((set) || (map) ? (map)->l_addr : 0)
+
+/* Calculate the address of symbol REF using the base address from map MAP,
+ if non-NULL. Don't check for NULL map if MAP_SET is TRUE. */
+#define SYMBOL_ADDRESS(map, ref, map_set) \
+ ((ref) == NULL ? 0 \
+ : LOOKUP_VALUE_ADDRESS (map, map_set) + (ref)->st_value)
/* On some architectures a pointer to a function is not just a pointer
to the actual code of the function but rather an architecture
specific descriptor. */
#ifndef ELF_FUNCTION_PTR_IS_SPECIAL
# define DL_SYMBOL_ADDRESS(map, ref) \
- (void *) (LOOKUP_VALUE_ADDRESS (map) + ref->st_value)
+ (void *) SYMBOL_ADDRESS (map, ref, false)
# define DL_LOOKUP_ADDRESS(addr) ((ElfW(Addr)) (addr))
# define DL_CALL_DT_INIT(map, start, argc, argv, env) \
((init_t) (start)) (argc, argv, env)
if (sym_map)
{
- value = sym ? sym_map->l_addr + sym->st_value : 0;
+ value = SYMBOL_ADDRESS (sym_map, sym, true);
value += reloc->r_addend;
}
else
case R_PARISC_DIR21L:
{
unsigned int insn = *(unsigned int *)reloc_addr;
- value = sym_map->l_addr + sym->st_value
- + ((reloc->r_addend + 0x1000) & -0x2000);
+ value = (SYMBOL_ADDRESS (sym_map, sym, true)
+ + ((reloc->r_addend + 0x1000) & -0x2000));
value = value >> 11;
insn = (insn &~ 0x1fffff) | reassemble_21 (value);
*(unsigned int *)reloc_addr = insn;
case R_PARISC_DIR14R:
{
unsigned int insn = *(unsigned int *)reloc_addr;
- value = ((sym_map->l_addr + sym->st_value) & 0x7ff)
- + (((reloc->r_addend & 0x1fff) ^ 0x1000) - 0x1000);
+ value = ((SYMBOL_ADDRESS (sym_map, sym, true) & 0x7ff)
+ + (((reloc->r_addend & 0x1fff) ^ 0x1000) - 0x1000));
insn = (insn &~ 0x3fff) | reassemble_14 (value);
*(unsigned int *)reloc_addr = insn;
}
_dl_symbol_address (struct link_map *map, const ElfW(Sym) *ref)
{
/* Find the "ip" from the "map" and symbol "ref" */
- Elf32_Addr value = (map ? map->l_addr : 0) + ref->st_value;
+ Elf32_Addr value = SYMBOL_ADDRESS (map, ref, false);
/* On hppa, we have to return the pointer to function descriptor.
This involves an "| 2" to inform $$dyncall that this is a plabel32 */
const Elf32_Sym *const refsym = sym;
# endif
struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
- Elf32_Addr value = sym_map == NULL ? 0 : sym_map->l_addr + sym->st_value;
+ Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
if (sym != NULL
&& __glibc_unlikely (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC)
const Elf32_Sym *const refsym = sym;
# endif
struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
- Elf32_Addr value = sym == NULL ? 0 : sym_map->l_addr + sym->st_value;
+ Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
if (sym != NULL
&& __glibc_likely (sym->st_shndx != SHN_UNDEF)
/* RESOLVE_MAP() will return NULL if it fail to locate the symbol. */
if ((sym_map = RESOLVE_MAP (&sym, version, r_type)))
{
- value = sym_map->l_addr + sym->st_value + reloc->r_addend;
+ value = SYMBOL_ADDRESS (sym_map, sym, true) + reloc->r_addend;
if (R_IA64_TYPE (r_type) == R_IA64_TYPE (R_IA64_DIR64LSB))
;/* No adjustment. */
{
const Elf32_Sym *const refsym = sym;
struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
- Elf32_Addr value = sym == NULL ? 0 : sym_map->l_addr + sym->st_value;
+ Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
switch (r_type)
{
{
const Elf32_Sym *const refsym = sym;
struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
- Elf32_Addr value = sym == NULL ? 0 : sym_map->l_addr + sym->st_value;
+ Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
value += reloc->r_addend;
if (r_type == R_MICROBLAZE_GLOB_DAT ||
while (i--) \
{ \
if (sym->st_shndx == SHN_UNDEF || sym->st_shndx == SHN_COMMON) \
- *got = map->l_addr + sym->st_value; \
+ *got = SYMBOL_ADDRESS (map, sym, true); \
else if (ELFW(ST_TYPE) (sym->st_info) == STT_FUNC \
&& *got != sym->st_value) \
*got += map->l_addr; \
*got += map->l_addr; \
} \
else \
- *got = map->l_addr + sym->st_value; \
+ *got = SYMBOL_ADDRESS (map, sym, true); \
\
got++; \
sym++; \
#ifndef RTLD_BOOTSTRAP
if (map != &GL(dl_rtld_map))
#endif
- reloc_value += sym->st_value + map->l_addr;
+ reloc_value += SYMBOL_ADDRESS (map, sym, true);
}
else
{
"found jump slot relocation with non-zero addend");
sym_map = RESOLVE_MAP (&sym, version, r_type);
- value = sym_map == NULL ? 0 : sym_map->l_addr + sym->st_value;
+ value = SYMBOL_ADDRESS (sym_map, sym, true);
*addr_field = value;
break;
/* Calculate the address of the symbol. */
sym_map = RESOLVE_MAP (&sym, version, r_type);
- value = sym_map == NULL ? 0 : sym_map->l_addr + sym->st_value;
+ value = SYMBOL_ADDRESS (sym_map, sym, true);
if (__builtin_expect (sym == NULL, 0))
/* This can happen in trace mode if an object could not be
= vernum ? &map->l_versions[vernum[sym_index] & 0x7fff] : NULL; \
struct link_map *sym_map; \
sym_map = RESOLVE_MAP (&ref, version, reloc); \
- ref ? sym_map->l_addr + ref->st_value : 0; \
+ SYMBOL_ADDRESS (sym_map, ref, true); \
})
if (map->l_info[VERSYMIDX (DT_VERSYM)] != NULL)
&& !(sym->st_other & STO_MIPS_PLT))
{
if (lazy)
- *got = sym->st_value + map->l_addr;
+ *got = SYMBOL_ADDRESS (map, sym, true);
else
/* This is a lazy-binding stub, so we don't need the
canonical address. */
/* Currently value contains the base load address of the object
that defines sym. Now add in the symbol offset. */
- value = (sym ? sym_map->l_addr + sym->st_value : 0);
+ value = SYMBOL_ADDRESS (sym_map, sym, true);
}
else
/* We already found the symbol. The module (and therefore its load
address) is also known. */
- value = l->l_addr + sym->st_value;
+ value = SYMBOL_ADDRESS (l, sym, true);
/* Apply the relocation with that value. */
*(got + local_gotno + sym_index - gotsym) = value;
{
const Elf32_Sym *const refsym = sym;
struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
- Elf32_Addr value = sym == NULL ? 0 : sym_map->l_addr + sym->st_value;
+ Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
switch (r_type)
{
else
{
sym_map = RESOLVE_MAP (&sym, version, r_type);
- value = sym_map == NULL ? 0 : sym_map->l_addr + sym->st_value;
+ value = SYMBOL_ADDRESS (sym_map, sym, true);
}
value += reloc->r_addend;
#else
/* We need SYM_MAP even in the absence of TLS, for elf_machine_fixup_plt
and STT_GNU_IFUNC. */
struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
- Elf64_Addr value = ((sym_map == NULL ? 0 : sym_map->l_addr + sym->st_value)
- + reloc->r_addend);
+ Elf64_Addr value = SYMBOL_ADDRESS (sym_map, sym, true) + reloc->r_addend;
if (sym != NULL
&& __builtin_expect (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC, 0)
struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
ElfW(Addr) value = 0;
if (sym_map != NULL)
- value = sym_map->l_addr + sym->st_value + reloc->r_addend;
+ value = SYMBOL_ADDRESS (sym_map, sym, true) + reloc->r_addend;
switch (r_type)
{
const Elf32_Sym *const refsym = sym;
#endif
struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
- Elf32_Addr value = sym == NULL ? 0 : sym_map->l_addr + sym->st_value;
+ Elf32_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
if (sym != NULL
&& __builtin_expect (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC, 0)
const Elf64_Sym *const refsym = sym;
#endif
struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
- Elf64_Addr value = sym == NULL ? 0 : sym_map->l_addr + sym->st_value;
+ Elf64_Addr value = SYMBOL_ADDRESS (sym_map, sym, true);
if (sym != NULL
&& __builtin_expect (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC,
const Elf32_Sym *const refsym = sym;
struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
- value = sym_map == NULL ? 0 : sym_map->l_addr + sym->st_value;
+ value = SYMBOL_ADDRESS (sym_map, sym, true);
value += reloc->r_addend;
switch (r_type)
binding found in the user program or a loaded library
rather than the dynamic linker's built-in definitions
used while loading those libraries. */
- value -= map->l_addr + refsym->st_value + reloc->r_addend;
+ value -= SYMBOL_ADDRESS (map, refsym, true) + reloc->r_addend;
#endif
COPY_UNALIGNED_WORD (&value, reloc_addr_arg,
(int) reloc_addr_arg & 3);
else
{
sym_map = RESOLVE_MAP (&sym, version, r_type);
- value = sym_map == NULL ? 0 : sym_map->l_addr + sym->st_value;
+ value = SYMBOL_ADDRESS (sym_map, sym, true);
}
#else
value = 0;
else
{
sym_map = RESOLVE_MAP (&sym, version, r_type);
- value = sym_map == NULL ? 0 : sym_map->l_addr + sym->st_value;
+ value = SYMBOL_ADDRESS (sym_map, sym, true);
}
#else
value = 0;
else if (ELFW_ST_TYPE (sym->st_info) == STT_SECTION)
value = map->l_addr; /* like a RELATIVE reloc */
else
- value = sym_map->l_addr + sym->st_value;
+ value = SYMBOL_ADDRESS (sym_map, sym, true);
if (sym != NULL
&& __builtin_expect (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC, 0)
const ElfW(Sym) *const refsym = sym;
# endif
struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
- ElfW(Addr) value = (sym == NULL ? 0
- : (ElfW(Addr)) sym_map->l_addr + sym->st_value);
+ ElfW(Addr) value = SYMBOL_ADDRESS (sym_map, sym, true);
if (sym != NULL
&& __glibc_unlikely (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC)
projects / thirdparty / glibc.git / commitdiff
