libc_mapping.cc

#include "libc_mapping.h"
#include "raw_write.h"

#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

#include <aliases.h>
#include <argp.h>
#include <argz.h>
#include <arpa/inet.h>
#include <arpa/nameser.h>
#include <asm/prctl.h>
#include <ctype.h>
#include <dirent.h>
#include <dlfcn.h>
#include <elf.h>
#include <err.h>
#include <errno.h>
#include <error.h>
#include <execinfo.h>
#include <fcntl.h>
#include <fnmatch.h>
#include <fts.h>
#include <ftw.h>
#include <getopt.h>
#include <glob.h>
#include <gnu/libc-version.h>
#include <grp.h>
#include <gshadow.h>
#include <iconv.h>
#include <ifaddrs.h>
#include <langinfo.h>
#include <libgen.h>
#include <libintl.h>
#include <link.h>
#include <malloc.h>
#include <math.h>
#include <mcheck.h>
#include <mntent.h>
#include <mqueue.h>
#include <net/if.h>
#include <netdb.h>
#include <netinet/ether.h>
#include <netinet/in.h>
#include <obstack.h>
#include <poll.h>
#include <printf.h>
#include <pthread.h>
#include <pty.h>
#include <pwd.h>
#include <regex.h>
#include <resolv.h>
#include <sched.h>
#include <search.h>
#include <semaphore.h>
#include <setjmp.h>
#include <shadow.h>
#include <signal.h>
#include <spawn.h>
#include <stdio.h>
#include <stdio_ext.h>
#include <stdlib.h>
#include <string.h>
#include <sys/auxv.h>
#include <sys/capability.h>
#include <sys/epoll.h>
#include <sys/eventfd.h>
#include <sys/file.h>
#include <sys/fsuid.h>
#include <sys/inotify.h>
#include <sys/io.h>
#include <sys/ioctl.h>
#include <sys/ipc.h>
#include <sys/klog.h>
#include <sys/mman.h>
#include <sys/mount.h>
#include <sys/msg.h>
#include <sys/personality.h>
#include <sys/prctl.h>
#include <sys/ptrace.h>
#include <sys/random.h>
#include <sys/resource.h>
#include <sys/sem.h>
#include <sys/sendfile.h>
#include <sys/shm.h>
#include <sys/signalfd.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
#include <sys/syscall.h>
#include <sys/sysinfo.h>
#include <sys/sysmacros.h>
#include <sys/time.h>
#include <sys/timerfd.h>
#include <sys/times.h>
#include <sys/timex.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <sys/utsname.h>
#include <sys/vfs.h>
#include <sys/wait.h>
#include <sys/xattr.h>
#include <syslog.h>
#include <termios.h>
#include <ttyent.h>
#include <ucontext.h>
#include <unistd.h>
#include <utime.h>
#include <utmp.h>
#include <utmpx.h>
#include <wchar.h>
#include <wctype.h>
#include <cinttypes>
#include <cstring>
#include <ctime>

#include "sloader_dl.h"
#include "dyn_loader.h"

extern thread_local unsigned long sloader_dummy_to_secure_tls_space[];
extern unsigned long sloader_tls_offset;

// Copy from libc
extern __thread struct __res_state* __resp;

namespace libc_mapping {

const char* (*strchr_c)(const char*, int) = strchr;
const char* (*strrchr_c)(const char*, int) = strrchr;
const void* (*rawmemchr_c)(const void*, int) = rawmemchr;
const wchar_t* (*wmemchr_c)(const wchar_t*, wchar_t, size_t) = wmemchr;
const void* (*memchr_c)(const void*, int, size_t) = memchr;
const char* (*strstr_c)(const char*, const char*) = strstr;
const char* (*strpbrk_c)(const char*, const char*) = strpbrk;
double (*frexp_c)(double, int*) = frexp;
double (*ldexp_c)(double, int) = ldexp;
const char* (*strchrnul_c)(const char*, int) = strchrnul;
const char* (*strcasestr_c)(const char* haystack, const char* needle) = strcasestr;
double (*modf_c)(double x, double* iptr) = modf;
const char* (*rindex_c)(const char* s, int c) = rindex;
const wchar_t* (*wcsstr_c)(const wchar_t* dest, const wchar_t* src) = wcsstr;
const wchar_t* (*wcspbrk_c)(const wchar_t* wcs1, const wchar_t* wcs2) = wcspbrk;

// TODO: I don't know why these functions need dummy definition not casts of function pointers.
// const wchar_t* (*wcschr_c)(const wchar_t* string, wchar_t character) = wcschr;
const wchar_t* wcschr_c(const wchar_t* string, wchar_t character) {
    // printf("wcschr_c: string=%p wc=%d\n", string, character);
    return wcschr(string, character);
}

// const wchar_t* (*wcsrchr_c)(const wchar_t *wcs, wchar_t wc) = wcsrchr;
const wchar_t* wcsrchr_c(const wchar_t* wcs, wchar_t wc) {
    // printf("wcsrchr_c: wcs=%p wc=%d\n", wcs, wc);
    return wcsrchr(wcs, wc);
}

// const void* (*memrchr_c)(const void*, int, size_t) = memrchr;
const void* memrchr_c(const void* s, int c, size_t n) {
    // printf("memrchr_c: s=%p c=%d n=%zu\n", s, c, n);
    return memchr(s, c, n);
}

int sloader_register_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void), void* dso_handle) {
    return pthread_atfork(prepare, parent, child);
}

typedef struct {
    unsigned long int ti_module;
    unsigned long int ti_offset;
} tls_index;

void* sloader_tls_get_addr(tls_index* ti) {
    return reinterpret_cast<void*>(reinterpret_cast<char*>(sloader_dummy_to_secure_tls_space) + sloader_tls_offset + ti->ti_offset);
}

void sloader_libc_start_main(int (*main)(int, char**, char**), int argc, char** argv, void (*init)(void), void (*fini)(void),
                             void (*rtld_fini)(void), void* stack_end) {
    // Although glibc write this function in assembly, we can use a plain C function?
    // https://github.com/akawashiro/glibc/blob/0005e54f762b2ec65cee2c4ecf1e9d42612030f0/sysdeps/x86_64/start.S#L64-L76
    // TODO
    // After SYS_arch_prctl, we cannot use glog.
    // LOG(INFO) << LOG_BITS(main);
    // We need __libc_stack_end
   
    // TODO: Passing __environ to main is not correct.
    myExit(main(argc, argv, __environ));
}

int sloader_fclose (FILE *__stream){
    if (__stream == stdout || __stream == stdin || __stream == stderr) {
        return 0;
    }
    return fclose(__stream);
}

#define DEFINE_DUMMY_FUN(name) \
    void sloader_##name() {    \
        ;                      \
    }
// #define DEFINE_DUMMY_FUN(name) void sloader_##name(){ RAW_PRINT_STR(#name); }

DEFINE_DUMMY_FUN(ZSTD_trace_compress_begin)
DEFINE_DUMMY_FUN(ZSTD_trace_compress_end)
DEFINE_DUMMY_FUN(ZSTD_trace_decompress_begin)
DEFINE_DUMMY_FUN(ZSTD_trace_decompress_end)
DEFINE_DUMMY_FUN(_ITM_deregisterTMCloneTable)
DEFINE_DUMMY_FUN(_ITM_registerTMCloneTable)
DEFINE_DUMMY_FUN(__asprintf_chk)
DEFINE_DUMMY_FUN(__assert_fail)
DEFINE_DUMMY_FUN(__cxa_finalize)
DEFINE_DUMMY_FUN(__gmon_start__)
DEFINE_DUMMY_FUN(__gmtime_r)
DEFINE_DUMMY_FUN(__libc_dn_expand)
DEFINE_DUMMY_FUN(__libc_ns_makecanon)
DEFINE_DUMMY_FUN(__libc_ns_samename)
DEFINE_DUMMY_FUN(__libc_res_nameinquery)
DEFINE_DUMMY_FUN(__libc_res_queriesmatch)
DEFINE_DUMMY_FUN(__stack_chk_fail)
DEFINE_DUMMY_FUN(__xpg_strerror_r)
DEFINE_DUMMY_FUN(__xstat)
DEFINE_DUMMY_FUN(atexit)
DEFINE_DUMMY_FUN(__cxa_atexit)
DEFINE_DUMMY_FUN(_nl_msg_cat_cntr)
DEFINE_DUMMY_FUN(__fxstat)
DEFINE_DUMMY_FUN(__strtold_nan)
DEFINE_DUMMY_FUN(__strtod_nan)
DEFINE_DUMMY_FUN(__strtof128_nan)
DEFINE_DUMMY_FUN(__strtof_nan)
DEFINE_DUMMY_FUN(_rtld_global_ro)
DEFINE_DUMMY_FUN(__cxa_thread_atexit_impl)
DEFINE_DUMMY_FUN(delete_module)
DEFINE_DUMMY_FUN(init_module)
DEFINE_DUMMY_FUN(__libc_dynarray_resize)
DEFINE_DUMMY_FUN(_libc_intl_domainname)
DEFINE_DUMMY_FUN(__nss_configure_lookup)
DEFINE_DUMMY_FUN(__progname_full)
DEFINE_DUMMY_FUN(__progname)
DEFINE_DUMMY_FUN(__res_context_hostalias)
DEFINE_DUMMY_FUN(__res_context_query)
DEFINE_DUMMY_FUN(__res_context_search)
DEFINE_DUMMY_FUN(__resolv_context_get_override)
DEFINE_DUMMY_FUN(__resolv_context_get)
DEFINE_DUMMY_FUN(__resolv_context_put)
DEFINE_DUMMY_FUN(__res_get_nsaddr)
DEFINE_DUMMY_FUN(__res_iclose)

std::map<std::string, const char*> sloader_libc_tls_variables = {
    {"errno", reinterpret_cast<const char*>(&errno)},
    {"__h_errno", reinterpret_cast<const char*>(&h_errno)},
    {"__resp", reinterpret_cast<const char*>(&_res)},
};

int sloader_atexit_always_success(void (*function)(void)) {
    return 0;
}

std::map<std::string, Elf64_Addr> sloader_libc_map = {
    // sloader dummy functions
    {"ZSTD_trace_compress_begin", reinterpret_cast<Elf64_Addr>(&sloader_ZSTD_trace_compress_begin)},
    {"ZSTD_trace_compress_end", reinterpret_cast<Elf64_Addr>(&sloader_ZSTD_trace_compress_end)},
    {"ZSTD_trace_decompress_begin", reinterpret_cast<Elf64_Addr>(&sloader_ZSTD_trace_decompress_begin)},
    {"ZSTD_trace_decompress_end", reinterpret_cast<Elf64_Addr>(&sloader_ZSTD_trace_decompress_end)},
    {"_ITM_deregisterTMCloneTable", reinterpret_cast<Elf64_Addr>(&sloader__ITM_deregisterTMCloneTable)},
    {"_ITM_registerTMCloneTable", reinterpret_cast<Elf64_Addr>(&sloader__ITM_registerTMCloneTable)},
    {"__asprintf_chk", reinterpret_cast<Elf64_Addr>(&sloader___asprintf_chk)},
    {"__assert_fail", reinterpret_cast<Elf64_Addr>(&sloader___assert_fail)},
    {"__cxa_atexit", reinterpret_cast<Elf64_Addr>(&sloader_atexit_always_success)},
    {"__cxa_finalize", reinterpret_cast<Elf64_Addr>(&sloader___cxa_finalize)},
    {"__cxa_thread_atexit_impl", reinterpret_cast<Elf64_Addr>(&sloader___cxa_thread_atexit_impl)},
    {"__fxstat", reinterpret_cast<Elf64_Addr>(&sloader___fxstat)},
    {"__gmon_start__", reinterpret_cast<Elf64_Addr>(&sloader___gmon_start__)},
    {"__gmtime_r", reinterpret_cast<Elf64_Addr>(&sloader___gmtime_r)},
    {"__libc_dn_expand", reinterpret_cast<Elf64_Addr>(&sloader___libc_dn_expand)},
    {"__libc_dynarray_resize", reinterpret_cast<Elf64_Addr>(&sloader___libc_dynarray_resize)},
    {"__libc_ns_makecanon", reinterpret_cast<Elf64_Addr>(&sloader___libc_ns_makecanon)},
    {"__libc_ns_samename", reinterpret_cast<Elf64_Addr>(&sloader___libc_ns_samename)},
    {"__libc_res_nameinquery", reinterpret_cast<Elf64_Addr>(&sloader___libc_res_nameinquery)},
    {"__libc_res_queriesmatch", reinterpret_cast<Elf64_Addr>(&sloader___libc_res_queriesmatch)},
    {"__nss_configure_lookup", reinterpret_cast<Elf64_Addr>(&sloader___nss_configure_lookup)},
    {"__progname", reinterpret_cast<Elf64_Addr>(&sloader___progname)},
    {"__progname_full", reinterpret_cast<Elf64_Addr>(&sloader___progname_full)},
    {"__res_context_hostalias", reinterpret_cast<Elf64_Addr>(&sloader___res_context_hostalias)},
    {"__res_context_query", reinterpret_cast<Elf64_Addr>(&sloader___res_context_query)},
    {"__res_context_search", reinterpret_cast<Elf64_Addr>(&sloader___res_context_search)},
    {"__res_get_nsaddr", reinterpret_cast<Elf64_Addr>(&sloader___res_get_nsaddr)},
    {"__res_iclose", reinterpret_cast<Elf64_Addr>(&sloader___res_iclose)},
    {"__resolv_context_get", reinterpret_cast<Elf64_Addr>(&sloader___resolv_context_get)},
    {"__resolv_context_get_override", reinterpret_cast<Elf64_Addr>(&sloader___resolv_context_get_override)},
    {"__resolv_context_put", reinterpret_cast<Elf64_Addr>(&sloader___resolv_context_put)},
    {"__stack_chk_fail", reinterpret_cast<Elf64_Addr>(&sloader___stack_chk_fail)},
    {"__strtod_nan", reinterpret_cast<Elf64_Addr>(&sloader___strtod_nan)},
    {"__strtof128_nan", reinterpret_cast<Elf64_Addr>(&sloader___strtof128_nan)},
    {"__strtof_nan", reinterpret_cast<Elf64_Addr>(&sloader___strtof_nan)},
    {"__strtold_nan", reinterpret_cast<Elf64_Addr>(&sloader___strtold_nan)},
    {"__xpg_strerror_r", reinterpret_cast<Elf64_Addr>(&sloader___xpg_strerror_r)},
    {"__xstat", reinterpret_cast<Elf64_Addr>(&sloader___xstat)},
    {"_libc_intl_domainname", reinterpret_cast<Elf64_Addr>(&sloader__libc_intl_domainname)},
    {"_nl_msg_cat_cntr", reinterpret_cast<Elf64_Addr>(&sloader__nl_msg_cat_cntr)},
    {"_rtld_global_ro", reinterpret_cast<Elf64_Addr>(&sloader__rtld_global_ro)},
    {"atexit", reinterpret_cast<Elf64_Addr>(&sloader_atexit)},
    {"delete_module", reinterpret_cast<Elf64_Addr>(&sloader_delete_module)},
    {"init_module", reinterpret_cast<Elf64_Addr>(&sloader_init_module)},

    // sloader original functions
    {"__libc_start_main", reinterpret_cast<Elf64_Addr>(&sloader_libc_start_main)},
    {"__register_atfork", reinterpret_cast<Elf64_Addr>(&sloader_register_atfork)},
    {"__tls_get_addr", reinterpret_cast<Elf64_Addr>(&sloader_tls_get_addr)},

    // libc functions
    {"__ctype_b_loc", reinterpret_cast<Elf64_Addr>(&__ctype_b_loc)},
    {"__ctype_get_mb_cur_max", reinterpret_cast<Elf64_Addr>(&__ctype_get_mb_cur_max)},
    {"__ctype_tolower_loc", reinterpret_cast<Elf64_Addr>(&__ctype_tolower_loc)},
    {"__ctype_toupper_loc", reinterpret_cast<Elf64_Addr>(&__ctype_toupper_loc)},
    {"__dcgettext", reinterpret_cast<Elf64_Addr>(&__dcgettext)},
    {"__dprintf_chk", reinterpret_cast<Elf64_Addr>(&__dprintf_chk)},
    {"__duplocale", reinterpret_cast<Elf64_Addr>(&duplocale)},
    {"__environ", reinterpret_cast<Elf64_Addr>(&__environ)},
    {"__errno_location", reinterpret_cast<Elf64_Addr>(&__errno_location)},
    {"__explicit_bzero_chk", reinterpret_cast<Elf64_Addr>(&__explicit_bzero_chk)},
    {"__fdelt_chk", reinterpret_cast<Elf64_Addr>(&__fdelt_chk)},
    {"__fgets_chk", reinterpret_cast<Elf64_Addr>(&__fgets_chk)},
    {"__fgets_unlocked_chk", reinterpret_cast<Elf64_Addr>(&__fgets_unlocked_chk)},
    {"__fgetws_chk", reinterpret_cast<Elf64_Addr>(&__fgetws_chk)},
    {"__fpending", reinterpret_cast<Elf64_Addr>(&__fpending)},
    {"__fprintf_chk", reinterpret_cast<Elf64_Addr>(&__fprintf_chk)},
    {"__fpurge", reinterpret_cast<Elf64_Addr>(&__fpurge)},
    {"__fread_chk", reinterpret_cast<Elf64_Addr>(&__fread_chk)},
    {"__fread_unlocked_chk", reinterpret_cast<Elf64_Addr>(&__fread_unlocked_chk)},
    {"__freading", reinterpret_cast<Elf64_Addr>(&__freading)},
    {"__freelocale", reinterpret_cast<Elf64_Addr>(&freelocale)},
    {"__fsetlocking", reinterpret_cast<Elf64_Addr>(&__fsetlocking)},
    {"__fwriting", reinterpret_cast<Elf64_Addr>(&__fwriting)},
    {"__getdelim", reinterpret_cast<Elf64_Addr>(&__getdelim)},
    {"__getgroups_chk", reinterpret_cast<Elf64_Addr>(&__getgroups_chk)},
    {"__gethostname_chk", reinterpret_cast<Elf64_Addr>(&__gethostname_chk)},
    {"__getpagesize", reinterpret_cast<Elf64_Addr>(&__getpagesize)},
    {"__h_errno_location", reinterpret_cast<Elf64_Addr>(&__h_errno_location)},
    {"__isoc99_fscanf", reinterpret_cast<Elf64_Addr>(&fscanf)},
    {"__isoc99_scanf", reinterpret_cast<Elf64_Addr>(&scanf)},
    {"__isoc99_sscanf", reinterpret_cast<Elf64_Addr>(&sscanf)},  // TODO
    {"__isoc99_vfscanf", reinterpret_cast<Elf64_Addr>(&vfscanf)},
    {"__isoc99_vsscanf", reinterpret_cast<Elf64_Addr>(&vsscanf)},
    {"__iswctype_l", reinterpret_cast<Elf64_Addr>(&iswctype_l)},
    {"__libc_current_sigrtmax", reinterpret_cast<Elf64_Addr>(&__libc_current_sigrtmax)},
    {"__libc_current_sigrtmin", reinterpret_cast<Elf64_Addr>(&__libc_current_sigrtmin)},
    {"__libc_current_sigrtmin", reinterpret_cast<Elf64_Addr>(&__libc_current_sigrtmin)},
    {"__libc_single_threaded", reinterpret_cast<Elf64_Addr>(&__libc_single_threaded)},
    {"__longjmp_chk", reinterpret_cast<Elf64_Addr>(&longjmp)},
    {"__mbrlen", reinterpret_cast<Elf64_Addr>(&__mbrlen)},
    {"__mbsnrtowcs_chk", reinterpret_cast<Elf64_Addr>(&__mbsnrtowcs_chk)},
    {"__mbsrtowcs_chk", reinterpret_cast<Elf64_Addr>(&__mbsrtowcs_chk)},
    {"__mbstowcs_chk", reinterpret_cast<Elf64_Addr>(&__mbstowcs_chk)},
    {"__memcpy_chk", reinterpret_cast<Elf64_Addr>(&memcpy)},
    {"__memmove_chk", reinterpret_cast<Elf64_Addr>(&memmove)},
    {"__mempcpy", reinterpret_cast<Elf64_Addr>(&__mempcpy)},
    {"__mempcpy_chk", reinterpret_cast<Elf64_Addr>(&mempcpy)},
    {"__memset_chk", reinterpret_cast<Elf64_Addr>(&memset)},
    {"__newlocale", reinterpret_cast<Elf64_Addr>(&newlocale)},
    {"__nl_langinfo_l", reinterpret_cast<Elf64_Addr>(&nl_langinfo_l)},
    {"__open64_2", reinterpret_cast<Elf64_Addr>(&__open64_2)},
    {"__open_2", reinterpret_cast<Elf64_Addr>(&__open_2)},
    {"__openat64_2", reinterpret_cast<Elf64_Addr>(&__openat64_2)},
    {"__openat_2", reinterpret_cast<Elf64_Addr>(&__openat_2)},
    {"__overflow", reinterpret_cast<Elf64_Addr>(&__overflow)},
    {"__poll_chk", reinterpret_cast<Elf64_Addr>(&__poll_chk)},
    {"__ppoll_chk", reinterpret_cast<Elf64_Addr>(&__ppoll_chk)},
    {"__pread64_chk", reinterpret_cast<Elf64_Addr>(&__pread64_chk)},
    {"__pread_chk", reinterpret_cast<Elf64_Addr>(&__pread_chk)},
    {"__printf_chk", reinterpret_cast<Elf64_Addr>(&__printf_chk)},
    {"__rawmemchr", reinterpret_cast<Elf64_Addr>(&rawmemchr_c)},
    {"__read_chk", reinterpret_cast<Elf64_Addr>(&__read_chk)},
    {"__realpath_chk", reinterpret_cast<Elf64_Addr>(&__realpath_chk)},
    {"__res_init", reinterpret_cast<Elf64_Addr>(&__res_init)},
    {"__res_nclose", reinterpret_cast<Elf64_Addr>(&__res_nclose)},
    {"__res_ninit", reinterpret_cast<Elf64_Addr>(&__res_ninit)},
    {"__resp", reinterpret_cast<Elf64_Addr>(&__resp)},
    {"__sched_cpualloc", reinterpret_cast<Elf64_Addr>(&__sched_cpualloc)},
    {"__sched_cpucount", reinterpret_cast<Elf64_Addr>(&__sched_cpucount)},
    {"__sched_cpufree", reinterpret_cast<Elf64_Addr>(&__sched_cpufree)},
    {"__sigsetjmp", reinterpret_cast<Elf64_Addr>(&__sigsetjmp)},
    {"__snprintf_chk", reinterpret_cast<Elf64_Addr>(&__snprintf_chk)},
    {"__sprintf_chk", reinterpret_cast<Elf64_Addr>(&__sprintf_chk)},
    {"__stpcpy", reinterpret_cast<Elf64_Addr>(&__stpcpy)},
    {"__stpcpy_chk", reinterpret_cast<Elf64_Addr>(&stpcpy)},
    {"__strcat_chk", reinterpret_cast<Elf64_Addr>(&strcat)},
    {"__strcoll_l", reinterpret_cast<Elf64_Addr>(&strcoll_l)},
    {"__strcpy_chk", reinterpret_cast<Elf64_Addr>(&strcpy)},
    {"__strftime_l", reinterpret_cast<Elf64_Addr>(&strftime_l)},
    {"__strncat_chk", reinterpret_cast<Elf64_Addr>(&strncat)},
    {"__strncpy_chk", reinterpret_cast<Elf64_Addr>(&strncpy)},
    {"__strtod_l", reinterpret_cast<Elf64_Addr>(&strtod_l)},
    {"__strtof_l", reinterpret_cast<Elf64_Addr>(&strtof_l)},
    {"__strxfrm_l", reinterpret_cast<Elf64_Addr>(&strxfrm_l)},
    {"__sysconf", reinterpret_cast<Elf64_Addr>(&__sysconf)},
    {"__syslog_chk", reinterpret_cast<Elf64_Addr>(&__syslog_chk)},
    {"__sysv_signal", reinterpret_cast<Elf64_Addr>(&__sysv_signal)},
    {"__timezone", reinterpret_cast<Elf64_Addr>(&__timezone)},
    {"__towlower_l", reinterpret_cast<Elf64_Addr>(&towlower_l)},
    {"__towupper_l", reinterpret_cast<Elf64_Addr>(&towupper_l)},
    {"__uflow", reinterpret_cast<Elf64_Addr>(&__uflow)},
    {"__uselocale", reinterpret_cast<Elf64_Addr>(&__gnu_cxx::__uselocale)},
    {"__vasprintf_chk", reinterpret_cast<Elf64_Addr>(&__vasprintf_chk)},
    {"__vfprintf_chk", reinterpret_cast<Elf64_Addr>(&__vfprintf_chk)},
    {"__vsnprintf_chk", reinterpret_cast<Elf64_Addr>(&__vsnprintf_chk)},
    {"__vsprintf_chk", reinterpret_cast<Elf64_Addr>(&__vsprintf_chk)},
    {"__vsyslog_chk", reinterpret_cast<Elf64_Addr>(&__vsyslog_chk)},
    {"__wcscoll_l", reinterpret_cast<Elf64_Addr>(&wcscoll_l)},
    {"__wcsftime_l", reinterpret_cast<Elf64_Addr>(&wcsftime_l)},
    {"__wcsncpy_chk", reinterpret_cast<Elf64_Addr>(&__wcsncpy_chk)},
    {"__wcsxfrm_l", reinterpret_cast<Elf64_Addr>(&wcsxfrm_l)},
    {"__wctomb_chk", reinterpret_cast<Elf64_Addr>(&__wctomb_chk)},
    {"__wctype_l", reinterpret_cast<Elf64_Addr>(&wctype_l)},
    {"__wmemcpy_chk", reinterpret_cast<Elf64_Addr>(&__wmemcpy_chk)},
    {"__wmemmove_chk", reinterpret_cast<Elf64_Addr>(&__wmemmove_chk)},
    {"__wmemset_chk", reinterpret_cast<Elf64_Addr>(&__wmemset_chk)},
    {"__xpg_basename", reinterpret_cast<Elf64_Addr>(&__xpg_basename)},
    {"_dl_find_object", reinterpret_cast<Elf64_Addr>(&_dl_find_object)},
    {"_exit", reinterpret_cast<Elf64_Addr>(&_exit)},
    {"_longjmp", reinterpret_cast<Elf64_Addr>(&_longjmp)},
    {"_obstack_begin", reinterpret_cast<Elf64_Addr>(&_obstack_begin)},
    {"_obstack_newchunk", reinterpret_cast<Elf64_Addr>(&_obstack_newchunk)},
    {"_obstack_free", reinterpret_cast<Elf64_Addr>(&obstack_free)},
    {"_setjmp", reinterpret_cast<Elf64_Addr>(&_setjmp)},
    {"abort", reinterpret_cast<Elf64_Addr>(&abort)},
    {"accept", reinterpret_cast<Elf64_Addr>(&accept)},
    {"accept4", reinterpret_cast<Elf64_Addr>(&accept4)},
    {"access", reinterpret_cast<Elf64_Addr>(&access)},
    {"access", reinterpret_cast<Elf64_Addr>(&access)},
    {"alarm", reinterpret_cast<Elf64_Addr>(&alarm)},
    {"aligned_alloc", reinterpret_cast<Elf64_Addr>(&aligned_alloc)},
    {"alphasort", reinterpret_cast<Elf64_Addr>(&alphasort)},
    {"alphasort64", reinterpret_cast<Elf64_Addr>(&alphasort64)},
    {"argp_err_exit_status", reinterpret_cast<Elf64_Addr>(&argp_err_exit_status)},
    {"argp_help", reinterpret_cast<Elf64_Addr>(&argp_help)},
    {"argp_parse", reinterpret_cast<Elf64_Addr>(&argp_parse)},
    {"argz_create_sep", reinterpret_cast<Elf64_Addr>(&argz_create_sep)},
    {"asctime", reinterpret_cast<Elf64_Addr>(&asctime)},
    {"asctime_r", reinterpret_cast<Elf64_Addr>(&asctime_r)},
    {"asprintf", reinterpret_cast<Elf64_Addr>(&asprintf)},
    {"atof", reinterpret_cast<Elf64_Addr>(&atof)},
    {"atoi", reinterpret_cast<Elf64_Addr>(&atoi)},
    {"atol", reinterpret_cast<Elf64_Addr>(&atol)},
    {"atoll", reinterpret_cast<Elf64_Addr>(&atoll)},
    {"backtrace", reinterpret_cast<Elf64_Addr>(&backtrace)},
    {"backtrace_symbols", reinterpret_cast<Elf64_Addr>(&backtrace_symbols)},
    {"backtrace_symbols_fd", reinterpret_cast<Elf64_Addr>(&backtrace_symbols_fd)},
    {"basename", reinterpret_cast<Elf64_Addr>(&basename)},
    {"bind", reinterpret_cast<Elf64_Addr>(&bind)},
    {"bind_textdomain_codeset", reinterpret_cast<Elf64_Addr>(&bind_textdomain_codeset)},
    {"bindtextdomain", reinterpret_cast<Elf64_Addr>(&bindtextdomain)},
    {"bsearch", reinterpret_cast<Elf64_Addr>(&bsearch)},
    {"bsearch", reinterpret_cast<Elf64_Addr>(&bsearch)},
    {"bsearch", reinterpret_cast<Elf64_Addr>(&bsearch)},
    {"bsearch", reinterpret_cast<Elf64_Addr>(&bsearch)},
    {"bsearch", reinterpret_cast<Elf64_Addr>(&bsearch)},
    {"btowc", reinterpret_cast<Elf64_Addr>(&btowc)},
    {"calloc", reinterpret_cast<Elf64_Addr>(&calloc)},
    {"canonicalize_file_name", reinterpret_cast<Elf64_Addr>(&canonicalize_file_name)},
    {"capget", reinterpret_cast<Elf64_Addr>(&capget)},
    {"capset", reinterpret_cast<Elf64_Addr>(&capset)},
    {"cfgetispeed", reinterpret_cast<Elf64_Addr>(&cfgetispeed)},
    {"cfgetospeed", reinterpret_cast<Elf64_Addr>(&cfgetospeed)},
    {"cfmakeraw", reinterpret_cast<Elf64_Addr>(&cfmakeraw)},
    {"cfsetispeed", reinterpret_cast<Elf64_Addr>(&cfsetispeed)},
    {"cfsetospeed", reinterpret_cast<Elf64_Addr>(&cfsetospeed)},
    {"cfsetspeed", reinterpret_cast<Elf64_Addr>(&cfsetspeed)},
    {"chdir", reinterpret_cast<Elf64_Addr>(&chdir)},
    {"chmod", reinterpret_cast<Elf64_Addr>(&chmod)},
    {"chown", reinterpret_cast<Elf64_Addr>(&chown)},
    {"chroot", reinterpret_cast<Elf64_Addr>(&chroot)},
    {"clearenv", reinterpret_cast<Elf64_Addr>(&clearenv)},
    {"clearerr", reinterpret_cast<Elf64_Addr>(&clearerr)},
    {"clearerr_unlocked", reinterpret_cast<Elf64_Addr>(&clearerr_unlocked)},
    {"clock", reinterpret_cast<Elf64_Addr>(&clock)},
    {"clock_getres", reinterpret_cast<Elf64_Addr>(&clock_getres)},
    {"clock_gettime", reinterpret_cast<Elf64_Addr>(&clock_gettime)},
    {"clock_settime", reinterpret_cast<Elf64_Addr>(&clock_settime)},
    {"clone", reinterpret_cast<Elf64_Addr>(&clone)},
    {"close", reinterpret_cast<Elf64_Addr>(&close)},
    {"close_range", reinterpret_cast<Elf64_Addr>(&close_range)},
    {"closedir", reinterpret_cast<Elf64_Addr>(&closedir)},
    {"closefrom", reinterpret_cast<Elf64_Addr>(&closefrom)},
    {"closelog", reinterpret_cast<Elf64_Addr>(&closelog)},
    {"confstr", reinterpret_cast<Elf64_Addr>(&confstr)},
    {"connect", reinterpret_cast<Elf64_Addr>(&connect)},
    {"copy_file_range", reinterpret_cast<Elf64_Addr>(&copy_file_range)},
    {"creat", reinterpret_cast<Elf64_Addr>(&creat)},
    {"creat64", reinterpret_cast<Elf64_Addr>(&creat64)},
    {"ctermid", reinterpret_cast<Elf64_Addr>(&ctermid)},
    {"ctime", reinterpret_cast<Elf64_Addr>(&ctime)},
    {"ctime_r", reinterpret_cast<Elf64_Addr>(&ctime_r)},
    {"daemon", reinterpret_cast<Elf64_Addr>(&daemon)},
    {"dcgettext", reinterpret_cast<Elf64_Addr>(&dcgettext)},
    {"dcngettext", reinterpret_cast<Elf64_Addr>(&dcngettext)},
    {"dgettext", reinterpret_cast<Elf64_Addr>(&dgettext)},
    {"difftime", reinterpret_cast<Elf64_Addr>(&difftime)},
    {"dirfd", reinterpret_cast<Elf64_Addr>(&dirfd)},
    {"dirname", reinterpret_cast<Elf64_Addr>(&dirname)},
    {"dl_iterate_phdr", reinterpret_cast<Elf64_Addr>(&dl_iterate_phdr)},
    {"dladdr", reinterpret_cast<Elf64_Addr>(&sloader_dladdr)},
    {"dlclose", reinterpret_cast<Elf64_Addr>(&dlclose)},
    {"dlerror", reinterpret_cast<Elf64_Addr>(&dlerror)},
    {"dlopen", reinterpret_cast<Elf64_Addr>(&sloader_dlopen)},
    {"dlsym", reinterpret_cast<Elf64_Addr>(&sloader_dlsym)},
    {"dlvsym", reinterpret_cast<Elf64_Addr>(&sloader_dlvsym)},
    {"dn_expand", reinterpret_cast<Elf64_Addr>(&dn_expand)},
    {"dn_skipname", reinterpret_cast<Elf64_Addr>(&dn_skipname)},
    {"dngettext", reinterpret_cast<Elf64_Addr>(&dngettext)},
    {"dup", reinterpret_cast<Elf64_Addr>(&dup)},
    {"dup2", reinterpret_cast<Elf64_Addr>(&dup2)},
    {"dup3", reinterpret_cast<Elf64_Addr>(&dup3)},
    {"duplocale", reinterpret_cast<Elf64_Addr>(&duplocale)},
    {"duplocale", reinterpret_cast<Elf64_Addr>(&duplocale)},
    {"duplocale", reinterpret_cast<Elf64_Addr>(&duplocale)},
    {"duplocale", reinterpret_cast<Elf64_Addr>(&duplocale)},
    {"eaccess", reinterpret_cast<Elf64_Addr>(&eaccess)},
    {"endaliasent", reinterpret_cast<Elf64_Addr>(&endaliasent)},
    {"endgrent", reinterpret_cast<Elf64_Addr>(&endgrent)},
    {"endhostent", reinterpret_cast<Elf64_Addr>(&endhostent)},
    {"endmntent", reinterpret_cast<Elf64_Addr>(&endmntent)},
    {"endnetent", reinterpret_cast<Elf64_Addr>(&endnetent)},
    {"endnetgrent", reinterpret_cast<Elf64_Addr>(&endnetgrent)},
    {"endprotoent", reinterpret_cast<Elf64_Addr>(&endprotoent)},
    {"endpwent", reinterpret_cast<Elf64_Addr>(&endpwent)},
    {"endrpcent", reinterpret_cast<Elf64_Addr>(&endrpcent)},
    {"endservent", reinterpret_cast<Elf64_Addr>(&endservent)},
    {"endsgent", reinterpret_cast<Elf64_Addr>(&endsgent)},
    {"endspent", reinterpret_cast<Elf64_Addr>(&endspent)},
    {"endusershell", reinterpret_cast<Elf64_Addr>(&endusershell)},
    {"endutent", reinterpret_cast<Elf64_Addr>(&endutent)},
    {"endutxent", reinterpret_cast<Elf64_Addr>(&endutxent)},
    {"environ", reinterpret_cast<Elf64_Addr>(&environ)},
    {"epoll_create", reinterpret_cast<Elf64_Addr>(&epoll_create)},
    {"epoll_create1", reinterpret_cast<Elf64_Addr>(&epoll_create1)},
    {"epoll_ctl", reinterpret_cast<Elf64_Addr>(&epoll_ctl)},
    {"epoll_pwait", reinterpret_cast<Elf64_Addr>(&epoll_pwait)},
    {"epoll_wait", reinterpret_cast<Elf64_Addr>(&epoll_wait)},
    {"err", reinterpret_cast<Elf64_Addr>(&err)},
    {"error", reinterpret_cast<Elf64_Addr>(&error)},
    {"error_at_line", reinterpret_cast<Elf64_Addr>(&error_at_line)},
    {"errx", reinterpret_cast<Elf64_Addr>(&errx)},
    {"ether_aton", reinterpret_cast<Elf64_Addr>(&ether_aton)},
    {"ether_hostton", reinterpret_cast<Elf64_Addr>(&ether_hostton)},
    {"ether_ntoa", reinterpret_cast<Elf64_Addr>(&ether_ntoa)},
    {"ether_ntohost", reinterpret_cast<Elf64_Addr>(&ether_ntohost)},
    {"euidaccess", reinterpret_cast<Elf64_Addr>(&euidaccess)},
    {"eventfd", reinterpret_cast<Elf64_Addr>(&eventfd)},
    {"eventfd_read", reinterpret_cast<Elf64_Addr>(&eventfd_read)},
    {"eventfd_write", reinterpret_cast<Elf64_Addr>(&eventfd_write)},
    {"execl", reinterpret_cast<Elf64_Addr>(&execl)},
    {"execle", reinterpret_cast<Elf64_Addr>(&execle)},
    {"execlp", reinterpret_cast<Elf64_Addr>(&execlp)},
    {"execv", reinterpret_cast<Elf64_Addr>(&execv)},
    {"execve", reinterpret_cast<Elf64_Addr>(&execve)},
    {"execvp", reinterpret_cast<Elf64_Addr>(&execvp)},
    {"exit", reinterpret_cast<Elf64_Addr>(&exit)},
    {"faccessat", reinterpret_cast<Elf64_Addr>(&faccessat)},
    {"fallocate", reinterpret_cast<Elf64_Addr>(&fallocate)},
    {"fallocate64", reinterpret_cast<Elf64_Addr>(&fallocate64)},
    {"fchdir", reinterpret_cast<Elf64_Addr>(&fchdir)},
    {"fchmod", reinterpret_cast<Elf64_Addr>(&fchmod)},
    {"fchmodat", reinterpret_cast<Elf64_Addr>(&fchmodat)},
    {"fchown", reinterpret_cast<Elf64_Addr>(&fchown)},
    {"fchownat", reinterpret_cast<Elf64_Addr>(&fchownat)},
    {"fclose", reinterpret_cast<Elf64_Addr>(&sloader_fclose)},
    {"fcntl", reinterpret_cast<Elf64_Addr>(&fcntl)},
    {"fcntl64", reinterpret_cast<Elf64_Addr>(&fcntl64)},
    {"fdatasync", reinterpret_cast<Elf64_Addr>(&fdatasync)},
    {"fdopen", reinterpret_cast<Elf64_Addr>(&fdopen)},
    {"fdopendir", reinterpret_cast<Elf64_Addr>(&fdopendir)},
    {"feof", reinterpret_cast<Elf64_Addr>(&feof)},
    {"ferror", reinterpret_cast<Elf64_Addr>(&ferror)},
    {"fexecve", reinterpret_cast<Elf64_Addr>(&fexecve)},
    {"fflush", reinterpret_cast<Elf64_Addr>(&fflush)},
    {"fflush_unlocked", reinterpret_cast<Elf64_Addr>(&fflush_unlocked)},
    {"fgetc", reinterpret_cast<Elf64_Addr>(&fgetc)},
    {"fgets", reinterpret_cast<Elf64_Addr>(&fgets)},
    {"fgets_unlocked", reinterpret_cast<Elf64_Addr>(&fgets_unlocked)},
    {"fgetwc", reinterpret_cast<Elf64_Addr>(&fgetwc)},
    {"fgetxattr", reinterpret_cast<Elf64_Addr>(&fgetxattr)},
    {"fileno", reinterpret_cast<Elf64_Addr>(&fileno)},
    {"fileno_unlocked", reinterpret_cast<Elf64_Addr>(&fileno_unlocked)},
    {"flistxattr", reinterpret_cast<Elf64_Addr>(&flistxattr)},
    {"flock", reinterpret_cast<Elf64_Addr>(&flock)},
    {"flockfile", reinterpret_cast<Elf64_Addr>(&flockfile)},
    {"fmemopen", reinterpret_cast<Elf64_Addr>(&fmemopen)},
    {"fnmatch", reinterpret_cast<Elf64_Addr>(&fnmatch)},
    {"fopen", reinterpret_cast<Elf64_Addr>(&fopen)},
    {"fopen64", reinterpret_cast<Elf64_Addr>(&fopen64)},
    {"fopencookie", reinterpret_cast<Elf64_Addr>(&fopencookie)},
    {"fork", reinterpret_cast<Elf64_Addr>(&fork)},
    {"forkpty", reinterpret_cast<Elf64_Addr>(&forkpty)},
    {"fpathconf", reinterpret_cast<Elf64_Addr>(&fpathconf)},
    {"fprintf", reinterpret_cast<Elf64_Addr>(&fprintf)},
    {"fputc", reinterpret_cast<Elf64_Addr>(&fputc)},
    {"fputc_unlocked", reinterpret_cast<Elf64_Addr>(&fputc_unlocked)},
    {"fputs", reinterpret_cast<Elf64_Addr>(&fputs)},
    {"fputs_unlocked", reinterpret_cast<Elf64_Addr>(&fputs_unlocked)},
    {"fputwc", reinterpret_cast<Elf64_Addr>(&fputwc)},
    {"fputws", reinterpret_cast<Elf64_Addr>(&fputws)},
    {"fread", reinterpret_cast<Elf64_Addr>(&fread)},
    {"fread_unlocked", reinterpret_cast<Elf64_Addr>(&fread_unlocked)},
    {"free", reinterpret_cast<Elf64_Addr>(&free)},
    {"freeaddrinfo", reinterpret_cast<Elf64_Addr>(&freeaddrinfo)},
    {"freeaddrinfo", reinterpret_cast<Elf64_Addr>(&freeaddrinfo)},
    {"freeaddrinfo", reinterpret_cast<Elf64_Addr>(&freeaddrinfo)},
    {"freeaddrinfo", reinterpret_cast<Elf64_Addr>(&freeaddrinfo)},
    {"freeaddrinfo", reinterpret_cast<Elf64_Addr>(&freeaddrinfo)},
    {"freeifaddrs", reinterpret_cast<Elf64_Addr>(&freeifaddrs)},
    {"freelocale", reinterpret_cast<Elf64_Addr>(&freelocale)},
    {"fremovexattr", reinterpret_cast<Elf64_Addr>(&fremovexattr)},
    {"freopen", reinterpret_cast<Elf64_Addr>(&freopen)},
    {"freopen64", reinterpret_cast<Elf64_Addr>(&freopen64)},
    {"frexp", reinterpret_cast<Elf64_Addr>(frexp_c)},
    {"frexpl", reinterpret_cast<Elf64_Addr>(&frexpl)},
    {"fscanf", reinterpret_cast<Elf64_Addr>(&fscanf)},
    {"fseek", reinterpret_cast<Elf64_Addr>(&fseek)},
    {"fseeko", reinterpret_cast<Elf64_Addr>(&fseeko)},
    {"fseeko64", reinterpret_cast<Elf64_Addr>(&fseeko64)},
    {"fsetxattr", reinterpret_cast<Elf64_Addr>(&fsetxattr)},
    {"fstat", reinterpret_cast<Elf64_Addr>(&fstat)},
    {"fstat64", reinterpret_cast<Elf64_Addr>(&fstat64)},
    {"fstatat", reinterpret_cast<Elf64_Addr>(&fstatat)},
    {"fstatat64", reinterpret_cast<Elf64_Addr>(&fstatat64)},
    {"fstatfs", reinterpret_cast<Elf64_Addr>(&fstatfs)},
    {"fstatfs64", reinterpret_cast<Elf64_Addr>(&fstatfs64)},
    {"fstatvfs", reinterpret_cast<Elf64_Addr>(&fstatvfs)},
    {"fstatvfs64", reinterpret_cast<Elf64_Addr>(&fstatvfs64)},
    {"fsync", reinterpret_cast<Elf64_Addr>(&fsync)},
    {"ftell", reinterpret_cast<Elf64_Addr>(&ftell)},
    {"ftello", reinterpret_cast<Elf64_Addr>(&ftello)},
    {"ftello64", reinterpret_cast<Elf64_Addr>(&ftello64)},
    {"ftruncate", reinterpret_cast<Elf64_Addr>(&ftruncate)},
    {"ftruncate64", reinterpret_cast<Elf64_Addr>(&ftruncate64)},
    {"fts_close", reinterpret_cast<Elf64_Addr>(&fts_close)},
    {"fts_open", reinterpret_cast<Elf64_Addr>(&fts_open)},
    {"fts_read", reinterpret_cast<Elf64_Addr>(&fts_read)},
    {"fts_set", reinterpret_cast<Elf64_Addr>(&fts_set)},
    {"ftw", reinterpret_cast<Elf64_Addr>(&ftw)},
    {"funlockfile", reinterpret_cast<Elf64_Addr>(&funlockfile)},
    {"futimens", reinterpret_cast<Elf64_Addr>(&futimens)},
    {"futimesat", reinterpret_cast<Elf64_Addr>(&futimesat)},
    {"fwrite", reinterpret_cast<Elf64_Addr>(&fwrite)},
    {"fwrite_unlocked", reinterpret_cast<Elf64_Addr>(&fwrite_unlocked)},
    {"gai_strerror", reinterpret_cast<Elf64_Addr>(&gai_strerror)},
    {"get_current_dir_name", reinterpret_cast<Elf64_Addr>(&get_current_dir_name)},
    {"get_nprocs", reinterpret_cast<Elf64_Addr>(&get_nprocs)},
    {"getaddrinfo", reinterpret_cast<Elf64_Addr>(&getaddrinfo)},
    {"getaliasbyname", reinterpret_cast<Elf64_Addr>(&getaliasbyname)},
    {"getaliasent", reinterpret_cast<Elf64_Addr>(&getaliasent)},
    {"getauxval", reinterpret_cast<Elf64_Addr>(&getauxval)},
    {"getc", reinterpret_cast<Elf64_Addr>(&getc)},
    {"getcontext", reinterpret_cast<Elf64_Addr>(&getcontext)},
    {"getcwd", reinterpret_cast<Elf64_Addr>(&getcwd)},
    {"getdelim", reinterpret_cast<Elf64_Addr>(&getdelim)},
    {"getdomainname", reinterpret_cast<Elf64_Addr>(&getdomainname)},
    {"getdtablesize", reinterpret_cast<Elf64_Addr>(&getdtablesize)},
    {"getegid", reinterpret_cast<Elf64_Addr>(&getegid)},
    {"getentropy", reinterpret_cast<Elf64_Addr>(&getentropy)},
    {"getenv", reinterpret_cast<Elf64_Addr>(&getenv)},
    {"geteuid", reinterpret_cast<Elf64_Addr>(&geteuid)},
    {"getgid", reinterpret_cast<Elf64_Addr>(&getgid)},
    {"getgrent", reinterpret_cast<Elf64_Addr>(&getgrent)},
    {"getgrgid", reinterpret_cast<Elf64_Addr>(&getgrgid)},
    {"getgrgid_r", reinterpret_cast<Elf64_Addr>(&getgrgid_r)},
    {"getgrnam", reinterpret_cast<Elf64_Addr>(&getgrnam)},
    {"getgrnam_r", reinterpret_cast<Elf64_Addr>(&getgrnam_r)},
    {"getgrouplist", reinterpret_cast<Elf64_Addr>(&getgrouplist)},
    {"getgroups", reinterpret_cast<Elf64_Addr>(&getgroups)},
    {"gethostbyaddr", reinterpret_cast<Elf64_Addr>(&gethostbyaddr)},
    {"gethostbyaddr_r", reinterpret_cast<Elf64_Addr>(&gethostbyaddr_r)},
    {"gethostbyname", reinterpret_cast<Elf64_Addr>(&gethostbyname)},
    {"gethostbyname2", reinterpret_cast<Elf64_Addr>(&gethostbyname2)},
    {"gethostbyname_r", reinterpret_cast<Elf64_Addr>(&gethostbyname_r)},
    {"gethostent", reinterpret_cast<Elf64_Addr>(&gethostent)},
    {"gethostid", reinterpret_cast<Elf64_Addr>(&gethostid)},
    {"gethostname", reinterpret_cast<Elf64_Addr>(&gethostname)},
    {"getifaddrs", reinterpret_cast<Elf64_Addr>(&getifaddrs)},
    {"getifaddrs", reinterpret_cast<Elf64_Addr>(&getifaddrs)},
    {"getitimer", reinterpret_cast<Elf64_Addr>(&getitimer)},
    {"getline", reinterpret_cast<Elf64_Addr>(&getline)},
    {"getloadavg", reinterpret_cast<Elf64_Addr>(&getloadavg)},
    {"getlogin", reinterpret_cast<Elf64_Addr>(&getlogin)},
    {"getmntent", reinterpret_cast<Elf64_Addr>(&getmntent)},
    {"getmntent_r", reinterpret_cast<Elf64_Addr>(&getmntent_r)},
    {"getnameinfo", reinterpret_cast<Elf64_Addr>(&getnameinfo)},
    {"getnetbyaddr", reinterpret_cast<Elf64_Addr>(&getnetbyaddr)},
    {"getnetbyname", reinterpret_cast<Elf64_Addr>(&getnetbyname)},
    {"getnetent", reinterpret_cast<Elf64_Addr>(&getnetent)},
    {"getnetgrent", reinterpret_cast<Elf64_Addr>(&getnetgrent)},
    {"getopt", reinterpret_cast<Elf64_Addr>(&getopt)},
    {"getopt_long", reinterpret_cast<Elf64_Addr>(&getopt_long)},
    {"getopt_long_only", reinterpret_cast<Elf64_Addr>(&getopt_long_only)},
    {"getpagesize", reinterpret_cast<Elf64_Addr>(&getpagesize)},
    {"getpass", reinterpret_cast<Elf64_Addr>(&getpass)},
    {"getpeername", reinterpret_cast<Elf64_Addr>(&getpeername)},
    {"getpgid", reinterpret_cast<Elf64_Addr>(&getpgid)},
    {"getpgrp", reinterpret_cast<Elf64_Addr>(&getpgrp)},
    {"getpid", reinterpret_cast<Elf64_Addr>(&getpid)},
    {"getppid", reinterpret_cast<Elf64_Addr>(&getppid)},
    {"getpriority", reinterpret_cast<Elf64_Addr>(&getpriority)},
    {"getprotobyname", reinterpret_cast<Elf64_Addr>(&getprotobyname)},
    {"getprotobynumber", reinterpret_cast<Elf64_Addr>(&getprotobynumber)},
    {"getprotoent", reinterpret_cast<Elf64_Addr>(&getprotoent)},
    {"getpwent", reinterpret_cast<Elf64_Addr>(&getpwent)},
    {"getpwnam", reinterpret_cast<Elf64_Addr>(&getpwnam)},
    {"getpwnam_r", reinterpret_cast<Elf64_Addr>(&getpwnam_r)},
    {"getpwuid", reinterpret_cast<Elf64_Addr>(&getpwuid)},
    {"getpwuid_r", reinterpret_cast<Elf64_Addr>(&getpwuid_r)},
    {"getpwuid_r", reinterpret_cast<Elf64_Addr>(&getpwuid_r)},
    {"getpwuid_r", reinterpret_cast<Elf64_Addr>(&getpwuid_r)},
    {"getrandom", reinterpret_cast<Elf64_Addr>(&getrandom)},
    {"getresgid", reinterpret_cast<Elf64_Addr>(&getresgid)},
    {"getresuid", reinterpret_cast<Elf64_Addr>(&getresuid)},
    {"getrlimit", reinterpret_cast<Elf64_Addr>(&getrlimit)},
    {"getrlimit64", reinterpret_cast<Elf64_Addr>(&getrlimit64)},
    {"getrpcbyname", reinterpret_cast<Elf64_Addr>(&getrpcbyname)},
    {"getrpcbynumber", reinterpret_cast<Elf64_Addr>(&getrpcbynumber)},
    {"getrpcent", reinterpret_cast<Elf64_Addr>(&getrpcent)},
    {"getrusage", reinterpret_cast<Elf64_Addr>(&getrusage)},
    {"getservbyname", reinterpret_cast<Elf64_Addr>(&getservbyname)},
    {"getservbyport", reinterpret_cast<Elf64_Addr>(&getservbyport)},
    {"getservbyport_r", reinterpret_cast<Elf64_Addr>(&getservbyport_r)},
    {"getservent", reinterpret_cast<Elf64_Addr>(&getservent)},
    {"getsgent", reinterpret_cast<Elf64_Addr>(&getsgent)},
    {"getsgnam", reinterpret_cast<Elf64_Addr>(&getsgnam)},
    {"getsid", reinterpret_cast<Elf64_Addr>(&getsid)},
    {"getsockname", reinterpret_cast<Elf64_Addr>(&getsockname)},
    {"getsockopt", reinterpret_cast<Elf64_Addr>(&getsockopt)},
    {"getspent", reinterpret_cast<Elf64_Addr>(&getspent)},
    {"getspnam", reinterpret_cast<Elf64_Addr>(&getspnam)},
    {"getspnam_r", reinterpret_cast<Elf64_Addr>(&getspnam_r)},
    {"gettext", reinterpret_cast<Elf64_Addr>(&gettext)},
    {"gettid", reinterpret_cast<Elf64_Addr>(&gettid)},
    {"gettimeofday", reinterpret_cast<Elf64_Addr>(&gettimeofday)},
    {"getttynam", reinterpret_cast<Elf64_Addr>(&getttynam)},
    {"getuid", reinterpret_cast<Elf64_Addr>(&getuid)},
    {"getusershell", reinterpret_cast<Elf64_Addr>(&getusershell)},
    {"getutent", reinterpret_cast<Elf64_Addr>(&getutent)},
    {"getutline", reinterpret_cast<Elf64_Addr>(&getutline)},
    {"getutxent", reinterpret_cast<Elf64_Addr>(&getutxent)},
    {"getutxline", reinterpret_cast<Elf64_Addr>(&getutxline)},
    {"getwc", reinterpret_cast<Elf64_Addr>(&getwc)},
    {"getwchar", reinterpret_cast<Elf64_Addr>(&getwchar)},
    {"getxattr", reinterpret_cast<Elf64_Addr>(&getxattr)},
    {"glob", reinterpret_cast<Elf64_Addr>(&glob)},
    {"glob64", reinterpret_cast<Elf64_Addr>(&glob64)},
    {"glob_pattern_p", reinterpret_cast<Elf64_Addr>(&glob_pattern_p)},
    {"globfree", reinterpret_cast<Elf64_Addr>(&globfree)},
    {"globfree64", reinterpret_cast<Elf64_Addr>(&globfree64)},
    {"gmtime", reinterpret_cast<Elf64_Addr>(&gmtime)},
    {"gmtime_r", reinterpret_cast<Elf64_Addr>(&gmtime_r)},
    {"gnu_dev_major", reinterpret_cast<Elf64_Addr>(&gnu_dev_major)},
    {"gnu_dev_major", reinterpret_cast<Elf64_Addr>(&gnu_dev_major)},
    {"gnu_dev_major", reinterpret_cast<Elf64_Addr>(&gnu_dev_major)},
    {"gnu_dev_major", reinterpret_cast<Elf64_Addr>(&gnu_dev_major)},
    {"gnu_dev_major", reinterpret_cast<Elf64_Addr>(&gnu_dev_major)},
    {"gnu_dev_makedev", reinterpret_cast<Elf64_Addr>(&gnu_dev_makedev)},
    {"gnu_dev_makedev", reinterpret_cast<Elf64_Addr>(&gnu_dev_makedev)},
    {"gnu_dev_makedev", reinterpret_cast<Elf64_Addr>(&gnu_dev_makedev)},
    {"gnu_dev_makedev", reinterpret_cast<Elf64_Addr>(&gnu_dev_makedev)},
    {"gnu_dev_makedev", reinterpret_cast<Elf64_Addr>(&gnu_dev_makedev)},
    {"gnu_dev_minor", reinterpret_cast<Elf64_Addr>(&gnu_dev_minor)},
    {"gnu_dev_minor", reinterpret_cast<Elf64_Addr>(&gnu_dev_minor)},
    {"gnu_dev_minor", reinterpret_cast<Elf64_Addr>(&gnu_dev_minor)},
    {"gnu_dev_minor", reinterpret_cast<Elf64_Addr>(&gnu_dev_minor)},
    {"gnu_dev_minor", reinterpret_cast<Elf64_Addr>(&gnu_dev_minor)},
    {"gnu_get_libc_version", reinterpret_cast<Elf64_Addr>(&gnu_get_libc_version)},
    {"grantpt", reinterpret_cast<Elf64_Addr>(&grantpt)},
    {"group_member", reinterpret_cast<Elf64_Addr>(&group_member)},
    {"hasmntopt", reinterpret_cast<Elf64_Addr>(&hasmntopt)},
    {"herror", reinterpret_cast<Elf64_Addr>(&herror)},
    {"hstrerror", reinterpret_cast<Elf64_Addr>(&hstrerror)},
    {"iconv", reinterpret_cast<Elf64_Addr>(&iconv)},
    {"iconv_close", reinterpret_cast<Elf64_Addr>(&iconv_close)},
    {"iconv_open", reinterpret_cast<Elf64_Addr>(&iconv_open)},
    {"if_freenameindex", reinterpret_cast<Elf64_Addr>(&if_freenameindex)},
    {"if_indextoname", reinterpret_cast<Elf64_Addr>(&if_indextoname)},
    {"if_nameindex", reinterpret_cast<Elf64_Addr>(&if_nameindex)},
    {"if_nametoindex", reinterpret_cast<Elf64_Addr>(&if_nametoindex)},
    {"in6addr_any", reinterpret_cast<Elf64_Addr>(&in6addr_any)},
    {"in6addr_any", reinterpret_cast<Elf64_Addr>(&in6addr_any)},
    {"in6addr_loopback", reinterpret_cast<Elf64_Addr>(&in6addr_loopback)},
    {"inet_addr", reinterpret_cast<Elf64_Addr>(&inet_addr)},
    {"inet_aton", reinterpret_cast<Elf64_Addr>(&inet_aton)},
    {"inet_nsap_ntoa", reinterpret_cast<Elf64_Addr>(&inet_nsap_ntoa)},
    {"inet_ntoa", reinterpret_cast<Elf64_Addr>(&inet_ntoa)},
    {"inet_ntop", reinterpret_cast<Elf64_Addr>(&inet_ntop)},
    {"inet_pton", reinterpret_cast<Elf64_Addr>(&inet_pton)},
    {"initgroups", reinterpret_cast<Elf64_Addr>(&initgroups)},
    {"innetgr", reinterpret_cast<Elf64_Addr>(&innetgr)},
    {"inotify_add_watch", reinterpret_cast<Elf64_Addr>(&inotify_add_watch)},
    {"inotify_init", reinterpret_cast<Elf64_Addr>(&inotify_init)},
    {"inotify_init1", reinterpret_cast<Elf64_Addr>(&inotify_init1)},
    {"inotify_rm_watch", reinterpret_cast<Elf64_Addr>(&inotify_rm_watch)},
    {"ioctl", reinterpret_cast<Elf64_Addr>(&ioctl)},
    {"iopl", reinterpret_cast<Elf64_Addr>(&iopl)},
    {"isalnum", reinterpret_cast<Elf64_Addr>(&isalnum)},
    {"isalpha", reinterpret_cast<Elf64_Addr>(&isalpha)},
    {"isatty", reinterpret_cast<Elf64_Addr>(&isatty)},
    {"isblank", reinterpret_cast<Elf64_Addr>(&isblank)},
    {"iscntrl", reinterpret_cast<Elf64_Addr>(&iscntrl)},
    {"isdigit", reinterpret_cast<Elf64_Addr>(&isdigit)},
    {"isgraph", reinterpret_cast<Elf64_Addr>(&isgraph)},
    {"islower", reinterpret_cast<Elf64_Addr>(&islower)},
    {"isprint", reinterpret_cast<Elf64_Addr>(&isprint)},
    {"ispunct", reinterpret_cast<Elf64_Addr>(&ispunct)},
    {"isspace", reinterpret_cast<Elf64_Addr>(&isspace)},
    {"isupper", reinterpret_cast<Elf64_Addr>(&isupper)},
    {"iswalnum", reinterpret_cast<Elf64_Addr>(&iswalnum)},
    {"iswalpha", reinterpret_cast<Elf64_Addr>(&iswalpha)},
    {"iswcntrl", reinterpret_cast<Elf64_Addr>(&iscntrl)},
    {"iswctype", reinterpret_cast<Elf64_Addr>(&iswctype)},
    {"iswdigit", reinterpret_cast<Elf64_Addr>(&iswdigit)},
    {"iswgraph", reinterpret_cast<Elf64_Addr>(&iswgraph)},
    {"iswlower", reinterpret_cast<Elf64_Addr>(&iswlower)},
    {"iswprint", reinterpret_cast<Elf64_Addr>(&isprint)},
    {"iswspace", reinterpret_cast<Elf64_Addr>(&iswspace)},
    {"iswupper", reinterpret_cast<Elf64_Addr>(&iswupper)},
    {"isxdigit", reinterpret_cast<Elf64_Addr>(&isxdigit)},
    {"jrand48", reinterpret_cast<Elf64_Addr>(&jrand48)},
    {"kill", reinterpret_cast<Elf64_Addr>(&kill)},
    {"killpg", reinterpret_cast<Elf64_Addr>(&killpg)},
    {"klogctl", reinterpret_cast<Elf64_Addr>(&klogctl)},
    {"l64a", reinterpret_cast<Elf64_Addr>(&l64a)},
    {"lchmod", reinterpret_cast<Elf64_Addr>(&lchmod)},
    {"lchown", reinterpret_cast<Elf64_Addr>(&lchown)},
    {"lckpwdf", reinterpret_cast<Elf64_Addr>(&lckpwdf)},
    {"ldexp", reinterpret_cast<Elf64_Addr>(ldexp_c)},
    {"ldexpl", reinterpret_cast<Elf64_Addr>(&ldexpl)},
    {"lgetxattr", reinterpret_cast<Elf64_Addr>(&lgetxattr)},
    {"link", reinterpret_cast<Elf64_Addr>(&link)},
    {"linkat", reinterpret_cast<Elf64_Addr>(&linkat)},
    {"listen", reinterpret_cast<Elf64_Addr>(&listen)},
    {"listen", reinterpret_cast<Elf64_Addr>(&listen)},
    {"listxattr", reinterpret_cast<Elf64_Addr>(&listxattr)},
    {"llistxattr", reinterpret_cast<Elf64_Addr>(&llistxattr)},
    {"localeconv", reinterpret_cast<Elf64_Addr>(&localeconv)},
    {"localtime", reinterpret_cast<Elf64_Addr>(&localtime)},
    {"localtime_r", reinterpret_cast<Elf64_Addr>(&localtime_r)},
    {"lockf", reinterpret_cast<Elf64_Addr>(&lockf)},
    {"lockf64", reinterpret_cast<Elf64_Addr>(&lockf64)},
    {"lremovexattr", reinterpret_cast<Elf64_Addr>(&lremovexattr)},
    {"lsearch", reinterpret_cast<Elf64_Addr>(&lsearch)},
    {"lseek", reinterpret_cast<Elf64_Addr>(&lseek)},
    {"lseek", reinterpret_cast<Elf64_Addr>(&lseek)},
    {"lseek64", reinterpret_cast<Elf64_Addr>(&lseek64)},
    {"lsetxattr", reinterpret_cast<Elf64_Addr>(&lsetxattr)},
    {"lstat", reinterpret_cast<Elf64_Addr>(&lstat)},
    {"lstat64", reinterpret_cast<Elf64_Addr>(&lstat64)},
    {"lutimes", reinterpret_cast<Elf64_Addr>(&lutimes)},
    {"madvise", reinterpret_cast<Elf64_Addr>(&madvise)},
    {"makecontext", reinterpret_cast<Elf64_Addr>(&makecontext)},
    {"mallinfo", reinterpret_cast<Elf64_Addr>(&mallinfo)},
    {"mallinfo2", reinterpret_cast<Elf64_Addr>(&mallinfo2)},
    {"malloc", reinterpret_cast<Elf64_Addr>(&malloc)},
    {"malloc_trim", reinterpret_cast<Elf64_Addr>(&malloc_trim)},
    {"malloc_usable_size", reinterpret_cast<Elf64_Addr>(&malloc_usable_size)},
    {"mblen", reinterpret_cast<Elf64_Addr>(&mblen)},
    {"mbrtowc", reinterpret_cast<Elf64_Addr>(&mbrtowc)},
    {"mbsinit", reinterpret_cast<Elf64_Addr>(&mbsinit)},
    {"mbsnrtowcs", reinterpret_cast<Elf64_Addr>(&mbsnrtowcs)},
    {"mbsrtowcs", reinterpret_cast<Elf64_Addr>(&mbsrtowcs)},
    {"mbstowcs", reinterpret_cast<Elf64_Addr>(&mbstowcs)},
    {"mbtowc", reinterpret_cast<Elf64_Addr>(&mbtowc)},
    {"memccpy", reinterpret_cast<Elf64_Addr>(&memccpy)},
    {"memchr", reinterpret_cast<Elf64_Addr>(memchr_c)},
    {"memcmp", reinterpret_cast<Elf64_Addr>(&memcmp)},
    {"memcpy", reinterpret_cast<Elf64_Addr>(&memcpy)},
    {"memfd_create", reinterpret_cast<Elf64_Addr>(&memfd_create)},
    {"memmem", reinterpret_cast<Elf64_Addr>(&memmem)},
    {"memmove", reinterpret_cast<Elf64_Addr>(&memmove)},
    {"mempcpy", reinterpret_cast<Elf64_Addr>(&mempcpy)},
    {"memrchr", reinterpret_cast<Elf64_Addr>(&memrchr_c)},
    {"memset", reinterpret_cast<Elf64_Addr>(&memset)},
    {"mincore", reinterpret_cast<Elf64_Addr>(&mincore)},
    {"mkdir", reinterpret_cast<Elf64_Addr>(&mkdir)},
    {"mkdirat", reinterpret_cast<Elf64_Addr>(&mkdirat)},
    {"mkdtemp", reinterpret_cast<Elf64_Addr>(&mkdtemp)},
    {"mkfifo", reinterpret_cast<Elf64_Addr>(&mkfifo)},
    {"mkfifoat", reinterpret_cast<Elf64_Addr>(&mkfifoat)},
    {"mknod", reinterpret_cast<Elf64_Addr>(&mknod)},
    {"mknodat", reinterpret_cast<Elf64_Addr>(&mknodat)},
    {"mkostemp", reinterpret_cast<Elf64_Addr>(&mkostemp)},
    {"mkostemp64", reinterpret_cast<Elf64_Addr>(&mkostemp64)},
    {"mkstemp", reinterpret_cast<Elf64_Addr>(&mkstemp)},
    {"mkstemp64", reinterpret_cast<Elf64_Addr>(&mkstemp64)},
    {"mkstemp64", reinterpret_cast<Elf64_Addr>(&mkstemp64)},
    {"mkstemps", reinterpret_cast<Elf64_Addr>(&mkstemps)},
    {"mktime", reinterpret_cast<Elf64_Addr>(&mktime)},
    {"mlock", reinterpret_cast<Elf64_Addr>(&mlock)},
    {"mmap", reinterpret_cast<Elf64_Addr>(&mmap)},
    {"mmap64", reinterpret_cast<Elf64_Addr>(&mmap64)},
    {"modf", reinterpret_cast<Elf64_Addr>(&modf_c)},
    {"mount", reinterpret_cast<Elf64_Addr>(&mount)},
    {"mprotect", reinterpret_cast<Elf64_Addr>(&mprotect)},
    {"mq_getattr", reinterpret_cast<Elf64_Addr>(&mq_getattr)},
    {"mremap", reinterpret_cast<Elf64_Addr>(&mremap)},
    {"msgctl", reinterpret_cast<Elf64_Addr>(&msgctl)},
    {"msync", reinterpret_cast<Elf64_Addr>(&msync)},
    {"mtrace", reinterpret_cast<Elf64_Addr>(&mtrace)},
    {"munlock", reinterpret_cast<Elf64_Addr>(&munlock)},
    {"munmap", reinterpret_cast<Elf64_Addr>(&munmap)},
    {"name_to_handle_at", reinterpret_cast<Elf64_Addr>(&name_to_handle_at)},
    {"nanosleep", reinterpret_cast<Elf64_Addr>(&nanosleep)},
    {"newlocale", reinterpret_cast<Elf64_Addr>(&newlocale)},
    {"nftw64", reinterpret_cast<Elf64_Addr>(&nftw64)},
    {"nice", reinterpret_cast<Elf64_Addr>(&nice)},
    {"nl_langinfo", reinterpret_cast<Elf64_Addr>(&nl_langinfo)},
    {"ns_name_uncompress", reinterpret_cast<Elf64_Addr>(&ns_name_uncompress)},
    {"ntp_gettimex", reinterpret_cast<Elf64_Addr>(&ntp_gettimex)},
    {"obstack_free", reinterpret_cast<Elf64_Addr>(&obstack_free)},
    {"obstack_printf", reinterpret_cast<Elf64_Addr>(&obstack_printf)},
    {"obstack_vprintf", reinterpret_cast<Elf64_Addr>(&obstack_vprintf)},
    {"open", reinterpret_cast<Elf64_Addr>(&open)},
    {"open64", reinterpret_cast<Elf64_Addr>(&open64)},
    {"open_by_handle_at", reinterpret_cast<Elf64_Addr>(&open_by_handle_at)},
    {"open_memstream", reinterpret_cast<Elf64_Addr>(&open_memstream)},
    {"openat", reinterpret_cast<Elf64_Addr>(&openat)},
    {"openat64", reinterpret_cast<Elf64_Addr>(&openat64)},
    {"opendir", reinterpret_cast<Elf64_Addr>(&opendir)},
    {"openlog", reinterpret_cast<Elf64_Addr>(&openlog)},
    {"openpty", reinterpret_cast<Elf64_Addr>(&openpty)},
    {"optarg", reinterpret_cast<Elf64_Addr>(&optarg)},
    {"opterr", reinterpret_cast<Elf64_Addr>(&opterr)},
    {"optind", reinterpret_cast<Elf64_Addr>(&optind)},
    {"optopt", reinterpret_cast<Elf64_Addr>(&optopt)},
    {"parse_printf_format", reinterpret_cast<Elf64_Addr>(&parse_printf_format)},
    {"pathconf", reinterpret_cast<Elf64_Addr>(&pathconf)},
    {"pause", reinterpret_cast<Elf64_Addr>(&pause)},
    {"pclose", reinterpret_cast<Elf64_Addr>(&pclose)},
    {"perror", reinterpret_cast<Elf64_Addr>(&perror)},
    {"personality", reinterpret_cast<Elf64_Addr>(&personality)},
    {"pipe", reinterpret_cast<Elf64_Addr>(&pipe)},
    {"pipe2", reinterpret_cast<Elf64_Addr>(&pipe2)},
    {"poll", reinterpret_cast<Elf64_Addr>(&poll)},
    {"popen", reinterpret_cast<Elf64_Addr>(&popen)},
    {"posix_fadvise", reinterpret_cast<Elf64_Addr>(&posix_fadvise)},
    {"posix_fadvise64", reinterpret_cast<Elf64_Addr>(&posix_fadvise64)},
    {"posix_fallocate", reinterpret_cast<Elf64_Addr>(&posix_fallocate)},
    {"posix_fallocate64", reinterpret_cast<Elf64_Addr>(&posix_fallocate64)},
    {"posix_madvise", reinterpret_cast<Elf64_Addr>(&posix_madvise)},
    {"posix_memalign", reinterpret_cast<Elf64_Addr>(&posix_memalign)},
    {"posix_openpt", reinterpret_cast<Elf64_Addr>(&posix_openpt)},
    {"posix_spawn", reinterpret_cast<Elf64_Addr>(&posix_spawn)},
    {"posix_spawn_file_actions_addclose", reinterpret_cast<Elf64_Addr>(&posix_spawn_file_actions_addclose)},
    {"posix_spawn_file_actions_adddup2", reinterpret_cast<Elf64_Addr>(&posix_spawn_file_actions_adddup2)},
    {"posix_spawn_file_actions_addopen", reinterpret_cast<Elf64_Addr>(&posix_spawn_file_actions_addopen)},
    {"posix_spawn_file_actions_destroy", reinterpret_cast<Elf64_Addr>(&posix_spawn_file_actions_destroy)},
    {"posix_spawn_file_actions_init", reinterpret_cast<Elf64_Addr>(&posix_spawn_file_actions_init)},
    {"posix_spawnattr_destroy", reinterpret_cast<Elf64_Addr>(&posix_spawnattr_destroy)},
    {"posix_spawnattr_init", reinterpret_cast<Elf64_Addr>(&posix_spawnattr_init)},
    {"posix_spawnattr_setflags", reinterpret_cast<Elf64_Addr>(&posix_spawnattr_setflags)},
    {"posix_spawnattr_setpgroup", reinterpret_cast<Elf64_Addr>(&posix_spawnattr_setpgroup)},
    {"posix_spawnattr_setschedparam", reinterpret_cast<Elf64_Addr>(&posix_spawnattr_setschedparam)},
    {"posix_spawnattr_setschedpolicy", reinterpret_cast<Elf64_Addr>(&posix_spawnattr_setschedpolicy)},
    {"posix_spawnattr_setsigdefault", reinterpret_cast<Elf64_Addr>(&posix_spawnattr_setsigdefault)},
    {"posix_spawnattr_setsigmask", reinterpret_cast<Elf64_Addr>(&posix_spawnattr_setsigmask)},
    {"posix_spawnp", reinterpret_cast<Elf64_Addr>(&posix_spawnp)},
    {"ppoll", reinterpret_cast<Elf64_Addr>(&ppoll)},
    {"prctl", reinterpret_cast<Elf64_Addr>(&prctl)},
    {"pread", reinterpret_cast<Elf64_Addr>(&pread)},
    {"pread64", reinterpret_cast<Elf64_Addr>(&pread64)},
    {"preadv64v2", reinterpret_cast<Elf64_Addr>(&preadv64v2)},
    {"printf", reinterpret_cast<Elf64_Addr>(&printf)},
    {"process_vm_readv", reinterpret_cast<Elf64_Addr>(&process_vm_readv)},
    {"process_vm_writev", reinterpret_cast<Elf64_Addr>(&process_vm_writev)},
    {"program_invocation_name", reinterpret_cast<Elf64_Addr>(&program_invocation_name)},
    {"program_invocation_short_name", reinterpret_cast<Elf64_Addr>(&program_invocation_short_name)},
    {"pselect", reinterpret_cast<Elf64_Addr>(&pselect)},
    {"pthread_getattr_np", reinterpret_cast<Elf64_Addr>(&pthread_getattr_np)},
    {"pthread_attr_getguardsize", reinterpret_cast<Elf64_Addr>(&pthread_attr_getguardsize)},
    {"__fxstat64", reinterpret_cast<Elf64_Addr>(&fstat64)},
    {"pthread_attr_getstack", reinterpret_cast<Elf64_Addr>(&pthread_attr_getstack)},
    {"bcmp", reinterpret_cast<Elf64_Addr>(&bcmp)},
    {"__lxstat64", reinterpret_cast<Elf64_Addr>(&lstat64)},
    {"__xstat64", reinterpret_cast<Elf64_Addr>(&stat64)},
    {"__fxstatat64", reinterpret_cast<Elf64_Addr>(&fstatat64)},
    // {"__libc_fatal", reinterpret_cast<Elf64_Addr>(&__libc_fatal)},
    // {"__libc_unwind_link_get", reinterpret_cast<Elf64_Addr>(&__libc_unwind_link_get)},
    {"pthread_attr_destroy", reinterpret_cast<Elf64_Addr>(&pthread_attr_destroy)},
    {"pthread_attr_getstacksize", reinterpret_cast<Elf64_Addr>(&pthread_attr_getstacksize)},
    {"pthread_attr_init", reinterpret_cast<Elf64_Addr>(&pthread_attr_init)},
    {"pthread_attr_setdetachstate", reinterpret_cast<Elf64_Addr>(&pthread_attr_setdetachstate)},
    {"pthread_attr_setguardsize", reinterpret_cast<Elf64_Addr>(&pthread_attr_setguardsize)},
    {"pthread_attr_setinheritsched", reinterpret_cast<Elf64_Addr>(&pthread_attr_setinheritsched)},
    {"pthread_attr_setscope", reinterpret_cast<Elf64_Addr>(&pthread_attr_setscope)},
    {"pthread_attr_setstacksize", reinterpret_cast<Elf64_Addr>(&pthread_attr_setstacksize)},
    {"pthread_barrier_destroy", reinterpret_cast<Elf64_Addr>(&pthread_barrier_destroy)},
    {"pthread_barrier_init", reinterpret_cast<Elf64_Addr>(&pthread_barrier_init)},
    {"pthread_barrier_wait", reinterpret_cast<Elf64_Addr>(&pthread_barrier_wait)},
    {"pthread_cancel", reinterpret_cast<Elf64_Addr>(&pthread_cancel)},
    {"pthread_cond_broadcast", reinterpret_cast<Elf64_Addr>(&pthread_cond_broadcast)},
    {"pthread_cond_broadcast", reinterpret_cast<Elf64_Addr>(&pthread_cond_broadcast)},
    {"pthread_cond_destroy", reinterpret_cast<Elf64_Addr>(&pthread_cond_destroy)},
    {"pthread_cond_destroy", reinterpret_cast<Elf64_Addr>(&pthread_cond_destroy)},
    {"pthread_cond_init", reinterpret_cast<Elf64_Addr>(&pthread_cond_init)},
    {"pthread_cond_init", reinterpret_cast<Elf64_Addr>(&pthread_cond_init)},
    {"pthread_cond_signal", reinterpret_cast<Elf64_Addr>(&pthread_cond_signal)},
    {"pthread_cond_signal", reinterpret_cast<Elf64_Addr>(&pthread_cond_signal)},
    {"pthread_cond_timedwait", reinterpret_cast<Elf64_Addr>(&pthread_cond_timedwait)},
    {"pthread_cond_wait", reinterpret_cast<Elf64_Addr>(&pthread_cond_wait)},
    {"pthread_cond_wait", reinterpret_cast<Elf64_Addr>(&pthread_cond_wait)},
    {"pthread_condattr_destroy", reinterpret_cast<Elf64_Addr>(&pthread_condattr_destroy)},
    {"pthread_condattr_init", reinterpret_cast<Elf64_Addr>(&pthread_condattr_init)},
    {"pthread_condattr_setclock", reinterpret_cast<Elf64_Addr>(&pthread_condattr_setclock)},
    {"pthread_condattr_setpshared", reinterpret_cast<Elf64_Addr>(&pthread_condattr_setpshared)},
    {"pthread_create", reinterpret_cast<Elf64_Addr>(&pthread_create)},
    {"pthread_detach", reinterpret_cast<Elf64_Addr>(&pthread_detach)},
    {"pthread_equal", reinterpret_cast<Elf64_Addr>(&pthread_equal)},
    {"pthread_exit", reinterpret_cast<Elf64_Addr>(&pthread_exit)},
    {"pthread_getconcurrency", reinterpret_cast<Elf64_Addr>(&pthread_getconcurrency)},
    {"pthread_getcpuclockid", reinterpret_cast<Elf64_Addr>(&pthread_getcpuclockid)},
    {"pthread_getname_np", reinterpret_cast<Elf64_Addr>(&pthread_getname_np)},
    {"pthread_getspecific", reinterpret_cast<Elf64_Addr>(&pthread_getspecific)},
    {"pthread_getspecific", reinterpret_cast<Elf64_Addr>(&pthread_getspecific)},
    {"pthread_getspecific", reinterpret_cast<Elf64_Addr>(&pthread_getspecific)},
    {"pthread_join", reinterpret_cast<Elf64_Addr>(&pthread_join)},
    {"pthread_join", reinterpret_cast<Elf64_Addr>(&pthread_join)},
    {"pthread_join", reinterpret_cast<Elf64_Addr>(&pthread_join)},
    {"pthread_join", reinterpret_cast<Elf64_Addr>(&pthread_join)},
    {"pthread_key_create", reinterpret_cast<Elf64_Addr>(&pthread_key_create)},
    {"pthread_key_delete", reinterpret_cast<Elf64_Addr>(&pthread_key_delete)},
    {"pthread_kill", reinterpret_cast<Elf64_Addr>(&pthread_kill)},
    {"pthread_mutex_consistent", reinterpret_cast<Elf64_Addr>(&pthread_mutex_consistent)},
    {"pthread_mutex_consistent", reinterpret_cast<Elf64_Addr>(&pthread_mutex_consistent)},
    {"pthread_mutex_consistent", reinterpret_cast<Elf64_Addr>(&pthread_mutex_consistent)},
    {"pthread_mutex_consistent", reinterpret_cast<Elf64_Addr>(&pthread_mutex_consistent)},
    {"pthread_mutex_destroy", reinterpret_cast<Elf64_Addr>(&pthread_mutex_destroy)},
    {"pthread_mutex_init", reinterpret_cast<Elf64_Addr>(&pthread_mutex_init)},
    {"pthread_mutex_lock", reinterpret_cast<Elf64_Addr>(&pthread_mutex_lock)},
    {"pthread_mutex_timedlock", reinterpret_cast<Elf64_Addr>(&pthread_mutex_timedlock)},
    {"pthread_mutex_trylock", reinterpret_cast<Elf64_Addr>(&pthread_mutex_trylock)},
    {"pthread_mutex_unlock", reinterpret_cast<Elf64_Addr>(&pthread_mutex_unlock)},
    {"pthread_mutexattr_destroy", reinterpret_cast<Elf64_Addr>(&pthread_mutexattr_destroy)},
    {"pthread_mutexattr_init", reinterpret_cast<Elf64_Addr>(&pthread_mutexattr_init)},
    {"pthread_mutexattr_setpshared", reinterpret_cast<Elf64_Addr>(&pthread_mutexattr_setpshared)},
    {"pthread_mutexattr_setrobust", reinterpret_cast<Elf64_Addr>(&pthread_mutexattr_setrobust)},
    {"pthread_mutexattr_setrobust", reinterpret_cast<Elf64_Addr>(&pthread_mutexattr_setrobust)},
    {"pthread_mutexattr_setrobust", reinterpret_cast<Elf64_Addr>(&pthread_mutexattr_setrobust)},
    {"pthread_mutexattr_setrobust", reinterpret_cast<Elf64_Addr>(&pthread_mutexattr_setrobust)},
    {"pthread_mutexattr_settype", reinterpret_cast<Elf64_Addr>(&pthread_mutexattr_settype)},
    {"pthread_once", reinterpret_cast<Elf64_Addr>(&pthread_once)},
    {"pthread_rwlock_destroy", reinterpret_cast<Elf64_Addr>(&pthread_rwlock_destroy)},
    {"pthread_rwlock_init", reinterpret_cast<Elf64_Addr>(&pthread_rwlock_init)},
    {"pthread_rwlock_rdlock", reinterpret_cast<Elf64_Addr>(&pthread_rwlock_rdlock)},
    {"pthread_rwlock_timedrdlock", reinterpret_cast<Elf64_Addr>(&pthread_rwlock_timedrdlock)},
    {"pthread_rwlock_timedwrlock", reinterpret_cast<Elf64_Addr>(&pthread_rwlock_timedwrlock)},
    {"pthread_rwlock_tryrdlock", reinterpret_cast<Elf64_Addr>(&pthread_rwlock_tryrdlock)},
    {"pthread_rwlock_trywrlock", reinterpret_cast<Elf64_Addr>(&pthread_rwlock_trywrlock)},
    {"pthread_rwlock_unlock", reinterpret_cast<Elf64_Addr>(&pthread_rwlock_unlock)},
    {"pthread_rwlock_wrlock", reinterpret_cast<Elf64_Addr>(&pthread_rwlock_wrlock)},
    {"pthread_rwlockattr_destroy", reinterpret_cast<Elf64_Addr>(&pthread_rwlockattr_destroy)},
    {"pthread_rwlockattr_init", reinterpret_cast<Elf64_Addr>(&pthread_rwlockattr_init)},
    {"pthread_rwlockattr_setkind_np", reinterpret_cast<Elf64_Addr>(&pthread_rwlockattr_setkind_np)},
    {"pthread_rwlockattr_setpshared", reinterpret_cast<Elf64_Addr>(&pthread_rwlockattr_setpshared)},
    {"pthread_self", reinterpret_cast<Elf64_Addr>(&pthread_self)},
    {"pthread_setcancelstate", reinterpret_cast<Elf64_Addr>(&pthread_setcancelstate)},
    {"pthread_setconcurrency", reinterpret_cast<Elf64_Addr>(&pthread_setconcurrency)},
    {"pthread_setname_np", reinterpret_cast<Elf64_Addr>(&pthread_setname_np)},
    {"pthread_setspecific", reinterpret_cast<Elf64_Addr>(&pthread_setspecific)},
    {"pthread_sigmask", reinterpret_cast<Elf64_Addr>(&pthread_sigmask)},
    {"pthread_tryjoin_np", reinterpret_cast<Elf64_Addr>(&pthread_tryjoin_np)},
    {"ptrace", reinterpret_cast<Elf64_Addr>(&ptrace)},
    {"ptsname", reinterpret_cast<Elf64_Addr>(&ptsname)},
    {"ptsname_r", reinterpret_cast<Elf64_Addr>(&ptsname_r)},
    {"putc", reinterpret_cast<Elf64_Addr>(&putc)},
    {"putchar", reinterpret_cast<Elf64_Addr>(&putchar)},
    {"putenv", reinterpret_cast<Elf64_Addr>(&putenv)},
    {"putgrent", reinterpret_cast<Elf64_Addr>(&putgrent)},
    {"putpwent", reinterpret_cast<Elf64_Addr>(&putpwent)},
    {"puts", reinterpret_cast<Elf64_Addr>(&puts)},
    {"putsgent", reinterpret_cast<Elf64_Addr>(&putsgent)},
    {"putspent", reinterpret_cast<Elf64_Addr>(&putspent)},
    {"pututline", reinterpret_cast<Elf64_Addr>(&pututline)},
    {"pututxline", reinterpret_cast<Elf64_Addr>(&pututxline)},
    {"putwc", reinterpret_cast<Elf64_Addr>(&putwc)},
    {"putwchar", reinterpret_cast<Elf64_Addr>(&putwchar)},
    {"pwrite", reinterpret_cast<Elf64_Addr>(&pwrite)},
    {"pwrite64", reinterpret_cast<Elf64_Addr>(&pwrite64)},
    {"pwritev64v2", reinterpret_cast<Elf64_Addr>(&pwritev64v2)},
    {"qsort", reinterpret_cast<Elf64_Addr>(&qsort)},
    {"qsort_r", reinterpret_cast<Elf64_Addr>(&qsort_r)},
    {"raise", reinterpret_cast<Elf64_Addr>(&raise)},
    {"rand", reinterpret_cast<Elf64_Addr>(&rand)},
    {"rand_r", reinterpret_cast<Elf64_Addr>(&rand_r)},
    {"random", reinterpret_cast<Elf64_Addr>(&random)},
    {"rawmemchr", reinterpret_cast<Elf64_Addr>(rawmemchr_c)},
    {"re_compile_pattern", reinterpret_cast<Elf64_Addr>(&re_compile_pattern)},
    {"re_match", reinterpret_cast<Elf64_Addr>(&re_match)},
    {"re_search", reinterpret_cast<Elf64_Addr>(&re_search)},
    {"re_set_syntax", reinterpret_cast<Elf64_Addr>(&re_set_syntax)},
    {"read", reinterpret_cast<Elf64_Addr>(&read)},
    {"readdir", reinterpret_cast<Elf64_Addr>(&readdir)},
    {"readdir64", reinterpret_cast<Elf64_Addr>(&readdir64)},
    {"readlink", reinterpret_cast<Elf64_Addr>(&readlink)},
    {"readlinkat", reinterpret_cast<Elf64_Addr>(&readlinkat)},
    {"readv", reinterpret_cast<Elf64_Addr>(&readv)},
    {"realloc", reinterpret_cast<Elf64_Addr>(&realloc)},
    {"reallocarray", reinterpret_cast<Elf64_Addr>(&reallocarray)},
    {"realpath", reinterpret_cast<Elf64_Addr>(&realpath)},
    {"recv", reinterpret_cast<Elf64_Addr>(&recv)},
    {"recvfrom", reinterpret_cast<Elf64_Addr>(&recvfrom)},
    {"recvmmsg", reinterpret_cast<Elf64_Addr>(&recvmmsg)},
    {"recvmsg", reinterpret_cast<Elf64_Addr>(&recvmsg)},
    {"regcomp", reinterpret_cast<Elf64_Addr>(&regcomp)},
    {"regerror", reinterpret_cast<Elf64_Addr>(&regerror)},
    {"regexec", reinterpret_cast<Elf64_Addr>(&regexec)},
    {"regfree", reinterpret_cast<Elf64_Addr>(&regfree)},
    {"remove", reinterpret_cast<Elf64_Addr>(&remove)},
    {"removexattr", reinterpret_cast<Elf64_Addr>(&removexattr)},
    {"rename", reinterpret_cast<Elf64_Addr>(&rename)},
    {"renameat", reinterpret_cast<Elf64_Addr>(&renameat)},
    {"renameat2", reinterpret_cast<Elf64_Addr>(&renameat2)},
    {"res_dnok", reinterpret_cast<Elf64_Addr>(&res_dnok)},
    {"res_hnok", reinterpret_cast<Elf64_Addr>(&res_hnok)},
    {"res_nquery", reinterpret_cast<Elf64_Addr>(&res_nquery)},
    {"res_nsearch", reinterpret_cast<Elf64_Addr>(&res_nsearch)},
    {"res_query", reinterpret_cast<Elf64_Addr>(&res_query)},
    {"rewind", reinterpret_cast<Elf64_Addr>(&rewind)},
    {"rewinddir", reinterpret_cast<Elf64_Addr>(&rewinddir)},
    {"rindex", reinterpret_cast<Elf64_Addr>(&rindex_c)},
    {"rmdir", reinterpret_cast<Elf64_Addr>(&rmdir)},
    {"rpmatch", reinterpret_cast<Elf64_Addr>(&rpmatch)},
    {"ruserok", reinterpret_cast<Elf64_Addr>(&ruserok)},
    {"sbrk", reinterpret_cast<Elf64_Addr>(&sbrk)},
    {"scandir", reinterpret_cast<Elf64_Addr>(&scandir)},
    {"scandir64", reinterpret_cast<Elf64_Addr>(&scandir64)},
    {"scandirat", reinterpret_cast<Elf64_Addr>(&scandirat)},
    {"sched_get_priority_max", reinterpret_cast<Elf64_Addr>(&sched_get_priority_max)},
    {"sched_get_priority_min", reinterpret_cast<Elf64_Addr>(&sched_get_priority_min)},
    {"sched_getaffinity", reinterpret_cast<Elf64_Addr>(&sched_getaffinity)},
    {"sched_getparam", reinterpret_cast<Elf64_Addr>(&sched_getparam)},
    {"sched_getscheduler", reinterpret_cast<Elf64_Addr>(&sched_getscheduler)},
    {"sched_rr_get_interval", reinterpret_cast<Elf64_Addr>(&sched_rr_get_interval)},
    {"sched_setaffinity", reinterpret_cast<Elf64_Addr>(&sched_setaffinity)},
    {"sched_setparam", reinterpret_cast<Elf64_Addr>(&sched_setparam)},
    {"sched_setscheduler", reinterpret_cast<Elf64_Addr>(&sched_setscheduler)},
    {"sched_yield", reinterpret_cast<Elf64_Addr>(&sched_yield)},
    {"secure_getenv", reinterpret_cast<Elf64_Addr>(&secure_getenv)},
    {"select", reinterpret_cast<Elf64_Addr>(&select)},
    {"sem_clockwait", reinterpret_cast<Elf64_Addr>(&sem_clockwait)},
    {"sem_destroy", reinterpret_cast<Elf64_Addr>(&sem_destroy)},
    {"sem_init", reinterpret_cast<Elf64_Addr>(&sem_init)},
    {"sem_post", reinterpret_cast<Elf64_Addr>(&sem_post)},
    {"sem_trywait", reinterpret_cast<Elf64_Addr>(&sem_trywait)},
    {"sem_wait", reinterpret_cast<Elf64_Addr>(&sem_wait)},
    {"semctl", reinterpret_cast<Elf64_Addr>(&semctl)},
    {"send", reinterpret_cast<Elf64_Addr>(&send)},
    {"sendfile", reinterpret_cast<Elf64_Addr>(&sendfile)},
    {"sendfile64", reinterpret_cast<Elf64_Addr>(&sendfile64)},
    {"sendmmsg", reinterpret_cast<Elf64_Addr>(&sendmmsg)},
    {"sendmsg", reinterpret_cast<Elf64_Addr>(&sendmsg)},
    {"sendto", reinterpret_cast<Elf64_Addr>(&sendto)},
    {"setaliasent", reinterpret_cast<Elf64_Addr>(&setaliasent)},
    {"setbuf", reinterpret_cast<Elf64_Addr>(&setbuf)},
    {"setbuf", reinterpret_cast<Elf64_Addr>(&setbuf)},
    {"setbuffer", reinterpret_cast<Elf64_Addr>(&setbuffer)},
    {"setcontext", reinterpret_cast<Elf64_Addr>(&setcontext)},
    {"setdomainname", reinterpret_cast<Elf64_Addr>(&setdomainname)},
    {"setegid", reinterpret_cast<Elf64_Addr>(&setegid)},
    {"setenv", reinterpret_cast<Elf64_Addr>(&setenv)},
    {"seteuid", reinterpret_cast<Elf64_Addr>(&seteuid)},
    {"setfsgid", reinterpret_cast<Elf64_Addr>(&setfsgid)},
    {"setfsuid", reinterpret_cast<Elf64_Addr>(&setfsuid)},
    {"setgid", reinterpret_cast<Elf64_Addr>(&setgid)},
    {"setgrent", reinterpret_cast<Elf64_Addr>(&setgrent)},
    {"setgroups", reinterpret_cast<Elf64_Addr>(&setgroups)},
    {"sethostent", reinterpret_cast<Elf64_Addr>(&sethostent)},
    {"sethostname", reinterpret_cast<Elf64_Addr>(&sethostname)},
    {"setitimer", reinterpret_cast<Elf64_Addr>(&setitimer)},
    {"setlinebuf", reinterpret_cast<Elf64_Addr>(&setlinebuf)},
    {"setlocale", reinterpret_cast<Elf64_Addr>(&setlocale)},
    {"setlogmask", reinterpret_cast<Elf64_Addr>(&setlogmask)},
    {"setmntent", reinterpret_cast<Elf64_Addr>(&setmntent)},
    {"setnetent", reinterpret_cast<Elf64_Addr>(&setnetent)},
    {"setnetgrent", reinterpret_cast<Elf64_Addr>(&setnetgrent)},
    {"setns", reinterpret_cast<Elf64_Addr>(&setns)},
    {"setpgid", reinterpret_cast<Elf64_Addr>(&setpgid)},
    {"setpgrp", reinterpret_cast<Elf64_Addr>(&setpgrp)},
    {"setpriority", reinterpret_cast<Elf64_Addr>(&setpriority)},
    {"setprotoent", reinterpret_cast<Elf64_Addr>(&setprotoent)},
    {"setpwent", reinterpret_cast<Elf64_Addr>(&setpwent)},
    {"setregid", reinterpret_cast<Elf64_Addr>(&setregid)},
    {"setresgid", reinterpret_cast<Elf64_Addr>(&setresgid)},
    {"setresuid", reinterpret_cast<Elf64_Addr>(&setresuid)},
    {"setreuid", reinterpret_cast<Elf64_Addr>(&setreuid)},
    {"setrlimit", reinterpret_cast<Elf64_Addr>(&setrlimit)},
    {"setrlimit64", reinterpret_cast<Elf64_Addr>(&setrlimit64)},
    {"setrpcent", reinterpret_cast<Elf64_Addr>(&setrpcent)},
    {"setservent", reinterpret_cast<Elf64_Addr>(&setservent)},
    {"setsgent", reinterpret_cast<Elf64_Addr>(&setsgent)},
    {"setsid", reinterpret_cast<Elf64_Addr>(&setsid)},
    {"setsid", reinterpret_cast<Elf64_Addr>(&setsid)},
    {"setsockopt", reinterpret_cast<Elf64_Addr>(&setsockopt)},
    {"setspent", reinterpret_cast<Elf64_Addr>(&setspent)},
    {"settimeofday", reinterpret_cast<Elf64_Addr>(&settimeofday)},
    {"setuid", reinterpret_cast<Elf64_Addr>(&setuid)},
    {"setusershell", reinterpret_cast<Elf64_Addr>(&setusershell)},
    {"setutent", reinterpret_cast<Elf64_Addr>(&setutent)},
    {"setutxent", reinterpret_cast<Elf64_Addr>(&setutxent)},
    {"setvbuf", reinterpret_cast<Elf64_Addr>(&setvbuf)},
    {"setxattr", reinterpret_cast<Elf64_Addr>(&setxattr)},
    {"sgetspent", reinterpret_cast<Elf64_Addr>(&sgetspent)},
    {"shmat", reinterpret_cast<Elf64_Addr>(&shmat)},
    {"shmctl", reinterpret_cast<Elf64_Addr>(&shmctl)},
    {"shmdt", reinterpret_cast<Elf64_Addr>(&shmdt)},
    {"shmget", reinterpret_cast<Elf64_Addr>(&shmget)},
    {"shutdown", reinterpret_cast<Elf64_Addr>(&shutdown)},
    {"sigabbrev_np", reinterpret_cast<Elf64_Addr>(&sigabbrev_np)},
    {"sigaction", reinterpret_cast<Elf64_Addr>(&sigaction)},
    {"sigaddset", reinterpret_cast<Elf64_Addr>(&sigaddset)},
    {"sigaltstack", reinterpret_cast<Elf64_Addr>(&sigaltstack)},
    {"sigdelset", reinterpret_cast<Elf64_Addr>(&sigdelset)},
    {"sigemptyset", reinterpret_cast<Elf64_Addr>(&sigemptyset)},
    {"sigfillset", reinterpret_cast<Elf64_Addr>(&sigfillset)},
    {"sigfillset", reinterpret_cast<Elf64_Addr>(&sigfillset)},
    {"sigfillset", reinterpret_cast<Elf64_Addr>(&sigfillset)},
    {"sigisemptyset", reinterpret_cast<Elf64_Addr>(&sigisemptyset)},
    {"sigismember", reinterpret_cast<Elf64_Addr>(&sigismember)},
    {"signal", reinterpret_cast<Elf64_Addr>(&signal)},
    {"signalfd", reinterpret_cast<Elf64_Addr>(&signalfd)},
    {"sigpending", reinterpret_cast<Elf64_Addr>(&sigpending)},
    {"sigprocmask", reinterpret_cast<Elf64_Addr>(&sigprocmask)},
    {"sigqueue", reinterpret_cast<Elf64_Addr>(&sigqueue)},
    {"sigset", reinterpret_cast<Elf64_Addr>(&sigset)},
    {"sigsuspend", reinterpret_cast<Elf64_Addr>(&sigsuspend)},
    {"sigtimedwait", reinterpret_cast<Elf64_Addr>(&sigtimedwait)},
    {"sigwait", reinterpret_cast<Elf64_Addr>(&sigwait)},
    {"sigwaitinfo", reinterpret_cast<Elf64_Addr>(&sigwaitinfo)},
    {"sleep", reinterpret_cast<Elf64_Addr>(&sleep)},
    {"snprintf", reinterpret_cast<Elf64_Addr>(&snprintf)},
    {"socket", reinterpret_cast<Elf64_Addr>(&socket)},
    {"socketpair", reinterpret_cast<Elf64_Addr>(&socketpair)},
    {"splice", reinterpret_cast<Elf64_Addr>(&splice)},
    {"sprintf", reinterpret_cast<Elf64_Addr>(&sprintf)},
    {"sprintf", reinterpret_cast<Elf64_Addr>(&sprintf)},
    {"srand", reinterpret_cast<Elf64_Addr>(&srand)},
    {"srandom", reinterpret_cast<Elf64_Addr>(&srandom)},
    {"sscanf", reinterpret_cast<Elf64_Addr>(&sscanf)},
    {"stat", reinterpret_cast<Elf64_Addr>(&stat)},
    {"stat64", reinterpret_cast<Elf64_Addr>(&stat64)},
    {"statfs", reinterpret_cast<Elf64_Addr>(&statfs)},
    {"statfs", reinterpret_cast<Elf64_Addr>(&statfs)},
    {"statfs64", reinterpret_cast<Elf64_Addr>(&statfs64)},
    {"statvfs", reinterpret_cast<Elf64_Addr>(&statvfs)},
    {"statvfs64", reinterpret_cast<Elf64_Addr>(&statvfs64)},
    {"statx", reinterpret_cast<Elf64_Addr>(&statx)},
    {"stderr", reinterpret_cast<Elf64_Addr>(&stderr)},
    {"stdin", reinterpret_cast<Elf64_Addr>(&stdin)},
    {"stdout", reinterpret_cast<Elf64_Addr>(&stdout)},
    {"stpcpy", reinterpret_cast<Elf64_Addr>(&stpcpy)},
    {"stpncpy", reinterpret_cast<Elf64_Addr>(&stpncpy)},
    {"strcasecmp", reinterpret_cast<Elf64_Addr>(&strcasecmp)},
    {"strcasestr", reinterpret_cast<Elf64_Addr>(&strcasestr_c)},
    {"strcat", reinterpret_cast<Elf64_Addr>(&strcat)},
    {"strchr", reinterpret_cast<Elf64_Addr>(strchr_c)},
    {"strchrnul", reinterpret_cast<Elf64_Addr>(strchrnul_c)},
    {"strcmp", reinterpret_cast<Elf64_Addr>(&strcmp)},
    {"strcoll", reinterpret_cast<Elf64_Addr>(&strcoll)},
    {"strcpy", reinterpret_cast<Elf64_Addr>(&strcpy)},
    {"strcspn", reinterpret_cast<Elf64_Addr>(&strcspn)},
    {"strdup", reinterpret_cast<Elf64_Addr>(&strdup)},
    {"strdup", reinterpret_cast<Elf64_Addr>(&strdup)},
    {"strerror", reinterpret_cast<Elf64_Addr>(&strerror)},
    {"strerror_l", reinterpret_cast<Elf64_Addr>(&strerror_l)},
    {"strerror_r", reinterpret_cast<Elf64_Addr>(&strerror_r)},
    {"strftime", reinterpret_cast<Elf64_Addr>(&strftime)},
    {"strlen", reinterpret_cast<Elf64_Addr>(&strlen)},
    {"strncasecmp", reinterpret_cast<Elf64_Addr>(&strncasecmp)},
    {"strncat", reinterpret_cast<Elf64_Addr>(&strncat)},
    {"strncmp", reinterpret_cast<Elf64_Addr>(&strncmp)},
    {"strncpy", reinterpret_cast<Elf64_Addr>(&strncpy)},
    {"strndup", reinterpret_cast<Elf64_Addr>(&strndup)},
    {"strnlen", reinterpret_cast<Elf64_Addr>(&strnlen)},
    {"strpbrk", reinterpret_cast<Elf64_Addr>(strpbrk_c)},
    {"strptime", reinterpret_cast<Elf64_Addr>(&strptime)},
    {"strrchr", reinterpret_cast<Elf64_Addr>(strrchr_c)},
    {"strsep", reinterpret_cast<Elf64_Addr>(&strsep)},
    {"strsignal", reinterpret_cast<Elf64_Addr>(&strsignal)},
    {"strspn", reinterpret_cast<Elf64_Addr>(&strspn)},
    {"strstr", reinterpret_cast<Elf64_Addr>(strstr_c)},
    {"strtod", reinterpret_cast<Elf64_Addr>(&strtod)},
    {"strtod_l", reinterpret_cast<Elf64_Addr>(&strtod_l)},
    {"strtof", reinterpret_cast<Elf64_Addr>(&strtof)},
    {"strtoimax", reinterpret_cast<Elf64_Addr>(&strtoimax)},
    {"strtok", reinterpret_cast<Elf64_Addr>(&strtok)},
    {"strtok_r", reinterpret_cast<Elf64_Addr>(&strtok_r)},
    {"strtok_r", reinterpret_cast<Elf64_Addr>(&strtok_r)},
    {"strtol", reinterpret_cast<Elf64_Addr>(&strtol)},
    {"strtold", reinterpret_cast<Elf64_Addr>(&strtold)},
    {"strtold_l", reinterpret_cast<Elf64_Addr>(&strtold_l)},
    {"strtoll", reinterpret_cast<Elf64_Addr>(&strtoll)},
    {"strtoll_l", reinterpret_cast<Elf64_Addr>(&strtoll_l)},
    {"strtoul", reinterpret_cast<Elf64_Addr>(&strtoul)},
    {"strtoull", reinterpret_cast<Elf64_Addr>(&strtoull)},
    {"strtoull_l", reinterpret_cast<Elf64_Addr>(&strtoull_l)},
    {"strtoumax", reinterpret_cast<Elf64_Addr>(&strtoumax)},
    {"strverscmp", reinterpret_cast<Elf64_Addr>(&strverscmp)},
    {"strxfrm", reinterpret_cast<Elf64_Addr>(&strxfrm)},
    {"swapcontext", reinterpret_cast<Elf64_Addr>(&swapcontext)},
    {"symlink", reinterpret_cast<Elf64_Addr>(&symlink)},
    {"symlinkat", reinterpret_cast<Elf64_Addr>(&symlinkat)},
    {"sync", reinterpret_cast<Elf64_Addr>(&sync)},
    {"sync_file_range", reinterpret_cast<Elf64_Addr>(&sync_file_range)},
    {"syncfs", reinterpret_cast<Elf64_Addr>(&syncfs)},
    {"syscall", reinterpret_cast<Elf64_Addr>(&syscall)},
    {"sysconf", reinterpret_cast<Elf64_Addr>(&sysconf)},
    {"sysinfo", reinterpret_cast<Elf64_Addr>(&sysinfo)},
    {"system", reinterpret_cast<Elf64_Addr>(&system)},
    {"tcdrain", reinterpret_cast<Elf64_Addr>(&tcdrain)},
    {"tcflow", reinterpret_cast<Elf64_Addr>(&tcflow)},
    {"tcflush", reinterpret_cast<Elf64_Addr>(&tcflush)},
    {"tcflush", reinterpret_cast<Elf64_Addr>(&tcflush)},
    {"tcgetattr", reinterpret_cast<Elf64_Addr>(&tcgetattr)},
    {"tcgetpgrp", reinterpret_cast<Elf64_Addr>(&tcgetpgrp)},
    {"tcsetattr", reinterpret_cast<Elf64_Addr>(&tcsetattr)},
    {"tcsetpgrp", reinterpret_cast<Elf64_Addr>(&tcsetpgrp)},
    {"tdelete", reinterpret_cast<Elf64_Addr>(&tdelete)},
    {"tdestroy", reinterpret_cast<Elf64_Addr>(&tdestroy)},
    {"tempnam", reinterpret_cast<Elf64_Addr>(&tempnam)},
    {"textdomain", reinterpret_cast<Elf64_Addr>(&textdomain)},
    {"tfind", reinterpret_cast<Elf64_Addr>(&tfind)},
    {"time", reinterpret_cast<Elf64_Addr>(&time)},
    {"timegm", reinterpret_cast<Elf64_Addr>(&timegm)},
    {"timer_create", reinterpret_cast<Elf64_Addr>(&timer_create)},
    {"timer_delete", reinterpret_cast<Elf64_Addr>(&timer_delete)},
    {"timer_gettime", reinterpret_cast<Elf64_Addr>(&timer_gettime)},
    {"timer_settime", reinterpret_cast<Elf64_Addr>(&timer_settime)},
    {"timerfd_create", reinterpret_cast<Elf64_Addr>(&timerfd_create)},
    {"timerfd_settime", reinterpret_cast<Elf64_Addr>(&timerfd_settime)},
    {"times", reinterpret_cast<Elf64_Addr>(&times)},
    {"tmpfile", reinterpret_cast<Elf64_Addr>(&tmpfile)},
    {"tmpfile64", reinterpret_cast<Elf64_Addr>(&tmpfile64)},
    {"tolower", reinterpret_cast<Elf64_Addr>(&tolower)},
    {"toupper", reinterpret_cast<Elf64_Addr>(&toupper)},
    {"towlower", reinterpret_cast<Elf64_Addr>(&towlower)},
    {"towupper", reinterpret_cast<Elf64_Addr>(&towupper)},
    {"truncate", reinterpret_cast<Elf64_Addr>(&truncate)},
    {"truncate64", reinterpret_cast<Elf64_Addr>(&truncate64)},
    {"tsearch", reinterpret_cast<Elf64_Addr>(&tsearch)},
    {"ttyname", reinterpret_cast<Elf64_Addr>(&ttyname)},
    {"ttyname_r", reinterpret_cast<Elf64_Addr>(&ttyname_r)},
    {"twalk", reinterpret_cast<Elf64_Addr>(&twalk)},
    {"tzname", reinterpret_cast<Elf64_Addr>(&tzname)},
    {"tzset", reinterpret_cast<Elf64_Addr>(&tzset)},
    {"ulckpwdf", reinterpret_cast<Elf64_Addr>(&ulckpwdf)},
    {"umask", reinterpret_cast<Elf64_Addr>(&umask)},
    {"umount", reinterpret_cast<Elf64_Addr>(&umount)},
    {"umount2", reinterpret_cast<Elf64_Addr>(&umount2)},
    {"uname", reinterpret_cast<Elf64_Addr>(&uname)},
    {"uname", reinterpret_cast<Elf64_Addr>(&uname)},
    {"ungetc", reinterpret_cast<Elf64_Addr>(&ungetc)},
    {"ungetwc", reinterpret_cast<Elf64_Addr>(&ungetwc)},
    {"unlink", reinterpret_cast<Elf64_Addr>(&unlink)},
    {"unlinkat", reinterpret_cast<Elf64_Addr>(&unlinkat)},
    {"unlockpt", reinterpret_cast<Elf64_Addr>(&unlockpt)},
    {"unsetenv", reinterpret_cast<Elf64_Addr>(&unsetenv)},
    {"unshare", reinterpret_cast<Elf64_Addr>(&unshare)},
    {"updwtmpx", reinterpret_cast<Elf64_Addr>(&updwtmpx)},
    {"uselocale", reinterpret_cast<Elf64_Addr>(&uselocale)},
    {"usleep", reinterpret_cast<Elf64_Addr>(&usleep)},
    {"utime", reinterpret_cast<Elf64_Addr>(&utime)},
    {"utimensat", reinterpret_cast<Elf64_Addr>(&utimensat)},
    {"utimes", reinterpret_cast<Elf64_Addr>(&utimes)},
    {"utmpxname", reinterpret_cast<Elf64_Addr>(&utmpxname)},
    {"vasprintf", reinterpret_cast<Elf64_Addr>(&vasprintf)},
    {"versionsort", reinterpret_cast<Elf64_Addr>(&versionsort)},
    {"vfork", reinterpret_cast<Elf64_Addr>(&vfork)},
    {"vfprintf", reinterpret_cast<Elf64_Addr>(&vfprintf)},
    {"vmsplice", reinterpret_cast<Elf64_Addr>(&vmsplice)},
    {"vsnprintf", reinterpret_cast<Elf64_Addr>(&vsnprintf)},
    {"wait", reinterpret_cast<Elf64_Addr>(&wait)},
    {"wait3", reinterpret_cast<Elf64_Addr>(&wait3)},
    {"wait4", reinterpret_cast<Elf64_Addr>(&wait4)},
    {"waitid", reinterpret_cast<Elf64_Addr>(&waitid)},
    {"waitpid", reinterpret_cast<Elf64_Addr>(&waitpid)},
    {"warn", reinterpret_cast<Elf64_Addr>(&warn)},
    {"warnx", reinterpret_cast<Elf64_Addr>(&warnx)},
    {"wcrtomb", reinterpret_cast<Elf64_Addr>(&wcrtomb)},
    {"wcscat", reinterpret_cast<Elf64_Addr>(&wcscat)},
    {"wcschr", reinterpret_cast<Elf64_Addr>(&wcschr_c)},
    {"wcscmp", reinterpret_cast<Elf64_Addr>(&wcscmp)},
    {"wcscoll", reinterpret_cast<Elf64_Addr>(&wcscoll)},
    {"wcscpy", reinterpret_cast<Elf64_Addr>(&wcscpy)},
    {"wcscspn", reinterpret_cast<Elf64_Addr>(&wcscspn)},
    {"wcsdup", reinterpret_cast<Elf64_Addr>(&wcsdup)},
    {"wcsftime", reinterpret_cast<Elf64_Addr>(&wcsftime)},
    {"wcslen", reinterpret_cast<Elf64_Addr>(&wcslen)},
    {"wcsncat", reinterpret_cast<Elf64_Addr>(&wcsncat)},
    {"wcsncmp", reinterpret_cast<Elf64_Addr>(&wcsncmp)},
    {"wcsncpy", reinterpret_cast<Elf64_Addr>(&wcsncpy)},
    {"wcsnlen", reinterpret_cast<Elf64_Addr>(&wcsnlen)},
    {"wcsnrtombs", reinterpret_cast<Elf64_Addr>(&wcsnrtombs)},
    {"wcspbrk", reinterpret_cast<Elf64_Addr>(&wcspbrk_c)},
    {"wcsrchr", reinterpret_cast<Elf64_Addr>(&wcsrchr_c)},
    {"wcsrtombs", reinterpret_cast<Elf64_Addr>(&wcsrtombs)},
    {"wcsstr", reinterpret_cast<Elf64_Addr>(&wcsstr_c)},
    {"wcstok", reinterpret_cast<Elf64_Addr>(&wcstok)},
    {"wcstol", reinterpret_cast<Elf64_Addr>(&wcstol)},
    {"wcstombs", reinterpret_cast<Elf64_Addr>(&wcstombs)},
    {"wcswidth", reinterpret_cast<Elf64_Addr>(&wcswidth)},
    {"wcsxfrm", reinterpret_cast<Elf64_Addr>(&wcsxfrm)},
    {"wctob", reinterpret_cast<Elf64_Addr>(&wctob)},
    {"wctomb", reinterpret_cast<Elf64_Addr>(&wctomb)},
    {"wctype", reinterpret_cast<Elf64_Addr>(&wctype)},
    {"wcwidth", reinterpret_cast<Elf64_Addr>(&wcwidth)},
    {"wmemchr", reinterpret_cast<Elf64_Addr>(&wmemchr_c)},
    {"wmemcmp", reinterpret_cast<Elf64_Addr>(&wmemcmp)},
    {"wmemcpy", reinterpret_cast<Elf64_Addr>(&wmemcpy)},
    {"wmemmove", reinterpret_cast<Elf64_Addr>(&wmemmove)},
    {"wmemset", reinterpret_cast<Elf64_Addr>(&wmemset)},
    {"write", reinterpret_cast<Elf64_Addr>(&write)},
    {"writev", reinterpret_cast<Elf64_Addr>(&writev)},
};
}  // namespace libc_mapping