/* Copyright (C) 1991,1994,1995,1996,1998,2001 Free Software Foundation, Inc.

   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, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

#
# For demonstration purposes in the abicheck project, the following
# information was taken from all of the "Versions" files in the GNU C
# Library source (which is under the copyright of the Free Software
# Foundation, Inc.) and modified to show how the public/private
# classification might appear.
#

#------------------------------------------------------------------------
# FILE: sysdeps/alpha/fpu/Versions
#
libc {
  GLIBC_2.0 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # functions used in other libraries
    __ieee_get_fp_control; __ieee_set_fp_control;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/alpha/Versions
#
libc {
  GLIBC_2.0 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # functions with special/multiple interfaces
    __divqu; __remqu; __divqs; __remqs; __divlu; __remlu; __divls;
    __remls; __divl; __reml; __divq; __remq; __divqu; __remqu;
  }
}
libm {
  GLIBC_2.0 {
    # used in inline functions.
    __atan2;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/hppa/Versions
#
ld {
  GLIBC_2.2 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.2)
    # hppa specific functions in the dynamic linker, but used by libc.so.
    _dl_symbol_address; _dl_unmap; _dl_lookup_address;
    _dl_function_address;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/i386/i686/Versions
#
ld {
  GLIBC_2.2.3 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.2.3)
    _dl_cpuclock_offset;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/i386/Versions
#
libc {
  GLIBC_2.0 {
    # Functions from libgcc.
    __divdi3; __moddi3; __udivdi3; __umoddi3;
  }
  GLIBC_2.1 {
    # empty now
  }
  GLIBC_2.1.1 {
    # extern inline functions used by <bits/string.h>
    __memcpy_c; __memset_cc; __memset_cg; __memset_gg; __strchr_c; __strchr_g;
    __strchrnul_c; __strchrnul_g;
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.1)
    # global variable
    _fp_hw;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/i386/fpu/Versions
#
libm {
  GLIBC_2.2 {
    # functions used in inline functions or macros
    __expl; __expm1l;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/i386/i486/Versions
#
libc {
  GLIBC_2.1.1 {
    # extern inline functions used by <bits/string.h>
    __memcpy_by2; __memcpy_by4; __memcpy_g; __mempcpy_by2; __mempcpy_by4;
    __mempcpy_byn; __memset_ccn_by2; __memset_ccn_by4; __memset_gcn_by2;
    __memset_gcn_by4; __stpcpy_g; __strcat_c; __strcat_g; __strchr_c;
    __strchr_g; __strchrnul_c; __strchrnul_g; __strcmp_gg; __strcpy_g;
    __strcspn_c1; __strcspn_cg; __strcspn_g; __strlen_g; __strncat_g;
    __strncmp_g; __strncpy_by2; __strncpy_by4; __strncpy_byn; __strncpy_gg;
    __strpbrk_cg; __strpbrk_g; __strrchr_c; __strrchr_g; __strspn_c1;
    __strspn_cg; __strspn_g; __strstr_cg; __strstr_g;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/ia64/fpu/Versions
#
libc {
  GLIBC_2.2.3 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.2.3)
    __libm_frexp_4; __libm_frexp_4f; __libm_frexp_4l; __libm_error_support;
  }
}
libm {
  GLIBC_2.2.3 {
    matherrf; matherrl;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/ia64/Versions
#
ld {
  GLIBC_2.2 {
    # empty now
  }
  GLIBC_2.2.3 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.2)
    # ia64 specific functions in the dynamic linker, but used by libc.so.
    _dl_symbol_address; _dl_unmap; _dl_lookup_address;
    _dl_function_address;

    # (introduced GLIBC_2.2.3)
    _dl_cpuclock_offset;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/m68k/Versions
#
libc {
  GLIBC_2.0 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # Functions from libgcc.
    __divdi3; __moddi3; __udivdi3; __umoddi3;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/mach/hurd/i386/Versions
#
libc {
  GLIBC_2.0 {
    # Exception handling support functions from libgcc
    __register_frame; __register_frame_table; __deregister_frame;
    __register_frame_info; __deregister_frame_info; __frame_state_for;
    __register_frame_info_table;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/mach/hurd/Versions
#
libc {
  GLIBC_2.0 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # functions with a weak definition in the dynamic linker
    __getcwd; __mmap;
  }
}

ld {
  GLIBC_2.0 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # variables that must be shared with libc
    __hurd_sigthread_stack_base; __hurd_sigthread_stack_end;
    __hurd_sigthread_variables;
    __hurd_threadvar_stack_mask;  __hurd_threadvar_stack_offset;

    # functions that must be shared with libc
    __close; __fxstat; __getcwd; __getpid; __libc_read; __libc_write;
    __lseek; __mmap; __open; __xstat;
    _exit; _hurd_intr_rpc_mach_msg;
    abort;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/powerpc/soft-fp/Versions
#
libc {
  GLIBC_2.2 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.2)
    _q_add; _q_cmp; _q_cmpe; _q_div; _q_dtoq; _q_feq; _q_fge; _q_fgt;
    _q_fle; _q_flt; _q_fne; _q_itoq; _q_mul; _q_neg; _q_qtod; _q_qtoi;
    _q_qtos; _q_qtou; _q_sqrt; _q_stoq; _q_sub;
    _q_utoq; 
    _q_lltoq; _q_qtoll; _q_qtoull; _q_ulltoq;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/powerpc/Versions
#
libm {
  GLIBC_2.1 {
    # symbols used in macros from sysdeps/powerpc/bits/fenv.h
    __fe_dfl_env; __fe_enabled_env; __fe_nonieee_env; __fe_nomask_env;
  }
  GLIBC_2.2 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.2)
    # Special functions to save and restore registers used by the
    # runtime libraries.
    _restgpr0_13; _restgpr0_14; _restgpr0_15; _restgpr0_16; _restgpr0_17;
    _restgpr0_18; _restgpr0_19; _restgpr0_20; _restgpr0_21; _restgpr0_22;
    _restgpr0_22; _restgpr0_23; _restgpr0_24; _restgpr0_25; _restgpr0_26;
    _restgpr0_27; _restgpr0_28; _restgpr0_29; _restgpr0_30; _restgpr0_31;
    _savegpr0_13; _savegpr0_14; _savegpr0_15; _savegpr0_16; _savegpr0_17;
    _savegpr0_18; _savegpr0_19; _savegpr0_20; _savegpr0_21; _savegpr0_22;
    _savegpr0_22; _savegpr0_23; _savegpr0_24; _savegpr0_25; _savegpr0_26;
    _savegpr0_27; _savegpr0_28; _savegpr0_29; _savegpr0_30; _savegpr0_31;
    _restgpr1_13; _restgpr1_14; _restgpr1_15; _restgpr1_16; _restgpr1_17;
    _restgpr1_18; _restgpr1_19; _restgpr1_20; _restgpr1_21; _restgpr1_22;
    _restgpr1_22; _restgpr1_23; _restgpr1_24; _restgpr1_25; _restgpr1_26;
    _restgpr1_27; _restgpr1_28; _restgpr1_29; _restgpr1_30; _restgpr1_31;
    _savegpr1_13; _savegpr1_14; _savegpr1_15; _savegpr1_16; _savegpr1_17;
    _savegpr1_18; _savegpr1_19; _savegpr1_20; _savegpr1_21; _savegpr1_22;
    _savegpr1_22; _savegpr1_23; _savegpr1_24; _savegpr1_25; _savegpr1_26;
    _savegpr1_27; _savegpr1_28; _savegpr1_29; _savegpr1_30; _savegpr1_31;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/s390/s390-32/Versions
#
libc {
  GLIBC_2.0 {
    # Functions from libgcc.
    __divdi3; __moddi3; __udivdi3; __umoddi3;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/sparc/sparc32/Versions
#
libc {
  GLIBC_2.0 {
    .div; .mul; .rem; .udiv; .umul; .urem;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/sparc/sparc64/soft-fp/Versions
#
libc {
  GLIBC_2.2 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.2)
    _Qp_add; _Qp_cmp; _Qp_cmpe; _Qp_div; _Qp_dtoq; _Qp_feq; _Qp_fge; _Qp_fgt;
    _Qp_fle; _Qp_flt; _Qp_fne; _Qp_itoq; _Qp_mul; _Qp_neg; _Qp_qtod; _Qp_qtoi;
    _Qp_qtos; _Qp_qtoui; _Qp_qtoux; _Qp_qtox; _Qp_sqrt; _Qp_stoq; _Qp_sub;
    _Qp_uitoq; _Qp_uxtoq; _Qp_xtoq; __Qp_handle_exceptions;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/sparc/sparc64/Versions
#
libc {
  GLIBC_2.1.1 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.1.1)
    # SPARC v9 SYSV ABI helper functions
    __align_cpy_1; __align_cpy_2; __align_cpy_4;
    __align_cpy_8; __align_cpy_16;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/sparc/Versions
#
ld {
  GLIBC_2.2.3 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.2.3)
    # If this symbol is ever available on SPARC it was introduced in 2.2.3.
    _dl_cpuclock_offset;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/unix/sysv/aix/Versions
#
libc {
  GLIBC_2.2 {
    # u*
    umount;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/unix/sysv/linux/alpha/Versions
#
libc {
  GLIBC_2.0 {
    # Unfortunately in wider use.
    _inb; _inw; _inl; _outb; _outw; _outl; _bus_base; _bus_base_sparse;
    _hae_shift;

    # Exception handling support functions from libgcc
    __register_frame; __register_frame_table; __deregister_frame;
    __register_frame_info; __deregister_frame_info; __frame_state_for;
    __register_frame_info_table;

    # b*
    bus_base; bus_base_sparse;

    # h*
    hae_shift;

    # i*
    inb; inl; inw; ioperm; iopl;

    # o*
    outb; outl; outw;

    # p*
    pciconfig_read; pciconfig_write; sethae;
  }
  GLIBC_2.1 {
    # Linux/Alpha 64-bit timeval functions.
    __select; select;
    adjtime; adjtimex; __adjtimex;
    __gettimeofday;

    # glob interface change
    glob; globfree;

    # limit type change
    getrusage;

    # time type change
    gettimeofday; getitimer;

    # i*
    ieee_get_fp_control; ieee_set_fp_control;

    # s*
    setitimer; settimeofday;

    # u*
    utimes;

    # w*
    wait4;
  }
  GLIBC_2.1.4 {
    pciconfig_iobase;
  }
  GLIBC_2.2.2 {
    # w*
    wordexp;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/unix/sysv/linux/arm/Versions
#
libc {
  GLIBC_2.0 {
    # Exception handling support functions from libgcc
    __register_frame; __register_frame_table; __deregister_frame;
    __register_frame_info; __deregister_frame_info; __frame_state_for;
    __register_frame_info_table;
  }
  GLIBC_2.1 {
    ioperm; iopl;
    inb; inw; inl;
    outb; outw; outl;
  }
  GLIBC_2.2 {
    # functions used in other libraries
    __xstat64; __fxstat64; __lxstat64;

    # a*
    alphasort64;

    # g*
    glob64;

    # New rlimit interface
    getrlimit; setrlimit; getrlimit64;

    # r*
    readdir64; readdir64_r;

    # s*
    scandir64;

    # v*
    versionsort64;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/unix/sysv/linux/hppa/Versions
#
libc {
  GLIBC_2.2 {
    # New rlimit interface
    getrlimit; setrlimit; getrlimit64; setrlimit64;
  }
}
#------------------------------------------------------------------------
# FILE: sysdeps/unix/sysv/linux/i386/Versions
#
libc {
  GLIBC_2.0 {
    # Exception handling support functions from libgcc
    __register_frame; __register_frame_table; __deregister_frame;
    __register_frame_info; __deregister_frame_info; __frame_state_for;
    __register_frame_info_table;

    ioperm; iopl;

    vm86;
  }
  GLIBC_2.1 {
    __modify_ldt; modify_ldt;
  }
  GLIBC_2.2 {
    # functions used in other libraries
    __xstat64; __fxstat64; __lxstat64;

    # a*
    alphasort64;

    # g*
    glob64;

    # New rlimit interface
    getrlimit; setrlimit; getrlimit64;

    # r*
    readdir64; readdir64_r;

    # s*
    scandir64;

    # v*
    versionsort64;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/unix/sysv/linux/ia64/Versions
#
ld {
  GLIBC_2.2 {
    # empty now
  }
  GLIBC_2.2.1 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.2)
    # global variables needed in the libc.
    _dl_pagesize;

    # (introduced GLIBC_2.2.1)
    _dl_var_init;
  }
}
libc {
  GLIBC_2.2 {
    ioperm; iopl;
    inb; inw; inl;
    _inb; _inw; _inl;
    outb; outw; _outl;
    _outb; _outw; _outl;
    pciconfig_read; pciconfig_write;

  }
  GLIBC_2.2.2 {
    # w*
    wordexp;
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.2)
    # linuxthreads
    __clone2;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/unix/sysv/linux/m68k/Versions
#
libc {
  GLIBC_2.0 {
    # Exception handling support functions from libgcc
    __register_frame; __register_frame_table; __deregister_frame;
    __register_frame_info; __deregister_frame_info; __frame_state_for;
    __register_frame_info_table;

    # c*
    cacheflush;
  }
  GLIBC_2.2 {
    # functions used in other libraries
    __xstat64; __fxstat64; __lxstat64;

    # a*
    alphasort64;

    # g*
    glob64;

    # New rlimit interface
    getrlimit; setrlimit; getrlimit64;

    # r*
    readdir64; readdir64_r;

    # s*
    scandir64;

    # v*
    versionsort64;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/unix/sysv/linux/mips/Versions
#
libc {
  GLIBC_2.0 {
    # Exception handling support functions from libgcc
    __register_frame; __register_frame_table; __deregister_frame;
    __register_frame_info; __deregister_frame_info; __frame_state_for;
    __register_frame_info_table;

    # c*
    cachectl; cacheflush;

    # s*
    sysmips;
  }
  GLIBC_2.2 {
    # _*
    _test_and_set;
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # Needed by gcc:
    _flush_cache;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/unix/sysv/linux/powerpc/Versions
#
libc {
  GLIBC_2.0 {
    # Exception handling support functions from libgcc
    __register_frame; __register_frame_table; __deregister_frame;
    __register_frame_info; __deregister_frame_info; __frame_state_for;
    __register_frame_info_table;
  }
  GLIBC_2.2 {
    # functions used in other libraries
    __xstat64; __fxstat64; __lxstat64;

    # g*
    glob64;

    # New rlimit interface
    getrlimit; setrlimit; getrlimit64; setrlimit64;

    # r*
    readdir64; readdir64_r;

    # s*
    scandir64;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/unix/sysv/linux/s390/s390-32/Versions
#
libc {
  GLIBC_2.0 {
    # Exception handling support functions from libgcc
    __register_frame; __register_frame_table; __deregister_frame;
    __register_frame_info; __deregister_frame_info; __frame_state_for;
    __register_frame_info_table;
  }
  GLIBC_2.2 {
    # functions used in other libraries
    __xstat64; __fxstat64; __lxstat64;

    # a*
    alphasort64;

    # New rlimit interface
    getrlimit; setrlimit; getrlimit64;

    # r*
    readdir64; readdir64_r;

    # s*
    scandir64;

    # v*
    versionsort64;
  }
}


#------------------------------------------------------------------------
# FILE: sysdeps/unix/sysv/linux/sh/Versions
#
libc {
  GLIBC_2.2 {
    # functions used in other libraries
    __xstat64; __fxstat64; __lxstat64;

    # a*
    alphasort64;

    # g*
    glob64;

    # New rlimit interface
    getrlimit; setrlimit; getrlimit64;

    # r*
    readdir64; readdir64_r;

    # s*
    scandir64;

    # v*
    versionsort64;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/unix/sysv/linux/sparc/sparc32/Versions
#
libc {
  GLIBC_2.0 {
    # Exception handling support functions from libgcc
    __register_frame; __register_frame_table; __deregister_frame;
    __register_frame_info; __deregister_frame_info; __frame_state_for;
    __register_frame_info_table;
  }
  GLIBC_2.2 {
    # functions used in other libraries
    __xstat64; __fxstat64; __lxstat64;

    # g*
    glob64;

    # r*
    readdir64; readdir64_r;

    # s*
    scandir64;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/unix/sysv/linux/sparc/sparc64/Versions
#
libc {
  GLIBC_2.0 {
    # Exception handling support functions from libgcc
    __register_frame; __register_frame_table; __deregister_frame;
    __register_frame_info; __deregister_frame_info; __frame_state_for;
    __register_frame_info_table;
  }
  GLIBC_2.2.2 {
    # w*
    wordexp;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/unix/sysv/linux/Versions
#
libc {
  GLIBC_2.0 {
    # functions used in inline functions or macros
    __cmsg_nxthdr;

    # helper functions
    __errno_location;

    # b*
    bdflush;

    # c*
    clone; create_module;

    # d*
    delete_module;

    # g*
    get_kernel_syms; getresgid; getresuid;

    # i*
    init_module;

    # k*
    klogctl;

    # l*
    llseek;

    # m*
    mremap;

    # n*
    nfsservctl;

    # p*
    personality; prctl;

    # q*
    query_module; quotactl;

    # s*
    setfsgid; setfsuid;

    # s*
    setresgid; setresuid; swapoff; swapon; sysctl;

    # u*
    umount; uselib;
  }
  GLIBC_2.1 {
    # functions used in inline functions or macros
    __libc_sa_len;

    # Since we have new signals this structure changed.
    _sys_siglist; sys_siglist; sys_sigabbrev;

    # New errlist.
    _sys_errlist; sys_errlist; _sys_nerr; sys_nerr;

    # chown interface change.
    chown;

    # Change in pthread_attr_t.
    pthread_attr_init;

    # c*
    capget; capset;

    # n*
    ntp_adjtime; ntp_gettime;

    # s*
    sendfile;

    # u*
    umount2;
  }
  GLIBC_2.2 {
    # ipc ctl interface change.
    semctl; shmctl; msgctl;
  }
  GLIBC_2.2.1 {
    # p*
    pivot_root;
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # functions used in other libraries
    __clone;


    # (introduced GLIBC_2.1)
    # functions used in other libraries
    __syscall_rt_sigqueueinfo;


    # (introduced GLIBC_2.2)
    # needed in other libraries.
    __endmntent; __getmntent_r; __setmntent; __statfs; __libc_sigaction;
    __sysctl;
  }
}

#------------------------------------------------------------------------
# FILE: sysdeps/unix/sysv/Versions
#
libc {
  GLIBC_2.0 {
    sysinfo;
  }
}

#------------------------------------------------------------------------
# FILE: csu/Versions
#
libc {
  GLIBC_2.0 {
    # variables in normal name space
    errno;
  }
  GLIBC_2.1 {
    # New special glibc functions.
    gnu_get_libc_release; gnu_get_libc_version;
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # global variables
    _errno;

    # helper functions
    __libc_init_first; __libc_start_main;
  }
}

#------------------------------------------------------------------------
# FILE: argp/Versions
#
libc {
  GLIBC_2.1 {
    # variables in normal name space
    argp_err_exit_status; argp_program_bug_address; argp_program_version;
    argp_program_version_hook;

    # a*
    argp_error; argp_failure; argp_help; argp_parse; argp_state_help;
    argp_usage;

  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.1)
    # kludge for recursive argp callers that know the magic.
    _argp_unlock_xxx;
  }
}

#------------------------------------------------------------------------
# FILE: assert/Versions
#
libc {
  GLIBC_2.0 {
    # functions used in inline functions or macros
    __assert_fail; __assert_perror_fail;
  }
  GLIBC_2.2 {
    # just for standard compliance
    __assert;
  }
}

#------------------------------------------------------------------------
# FILE: catgets/Versions
#
libc {
  GLIBC_2.0 {
    # functions with required interface outside normal name space
    __open_catalog;

    # c*
    catclose; catgets; catopen;
  }
}

#------------------------------------------------------------------------
# FILE: crypt/Versions
#
libcrypt {
  GLIBC_2.0 {
    crypt; crypt_r; encrypt; encrypt_r; fcrypt; setkey; setkey_r;
  }
}

#------------------------------------------------------------------------
# FILE: ctype/Versions
#
libc {
  GLIBC_2.0 {
    # global variables
    __ctype_b; __ctype32_b; __ctype_tolower; __ctype_toupper;
    _tolower; _toupper;

    # i*
    isalnum; isalpha; isascii; isblank; iscntrl; isdigit; isgraph; islower;
    isprint; ispunct; isspace; isupper; isxdigit;

    # t*
    toascii; tolower; toupper;
  }
  GLIBC_2.2 {
    # global variables
    __ctype32_tolower; __ctype32_toupper;
  }
}

#------------------------------------------------------------------------
# FILE: debug/Versions
#
libc {
  GLIBC_2.1 {
    # b*
    backtrace; backtrace_symbols; backtrace_symbols_fd;
  }
  GLIBC_2.2 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.1)
    # functions used in other libraries
    __backtrace; __backtrace_symbols; __backtrace_symbols_fd;


    # (introduced GLIBC_2.2)
    # These are to support some gcc features.
    __cyg_profile_func_enter; __cyg_profile_func_exit;
  }
}

#------------------------------------------------------------------------
# FILE: dirent/Versions
#
libc {
  GLIBC_2.0 {
    # a*
    alphasort;

    # c*
    closedir;

    # d*
    dirfd;

    # g*
    getdirentries;

    # o*
    opendir;

    # r*
    readdir; readdir_r; rewinddir;

    # s*
    scandir; seekdir;

    # t*
    telldir;
  }
  GLIBC_2.1 {
    # a*
    alphasort64;

    # r*
    readdir64; readdir64_r;

    # s*
    scandir64;

    # v*
    versionsort; versionsort64;
  }
  GLIBC_2.2 {
    # g*
    getdirentries64;
  }
}

#------------------------------------------------------------------------
# FILE: dlfcn/Versions
#
libdl {
  GLIBC_2.0 {
    dladdr; dlclose; dlerror; dlopen; dlsym;
  }
  GLIBC_2.1 {
    dlopen; dlvsym;
  }
}

#------------------------------------------------------------------------
# FILE: elf/Versions
#
libc {
  GLIBC_2.0 {
    # empty now
  }
  GLIBC_2.1 {
    # empty now
  }
  GLIBC_2.2 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # functions used in other libraries
    _dl_open; _dl_close; _dl_addr;

    # (introduced GLIBC_2.1)
    # functions used in other libraries
    _dl_mcount_wrapper; _dl_mcount_wrapper_check;

    # (introduced GLIBC_2.2)
    # this is defined in ld.so and overridden by libc
    _dl_init_first;

    # functions used in other libraries
    _dl_sym; _dl_vsym;
  }
}

ld {
  GLIBC_2.0 {
    # Function from libc.so which must be shared with libc.
    calloc; free; malloc; realloc;
  }
  GLIBC_2.1 {
    # empty now
  }
  GLIBC_2.1.1 {
    # empty now
  }
  GLIBC_2.2 {
    # empty now
  }
  GLIBC_2.2.3 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # global variables
    _dl_debug_fd;

    # Those are in the dynamic linker, but used by libc.so.
    __libc_enable_secure; _dl_catch_error; _dl_check_all_versions;
    _dl_debug_initialize; _dl_debug_state; _dl_default_scope;
    _dl_global_scope_end; _dl_lookup_symbol;
    _dl_map_object; _dl_map_object_deps; _dl_object_relocation_scope;
    _dl_relocate_object; _dl_signal_error; _dl_starting_up;
    _dl_sysdep_start; _r_debug;
    _dl_global_scope; _dl_lookup_symbol_skip;
    _dl_lookup_versioned_symbol; _dl_lookup_versioned_symbol_skip;


    # (introduced GLIBC_2.1)
    # global variables
    _dl_profile; _dl_profile_map; _dl_profile_output; _dl_start_profile;
    _dl_loaded; _dl_main_searchlist; _dl_fpu_control; _dl_initial_searchlist;
    _dl_global_scope_alloc; __libc_stack_end;

    # functions used in other libraries
    _dl_mcount; _dl_unload_cache;

    # (introduced GLIBC_2.1.1)
    # global variables
    _dl_lazy; _dl_origin_path; _dl_platformlen;

    # functions used in other libraries
    _dl_dst_count; _dl_dst_substitute;

    # (introduced GLIBC_2.2)
    _dl_init; _dl_load_lock; _dl_argv; _dl_nloaded; _dl_check_map_versions;

    # this is defined in ld.so and overridden by libc
    _dl_init_first;

    # variables used elsewhere
    _dl_out_of_memory; _dl_all_dirs; _dl_init_all_dirs;
    _dl_clktck; _dl_pagesize;

    # (introduced GLIBC_2.2.3)
    _dl_debug_mask; _dl_debug_printf;
  }
}

#------------------------------------------------------------------------
# FILE: gmon/Versions
#
libc {
  GLIBC_2.0 {
    # Profiling support
    __monstartup; _mcleanup; __profile_frequency;

    # m*
    monstartup;

    # p*
    profil; profil_counter;
  }
  GLIBC_2.2 {
    # m*
    moncontrol;
  }
  GLIBC_2.2.3 {
    sprofil;
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # functions with special/multiple interfaces
    _mcount;
  }
}

#------------------------------------------------------------------------
# FILE: grp/Versions
#
libc {
  GLIBC_2.0 {
    # e*
    endgrent;

    # f*
    fgetgrent; fgetgrent_r;

    # g*
    getgrent; getgrent_r; getgrgid; getgrgid_r; getgrnam; getgrnam_r;
    getgroups;

    # i*
    initgroups;

    # s*
    setgrent; setgroups;
  }
  GLIBC_2.1 {
    # p*
    putgrent;
  }
  GLIBC_2.1.2 {
    # g*
    getgrent_r; getgrgid_r; getgrnam_r;
  }
}

#------------------------------------------------------------------------
# FILE: hesiod/Versions
#
libnss_hesiod {
  GLIBC_2.1 {
    # empty now
  }
  GLIBC_2.2 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.1)
    _nss_hesiod_setpwent; _nss_hesiod_endpwent;
    _nss_hesiod_getpwnam_r; _nss_hesiod_getpwuid_r;
    _nss_hesiod_setgrent; _nss_hesiod_endgrent;
    _nss_hesiod_getgrnam_r; _nss_hesiod_getgrgid_r;
    _nss_hesiod_setservent; _nss_hesiod_endservent;
    _nss_hesiod_getservbyname_r;

    # (introduced GLIBC_2.2)
    _nss_hesiod_initgroups_dyn;
    _nss_hesiod_getservbyport_r;
    _nss_hesiod_setprotoent; _nss_hesiod_endprotoent;
    _nss_hesiod_getprotobyname_r; _nss_hesiod_getprotobynumber_r;
  }
}

#------------------------------------------------------------------------
# FILE: hurd/Versions
#
%define SHARED
%include <shlib-compat.h>

libc {

%if !SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_2)
  HURD_CTHREADS_0.3 {
    # weak refs to libthreads functions that libc calls iff libthreads in use
    cthread_fork; cthread_detach;

    # variables used for detecting cthreads
    _cthread_exit_routine; _cthread_init_routine;

    # cthreads functions with stubs in libc
    cthread_keycreate; cthread_getspecific; cthread_setspecific;
    __libc_getspecific;
  }
%endif
  GLIBC_2.0 {
%if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_1)
%endif
%if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_2)
    # cthreads functions with stubs in libc
    cthread_keycreate; cthread_getspecific; cthread_setspecific;
    __libc_getspecific;
%endif

    # functions in normal name space

    # f*
    file_name_lookup; file_name_lookup_under; file_name_path_lookup;
    file_name_split;
    fopenport;

    # g*
    get_privileged_ports;
    getauth; getcrdir; getcwdir; getcttyid; getdport; getproc; getumask;

    # h*
    hurd_catch_signal;
    hurd_check_cancel;
    hurd_file_name_lookup; hurd_file_name_lookup_retry;
    hurd_file_name_path_lookup; hurd_file_name_split;
    hurd_preempt_signals;
    hurd_safe_copyin; hurd_safe_copyout;
    hurd_safe_memmove; hurd_safe_memset;
    hurd_sig_post;
    hurd_thread_cancel; hurd_thread_self;
    hurd_unpreempt_signals;

    # o*
    openport;

    # p*
    pid2task;

    # s*
    setauth; setcrdir; setcwdir; setproc; setcttyid;

    # t*
    task2pid;

    # v*
    vpprintf;
  }
  GLIBC_2.1 {
    # g*
    geteuids;

    # s*
    seteuids;
  }
  GLIBC_2.1.3 {
%if SHLIB_COMPAT (libc, GLIBC_2_1_3, HURD_CTHREADS_0_3)
    # c*
    cthread_fork; cthread_detach;
%endif

    # d*
    directory_name_split;

    # h*
    hurd_directory_name_split;
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # These few symbols are here only for binary compatibility
    # with the pre-versioning libc.so.0.2 ABI.  Their replacements
    # are in the GLIBC_2.1 version set.  When the soname changes,
    # these can be removed.
    __getuids;
    __hurd_file_name_lookup;
    _hurd_proc_init; _hurd_umask;

    # These go into a different version set if GLIBC_2.0 compatibility
    # is not required.  See below.
    # variables used for detecting cthreads
    _cthread_exit_routine; _cthread_init_routine;

    # necessary for the Hurd brk implementation
    _end;

    # variables used in macros & inline functions
    __hurd_sigthread_stack_base; __hurd_sigthread_stack_end;
    __hurd_sigthread_variables;
    __hurd_threadvar_max;
    __hurd_threadvar_stack_mask; __hurd_threadvar_stack_offset;

    # functions used in macros & inline functions
    __hurd_errno_location;

    # functions used in libmachuser and libhurduser
    _S_catch_exception_raise;
    _S_msg_add_auth; _S_msg_del_auth;
    _S_msg_describe_ports;
    _S_msg_get_dtable; _S_msg_set_dtable;
    _S_msg_get_env_variable; _S_msg_set_env_variable;
    _S_msg_get_environment; _S_msg_set_environment;
    _S_msg_get_fd; _S_msg_set_fd;
    _S_msg_get_init_int; _S_msg_set_init_int;
    _S_msg_get_init_ints; _S_msg_set_init_ints;
    _S_msg_get_init_port; _S_msg_set_init_port;
    _S_msg_get_init_ports; _S_msg_set_init_ports;
    _S_msg_proc_newids; _S_msg_report_wait;
    _S_msg_sig_post; _S_msg_sig_post_untraced;
    _hurd_intr_rpc_mach_msg; _hurdsig_fault_catch_exception_raise;

    # "quasi-internal" variables
    _hurd_device_master;
    _hurd_dtable; _hurd_dtablesize; _hurd_dtable_lock;
    _hurd_host_priv;
    _hurd_msgport;
    _hurd_ports;

    # "quasi-internal" functions
    _hurd_canonicalize_directory_name_internal;
    _hurd_critical_section_lock;
    _hurd_critical_section_unlock;
    _hurd_exception2signal;
    _hurd_exec;
    _hurd_fd_get;
    _hurd_init;
    _hurd_intern_fd;
    _hurd_port_cleanup;
    _hurd_port_free;
    _hurd_port_get;
    _hurd_port_locked_get;
    _hurd_ports_use;
    _hurd_thread_sigstate;


    # (introduced GLIBC_2.1)
    # "quasi-internal" functions
    _hurd_proc_init;
  }
}

#------------------------------------------------------------------------
# FILE: iconv/Versions
#
libc {
  GLIBC_2.1 {
    # global variables
    __gconv_alias_db; __gconv_modules_db;

    # i*
    iconv_open; iconv; iconv_close;
  }
}

#------------------------------------------------------------------------
# FILE: inet/Versions
#
libc {
  GLIBC_2.0 {
    # functions with required interface outside normal name space
    __ivaliduser; __check_rhosts_file; __rcmd_errstr;

    # variables in normal name space
    rexecoptions;

    # e*
    endaliasent; endhostent; endnetent; endnetgrent; endprotoent; endrpcent;
    endservent;

    # e*
    ether_aton; ether_aton_r; ether_hostton; ether_line; ether_ntoa;
    ether_ntoa_r; ether_ntohost;

    # g*
    getaliasbyname; getaliasbyname_r; getaliasent; getaliasent_r;
    getdomainname; gethostbyaddr; gethostbyaddr_r; gethostbyname;
    gethostbyname2; gethostbyname2_r; gethostbyname_r; gethostent;
    gethostent_r; getnetbyaddr; getnetbyaddr_r; getnetbyname;
    getnetbyname_r; getnetent; getnetent_r; getnetgrent; getnetgrent_r;
    getprotobyname; getprotobyname_r; getprotobynumber;
    getprotobynumber_r; getprotoent; getprotoent_r; getrpcbyname;
    getrpcbyname_r; getrpcbynumber; getrpcbynumber_r; getrpcent; getrpcent_r;
    getrpcport; getservbyname; getservbyname_r; getservbyport;
    getservbyport_r; getservent; getservent_r;

    # h*
    htonl; htons;

    # i*
    inet_addr; inet_aton; inet_lnaof; inet_makeaddr; inet_netof; inet_network;
    inet_nsap_addr; inet_nsap_ntoa; inet_ntoa; inet_ntop; inet_pton; innetgr;
    iruserok;

    # n*
    ntohl; ntohs;

    # r*
    rcmd; rexec; rresvport; ruserok; ruserpass;

    # s*
    setaliasent; setnetent; setnetgrent; setprotoent; setrpcent; setservent;
  }
  GLIBC_2.1 {
    # variables in normal name space
    in6addr_any; in6addr_loopback;

    # i*
    if_freenameindex; if_indextoname; if_nameindex; if_nametoindex;
  }
  GLIBC_2.1.2 {
    # g*
    getaliasbyname_r; getaliasent_r; gethostbyaddr_r; gethostbyname2_r;
    gethostbyname_r; gethostent_r; getnetbyaddr_r; getnetbyname_r;
    getnetent_r; getnetgrent_r; getprotobyname_r; getprotobynumber_r;
    getprotoent_r; getrpcbyname_r; getrpcbynumber_r; getrpcent_r;
    getservbyname_r;
  }
  GLIBC_2.2 {
    # i*
    iruserok_af;
    # r*
    rcmd_af; rexec_af; rresvport_af; ruserok_af;
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # functions used in other libraries
    __internal_endnetgrent; __internal_getnetgrent_r;
    __internal_setnetgrent;
  }
}

#------------------------------------------------------------------------
# FILE: intl/Versions
#
libc {
  GLIBC_2.0 {
    # global variables
    _nl_msg_cat_cntr; _nl_default_dirname; _nl_domain_bindings;

    # functions used in inline functions or macros
    __dcgettext;

    # b*
    bindtextdomain;

    # d*
    dcgettext; dgettext; gettext;

    # t*
    textdomain;
  }
  GLIBC_2.2 {
    # functions used in inline functions or macros
    __dcngettext;

    # b*
    bind_textdomain_codeset;

    # d*
    dcngettext; dngettext;

    # n*
    ngettext;
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # functions used in other libraries
    __dgettext;
  }
}

#------------------------------------------------------------------------
# FILE: io/Versions
#
libc {
  GLIBC_2.0 {
    # functions used in inline functions or macros
    __xstat; __fxstat; __lxstat; __xmknod; __write; __close; __fcntl;
    __lseek; __open; __read;

    # a*
    access;

    # c*
    chdir; chmod; chown; close; creat;

    # d*
    dup; dup2;

    # e*
    euidaccess;

    # f*
    fchdir; fchmod; fchown; fcntl; flock; fstatfs; fts_children; fts_close;
    fts_open; fts_read; fts_set; ftw;

    # g*
    get_current_dir_name; getcwd; getwd;

    # i*
    isatty;

    # l*
    lchown; link; lockf; lseek;

    # m*
    mkdir; mkfifo;

    # o*
    open;

    # p*
    pipe; poll;

    # r*
    read; readlink; rmdir;

    # s*
    statfs; symlink;

    # t*
    ttyname; ttyname_r;

    # u*
    umask; unlink; utime;

    # w*
    write;
  }
  GLIBC_2.1 {
    # functions used in other libraries
    __xstat64; __fxstat64; __lxstat64; __poll;

    # c*
    creat64;

    # f*
    fstatfs64; fstatvfs; fstatvfs64; ftw64;

    # l*
    lockf64; lseek64;

    # n*
    nftw; nftw64;

    # o*
    open64;

    # s*
    statfs64; statvfs; statvfs64;
  }
  GLIBC_2.1.3 {
    # empty now
  }
  GLIBC_2.2 {
    # p*
    posix_fadvise; posix_fadvise64; posix_fallocate; posix_fallocate64;

  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # functions which have an additional interface since they are
    # are cancelable.
    __libc_open; __libc_close; __libc_read; __libc_write;
    __libc_lseek; __libc_fcntl;

    # functions used by libstdc++ 2.7.2
    __dup2; __pipe;


    # (introduced GLIBC_2.1.3)
    # For the cancelation wrappers.
    __libc_open64; __libc_lseek64;

    # (introduced GLIBC_2.2)
    __open64;
  }
}

#------------------------------------------------------------------------
# FILE: libio/Versions
#
libc {
  GLIBC_2.0 {
    # functions used in inline functions or macros
    __getdelim;

    # functions used in inline functions or macros
    _IO_getc; _IO_peekc_unlocked; _IO_putc; _IO_feof; _IO_ferror;
    __uflow; __underflow; __overflow;

    # functions used in other libraries
    __vsscanf; __vsnprintf;

    # variables in normal name space
    stderr; stdin; stdout;

    # c*
    clearerr; clearerr_unlocked;

    # f*
    fclose; fcloseall; fdopen; feof; feof_locked; feof_unlocked; ferror;
    ferror_locked; ferror_unlocked; fflush; fflush_locked; fflush_unlocked;
    fgetc; fgetpos; fgets; fileno; fileno_locked; fileno_unlocked;
    fopen; fopencookie; fputc; fputc_locked; fputc_unlocked; fputs;
    fread; freopen; fseek; fsetpos; ftell; fwrite;

    # g*
    getc; getc_locked; getc_unlocked; getchar; getchar_unlocked; getdelim;
    gets;

    # o*
    open_memstream; open_obstack_stream; obstack_printf; obstack_vprintf;

    # p*
    pclose; popen; putc; putc_locked; putc_unlocked; putchar;
    putchar_unlocked; puts;

    # r*
    rewind;

    # s*
    setbuf; setbuffer; setlinebuf; setvbuf;

    # u*
    ungetc;

    # v*
    vasprintf; vdprintf; vscanf; vsnprintf; vsprintf; vsscanf;
  }
  GLIBC_2.1 {
    # f*
    fgetpos64; fopen64; freopen64; fseeko; fseeko64; fsetpos64; ftello;
    ftello64; fopen; fclose; fdopen; fread_unlocked; fwrite_unlocked;
    fgets_unlocked; fputs_unlocked; fgetc_unlocked;

    # p*
    pclose; popen;
  }
  GLIBC_2.2 {
    # f*
    fgetpos; fgetpos64; fgetwc; fgetwc_unlocked; fgetws; fgetws_unlocked;
    fputwc; fputwc_unlocked; fputws; fputws_unlocked; fsetpos; fsetpos64;
    fwide; fwprintf; fwscanf; fopencookie; fmemopen;

    # g*
    getwc; getwc_unlocked; getwchar; getwchar_unlocked;

    # p*
    putwc; putwc_unlocked; putwchar; putwchar_unlocked;

    # s*
    swprintf; swscanf;

    # u*
    ungetwc;

    # v*
    vfwprintf; vswprintf; vwprintf; vfwscanf; vswscanf; vwscanf;

    # w*
    wprintf; wscanf;
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # global variables
    _IO_list_all; _IO_stderr_; _IO_stdin_; _IO_stdout_;

    # libio
    _IO_adjust_column; _IO_clearerr; _IO_default_doallocate;
    _IO_default_finish; _IO_default_pbackfail; _IO_default_uflow;
    _IO_default_xsgetn; _IO_default_xsputn; _IO_do_write;
    _IO_doallocbuf; _IO_fclose; _IO_fdopen; SKIP_REPEATED_IO_feof; SKIP_REPEATED_IO_ferror;
    _IO_fflush; _IO_fgetc; _IO_fgetpos; _IO_fgets; _IO_file_attach;
    _IO_file_close; _IO_file_close_it; _IO_file_doallocate;
    _IO_file_fopen; _IO_file_init; _IO_file_jumps; _IO_file_open;
    _IO_file_overflow; _IO_file_read; _IO_file_seek; _IO_file_seekoff;
    _IO_file_setbuf; _IO_file_stat; _IO_file_sync; _IO_file_underflow;
    _IO_file_write; _IO_file_xsputn; _IO_fileno; _IO_flockfile;
    _IO_flush_all; _IO_flush_all_linebuffered; _IO_fopen; _IO_fprintf;
    _IO_fputs; _IO_fread; _IO_free_backup_area; _IO_freopen;
    _IO_fscanf; _IO_fseek; _IO_fsetpos; _IO_ftell; _IO_ftrylockfile;
    _IO_funlockfile; _IO_fwrite; SKIP_REPEATED_IO_getc; _IO_getline; _IO_gets;
    _IO_init; _IO_init_marker; _IO_link_in; _IO_marker_delta;
    _IO_marker_difference; _IO_padn; _IO_pclose; _IO_peekc_locked;
    _IO_perror; _IO_popen; _IO_printf; _IO_proc_close; _IO_proc_open;
    SKIP_REPEATED_IO_putc; _IO_puts; _IO_remove_marker; _IO_rewind; _IO_scanf;
    _IO_seekmark; _IO_seekoff; _IO_seekpos; _IO_setb; _IO_setbuf;
    _IO_setbuffer; _IO_setlinebuf; _IO_setvbuf; _IO_sgetn;
    _IO_sprintf; _IO_sputbackc; _IO_sscanf; _IO_str_init_readonly;
    _IO_str_init_static; _IO_str_overflow; _IO_str_pbackfail;
    _IO_str_seekoff; _IO_str_underflow; _IO_sungetc;
    _IO_switch_to_get_mode; _IO_un_link; _IO_ungetc;
    _IO_unsave_markers; _IO_vfprintf; _IO_vfscanf; _IO_vsprintf;


    # (introduced GLIBC_2.1)
    # global variables
    _IO_2_1_stdin_; _IO_2_1_stdout_; _IO_2_1_stderr_;

    # functions used in other libraries
    _IO_fclose; _IO_fopen; _IO_fdopen; _IO_popen; __asprintf;

    # functions used in libstdc++
    _IO_do_write; _IO_file_attach; _IO_file_close_it; _IO_file_finish;
    _IO_file_fopen; _IO_file_init; _IO_file_overflow; _IO_file_seekoff;
    _IO_file_setbuf; _IO_file_sync; _IO_file_underflow;
    _IO_file_write; _IO_file_xsputn; _IO_proc_open; _IO_proc_close;

    # Changed getline function in libio.
    _IO_getline_info;


    # (introduced GLIBC_2.2)
    # functions used in libstdc++
    _IO_fgetpos; _IO_fgetpos64; _IO_fsetpos; _IO_fsetpos64;
    _IO_wdo_write; _IO_wfile_jumps; _IO_wfile_overflow; _IO_wfile_seekoff;
    _IO_wfile_setbuf; _IO_wfile_sync; _IO_wfile_underflow; _IO_wfile_xsputn;
    _IO_adjust_wcolumn; _IO_free_wbackup_area; _IO_init_wmarker;
    _IO_least_wmarker; _IO_seekwmark; _IO_sputbackwc; _IO_sungetwc;
    _IO_switch_to_main_wget_area; _IO_switch_to_wbackup_area;
    _IO_switch_to_wget_mode; _IO_unsave_wmarkers; _IO_wdefault_doallocate;
    _IO_wdefault_finish; _IO_wdefault_pbackfail; _IO_wdefault_setbuf;
    _IO_wdefault_uflow; _IO_wdefault_xsgetn; _IO_wdefault_xsputn;
    _IO_wdoallocbuf; _IO_wmarker_delta; _IO_wsetb; __woverflow; __wuflow;
    __wunderflow;

    # LinuxThreads uses this protected interface
    _IO_iter_begin; _IO_iter_end; _IO_iter_next; _IO_iter_file;
    _IO_list_lock; _IO_list_unlock; _IO_list_resetlock;

    # Functions to access FILE internals.
    __fbufsize; __freading; __fwriting; __freadable; __fwritable; __flbf;
    __fpurge; __fpending; __fsetlocking; _flushlbf;
  }
}

#------------------------------------------------------------------------
# FILE: locale/Versions
#
libBrokenLocale {
  GLIBC_2.0 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    __ctype_get_mb_cur_max;
  }
}

libc {
  GLIBC_2.0 {
    # global variables
    __collate_element_hash; __collate_element_strings;
    __collate_symbol_classes; __collate_symbol_hash; __collate_symbol_strings;
    _libc_intl_domainname; _nl_current_LC_COLLATE; _nl_current_LC_CTYPE;

    # functions used in inline functions or macros
    __ctype_get_mb_cur_max;

    # l*
    localeconv;

    # n*
    nl_langinfo;

    # s*
    setlocale;
  }
  GLIBC_2.1 {
    # empty now
  }
  GLIBC_2.2 {
    # The data structure changed.
    localeconv;

  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.1)
    # functions from the experimental locale implementation
    __newlocale; __duplocale; __freelocale;
    __isalnum_l; __isalpha_l; __isascii_l; __isblank_l; __iscntrl_l;
    __isdigit_l; __isgraph_l; __islower_l; __isprint_l; __ispunct_l;
    __isspace_l; __isupper_l; __iswalnum_l; __iswalpha_l; __iswblank_l;
    __iswcntrl_l; __iswctype_l; __iswdigit_l; __iswgraph_l; __iswlower_l;
    __iswprint_l; __iswpunct_l; __iswspace_l; __iswupper_l; __iswxdigit_l;
    __isxdigit_l; __strcasecmp_l; __strcoll_l; __strfmon_l; __strncasecmp_l;
    __strtod_l; __strtof_l; __strtol_l; __strtold_l; __strtoll_l; __strtoul_l;
    __strtoull_l; __strxfrm_l; __toascii_l; __tolower_l; __toupper_l;
    __towctrans_l; __towlower_l; __towupper_l; __wcscasecmp_l; __wcscoll_l;
    __wcsncasecmp_l; __wcstod_l; __wcstof_l; __wcstol_l; __wcstold_l;
    __wcstoll_l; __wcstoul_l; __wcstoull_l; __wcsxfrm_l; __wctype_l;

    # (introduced GLIBC_2.2)
    # more functions from the experimental locale implementation
    __wctrans_l;

    # missing function from the experimental locale implementation
    __nl_langinfo_l;
  }
}

#------------------------------------------------------------------------
# FILE: login/Versions
#
libc {
  GLIBC_2.0 {
    # e*
    endutent;

    # g*
    getlogin; getlogin_r; getutent; getutent_r; getutid; getutid_r; getutline;
    getutline_r;

    # p*
    pututline;

    # s*
    setutent;

    # u*
    updwtmp; utmpname;
  }
  GLIBC_2.1 {
    # e*
    endutxent;

    # g*
    getpt; getutxent; getutxid; getutxline; grantpt;

    # p*
    ptsname; ptsname_r; pututxline;

    # s*
    setutxent;

    # u*
    unlockpt; updwtmpx; utmpxname;
  }
  GLIBC_2.1.1 {
    # g*
    getutmpx; getutmp;
  }
  GLIBC_2.2.1 {
    # p*
    posix_openpt;
  }
}

libutil {
  GLIBC_2.0 {
    forkpty; login; login_tty; logout; logwtmp; openpty;
  }
}

#------------------------------------------------------------------------
# FILE: mach/Versions
#
%define SHARED
%include <shlib-compat.h>

libc {

%if !SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_2)
  HURD_CTHREADS_0.3 {
    __mutex_init; __mutex_lock; __mutex_lock_solid; __mutex_trylock;
    __mutex_unlock; __mutex_unlock_solid;
    __spin_lock; __spin_lock_init; __spin_lock_solid; __spin_try_lock;
    __spin_unlock;
  }
%endif
  GLIBC_2.0 {
%if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_1)
%endif
    # variables used in Mach-specific macros
    __mach_task_self_;
    __vm_page_size;

    # functions used in inline functions and macros
    __mach_port_deallocate; __mach_thread_self;
%if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_2)
    __mutex_init; __mutex_lock; __mutex_lock_solid; __mutex_trylock;
    __mutex_unlock; __mutex_unlock_solid;
    __spin_lock; __spin_lock_init; __spin_lock_solid; __spin_try_lock;
    __spin_unlock;
%endif

    # variables in normal name space
    vm_page_size;

    # functions in normal name space

    # e*
    evc_wait;

    # m*
    mach_error; mach_error_string; mach_error_type;
    mach_host_self;
    mach_msg; mach_msg_destroy;
    mach_msg_send; mach_msg_receive;
    mach_msg_server; mach_msg_server_timeout;
    mach_open_devstream;
    mach_port_allocate; mach_port_allocate_name; mach_port_deallocate;
    mach_port_insert_right; mach_reply_port;
    mach_setup_thread;
    mach_task_self;
    mach_thread_self;
    mig_allocate; mig_dealloc_reply_port; mig_deallocate;
    mig_get_reply_port; mig_init; mig_put_reply_port;

    # v*
    vm_allocate; vm_deallocate; vm_map;

    # s*
    swtch; swtch_pri;

    # t*
    task_create; task_set_special_port; task_suspend; task_terminate;
    thread_depress_abort; thread_switch;
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # This symbol is here only for binary compatibility with the
    # pre-versioning libc.so.0.2 ABI.  When the soname changes,
    # it can be removed.
    __vm_allocate;

    # functions used by RPC stubs
    __mach_msg;
    __mig_allocate; __mig_deallocate; __mig_dealloc_reply_port;
    __mig_get_reply_port; __mig_put_reply_port;
    __mig_strncpy;
  }
}

#------------------------------------------------------------------------
# FILE: malloc/Versions
#
libc {
  GLIBC_2.0 {
    __malloc_initialize_hook; __free_hook; __malloc_hook; __realloc_hook;
    __memalign_hook; __after_morecore_hook;
    __malloc_initialized; __default_morecore; __morecore;

    # functions used in inline functions or macros
    _obstack_allocated_p; _obstack_begin; _obstack_begin_1;
    _obstack_free; _obstack_memory_used; _obstack_newchunk;

    # variables in normal name space
    mallwatch; obstack_alloc_failed_handler; obstack_exit_failure;

    # c*
    calloc; cfree;

    # f*
    free;

    # m*
    mallinfo; malloc; malloc_get_state; malloc_set_state; malloc_stats;
    malloc_trim; malloc_usable_size; mallopt; memalign; mprobe; mtrace;
    muntrace;

    # o*
    obstack_free;

    # p*
    pvalloc;

    # r*
    realloc;

    # t*
    tr_break;

    # v*
    valloc;
  }
  GLIBC_2.1 {
    # empty now
  }
  GLIBC_2.2 {
    # m*
    mcheck_check_all; mcheck_pedantic;

    # p*
    posix_memalign;
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # global variables
    _obstack;

    # interface of malloc functions
    __libc_calloc; __libc_free; __libc_mallinfo; __libc_malloc;
    __libc_mallopt; __libc_memalign; __libc_pvalloc; __libc_realloc;
    __libc_valloc;

    # (introduced GLIBC_2.1)
    # Special functions.
    __libc_freeres;
  }
}

#------------------------------------------------------------------------
# FILE: math/Versions
#
libc {
  GLIBC_2.0 {
    # functions used in inline functions or macros
    __isnan; __isnanf; __isnanl; __finite; __finitef; __finitel;
    __isinf; __isinff; __isinfl;

    # c*
    copysign; copysignf; copysignl;

    # f*
    finite; finitef; finitel; frexp; frexpf; frexpl;

    # i*
    isinf; isinff; isinfl; isnan; isnanf; isnanl; ldexp; ldexpf; ldexpl;

    # m*
    modf; modff; modfl;

    # s*
    scalbn; scalbnf; scalbnl;
  }
  GLIBC_2.1 {
    # functions used in inline functions or macros
    __signbit; __signbitf; __signbitl;

    # s*
    scalbln; scalblnf; scalblnl;
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # global variables
    __fpu_control;
  }
}

libm {
  GLIBC_2.0 {
    # mathematical functions
    acos; acosf; acosl;
    acosh; acoshf; acoshl;
    asin; asinf; asinl;
    asinh; asinhf; asinhl;
    atan2; atan2f; atan2l;
    atan; atanf; atanl;
    atanh; atanhf; atanhl;
    cbrt; cbrtf; cbrtl;
    ceil; ceilf; ceill;
    copysign; copysignf; copysignl;
    cos; cosf; cosl;
    coshf; cosh; coshl;
    drem; dremf; dreml;
    erf; erff; erfl;
    erfc; erfcf; erfcl;
    exp; expf; expl;
    expm1; expm1f; expm1l;
    fabs; fabsf; fabsl;
    finite; finitef; finitel;
    floor; floorf; floorl;
    fmod; fmodf; fmodl;
    frexp; frexpf; frexpl;
    gamma; gammaf; gammal;
    gamma_r; gammaf_r; gammal_r;
    hypot; hypotf; hypotl;
    ilogb; ilogbf; ilogbl;
    j0; j0f; j0l;
    j1; j1f; j1l;
    jn; jnf; jnl;
    ldexp; ldexpf; ldexpl;
    lgamma; lgammaf; lgammal;
    lgamma_r; lgammaf_r; lgammal_r;
    log10; log10f; log10l;
    log1p; log1pf; log1pl;
    log; logf; logl;
    logb; logbf; logbl;
    matherr;
    modf; modff; modfl;
    nextafter; nextafterf; nextafterl;
    pow; powf; powl;
    remainder; remainderf; remainderl;
    rint; rintf; rintl;
    scalb; scalbf; scalbl;
    scalbn; scalbnf; scalbnl;
    significand; significandf; significandl;
    sin; sinf; sinl;
    sinh; sinhf; sinhl;
    sqrt; sqrtf; sqrtl;
    tan; tanf; tanl;
    tanh; tanhf; tanhl;
    y0; y0f; y0l;
    y1; y1f; y1l;
    yn; ynf; ynl;


    # global variables
    _LIB_VERSION; signgam;
  }
  GLIBC_2.1 {
    # mathematical functions
    exp2; exp2f; exp2l;
    exp10; exp10f; exp10l;
    fdim; fdimf; fdiml;
    fma; fmaf; fmal;
    fmax; fmaxf; fmaxl;
    fmin; fminf; fminl;
    log2; log2f; log2l;
    nan; nanf; nanl;
    nearbyint; nearbyintf; nearbyintl;
    nexttoward; nexttowardf; nexttowardl;
    pow10; pow10f; pow10l;
    remquo; remquof; remquol;
    lrint; lrintf; lrintl;
    llrint; llrintf; llrintl;
    round; roundf; roundl;
    lround; lroundf; lroundl;
    llround; llroundf; llroundl;
    scalbln; scalblnf; scalblnl;
    sincos; sincosf; sincosl;
    trunc; truncf; truncl;
    tgamma; tgammaf; tgammal;

    # complex functions
    cabs; cabsf; cabsl;
    cacos; cacosf; cacosl;
    cacosh; cacoshf; cacoshl;
    carg; cargf; cargl;
    casin; casinf; casinl;
    casinh; casinhf; casinhl;
    catan; catanf; catanl;
    catanh; catanhf; catanhl;
    ccos; ccosf; ccosl;
    ccosh; ccoshf; ccoshl;
    cexp; cexpf; cexpl;
    cimag; cimagf; cimagl;
    clog; clogf; clogl;
    clog10; clog10f; clog10l;
    __clog10; __clog10f; __clog10l;
    conj; conjf; conjl;
    cpow; cpowf; cpowl;
    cproj; cprojf; cprojl;
    creal; crealf; creall;
    csin; csinf; csinl;
    csinh; csinhf; csinhl;
    csqrt; csqrtf; csqrtl;
    ctan; ctanf; ctanl;
    ctanh; ctanhf; ctanhl;

    # fp environment functions
    feclearexcept; fegetenv; fegetexceptflag;
    fegetround; feholdexcept; feraiseexcept;
    fesetenv; fesetexceptflag; fesetround;
    fetestexcept; feupdateenv;

    # functions used in inline functions or macros
    __finite; __finitef; __finitel;
    __fpclassify; __fpclassifyf; __fpclassifyl;
    __signbit; __signbitf; __signbitl;
  }
  GLIBC_2.2 {
    # fp environment functions changes from ISO C99 TR1
    feclearexcept; fegetenv; fegetexceptflag; feraiseexcept;
    fesetenv; fesetexceptflag; feupdateenv;

    # fp environment function
    feenableexcept; fedisableexcept; fegetexcept;
  }
}

#------------------------------------------------------------------------
# FILE: misc/Versions
#
libc {
  GLIBC_2.0 {
    # global variables
    ___brk_addr; __curbrk; __progname; __progname_full;

    # variables in normal name space
    error_message_count; error_one_per_line; error_print_progname;

    # variables in normal name space
    loc1; loc2; locs;
    program_invocation_name; program_invocation_short_name;

    # a*
    acct; addmntent; advance;

    # b*
    brk;

    # c*
    chflags; chroot; closelog;

    # d*
    daemon; dirname;

    # e*
    ecvt; ecvt_r; endfsent; endmntent; endttyent; endusershell;

    # e*
    err; error; error_at_line; errx;

    # f*
    fchflags; fcvt; fcvt_r; fdatasync; fsync; ftruncate;

    # g*
    gcvt; get_avphys_pages; get_nprocs; get_nprocs_conf; get_phys_pages;
    getfsent; getfsfile; getfsspec; gethostid; gethostname; getmntent;
    getmntent_r; getpagesize; getpass; getttyent; getttynam; getusershell;
    gtty;

    # h*
    hasmntopt; hcreate; hcreate_r; hdestroy; hdestroy_r; hsearch; hsearch_r;

    # i*
    insque; ioctl;

    # j*
    jrand48; jrand48_r; lfind; lsearch;

    # m*
    madvise; mkstemp; mktemp; mlock; mlockall; mmap; mount; mprotect; msync;
    munlock; munlockall; munmap;

    # o*
    openlog;

    # p*
    ptrace;

    # q*
    qecvt; qecvt_r; qfcvt; qfcvt_r; qgcvt;

    # r*
    readv; reboot; remque; revoke;

    # s*
    sbrk; select; setdomainname; setfsent; sethostent; sethostid; sethostname;
    setlogmask; setmntent; setregid; setreuid; setttyent; setusershell; sstk;
    stty; sync; syscall; syslog;

    # t*
    tdelete; tfind; truncate; tsearch; ttyslot; twalk;

    # u*
    ualarm; usleep; ustat; utimes;

    # v*
    verr; verrx; vhangup; vsyslog; vwarn; vwarnx;

    # w*
    warn; warnx;

    # w*
    writev;
  }
  GLIBC_2.1 {
    # f*
    ftruncate64;

    # m*
    mmap64;

    # t*
    tdestroy; truncate64;
  }
  GLIBC_2.2 {
    # g*
    getloadavg;

    # m*
    mincore; mkdtemp; mkstemp64;

    # p*
    posix_madvise;
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # functions which have an additional interface since they are
    # are cancelable.
    __libc_fsync; __libc_msync;

    # interface of malloc functions
    __sbrk; __getpagesize;

    # functions used in other libraries
    __select;
  }
}

#------------------------------------------------------------------------
# FILE: nis/Versions
#
libnsl {
  GLIBC_2.0 {
    # Many programs expect this, but every user program should
    # have it's own version, since the interface is different on
    # various platforms.
    xdr_domainname;       xdr_keydat;          xdr_mapname;
    xdr_peername;         xdr_valdat;          xdr_yp_buf;
    xdr_ypbind_binding;   xdr_ypbind_resp;     xdr_ypbind_resptype;
    xdr_ypbind_setdom;    xdr_ypdelete_args;   xdr_ypmap_parms;
    xdr_ypmaplist;        xdr_yppush_status;   xdr_yppushresp_xfr;
    xdr_ypreq_key;        xdr_ypreq_nokey;     xdr_ypreq_xfr;
    xdr_ypresp_all;       xdr_ypresp_key_val;  xdr_ypresp_maplist;
    xdr_ypresp_master;    xdr_ypresp_order;    xdr_ypresp_val;
    xdr_ypresp_xfr;       xdr_ypstat;          xdr_ypupdate_args;
    xdr_ypxfrstat;

    __yp_check;
    yp_all;               yp_bind;             yp_first;
    yp_get_default_domain; yp_maplist;         yp_master;
    yp_match;             yp_next;             yp_order;
    yp_unbind;            yp_update;           ypbinderr_string;
    yperr_string;         ypprot_err;
  }
  GLIBC_2.1 {
    nis_add;              nis_add_entry;       nis_addmember;
    nis_checkpoint;       nis_clone_directory; nis_clone_object;
    nis_clone_result;     nis_creategroup;     nis_destroy_object;
    nis_destroygroup;     nis_dir_cmp;         nis_domain_of;
    nis_domain_of_r;      nis_first_entry;     nis_free_directory;
    nis_free_object;      nis_free_request;    nis_freenames;
    nis_freeresult;       nis_freeservlist;    nis_freetags;
    nis_getnames;         nis_getservlist;     nis_ismember;
    nis_leaf_of;          nis_leaf_of_r;       nis_lerror;
    nis_list;             nis_local_directory; nis_local_group;
    nis_local_host;       nis_local_principal; nis_lookup;
    nis_mkdir;            nis_modify;          nis_modify_entry;
    nis_name_of;          nis_name_of_r;       nis_next_entry;
    nis_perror;           nis_ping;            nis_print_directory;
    nis_print_entry;      nis_print_group;     nis_print_group_entry;
    nis_print_link;       nis_print_object;    nis_print_result;
    nis_print_rights;     nis_print_table;     nis_read_obj;
    nis_remove;           nis_remove_entry;    nis_removemember;
    nis_rmdir;            nis_servstate;       nis_sperrno;
    nis_sperror;          nis_sperror_r;       nis_stats;
    nis_verifygroup;      nis_write_obj;

    xdr_cback_data;       xdr_obj_p;

  }
  GLIBC_2.2 {
    xdr_ypall;
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.1)
    # This functions are needed by the NIS+ tools and rpc.nisd,
    # they should never be used in a normal user program !
    __free_fdresult;      __nis_default_access; __nis_default_group;
    __nis_default_owner;  __nis_default_ttl;   __nis_finddirectory;
    __nis_hash;           __nisbind_connect;   __nisbind_create;
    __nisbind_destroy;    __nisbind_next;
    readColdStartFile;    writeColdStartFile;
  }
}

libnss_compat {
  GLIBC_2.0 {
    # empty now
  }
  GLIBC_2.2 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    _nss_compat_endgrent; _nss_compat_endpwent; _nss_compat_endspent;
    _nss_compat_getgrent_r; _nss_compat_getgrgid_r; _nss_compat_getgrnam_r;
    _nss_compat_getpwent_r; _nss_compat_getpwnam_r; _nss_compat_getpwuid_r;
    _nss_compat_getspent_r; _nss_compat_getspnam_r;
    _nss_compat_setgrent; _nss_compat_setpwent; _nss_compat_setspent;

    # (introduced GLIBC_2.2)
    _nss_compat_initgroups_dyn;
  }
}

libnss_nis {
  GLIBC_2.0 {
    # empty now
  }
  GLIBC_2.2 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    _nss_nis_endaliasent; _nss_nis_endetherent; _nss_nis_endgrent;
    _nss_nis_endhostent; _nss_nis_endnetent; _nss_nis_endnetgrent;
    _nss_nis_endprotoent; _nss_nis_endpwent; _nss_nis_endrpcent;
    _nss_nis_endservent; _nss_nis_endspent; _nss_nis_getaliasbyname_r;
    _nss_nis_getaliasent_r; _nss_nis_getetherent_r; _nss_nis_getgrent_r;
    _nss_nis_getgrgid_r; _nss_nis_getgrnam_r; _nss_nis_gethostbyaddr_r;
    _nss_nis_gethostbyname2_r; _nss_nis_gethostbyname_r; _nss_nis_gethostent_r;
    _nss_nis_gethostton_r; _nss_nis_getnetbyaddr_r; _nss_nis_getnetbyname_r;
    _nss_nis_getnetent_r; _nss_nis_getnetgrent_r; _nss_nis_getntohost_r;
    _nss_nis_getprotobyname_r; _nss_nis_getprotobynumber_r;
    _nss_nis_getprotoent_r; _nss_nis_getpublickey; _nss_nis_getpwent_r;
    _nss_nis_getpwnam_r; _nss_nis_getpwuid_r; _nss_nis_getrpcbyname_r;
    _nss_nis_getrpcbynumber_r; _nss_nis_getrpcent_r; _nss_nis_getsecretkey;
    _nss_nis_getservbyname_r; _nss_nis_getservbyport_r; _nss_nis_getservent_r;
    _nss_nis_getspent_r; _nss_nis_getspnam_r;
    _nss_nis_netname2user; _nss_nis_setaliasent; _nss_nis_setetherent;
    _nss_nis_setgrent; _nss_nis_sethostent; _nss_nis_setnetent;
    _nss_nis_setnetgrent; _nss_nis_setprotoent; _nss_nis_setpwent;
    _nss_nis_setrpcent; _nss_nis_setservent; _nss_nis_setspent;

    # (introduced GLIBC_2.2)
    _nss_nis_initgroups_dyn;
  }
}

libnss_nisplus {
  GLIBC_2.1 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.1)
    _nss_nisplus_endaliasent; _nss_nisplus_endetherent; _nss_nisplus_endgrent;
    _nss_nisplus_endhostent; _nss_nisplus_endnetent; _nss_nisplus_endnetgrent;
    _nss_nisplus_endprotoent; _nss_nisplus_endpwent; _nss_nisplus_endrpcent;
    _nss_nisplus_endservent; _nss_nisplus_endspent;
    _nss_nisplus_getaliasbyname_r; _nss_nisplus_getaliasent_r;
    _nss_nisplus_getetherent_r; _nss_nisplus_getgrent_r;
    _nss_nisplus_getgrgid_r; _nss_nisplus_getgrnam_r;
    _nss_nisplus_gethostbyaddr_r; _nss_nisplus_gethostbyname2_r;
    _nss_nisplus_gethostbyname_r; _nss_nisplus_gethostent_r;
    _nss_nisplus_gethostton_r; _nss_nisplus_getnetbyaddr_r;
    _nss_nisplus_getnetbyname_r; _nss_nisplus_getnetent_r;
    _nss_nisplus_getnetgrent_r; _nss_nisplus_getntohost_r;
    _nss_nisplus_getprotobyname_r; _nss_nisplus_getprotobynumber_r;
    _nss_nisplus_getprotoent_r; _nss_nisplus_getpublickey;
    _nss_nisplus_getpwent_r; _nss_nisplus_getpwnam_r; _nss_nisplus_getpwuid_r;
    _nss_nisplus_getrpcbyname_r; _nss_nisplus_getrpcbynumber_r;
    _nss_nisplus_getrpcent_r; _nss_nisplus_getsecretkey;
    _nss_nisplus_getservbyname_r; _nss_nisplus_getservbynumber_r;
    _nss_nisplus_getservent_r; _nss_nisplus_getspent_r;
    _nss_nisplus_getspnam_r; _nss_nisplus_netname2user;
    _nss_nisplus_parse_grent; _nss_nisplus_parse_pwent;
    _nss_nisplus_parse_spent; _nss_nisplus_setaliasent;
    _nss_nisplus_setetherent; _nss_nisplus_setgrent; _nss_nisplus_sethostent;
    _nss_nisplus_setnetent; _nss_nisplus_setnetgrent; _nss_nisplus_setprotoent;
    _nss_nisplus_setpwent; _nss_nisplus_setrpcent; _nss_nisplus_setservent;
    _nss_nisplus_setspent;
  }
}

#------------------------------------------------------------------------
# FILE: nss/Versions
#
libc {
  GLIBC_2.0 {
    # empty now
  }
  GLIBC_2.2.2 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # functions used in other libraries
    __nss_passwd_lookup; __nss_group_lookup; __nss_hosts_lookup; __nss_next;
    _nss_files_parse_grent; _nss_files_parse_pwent; _nss_files_parse_spent;
    __nss_database_lookup; __nss_configure_lookup;

    # (introduced GLIBC_2.2.2)
    __nss_hostname_digits_dots;
  }
}

libnss_files {
  GLIBC_2.0 {
    # empty now
  }
  GLIBC_2.1 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    _nss_files_setaliasent;
    _nss_files_endaliasent;
    _nss_files_getaliasbyname_r;
    _nss_files_getaliasent_r;

    _nss_files_setetherent;
    _nss_files_endetherent;
    _nss_files_getetherent_r;
    _nss_files_parse_etherent;

    _nss_files_setgrent;
    _nss_files_endgrent;
    _nss_files_getgrent_r;
    _nss_files_getgrgid_r;
    _nss_files_getgrnam_r;

    _nss_files_sethostent;
    _nss_files_endhostent;
    _nss_files_gethostbyaddr_r;
    _nss_files_gethostbyname2_r;
    _nss_files_gethostbyname_r;
    _nss_files_gethostent_r;
    _nss_files_gethostton_r;

    _nss_files_setnetent;
    _nss_files_endnetent;
    _nss_files_getnetbyaddr_r;
    _nss_files_getnetbyname_r;
    _nss_files_getnetent_r;
    _nss_files_getntohost_r;
    _nss_files_parse_netent;

    _nss_files_setnetgrent;
    _nss_files_endnetgrent;
    _nss_files_getnetgrent_r;

    _nss_files_setprotoent;
    _nss_files_endprotoent;
    _nss_files_getprotobyname_r;
    _nss_files_getprotobynumber_r;
    _nss_files_getprotoent_r;
    _nss_files_parse_protoent;

    _nss_files_setpwent;
    _nss_files_endpwent;
    _nss_files_getpwent_r;
    _nss_files_getpwnam_r;
    _nss_files_getpwuid_r;

    _nss_files_setrpcent;
    _nss_files_endrpcent;
    _nss_files_getrpcbyname_r;
    _nss_files_getrpcbynumber_r;
    _nss_files_getrpcent_r;
    _nss_files_parse_rpcent;

    _nss_files_setservent;
    _nss_files_endservent;
    _nss_files_getservbyname_r;
    _nss_files_getservbyport_r;
    _nss_files_getservent_r;
    _nss_files_parse_servent;

    _nss_files_setspent;
    _nss_files_endspent;
    _nss_files_getspent_r;
    _nss_files_getspnam_r;

    _nss_netgroup_parseline;

    # (introduced GLIBC_2.1)
    _nss_files_getpublickey;
    _nss_files_getsecretkey;
  }
}

#------------------------------------------------------------------------
# FILE: posix/Versions
#
libc {
  GLIBC_2.0 {
    # functions with required interface outside normal name space
    _exit;

    # global variables
    __environ; _environ;

    # variables in normal name space
    environ; optarg; opterr; optind; optopt;
    re_max_failures; re_syntax_options;

    # a*
    alarm;

    # c*
    confstr;

    # e*
    execl; execle; execlp; execv; execve; execvp; fexecve;

    # f*
    fnmatch; fork; fpathconf; freeaddrinfo;

    # g*
    getaddrinfo; getdtablesize; getegid; geteuid; getgid; getopt; getopt_long;
    getopt_long_only; getpgid; getpgrp; getpid; getppid; getsid; getuid; glob;
    glob_pattern_p; globfree; group_member;

    # n*
    nanosleep;

    # p*
    pathconf; pause; pselect;

    # r*
    re_comp; re_compile_fastmap; re_compile_pattern; re_exec; re_match;
    re_match_2; re_search; re_search_2; re_set_registers; re_set_syntax;
    regcomp; regerror; regexec; regfree;

    # s*
    sched_get_priority_max; sched_get_priority_min; sched_getparam;
    sched_getscheduler; sched_rr_get_interval; sched_setparam;
    sched_setscheduler; sched_yield; setegid; seteuid; setgid; setlogin;
    setpgid; setpgrp; setsid; setuid; sleep; sysconf;

    # t*
    times;

    # u*
    uname;

    # v*
    vfork;

    # w*
    wait; wait3; wait4; waitpid;
  }
  GLIBC_2.1 {
    # g*
    gai_strerror; getnameinfo; glob64; globfree64;

    # p*
    pread; pread64; pwrite; pwrite64;

    # w*
    waitid; wordexp; wordfree;
  }
  GLIBC_2.1.2 {
    # empty now
  }
  GLIBC_2.1.3 {
    # empty now
  }
  GLIBC_2.2 {
    # p*
    posix_spawn_file_actions_init; posix_spawn_file_actions_destroy;
    posix_spawn_file_actions_addclose; posix_spawn_file_actions_addopen;
    posix_spawn_file_actions_adddup2;
    posix_spawnattr_init; posix_spawnattr_destroy;
    posix_spawnattr_getsigdefault; posix_spawnattr_setsigdefault;
    posix_spawnattr_getflags; posix_spawnattr_setflags;
    posix_spawnattr_getpgroup; posix_spawnattr_setpgroup;
    posix_spawnattr_setsigmask; posix_spawnattr_getsigmask;
    posix_spawn; posix_spawnp; posix_spawnattr_getschedpolicy;
    posix_spawnattr_setschedpolicy; posix_spawnattr_getschedparam;
    posix_spawnattr_setschedparam;

    # Used in macros.
    __sysconf;
  }
  GLIBC_2.2.3 {
    # Extended Interface.
    fnmatch;
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # functions with special/multiple interfaces
    __bsd_getpgrp; __setpgid; __getpgid;

    # functions which have an additional interface since they are
    # are cancelable.
    __libc_wait; __libc_waitpid; __libc_pause; __libc_nanosleep;

    # functions used in other libraries
    __sched_get_priority_max; __sched_get_priority_min;
    __sched_getparam; __sched_getscheduler; __sched_setscheduler;
    __sched_yield; __fork; __getpid; __wait;

    # functions used by libstdc++ 2.7.2
    __waitpid;


    # (introduced GLIBC_2.1)
    # functions used in other libraries
    __pread64; __pwrite64;


    # (introduced GLIBC_2.1.2)
    # functions used in other libraries
    __libc_fork; __vfork;

    # (introduced GLIBC_2.1.3)
    # For the cancelation wrappers.
    __libc_pread; __libc_pread64; __libc_pwrite; __libc_pwrite64;
  }
}

#------------------------------------------------------------------------
# FILE: pwd/Versions
#
libc {
  GLIBC_2.0 {
    # e*
    endpwent;

    # f*
    fgetpwent; fgetpwent_r;

    # g*
    getpw; getpwent; getpwent_r; getpwnam; getpwnam_r; getpwuid; getpwuid_r;

    # p*
    putpwent; setpwent;
  }
  GLIBC_2.1.2 {
    # g*
    getpwent_r; getpwuid_r; getpwnam_r;
  }
}

#------------------------------------------------------------------------
# FILE: resolv/Versions
#
libc {
  GLIBC_2.0 {
    # global variables
    _h_errno; _res;

    # helper functions
    __h_errno_location;

    # variables in normal name space
    h_errlist; h_errno; h_nerr;

    # h*
    herror; hstrerror;

    # r*
    res_init;
  }
  GLIBC_2.2 {
    # r*
    __res_state; __res_init; __res_nclose; __res_ninit; _res_hconf;
  }
  GLIBC_2.2.3 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # functions used in other libraries
    __res_randomid;


    # (introduced GLIBC_2.2.3)
    __gai_sigqueue;
  }
}

libresolv {
  GLIBC_2.0 {
    _gethtbyaddr; _gethtbyname; _gethtbyname2; _gethtent; _getlong;
    _getshort; _res_opcodes; _res_resultcodes; _sethtent; dn_expand;
    inet_net_ntop; inet_net_pton; inet_neta; res_gethostbyaddr;
    res_gethostbyname; res_gethostbyname2; res_mkquery; res_query;
    res_querydomain; res_search; res_send_setqhook; res_send_setrhook;
  }
  GLIBC_2.1 {
    # empty now
  }
  GLIBC_2.2 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # Variables
    __p_class_syms; __p_type_syms;
    # Private routines shared between libc/net, named, nslookup and others.
    __b64_ntop; __b64_pton;
    __dn_comp;  __dn_count_labels; __dn_skipname;
    __fp_nquery; __fp_query; __fp_resstat; __hostalias;
    __loc_aton; __loc_ntoa;
    __p_cdname; __p_cdnname; __p_class; __p_fqname; __p_fqnname; __p_option;
    __p_query; __p_rr; __p_secstodate; __p_time; __p_type;
    __putlong; __putshort;
    __res_close; __res_dnok; __res_hnok; __res_isourserver; __res_mailok;
    __res_nameinquery; __res_ownok; __res_queriesmatch;
    __res_send;
    __sym_ntop; __sym_ntos; __sym_ston;

    # (introduced GLIBC_2.1)
    # Needed in libnss_dns.
    __ns_name_unpack; __ns_name_ntop;

    # (introduced GLIBC_2.2)
    __dn_expand;
    __ns_get16; __ns_samename;
    __res_hostalias; __res_mkquery; __res_nmkquery; __res_nquery;
    __res_nquerydomain; __res_nsearch; __res_nsend; __res_query;
    __res_querydomain; __res_search;
  }
}

libnss_dns {
  GLIBC_2.0 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    _nss_dns_gethostbyaddr_r; _nss_dns_gethostbyname2_r;
    _nss_dns_gethostbyname_r; _nss_dns_getnetbyaddr_r;
    _nss_dns_getnetbyname_r;
  }
}

libanl {
  GLIBC_2.2.3 {
    getaddrinfo_a; gai_cancel; gai_error; gai_suspend;
  }
}

#------------------------------------------------------------------------
# FILE: resource/Versions
#
libc {
  GLIBC_2.0 {
    # g*
    getpriority; getrlimit; getrusage;

    # n*
    nice;

    # s*
    setpriority; setrlimit;

    # u*
    ulimit;

    # v*
    vlimit; vtimes;
  }
  GLIBC_2.1 {
    # g*
    getrlimit64;

    # s*
    setrlimit64;
  }
}

#------------------------------------------------------------------------
# FILE: rt/Versions
#
librt {
  GLIBC_2.1 {
    # AIO functions.
    aio_cancel; aio_cancel64; aio_error; aio_error64; aio_fsync; aio_fsync64;
    aio_init; aio_read; aio_read64; aio_return; aio_return64; aio_suspend;
    aio_suspend64; aio_write; aio_write64; lio_listio; lio_listio64;
  }
  GLIBC_2.2 {
    # c*
    clock_getres; clock_gettime; clock_settime; clock_getcpuclockid;
    clock_nanosleep;

    # s*
    shm_open; shm_unlink;

    # t*
    timer_create; timer_delete; timer_getoverrun; timer_gettime;
    timer_settime;
  }
}

#------------------------------------------------------------------------
# FILE: setjmp/Versions
#
libc {
  GLIBC_2.0 {
    # functions with special/multiple interfaces
    _longjmp; __sigsetjmp; _setjmp;

    # l*
    longjmp;

    # s*
    setjmp;
  }
  GLIBC_2.1 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.1)
    # helper functions
    __libc_longjmp; __libc_siglongjmp;
  }
}

#------------------------------------------------------------------------
# FILE: shadow/Versions
#
libc {
  GLIBC_2.0 {
    # e*
    endspent;

    # f*
    fgetspent; fgetspent_r;

    # g*
    getspent; getspent_r; getspnam; getspnam_r;

    # l*
    lckpwdf;

    # p*
    putspent;

    # s*
    setspent;

    # s*
    sgetspent; sgetspent_r;

    # u*
    ulckpwdf;
  }
  GLIBC_2.1.2 {
    # g*
    getspent_r; getspnam_r;
  }
}

#------------------------------------------------------------------------
# FILE: signal/Versions
#
libc {
  GLIBC_2.0 {
    # functions with special/multiple interfaces
    __sigaddset; __sigdelset; __sigismember; __sysv_signal;

    # functions used in inline functions or macros
    __sigpause;

    # b*
    bsd_signal;

    # g*
    gsignal;

    # k*
    kill; killpg;

    # p*
    psignal;

    # r*
    raise;

    # s*
    sigaction; sigaddset; sigaltstack; sigandset; sigblock; sigdelset;
    sigemptyset; sigfillset; siggetmask; siginterrupt; sigisemptyset;
    sigismember; siglongjmp; signal; sigorset; sigpause; sigpending;
    sigprocmask; sigreturn; sigsetmask; sigstack; sigsuspend; sigvec;
    sigwait; ssignal;
  }
  GLIBC_2.1 {
    # helper functions
    __libc_current_sigrtmin; __libc_current_sigrtmax; __libc_allocate_rtsig;

    # s*
    sighold; sigrelse; sigignore; sigset; sysv_signal;

    # New RT signal functions.
    sigqueue; sigtimedwait; sigwaitinfo;
  }
  GLIBC_2.1.3 {
    # empty now
  }
  GLIBC_2.2 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # functions used in other libraries
     __sigaction;


    # (introduced GLIBC_2.1.3)
    # LinuxThreads needs this entry point.
    __sigsuspend;

    # (introduced GLIBC_2.2)
    # Needed to provide a pointer to the XPG sigpause function.
    __xpg_sigpause;
  }
}

#------------------------------------------------------------------------
# FILE: socket/Versions
#
libc {
  GLIBC_2.0 {
    # a*
    accept;

    # b*
    bind;

    # c*
    connect;

    # g*
    getpeername; getsockname; getsockopt;

    # i*
    isfdtype;

    # l*
    listen;

    # r*
    recv; recvfrom; recvmsg;

    # s*
    send; sendmsg; sendto; setsockopt; shutdown; socket; socketpair;
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # functions which have an additional interface since they are
    # are cancelable.
    __libc_accept; __libc_send; __libc_recvfrom;
    __libc_recvmsg; __libc_sendmsg; __libc_recv; __libc_sendto; __libc_connect;

    # functions used in other libraries
    __connect; __send;
  }
}

#------------------------------------------------------------------------
# FILE: stdio/Versions
#
libc {
  GLIBC_2.0 {
    # functions used in inline functions or macros
    __getdelim; __line_wrap_output; __line_wrap_update;
    __vfscanf; __vsscanf;

    # variables in normal name space
    stderr; stdin; stdout;

    # c*
    clearerr;

    # f*
    fclose; fcloseall; fdopen; feof; ferror; fflush; fgetc; fgetpos; fgets;
    fileno; fmemopen; fopen; fopencookie; fputc; fputs; fread; freopen;
    fseek; fsetpos; ftell; fwrite;

    # g*
    getc; getchar; getdelim; gets;

    # l*
    line_wrap_stream; line_unwrap_stream; line_wrapped; line_wrap_lmargin;
    line_wrap_set_lmargin; line_wrap_rmargin; line_wrap_set_rmargin;
    line_wrap_wmargin; line_wrap_set_wmargin; line_wrap_point;

    # o*
    open_memstream; open_obstack_stream; obstack_printf; obstack_vprintf;

    # p*
    pclose; popen; putc; putchar; puts;

    # r*
    rewind;

    # s*
    setbuf; setbuffer; setlinebuf; setvbuf;

    # u*
    ungetc;

    # v*
    vasprintf; vdprintf; vscanf; vsnprintf; vsprintf; vsscanf;
  }
  GLIBC_2.1 {
    # c*
    clearerr_unlocked;

    # f*
    feof_unlocked; ferror_unlocked; fflush_unlocked;  fgets_unlocked;
    fileno_unlocked; fputc_unlocked; fputs_unlocked;
    fread_unlocked; fwrite_unlocked;

    # g*
    getc_unlocked; getchar_unlocked;

    # p*
    putc_unlocked; putchar_unlocked;
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # more or less standard functions
    __fillbf; __flshfp;


    # (introduced GLIBC_2.1)
    # functions used in other libraries
    __asprintf;
  }
}

#------------------------------------------------------------------------
# FILE: stdio-common/Versions
#
libc {
  GLIBC_2.0 {
    # global variables
    _itoa_lower_digits; _itoa_upper_digits; _sys_errlist; _sys_nerr;
    _sys_siglist;

    # functions used in other libraries
    __printf_fp; __vfscanf;

    # variables in normal name space
    sys_errlist; sys_nerr; sys_sigabbrev; sys_siglist;

    # a*
    asprintf;

    # c*
    ctermid; cuserid;

    # d*
    dprintf;

    # f*
    flockfile; fprintf; fscanf; ftrylockfile; funlockfile;

    # g*
    getline; getw;

    # p*
    parse_printf_format; perror; printf; putw;

    # r*
    register_printf_function; remove; rename;

    # s*
    scanf; snprintf; sprintf; sscanf;

    # t*
    tempnam; tmpfile; tmpnam; tmpnam_r;

    # v*
    vfprintf; vfscanf; vprintf; 
  }
  GLIBC_2.1 {
    # p*
    printf_size; printf_size_info;

    # t*
    tmpfile; tmpfile64;
  }
}

#------------------------------------------------------------------------
# FILE: stdlib/Versions
#
libc {
  GLIBC_2.0 {
    # functions with required interface outside normal name space
    __xpg_basename;

    # functions used in inline functions or macros
    __strto*_internal;

    # functions used in other libraries
    __secure_getenv; __on_exit;

    # a*
    a64l; abort; abs; atexit; atof; atoi; atol; atoll;

    # b*
    bsearch;

    # c*
    canonicalize_file_name; clearenv;

    # d*
    div; drand48; drand48_r;

    # e*
    erand48; erand48_r; exit;

    # g*
    getenv; getsubopt;

    # i*
    initstate; initstate_r;

    # l*
    l64a; labs; lcong48; lcong48_r; ldiv; llabs; lldiv; lrand48; lrand48_r;

    # m*
    mblen; mbrlen; mbrtowc; mbsinit; mbsnrtowcs; mbsrtowcs; mbstowcs;
    mbtowc; mcheck; mcount; mrand48; mrand48_r;

    # n*
    nrand48; nrand48_r;

    # o*
    on_exit;

    # p*
    putenv;

    # q*
    qsort;

    # r*
    rand; rand_r; random; random_r; realpath; rpmatch;

    # s*
    seed48; seed48_r; setcontext; setenv; setstate; setstate_r; srand; srand48;
    srand48_r; srandom; srandom_r; step; strfmon; strtod; strtof; strtol;
    strtold; strtoll; strtoq; strtoul; strtoull; strtouq; system;

    # u*
    unsetenv;

    # w*
    wcstombs; wctomb;
  }
  GLIBC_2.1 {
    # a*
    addseverity;

    # f*
    fmtmsg;

    # g*
    getcontext;

    # m*
    makecontext;

    # s*
    strtoimax; strtoumax; swapcontext;
  }
  GLIBC_2.1.1 {
    # i*
    imaxabs; imaxdiv;
  }
  GLIBC_2.1.3 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # functions which have an additional interface since they are
    # are cancelable.
    __libc_system;


    # (introduced GLIBC_2.1.1)
    # _*
    _Exit;


    # (introduced GLIBC_2.1.3)
    # used by new G++ ABI
    __cxa_atexit; __cxa_finalize;
  }
}

#------------------------------------------------------------------------
# FILE: streams/Versions
#
libc {
  GLIBC_2.1 {
    # f*
    fattach; fdetach;

    # g*
    getmsg; getpmsg;

    # i*
    isastream;

    # p*
    putmsg; putpmsg;
  }
}

#------------------------------------------------------------------------
# FILE: string/Versions
#
libc {
  GLIBC_2.0 {
    # functions with required interface outside normal name space
    __argz_count; __argz_stringify; __argz_next;

    # functions used in inline functions or macros
    __bzero; __strtok_r;

    # functions used in other libraries
    __stpncpy; __stpcpy; __strdup; __mempcpy; __strcasecmp; __strerror_r;
    __ffs;

    # a*
    argz_add; argz_add_sep; argz_append; argz_count; argz_create;
    argz_create_sep; argz_delete; argz_extract; argz_insert; argz_next;
    argz_replace; argz_stringify;

    # b*
    basename; bcmp; bcopy; bzero;

    # e*
    envz_add; envz_entry; envz_get; envz_merge; envz_remove;
    envz_strip;

    # f*
    ffs;

    # i*
    index;

    # m*
    memccpy; memchr; memcmp; memcpy; memfrob; memmem; memmove; memset;

    # r*
    rindex;

    # s*
    stpcpy; stpncpy; strcasecmp; strcat; strchr; strcmp; strcoll; strcpy;
    strcspn; strdup; strerror; strerror_r; strfry; strlen; strncasecmp;
    strncat; strncmp; strncpy; strndup; strnlen; strpbrk; strrchr; strsep;
    strsignal; strspn; strstr; strtok; strtok_r; strxfrm; swab;
  }
  GLIBC_2.1 {
    # functions used in macros and other libraries
    __rawmemchr; __strcasestr;

    # f*
    ffsl; ffsll;

    # m*
    mempcpy;

    # r*
    rawmemchr;

    # s*
    strcasestr; strverscmp;
  }
  GLIBC_2.1.1 {
    # extern inline functions used by <bits/string2.h>
    __mempcpy_small; __stpcpy_small; __strcspn_c1; __strcspn_c2; __strcspn_c3;
    __strcpy_small; __strspn_c1; __strspn_c2; __strspn_c3; __strpbrk_c2;
    __strpbrk_c3; __strsep_1c; __strsep_2c; __strsep_3c; __strsep_g;
    __strtok_r_1c;

    # s*
    strchrnul; __strverscmp;
  }
  GLIBC_2.2 {
    # functions used in macros.
    __strndup;

    # m*
    memrchr;
  }
}

#------------------------------------------------------------------------
# FILE: sunrpc/Versions
#
libc {
  GLIBC_2.0 {
    # variables in normal name space
    rpc_createerr; svc_fdset; svcauthdes_stats;

    # a*
    authnone_create; authunix_create; authunix_create_default;

    # b*
    bindresvport;

    # c*
    callrpc;
    clnt_broadcast; clnt_create; clnt_pcreateerror; clnt_perrno;
    clnt_perror; clnt_spcreateerror; clnt_sperrno; clnt_sperror;
    clntraw_create; clnttcp_create; clntudp_bufcreate; clntudp_create;

    # g*
    get_myaddress; getpublickey; getsecretkey;

    # p*
    pmap_getmaps; pmap_getport; pmap_rmtcall; pmap_set; pmap_unset;

    # r*
    registerrpc;

    # s*
    svc_exit; svc_getreq; svc_getreqset; svc_register; svc_run;
    svc_sendreply; svc_unregister; svcerr_auth; svcerr_decode;
    svcerr_noproc; svcerr_noprog; svcerr_progvers; svcerr_systemerr;
    svcerr_weakauth; svcfd_create; svcraw_create; svctcp_create;
    svcudp_bufcreate; svcudp_create; svcudp_enablecache;

    # x*
    xdr_accepted_reply; xdr_array; xdr_authunix_parms; xdr_bool; xdr_bytes;
    xdr_callhdr; xdr_callmsg; xdr_char; xdr_cryptkeyarg; xdr_cryptkeyarg2;
    xdr_cryptkeyres; xdr_des_block; xdr_double; xdr_enum; xdr_float;
    xdr_free; xdr_int; xdr_key_netstarg; xdr_key_netstres; xdr_keybuf;
    xdr_keystatus; xdr_long; xdr_netobj; xdr_opaque; xdr_opaque_auth;
    xdr_pmap; xdr_pmaplist; xdr_pointer; xdr_reference; xdr_rejected_reply;
    xdr_replymsg; xdr_rmtcall_args; xdr_rmtcallres; xdr_short; xdr_string;
    xdr_u_char; xdr_u_int; xdr_u_long; xdr_u_short; xdr_union; xdr_vector;
    xdr_void; xdr_wrapstring; xdrmem_create; xdrrec_create;
    xdrrec_endofrecord; xdrrec_eof; xdrrec_skiprecord; xdrstdio_create;
    xencrypt; xprt_register; xprt_unregister;
  }
  GLIBC_2.1 {
    # _*
    _authenticate;

    # a*
    authdes_create; authdes_getucred; authdes_pk_create;

    # c*
    cbc_crypt; clntunix_create;

    # d*
    des_setparity;

    # e*
    ecb_crypt;

    # g*
    getnetname;

    # h*
    host2netname;

    # k*
    key_decryptsession; key_decryptsession_pk; key_encryptsession;
    key_encryptsession_pk; key_gendes; key_get_conv; key_secretkey_is_set;
    key_setnet; key_setsecret;

    # n*
    netname2host; netname2user;

    # p*
    passwd2des;

    # r*
    rtime;

    # s*
    svcunix_create; svcunixfd_create;

    # u*
    user2netname;

    # x*
    xdecrypt; xdr_authdes_cred; xdr_authdes_verf;
    xdr_getcredres; xdr_int16_t; xdr_int32_t; xdr_int8_t;
    xdr_netnamestr; xdr_sizeof;
    xdr_uint16_t; xdr_uint32_t; xdr_uint8_t; xdr_unixcred;
  }
  GLIBC_2.1.1 {
    xdr_hyper; xdr_u_hyper; xdr_longlong_t; xdr_u_longlong_t;
    xdr_int64_t; xdr_uint64_t;
  }
  GLIBC_2.2 {
    svc_getreq_common; svc_getreq_poll; svc_max_pollfd; svc_pollfd;
  }
  GLIBC_2.2.3 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # global variables.
    _null_auth;

    # functions used in other libraries
    _rpc_dtablesize; _seterr_reply;


    # (introduced GLIBC_2.1)
    # Special Pointer to avoid keyserv deadlock
    __key_decryptsession_pk_LOCAL; __key_encryptsession_pk_LOCAL;
    __key_gendes_LOCAL;


    # (introduced GLIBC_2.2.3)
    __rpc_thread_destroy; __rpc_thread_svc_fdset; __rpc_thread_createerr;
    __rpc_thread_svc_pollfd; __rpc_thread_svc_max_pollfd;
  }
}

#------------------------------------------------------------------------
# FILE: sysvipc/Versions
#
libc {
  GLIBC_2.0 {
    # f*
    ftok;

    # m*
    msgctl; msgget; msgrcv; msgsnd;

    # s*
    semctl; semget; semop; shmat; shmctl; shmdt; shmget;
  }
}

#------------------------------------------------------------------------
# FILE: termios/Versions
#
libc {
  GLIBC_2.0 {
    # c*
    cfgetispeed; cfgetospeed; cfmakeraw; cfsetispeed; cfsetospeed; cfsetspeed;

    # t*
    tcdrain; tcflow; tcflush; tcgetattr; tcgetpgrp; tcsendbreak; tcsetattr;
    tcsetpgrp;
  }
  GLIBC_2.1 {
    # t*
    tcgetsid;
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # functions which have an additional interface since they are
    # are cancelable.
    __libc_tcdrain;
  }
}

#------------------------------------------------------------------------
# FILE: time/Versions
#
libc {
  GLIBC_2.0 {
    # global variables
    __timezone; __daylight; __tzname;

    # variables in normal name space
    daylight; timezone; tzname;

    # a*
    adjtime; adjtimex; asctime; asctime_r;

    # c*
    clock; ctime; ctime_r;

    # d*
    difftime; dysize;

    # f*
    ftime;

    # g*
    getitimer; gettimeofday; gmtime; gmtime_r;

    # l*
    localtime; localtime_r;

    # m*
    mktime;

    # s*
    setitimer; settimeofday; stime; strftime; strptime;

    # t*
    time; timegm; timelocal; tzset;
  }
  GLIBC_2.1 {
    # variables in normal name space
    getdate_err;

    # g*
    getdate; getdate_r;
  }
  GLIBC_2.2 {
    # w*
    wcsftime;
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # functions with special/multiple interfaces
    __adjtimex;

    # functions used in other libraries
    __gmtime_r; __gettimeofday;
  }
}

#------------------------------------------------------------------------
# FILE: wcsmbs/Versions
#
libc {
  GLIBC_2.0 {
    # functions used in inline functions or macros
    __wcsto*_internal; __mbrlen; __mbrtowc;

    # b*
    btowc;

    # w*
    wcpcpy; wcpncpy; wcrtomb; wcscat; wcschr; wcscmp; wcscoll;
    wcscpy; wcscspn; wcsdup; wcslen; wcsncat; wcsncmp;
    wcsncpy; wcsnrtombs; wcspbrk; wcsrchr; wcsrtombs; wcsspn; wcsstr;
    wcstod; wcstof; wcstok; wcstol; wcstold; wcstoq; wcstoul;
    wcstouq; wcswidth; wcsxfrm; wctob;

    wmemchr; wmemcmp; wmemcpy; wmemmove; wmemset;
  }
  GLIBC_2.1 {
    # w*
    wcscasecmp; wcsncasecmp; wcsnlen; wcstoll;
    wcstoimax; wcstoumax; wcstoull; wcswcs; wmemrtombs; wmemrtowcs;
  }
  GLIBC_2.2 {
    # w*
    wcschrnul; wmempcpy;
  }
}

#------------------------------------------------------------------------
# FILE: wctype/Versions
#
libc {
  GLIBC_2.0 {
    # functions used in inline functions or macros
    __iswctype;

    # i*
    iswalnum; iswalpha; iswcntrl; iswctype; iswdigit; iswgraph; iswlower;
    iswprint; iswpunct; iswspace; iswupper; iswxdigit;

    # t*
    towctrans; towlower; towupper;

    # w*
    wctrans; wctype; wcwidth;
  }
  GLIBC_2.1 {
    # functions used in inline functions or macros
    __towctrans;

    # i*
    iswblank;
  }
}

#------------------------------------------------------------------------
# FILE: linuxthreads/Versions
#
libc {
  GLIBC_2.0 {
    pthread_attr_destroy; pthread_attr_getdetachstate;
    pthread_attr_getinheritsched; pthread_attr_getschedparam;
    pthread_attr_getschedpolicy; pthread_attr_getscope; pthread_attr_init;
    pthread_attr_setdetachstate; pthread_attr_setinheritsched;
    pthread_attr_setschedparam; pthread_attr_setschedpolicy;
    pthread_attr_setscope; pthread_cond_broadcast; pthread_cond_destroy;
    pthread_cond_init; pthread_cond_signal; pthread_cond_wait;
    pthread_condattr_destroy; pthread_condattr_init; pthread_equal;
    pthread_exit; pthread_getschedparam; pthread_mutex_destroy;
    pthread_mutex_init; pthread_mutex_lock; pthread_mutex_unlock;
    pthread_mutexattr_getkind_np; pthread_mutexattr_setkind_np;
    pthread_self; pthread_setcancelstate; pthread_setcanceltype;
    pthread_setschedparam;

  }
  GLIBC_2.1 {
    pthread_attr_init;
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # Internal libc interface to libpthread
    __libc_internal_tsd_get; __libc_internal_tsd_set;
  }
}

ld {
  GLIBC_2.0 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # Internal libc interface to libpthread
    __libc_internal_tsd_get; __libc_internal_tsd_set;
  }
}

libpthread {
  GLIBC_2.0 {
    # Hidden entry point (through macros).
    _pthread_cleanup_pop; _pthread_cleanup_pop_restore; _pthread_cleanup_push;
    _pthread_cleanup_push_defer;

    # Overwritten libc functions.
    accept; close; connect; fcntl; fork; fsync; longjmp; lseek; msync;
    nanosleep; open; pause; raise; read; recv; recvfrom; recvmsg; send;
    sendmsg; sendto; sigaction; siglongjmp; system; tcdrain; wait;
    waitpid; write;
    __close; __connect; __fcntl; __lseek; __open; __read; __send; __wait;
    __write;
    _IO_flockfile; _IO_ftrylockfile; _IO_funlockfile;
    vfork; __fork;

    # POSIX.1c extensions to libc.
    flockfile; funlockfile; ftrylockfile;

    # Non-standard POSIX1.x functions.
    pthread_kill_other_threads_np; pthread_mutexattr_getkind_np;
    pthread_mutexattr_setkind_np;

    # Real POSIX.1c functions.
    pthread_atfork; pthread_attr_destroy; pthread_attr_getdetachstate;
    pthread_attr_getinheritsched; pthread_attr_getschedparam;
    pthread_attr_getschedpolicy; pthread_attr_getscope; pthread_attr_init;
    pthread_attr_setdetachstate; pthread_attr_setinheritsched;
    pthread_attr_setschedparam; pthread_attr_setschedpolicy;
    pthread_attr_setscope; pthread_cancel; pthread_cond_broadcast;
    pthread_cond_destroy; pthread_cond_init; pthread_cond_signal;
    pthread_cond_timedwait; pthread_cond_wait; pthread_condattr_destroy;
    pthread_condattr_init; pthread_create; pthread_detach; pthread_equal;
    pthread_exit; pthread_getschedparam; pthread_getspecific; pthread_join;
    pthread_key_create; pthread_key_delete; pthread_kill;
    pthread_mutex_destroy; pthread_mutex_init; pthread_mutex_lock;
    pthread_mutex_trylock; pthread_mutex_unlock; pthread_mutexattr_destroy;
    pthread_mutexattr_init; pthread_once; pthread_self; pthread_setcancelstate;
    pthread_setcanceltype; pthread_setschedparam; pthread_setspecific;
    pthread_sigmask; pthread_testcancel;

    sem_destroy; sem_getvalue; sem_init; sem_post; sem_trywait; sem_wait;
    sigwait;

    # The error functions.
    __errno_location; __h_errno_location;

  }
  GLIBC_2.1 {
    # Functions with changed interface.
    pthread_attr_init; pthread_create;

    # Unix98 extensions.
    pthread_rwlock_init; pthread_rwlock_destroy; pthread_rwlock_rdlock;
    pthread_rwlock_tryrdlock; pthread_rwlock_wrlock; pthread_rwlock_trywrlock;
    pthread_rwlock_unlock; pthread_rwlockattr_init; pthread_rwlockattr_destroy;
    pthread_rwlockattr_getpshared; pthread_rwlockattr_setpshared;
    pthread_rwlockattr_getkind_np; pthread_rwlockattr_setkind_np;

    pthread_attr_getguardsize; pthread_attr_setguardsize;
    pthread_attr_getstackaddr; pthread_attr_setstackaddr;
    pthread_attr_getstacksize; pthread_attr_setstacksize;

    pthread_getconcurrency; pthread_setconcurrency;

    pthread_mutexattr_gettype; pthread_mutexattr_settype;

    sem_destroy; sem_getvalue; sem_init; sem_post; sem_trywait; sem_wait;

  }
  GLIBC_2.1.1 {
    sem_close; sem_open; sem_unlink;
  }
  GLIBC_2.1.2 {
    # empty now
  }
  GLIBC_2.2 {
    # For the cancelation wrappers.
    pread; __pread64; pread64; pwrite; __pwrite64; pwrite64; lseek64;
    open64; __open64;

    __res_state;

    # No really implemented.
    pthread_condattr_getpshared; pthread_condattr_setpshared;
    pthread_mutexattr_getpshared; pthread_mutexattr_setpshared;

    # New functions from IEEE Std. 1003.1-200x.
    sem_timedwait;
    pthread_attr_getstack; pthread_attr_setstack;
    pthread_spin_destroy; pthread_spin_init; pthread_spin_lock;
    pthread_spin_trylock; pthread_spin_unlock;
    pthread_getcpuclockid;
    pthread_barrier_destroy; pthread_barrier_init; pthread_barrier_wait;
    pthread_barrierattr_destroy; pthread_barrierattr_init;
    pthread_barrierattr_getpshared; pthread_barrierattr_setpshared;
    pthread_mutex_timedlock;
    pthread_rwlock_timedrdlock; pthread_rwlock_timedwrlock;

    # Extensions.
    pthread_yield;
  }
  GLIBC_2.2.3 {
    # Extensions.
    pthread_getattr_np;
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.0)
    # Internal libc interface to libpthread
    __libc_internal_tsd_get; __libc_internal_tsd_set;

    # Protected names for functions used in other shared objects.
    __pthread_atfork; __pthread_initialize; __pthread_getspecific;
    __pthread_key_create; __pthread_mutex_destroy; __pthread_mutex_init;
    __pthread_mutex_lock; __pthread_mutex_trylock; __pthread_mutex_unlock;
    __pthread_mutexattr_destroy; __pthread_mutexattr_init;
    __pthread_mutexattr_settype; __pthread_once; __pthread_setspecific;

    # Must be preemptible
    __sigaction;

    # (introduced GLIBC_2.1)
    # helper functions
    __libc_current_sigrtmin; __libc_current_sigrtmax;
    __libc_allocate_rtsig;

    # (introduced GLIBC_2.1.2)
    __pthread_kill_other_threads_np;
    __vfork;

    # (introduced GLIBC_2.2)
    # Names used internally.
    __pthread_rwlock_init; __pthread_rwlock_destroy; __pthread_rwlock_rdlock;
    __pthread_rwlock_tryrdlock; __pthread_rwlock_wrlock;
    __pthread_rwlock_trywrlock; __pthread_rwlock_unlock;
  }
}

#------------------------------------------------------------------------
# FILE: linuxthreads/sysdeps/i386/i586/Versions
#
libpthread {
  GLIBC_2.2.3 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.2.3)
    __pthread_clock_gettime; __pthread_clock_settime;
  }
}

#------------------------------------------------------------------------
# FILE: linuxthreads/sysdeps/ia64/Versions
#
libpthread {
  GLIBC_2.2.3 {
    # empty now
  }

  ; # distinct private node
  GLIBC_PRIVATE {
    # (introduced GLIBC_2.2.3)
    __pthread_clock_gettime; __pthread_clock_settime;
  }
}

#------------------------------------------------------------------------
# FILE: linuxthreads_db/Versions
#
libthread_db {
  GLIBC_2.1.3 {
    # t*
    td_init; td_log; td_ta_clear_event; td_ta_delete; td_ta_enable_stats;
    td_ta_event_addr; td_ta_event_getmsg; td_ta_get_nthreads; td_ta_get_ph;
    td_ta_get_stats; td_ta_map_id2thr; td_ta_map_lwp2thr; td_ta_new;
    td_ta_reset_stats; td_ta_set_event; td_ta_setconcurrency;
    td_ta_thr_iter; td_ta_tsd_iter; td_thr_clear_event; td_thr_dbresume;
    td_thr_dbsuspend; td_thr_event_enable; td_thr_event_getmsg;
    td_thr_get_info; td_thr_getfpregs; td_thr_getgregs; td_thr_getxregs;
    td_thr_getxregsize; td_thr_set_event; td_thr_setfpregs; td_thr_setgregs;
    td_thr_setprio; td_thr_setsigpending; td_thr_setxregs; td_thr_sigsetmask;
    td_thr_tsd; td_thr_validate;
  }
  GLIBC_2.2.3 {
    td_symbol_list;
  }
}