/* Compare dlvsym and __libc_dlvsym results.  Common code.
   Copyright (C) 2017 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
   <http://www.gnu.org/licenses/>.  */

/* compare_vsyms is the main entry point for these tests.

   Indirectly, It calls __libc_dlvsym (from libc.so; internal
   interface) and dlvsym (from libdl.so; public interface) to compare
   the results for a selected set of symbols in libc.so which
   typically have more than one symbol version.  The two functions are
   implemented by somewhat different code, and this test checks that
   their results are the same.

   The versions are generated to range from GLIBC_2.0 to GLIBC_2.Y,
   with Y being the current __GLIBC_MINOR__ version plus two.  In
   addition, there is a list of special symbol versions of the form
   GLIBC_2.Y.Z, which were used for some releases.

   Comparing the two dlvsym results at versions which do not actually
   exist does not test much, but it will not contribute to false test
   failures, either.  */

#include <array_length.h>
#include <gnu/lib-names.h>
#include <stdbool.h>
#include <stdio.h>
#include <support/check.h>
#include <support/xdlfcn.h>

/* Run consistency check for versioned symbol NAME@VERSION.  NB: We
   may execute in a shared object, so exit on error for proper error
   reporting.  */
static void
compare_vsyms_0 (void *libc_handle, const char *name, const char *version,
                 bool *pfound)
{
  void *dlvsym_address = dlvsym (libc_handle, name, version);
  void *libc_dlvsym_address
    = __libc_dlvsym (libc_handle, name, version);
  if (dlvsym_address != libc_dlvsym_address)
    FAIL_EXIT1 ("%s@%s mismatch: %p != %p",
                name, version, dlvsym_address, libc_dlvsym_address);
  if (dlvsym_address != NULL)
    *pfound = true;
}


/* Run consistency check for versioned symbol NAME at multiple symbol
   version.  */
static void
compare_vsyms_1 (void *libc_handle, const char *name)
{
  bool found = false;

  /* Historic versions which do not follow the usual GLIBC_2.Y
     pattern, to increase test coverage.  Not all architectures have
     those, but probing additional versions does not hurt.  */
  static const char special_versions[][12] =
    {
      "GLIBC_2.1.1",
      "GLIBC_2.1.2",
      "GLIBC_2.1.3",
      "GLIBC_2.1.4",
      "GLIBC_2.2.1",
      "GLIBC_2.2.2",
      "GLIBC_2.2.3",
      "GLIBC_2.2.4",
      "GLIBC_2.2.5",
      "GLIBC_2.2.6",
      "GLIBC_2.3.2",
      "GLIBC_2.3.3",
      "GLIBC_2.3.4",
    };
  for (int i = 0; i < array_length (special_versions); ++i)
    compare_vsyms_0 (libc_handle, name, special_versions[i], &found);

  /* Iterate to an out-of-range version, to cover some unused symbols
     as well.  */
  for (int minor_version = 0; minor_version <= __GLIBC_MINOR__ + 2;
       ++minor_version)
    {
      char version[30];
      snprintf (version, sizeof (version), "GLIBC_%d.%d",
                __GLIBC__, minor_version);
      compare_vsyms_0 (libc_handle, name, version, &found);
    }

  if (!found)
    FAIL_EXIT1 ("symbol %s not found at any version", name);
}

/* Run consistency checks for various symbols which usually have
   multiple versions.  */
static void
compare_vsyms (void)
{
  /* The minor version loop in compare_vsyms_1 needs updating in case
     we ever switch to glibc 3.0.  */
  if (__GLIBC__ != 2)
    FAIL_EXIT1 ("unexpected glibc major version: %d", __GLIBC__);

  /* __libc_dlvsym does not recognize the special RTLD_* handles, so
     obtain an explicit handle for libc.so.  */
  void *libc_handle = xdlopen (LIBC_SO, RTLD_LAZY | RTLD_NOLOAD);

  compare_vsyms_1 (libc_handle, "_sys_errlist");
  compare_vsyms_1 (libc_handle, "_sys_siglist");
  compare_vsyms_1 (libc_handle, "quick_exit");

  xdlclose (libc_handle);
}