/* Look up a symbol in a single specified object.
   Copyright (C) 1995-2020 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, see
   <https://www.gnu.org/licenses/>.  */

#include <ldsodefs.h>
#include <string.h>
#include <elf_machine_sym_no_match.h>
#include <dl-hash.h>

/* This function corresponds to do_lookup_x in elf/dl-lookup.c.  The
   variant here is simplified because it requires symbol
   versioning.  */
static const ElfW(Sym) *
check_match (const struct link_map *const map, const char *const undef_name,
             const char *version, uint32_t version_hash,
             const Elf_Symndx symidx)
{
  const ElfW(Sym) *symtab = (const void *) D_PTR (map, l_info[DT_SYMTAB]);
  const ElfW(Sym) *sym = &symtab[symidx];

  unsigned int stt = ELFW(ST_TYPE) (sym->st_info);
  if (__glibc_unlikely ((sym->st_value == 0 /* No value.  */
                         && sym->st_shndx != SHN_ABS
                         && stt != STT_TLS)
                        || elf_machine_sym_no_match (sym)))
    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 (__glibc_unlikely (((1 << stt) & ALLOWED_STT) == 0))
    return NULL;

  const char *strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);

  if (strcmp (strtab + sym->st_name, undef_name) != 0)
    /* Not the symbol we are looking for.  */
    return NULL;

  ElfW(Half) ndx = map->l_versyms[symidx] & 0x7fff;
  if (map->l_versions[ndx].hash != version_hash
      || strcmp (map->l_versions[ndx].name, version) != 0)
    /* It's not the version we want.  */
    return NULL;

  return sym;
}


/* This function corresponds to do_lookup_x in elf/dl-lookup.c.  The
   variant here is simplified because it does not search object
   dependencies.  It is optimized for a successful lookup.  */
const ElfW(Sym) *
_dl_lookup_direct (struct link_map *map,
                   const char *undef_name, uint32_t new_hash,
                   const char *version, uint32_t version_hash)
{
  const ElfW(Addr) *bitmask = map->l_gnu_bitmask;
  if (__glibc_likely (bitmask != NULL))
    {
      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)
              {
                Elf_Symndx symidx = ELF_MACHINE_HASH_SYMIDX (map, hasharr);
                const ElfW(Sym) *sym = check_match (map, undef_name,
                                                    version, version_hash,
                                                    symidx);
                if (sym != NULL)
                  return sym;
              }
          while ((*hasharr++ & 1u) == 0);
        }
    }
  else
    {
      /* Fallback code for lack of GNU_HASH support.  */
      uint32_t 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 (Elf_Symndx symidx = map->l_buckets[old_hash % map->l_nbuckets];
           symidx != STN_UNDEF;
           symidx = map->l_chain[symidx])
        {
          const ElfW(Sym) *sym = check_match (map, undef_name,
                                              version, version_hash, symidx);
          if (sym != NULL)
            return sym;
        }
    }

  return NULL;
}