elf/do-lookup.h

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