AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-11-22 13:00:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update MIPS dl-lookup.c for changes to generic version.

Browse Source 
* sysdeps/mips/do-lookup.h: Remove.
	* sysdeps/mips/dl-lookup.c: Update from generic version, with
	non-PIC handling integrated.
This commit is contained in:
Joseph Myers 2009-07-17 20:39:04 +00:00
parent f40617927c
commit cda50f828e
3 changed files with 402 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ChangeLog.mips
View File

@ -1,3 +1,9 @@
2009-07-17 Joseph Myers <joseph@codesourcery.com>
* sysdeps/mips/do-lookup.h: Remove.
* sysdeps/mips/dl-lookup.c: Update from generic version, with
non-PIC handling integrated.
2009-06-18 Joseph Myers <joseph@codesourcery.com>
* sysdeps/unix/sysv/linux/mips/bits/socket.h: Define PF_IEEE802154

411
sysdeps/mips/dl-lookup.c
View File

@ -1,9 +1,6 @@
/* Look up a symbol in the loaded objects.
MIPS/Linux version - this is identical to the common version, but
because it is in sysdeps/mips, it gets sysdeps/mips/do-lookup.h.
Using <do-lookup.h> instead of "do-lookup.h" would work too.
Copyright (C) 1995-2005, 2006, 2007 Free Software Foundation, Inc.
MIPS/Linux version - special handling of non-PIC undefined symbol rules.
Copyright (C) 1995-2005, 2006, 2007, 2009 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
@ -73,8 +70,387 @@ struct sym_val
#endif
/* The actual lookup code. */
#include "do-lookup.h"
/* Inner part of the lookup functions. We return a value > 0 if we
found the symbol, the value 0 if nothing is found and < 0 if
something bad happened. */
static int
__attribute_noinline__
do_lookup_x (const char *undef_name, uint_fast32_t new_hash,
unsigned long int *old_hash, const ElfW(Sym) *ref,
struct sym_val *result, struct r_scope_elem *scope, size_t i,
const struct r_found_version *const version, int flags,
struct link_map *skip, int type_class, struct link_map *undef_map)
{
size_t n = scope->r_nlist;
/* Make sure we read the value before proceeding. Otherwise we
might use r_list pointing to the initial scope and r_nlist being
the value after a resize. That is the only path in dl-open.c not
protected by GSCOPE. A read barrier here might be to expensive. */
__asm volatile ("" : "+r" (n), "+m" (scope->r_list));
struct link_map **list = scope->r_list;
do
{
/* These variables are used in the nested function. */
Elf_Symndx symidx;
int num_versions = 0;
const ElfW(Sym) *versioned_sym = NULL;
const struct link_map *map = list[i]->l_real;
/* Here come the extra test needed for `_dl_lookup_symbol_skip'. */
if (map == skip)
continue;
/* Don't search the executable when resolving a copy reloc. */
if ((type_class & ELF_RTYPE_CLASS_COPY) && map->l_type == lt_executable)
continue;
/* Do not look into objects which are going to be removed. */
if (map->l_removed)
continue;
/* Print some debugging info if wanted. */
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_SYMBOLS, 0))
_dl_debug_printf ("symbol=%s; lookup in file=%s [%lu]\n",
undef_name,
map->l_name[0] ? map->l_name : rtld_progname,
map->l_ns);
/* If the hash table is empty there is nothing to do here. */
if (map->l_nbuckets == 0)
continue;
/* The tables for this map. */
const ElfW(Sym) *symtab = (const void *) D_PTR (map, l_info[DT_SYMTAB]);
const char *strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
/* Nested routine to check whether the symbol matches. */
const ElfW(Sym) *
__attribute_noinline__
check_match (const ElfW(Sym) *sym)
{
unsigned int stt = ELFW(ST_TYPE) (sym->st_info);
assert (ELF_RTYPE_CLASS_PLT == 1);
/* The semantics of zero/non-zero values of undefined symbols
differs depending on whether the non-PIC ABI is in use.
Under the non-PIC ABI, a non-zero value indicates that
there is an address reference to the symbol and thus it
must always be resolved (except when resolving a jump slot
relocation) to the PLT entry whose address is provided as
the symbol's value; a zero value indicates that this
canonical-address behaviour is not required. Yet under the
classic MIPS psABI, a zero value indicates that there is an
address reference to the function and the dynamic linker
must resolve the symbol immediately upon loading. To avoid
conflict, symbols for which the dynamic linker must assume
the non-PIC ABI semantics are marked with the STO_MIPS_PLT
flag. */
if (__builtin_expect ((sym->st_value == 0 /* No value. */
&& stt != STT_TLS)
|| (sym->st_shndx == SHN_UNDEF
&& !(sym->st_other & STO_MIPS_PLT))
|| (type_class & (sym->st_shndx == SHN_UNDEF)),
0))
return NULL;
/* Ignore all but STT_NOTYPE, STT_OBJECT, STT_FUNC,
STT_COMMON, STT_TLS, and STT_GNU_IFUNC since these are no
code/data definitions. */
#define ALLOWED_STT \
((1 << STT_NOTYPE) | (1 << STT_OBJECT) | (1 << STT_FUNC) \
| (1 << STT_COMMON) | (1 << STT_TLS) | (1 << STT_GNU_IFUNC))
if (__builtin_expect (((1 << stt) & ALLOWED_STT) == 0, 0))
return NULL;
if (sym != ref && strcmp (strtab + sym->st_name, undef_name))
/* Not the symbol we are looking for. */
return NULL;
const ElfW(Half) *verstab = map->l_versyms;
if (version != NULL)
{
if (__builtin_expect (verstab == NULL, 0))
{
/* We need a versioned symbol but haven't found any. If
this is the object which is referenced in the verneed
entry it is a bug in the library since a symbol must
not simply disappear.
It would also be a bug in the object since it means that
the list of required versions is incomplete and so the
tests in dl-version.c haven't found a problem.*/
assert (version->filename == NULL
|| ! _dl_name_match_p (version->filename, map));
/* Otherwise we accept the symbol. */
}
else
{
/* We can match the version information or use the
default one if it is not hidden. */
ElfW(Half) ndx = verstab[symidx] & 0x7fff;
if ((map->l_versions[ndx].hash != version->hash
|| strcmp (map->l_versions[ndx].name, version->name))
&& (version->hidden || map->l_versions[ndx].hash
|| (verstab[symidx] & 0x8000)))
/* It's not the version we want. */
return NULL;
}
}
else
{
/* No specific version is selected. There are two ways we
can got here:
- a binary which does not include versioning information
is loaded
- dlsym() instead of dlvsym() is used to get a symbol which
might exist in more than one form
If the library does not provide symbol version information
there is no problem at at: we simply use the symbol if it
is defined.
These two lookups need to be handled differently if the
library defines versions. In the case of the old
unversioned application the oldest (default) version
should be used. In case of a dlsym() call the latest and
public interface should be returned. */
if (verstab != NULL)
{
if ((verstab[symidx] & 0x7fff)
>= ((flags & DL_LOOKUP_RETURN_NEWEST) ? 2 : 3))
{
/* Don't accept hidden symbols. */
if ((verstab[symidx] & 0x8000) == 0
&& num_versions++ == 0)
/* No version so far. */
versioned_sym = sym;
return NULL;
}
}
}
/* There cannot be another entry for this symbol so stop here. */
return sym;
}
const ElfW(Sym) *sym;
const ElfW(Addr) *bitmask = map->l_gnu_bitmask;
if (__builtin_expect (bitmask != NULL, 1))
{
ElfW(Addr) bitmask_word
= bitmask[(new_hash / __ELF_NATIVE_CLASS)
& map->l_gnu_bitmask_idxbits];
unsigned int hashbit1 = new_hash & (__ELF_NATIVE_CLASS - 1);
unsigned int hashbit2 = ((new_hash >> map->l_gnu_shift)
& (__ELF_NATIVE_CLASS - 1));
if (__builtin_expect ((bitmask_word >> hashbit1)
& (bitmask_word >> hashbit2) & 1, 0))
{
Elf32_Word bucket = map->l_gnu_buckets[new_hash
% map->l_nbuckets];
if (bucket != 0)
{
const Elf32_Word *hasharr = &map->l_gnu_chain_zero[bucket];
do
if (((*hasharr ^ new_hash) >> 1) == 0)
{
symidx = hasharr - map->l_gnu_chain_zero;
sym = check_match (&symtab[symidx]);
if (sym != NULL)
goto found_it;
}
while ((*hasharr++ & 1u) == 0);
}
}
/* No symbol found. */
symidx = SHN_UNDEF;
}
else
{
if (*old_hash == 0xffffffff)
*old_hash = _dl_elf_hash (undef_name);
/* Use the old SysV-style hash table. Search the appropriate
hash bucket in this object's symbol table for a definition
for the same symbol name. */
for (symidx = map->l_buckets[*old_hash % map->l_nbuckets];
symidx != STN_UNDEF;
symidx = map->l_chain[symidx])
{
sym = check_match (&symtab[symidx]);
if (sym != NULL)
goto found_it;
}
}
/* If we have seen exactly one versioned symbol while we are
looking for an unversioned symbol and the version is not the
default version we still accept this symbol since there are
no possible ambiguities. */
sym = num_versions == 1 ? versioned_sym : NULL;
if (sym != NULL)
{
found_it:
switch (__builtin_expect (ELFW(ST_BIND) (sym->st_info), STB_GLOBAL))
{
case STB_WEAK:
/* Weak definition. Use this value if we don't find another. */
if (__builtin_expect (GLRO(dl_dynamic_weak), 0))
{
if (! result->s)
{
result->s = sym;
result->m = (struct link_map *) map;
}
break;
}
/* FALLTHROUGH */
case STB_GLOBAL:
success:
/* Global definition. Just what we need. */
result->s = sym;
result->m = (struct link_map *) map;
return 1;
case STB_GNU_UNIQUE:;
/* We have to determine whether we already found a
symbol with this name before. If not then we have to
add it to the search table. If we already found a
definition we have to use it. */
void enter (struct unique_sym *table, size_t size,
unsigned int hash, const char *name,
const ElfW(Sym) *sym, const struct link_map *map)
{
size_t idx = hash % size;
size_t hash2 = 1 + hash % (size - 2);
while (1)
{
if (table[idx].hashval == 0)
{
table[idx].hashval = hash;
table[idx].name = strtab + sym->st_name;
if ((type_class & ELF_RTYPE_CLASS_COPY) != 0)
{
table[idx].sym = ref;
table[idx].map = undef_map;
}
else
{
table[idx].sym = sym;
table[idx].map = map;
}
return;
}
idx += hash2;
if (idx >= size)
idx -= size;
}
}
struct unique_sym_table *tab
= &GL(dl_ns)[map->l_ns]._ns_unique_sym_table;
__rtld_lock_lock_recursive (tab->lock);
struct unique_sym *entries = tab->entries;
size_t size = tab->size;
if (entries != NULL)
{
size_t idx = new_hash % size;
size_t hash2 = 1 + new_hash % (size - 2);
while (1)
{
if (entries[idx].hashval == new_hash
&& strcmp (entries[idx].name, undef_name) == 0)
{
result->s = entries[idx].sym;
result->m = (struct link_map *) entries[idx].map;
__rtld_lock_unlock_recursive (tab->lock);
return 1;
}
if (entries[idx].hashval == 0
&& entries[idx].name == NULL)
break;
idx += hash2;
if (idx >= size)
idx -= size;
}
if (size * 3 <= tab->n_elements)
{
/* Expand the table. */
size_t newsize = _dl_higher_prime_number (size);
struct unique_sym *newentries
= calloc (sizeof (struct unique_sym), newsize);
if (newentries == NULL)
{
nomem:
__rtld_lock_unlock_recursive (tab->lock);
_dl_fatal_printf ("out of memory\n");
}
for (idx = 0; idx < size; ++idx)
if (entries[idx].hashval != 0)
enter (newentries, newsize, entries[idx].hashval,
entries[idx].name, entries[idx].sym,
entries[idx].map);
tab->free (entries);
tab->size = newsize;
entries = tab->entries = newentries;
tab->free = free;
}
}
else
{
#define INITIAL_NUNIQUE_SYM_TABLE 31
size = INITIAL_NUNIQUE_SYM_TABLE;
entries = calloc (sizeof (struct unique_sym), size);
if (entries == NULL)
goto nomem;
tab->entries = entries;
tab->size = size;
tab->free = free;
}
enter (entries, size, new_hash, strtab + sym->st_name, sym, map);
++tab->n_elements;
__rtld_lock_unlock_recursive (tab->lock);
goto success;
default:
/* Local symbols are ignored. */
break;
}
}
/* If this current map is the one mentioned in the verneed entry
and we have not found a weak entry, it is a bug. */
if (symidx == STN_UNDEF && version != NULL && version->filename != NULL
&& __builtin_expect (_dl_name_match_p (version->filename, map), 0))
return -1;
}
while (++i < n);
/* We have not found anything until now. */
return 0;
}
static uint_fast32_t
@ -341,7 +717,7 @@ _dl_lookup_symbol_x (const char *undef_name, struct link_map *undef_map,
{
int res = do_lookup_x (undef_name, new_hash, &old_hash, *ref,
&current_value, *scope, start, version, flags,
skip_map, type_class);
skip_map, type_class, undef_map);
if (res > 0)
break;
@ -414,7 +790,7 @@ _dl_lookup_symbol_x (const char *undef_name, struct link_map *undef_map,
for (scope = symbol_scope; *scope != NULL; i = 0, ++scope)
if (do_lookup_x (undef_name, new_hash, &old_hash, *ref,
&protected_value, *scope, i, version, flags,
skip_map, ELF_RTYPE_CLASS_PLT) != 0)
skip_map, ELF_RTYPE_CLASS_PLT, NULL) != 0)
break;
if (protected_value.s != NULL && protected_value.m != undef_map)
@ -540,21 +916,26 @@ _dl_debug_bindings (const char *undef_name, struct link_map *undef_map,
do_lookup_x (undef_name, new_hash, &old_hash, *ref, &val,
undef_map->l_local_scope[0], 0, version, 0, NULL,
type_class);
type_class, undef_map);
if (val.s != value->s || val.m != value->m)
conflict = 1;
}
if (value->s
&& (__builtin_expect (ELFW(ST_TYPE) (value->s->st_info)
== STT_TLS, 0)))
type_class = 4;
if (value->s)
{
if (__builtin_expect (ELFW(ST_TYPE) (value->s->st_info)
== STT_TLS, 0))
type_class = 4;
else if (__builtin_expect (ELFW(ST_TYPE) (value->s->st_info)
== STT_GNU_IFUNC, 0))
type_class |= 8;
}
if (conflict
|| GLRO(dl_trace_prelink_map) == undef_map
|| GLRO(dl_trace_prelink_map) == NULL
|| type_class == 4)
|| type_class >= 4)
{
_dl_printf ("%s 0x%0*Zx 0x%0*Zx -> 0x%0*Zx 0x%0*Zx ",
conflict ? "conflict" : "lookup",

37
sysdeps/mips/do-lookup.h
View File

@ -1,37 +0,0 @@
/* MIPS-specific veneer to GLIBC's do-lookup.h.
Copyright (C) 2008 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, write to the Free
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
/* The semantics of zero/non-zero values of undefined symbols differs
depending on whether the non-PIC ABI is in use. Under the non-PIC ABI,
a non-zero value indicates that there is an address reference to the
symbol and thus it must always be resolved (except when resolving a jump
slot relocation) to the PLT entry whose address is provided as the
symbol's value; a zero value indicates that this canonical-address
behaviour is not required. Yet under the classic MIPS psABI, a zero value
indicates that there is an address reference to the function and the
dynamic linker must resolve the symbol immediately upon loading. To
avoid conflict, symbols for which the dynamic linker must assume the
non-PIC ABI semantics are marked with the STO_MIPS_PLT flag. The
following ugly hack causes the code in the platform-independent
do-lookup.h file to check this flag correctly. */
#define st_value st_shndx == SHN_UNDEF && !(sym->st_other & STO_MIPS_PLT)) \
|| (sym->st_value
#include_next "do-lookup.h"
#undef st_value