elf/do-lookup.h

   1 /* Look up a symbol in the loaded objects.
   2    Copyright (C) 1995-2004, 2005, 2006, 2007 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20
  21 /* Inner part of the lookup functions.  We return a value > 0 if we
  22    found the symbol, the value 0 if nothing is found and < 0 if
  23    something bad happened.  */
  24 static int
  25 __attribute_noinline__
  26 do_lookup_x (const char *undef_name, uint_fast32_t new_hash,
  27              unsigned long int *old_hash, const ElfW(Sym) *ref,
  28              struct sym_val *result, struct r_scope_elem *scope, size_t i,
  29              const struct r_found_version *const version, int flags,
  30              struct link_map *skip, int type_class)
  31 {
  32   size_t n = scope->r_nlist;
  33   /* Make sure we read the value before proceeding.  Otherwise we
  34      might use r_list pointing to the initial scope and r_nlist being
  35      the value after a resize.  That is the only path in dl-open.c not
  36      protected by GSCOPE.  A read barrier here might be to expensive.  */
  37   __asm volatile ("" : "+r" (n), "+m" (scope->r_list));
  38   struct link_map **list = scope->r_list;
  39
  40   do
  41     {
  42       /* These variables are used in the nested function.  */
  43       Elf_Symndx symidx;
  44       int num_versions = 0;
  45       const ElfW(Sym) *versioned_sym = NULL;
  46
  47       const struct link_map *map = list[i]->l_real;
  48
  49       /* Here come the extra test needed for `_dl_lookup_symbol_skip'.  */
  50       if (map == skip)
  51         continue;
  52
  53       /* Don't search the executable when resolving a copy reloc.  */
  54       if ((type_class & ELF_RTYPE_CLASS_COPY) && map->l_type == lt_executable)
  55         continue;
  56
  57       /* Do not look into objects which are going to be removed.  */
  58       if (map->l_removed)
  59         continue;
  60
  61       /* Print some debugging info if wanted.  */
  62       if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_SYMBOLS, 0))
  63         _dl_debug_printf ("symbol=%s;  lookup in file=%s [%lu]\n",
  64                           undef_name,
  65                           map->l_name[0] ? map->l_name : rtld_progname,
  66                           map->l_ns);
  67
  68       /* If the hash table is empty there is nothing to do here.  */
  69       if (map->l_nbuckets == 0)
  70         continue;
  71
  72       /* The tables for this map.  */
  73       const ElfW(Sym) *symtab = (const void *) D_PTR (map, l_info[DT_SYMTAB]);
  74       const char *strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
  75
  76
  77       /* Nested routine to check whether the symbol matches.  */
  78       const ElfW(Sym) *
  79       __attribute_noinline__
  80       check_match (const ElfW(Sym) *sym)
  81       {
  82         assert (ELF_RTYPE_CLASS_PLT == 1);
  83         if (__builtin_expect ((sym->st_value == 0 /* No value.  */
  84                                && ELFW(ST_TYPE) (sym->st_info) != STT_TLS)
  85                               || (type_class & (sym->st_shndx == SHN_UNDEF)),
  86                               0))
  87           return NULL;
  88
  89         if (__builtin_expect (ELFW(ST_TYPE) (sym->st_info) > STT_FUNC
  90                               && ELFW(ST_TYPE) (sym->st_info) != STT_TLS, 0))
  91           /* Ignore all but STT_NOTYPE, STT_OBJECT and STT_FUNC
  92              entries (and STT_TLS if TLS is supported) since these
  93              are no code/data definitions.  */
  94           return NULL;
  95
  96         if (sym != ref && strcmp (strtab + sym->st_name, undef_name))
  97           /* Not the symbol we are looking for.  */
  98           return NULL;
  99
 100         const ElfW(Half) *verstab = map->l_versyms;
 101         if (version != NULL)
 102           {
 103             if (__builtin_expect (verstab == NULL, 0))
 104               {
 105                 /* We need a versioned symbol but haven't found any.  If
 106                    this is the object which is referenced in the verneed
 107                    entry it is a bug in the library since a symbol must
 108                    not simply disappear.
 109
 110                    It would also be a bug in the object since it means that
 111                    the list of required versions is incomplete and so the
 112                    tests in dl-version.c haven't found a problem.*/
 113                 assert (version->filename == NULL
 114                         || ! _dl_name_match_p (version->filename, map));
 115
 116                 /* Otherwise we accept the symbol.  */
 117               }
 118             else
 119               {
 120                 /* We can match the version information or use the
 121                    default one if it is not hidden.  */
 122                 ElfW(Half) ndx = verstab[symidx] & 0x7fff;
 123                 if ((map->l_versions[ndx].hash != version->hash
 124                      || strcmp (map->l_versions[ndx].name, version->name))
 125                     && (version->hidden || map->l_versions[ndx].hash
 126                         || (verstab[symidx] & 0x8000)))
 127                   /* It's not the version we want.  */
 128                   return NULL;
 129               }
 130           }
 131         else
 132           {
 133             /* No specific version is selected.  There are two ways we
 134                can got here:
 135
 136                - a binary which does not include versioning information
 137                is loaded
 138
 139                - dlsym() instead of dlvsym() is used to get a symbol which
 140                might exist in more than one form
 141
 142                If the library does not provide symbol version information
 143                there is no problem at at: we simply use the symbol if it
 144                is defined.
 145
 146                These two lookups need to be handled differently if the
 147                library defines versions.  In the case of the old
 148                unversioned application the oldest (default) version
 149                should be used.  In case of a dlsym() call the latest and
 150                public interface should be returned.  */
 151             if (verstab != NULL)
 152               {
 153                 if ((verstab[symidx] & 0x7fff)
 154                     >= ((flags & DL_LOOKUP_RETURN_NEWEST) ? 2 : 3))
 155                   {
 156                     /* Don't accept hidden symbols.  */
 157                     if ((verstab[symidx] & 0x8000) == 0
 158                         && num_versions++ == 0)
 159                       /* No version so far.  */
 160                       versioned_sym = sym;
 161
 162                     return NULL;
 163                   }
 164               }
 165           }
 166
 167         /* There cannot be another entry for this symbol so stop here.  */
 168         return sym;
 169       }
 170
 171       const ElfW(Sym) *sym;
 172       const ElfW(Addr) *bitmask = map->l_gnu_bitmask;
 173       if (__builtin_expect (bitmask != NULL, 1))
 174         {
 175           ElfW(Addr) bitmask_word
 176             = bitmask[(new_hash / __ELF_NATIVE_CLASS)
 177                       & map->l_gnu_bitmask_idxbits];
 178
 179           unsigned int hashbit1 = new_hash & (__ELF_NATIVE_CLASS - 1);
 180           unsigned int hashbit2 = ((new_hash >> map->l_gnu_shift)
 181                                    & (__ELF_NATIVE_CLASS - 1));
 182
 183           if (__builtin_expect ((bitmask_word >> hashbit1)
 184                                 & (bitmask_word >> hashbit2) & 1, 0))
 185             {
 186               Elf32_Word bucket = map->l_gnu_buckets[new_hash
 187                                                      % map->l_nbuckets];
 188               if (bucket != 0)
 189                 {
 190                   const Elf32_Word *hasharr = &map->l_gnu_chain_zero[bucket];
 191
 192                   do
 193                     if (((*hasharr ^ new_hash) >> 1) == 0)
 194                       {
 195                         symidx = hasharr - map->l_gnu_chain_zero;
 196                         sym = check_match (&symtab[symidx]);
 197                         if (sym != NULL)
 198                           goto found_it;
 199                       }
 200                   while ((*hasharr++ & 1u) == 0);
 201                 }
 202             }
 203           /* No symbol found.  */
 204           symidx = SHN_UNDEF;
 205         }
 206       else
 207         {
 208           if (*old_hash == 0xffffffff)
 209             *old_hash = _dl_elf_hash (undef_name);
 210
 211           /* Use the old SysV-style hash table.  Search the appropriate
 212              hash bucket in this object's symbol table for a definition
 213              for the same symbol name.  */
 214           for (symidx = map->l_buckets[*old_hash % map->l_nbuckets];
 215                symidx != STN_UNDEF;
 216                symidx = map->l_chain[symidx])
 217             {
 218               sym = check_match (&symtab[symidx]);
 219               if (sym != NULL)
 220                 goto found_it;
 221             }
 222         }
 223
 224       /* If we have seen exactly one versioned symbol while we are
 225          looking for an unversioned symbol and the version is not the
 226          default version we still accept this symbol since there are
 227          no possible ambiguities.  */
 228       sym = num_versions == 1 ? versioned_sym : NULL;
 229
 230       if (sym != NULL)
 231         {
 232         found_it:
 233           switch (ELFW(ST_BIND) (sym->st_info))
 234             {
 235             case STB_WEAK:
 236               /* Weak definition.  Use this value if we don't find another.  */
 237               if (__builtin_expect (GLRO(dl_dynamic_weak), 0))
 238                 {
 239                   if (! result->s)
 240                     {
 241                       result->s = sym;
 242                       result->m = (struct link_map *) map;
 243                     }
 244                   break;
 245                 }
 246               /* FALLTHROUGH */
 247             case STB_GLOBAL:
 248               /* Global definition.  Just what we need.  */
 249               result->s = sym;
 250               result->m = (struct link_map *) map;
 251               return 1;
 252             default:
 253               /* Local symbols are ignored.  */
 254               break;
 255             }
 256         }
 257
 258       /* If this current map is the one mentioned in the verneed entry
 259          and we have not found a weak entry, it is a bug.  */
 260       if (symidx == STN_UNDEF && version != NULL && version->filename != NULL
 261           && __builtin_expect (_dl_name_match_p (version->filename, map), 0))
 262         return -1;
 263     }
 264   while (++i < n);
 265
 266   /* We have not found anything until now.  */
 267   return 0;
 268 }