elf/do-lookup.h

   1 /* Look up a symbol in the loaded objects.
   2    Copyright (C) 1995,96,97,98,99,2000,2001,2002 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 #if VERSIONED
  21 # define FCT do_lookup_versioned
  22 # define ARG const struct r_found_version *const version,
  23 #else
  24 # define FCT do_lookup
  25 # define ARG
  26 #endif
  27
  28 /* Inner part of the lookup functions.  We return a value > 0 if we
  29    found the symbol, the value 0 if nothing is found and < 0 if
  30    something bad happened.  */
  31 static inline int
  32 FCT (const char *undef_name, unsigned long int hash, const ElfW(Sym) *ref,
  33      struct sym_val *result, struct r_scope_elem *scope, size_t i, ARG
  34      struct link_map *skip, int type_class)
  35 {
  36   struct link_map **list = scope->r_list;
  37   size_t n = scope->r_nlist;
  38   struct link_map *map;
  39
  40   do
  41     {
  42       const ElfW(Sym) *symtab;
  43       const char *strtab;
  44       const ElfW(Half) *verstab;
  45       Elf_Symndx symidx;
  46       const ElfW(Sym) *sym;
  47 #if ! VERSIONED
  48       int num_versions = 0;
  49       const ElfW(Sym) *versioned_sym = NULL;
  50 #endif
  51
  52       map = list[i];
  53
  54       /* Here come the extra test needed for `_dl_lookup_symbol_skip'.  */
  55       if (skip != NULL && map == skip)
  56         continue;
  57
  58       /* Don't search the executable when resolving a copy reloc.  */
  59       if ((type_class & ELF_RTYPE_CLASS_COPY) && map->l_type == lt_executable)
  60         continue;
  61
  62       /* Print some debugging info if wanted.  */
  63       if (__builtin_expect (GL(dl_debug_mask) & DL_DEBUG_SYMBOLS, 0))
  64         INTUSE(_dl_debug_printf) ("symbol=%s;  lookup in file=%s\n", undef_name,
  65                                   map->l_name[0] ? map->l_name : _dl_argv[0]);
  66
  67       symtab = (const void *) D_PTR (map, l_info[DT_SYMTAB]);
  68       strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
  69       verstab = map->l_versyms;
  70
  71       /* Search the appropriate hash bucket in this object's symbol table
  72          for a definition for the same symbol name.  */
  73       for (symidx = map->l_buckets[hash % map->l_nbuckets];
  74            symidx != STN_UNDEF;
  75            symidx = map->l_chain[symidx])
  76         {
  77           sym = &symtab[symidx];
  78
  79           assert (ELF_RTYPE_CLASS_PLT == 1);
  80           if ((sym->st_value == 0 /* No value.  */
  81 #ifdef USE_TLS
  82                && ELFW(ST_TYPE) (sym->st_info) != STT_TLS
  83 #endif
  84                )
  85               || (type_class & (sym->st_shndx == SHN_UNDEF)))
  86             continue;
  87
  88           if (ELFW(ST_TYPE) (sym->st_info) > STT_FUNC
  89 #ifdef USE_TLS
  90               && ELFW(ST_TYPE) (sym->st_info) != STT_TLS
  91 #endif
  92               )
  93             /* Ignore all but STT_NOTYPE, STT_OBJECT and STT_FUNC
  94                entries (and STT_TLS if TLS is supported) since these
  95                are no code/data definitions.  */
  96             continue;
  97
  98           if (sym != ref && strcmp (strtab + sym->st_name, undef_name))
  99             /* Not the symbol we are looking for.  */
 100             continue;
 101
 102 #if VERSIONED
 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                 continue;
 129             }
 130 #else
 131           /* No specific version is selected.  When the object file
 132              also does not define a version we have a match.
 133              Otherwise we accept the default version, or in case there
 134              is only one version defined, this one version.  */
 135           if (verstab != NULL)
 136             {
 137               ElfW(Half) ndx = verstab[symidx] & 0x7fff;
 138               if (ndx > 2) /* map->l_versions[ndx].hash != 0) */
 139                 {
 140                   /* Don't accept hidden symbols.  */
 141                   if ((verstab[symidx] & 0x8000) == 0 && num_versions++ == 0)
 142                     /* No version so far.  */
 143                     versioned_sym = sym;
 144                   continue;
 145                 }
 146             }
 147 #endif
 148
 149           /* There cannot be another entry for this symbol so stop here.  */
 150           goto found_it;
 151         }
 152
 153       /* If we have seen exactly one versioned symbol while we are
 154          looking for an unversioned symbol and the version is not the
 155          default version we still accept this symbol since there are
 156          no possible ambiguities.  */
 157 #if VERSIONED
 158       sym = NULL;
 159 #else
 160       sym = num_versions == 1 ? versioned_sym : NULL;
 161 #endif
 162
 163       if (sym != NULL)
 164         {
 165         found_it:
 166           switch (ELFW(ST_BIND) (sym->st_info))
 167             {
 168             case STB_WEAK:
 169               /* Weak definition.  Use this value if we don't find another.  */
 170               if (__builtin_expect (GL(dl_dynamic_weak), 0))
 171                 {
 172                   if (! result->s)
 173                     {
 174                       result->s = sym;
 175                       result->m = map;
 176                     }
 177                   break;
 178                 }
 179               /* FALLTHROUGH */
 180             case STB_GLOBAL:
 181               /* Global definition.  Just what we need.  */
 182               result->s = sym;
 183               result->m = map;
 184               return 1;
 185             default:
 186               /* Local symbols are ignored.  */
 187               break;
 188             }
 189         }
 190
 191 #if VERSIONED
 192       /* If this current map is the one mentioned in the verneed entry
 193          and we have not found a weak entry, it is a bug.  */
 194       if (symidx == STN_UNDEF && version->filename != NULL
 195           && __builtin_expect (_dl_name_match_p (version->filename, map), 0))
 196         return -1;
 197 #endif
 198     }
 199   while (++i < n);
 200
 201   /* We have not found anything until now.  */
 202   return 0;
 203 }
 204
 205 #undef FCT
 206 #undef ARG
 207 #undef VERSIONED