From 307d98dc35354c6562bb0c12cc79710f6b8a4c01 Mon Sep 17 00:00:00 2001 From: Isaac Freund Date: Fri, 11 Dec 2020 15:31:23 +0100 Subject: [PATCH 1/3] stage2: support dynamically linking musl libc --- lib/libc/musl/libc.s | 5097 ++++++++++++++++++++++++++++++++++++++++++ src/Compilation.zig | 5 +- src/link/Elf.zig | 5 +- src/musl.zig | 53 + tools/gen_stubs.zig | 117 + 5 files changed, 5275 insertions(+), 2 deletions(-) create mode 100644 lib/libc/musl/libc.s create mode 100644 tools/gen_stubs.zig diff --git a/lib/libc/musl/libc.s b/lib/libc/musl/libc.s new file mode 100644 index 0000000000..c7a3bf10a8 --- /dev/null +++ b/lib/libc/musl/libc.s @@ -0,0 +1,5097 @@ +.bss +.weak ___environ +.type ___environ, @object; +___environ: +.globl __daylight +.type __daylight, @object; +__daylight: +.globl __environ +.type __environ, @object; +__environ: +.globl __optpos +.type __optpos, @object; +__optpos: +.globl __optreset +.type __optreset, @object; +__optreset: +.globl __progname +.type __progname, @object; +__progname: +.globl __progname_full +.type __progname_full, @object; +__progname_full: +.globl __signgam +.type __signgam, @object; +__signgam: +.globl __stack_chk_guard +.type __stack_chk_guard, @object; +__stack_chk_guard: +.globl __timezone +.type __timezone, @object; +__timezone: +.globl __tzname +.type __tzname, @object; +__tzname: +.weak _environ +.type _environ, @object; +_environ: +.weak daylight +.type daylight, @object; +daylight: +.weak environ +.type environ, @object; +environ: +.globl getdate_err +.type getdate_err, @object; +getdate_err: +.globl h_errno +.type h_errno, @object; +h_errno: +.globl optarg +.type optarg, @object; +optarg: +.globl optopt +.type optopt, @object; +optopt: +.weak optreset +.type optreset, @object; +optreset: +.weak program_invocation_name +.type program_invocation_name, @object; +program_invocation_name: +.weak program_invocation_short_name +.type program_invocation_short_name, @object; +program_invocation_short_name: +.weak signgam +.type signgam, @object; +signgam: +.weak timezone +.type timezone, @object; +timezone: +.weak tzname +.type tzname, @object; +tzname: +.data +.globl _dl_debug_addr +.type _dl_debug_addr, @object; +_dl_debug_addr: +.globl opterr +.type opterr, @object; +opterr: +.globl optind +.type optind, @object; +optind: +.data.rel.ro +.globl stderr +.type stderr, @object; +stderr: +.globl stdin +.type stdin, @object; +stdin: +.globl stdout +.type stdout, @object; +stdout: +.rodata +.globl _ns_flagdata +.type _ns_flagdata, @object; +_ns_flagdata: +.globl in6addr_any +.type in6addr_any, @object; +in6addr_any: +.globl in6addr_loopback +.type in6addr_loopback, @object; +in6addr_loopback: +.text +.globl _Exit +.type _Exit, @function; +_Exit: +.weak _IO_feof_unlocked +.type _IO_feof_unlocked, @function; +_IO_feof_unlocked: +.weak _IO_ferror_unlocked +.type _IO_ferror_unlocked, @function; +_IO_ferror_unlocked: +.weak _IO_getc +.type _IO_getc, @function; +_IO_getc: +.weak _IO_getc_unlocked +.type _IO_getc_unlocked, @function; +_IO_getc_unlocked: +.weak _IO_putc +.type _IO_putc, @function; +_IO_putc: +.weak _IO_putc_unlocked +.type _IO_putc_unlocked, @function; +_IO_putc_unlocked: +.globl __assert_fail +.type __assert_fail, @function; +__assert_fail: +.globl __ctype_b_loc +.type __ctype_b_loc, @function; +__ctype_b_loc: +.globl __ctype_get_mb_cur_max +.type __ctype_get_mb_cur_max, @function; +__ctype_get_mb_cur_max: +.globl __ctype_tolower_loc +.type __ctype_tolower_loc, @function; +__ctype_tolower_loc: +.globl __ctype_toupper_loc +.type __ctype_toupper_loc, @function; +__ctype_toupper_loc: +.globl __cxa_atexit +.type __cxa_atexit, @function; +__cxa_atexit: +.globl __cxa_finalize +.type __cxa_finalize, @function; +__cxa_finalize: +.globl __dls2b +.type __dls2b, @function; +__dls2b: +.globl __dls3 +.type __dls3, @function; +__dls3: +.globl __duplocale +.type __duplocale, @function; +__duplocale: +.globl __errno_location +.type __errno_location, @function; +__errno_location: +.globl __fbufsize +.type __fbufsize, @function; +__fbufsize: +.globl __fgetwc_unlocked +.type __fgetwc_unlocked, @function; +__fgetwc_unlocked: +.globl __flbf +.type __flbf, @function; +__flbf: +.globl __flt_rounds +.type __flt_rounds, @function; +__flt_rounds: +.globl __fpclassify +.type __fpclassify, @function; +__fpclassify: +.globl __fpclassifyf +.type __fpclassifyf, @function; +__fpclassifyf: +.globl __fpclassifyl +.type __fpclassifyl, @function; +__fpclassifyl: +.globl __fpending +.type __fpending, @function; +__fpending: +.globl __fpurge +.type __fpurge, @function; +__fpurge: +.globl __fputwc_unlocked +.type __fputwc_unlocked, @function; +__fputwc_unlocked: +.globl __freadable +.type __freadable, @function; +__freadable: +.globl __freadahead +.type __freadahead, @function; +__freadahead: +.globl __freading +.type __freading, @function; +__freading: +.globl __freadptr +.type __freadptr, @function; +__freadptr: +.globl __freadptrinc +.type __freadptrinc, @function; +__freadptrinc: +.weak __freelocale +.type __freelocale, @function; +__freelocale: +.globl __fseterr +.type __fseterr, @function; +__fseterr: +.globl __fsetlocking +.type __fsetlocking, @function; +__fsetlocking: +.globl __fwritable +.type __fwritable, @function; +__fwritable: +.globl __fwriting +.type __fwriting, @function; +__fwriting: +.globl __fxstat +.type __fxstat, @function; +__fxstat: +.weak __fxstat64 +.type __fxstat64, @function; +__fxstat64: +.globl __fxstatat +.type __fxstatat, @function; +__fxstatat: +.weak __fxstatat64 +.type __fxstatat64, @function; +__fxstatat64: +.weak __getdelim +.type __getdelim, @function; +__getdelim: +.globl __h_errno_location +.type __h_errno_location, @function; +__h_errno_location: +.globl __isalnum_l +.type __isalnum_l, @function; +__isalnum_l: +.globl __isalpha_l +.type __isalpha_l, @function; +__isalpha_l: +.globl __isblank_l +.type __isblank_l, @function; +__isblank_l: +.globl __iscntrl_l +.type __iscntrl_l, @function; +__iscntrl_l: +.globl __isdigit_l +.type __isdigit_l, @function; +__isdigit_l: +.globl __isgraph_l +.type __isgraph_l, @function; +__isgraph_l: +.globl __islower_l +.type __islower_l, @function; +__islower_l: +.weak __isoc99_fscanf +.type __isoc99_fscanf, @function; +__isoc99_fscanf: +.weak __isoc99_fwscanf +.type __isoc99_fwscanf, @function; +__isoc99_fwscanf: +.weak __isoc99_scanf +.type __isoc99_scanf, @function; +__isoc99_scanf: +.weak __isoc99_sscanf +.type __isoc99_sscanf, @function; +__isoc99_sscanf: +.weak __isoc99_swscanf +.type __isoc99_swscanf, @function; +__isoc99_swscanf: +.weak __isoc99_vfscanf +.type __isoc99_vfscanf, @function; +__isoc99_vfscanf: +.weak __isoc99_vfwscanf +.type __isoc99_vfwscanf, @function; +__isoc99_vfwscanf: +.weak __isoc99_vscanf +.type __isoc99_vscanf, @function; +__isoc99_vscanf: +.weak __isoc99_vsscanf +.type __isoc99_vsscanf, @function; +__isoc99_vsscanf: +.weak __isoc99_vswscanf +.type __isoc99_vswscanf, @function; +__isoc99_vswscanf: +.weak __isoc99_vwscanf +.type __isoc99_vwscanf, @function; +__isoc99_vwscanf: +.weak __isoc99_wscanf +.type __isoc99_wscanf, @function; +__isoc99_wscanf: +.globl __isprint_l +.type __isprint_l, @function; +__isprint_l: +.globl __ispunct_l +.type __ispunct_l, @function; +__ispunct_l: +.globl __isspace_l +.type __isspace_l, @function; +__isspace_l: +.globl __isupper_l +.type __isupper_l, @function; +__isupper_l: +.globl __iswalnum_l +.type __iswalnum_l, @function; +__iswalnum_l: +.globl __iswalpha_l +.type __iswalpha_l, @function; +__iswalpha_l: +.globl __iswblank_l +.type __iswblank_l, @function; +__iswblank_l: +.globl __iswcntrl_l +.type __iswcntrl_l, @function; +__iswcntrl_l: +.globl __iswctype_l +.type __iswctype_l, @function; +__iswctype_l: +.globl __iswdigit_l +.type __iswdigit_l, @function; +__iswdigit_l: +.globl __iswgraph_l +.type __iswgraph_l, @function; +__iswgraph_l: +.globl __iswlower_l +.type __iswlower_l, @function; +__iswlower_l: +.globl __iswprint_l +.type __iswprint_l, @function; +__iswprint_l: +.globl __iswpunct_l +.type __iswpunct_l, @function; +__iswpunct_l: +.globl __iswspace_l +.type __iswspace_l, @function; +__iswspace_l: +.globl __iswupper_l +.type __iswupper_l, @function; +__iswupper_l: +.globl __iswxdigit_l +.type __iswxdigit_l, @function; +__iswxdigit_l: +.globl __isxdigit_l +.type __isxdigit_l, @function; +__isxdigit_l: +.globl __lgammal_r +.type __lgammal_r, @function; +__lgammal_r: +.globl __libc_current_sigrtmax +.type __libc_current_sigrtmax, @function; +__libc_current_sigrtmax: +.globl __libc_current_sigrtmin +.type __libc_current_sigrtmin, @function; +__libc_current_sigrtmin: +.globl __libc_start_main +.type __libc_start_main, @function; +__libc_start_main: +.globl __lxstat +.type __lxstat, @function; +__lxstat: +.weak __lxstat64 +.type __lxstat64, @function; +__lxstat64: +.globl __newlocale +.type __newlocale, @function; +__newlocale: +.globl __nl_langinfo +.type __nl_langinfo, @function; +__nl_langinfo: +.globl __nl_langinfo_l +.type __nl_langinfo_l, @function; +__nl_langinfo_l: +.globl __overflow +.type __overflow, @function; +.protected __overflow +__overflow: +.weak __posix_getopt +.type __posix_getopt, @function; +__posix_getopt: +.globl __res_state +.type __res_state, @function; +__res_state: +.globl __sched_cpucount +.type __sched_cpucount, @function; +__sched_cpucount: +.globl __setjmp +.type __setjmp, @function; +__setjmp: +.globl __signbit +.type __signbit, @function; +__signbit: +.globl __signbitf +.type __signbitf, @function; +__signbitf: +.globl __signbitl +.type __signbitl, @function; +__signbitl: +.globl __sigsetjmp +.type __sigsetjmp, @function; +__sigsetjmp: +.globl __stack_chk_fail +.type __stack_chk_fail, @function; +__stack_chk_fail: +.globl __strcasecmp_l +.type __strcasecmp_l, @function; +__strcasecmp_l: +.globl __strcoll_l +.type __strcoll_l, @function; +__strcoll_l: +.globl __strerror_l +.type __strerror_l, @function; +__strerror_l: +.globl __strncasecmp_l +.type __strncasecmp_l, @function; +__strncasecmp_l: +.weak __strtod_l +.type __strtod_l, @function; +__strtod_l: +.weak __strtof_l +.type __strtof_l, @function; +__strtof_l: +.weak __strtoimax_internal +.type __strtoimax_internal, @function; +__strtoimax_internal: +.weak __strtol_internal +.type __strtol_internal, @function; +__strtol_internal: +.weak __strtold_l +.type __strtold_l, @function; +__strtold_l: +.weak __strtoll_internal +.type __strtoll_internal, @function; +__strtoll_internal: +.weak __strtoul_internal +.type __strtoul_internal, @function; +__strtoul_internal: +.weak __strtoull_internal +.type __strtoull_internal, @function; +__strtoull_internal: +.weak __strtoumax_internal +.type __strtoumax_internal, @function; +__strtoumax_internal: +.globl __strxfrm_l +.type __strxfrm_l, @function; +__strxfrm_l: +.weak __sysv_signal +.type __sysv_signal, @function; +__sysv_signal: +.globl __tls_get_addr +.type __tls_get_addr, @function; +__tls_get_addr: +.globl __tolower_l +.type __tolower_l, @function; +__tolower_l: +.globl __toupper_l +.type __toupper_l, @function; +__toupper_l: +.globl __towctrans_l +.type __towctrans_l, @function; +__towctrans_l: +.globl __towlower_l +.type __towlower_l, @function; +__towlower_l: +.globl __towupper_l +.type __towupper_l, @function; +__towupper_l: +.globl __uflow +.type __uflow, @function; +.protected __uflow +__uflow: +.globl __uselocale +.type __uselocale, @function; +__uselocale: +.globl __wcscoll_l +.type __wcscoll_l, @function; +__wcscoll_l: +.globl __wcsftime_l +.type __wcsftime_l, @function; +__wcsftime_l: +.globl __wcsxfrm_l +.type __wcsxfrm_l, @function; +__wcsxfrm_l: +.globl __wctrans_l +.type __wctrans_l, @function; +__wctrans_l: +.globl __wctype_l +.type __wctype_l, @function; +__wctype_l: +.globl __xmknod +.type __xmknod, @function; +__xmknod: +.globl __xmknodat +.type __xmknodat, @function; +__xmknodat: +.weak __xpg_basename +.type __xpg_basename, @function; +__xpg_basename: +.weak __xpg_strerror_r +.type __xpg_strerror_r, @function; +__xpg_strerror_r: +.globl __xstat +.type __xstat, @function; +__xstat: +.weak __xstat64 +.type __xstat64, @function; +__xstat64: +.weak _dl_debug_state +.type _dl_debug_state, @function; +_dl_debug_state: +.globl _dlstart +_dlstart: +.globl _exit +.type _exit, @function; +_exit: +.weak _fini +.type _fini, @function; +_fini: +.globl _flushlbf +.type _flushlbf, @function; +_flushlbf: +.weak _init +.type _init, @function; +_init: +.globl _longjmp +.type _longjmp, @function; +_longjmp: +.globl _pthread_cleanup_pop +.type _pthread_cleanup_pop, @function; +_pthread_cleanup_pop: +.globl _pthread_cleanup_push +.type _pthread_cleanup_push, @function; +_pthread_cleanup_push: +.globl _setjmp +.type _setjmp, @function; +_setjmp: +.globl a64l +.type a64l, @function; +a64l: +.globl abort +.type abort, @function; +abort: +.globl abs +.type abs, @function; +abs: +.globl accept +.type accept, @function; +accept: +.globl accept4 +.type accept4, @function; +accept4: +.globl access +.type access, @function; +access: +.globl acct +.type acct, @function; +acct: +.globl acos +.type acos, @function; +acos: +.globl acosf +.type acosf, @function; +acosf: +.globl acosh +.type acosh, @function; +acosh: +.globl acoshf +.type acoshf, @function; +acoshf: +.globl acoshl +.type acoshl, @function; +acoshl: +.globl acosl +.type acosl, @function; +acosl: +.globl addmntent +.type addmntent, @function; +addmntent: +.globl adjtime +.type adjtime, @function; +adjtime: +.globl adjtimex +.type adjtimex, @function; +adjtimex: +.globl aio_cancel +.type aio_cancel, @function; +aio_cancel: +.weak aio_cancel64 +.type aio_cancel64, @function; +aio_cancel64: +.globl aio_error +.type aio_error, @function; +aio_error: +.weak aio_error64 +.type aio_error64, @function; +aio_error64: +.globl aio_fsync +.type aio_fsync, @function; +aio_fsync: +.weak aio_fsync64 +.type aio_fsync64, @function; +aio_fsync64: +.globl aio_read +.type aio_read, @function; +aio_read: +.weak aio_read64 +.type aio_read64, @function; +aio_read64: +.globl aio_return +.type aio_return, @function; +aio_return: +.weak aio_return64 +.type aio_return64, @function; +aio_return64: +.globl aio_suspend +.type aio_suspend, @function; +aio_suspend: +.weak aio_suspend64 +.type aio_suspend64, @function; +aio_suspend64: +.globl aio_write +.type aio_write, @function; +aio_write: +.weak aio_write64 +.type aio_write64, @function; +aio_write64: +.globl alarm +.type alarm, @function; +alarm: +.globl aligned_alloc +.type aligned_alloc, @function; +aligned_alloc: +.globl alphasort +.type alphasort, @function; +alphasort: +.weak alphasort64 +.type alphasort64, @function; +alphasort64: +.globl arch_prctl +.type arch_prctl, @function; +arch_prctl: +.globl asctime +.type asctime, @function; +asctime: +.weak asctime_r +.type asctime_r, @function; +asctime_r: +.globl asin +.type asin, @function; +asin: +.globl asinf +.type asinf, @function; +asinf: +.globl asinh +.type asinh, @function; +asinh: +.globl asinhf +.type asinhf, @function; +asinhf: +.globl asinhl +.type asinhl, @function; +asinhl: +.globl asinl +.type asinl, @function; +asinl: +.globl asprintf +.type asprintf, @function; +asprintf: +.globl at_quick_exit +.type at_quick_exit, @function; +at_quick_exit: +.globl atan +.type atan, @function; +atan: +.globl atan2 +.type atan2, @function; +atan2: +.globl atan2f +.type atan2f, @function; +atan2f: +.globl atan2l +.type atan2l, @function; +atan2l: +.globl atanf +.type atanf, @function; +atanf: +.globl atanh +.type atanh, @function; +atanh: +.globl atanhf +.type atanhf, @function; +atanhf: +.globl atanhl +.type atanhl, @function; +atanhl: +.globl atanl +.type atanl, @function; +atanl: +.globl atexit +.type atexit, @function; +atexit: +.globl atof +.type atof, @function; +atof: +.globl atoi +.type atoi, @function; +atoi: +.globl atol +.type atol, @function; +atol: +.globl atoll +.type atoll, @function; +atoll: +.globl basename +.type basename, @function; +basename: +.globl bcmp +.type bcmp, @function; +bcmp: +.globl bcopy +.type bcopy, @function; +bcopy: +.globl bind +.type bind, @function; +bind: +.globl bind_textdomain_codeset +.type bind_textdomain_codeset, @function; +bind_textdomain_codeset: +.globl bindtextdomain +.type bindtextdomain, @function; +bindtextdomain: +.globl brk +.type brk, @function; +brk: +.weak bsd_signal +.type bsd_signal, @function; +bsd_signal: +.globl bsearch +.type bsearch, @function; +bsearch: +.globl btowc +.type btowc, @function; +btowc: +.globl bzero +.type bzero, @function; +bzero: +.globl c16rtomb +.type c16rtomb, @function; +c16rtomb: +.globl c32rtomb +.type c32rtomb, @function; +c32rtomb: +.globl cabs +.type cabs, @function; +cabs: +.globl cabsf +.type cabsf, @function; +cabsf: +.globl cabsl +.type cabsl, @function; +cabsl: +.globl cacos +.type cacos, @function; +cacos: +.globl cacosf +.type cacosf, @function; +cacosf: +.globl cacosh +.type cacosh, @function; +cacosh: +.globl cacoshf +.type cacoshf, @function; +cacoshf: +.globl cacoshl +.type cacoshl, @function; +cacoshl: +.globl cacosl +.type cacosl, @function; +cacosl: +.globl call_once +.type call_once, @function; +call_once: +.globl calloc +.type calloc, @function; +calloc: +.globl capget +.type capget, @function; +capget: +.globl capset +.type capset, @function; +capset: +.globl carg +.type carg, @function; +carg: +.globl cargf +.type cargf, @function; +cargf: +.globl cargl +.type cargl, @function; +cargl: +.globl casin +.type casin, @function; +casin: +.globl casinf +.type casinf, @function; +casinf: +.globl casinh +.type casinh, @function; +casinh: +.globl casinhf +.type casinhf, @function; +casinhf: +.globl casinhl +.type casinhl, @function; +casinhl: +.globl casinl +.type casinl, @function; +casinl: +.globl catan +.type catan, @function; +catan: +.globl catanf +.type catanf, @function; +catanf: +.globl catanh +.type catanh, @function; +catanh: +.globl catanhf +.type catanhf, @function; +catanhf: +.globl catanhl +.type catanhl, @function; +catanhl: +.globl catanl +.type catanl, @function; +catanl: +.globl catclose +.type catclose, @function; +catclose: +.globl catgets +.type catgets, @function; +catgets: +.globl catopen +.type catopen, @function; +catopen: +.globl cbrt +.type cbrt, @function; +cbrt: +.globl cbrtf +.type cbrtf, @function; +cbrtf: +.globl cbrtl +.type cbrtl, @function; +cbrtl: +.globl ccos +.type ccos, @function; +ccos: +.globl ccosf +.type ccosf, @function; +ccosf: +.globl ccosh +.type ccosh, @function; +ccosh: +.globl ccoshf +.type ccoshf, @function; +ccoshf: +.globl ccoshl +.type ccoshl, @function; +ccoshl: +.globl ccosl +.type ccosl, @function; +ccosl: +.globl ceil +.type ceil, @function; +ceil: +.globl ceilf +.type ceilf, @function; +ceilf: +.globl ceill +.type ceill, @function; +ceill: +.globl cexp +.type cexp, @function; +cexp: +.globl cexpf +.type cexpf, @function; +cexpf: +.globl cexpl +.type cexpl, @function; +cexpl: +.globl cfgetispeed +.type cfgetispeed, @function; +cfgetispeed: +.globl cfgetospeed +.type cfgetospeed, @function; +cfgetospeed: +.globl cfmakeraw +.type cfmakeraw, @function; +cfmakeraw: +.globl cfsetispeed +.type cfsetispeed, @function; +cfsetispeed: +.globl cfsetospeed +.type cfsetospeed, @function; +cfsetospeed: +.weak cfsetspeed +.type cfsetspeed, @function; +cfsetspeed: +.globl chdir +.type chdir, @function; +chdir: +.globl chmod +.type chmod, @function; +chmod: +.globl chown +.type chown, @function; +chown: +.globl chroot +.type chroot, @function; +chroot: +.globl cimag +.type cimag, @function; +cimag: +.globl cimagf +.type cimagf, @function; +cimagf: +.globl cimagl +.type cimagl, @function; +cimagl: +.globl clearenv +.type clearenv, @function; +clearenv: +.globl clearerr +.type clearerr, @function; +clearerr: +.weak clearerr_unlocked +.type clearerr_unlocked, @function; +clearerr_unlocked: +.globl clock +.type clock, @function; +clock: +.globl clock_adjtime +.type clock_adjtime, @function; +clock_adjtime: +.globl clock_getcpuclockid +.type clock_getcpuclockid, @function; +clock_getcpuclockid: +.globl clock_getres +.type clock_getres, @function; +clock_getres: +.weak clock_gettime +.type clock_gettime, @function; +clock_gettime: +.weak clock_nanosleep +.type clock_nanosleep, @function; +clock_nanosleep: +.globl clock_settime +.type clock_settime, @function; +clock_settime: +.globl clog +.type clog, @function; +clog: +.globl clogf +.type clogf, @function; +clogf: +.globl clogl +.type clogl, @function; +clogl: +.globl clone +.type clone, @function; +clone: +.globl close +.type close, @function; +close: +.globl closedir +.type closedir, @function; +closedir: +.globl closelog +.type closelog, @function; +closelog: +.globl cnd_broadcast +.type cnd_broadcast, @function; +cnd_broadcast: +.globl cnd_destroy +.type cnd_destroy, @function; +cnd_destroy: +.globl cnd_init +.type cnd_init, @function; +cnd_init: +.globl cnd_signal +.type cnd_signal, @function; +cnd_signal: +.globl cnd_timedwait +.type cnd_timedwait, @function; +cnd_timedwait: +.globl cnd_wait +.type cnd_wait, @function; +cnd_wait: +.globl confstr +.type confstr, @function; +confstr: +.globl conj +.type conj, @function; +conj: +.globl conjf +.type conjf, @function; +conjf: +.globl conjl +.type conjl, @function; +conjl: +.globl connect +.type connect, @function; +connect: +.globl copy_file_range +.type copy_file_range, @function; +copy_file_range: +.globl copysign +.type copysign, @function; +copysign: +.globl copysignf +.type copysignf, @function; +copysignf: +.globl copysignl +.type copysignl, @function; +copysignl: +.globl cos +.type cos, @function; +cos: +.globl cosf +.type cosf, @function; +cosf: +.globl cosh +.type cosh, @function; +cosh: +.globl coshf +.type coshf, @function; +coshf: +.globl coshl +.type coshl, @function; +coshl: +.globl cosl +.type cosl, @function; +cosl: +.globl cpow +.type cpow, @function; +cpow: +.globl cpowf +.type cpowf, @function; +cpowf: +.globl cpowl +.type cpowl, @function; +cpowl: +.globl cproj +.type cproj, @function; +cproj: +.globl cprojf +.type cprojf, @function; +cprojf: +.globl cprojl +.type cprojl, @function; +cprojl: +.globl creal +.type creal, @function; +creal: +.globl crealf +.type crealf, @function; +crealf: +.globl creall +.type creall, @function; +creall: +.globl creat +.type creat, @function; +creat: +.weak creat64 +.type creat64, @function; +creat64: +.globl crypt +.type crypt, @function; +crypt: +.weak crypt_r +.type crypt_r, @function; +crypt_r: +.globl csin +.type csin, @function; +csin: +.globl csinf +.type csinf, @function; +csinf: +.globl csinh +.type csinh, @function; +csinh: +.globl csinhf +.type csinhf, @function; +csinhf: +.globl csinhl +.type csinhl, @function; +csinhl: +.globl csinl +.type csinl, @function; +csinl: +.globl csqrt +.type csqrt, @function; +csqrt: +.globl csqrtf +.type csqrtf, @function; +csqrtf: +.globl csqrtl +.type csqrtl, @function; +csqrtl: +.globl ctan +.type ctan, @function; +ctan: +.globl ctanf +.type ctanf, @function; +ctanf: +.globl ctanh +.type ctanh, @function; +ctanh: +.globl ctanhf +.type ctanhf, @function; +ctanhf: +.globl ctanhl +.type ctanhl, @function; +ctanhl: +.globl ctanl +.type ctanl, @function; +ctanl: +.globl ctermid +.type ctermid, @function; +ctermid: +.globl ctime +.type ctime, @function; +ctime: +.globl ctime_r +.type ctime_r, @function; +ctime_r: +.globl cuserid +.type cuserid, @function; +cuserid: +.globl daemon +.type daemon, @function; +daemon: +.globl dcgettext +.type dcgettext, @function; +dcgettext: +.globl dcngettext +.type dcngettext, @function; +dcngettext: +.globl delete_module +.type delete_module, @function; +delete_module: +.globl dgettext +.type dgettext, @function; +dgettext: +.globl difftime +.type difftime, @function; +difftime: +.globl dirfd +.type dirfd, @function; +dirfd: +.globl dirname +.type dirname, @function; +dirname: +.globl div +.type div, @function; +div: +.globl dl_iterate_phdr +.type dl_iterate_phdr, @function; +dl_iterate_phdr: +.globl dladdr +.type dladdr, @function; +dladdr: +.globl dlclose +.type dlclose, @function; +dlclose: +.globl dlerror +.type dlerror, @function; +dlerror: +.globl dlinfo +.type dlinfo, @function; +dlinfo: +.globl dlopen +.type dlopen, @function; +dlopen: +.globl dlsym +.type dlsym, @function; +dlsym: +.globl dn_comp +.type dn_comp, @function; +dn_comp: +.weak dn_expand +.type dn_expand, @function; +dn_expand: +.globl dn_skipname +.type dn_skipname, @function; +dn_skipname: +.globl dngettext +.type dngettext, @function; +dngettext: +.globl dprintf +.type dprintf, @function; +dprintf: +.globl drand48 +.type drand48, @function; +drand48: +.weak drem +.type drem, @function; +drem: +.weak dremf +.type dremf, @function; +dremf: +.globl dup +.type dup, @function; +dup: +.globl dup2 +.type dup2, @function; +dup2: +.weak dup3 +.type dup3, @function; +dup3: +.weak duplocale +.type duplocale, @function; +duplocale: +.weak eaccess +.type eaccess, @function; +eaccess: +.globl ecvt +.type ecvt, @function; +ecvt: +.globl encrypt +.type encrypt, @function; +encrypt: +.weak endgrent +.type endgrent, @function; +endgrent: +.globl endhostent +.type endhostent, @function; +endhostent: +.globl endmntent +.type endmntent, @function; +endmntent: +.weak endnetent +.type endnetent, @function; +endnetent: +.globl endprotoent +.type endprotoent, @function; +endprotoent: +.weak endpwent +.type endpwent, @function; +endpwent: +.globl endservent +.type endservent, @function; +endservent: +.globl endspent +.type endspent, @function; +endspent: +.globl endusershell +.type endusershell, @function; +endusershell: +.weak endutent +.type endutent, @function; +endutent: +.globl endutxent +.type endutxent, @function; +endutxent: +.globl epoll_create +.type epoll_create, @function; +epoll_create: +.globl epoll_create1 +.type epoll_create1, @function; +epoll_create1: +.globl epoll_ctl +.type epoll_ctl, @function; +epoll_ctl: +.globl epoll_pwait +.type epoll_pwait, @function; +epoll_pwait: +.globl epoll_wait +.type epoll_wait, @function; +epoll_wait: +.globl erand48 +.type erand48, @function; +erand48: +.globl erf +.type erf, @function; +erf: +.globl erfc +.type erfc, @function; +erfc: +.globl erfcf +.type erfcf, @function; +erfcf: +.globl erfcl +.type erfcl, @function; +erfcl: +.globl erff +.type erff, @function; +erff: +.globl erfl +.type erfl, @function; +erfl: +.globl err +.type err, @function; +err: +.globl errx +.type errx, @function; +errx: +.globl ether_aton +.type ether_aton, @function; +ether_aton: +.globl ether_aton_r +.type ether_aton_r, @function; +ether_aton_r: +.globl ether_hostton +.type ether_hostton, @function; +ether_hostton: +.globl ether_line +.type ether_line, @function; +ether_line: +.globl ether_ntoa +.type ether_ntoa, @function; +ether_ntoa: +.globl ether_ntoa_r +.type ether_ntoa_r, @function; +ether_ntoa_r: +.globl ether_ntohost +.type ether_ntohost, @function; +ether_ntohost: +.globl euidaccess +.type euidaccess, @function; +euidaccess: +.globl eventfd +.type eventfd, @function; +eventfd: +.globl eventfd_read +.type eventfd_read, @function; +eventfd_read: +.globl eventfd_write +.type eventfd_write, @function; +eventfd_write: +.globl execl +.type execl, @function; +execl: +.globl execle +.type execle, @function; +execle: +.globl execlp +.type execlp, @function; +execlp: +.globl execv +.type execv, @function; +execv: +.globl execve +.type execve, @function; +execve: +.globl execvp +.type execvp, @function; +execvp: +.weak execvpe +.type execvpe, @function; +execvpe: +.globl exit +.type exit, @function; +exit: +.globl exp +.type exp, @function; +exp: +.globl exp10 +.type exp10, @function; +exp10: +.globl exp10f +.type exp10f, @function; +exp10f: +.globl exp10l +.type exp10l, @function; +exp10l: +.globl exp2 +.type exp2, @function; +exp2: +.globl exp2f +.type exp2f, @function; +exp2f: +.globl exp2l +.type exp2l, @function; +exp2l: +.globl expf +.type expf, @function; +expf: +.globl expl +.type expl, @function; +expl: +.globl explicit_bzero +.type explicit_bzero, @function; +explicit_bzero: +.globl expm1 +.type expm1, @function; +expm1: +.globl expm1f +.type expm1f, @function; +expm1f: +.globl expm1l +.type expm1l, @function; +expm1l: +.globl fabs +.type fabs, @function; +fabs: +.globl fabsf +.type fabsf, @function; +fabsf: +.globl fabsl +.type fabsl, @function; +fabsl: +.globl faccessat +.type faccessat, @function; +faccessat: +.globl fallocate +.type fallocate, @function; +fallocate: +.weak fallocate64 +.type fallocate64, @function; +fallocate64: +.globl fanotify_init +.type fanotify_init, @function; +fanotify_init: +.globl fanotify_mark +.type fanotify_mark, @function; +fanotify_mark: +.globl fchdir +.type fchdir, @function; +fchdir: +.globl fchmod +.type fchmod, @function; +fchmod: +.globl fchmodat +.type fchmodat, @function; +fchmodat: +.globl fchown +.type fchown, @function; +fchown: +.globl fchownat +.type fchownat, @function; +fchownat: +.globl fclose +.type fclose, @function; +fclose: +.globl fcntl +.type fcntl, @function; +fcntl: +.globl fcvt +.type fcvt, @function; +fcvt: +.globl fdatasync +.type fdatasync, @function; +fdatasync: +.globl fdim +.type fdim, @function; +fdim: +.globl fdimf +.type fdimf, @function; +fdimf: +.globl fdiml +.type fdiml, @function; +fdiml: +.weak fdopen +.type fdopen, @function; +fdopen: +.globl fdopendir +.type fdopendir, @function; +fdopendir: +.globl feclearexcept +.type feclearexcept, @function; +feclearexcept: +.globl fegetenv +.type fegetenv, @function; +fegetenv: +.globl fegetexceptflag +.type fegetexceptflag, @function; +fegetexceptflag: +.globl fegetround +.type fegetround, @function; +fegetround: +.globl feholdexcept +.type feholdexcept, @function; +feholdexcept: +.globl feof +.type feof, @function; +feof: +.weak feof_unlocked +.type feof_unlocked, @function; +feof_unlocked: +.globl feraiseexcept +.type feraiseexcept, @function; +feraiseexcept: +.globl ferror +.type ferror, @function; +ferror: +.weak ferror_unlocked +.type ferror_unlocked, @function; +ferror_unlocked: +.globl fesetenv +.type fesetenv, @function; +fesetenv: +.globl fesetexceptflag +.type fesetexceptflag, @function; +fesetexceptflag: +.globl fesetround +.type fesetround, @function; +fesetround: +.globl fetestexcept +.type fetestexcept, @function; +fetestexcept: +.globl feupdateenv +.type feupdateenv, @function; +feupdateenv: +.globl fexecve +.type fexecve, @function; +fexecve: +.globl fflush +.type fflush, @function; +fflush: +.weak fflush_unlocked +.type fflush_unlocked, @function; +fflush_unlocked: +.globl ffs +.type ffs, @function; +ffs: +.globl ffsl +.type ffsl, @function; +ffsl: +.globl ffsll +.type ffsll, @function; +ffsll: +.globl fgetc +.type fgetc, @function; +fgetc: +.weak fgetc_unlocked +.type fgetc_unlocked, @function; +fgetc_unlocked: +.globl fgetgrent +.type fgetgrent, @function; +fgetgrent: +.globl fgetln +.type fgetln, @function; +fgetln: +.globl fgetpos +.type fgetpos, @function; +fgetpos: +.weak fgetpos64 +.type fgetpos64, @function; +fgetpos64: +.globl fgetpwent +.type fgetpwent, @function; +fgetpwent: +.globl fgets +.type fgets, @function; +fgets: +.weak fgets_unlocked +.type fgets_unlocked, @function; +fgets_unlocked: +.globl fgetspent +.type fgetspent, @function; +fgetspent: +.globl fgetwc +.type fgetwc, @function; +fgetwc: +.weak fgetwc_unlocked +.type fgetwc_unlocked, @function; +fgetwc_unlocked: +.globl fgetws +.type fgetws, @function; +fgetws: +.weak fgetws_unlocked +.type fgetws_unlocked, @function; +fgetws_unlocked: +.globl fgetxattr +.type fgetxattr, @function; +fgetxattr: +.globl fileno +.type fileno, @function; +fileno: +.weak fileno_unlocked +.type fileno_unlocked, @function; +fileno_unlocked: +.globl finite +.type finite, @function; +finite: +.globl finitef +.type finitef, @function; +finitef: +.globl flistxattr +.type flistxattr, @function; +flistxattr: +.globl flock +.type flock, @function; +flock: +.globl flockfile +.type flockfile, @function; +flockfile: +.globl floor +.type floor, @function; +floor: +.globl floorf +.type floorf, @function; +floorf: +.globl floorl +.type floorl, @function; +floorl: +.globl fma +.type fma, @function; +fma: +.globl fmaf +.type fmaf, @function; +fmaf: +.globl fmal +.type fmal, @function; +fmal: +.globl fmax +.type fmax, @function; +fmax: +.globl fmaxf +.type fmaxf, @function; +fmaxf: +.globl fmaxl +.type fmaxl, @function; +fmaxl: +.globl fmemopen +.type fmemopen, @function; +fmemopen: +.globl fmin +.type fmin, @function; +fmin: +.globl fminf +.type fminf, @function; +fminf: +.globl fminl +.type fminl, @function; +fminl: +.globl fmod +.type fmod, @function; +fmod: +.globl fmodf +.type fmodf, @function; +fmodf: +.globl fmodl +.type fmodl, @function; +fmodl: +.globl fmtmsg +.type fmtmsg, @function; +fmtmsg: +.globl fnmatch +.type fnmatch, @function; +fnmatch: +.globl fopen +.type fopen, @function; +fopen: +.weak fopen64 +.type fopen64, @function; +fopen64: +.globl fopencookie +.type fopencookie, @function; +fopencookie: +.globl fork +.type fork, @function; +fork: +.globl forkpty +.type forkpty, @function; +forkpty: +.globl fpathconf +.type fpathconf, @function; +fpathconf: +.globl fprintf +.type fprintf, @function; +fprintf: +.weak fpurge +.type fpurge, @function; +fpurge: +.globl fputc +.type fputc, @function; +fputc: +.weak fputc_unlocked +.type fputc_unlocked, @function; +fputc_unlocked: +.globl fputs +.type fputs, @function; +fputs: +.weak fputs_unlocked +.type fputs_unlocked, @function; +fputs_unlocked: +.globl fputwc +.type fputwc, @function; +fputwc: +.weak fputwc_unlocked +.type fputwc_unlocked, @function; +fputwc_unlocked: +.globl fputws +.type fputws, @function; +fputws: +.weak fputws_unlocked +.type fputws_unlocked, @function; +fputws_unlocked: +.globl fread +.type fread, @function; +fread: +.weak fread_unlocked +.type fread_unlocked, @function; +fread_unlocked: +.globl free +.type free, @function; +free: +.globl freeaddrinfo +.type freeaddrinfo, @function; +freeaddrinfo: +.globl freeifaddrs +.type freeifaddrs, @function; +freeifaddrs: +.globl freelocale +.type freelocale, @function; +freelocale: +.globl fremovexattr +.type fremovexattr, @function; +fremovexattr: +.globl freopen +.type freopen, @function; +freopen: +.weak freopen64 +.type freopen64, @function; +freopen64: +.globl frexp +.type frexp, @function; +frexp: +.globl frexpf +.type frexpf, @function; +frexpf: +.globl frexpl +.type frexpl, @function; +frexpl: +.globl fscanf +.type fscanf, @function; +fscanf: +.globl fseek +.type fseek, @function; +fseek: +.weak fseeko +.type fseeko, @function; +fseeko: +.weak fseeko64 +.type fseeko64, @function; +fseeko64: +.globl fsetpos +.type fsetpos, @function; +fsetpos: +.weak fsetpos64 +.type fsetpos64, @function; +fsetpos64: +.globl fsetxattr +.type fsetxattr, @function; +fsetxattr: +.globl fstat +.type fstat, @function; +fstat: +.weak fstat64 +.type fstat64, @function; +fstat64: +.globl fstatat +.type fstatat, @function; +fstatat: +.weak fstatat64 +.type fstatat64, @function; +fstatat64: +.weak fstatfs +.type fstatfs, @function; +fstatfs: +.weak fstatfs64 +.type fstatfs64, @function; +fstatfs64: +.globl fstatvfs +.type fstatvfs, @function; +fstatvfs: +.weak fstatvfs64 +.type fstatvfs64, @function; +fstatvfs64: +.globl fsync +.type fsync, @function; +fsync: +.globl ftell +.type ftell, @function; +ftell: +.weak ftello +.type ftello, @function; +ftello: +.weak ftello64 +.type ftello64, @function; +ftello64: +.globl ftime +.type ftime, @function; +ftime: +.globl ftok +.type ftok, @function; +ftok: +.globl ftruncate +.type ftruncate, @function; +ftruncate: +.weak ftruncate64 +.type ftruncate64, @function; +ftruncate64: +.globl ftrylockfile +.type ftrylockfile, @function; +ftrylockfile: +.globl ftw +.type ftw, @function; +ftw: +.weak ftw64 +.type ftw64, @function; +ftw64: +.globl funlockfile +.type funlockfile, @function; +funlockfile: +.globl futimens +.type futimens, @function; +futimens: +.globl futimes +.type futimes, @function; +futimes: +.weak futimesat +.type futimesat, @function; +futimesat: +.globl fwide +.type fwide, @function; +fwide: +.globl fwprintf +.type fwprintf, @function; +fwprintf: +.globl fwrite +.type fwrite, @function; +fwrite: +.weak fwrite_unlocked +.type fwrite_unlocked, @function; +fwrite_unlocked: +.globl fwscanf +.type fwscanf, @function; +fwscanf: +.globl gai_strerror +.type gai_strerror, @function; +gai_strerror: +.globl gcvt +.type gcvt, @function; +gcvt: +.globl get_avphys_pages +.type get_avphys_pages, @function; +get_avphys_pages: +.globl get_current_dir_name +.type get_current_dir_name, @function; +get_current_dir_name: +.globl get_nprocs +.type get_nprocs, @function; +get_nprocs: +.globl get_nprocs_conf +.type get_nprocs_conf, @function; +get_nprocs_conf: +.globl get_phys_pages +.type get_phys_pages, @function; +get_phys_pages: +.globl getaddrinfo +.type getaddrinfo, @function; +getaddrinfo: +.weak getauxval +.type getauxval, @function; +getauxval: +.globl getc +.type getc, @function; +getc: +.globl getc_unlocked +.type getc_unlocked, @function; +getc_unlocked: +.globl getchar +.type getchar, @function; +getchar: +.globl getchar_unlocked +.type getchar_unlocked, @function; +getchar_unlocked: +.globl getcwd +.type getcwd, @function; +getcwd: +.globl getdate +.type getdate, @function; +getdate: +.globl getdelim +.type getdelim, @function; +getdelim: +.globl getdents +.type getdents, @function; +getdents: +.weak getdents64 +.type getdents64, @function; +getdents64: +.globl getdomainname +.type getdomainname, @function; +getdomainname: +.globl getdtablesize +.type getdtablesize, @function; +getdtablesize: +.globl getegid +.type getegid, @function; +getegid: +.globl getentropy +.type getentropy, @function; +getentropy: +.globl getenv +.type getenv, @function; +getenv: +.globl geteuid +.type geteuid, @function; +geteuid: +.globl getgid +.type getgid, @function; +getgid: +.globl getgrent +.type getgrent, @function; +getgrent: +.globl getgrgid +.type getgrgid, @function; +getgrgid: +.globl getgrgid_r +.type getgrgid_r, @function; +getgrgid_r: +.globl getgrnam +.type getgrnam, @function; +getgrnam: +.globl getgrnam_r +.type getgrnam_r, @function; +getgrnam_r: +.globl getgrouplist +.type getgrouplist, @function; +getgrouplist: +.globl getgroups +.type getgroups, @function; +getgroups: +.globl gethostbyaddr +.type gethostbyaddr, @function; +gethostbyaddr: +.globl gethostbyaddr_r +.type gethostbyaddr_r, @function; +gethostbyaddr_r: +.globl gethostbyname +.type gethostbyname, @function; +gethostbyname: +.globl gethostbyname2 +.type gethostbyname2, @function; +gethostbyname2: +.globl gethostbyname2_r +.type gethostbyname2_r, @function; +gethostbyname2_r: +.globl gethostbyname_r +.type gethostbyname_r, @function; +gethostbyname_r: +.globl gethostent +.type gethostent, @function; +gethostent: +.globl gethostid +.type gethostid, @function; +gethostid: +.globl gethostname +.type gethostname, @function; +gethostname: +.globl getifaddrs +.type getifaddrs, @function; +getifaddrs: +.globl getitimer +.type getitimer, @function; +getitimer: +.globl getline +.type getline, @function; +getline: +.globl getloadavg +.type getloadavg, @function; +getloadavg: +.globl getlogin +.type getlogin, @function; +getlogin: +.globl getlogin_r +.type getlogin_r, @function; +getlogin_r: +.globl getmntent +.type getmntent, @function; +getmntent: +.globl getmntent_r +.type getmntent_r, @function; +getmntent_r: +.globl getnameinfo +.type getnameinfo, @function; +getnameinfo: +.globl getnetbyaddr +.type getnetbyaddr, @function; +getnetbyaddr: +.globl getnetbyname +.type getnetbyname, @function; +getnetbyname: +.globl getnetent +.type getnetent, @function; +getnetent: +.globl getopt +.type getopt, @function; +getopt: +.globl getopt_long +.type getopt_long, @function; +getopt_long: +.globl getopt_long_only +.type getopt_long_only, @function; +getopt_long_only: +.globl getpagesize +.type getpagesize, @function; +getpagesize: +.globl getpass +.type getpass, @function; +getpass: +.globl getpeername +.type getpeername, @function; +getpeername: +.globl getpgid +.type getpgid, @function; +getpgid: +.globl getpgrp +.type getpgrp, @function; +getpgrp: +.globl getpid +.type getpid, @function; +getpid: +.globl getppid +.type getppid, @function; +getppid: +.globl getpriority +.type getpriority, @function; +getpriority: +.globl getprotobyname +.type getprotobyname, @function; +getprotobyname: +.globl getprotobynumber +.type getprotobynumber, @function; +getprotobynumber: +.globl getprotoent +.type getprotoent, @function; +getprotoent: +.globl getpwent +.type getpwent, @function; +getpwent: +.globl getpwnam +.type getpwnam, @function; +getpwnam: +.globl getpwnam_r +.type getpwnam_r, @function; +getpwnam_r: +.globl getpwuid +.type getpwuid, @function; +getpwuid: +.globl getpwuid_r +.type getpwuid_r, @function; +getpwuid_r: +.globl getrandom +.type getrandom, @function; +getrandom: +.globl getresgid +.type getresgid, @function; +getresgid: +.globl getresuid +.type getresuid, @function; +getresuid: +.globl getrlimit +.type getrlimit, @function; +getrlimit: +.weak getrlimit64 +.type getrlimit64, @function; +getrlimit64: +.globl getrusage +.type getrusage, @function; +getrusage: +.globl gets +.type gets, @function; +gets: +.globl getservbyname +.type getservbyname, @function; +getservbyname: +.globl getservbyname_r +.type getservbyname_r, @function; +getservbyname_r: +.globl getservbyport +.type getservbyport, @function; +getservbyport: +.globl getservbyport_r +.type getservbyport_r, @function; +getservbyport_r: +.globl getservent +.type getservent, @function; +getservent: +.globl getsid +.type getsid, @function; +getsid: +.globl getsockname +.type getsockname, @function; +getsockname: +.globl getsockopt +.type getsockopt, @function; +getsockopt: +.globl getspent +.type getspent, @function; +getspent: +.globl getspnam +.type getspnam, @function; +getspnam: +.globl getspnam_r +.type getspnam_r, @function; +getspnam_r: +.globl getsubopt +.type getsubopt, @function; +getsubopt: +.globl gettext +.type gettext, @function; +gettext: +.globl gettimeofday +.type gettimeofday, @function; +gettimeofday: +.globl getuid +.type getuid, @function; +getuid: +.globl getusershell +.type getusershell, @function; +getusershell: +.weak getutent +.type getutent, @function; +getutent: +.weak getutid +.type getutid, @function; +getutid: +.weak getutline +.type getutline, @function; +getutline: +.globl getutxent +.type getutxent, @function; +getutxent: +.globl getutxid +.type getutxid, @function; +getutxid: +.globl getutxline +.type getutxline, @function; +getutxline: +.globl getw +.type getw, @function; +getw: +.globl getwc +.type getwc, @function; +getwc: +.weak getwc_unlocked +.type getwc_unlocked, @function; +getwc_unlocked: +.globl getwchar +.type getwchar, @function; +getwchar: +.weak getwchar_unlocked +.type getwchar_unlocked, @function; +getwchar_unlocked: +.globl getxattr +.type getxattr, @function; +getxattr: +.globl glob +.type glob, @function; +glob: +.weak glob64 +.type glob64, @function; +glob64: +.globl globfree +.type globfree, @function; +globfree: +.weak globfree64 +.type globfree64, @function; +globfree64: +.globl gmtime +.type gmtime, @function; +gmtime: +.weak gmtime_r +.type gmtime_r, @function; +gmtime_r: +.globl grantpt +.type grantpt, @function; +grantpt: +.globl hasmntopt +.type hasmntopt, @function; +hasmntopt: +.globl hcreate +.type hcreate, @function; +hcreate: +.weak hcreate_r +.type hcreate_r, @function; +hcreate_r: +.globl hdestroy +.type hdestroy, @function; +hdestroy: +.weak hdestroy_r +.type hdestroy_r, @function; +hdestroy_r: +.globl herror +.type herror, @function; +herror: +.globl hsearch +.type hsearch, @function; +hsearch: +.weak hsearch_r +.type hsearch_r, @function; +hsearch_r: +.globl hstrerror +.type hstrerror, @function; +hstrerror: +.globl htonl +.type htonl, @function; +htonl: +.globl htons +.type htons, @function; +htons: +.globl hypot +.type hypot, @function; +hypot: +.globl hypotf +.type hypotf, @function; +hypotf: +.globl hypotl +.type hypotl, @function; +hypotl: +.globl iconv +.type iconv, @function; +iconv: +.globl iconv_close +.type iconv_close, @function; +iconv_close: +.globl iconv_open +.type iconv_open, @function; +iconv_open: +.globl if_freenameindex +.type if_freenameindex, @function; +if_freenameindex: +.globl if_indextoname +.type if_indextoname, @function; +if_indextoname: +.globl if_nameindex +.type if_nameindex, @function; +if_nameindex: +.globl if_nametoindex +.type if_nametoindex, @function; +if_nametoindex: +.globl ilogb +.type ilogb, @function; +ilogb: +.globl ilogbf +.type ilogbf, @function; +ilogbf: +.globl ilogbl +.type ilogbl, @function; +ilogbl: +.globl imaxabs +.type imaxabs, @function; +imaxabs: +.globl imaxdiv +.type imaxdiv, @function; +imaxdiv: +.globl index +.type index, @function; +index: +.globl inet_addr +.type inet_addr, @function; +inet_addr: +.weak inet_aton +.type inet_aton, @function; +inet_aton: +.globl inet_lnaof +.type inet_lnaof, @function; +inet_lnaof: +.globl inet_makeaddr +.type inet_makeaddr, @function; +inet_makeaddr: +.globl inet_netof +.type inet_netof, @function; +inet_netof: +.globl inet_network +.type inet_network, @function; +inet_network: +.globl inet_ntoa +.type inet_ntoa, @function; +inet_ntoa: +.globl inet_ntop +.type inet_ntop, @function; +inet_ntop: +.globl inet_pton +.type inet_pton, @function; +inet_pton: +.globl init_module +.type init_module, @function; +init_module: +.globl initgroups +.type initgroups, @function; +initgroups: +.globl initstate +.type initstate, @function; +initstate: +.globl inotify_add_watch +.type inotify_add_watch, @function; +inotify_add_watch: +.globl inotify_init +.type inotify_init, @function; +inotify_init: +.globl inotify_init1 +.type inotify_init1, @function; +inotify_init1: +.globl inotify_rm_watch +.type inotify_rm_watch, @function; +inotify_rm_watch: +.globl insque +.type insque, @function; +insque: +.globl ioctl +.type ioctl, @function; +ioctl: +.globl ioperm +.type ioperm, @function; +ioperm: +.globl iopl +.type iopl, @function; +iopl: +.globl isalnum +.type isalnum, @function; +isalnum: +.weak isalnum_l +.type isalnum_l, @function; +isalnum_l: +.globl isalpha +.type isalpha, @function; +isalpha: +.weak isalpha_l +.type isalpha_l, @function; +isalpha_l: +.globl isascii +.type isascii, @function; +isascii: +.globl isastream +.type isastream, @function; +isastream: +.globl isatty +.type isatty, @function; +isatty: +.globl isblank +.type isblank, @function; +isblank: +.weak isblank_l +.type isblank_l, @function; +isblank_l: +.globl iscntrl +.type iscntrl, @function; +iscntrl: +.weak iscntrl_l +.type iscntrl_l, @function; +iscntrl_l: +.globl isdigit +.type isdigit, @function; +isdigit: +.weak isdigit_l +.type isdigit_l, @function; +isdigit_l: +.globl isgraph +.type isgraph, @function; +isgraph: +.weak isgraph_l +.type isgraph_l, @function; +isgraph_l: +.globl islower +.type islower, @function; +islower: +.weak islower_l +.type islower_l, @function; +islower_l: +.globl isprint +.type isprint, @function; +isprint: +.weak isprint_l +.type isprint_l, @function; +isprint_l: +.globl ispunct +.type ispunct, @function; +ispunct: +.weak ispunct_l +.type ispunct_l, @function; +ispunct_l: +.globl issetugid +.type issetugid, @function; +issetugid: +.globl isspace +.type isspace, @function; +isspace: +.weak isspace_l +.type isspace_l, @function; +isspace_l: +.globl isupper +.type isupper, @function; +isupper: +.weak isupper_l +.type isupper_l, @function; +isupper_l: +.globl iswalnum +.type iswalnum, @function; +iswalnum: +.weak iswalnum_l +.type iswalnum_l, @function; +iswalnum_l: +.globl iswalpha +.type iswalpha, @function; +iswalpha: +.weak iswalpha_l +.type iswalpha_l, @function; +iswalpha_l: +.globl iswblank +.type iswblank, @function; +iswblank: +.weak iswblank_l +.type iswblank_l, @function; +iswblank_l: +.globl iswcntrl +.type iswcntrl, @function; +iswcntrl: +.weak iswcntrl_l +.type iswcntrl_l, @function; +iswcntrl_l: +.globl iswctype +.type iswctype, @function; +iswctype: +.weak iswctype_l +.type iswctype_l, @function; +iswctype_l: +.globl iswdigit +.type iswdigit, @function; +iswdigit: +.weak iswdigit_l +.type iswdigit_l, @function; +iswdigit_l: +.globl iswgraph +.type iswgraph, @function; +iswgraph: +.weak iswgraph_l +.type iswgraph_l, @function; +iswgraph_l: +.globl iswlower +.type iswlower, @function; +iswlower: +.weak iswlower_l +.type iswlower_l, @function; +iswlower_l: +.globl iswprint +.type iswprint, @function; +iswprint: +.weak iswprint_l +.type iswprint_l, @function; +iswprint_l: +.globl iswpunct +.type iswpunct, @function; +iswpunct: +.weak iswpunct_l +.type iswpunct_l, @function; +iswpunct_l: +.globl iswspace +.type iswspace, @function; +iswspace: +.weak iswspace_l +.type iswspace_l, @function; +iswspace_l: +.globl iswupper +.type iswupper, @function; +iswupper: +.weak iswupper_l +.type iswupper_l, @function; +iswupper_l: +.globl iswxdigit +.type iswxdigit, @function; +iswxdigit: +.weak iswxdigit_l +.type iswxdigit_l, @function; +iswxdigit_l: +.globl isxdigit +.type isxdigit, @function; +isxdigit: +.weak isxdigit_l +.type isxdigit_l, @function; +isxdigit_l: +.globl j0 +.type j0, @function; +j0: +.globl j0f +.type j0f, @function; +j0f: +.globl j1 +.type j1, @function; +j1: +.globl j1f +.type j1f, @function; +j1f: +.globl jn +.type jn, @function; +jn: +.globl jnf +.type jnf, @function; +jnf: +.globl jrand48 +.type jrand48, @function; +jrand48: +.globl kill +.type kill, @function; +kill: +.globl killpg +.type killpg, @function; +killpg: +.globl klogctl +.type klogctl, @function; +klogctl: +.globl l64a +.type l64a, @function; +l64a: +.globl labs +.type labs, @function; +labs: +.globl lchmod +.type lchmod, @function; +lchmod: +.globl lchown +.type lchown, @function; +lchown: +.globl lckpwdf +.type lckpwdf, @function; +lckpwdf: +.globl lcong48 +.type lcong48, @function; +lcong48: +.globl ldexp +.type ldexp, @function; +ldexp: +.globl ldexpf +.type ldexpf, @function; +ldexpf: +.globl ldexpl +.type ldexpl, @function; +ldexpl: +.globl ldiv +.type ldiv, @function; +ldiv: +.globl lfind +.type lfind, @function; +lfind: +.globl lgamma +.type lgamma, @function; +lgamma: +.weak lgamma_r +.type lgamma_r, @function; +lgamma_r: +.globl lgammaf +.type lgammaf, @function; +lgammaf: +.weak lgammaf_r +.type lgammaf_r, @function; +lgammaf_r: +.globl lgammal +.type lgammal, @function; +lgammal: +.weak lgammal_r +.type lgammal_r, @function; +lgammal_r: +.globl lgetxattr +.type lgetxattr, @function; +lgetxattr: +.globl link +.type link, @function; +link: +.globl linkat +.type linkat, @function; +linkat: +.globl lio_listio +.type lio_listio, @function; +lio_listio: +.weak lio_listio64 +.type lio_listio64, @function; +lio_listio64: +.globl listen +.type listen, @function; +listen: +.globl listxattr +.type listxattr, @function; +listxattr: +.globl llabs +.type llabs, @function; +llabs: +.globl lldiv +.type lldiv, @function; +lldiv: +.globl llistxattr +.type llistxattr, @function; +llistxattr: +.globl llrint +.type llrint, @function; +llrint: +.globl llrintf +.type llrintf, @function; +llrintf: +.globl llrintl +.type llrintl, @function; +llrintl: +.globl llround +.type llround, @function; +llround: +.globl llroundf +.type llroundf, @function; +llroundf: +.globl llroundl +.type llroundl, @function; +llroundl: +.globl localeconv +.type localeconv, @function; +localeconv: +.globl localtime +.type localtime, @function; +localtime: +.weak localtime_r +.type localtime_r, @function; +localtime_r: +.globl lockf +.type lockf, @function; +lockf: +.weak lockf64 +.type lockf64, @function; +lockf64: +.globl log +.type log, @function; +log: +.globl log10 +.type log10, @function; +log10: +.globl log10f +.type log10f, @function; +log10f: +.globl log10l +.type log10l, @function; +log10l: +.globl log1p +.type log1p, @function; +log1p: +.globl log1pf +.type log1pf, @function; +log1pf: +.globl log1pl +.type log1pl, @function; +log1pl: +.globl log2 +.type log2, @function; +log2: +.globl log2f +.type log2f, @function; +log2f: +.globl log2l +.type log2l, @function; +log2l: +.globl logb +.type logb, @function; +logb: +.globl logbf +.type logbf, @function; +logbf: +.globl logbl +.type logbl, @function; +logbl: +.globl logf +.type logf, @function; +logf: +.globl login_tty +.type login_tty, @function; +login_tty: +.globl logl +.type logl, @function; +logl: +.globl longjmp +.type longjmp, @function; +longjmp: +.globl lrand48 +.type lrand48, @function; +lrand48: +.globl lremovexattr +.type lremovexattr, @function; +lremovexattr: +.globl lrint +.type lrint, @function; +lrint: +.globl lrintf +.type lrintf, @function; +lrintf: +.globl lrintl +.type lrintl, @function; +lrintl: +.globl lround +.type lround, @function; +lround: +.globl lroundf +.type lroundf, @function; +lroundf: +.globl lroundl +.type lroundl, @function; +lroundl: +.globl lsearch +.type lsearch, @function; +lsearch: +.weak lseek +.type lseek, @function; +lseek: +.weak lseek64 +.type lseek64, @function; +lseek64: +.globl lsetxattr +.type lsetxattr, @function; +lsetxattr: +.globl lstat +.type lstat, @function; +lstat: +.weak lstat64 +.type lstat64, @function; +lstat64: +.globl lutimes +.type lutimes, @function; +lutimes: +.weak madvise +.type madvise, @function; +madvise: +.globl malloc +.type malloc, @function; +malloc: +.globl malloc_usable_size +.type malloc_usable_size, @function; +malloc_usable_size: +.globl mblen +.type mblen, @function; +mblen: +.globl mbrlen +.type mbrlen, @function; +mbrlen: +.globl mbrtoc16 +.type mbrtoc16, @function; +mbrtoc16: +.globl mbrtoc32 +.type mbrtoc32, @function; +mbrtoc32: +.globl mbrtowc +.type mbrtowc, @function; +mbrtowc: +.globl mbsinit +.type mbsinit, @function; +mbsinit: +.globl mbsnrtowcs +.type mbsnrtowcs, @function; +mbsnrtowcs: +.globl mbsrtowcs +.type mbsrtowcs, @function; +mbsrtowcs: +.globl mbstowcs +.type mbstowcs, @function; +mbstowcs: +.globl mbtowc +.type mbtowc, @function; +mbtowc: +.globl memalign +.type memalign, @function; +memalign: +.weak membarrier +.type membarrier, @function; +membarrier: +.globl memccpy +.type memccpy, @function; +memccpy: +.globl memchr +.type memchr, @function; +memchr: +.globl memcmp +.type memcmp, @function; +memcmp: +.globl memcpy +.type memcpy, @function; +memcpy: +.globl memfd_create +.type memfd_create, @function; +memfd_create: +.globl memmem +.type memmem, @function; +memmem: +.globl memmove +.type memmove, @function; +memmove: +.globl mempcpy +.type mempcpy, @function; +mempcpy: +.weak memrchr +.type memrchr, @function; +memrchr: +.globl memset +.type memset, @function; +memset: +.globl mincore +.type mincore, @function; +mincore: +.globl mkdir +.type mkdir, @function; +mkdir: +.globl mkdirat +.type mkdirat, @function; +mkdirat: +.globl mkdtemp +.type mkdtemp, @function; +mkdtemp: +.globl mkfifo +.type mkfifo, @function; +mkfifo: +.globl mkfifoat +.type mkfifoat, @function; +mkfifoat: +.globl mknod +.type mknod, @function; +mknod: +.globl mknodat +.type mknodat, @function; +mknodat: +.globl mkostemp +.type mkostemp, @function; +mkostemp: +.weak mkostemp64 +.type mkostemp64, @function; +mkostemp64: +.weak mkostemps +.type mkostemps, @function; +mkostemps: +.weak mkostemps64 +.type mkostemps64, @function; +mkostemps64: +.globl mkstemp +.type mkstemp, @function; +mkstemp: +.weak mkstemp64 +.type mkstemp64, @function; +mkstemp64: +.globl mkstemps +.type mkstemps, @function; +mkstemps: +.weak mkstemps64 +.type mkstemps64, @function; +mkstemps64: +.globl mktemp +.type mktemp, @function; +mktemp: +.globl mktime +.type mktime, @function; +mktime: +.globl mlock +.type mlock, @function; +mlock: +.globl mlock2 +.type mlock2, @function; +mlock2: +.globl mlockall +.type mlockall, @function; +mlockall: +.weak mmap +.type mmap, @function; +mmap: +.weak mmap64 +.type mmap64, @function; +mmap64: +.globl modf +.type modf, @function; +modf: +.globl modff +.type modff, @function; +modff: +.globl modfl +.type modfl, @function; +modfl: +.globl mount +.type mount, @function; +mount: +.weak mprotect +.type mprotect, @function; +mprotect: +.globl mq_close +.type mq_close, @function; +mq_close: +.globl mq_getattr +.type mq_getattr, @function; +mq_getattr: +.globl mq_notify +.type mq_notify, @function; +mq_notify: +.globl mq_open +.type mq_open, @function; +mq_open: +.globl mq_receive +.type mq_receive, @function; +mq_receive: +.globl mq_send +.type mq_send, @function; +mq_send: +.globl mq_setattr +.type mq_setattr, @function; +mq_setattr: +.globl mq_timedreceive +.type mq_timedreceive, @function; +mq_timedreceive: +.globl mq_timedsend +.type mq_timedsend, @function; +mq_timedsend: +.globl mq_unlink +.type mq_unlink, @function; +mq_unlink: +.globl mrand48 +.type mrand48, @function; +mrand48: +.weak mremap +.type mremap, @function; +mremap: +.globl msgctl +.type msgctl, @function; +msgctl: +.globl msgget +.type msgget, @function; +msgget: +.globl msgrcv +.type msgrcv, @function; +msgrcv: +.globl msgsnd +.type msgsnd, @function; +msgsnd: +.globl msync +.type msync, @function; +msync: +.globl mtx_destroy +.type mtx_destroy, @function; +mtx_destroy: +.globl mtx_init +.type mtx_init, @function; +mtx_init: +.globl mtx_lock +.type mtx_lock, @function; +mtx_lock: +.globl mtx_timedlock +.type mtx_timedlock, @function; +mtx_timedlock: +.globl mtx_trylock +.type mtx_trylock, @function; +mtx_trylock: +.globl mtx_unlock +.type mtx_unlock, @function; +mtx_unlock: +.globl munlock +.type munlock, @function; +munlock: +.globl munlockall +.type munlockall, @function; +munlockall: +.weak munmap +.type munmap, @function; +munmap: +.globl name_to_handle_at +.type name_to_handle_at, @function; +name_to_handle_at: +.globl nan +.type nan, @function; +nan: +.globl nanf +.type nanf, @function; +nanf: +.globl nanl +.type nanl, @function; +nanl: +.globl nanosleep +.type nanosleep, @function; +nanosleep: +.globl nearbyint +.type nearbyint, @function; +nearbyint: +.globl nearbyintf +.type nearbyintf, @function; +nearbyintf: +.globl nearbyintl +.type nearbyintl, @function; +nearbyintl: +.weak newlocale +.type newlocale, @function; +newlocale: +.globl nextafter +.type nextafter, @function; +nextafter: +.globl nextafterf +.type nextafterf, @function; +nextafterf: +.globl nextafterl +.type nextafterl, @function; +nextafterl: +.globl nexttoward +.type nexttoward, @function; +nexttoward: +.globl nexttowardf +.type nexttowardf, @function; +nexttowardf: +.globl nexttowardl +.type nexttowardl, @function; +nexttowardl: +.globl nftw +.type nftw, @function; +nftw: +.weak nftw64 +.type nftw64, @function; +nftw64: +.globl ngettext +.type ngettext, @function; +ngettext: +.globl nice +.type nice, @function; +nice: +.weak nl_langinfo +.type nl_langinfo, @function; +nl_langinfo: +.weak nl_langinfo_l +.type nl_langinfo_l, @function; +nl_langinfo_l: +.globl nrand48 +.type nrand48, @function; +nrand48: +.globl ns_get16 +.type ns_get16, @function; +ns_get16: +.globl ns_get32 +.type ns_get32, @function; +ns_get32: +.globl ns_initparse +.type ns_initparse, @function; +ns_initparse: +.globl ns_name_uncompress +.type ns_name_uncompress, @function; +ns_name_uncompress: +.globl ns_parserr +.type ns_parserr, @function; +ns_parserr: +.globl ns_put16 +.type ns_put16, @function; +ns_put16: +.globl ns_put32 +.type ns_put32, @function; +ns_put32: +.globl ns_skiprr +.type ns_skiprr, @function; +ns_skiprr: +.globl ntohl +.type ntohl, @function; +ntohl: +.globl ntohs +.type ntohs, @function; +ntohs: +.globl open +.type open, @function; +open: +.weak open64 +.type open64, @function; +open64: +.globl open_by_handle_at +.type open_by_handle_at, @function; +open_by_handle_at: +.globl open_memstream +.type open_memstream, @function; +open_memstream: +.globl open_wmemstream +.type open_wmemstream, @function; +open_wmemstream: +.globl openat +.type openat, @function; +openat: +.weak openat64 +.type openat64, @function; +openat64: +.globl opendir +.type opendir, @function; +opendir: +.globl openlog +.type openlog, @function; +openlog: +.globl openpty +.type openpty, @function; +openpty: +.globl pathconf +.type pathconf, @function; +pathconf: +.globl pause +.type pause, @function; +pause: +.globl pclose +.type pclose, @function; +pclose: +.globl perror +.type perror, @function; +perror: +.globl personality +.type personality, @function; +personality: +.globl pipe +.type pipe, @function; +pipe: +.globl pipe2 +.type pipe2, @function; +pipe2: +.globl pivot_root +.type pivot_root, @function; +pivot_root: +.globl poll +.type poll, @function; +poll: +.globl popen +.type popen, @function; +popen: +.globl posix_close +.type posix_close, @function; +posix_close: +.globl posix_fadvise +.type posix_fadvise, @function; +posix_fadvise: +.weak posix_fadvise64 +.type posix_fadvise64, @function; +posix_fadvise64: +.globl posix_fallocate +.type posix_fallocate, @function; +posix_fallocate: +.weak posix_fallocate64 +.type posix_fallocate64, @function; +posix_fallocate64: +.globl posix_madvise +.type posix_madvise, @function; +posix_madvise: +.globl posix_memalign +.type posix_memalign, @function; +posix_memalign: +.globl posix_openpt +.type posix_openpt, @function; +posix_openpt: +.globl posix_spawn +.type posix_spawn, @function; +posix_spawn: +.globl posix_spawn_file_actions_addchdir_np +.type posix_spawn_file_actions_addchdir_np, @function; +posix_spawn_file_actions_addchdir_np: +.globl posix_spawn_file_actions_addclose +.type posix_spawn_file_actions_addclose, @function; +posix_spawn_file_actions_addclose: +.globl posix_spawn_file_actions_adddup2 +.type posix_spawn_file_actions_adddup2, @function; +posix_spawn_file_actions_adddup2: +.globl posix_spawn_file_actions_addfchdir_np +.type posix_spawn_file_actions_addfchdir_np, @function; +posix_spawn_file_actions_addfchdir_np: +.globl posix_spawn_file_actions_addopen +.type posix_spawn_file_actions_addopen, @function; +posix_spawn_file_actions_addopen: +.globl posix_spawn_file_actions_destroy +.type posix_spawn_file_actions_destroy, @function; +posix_spawn_file_actions_destroy: +.globl posix_spawn_file_actions_init +.type posix_spawn_file_actions_init, @function; +posix_spawn_file_actions_init: +.globl posix_spawnattr_destroy +.type posix_spawnattr_destroy, @function; +posix_spawnattr_destroy: +.globl posix_spawnattr_getflags +.type posix_spawnattr_getflags, @function; +posix_spawnattr_getflags: +.globl posix_spawnattr_getpgroup +.type posix_spawnattr_getpgroup, @function; +posix_spawnattr_getpgroup: +.globl posix_spawnattr_getschedparam +.type posix_spawnattr_getschedparam, @function; +posix_spawnattr_getschedparam: +.globl posix_spawnattr_getschedpolicy +.type posix_spawnattr_getschedpolicy, @function; +posix_spawnattr_getschedpolicy: +.globl posix_spawnattr_getsigdefault +.type posix_spawnattr_getsigdefault, @function; +posix_spawnattr_getsigdefault: +.globl posix_spawnattr_getsigmask +.type posix_spawnattr_getsigmask, @function; +posix_spawnattr_getsigmask: +.globl posix_spawnattr_init +.type posix_spawnattr_init, @function; +posix_spawnattr_init: +.globl posix_spawnattr_setflags +.type posix_spawnattr_setflags, @function; +posix_spawnattr_setflags: +.globl posix_spawnattr_setpgroup +.type posix_spawnattr_setpgroup, @function; +posix_spawnattr_setpgroup: +.globl posix_spawnattr_setschedparam +.type posix_spawnattr_setschedparam, @function; +posix_spawnattr_setschedparam: +.globl posix_spawnattr_setschedpolicy +.type posix_spawnattr_setschedpolicy, @function; +posix_spawnattr_setschedpolicy: +.globl posix_spawnattr_setsigdefault +.type posix_spawnattr_setsigdefault, @function; +posix_spawnattr_setsigdefault: +.globl posix_spawnattr_setsigmask +.type posix_spawnattr_setsigmask, @function; +posix_spawnattr_setsigmask: +.globl posix_spawnp +.type posix_spawnp, @function; +posix_spawnp: +.globl pow +.type pow, @function; +pow: +.weak pow10 +.type pow10, @function; +pow10: +.weak pow10f +.type pow10f, @function; +pow10f: +.weak pow10l +.type pow10l, @function; +pow10l: +.globl powf +.type powf, @function; +powf: +.globl powl +.type powl, @function; +powl: +.globl ppoll +.type ppoll, @function; +ppoll: +.globl prctl +.type prctl, @function; +prctl: +.globl pread +.type pread, @function; +pread: +.weak pread64 +.type pread64, @function; +pread64: +.globl preadv +.type preadv, @function; +preadv: +.weak preadv64 +.type preadv64, @function; +preadv64: +.globl printf +.type printf, @function; +printf: +.globl prlimit +.type prlimit, @function; +prlimit: +.weak prlimit64 +.type prlimit64, @function; +prlimit64: +.globl process_vm_readv +.type process_vm_readv, @function; +process_vm_readv: +.globl process_vm_writev +.type process_vm_writev, @function; +process_vm_writev: +.globl pselect +.type pselect, @function; +pselect: +.globl psiginfo +.type psiginfo, @function; +psiginfo: +.globl psignal +.type psignal, @function; +psignal: +.globl pthread_atfork +.type pthread_atfork, @function; +pthread_atfork: +.globl pthread_attr_destroy +.type pthread_attr_destroy, @function; +pthread_attr_destroy: +.globl pthread_attr_getdetachstate +.type pthread_attr_getdetachstate, @function; +pthread_attr_getdetachstate: +.globl pthread_attr_getguardsize +.type pthread_attr_getguardsize, @function; +pthread_attr_getguardsize: +.globl pthread_attr_getinheritsched +.type pthread_attr_getinheritsched, @function; +pthread_attr_getinheritsched: +.globl pthread_attr_getschedparam +.type pthread_attr_getschedparam, @function; +pthread_attr_getschedparam: +.globl pthread_attr_getschedpolicy +.type pthread_attr_getschedpolicy, @function; +pthread_attr_getschedpolicy: +.globl pthread_attr_getscope +.type pthread_attr_getscope, @function; +pthread_attr_getscope: +.globl pthread_attr_getstack +.type pthread_attr_getstack, @function; +pthread_attr_getstack: +.globl pthread_attr_getstacksize +.type pthread_attr_getstacksize, @function; +pthread_attr_getstacksize: +.globl pthread_attr_init +.type pthread_attr_init, @function; +pthread_attr_init: +.globl pthread_attr_setdetachstate +.type pthread_attr_setdetachstate, @function; +pthread_attr_setdetachstate: +.globl pthread_attr_setguardsize +.type pthread_attr_setguardsize, @function; +pthread_attr_setguardsize: +.globl pthread_attr_setinheritsched +.type pthread_attr_setinheritsched, @function; +pthread_attr_setinheritsched: +.globl pthread_attr_setschedparam +.type pthread_attr_setschedparam, @function; +pthread_attr_setschedparam: +.globl pthread_attr_setschedpolicy +.type pthread_attr_setschedpolicy, @function; +pthread_attr_setschedpolicy: +.globl pthread_attr_setscope +.type pthread_attr_setscope, @function; +pthread_attr_setscope: +.globl pthread_attr_setstack +.type pthread_attr_setstack, @function; +pthread_attr_setstack: +.globl pthread_attr_setstacksize +.type pthread_attr_setstacksize, @function; +pthread_attr_setstacksize: +.globl pthread_barrier_destroy +.type pthread_barrier_destroy, @function; +pthread_barrier_destroy: +.globl pthread_barrier_init +.type pthread_barrier_init, @function; +pthread_barrier_init: +.globl pthread_barrier_wait +.type pthread_barrier_wait, @function; +pthread_barrier_wait: +.globl pthread_barrierattr_destroy +.type pthread_barrierattr_destroy, @function; +pthread_barrierattr_destroy: +.globl pthread_barrierattr_getpshared +.type pthread_barrierattr_getpshared, @function; +pthread_barrierattr_getpshared: +.globl pthread_barrierattr_init +.type pthread_barrierattr_init, @function; +pthread_barrierattr_init: +.globl pthread_barrierattr_setpshared +.type pthread_barrierattr_setpshared, @function; +pthread_barrierattr_setpshared: +.globl pthread_cancel +.type pthread_cancel, @function; +pthread_cancel: +.globl pthread_cond_broadcast +.type pthread_cond_broadcast, @function; +pthread_cond_broadcast: +.globl pthread_cond_destroy +.type pthread_cond_destroy, @function; +pthread_cond_destroy: +.globl pthread_cond_init +.type pthread_cond_init, @function; +pthread_cond_init: +.globl pthread_cond_signal +.type pthread_cond_signal, @function; +pthread_cond_signal: +.weak pthread_cond_timedwait +.type pthread_cond_timedwait, @function; +pthread_cond_timedwait: +.globl pthread_cond_wait +.type pthread_cond_wait, @function; +pthread_cond_wait: +.globl pthread_condattr_destroy +.type pthread_condattr_destroy, @function; +pthread_condattr_destroy: +.globl pthread_condattr_getclock +.type pthread_condattr_getclock, @function; +pthread_condattr_getclock: +.globl pthread_condattr_getpshared +.type pthread_condattr_getpshared, @function; +pthread_condattr_getpshared: +.globl pthread_condattr_init +.type pthread_condattr_init, @function; +pthread_condattr_init: +.globl pthread_condattr_setclock +.type pthread_condattr_setclock, @function; +pthread_condattr_setclock: +.globl pthread_condattr_setpshared +.type pthread_condattr_setpshared, @function; +pthread_condattr_setpshared: +.weak pthread_create +.type pthread_create, @function; +pthread_create: +.weak pthread_detach +.type pthread_detach, @function; +pthread_detach: +.weak pthread_equal +.type pthread_equal, @function; +pthread_equal: +.weak pthread_exit +.type pthread_exit, @function; +pthread_exit: +.globl pthread_getaffinity_np +.type pthread_getaffinity_np, @function; +pthread_getaffinity_np: +.globl pthread_getattr_default_np +.type pthread_getattr_default_np, @function; +pthread_getattr_default_np: +.globl pthread_getattr_np +.type pthread_getattr_np, @function; +pthread_getattr_np: +.globl pthread_getconcurrency +.type pthread_getconcurrency, @function; +pthread_getconcurrency: +.globl pthread_getcpuclockid +.type pthread_getcpuclockid, @function; +pthread_getcpuclockid: +.globl pthread_getschedparam +.type pthread_getschedparam, @function; +pthread_getschedparam: +.weak pthread_getspecific +.type pthread_getspecific, @function; +pthread_getspecific: +.weak pthread_join +.type pthread_join, @function; +pthread_join: +.weak pthread_key_create +.type pthread_key_create, @function; +pthread_key_create: +.weak pthread_key_delete +.type pthread_key_delete, @function; +pthread_key_delete: +.globl pthread_kill +.type pthread_kill, @function; +pthread_kill: +.globl pthread_mutex_consistent +.type pthread_mutex_consistent, @function; +pthread_mutex_consistent: +.globl pthread_mutex_destroy +.type pthread_mutex_destroy, @function; +pthread_mutex_destroy: +.globl pthread_mutex_getprioceiling +.type pthread_mutex_getprioceiling, @function; +pthread_mutex_getprioceiling: +.globl pthread_mutex_init +.type pthread_mutex_init, @function; +pthread_mutex_init: +.weak pthread_mutex_lock +.type pthread_mutex_lock, @function; +pthread_mutex_lock: +.globl pthread_mutex_setprioceiling +.type pthread_mutex_setprioceiling, @function; +pthread_mutex_setprioceiling: +.weak pthread_mutex_timedlock +.type pthread_mutex_timedlock, @function; +pthread_mutex_timedlock: +.weak pthread_mutex_trylock +.type pthread_mutex_trylock, @function; +pthread_mutex_trylock: +.weak pthread_mutex_unlock +.type pthread_mutex_unlock, @function; +pthread_mutex_unlock: +.globl pthread_mutexattr_destroy +.type pthread_mutexattr_destroy, @function; +pthread_mutexattr_destroy: +.globl pthread_mutexattr_getprotocol +.type pthread_mutexattr_getprotocol, @function; +pthread_mutexattr_getprotocol: +.globl pthread_mutexattr_getpshared +.type pthread_mutexattr_getpshared, @function; +pthread_mutexattr_getpshared: +.globl pthread_mutexattr_getrobust +.type pthread_mutexattr_getrobust, @function; +pthread_mutexattr_getrobust: +.globl pthread_mutexattr_gettype +.type pthread_mutexattr_gettype, @function; +pthread_mutexattr_gettype: +.globl pthread_mutexattr_init +.type pthread_mutexattr_init, @function; +pthread_mutexattr_init: +.globl pthread_mutexattr_setprotocol +.type pthread_mutexattr_setprotocol, @function; +pthread_mutexattr_setprotocol: +.globl pthread_mutexattr_setpshared +.type pthread_mutexattr_setpshared, @function; +pthread_mutexattr_setpshared: +.globl pthread_mutexattr_setrobust +.type pthread_mutexattr_setrobust, @function; +pthread_mutexattr_setrobust: +.globl pthread_mutexattr_settype +.type pthread_mutexattr_settype, @function; +pthread_mutexattr_settype: +.weak pthread_once +.type pthread_once, @function; +pthread_once: +.globl pthread_rwlock_destroy +.type pthread_rwlock_destroy, @function; +pthread_rwlock_destroy: +.globl pthread_rwlock_init +.type pthread_rwlock_init, @function; +pthread_rwlock_init: +.weak pthread_rwlock_rdlock +.type pthread_rwlock_rdlock, @function; +pthread_rwlock_rdlock: +.weak pthread_rwlock_timedrdlock +.type pthread_rwlock_timedrdlock, @function; +pthread_rwlock_timedrdlock: +.weak pthread_rwlock_timedwrlock +.type pthread_rwlock_timedwrlock, @function; +pthread_rwlock_timedwrlock: +.weak pthread_rwlock_tryrdlock +.type pthread_rwlock_tryrdlock, @function; +pthread_rwlock_tryrdlock: +.weak pthread_rwlock_trywrlock +.type pthread_rwlock_trywrlock, @function; +pthread_rwlock_trywrlock: +.weak pthread_rwlock_unlock +.type pthread_rwlock_unlock, @function; +pthread_rwlock_unlock: +.weak pthread_rwlock_wrlock +.type pthread_rwlock_wrlock, @function; +pthread_rwlock_wrlock: +.globl pthread_rwlockattr_destroy +.type pthread_rwlockattr_destroy, @function; +pthread_rwlockattr_destroy: +.globl pthread_rwlockattr_getpshared +.type pthread_rwlockattr_getpshared, @function; +pthread_rwlockattr_getpshared: +.globl pthread_rwlockattr_init +.type pthread_rwlockattr_init, @function; +pthread_rwlockattr_init: +.globl pthread_rwlockattr_setpshared +.type pthread_rwlockattr_setpshared, @function; +pthread_rwlockattr_setpshared: +.weak pthread_self +.type pthread_self, @function; +pthread_self: +.globl pthread_setaffinity_np +.type pthread_setaffinity_np, @function; +pthread_setaffinity_np: +.globl pthread_setattr_default_np +.type pthread_setattr_default_np, @function; +pthread_setattr_default_np: +.weak pthread_setcancelstate +.type pthread_setcancelstate, @function; +pthread_setcancelstate: +.globl pthread_setcanceltype +.type pthread_setcanceltype, @function; +pthread_setcanceltype: +.globl pthread_setconcurrency +.type pthread_setconcurrency, @function; +pthread_setconcurrency: +.globl pthread_setname_np +.type pthread_setname_np, @function; +pthread_setname_np: +.globl pthread_setschedparam +.type pthread_setschedparam, @function; +pthread_setschedparam: +.globl pthread_setschedprio +.type pthread_setschedprio, @function; +pthread_setschedprio: +.globl pthread_setspecific +.type pthread_setspecific, @function; +pthread_setspecific: +.globl pthread_sigmask +.type pthread_sigmask, @function; +pthread_sigmask: +.globl pthread_spin_destroy +.type pthread_spin_destroy, @function; +pthread_spin_destroy: +.globl pthread_spin_init +.type pthread_spin_init, @function; +pthread_spin_init: +.globl pthread_spin_lock +.type pthread_spin_lock, @function; +pthread_spin_lock: +.globl pthread_spin_trylock +.type pthread_spin_trylock, @function; +pthread_spin_trylock: +.globl pthread_spin_unlock +.type pthread_spin_unlock, @function; +pthread_spin_unlock: +.weak pthread_testcancel +.type pthread_testcancel, @function; +pthread_testcancel: +.weak pthread_timedjoin_np +.type pthread_timedjoin_np, @function; +pthread_timedjoin_np: +.weak pthread_tryjoin_np +.type pthread_tryjoin_np, @function; +pthread_tryjoin_np: +.globl ptrace +.type ptrace, @function; +ptrace: +.globl ptsname +.type ptsname, @function; +ptsname: +.weak ptsname_r +.type ptsname_r, @function; +ptsname_r: +.globl putc +.type putc, @function; +putc: +.globl putc_unlocked +.type putc_unlocked, @function; +putc_unlocked: +.globl putchar +.type putchar, @function; +putchar: +.globl putchar_unlocked +.type putchar_unlocked, @function; +putchar_unlocked: +.globl putenv +.type putenv, @function; +putenv: +.globl putgrent +.type putgrent, @function; +putgrent: +.globl putpwent +.type putpwent, @function; +putpwent: +.globl puts +.type puts, @function; +puts: +.globl putspent +.type putspent, @function; +putspent: +.weak pututline +.type pututline, @function; +pututline: +.globl pututxline +.type pututxline, @function; +pututxline: +.globl putw +.type putw, @function; +putw: +.globl putwc +.type putwc, @function; +putwc: +.weak putwc_unlocked +.type putwc_unlocked, @function; +putwc_unlocked: +.globl putwchar +.type putwchar, @function; +putwchar: +.weak putwchar_unlocked +.type putwchar_unlocked, @function; +putwchar_unlocked: +.globl pwrite +.type pwrite, @function; +pwrite: +.weak pwrite64 +.type pwrite64, @function; +pwrite64: +.globl pwritev +.type pwritev, @function; +pwritev: +.weak pwritev64 +.type pwritev64, @function; +pwritev64: +.globl qsort +.type qsort, @function; +qsort: +.globl quick_exit +.type quick_exit, @function; +quick_exit: +.globl quotactl +.type quotactl, @function; +quotactl: +.globl raise +.type raise, @function; +raise: +.globl rand +.type rand, @function; +rand: +.globl rand_r +.type rand_r, @function; +rand_r: +.globl random +.type random, @function; +random: +.globl read +.type read, @function; +read: +.globl readahead +.type readahead, @function; +readahead: +.globl readdir +.type readdir, @function; +readdir: +.weak readdir64 +.type readdir64, @function; +readdir64: +.weak readdir64_r +.type readdir64_r, @function; +readdir64_r: +.globl readdir_r +.type readdir_r, @function; +readdir_r: +.globl readlink +.type readlink, @function; +readlink: +.globl readlinkat +.type readlinkat, @function; +readlinkat: +.globl readv +.type readv, @function; +readv: +.globl realloc +.type realloc, @function; +realloc: +.globl realpath +.type realpath, @function; +realpath: +.globl reboot +.type reboot, @function; +reboot: +.globl recv +.type recv, @function; +recv: +.globl recvfrom +.type recvfrom, @function; +recvfrom: +.globl recvmmsg +.type recvmmsg, @function; +recvmmsg: +.globl recvmsg +.type recvmsg, @function; +recvmsg: +.globl regcomp +.type regcomp, @function; +regcomp: +.globl regerror +.type regerror, @function; +regerror: +.globl regexec +.type regexec, @function; +regexec: +.globl regfree +.type regfree, @function; +regfree: +.globl remainder +.type remainder, @function; +remainder: +.globl remainderf +.type remainderf, @function; +remainderf: +.globl remainderl +.type remainderl, @function; +remainderl: +.globl remap_file_pages +.type remap_file_pages, @function; +remap_file_pages: +.globl remove +.type remove, @function; +remove: +.globl removexattr +.type removexattr, @function; +removexattr: +.globl remque +.type remque, @function; +remque: +.globl remquo +.type remquo, @function; +remquo: +.globl remquof +.type remquof, @function; +remquof: +.globl remquol +.type remquol, @function; +remquol: +.globl rename +.type rename, @function; +rename: +.globl renameat +.type renameat, @function; +renameat: +.globl res_init +.type res_init, @function; +res_init: +.weak res_mkquery +.type res_mkquery, @function; +res_mkquery: +.globl res_query +.type res_query, @function; +res_query: +.globl res_querydomain +.type res_querydomain, @function; +res_querydomain: +.weak res_search +.type res_search, @function; +res_search: +.weak res_send +.type res_send, @function; +res_send: +.globl rewind +.type rewind, @function; +rewind: +.globl rewinddir +.type rewinddir, @function; +rewinddir: +.globl rindex +.type rindex, @function; +rindex: +.globl rint +.type rint, @function; +rint: +.globl rintf +.type rintf, @function; +rintf: +.globl rintl +.type rintl, @function; +rintl: +.globl rmdir +.type rmdir, @function; +rmdir: +.globl round +.type round, @function; +round: +.globl roundf +.type roundf, @function; +roundf: +.globl roundl +.type roundl, @function; +roundl: +.globl sbrk +.type sbrk, @function; +sbrk: +.globl scalb +.type scalb, @function; +scalb: +.globl scalbf +.type scalbf, @function; +scalbf: +.globl scalbln +.type scalbln, @function; +scalbln: +.globl scalblnf +.type scalblnf, @function; +scalblnf: +.globl scalblnl +.type scalblnl, @function; +scalblnl: +.globl scalbn +.type scalbn, @function; +scalbn: +.globl scalbnf +.type scalbnf, @function; +scalbnf: +.globl scalbnl +.type scalbnl, @function; +scalbnl: +.globl scandir +.type scandir, @function; +scandir: +.weak scandir64 +.type scandir64, @function; +scandir64: +.globl scanf +.type scanf, @function; +scanf: +.globl sched_get_priority_max +.type sched_get_priority_max, @function; +sched_get_priority_max: +.globl sched_get_priority_min +.type sched_get_priority_min, @function; +sched_get_priority_min: +.globl sched_getaffinity +.type sched_getaffinity, @function; +sched_getaffinity: +.globl sched_getcpu +.type sched_getcpu, @function; +sched_getcpu: +.globl sched_getparam +.type sched_getparam, @function; +sched_getparam: +.globl sched_getscheduler +.type sched_getscheduler, @function; +sched_getscheduler: +.globl sched_rr_get_interval +.type sched_rr_get_interval, @function; +sched_rr_get_interval: +.globl sched_setaffinity +.type sched_setaffinity, @function; +sched_setaffinity: +.globl sched_setparam +.type sched_setparam, @function; +sched_setparam: +.globl sched_setscheduler +.type sched_setscheduler, @function; +sched_setscheduler: +.globl sched_yield +.type sched_yield, @function; +sched_yield: +.globl secure_getenv +.type secure_getenv, @function; +secure_getenv: +.globl seed48 +.type seed48, @function; +seed48: +.globl seekdir +.type seekdir, @function; +seekdir: +.globl select +.type select, @function; +select: +.globl sem_close +.type sem_close, @function; +sem_close: +.globl sem_destroy +.type sem_destroy, @function; +sem_destroy: +.globl sem_getvalue +.type sem_getvalue, @function; +sem_getvalue: +.globl sem_init +.type sem_init, @function; +sem_init: +.globl sem_open +.type sem_open, @function; +sem_open: +.globl sem_post +.type sem_post, @function; +sem_post: +.globl sem_timedwait +.type sem_timedwait, @function; +sem_timedwait: +.globl sem_trywait +.type sem_trywait, @function; +sem_trywait: +.globl sem_unlink +.type sem_unlink, @function; +sem_unlink: +.globl sem_wait +.type sem_wait, @function; +sem_wait: +.globl semctl +.type semctl, @function; +semctl: +.globl semget +.type semget, @function; +semget: +.globl semop +.type semop, @function; +semop: +.globl semtimedop +.type semtimedop, @function; +semtimedop: +.globl send +.type send, @function; +send: +.globl sendfile +.type sendfile, @function; +sendfile: +.weak sendfile64 +.type sendfile64, @function; +sendfile64: +.globl sendmmsg +.type sendmmsg, @function; +sendmmsg: +.globl sendmsg +.type sendmsg, @function; +sendmsg: +.globl sendto +.type sendto, @function; +sendto: +.globl setbuf +.type setbuf, @function; +setbuf: +.globl setbuffer +.type setbuffer, @function; +setbuffer: +.globl setdomainname +.type setdomainname, @function; +setdomainname: +.globl setegid +.type setegid, @function; +setegid: +.globl setenv +.type setenv, @function; +setenv: +.globl seteuid +.type seteuid, @function; +seteuid: +.globl setfsgid +.type setfsgid, @function; +setfsgid: +.globl setfsuid +.type setfsuid, @function; +setfsuid: +.globl setgid +.type setgid, @function; +setgid: +.globl setgrent +.type setgrent, @function; +setgrent: +.globl setgroups +.type setgroups, @function; +setgroups: +.globl sethostent +.type sethostent, @function; +sethostent: +.globl sethostname +.type sethostname, @function; +sethostname: +.globl setitimer +.type setitimer, @function; +setitimer: +.globl setjmp +.type setjmp, @function; +setjmp: +.globl setkey +.type setkey, @function; +setkey: +.globl setlinebuf +.type setlinebuf, @function; +setlinebuf: +.globl setlocale +.type setlocale, @function; +setlocale: +.globl setlogmask +.type setlogmask, @function; +setlogmask: +.globl setmntent +.type setmntent, @function; +setmntent: +.weak setnetent +.type setnetent, @function; +setnetent: +.globl setns +.type setns, @function; +setns: +.globl setpgid +.type setpgid, @function; +setpgid: +.globl setpgrp +.type setpgrp, @function; +setpgrp: +.globl setpriority +.type setpriority, @function; +setpriority: +.globl setprotoent +.type setprotoent, @function; +setprotoent: +.globl setpwent +.type setpwent, @function; +setpwent: +.globl setregid +.type setregid, @function; +setregid: +.globl setresgid +.type setresgid, @function; +setresgid: +.globl setresuid +.type setresuid, @function; +setresuid: +.globl setreuid +.type setreuid, @function; +setreuid: +.globl setrlimit +.type setrlimit, @function; +setrlimit: +.weak setrlimit64 +.type setrlimit64, @function; +setrlimit64: +.globl setservent +.type setservent, @function; +setservent: +.globl setsid +.type setsid, @function; +setsid: +.globl setsockopt +.type setsockopt, @function; +setsockopt: +.globl setspent +.type setspent, @function; +setspent: +.globl setstate +.type setstate, @function; +setstate: +.globl settimeofday +.type settimeofday, @function; +settimeofday: +.globl setuid +.type setuid, @function; +setuid: +.globl setusershell +.type setusershell, @function; +setusershell: +.weak setutent +.type setutent, @function; +setutent: +.globl setutxent +.type setutxent, @function; +setutxent: +.globl setvbuf +.type setvbuf, @function; +setvbuf: +.globl setxattr +.type setxattr, @function; +setxattr: +.globl shm_open +.type shm_open, @function; +shm_open: +.globl shm_unlink +.type shm_unlink, @function; +shm_unlink: +.globl shmat +.type shmat, @function; +shmat: +.globl shmctl +.type shmctl, @function; +shmctl: +.globl shmdt +.type shmdt, @function; +shmdt: +.globl shmget +.type shmget, @function; +shmget: +.globl shutdown +.type shutdown, @function; +shutdown: +.weak sigaction +.type sigaction, @function; +sigaction: +.globl sigaddset +.type sigaddset, @function; +sigaddset: +.globl sigaltstack +.type sigaltstack, @function; +sigaltstack: +.globl sigandset +.type sigandset, @function; +sigandset: +.globl sigdelset +.type sigdelset, @function; +sigdelset: +.globl sigemptyset +.type sigemptyset, @function; +sigemptyset: +.globl sigfillset +.type sigfillset, @function; +sigfillset: +.globl sighold +.type sighold, @function; +sighold: +.globl sigignore +.type sigignore, @function; +sigignore: +.globl siginterrupt +.type siginterrupt, @function; +siginterrupt: +.globl sigisemptyset +.type sigisemptyset, @function; +sigisemptyset: +.globl sigismember +.type sigismember, @function; +sigismember: +.globl siglongjmp +.type siglongjmp, @function; +siglongjmp: +.globl signal +.type signal, @function; +signal: +.globl signalfd +.type signalfd, @function; +signalfd: +.globl significand +.type significand, @function; +significand: +.globl significandf +.type significandf, @function; +significandf: +.globl sigorset +.type sigorset, @function; +sigorset: +.globl sigpause +.type sigpause, @function; +sigpause: +.globl sigpending +.type sigpending, @function; +sigpending: +.globl sigprocmask +.type sigprocmask, @function; +sigprocmask: +.globl sigqueue +.type sigqueue, @function; +sigqueue: +.globl sigrelse +.type sigrelse, @function; +sigrelse: +.globl sigset +.type sigset, @function; +sigset: +.globl sigsetjmp +.type sigsetjmp, @function; +sigsetjmp: +.globl sigsuspend +.type sigsuspend, @function; +sigsuspend: +.globl sigtimedwait +.type sigtimedwait, @function; +sigtimedwait: +.globl sigwait +.type sigwait, @function; +sigwait: +.globl sigwaitinfo +.type sigwaitinfo, @function; +sigwaitinfo: +.globl sin +.type sin, @function; +sin: +.globl sincos +.type sincos, @function; +sincos: +.globl sincosf +.type sincosf, @function; +sincosf: +.globl sincosl +.type sincosl, @function; +sincosl: +.globl sinf +.type sinf, @function; +sinf: +.globl sinh +.type sinh, @function; +sinh: +.globl sinhf +.type sinhf, @function; +sinhf: +.globl sinhl +.type sinhl, @function; +sinhl: +.globl sinl +.type sinl, @function; +sinl: +.globl sleep +.type sleep, @function; +sleep: +.globl snprintf +.type snprintf, @function; +snprintf: +.globl sockatmark +.type sockatmark, @function; +sockatmark: +.globl socket +.type socket, @function; +socket: +.globl socketpair +.type socketpair, @function; +socketpair: +.globl splice +.type splice, @function; +splice: +.globl sprintf +.type sprintf, @function; +sprintf: +.globl sqrt +.type sqrt, @function; +sqrt: +.globl sqrtf +.type sqrtf, @function; +sqrtf: +.globl sqrtl +.type sqrtl, @function; +sqrtl: +.globl srand +.type srand, @function; +srand: +.globl srand48 +.type srand48, @function; +srand48: +.globl srandom +.type srandom, @function; +srandom: +.globl sscanf +.type sscanf, @function; +sscanf: +.globl stat +.type stat, @function; +stat: +.weak stat64 +.type stat64, @function; +stat64: +.weak statfs +.type statfs, @function; +statfs: +.weak statfs64 +.type statfs64, @function; +statfs64: +.globl statvfs +.type statvfs, @function; +statvfs: +.weak statvfs64 +.type statvfs64, @function; +statvfs64: +.globl stime +.type stime, @function; +stime: +.weak stpcpy +.type stpcpy, @function; +stpcpy: +.weak stpncpy +.type stpncpy, @function; +stpncpy: +.globl strcasecmp +.type strcasecmp, @function; +strcasecmp: +.weak strcasecmp_l +.type strcasecmp_l, @function; +strcasecmp_l: +.globl strcasestr +.type strcasestr, @function; +strcasestr: +.globl strcat +.type strcat, @function; +strcat: +.globl strchr +.type strchr, @function; +strchr: +.weak strchrnul +.type strchrnul, @function; +strchrnul: +.globl strcmp +.type strcmp, @function; +strcmp: +.globl strcoll +.type strcoll, @function; +strcoll: +.weak strcoll_l +.type strcoll_l, @function; +strcoll_l: +.globl strcpy +.type strcpy, @function; +strcpy: +.globl strcspn +.type strcspn, @function; +strcspn: +.globl strdup +.type strdup, @function; +strdup: +.globl strerror +.type strerror, @function; +strerror: +.weak strerror_l +.type strerror_l, @function; +strerror_l: +.globl strerror_r +.type strerror_r, @function; +strerror_r: +.globl strfmon +.type strfmon, @function; +strfmon: +.globl strfmon_l +.type strfmon_l, @function; +strfmon_l: +.globl strftime +.type strftime, @function; +strftime: +.weak strftime_l +.type strftime_l, @function; +strftime_l: +.globl strlcat +.type strlcat, @function; +strlcat: +.globl strlcpy +.type strlcpy, @function; +strlcpy: +.globl strlen +.type strlen, @function; +strlen: +.globl strncasecmp +.type strncasecmp, @function; +strncasecmp: +.weak strncasecmp_l +.type strncasecmp_l, @function; +strncasecmp_l: +.globl strncat +.type strncat, @function; +strncat: +.globl strncmp +.type strncmp, @function; +strncmp: +.globl strncpy +.type strncpy, @function; +strncpy: +.globl strndup +.type strndup, @function; +strndup: +.globl strnlen +.type strnlen, @function; +strnlen: +.globl strpbrk +.type strpbrk, @function; +strpbrk: +.globl strptime +.type strptime, @function; +strptime: +.globl strrchr +.type strrchr, @function; +strrchr: +.globl strsep +.type strsep, @function; +strsep: +.globl strsignal +.type strsignal, @function; +strsignal: +.globl strspn +.type strspn, @function; +strspn: +.globl strstr +.type strstr, @function; +strstr: +.globl strtod +.type strtod, @function; +strtod: +.weak strtod_l +.type strtod_l, @function; +strtod_l: +.globl strtof +.type strtof, @function; +strtof: +.weak strtof_l +.type strtof_l, @function; +strtof_l: +.globl strtoimax +.type strtoimax, @function; +strtoimax: +.globl strtok +.type strtok, @function; +strtok: +.globl strtok_r +.type strtok_r, @function; +strtok_r: +.globl strtol +.type strtol, @function; +strtol: +.globl strtold +.type strtold, @function; +strtold: +.weak strtold_l +.type strtold_l, @function; +strtold_l: +.globl strtoll +.type strtoll, @function; +strtoll: +.globl strtoul +.type strtoul, @function; +strtoul: +.globl strtoull +.type strtoull, @function; +strtoull: +.globl strtoumax +.type strtoumax, @function; +strtoumax: +.globl strverscmp +.type strverscmp, @function; +strverscmp: +.globl strxfrm +.type strxfrm, @function; +strxfrm: +.weak strxfrm_l +.type strxfrm_l, @function; +strxfrm_l: +.globl swab +.type swab, @function; +swab: +.globl swapoff +.type swapoff, @function; +swapoff: +.globl swapon +.type swapon, @function; +swapon: +.globl swprintf +.type swprintf, @function; +swprintf: +.globl swscanf +.type swscanf, @function; +swscanf: +.globl symlink +.type symlink, @function; +symlink: +.globl symlinkat +.type symlinkat, @function; +symlinkat: +.globl sync +.type sync, @function; +sync: +.globl sync_file_range +.type sync_file_range, @function; +sync_file_range: +.globl syncfs +.type syncfs, @function; +syncfs: +.globl syscall +.type syscall, @function; +syscall: +.globl sysconf +.type sysconf, @function; +sysconf: +.weak sysinfo +.type sysinfo, @function; +sysinfo: +.globl syslog +.type syslog, @function; +syslog: +.globl system +.type system, @function; +system: +.globl tan +.type tan, @function; +tan: +.globl tanf +.type tanf, @function; +tanf: +.globl tanh +.type tanh, @function; +tanh: +.globl tanhf +.type tanhf, @function; +tanhf: +.globl tanhl +.type tanhl, @function; +tanhl: +.globl tanl +.type tanl, @function; +tanl: +.globl tcdrain +.type tcdrain, @function; +tcdrain: +.globl tcflow +.type tcflow, @function; +tcflow: +.globl tcflush +.type tcflush, @function; +tcflush: +.globl tcgetattr +.type tcgetattr, @function; +tcgetattr: +.globl tcgetpgrp +.type tcgetpgrp, @function; +tcgetpgrp: +.globl tcgetsid +.type tcgetsid, @function; +tcgetsid: +.globl tcsendbreak +.type tcsendbreak, @function; +tcsendbreak: +.globl tcsetattr +.type tcsetattr, @function; +tcsetattr: +.globl tcsetpgrp +.type tcsetpgrp, @function; +tcsetpgrp: +.globl tdelete +.type tdelete, @function; +tdelete: +.globl tdestroy +.type tdestroy, @function; +tdestroy: +.globl tee +.type tee, @function; +tee: +.globl telldir +.type telldir, @function; +telldir: +.globl tempnam +.type tempnam, @function; +tempnam: +.globl textdomain +.type textdomain, @function; +textdomain: +.globl tfind +.type tfind, @function; +tfind: +.globl tgamma +.type tgamma, @function; +tgamma: +.globl tgammaf +.type tgammaf, @function; +tgammaf: +.globl tgammal +.type tgammal, @function; +tgammal: +.globl thrd_create +.type thrd_create, @function; +thrd_create: +.weak thrd_current +.type thrd_current, @function; +thrd_current: +.weak thrd_detach +.type thrd_detach, @function; +thrd_detach: +.weak thrd_equal +.type thrd_equal, @function; +thrd_equal: +.globl thrd_exit +.type thrd_exit, @function; +thrd_exit: +.globl thrd_join +.type thrd_join, @function; +thrd_join: +.globl thrd_sleep +.type thrd_sleep, @function; +thrd_sleep: +.globl thrd_yield +.type thrd_yield, @function; +thrd_yield: +.globl time +.type time, @function; +time: +.globl timegm +.type timegm, @function; +timegm: +.globl timer_create +.type timer_create, @function; +timer_create: +.globl timer_delete +.type timer_delete, @function; +timer_delete: +.globl timer_getoverrun +.type timer_getoverrun, @function; +timer_getoverrun: +.globl timer_gettime +.type timer_gettime, @function; +timer_gettime: +.globl timer_settime +.type timer_settime, @function; +timer_settime: +.globl timerfd_create +.type timerfd_create, @function; +timerfd_create: +.globl timerfd_gettime +.type timerfd_gettime, @function; +timerfd_gettime: +.globl timerfd_settime +.type timerfd_settime, @function; +timerfd_settime: +.globl times +.type times, @function; +times: +.globl timespec_get +.type timespec_get, @function; +timespec_get: +.globl tmpfile +.type tmpfile, @function; +tmpfile: +.weak tmpfile64 +.type tmpfile64, @function; +tmpfile64: +.globl tmpnam +.type tmpnam, @function; +tmpnam: +.globl toascii +.type toascii, @function; +toascii: +.globl tolower +.type tolower, @function; +tolower: +.weak tolower_l +.type tolower_l, @function; +tolower_l: +.globl toupper +.type toupper, @function; +toupper: +.weak toupper_l +.type toupper_l, @function; +toupper_l: +.globl towctrans +.type towctrans, @function; +towctrans: +.weak towctrans_l +.type towctrans_l, @function; +towctrans_l: +.globl towlower +.type towlower, @function; +towlower: +.weak towlower_l +.type towlower_l, @function; +towlower_l: +.globl towupper +.type towupper, @function; +towupper: +.weak towupper_l +.type towupper_l, @function; +towupper_l: +.globl trunc +.type trunc, @function; +trunc: +.globl truncate +.type truncate, @function; +truncate: +.weak truncate64 +.type truncate64, @function; +truncate64: +.globl truncf +.type truncf, @function; +truncf: +.globl truncl +.type truncl, @function; +truncl: +.globl tsearch +.type tsearch, @function; +tsearch: +.globl tss_create +.type tss_create, @function; +tss_create: +.globl tss_delete +.type tss_delete, @function; +tss_delete: +.weak tss_get +.type tss_get, @function; +tss_get: +.globl tss_set +.type tss_set, @function; +tss_set: +.globl ttyname +.type ttyname, @function; +ttyname: +.globl ttyname_r +.type ttyname_r, @function; +ttyname_r: +.globl twalk +.type twalk, @function; +twalk: +.weak tzset +.type tzset, @function; +tzset: +.globl ualarm +.type ualarm, @function; +ualarm: +.globl ulckpwdf +.type ulckpwdf, @function; +ulckpwdf: +.globl ulimit +.type ulimit, @function; +ulimit: +.globl umask +.type umask, @function; +umask: +.globl umount +.type umount, @function; +umount: +.globl umount2 +.type umount2, @function; +umount2: +.globl uname +.type uname, @function; +uname: +.globl ungetc +.type ungetc, @function; +ungetc: +.globl ungetwc +.type ungetwc, @function; +ungetwc: +.globl unlink +.type unlink, @function; +unlink: +.globl unlinkat +.type unlinkat, @function; +unlinkat: +.globl unlockpt +.type unlockpt, @function; +unlockpt: +.globl unsetenv +.type unsetenv, @function; +unsetenv: +.globl unshare +.type unshare, @function; +unshare: +.weak updwtmp +.type updwtmp, @function; +updwtmp: +.globl updwtmpx +.type updwtmpx, @function; +updwtmpx: +.weak uselocale +.type uselocale, @function; +uselocale: +.globl usleep +.type usleep, @function; +usleep: +.globl utime +.type utime, @function; +utime: +.globl utimensat +.type utimensat, @function; +utimensat: +.globl utimes +.type utimes, @function; +utimes: +.weak utmpname +.type utmpname, @function; +utmpname: +.weak utmpxname +.type utmpxname, @function; +utmpxname: +.globl valloc +.type valloc, @function; +valloc: +.globl vasprintf +.type vasprintf, @function; +vasprintf: +.globl vdprintf +.type vdprintf, @function; +vdprintf: +.globl verr +.type verr, @function; +verr: +.globl verrx +.type verrx, @function; +verrx: +.globl versionsort +.type versionsort, @function; +versionsort: +.weak versionsort64 +.type versionsort64, @function; +versionsort64: +.globl vfork +.type vfork, @function; +vfork: +.globl vfprintf +.type vfprintf, @function; +vfprintf: +.globl vfscanf +.type vfscanf, @function; +vfscanf: +.globl vfwprintf +.type vfwprintf, @function; +vfwprintf: +.globl vfwscanf +.type vfwscanf, @function; +vfwscanf: +.globl vhangup +.type vhangup, @function; +vhangup: +.globl vmsplice +.type vmsplice, @function; +vmsplice: +.globl vprintf +.type vprintf, @function; +vprintf: +.globl vscanf +.type vscanf, @function; +vscanf: +.globl vsnprintf +.type vsnprintf, @function; +vsnprintf: +.globl vsprintf +.type vsprintf, @function; +vsprintf: +.globl vsscanf +.type vsscanf, @function; +vsscanf: +.globl vswprintf +.type vswprintf, @function; +vswprintf: +.globl vswscanf +.type vswscanf, @function; +vswscanf: +.weak vsyslog +.type vsyslog, @function; +vsyslog: +.globl vwarn +.type vwarn, @function; +vwarn: +.globl vwarnx +.type vwarnx, @function; +vwarnx: +.globl vwprintf +.type vwprintf, @function; +vwprintf: +.globl vwscanf +.type vwscanf, @function; +vwscanf: +.globl wait +.type wait, @function; +wait: +.globl wait3 +.type wait3, @function; +wait3: +.globl wait4 +.type wait4, @function; +wait4: +.globl waitid +.type waitid, @function; +waitid: +.globl waitpid +.type waitpid, @function; +waitpid: +.globl warn +.type warn, @function; +warn: +.globl warnx +.type warnx, @function; +warnx: +.globl wcpcpy +.type wcpcpy, @function; +wcpcpy: +.globl wcpncpy +.type wcpncpy, @function; +wcpncpy: +.globl wcrtomb +.type wcrtomb, @function; +wcrtomb: +.globl wcscasecmp +.type wcscasecmp, @function; +wcscasecmp: +.globl wcscasecmp_l +.type wcscasecmp_l, @function; +wcscasecmp_l: +.globl wcscat +.type wcscat, @function; +wcscat: +.globl wcschr +.type wcschr, @function; +wcschr: +.globl wcscmp +.type wcscmp, @function; +wcscmp: +.globl wcscoll +.type wcscoll, @function; +wcscoll: +.weak wcscoll_l +.type wcscoll_l, @function; +wcscoll_l: +.globl wcscpy +.type wcscpy, @function; +wcscpy: +.globl wcscspn +.type wcscspn, @function; +wcscspn: +.globl wcsdup +.type wcsdup, @function; +wcsdup: +.globl wcsftime +.type wcsftime, @function; +wcsftime: +.weak wcsftime_l +.type wcsftime_l, @function; +wcsftime_l: +.globl wcslen +.type wcslen, @function; +wcslen: +.globl wcsncasecmp +.type wcsncasecmp, @function; +wcsncasecmp: +.globl wcsncasecmp_l +.type wcsncasecmp_l, @function; +wcsncasecmp_l: +.globl wcsncat +.type wcsncat, @function; +wcsncat: +.globl wcsncmp +.type wcsncmp, @function; +wcsncmp: +.globl wcsncpy +.type wcsncpy, @function; +wcsncpy: +.globl wcsnlen +.type wcsnlen, @function; +wcsnlen: +.globl wcsnrtombs +.type wcsnrtombs, @function; +wcsnrtombs: +.globl wcspbrk +.type wcspbrk, @function; +wcspbrk: +.globl wcsrchr +.type wcsrchr, @function; +wcsrchr: +.globl wcsrtombs +.type wcsrtombs, @function; +wcsrtombs: +.globl wcsspn +.type wcsspn, @function; +wcsspn: +.globl wcsstr +.type wcsstr, @function; +wcsstr: +.globl wcstod +.type wcstod, @function; +wcstod: +.globl wcstof +.type wcstof, @function; +wcstof: +.globl wcstoimax +.type wcstoimax, @function; +wcstoimax: +.globl wcstok +.type wcstok, @function; +wcstok: +.globl wcstol +.type wcstol, @function; +wcstol: +.globl wcstold +.type wcstold, @function; +wcstold: +.globl wcstoll +.type wcstoll, @function; +wcstoll: +.globl wcstombs +.type wcstombs, @function; +wcstombs: +.globl wcstoul +.type wcstoul, @function; +wcstoul: +.globl wcstoull +.type wcstoull, @function; +wcstoull: +.globl wcstoumax +.type wcstoumax, @function; +wcstoumax: +.globl wcswcs +.type wcswcs, @function; +wcswcs: +.globl wcswidth +.type wcswidth, @function; +wcswidth: +.globl wcsxfrm +.type wcsxfrm, @function; +wcsxfrm: +.weak wcsxfrm_l +.type wcsxfrm_l, @function; +wcsxfrm_l: +.globl wctob +.type wctob, @function; +wctob: +.globl wctomb +.type wctomb, @function; +wctomb: +.globl wctrans +.type wctrans, @function; +wctrans: +.weak wctrans_l +.type wctrans_l, @function; +wctrans_l: +.globl wctype +.type wctype, @function; +wctype: +.weak wctype_l +.type wctype_l, @function; +wctype_l: +.globl wcwidth +.type wcwidth, @function; +wcwidth: +.globl wmemchr +.type wmemchr, @function; +wmemchr: +.globl wmemcmp +.type wmemcmp, @function; +wmemcmp: +.globl wmemcpy +.type wmemcpy, @function; +wmemcpy: +.globl wmemmove +.type wmemmove, @function; +wmemmove: +.globl wmemset +.type wmemset, @function; +wmemset: +.globl wordexp +.type wordexp, @function; +wordexp: +.globl wordfree +.type wordfree, @function; +wordfree: +.globl wprintf +.type wprintf, @function; +wprintf: +.globl write +.type write, @function; +write: +.globl writev +.type writev, @function; +writev: +.globl wscanf +.type wscanf, @function; +wscanf: +.globl y0 +.type y0, @function; +y0: +.globl y0f +.type y0f, @function; +y0f: +.globl y1 +.type y1, @function; +y1: +.globl y1f +.type y1f, @function; +y1f: +.globl yn +.type yn, @function; +yn: +.globl ynf +.type ynf, @function; +ynf: diff --git a/src/Compilation.zig b/src/Compilation.zig index 96bf7b5797..1c8edcfde2 100644 --- a/src/Compilation.zig +++ b/src/Compilation.zig @@ -1025,7 +1025,10 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation { .{ .musl_crt_file = .crt1_o }, .{ .musl_crt_file = .scrt1_o }, .{ .musl_crt_file = .rcrt1_o }, - .{ .musl_crt_file = .libc_a }, + switch (comp.bin_file.options.link_mode) { + .Static => .{ .musl_crt_file = .libc_a }, + .Dynamic => .{ .musl_crt_file = .libc_so }, + }, }); } if (comp.wantBuildMinGWFromSource()) { diff --git a/src/link/Elf.zig b/src/link/Elf.zig index 852b51ece1..03202c90be 100644 --- a/src/link/Elf.zig +++ b/src/link/Elf.zig @@ -1598,7 +1598,10 @@ fn linkWithLLD(self: *Elf, comp: *Compilation) !void { try argv.append(try comp.get_libc_crt_file(arena, "libc_nonshared.a")); } else if (target.isMusl()) { try argv.append(comp.libunwind_static_lib.?.full_object_path); - try argv.append(try comp.get_libc_crt_file(arena, "libc.a")); + try argv.append(try comp.get_libc_crt_file(arena, switch (self.base.options.link_mode) { + .Static => "libc.a", + .Dynamic => "libc.so", + })); } else if (self.base.options.link_libcpp) { try argv.append(comp.libunwind_static_lib.?.full_object_path); } else { diff --git a/src/musl.zig b/src/musl.zig index 9ac4d42f8d..d69acc650e 100644 --- a/src/musl.zig +++ b/src/musl.zig @@ -15,6 +15,7 @@ pub const CRTFile = enum { rcrt1_o, scrt1_o, libc_a, + libc_so, }; pub fn buildCRTFile(comp: *Compilation, crt_file: CRTFile) !void { @@ -189,6 +190,58 @@ pub fn buildCRTFile(comp: *Compilation, crt_file: CRTFile) !void { } return comp.build_crt_file("c", .Lib, c_source_files.items); }, + .libc_so => { + const sub_compilation = try Compilation.create(comp.gpa, .{ + .local_cache_directory = comp.global_cache_directory, + .global_cache_directory = comp.global_cache_directory, + .zig_lib_directory = comp.zig_lib_directory, + .target = comp.getTarget(), + .root_name = "c", + .root_pkg = null, + .output_mode = .Lib, + .link_mode = .Dynamic, + .rand = comp.rand, + .libc_installation = comp.bin_file.options.libc_installation, + .emit_bin = Compilation.EmitLoc{ .directory = null, .basename = "libc.so" }, + .optimize_mode = comp.bin_file.options.optimize_mode, + .want_sanitize_c = false, + .want_stack_check = false, + .want_valgrind = false, + .emit_h = null, + .strip = comp.bin_file.options.strip, + .is_native_os = false, + .self_exe_path = comp.self_exe_path, + .verbose_cc = comp.verbose_cc, + .verbose_link = comp.bin_file.options.verbose_link, + .verbose_tokenize = comp.verbose_tokenize, + .verbose_ast = comp.verbose_ast, + .verbose_ir = comp.verbose_ir, + .verbose_llvm_ir = comp.verbose_llvm_ir, + .verbose_cimport = comp.verbose_cimport, + .verbose_llvm_cpu_features = comp.verbose_llvm_cpu_features, + .clang_passthrough_mode = comp.clang_passthrough_mode, + .c_source_files = &[_]Compilation.CSourceFile{ + .{ .src_path = try comp.zig_lib_directory.join(arena, &[_][]const u8{ "libc", "musl", "libc.s" }) }, + }, + .is_compiler_rt_or_libc = true, + .soname = "libc.so", + }); + defer sub_compilation.destroy(); + + try sub_compilation.updateSubCompilation(); + + try comp.crt_files.ensureCapacity(comp.gpa, comp.crt_files.count() + 1); + + const basename = try comp.gpa.dupe(u8, "libc.so"); + errdefer comp.gpa.free(basename); + + comp.crt_files.putAssumeCapacityNoClobber(basename, .{ + .full_object_path = try sub_compilation.bin_file.options.emit.?.directory.join(comp.gpa, &[_][]const u8{ + sub_compilation.bin_file.options.emit.?.sub_path, + }), + .lock = sub_compilation.bin_file.toOwnedLock(), + }); + }, } } diff --git a/tools/gen_stubs.zig b/tools/gen_stubs.zig new file mode 100644 index 0000000000..b436fdc530 --- /dev/null +++ b/tools/gen_stubs.zig @@ -0,0 +1,117 @@ +const std = @import("std"); + +const mem = std.mem; + +const Symbol = struct { + name: []const u8, + section: []const u8, + kind: enum { + global, + weak, + }, + type: enum { + none, + function, + object, + }, + protected: bool, +}; + +// Example usage: +// objdump --dynamic-syms /path/to/libc.so | ./gen_stubs > lib/libc/musl/libc.s +pub fn main() !void { + const stdin = std.io.getStdIn().reader(); + const stdout = std.io.getStdOut().writer(); + + var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator); + defer arena.deinit(); + const ally = &arena.allocator; + + var symbols = std.ArrayList(Symbol).init(ally); + var sections = std.ArrayList([]const u8).init(ally); + + // This is many times larger than any line objdump produces should ever be + var buf: [4096]u8 = undefined; + + // Sample input line: + // 00000000000241b0 g DF .text 000000000000001b copy_file_range + while (try stdin.readUntilDelimiterOrEof(&buf, '\n')) |line| { + // the lines we want all start with a 16 digit hex value + if (line.len < 16) continue; + _ = std.fmt.parseInt(u64, line[0..16], 16) catch continue; + + // Ignore non-dynamic symbols + if (line[22] != 'D') continue; + + const section = line[25 .. 25 + mem.indexOfAny(u8, line[25..], &std.ascii.spaces).?]; + + // the last whitespace-separated column is the symbol name + const name = line[1 + mem.lastIndexOfAny(u8, line, &std.ascii.spaces).? ..]; + + const symbol = Symbol{ + .name = try ally.dupe(u8, name), + .section = try ally.dupe(u8, section), + + .kind = if (line[17] == 'g' and line[18] == ' ') + .global + else if (line[17] == ' ' and line[18] == 'w') + .weak + else + unreachable, + + .type = switch (line[23]) { + 'F' => .function, + 'O' => .object, + ' ' => .none, + else => unreachable, + }, + + .protected = mem.indexOf(u8, line, ".protected") != null, + }; + + for (sections.items) |s| { + if (mem.eql(u8, s, symbol.section)) break; + } else { + try sections.append(symbol.section); + } + + try symbols.append(symbol); + } + + std.sort.sort(Symbol, symbols.items, {}, cmpSymbols); + std.sort.sort([]const u8, sections.items, {}, alphabetical); + + for (sections.items) |section| { + try stdout.print("{s}\n", .{section}); + + for (symbols.items) |symbol| { + if (!mem.eql(u8, symbol.section, section)) continue; + + switch (symbol.kind) { + .global => try stdout.print(".globl {s}\n", .{symbol.name}), + .weak => try stdout.print(".weak {s}\n", .{symbol.name}), + } + switch (symbol.type) { + .function => try stdout.print(".type {s}, @function;\n", .{symbol.name}), + .object => try stdout.print(".type {s}, @object;\n", .{symbol.name}), + .none => {}, + } + if (symbol.protected) + try stdout.print(".protected {s}\n", .{symbol.name}); + try stdout.print("{s}:\n", .{symbol.name}); + } + } +} + +fn cmpSymbols(_: void, lhs: Symbol, rhs: Symbol) bool { + return alphabetical({}, lhs.name, rhs.name); +} + +fn alphabetical(_: void, lhs: []const u8, rhs: []const u8) bool { + var i: usize = 0; + while (i < lhs.len and i < rhs.len) : (i += 1) { + if (lhs[i] == rhs[i]) continue; + return lhs[i] < rhs[i]; + } + return lhs.len < rhs.len; +} From 078a64f8d9b50ad99afe12ba3038afc3e68f507c Mon Sep 17 00:00:00 2001 From: Isaac Freund Date: Sat, 12 Dec 2020 02:14:06 +0100 Subject: [PATCH 2/3] std.CrossTarget: add isNativeAbi() --- lib/std/zig/cross_target.zig | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/lib/std/zig/cross_target.zig b/lib/std/zig/cross_target.zig index b26f416d26..87a65d6ad8 100644 --- a/lib/std/zig/cross_target.zig +++ b/lib/std/zig/cross_target.zig @@ -500,8 +500,12 @@ pub const CrossTarget = struct { self.dynamic_linker.get() == null and self.glibc_version == null; } + pub fn isNativeAbi(self: CrossTarget) bool { + return self.os_tag == null and self.abi == null; + } + pub fn isNative(self: CrossTarget) bool { - return self.isNativeCpu() and self.isNativeOs() and self.abi == null; + return self.isNativeCpu() and self.isNativeOs() and self.isNativeAbi(); } pub fn zigTriple(self: CrossTarget, allocator: *mem.Allocator) error{OutOfMemory}![]u8 { From 1d8f33ca98493d63c509e0a23b8dc512f4d7b79f Mon Sep 17 00:00:00 2001 From: Isaac Freund Date: Fri, 11 Dec 2020 23:02:35 +0100 Subject: [PATCH 3/3] stage2: link musl dynamically by default if native If targeting the native OS and the system libc is musl, link against it dynamically by default. --- src/Compilation.zig | 18 +++++++++++++++++- src/glibc.zig | 1 + src/libcxx.zig | 2 ++ src/libunwind.zig | 1 + src/link.zig | 1 + src/main.zig | 2 ++ src/musl.zig | 1 + src/test.zig | 1 + 8 files changed, 26 insertions(+), 1 deletion(-) diff --git a/src/Compilation.zig b/src/Compilation.zig index 1c8edcfde2..81a2bff37b 100644 --- a/src/Compilation.zig +++ b/src/Compilation.zig @@ -385,6 +385,7 @@ pub const InitOptions = struct { single_threaded: bool = false, function_sections: bool = false, is_native_os: bool, + is_native_abi: bool, time_report: bool = false, stack_report: bool = false, link_eh_frame_hdr: bool = false, @@ -600,7 +601,19 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation { break :dl false; }; - const default_link_mode: std.builtin.LinkMode = if (must_dynamic_link) .Dynamic else .Static; + const default_link_mode: std.builtin.LinkMode = blk: { + if (must_dynamic_link) { + break :blk .Dynamic; + } else if (is_exe_or_dyn_lib and link_libc and + options.is_native_abi and options.target.abi.isMusl()) + { + // If targeting the system's native ABI and the system's + // libc is musl, link dynamically by default. + break :blk .Dynamic; + } else { + break :blk .Static; + } + }; const link_mode: std.builtin.LinkMode = if (options.link_mode) |lm| blk: { if (lm == .Static and must_dynamic_link) { return error.UnableToStaticLink; @@ -910,6 +923,7 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation { .rpath_list = options.rpath_list, .strip = strip, .is_native_os = options.is_native_os, + .is_native_abi = options.is_native_abi, .function_sections = options.function_sections, .allow_shlib_undefined = options.linker_allow_shlib_undefined, .bind_global_refs_locally = options.linker_bind_global_refs_locally orelse false, @@ -2778,6 +2792,7 @@ fn buildOutputFromZig( .emit_h = null, .strip = comp.bin_file.options.strip, .is_native_os = comp.bin_file.options.is_native_os, + .is_native_abi = comp.bin_file.options.is_native_abi, .self_exe_path = comp.self_exe_path, .verbose_cc = comp.verbose_cc, .verbose_link = comp.bin_file.options.verbose_link, @@ -3148,6 +3163,7 @@ pub fn build_crt_file( .emit_h = null, .strip = comp.bin_file.options.strip, .is_native_os = comp.bin_file.options.is_native_os, + .is_native_abi = comp.bin_file.options.is_native_abi, .self_exe_path = comp.self_exe_path, .c_source_files = c_source_files, .verbose_cc = comp.verbose_cc, diff --git a/src/glibc.zig b/src/glibc.zig index 6da397d4f5..4f092efb09 100644 --- a/src/glibc.zig +++ b/src/glibc.zig @@ -945,6 +945,7 @@ fn buildSharedLib( .emit_h = null, .strip = comp.bin_file.options.strip, .is_native_os = false, + .is_native_abi = false, .self_exe_path = comp.self_exe_path, .verbose_cc = comp.verbose_cc, .verbose_link = comp.bin_file.options.verbose_link, diff --git a/src/libcxx.zig b/src/libcxx.zig index 9c5ec93776..39ec776659 100644 --- a/src/libcxx.zig +++ b/src/libcxx.zig @@ -175,6 +175,7 @@ pub fn buildLibCXX(comp: *Compilation) !void { .emit_h = null, .strip = comp.bin_file.options.strip, .is_native_os = comp.bin_file.options.is_native_os, + .is_native_abi = comp.bin_file.options.is_native_abi, .self_exe_path = comp.self_exe_path, .c_source_files = c_source_files.items, .verbose_cc = comp.verbose_cc, @@ -293,6 +294,7 @@ pub fn buildLibCXXABI(comp: *Compilation) !void { .emit_h = null, .strip = comp.bin_file.options.strip, .is_native_os = comp.bin_file.options.is_native_os, + .is_native_abi = comp.bin_file.options.is_native_abi, .self_exe_path = comp.self_exe_path, .c_source_files = &c_source_files, .verbose_cc = comp.verbose_cc, diff --git a/src/libunwind.zig b/src/libunwind.zig index 3607488aba..ec8fe990e9 100644 --- a/src/libunwind.zig +++ b/src/libunwind.zig @@ -108,6 +108,7 @@ pub fn buildStaticLib(comp: *Compilation) !void { .emit_h = null, .strip = comp.bin_file.options.strip, .is_native_os = comp.bin_file.options.is_native_os, + .is_native_abi = comp.bin_file.options.is_native_abi, .self_exe_path = comp.self_exe_path, .c_source_files = &c_source_files, .verbose_cc = comp.verbose_cc, diff --git a/src/link.zig b/src/link.zig index 40d5ff9a7f..c0e78f445f 100644 --- a/src/link.zig +++ b/src/link.zig @@ -71,6 +71,7 @@ pub const Options = struct { z_defs: bool, bind_global_refs_locally: bool, is_native_os: bool, + is_native_abi: bool, pic: bool, pie: bool, valgrind: bool, diff --git a/src/main.zig b/src/main.zig index 346fc11af2..9654fc9565 100644 --- a/src/main.zig +++ b/src/main.zig @@ -1685,6 +1685,7 @@ fn buildOutputType( .root_name = root_name, .target = target_info.target, .is_native_os = cross_target.isNativeOs(), + .is_native_abi = cross_target.isNativeAbi(), .dynamic_linker = target_info.dynamic_linker.get(), .output_mode = output_mode, .root_pkg = root_pkg, @@ -2415,6 +2416,7 @@ pub fn cmdBuild(gpa: *Allocator, arena: *Allocator, args: []const []const u8) !v .root_name = "build", .target = target_info.target, .is_native_os = cross_target.isNativeOs(), + .is_native_abi = cross_target.isNativeAbi(), .dynamic_linker = target_info.dynamic_linker.get(), .output_mode = .Exe, .root_pkg = &root_pkg, diff --git a/src/musl.zig b/src/musl.zig index d69acc650e..ac39eb7d74 100644 --- a/src/musl.zig +++ b/src/musl.zig @@ -210,6 +210,7 @@ pub fn buildCRTFile(comp: *Compilation, crt_file: CRTFile) !void { .emit_h = null, .strip = comp.bin_file.options.strip, .is_native_os = false, + .is_native_abi = false, .self_exe_path = comp.self_exe_path, .verbose_cc = comp.verbose_cc, .verbose_link = comp.bin_file.options.verbose_link, diff --git a/src/test.zig b/src/test.zig index c72c5207f6..251edc2d34 100644 --- a/src/test.zig +++ b/src/test.zig @@ -561,6 +561,7 @@ pub const TestContext = struct { .keep_source_files_loaded = true, .object_format = ofmt, .is_native_os = case.target.isNativeOs(), + .is_native_abi = case.target.isNativeAbi(), }); defer comp.destroy();