Split ltrace.conf into libc.so.conf and libacl.so.conf; add libm.so.conf

- This won't work as is--if libc.so.6.conf isn't found, ltrace needs
  to keep looking for libc.so.conf.

3 files changed, 520 insertions, 105 deletions

diff --git a/etc/libacl.so.conf b/etc/libacl.so.conf
new file mode 100644
index 0000000..6b277cd
--- /dev/null
+++ b/etc/libacl.so.conf
@@ -0,0 +1,43 @@
+# See ltrace.conf(5) for description of syntax of this file.
+
+# sys/acl.h
+int acl_add_perm(addr,uint);
+int acl_calc_mask(addr);
+int acl_clear_perms(addr);
+int acl_copy_entry(addr,addr);
+int acl_copy_ext(addr,addr,int);
+addr acl_copy_int(addr);
+int acl_create_entry(addr,addr);
+int acl_delete_def_file(string);
+int acl_delete_entry(addr,addr);
+int acl_delete_perm(addr,uint);
+addr acl_dup(addr);
+int acl_free(addr);
+addr acl_from_text(string);
+int acl_get_entry(addr,int,addr);
+addr acl_get_fd(int);
+addr acl_get_file(string,int);
+int acl_get_permset(addr,addr);
+addr acl_get_qualifier(addr);
+int acl_get_tag_type(addr,addr);
+addr acl_init(int);
+int acl_set_fd(int,addr);
+int acl_set_file(string,int,addr);
+int acl_set_permset(addr,addr);
+int acl_set_qualifier(addr,addr);
+int acl_set_tag_type(addr,int);
+int acl_size(addr);
+string acl_to_text(addr,addr);
+int acl_valid(addr);
+
+# acl/libacl.h
+int acl_check(addr,addr);
+int acl_cmp(addr,addr);
+int acl_entries(addr);
+int acl_equiv_mode(addr,addr);
+string acl_error(int);
+int acl_extended_fd(int);
+int acl_extended_file(string);
+addr acl_from_mode(octal);
+int acl_get_perm(addr,uint);
+string acl_to_any_text(addr,string,char,int);
diff --git a/etc/ltrace.conf b/etc/libc.so.conf
index 0dc573d..efa1b95 100644
--- a/etc/ltrace.conf
+++ b/etc/libc.so.conf
@@ -1,13 +1,6 @@
-; ltrace.conf
-;
-; ~/.ltrace.conf will also be read, if it exists. The -F option may be
-; used to suppress the automatic inclusion of both this file and
-; ~/.ltrace.conf, and load a different config file or config files
-; instead.
-;
-; See ltrace.conf(5) for description of syntax of this file.
-
-; arpa/inet.h
+# See ltrace.conf(5) for description of syntax of this file.
+
+# arpa/inet.h
 typedef in_addr = struct(hex(uint));
 int inet_aton(string, +in_addr*);
 hex(uint) inet_addr(string);
@@ -17,14 +10,14 @@ in_addr inet_makeaddr(hex(int), hex(int));
 hex(uint) inet_lnaof(in_addr);
 hex(uint) inet_netof(in_addr);
 
-; bfd.h
+# bfd.h
 void bfd_init();
 int bfd_set_default_target(string);
 addr bfd_scan_vma(string, addr, int);
 addr bfd_openr(string,string);
 int bfd_check_format(addr,int);
 
-; ctype.h
+# ctype.h
 char tolower(char);
 char toupper(char);
 addr __ctype_b_loc();
@@ -32,27 +25,27 @@ addr __ctype_tolower_loc();
 addr __ctype_toupper_loc();
 ulong __ctype_get_mb_cur_max();
 
-; curses.h
+# curses.h
 int waddch(addr, char);
 int mvprintw(int, int, format);
 int wmove(addr, int, int);
 int waddnstr(addr, string, int);
 string tgoto(string, int, int);
 
-; dirent.h
+# dirent.h
 
-; We can't portably rely on DIR internals at all.  Ideally this would
-; be implemented in a per-OS config file, but even on Linux, we don't
-; know whether there's a lock in the structure or not.  Luckily the
-; one interesting datum, file descriptor, we can access reliably.
-; Having the structure half-defined like this is potentially
-; problematic as structure size influences parameter passing.  But
-; POSIX always uses pointer to the structure, so it's fine.
+# We can't portably rely on DIR internals at all.  Ideally this would
+# be implemented in a per-OS config file, but even on Linux, we don't
+# know whether there's a lock in the structure or not.  Luckily the
+# one interesting datum, file descriptor, we can access reliably.
+# Having the structure half-defined like this is potentially
+# problematic as structure size influences parameter passing.  But
+# POSIX always uses pointer to the structure, so it's fine.
 
 typedef DIR = struct(int);
 
-; XXX We can't represent the following portably without having either
-; uulong, or directly uint64_t.'
+# XXX We can't represent the following portably without having either
+# uulong, or directly uint64_t.'
 
 typedef ino_t = ulong;
 typedef ino_t64 = ulong;
@@ -72,49 +65,49 @@ void rewinddir(DIR *);
 long telldir(DIR *);
 void seekdir(DIR *, long);
 
-; dlfcn.h
+# dlfcn.h
 addr  dlopen(string, int);
 string dlerror();
 addr  dlsym(addr, string);
 int dlclose(addr);
 
-; errno.h
+# errno.h
 addr __errno_location();
 
-; fcntl.h
+# fcntl.h
 int open(string,int,octal);		; WARNING: 3rd argument may not be there
 int open64(string,int,octal);		; WARNING: 3rd argument may not be there
 
-; fnmatch.h
+# fnmatch.h
 int fnmatch(string, string, int);
 
-; getopt.h
+# getopt.h
 int getopt_long(int,addr,string,addr,int*);
 int getopt_long_only(int,addr,string,addr,addr);
 
-; grp.h
+# grp.h
 void endgrent();
 addr getgrnam(string);
 void setgrent();
 addr getgrent();
 
-; libintl.h
+# libintl.h
 string __dcgettext(string,string,int);
 string bindtextdomain(string, string);
 string textdomain(string);
 
-; libio.h
+# libio.h
 char _IO_getc(file);
 int _IO_putc(char,file);
 
-; locale.h
+# locale.h
 string setlocale(enum(LC_CTYPE=0, LC_NUMERIC=1, LC_TIME=2, LC_COLLATE=3, LC_MONETARY=4, LC_MESSAGES=5, LC_ALL=6, LC_PAPER=7, LC_NAME=8, LC_ADDRESS=9, LC_TELEPHONE=10, LC_MEASUREMENT=11, LC_IDENTIFICATION=12), string);
 
-; mcheck.h
+# mcheck.h
 void mtrace();
 void muntrace();
 
-; mqueue.h
+# mqueue.h
 int mq_open(string, int, octal, addr);  ; WARNING: 3rd and 4th arguments may not be there
 int mq_close(int);
 int mq_unlink(string);
@@ -126,7 +119,7 @@ int mq_timedsend(int, string3, ulong, uint, addr);
 long mq_receive(int, +string0, ulong, addr);
 long mq_timedreceive(int, +string0, ulong, addr, addr);
 
-; netdb.h
+# netdb.h
 void endhostent();
 void endnetent();
 void endnetgrent();
@@ -165,29 +158,29 @@ int setnetgrent(string);
 void setprotoent(int);
 void setservent(int);
 
-; netinet/in.h
+# netinet/in.h
 uint ntohs(uint);
 
-; pcap.h
+# pcap.h
 string pcap_lookupdev(addr);
 addr pcap_open_live(string, int, int, int, addr);
 int pcap_snapshot(addr);
 int pcap_lookupnet(string, addr, addr, addr);
 int pcap_compile(addr, addr, string, int, addr);
 
-; pwd.h
+# pwd.h
 string getpass(string);
 void endpwent();
 addr getpwnam(string);
 void setpwent();
 
-; readline/readline.h
+# readline/readline.h
 string readline(string);
 
-; signal.h
+# signal.h
 typedef signum = enum(SIGHUP=1, SIGINT=2, SIGQUIT=3, SIGILL=4, SIGTRAP=5, SIGABRT=6, SIGBUS=7, SIGFPE=8, SIGKILL=9, SIGUSR1=10, SIGSEGV=11, SIGUSR2=12, SIGPIPE=13, SIGALRM=14, SIGTERM=15, SIGSTKFLT=16, SIGCHLD=17, SIGCONT=18, SIGSTOP=19, SIGTSTP=20, SIGTTIN=21, SIGTTOU=22, SIGURG=23, SIGXCPU=24, SIGXFSZ=25, SIGVTALRM=26, SIGPROF=27, SIGWINCH=28, SIGIO=29, SIGPWR=30, SIGSYS=31, SIGRTMIN_0=32, SIGRTMIN_1=33, SIGRTMIN_2=34, SIGRTMIN_3=35, SIGRTMIN_4=36, SIGRTMIN_5=37, SIGRTMIN_6=38, SIGRTMIN_7=39, SIGRTMIN_8=40, SIGRTMIN_9=41, SIGRTMIN_10=42, SIGRTMIN_11=43, SIGRTMIN_12=44, SIGRTMIN_13=45, SIGRTMIN_14=46, SIGRTMIN_15=47, SIGRTMIN_16=48, SIGRTMIN_17=49, SIGRTMIN_18=50, SIGRTMIN_19=51, SIGRTMIN_20=52, SIGRTMIN_21=53, SIGRTMIN_22=54, SIGRTMIN_23=55, SIGRTMIN_24=56, SIGRTMIN_25=57, SIGRTMIN_26=58, SIGRTMIN_27=59, SIGRTMIN_28=60, SIGRTMIN_29=61, SIGRTMIN_30=62, SIGRTMIN_31=63);
 typedef sigset_t = bitvec(ulong);
-; elm3 should be flags
+# elm3 should be flags
 typedef sigaction = struct(addr, sigset_t, hex(int), addr);
 int kill(int, signum);
 int sigemptyset(+sigset_t*);
@@ -204,7 +197,7 @@ int sigisemptyset(sigset_t*);
 int sigorset(+sigset_t*, sigset_t*, sigset_t*);
 int sigandset(+sigset_t*, sigset_t*, sigset_t*);
 
-; stdio.h
+# stdio.h
 int fclose(file);
 int feof(file);
 int ferror(file);
@@ -238,7 +231,7 @@ void setbuffer(file,addr,ulong);
 void setlinebuf(file);
 int rename(string,string);
 
-; stdlib.h
+# stdlib.h
 long __strtol_internal(string,addr,int);
 ulong __strtoul_internal(string,addr,int);
 int atexit(addr);
@@ -276,7 +269,7 @@ void srand48(long);
 array(ushort,3)* seed48(array(ushort,3)*);
 void lcong48(array(ushort,7)*);
 
-; string.h
+# string.h
 void bcopy(addr,addr,ulong);
 void bzero(addr,ulong);
 string basename(string);
@@ -305,13 +298,13 @@ ulong strcspn(string,string);
 string strstr(string,string);
 string strtok(string, string);
 
-; sys/ioctl.h
+# sys/ioctl.h
 int ioctl(int, int, addr);
 
-; sys/socket.h
+# sys/socket.h
 int socket(int,int,int);
 
-; sys/stat.h
+# sys/stat.h
 int __fxstat(int,int,addr);
 int __xstat(int,string,addr);
 int __lxstat(int,string,addr);
@@ -323,25 +316,25 @@ int fchmod(int,octal);
 int mkfifo(string,octal);
 octal umask(octal);
 
-; sys/utsname.h
+# sys/utsname.h
 int uname(addr);
 
-; sys/vfs.h
+# sys/vfs.h
 int statfs(string,addr);
 
-; syslog.h
+# syslog.h
 void closelog();
 void openlog(string,int,int);
 void syslog(int,format);
 
-; term.h
+# term.h
 int tputs(string, int, addr);
 
-; termios.h
+# termios.h
 int tcgetattr(int,addr);
 int tcsetattr(int,int,addr);
 
-; time.h
+# time.h
 string ctime(addr);
 int gettimeofday(addr, addr);
 addr gmtime(addr);
@@ -349,7 +342,7 @@ addr localtime(addr);
 ulong strftime(+string2,ulong,string,addr);
 long time(addr);
 
-; unistd.h
+# unistd.h
 void _exit(int);
 int access(string, int);
 uint alarm(uint);
@@ -401,66 +394,19 @@ int getpagesize();
 long lseek(int,long,int);
 int pipe(addr);
 
-; utmp.h
+# utmp.h
 void endutent();
 addr getutent();
 void setutent();
 
-; wchar.h
+# wchar.h
 int fwide(addr, int);
 
-; sys/wait.h
+# sys/wait.h
 int wait(addr);
 int waitpid(int,addr,int);
 
-; X11/Xlib.h
-void XCloseDisplay(addr);
-int XMapWindow(addr,addr);
-addr XOpenDisplay(string);
-
-; sys/acl.h
-int acl_add_perm(addr,uint);
-int acl_calc_mask(addr);
-int acl_clear_perms(addr);
-int acl_copy_entry(addr,addr);
-int acl_copy_ext(addr,addr,int);
-addr acl_copy_int(addr);
-int acl_create_entry(addr,addr);
-int acl_delete_def_file(string);
-int acl_delete_entry(addr,addr);
-int acl_delete_perm(addr,uint);
-addr acl_dup(addr);
-int acl_free(addr);
-addr acl_from_text(string);
-int acl_get_entry(addr,int,addr);
-addr acl_get_fd(int);
-addr acl_get_file(string,int);
-int acl_get_permset(addr,addr);
-addr acl_get_qualifier(addr);
-int acl_get_tag_type(addr,addr);
-addr acl_init(int);
-int acl_set_fd(int,addr);
-int acl_set_file(string,int,addr);
-int acl_set_permset(addr,addr);
-int acl_set_qualifier(addr,addr);
-int acl_set_tag_type(addr,int);
-int acl_size(addr);
-string acl_to_text(addr,addr);
-int acl_valid(addr);
-
-; acl/libacl.h
-int acl_check(addr,addr);
-int acl_cmp(addr,addr);
-int acl_entries(addr);
-int acl_equiv_mode(addr,addr);
-string acl_error(int);
-int acl_extended_fd(int);
-int acl_extended_file(string);
-addr acl_from_mode(octal);
-int acl_get_perm(addr,uint);
-string acl_to_any_text(addr,string,char,int);
-
-; other symbols not included above
+# other symbols not included above
 long a64l(string);
 string l64a(long);
 void abort();
diff --git a/etc/libm.so.conf b/etc/libm.so.conf
new file mode 100644
index 0000000..8159221
--- /dev/null
+++ b/etc/libm.so.conf
@@ -0,0 +1,426 @@
+# XXX ltrace misses long double and long long support
+typedef ldouble = double;
+typedef llong = long;
+
+# This should generally work, I'm not aware of any arch, where the
+# parameter passing of complex arguments differs from that for
+# structure of two floats.
+typedef double_complex = struct(double, double);
+typedef float_complex = struct(float, float);
+typedef ldouble_complex = struct(ldouble, ldouble);
+
+double sin(double);
+float sinf(float);
+ldouble sinl(ldouble);
+
+double cos(double);
+float cosf(float);
+ldouble cosl(ldouble);
+
+void sincos(double, +double*, double*);
+void sincosf(float, +float*, float*);
+void sincosl(ldouble, +ldouble*, ldouble*);
+
+double tan(double);
+float tanf(float);
+ldouble tanl(ldouble);
+
+double asin(double);
+float asinf(float);
+ldouble asinl(ldouble);
+
+double acos(double);
+float acosf(float);
+ldouble acosl(ldouble);
+
+double atan(double);
+float atanf(float);
+ldouble atanl(ldouble);
+
+double atan2(double, double);
+float atan2f(float, float);
+ldouble atan2l(ldouble, ldouble);
+
+double sinh(double);
+float sinhf(float);
+ldouble sinhl(ldouble);
+
+double cosh(double);
+float coshf(float);
+ldouble coshl(ldouble);
+
+double tanh(double);
+float tanhf(float);
+ldouble tanhl(ldouble);
+
+double asinh(double);
+float asinhf(float);
+ldouble asinhl(ldouble);
+
+double acosh(double);
+float acoshf(float);
+ldouble acoshl(ldouble);
+
+double atanh(double);
+float atanhf(float);
+ldouble atanhl(ldouble);
+
+double_complex csin(double_complex);
+float_complex csinf(float_complex);
+ldouble_complex csinl(ldouble_complex);
+
+double_complex ccos(double_complex);
+float_complex ccosf(float_complex);
+ldouble_complex ccosl(ldouble_complex);
+
+double_complex ctan(double_complex);
+float_complex ctanf(float_complex);
+ldouble_complex ctanl(ldouble_complex);
+
+double_complex casin(double_complex);
+float_complex casinf(float_complex);
+ldouble_complex casinl(ldouble_complex);
+
+double_complex cacos(double_complex);
+float_complex cacosf(float_complex);
+ldouble_complex cacosl(ldouble_complex);
+
+double_complex catan(double_complex);
+float_complex catanf(float_complex);
+ldouble_complex catanl(ldouble_complex);
+
+double_complex csinh(double_complex);
+float_complex csinhf(float_complex);
+ldouble_complex csinhl(ldouble_complex);
+
+double_complex ccosh(double_complex);
+float_complex ccoshf(float_complex);
+ldouble_complex ccoshl(ldouble_complex);
+
+double_complex ctanh(double_complex);
+float_complex ctanhf(float_complex);
+ldouble_complex ctanhl(ldouble_complex);
+
+double_complex casinh(double_complex);
+float_complex casinhf(float_complex);
+ldouble_complex casinhl(ldouble_complex);
+
+double_complex cacosh(double_complex);
+float_complex cacoshf(float_complex);
+ldouble_complex cacoshl(ldouble_complex);
+
+double_complex catanh(double_complex);
+float_complex catanhf(float_complex);
+ldouble_complex catanhl(ldouble_complex);
+
+double creal(double_complex);
+float crealf(float_complex);
+ldouble creall(ldouble_complex);
+
+double cimag(double_complex);
+float cimagf(float_complex);
+ldouble cimagl(ldouble_complex);
+
+double round(double);
+float roundf(float);
+ldouble roundl(ldouble);
+
+long lround(double);
+long lroundf(float);
+long lroundl(ldouble);
+
+llong llround(double);
+llong llroundf(float);
+llong llroundl(ldouble);
+
+double trunc(double);
+float truncf(float);
+ldouble truncl(ldouble);
+
+double floor(double);
+float floorf(float);
+ldouble floorl(ldouble);
+
+double ceil(double);
+float ceilf(float);
+ldouble ceill(ldouble);
+
+double pow(double, double);
+float powf(float, float);
+ldouble powl(ldouble, ldouble);
+
+double_complex cpow(double_complex, double_complex);
+float_complex cpowf(float_complex, float_complex);
+ldouble_complex cpowl(ldouble_complex, ldouble_complex);
+
+double pow10(double);
+float pow10f(float);
+ldouble pow10l(ldouble);
+
+double sqrt(double);
+float sqrtf(float);
+ldouble sqrtl(ldouble);
+
+double_complex csqrt(double_complex);
+float_complex csqrtf(float_complex);
+ldouble_complex csqrtl(ldouble_complex);
+
+double cbrt(double);
+float cbrtf(float);
+ldouble cbrtl(ldouble);
+
+double log(double);
+float logf(float);
+ldouble logl(ldouble);
+
+double log10(double);
+float log10f(float);
+ldouble log10l(ldouble);
+
+double log2(double);
+float log2f(float);
+ldouble log2l(ldouble);
+
+double logb(double);
+float logbf(float);
+ldouble logbl(ldouble);
+
+int ilogb(double);
+int ilogbf(float);
+int ilogbl(ldouble);
+
+double log1p(double);
+float log1pf(float);
+ldouble log1pl(ldouble);
+
+double_complex clog(double_complex);
+float_complex clogf(float_complex);
+ldouble_complex clogl(ldouble_complex);
+
+double_complex clog10(double_complex);
+float_complex clog10f(float_complex);
+ldouble_complex clog10l(ldouble_complex);
+
+double gamma(double);
+float gammaf(float);
+ldouble gammal(ldouble);
+
+double lgamma(double);
+float lgammaf(float);
+ldouble lgammal(ldouble);
+
+double lgamma_r(double, +int*);
+float lgammaf_r(float, +int*);
+ldouble lgammal_r(ldouble, +int*);
+
+double tgamma(double);
+float tgammaf(float);
+ldouble tgammal(ldouble);
+
+double j0(double);
+float j0f(float);
+ldouble j0l(ldouble);
+
+double j1(double);
+float j1f(float);
+ldouble j1l(ldouble);
+
+double jn(int, double);
+float jnf(int, float);
+ldouble jnl(int, ldouble);
+
+double y0(double);
+float y0f(float);
+ldouble y0l(ldouble);
+
+double y1(double);
+float y1f(float);
+ldouble y1l(ldouble);
+
+double yn(int, double);
+float ynf(int, float);
+ldouble ynl(int, ldouble);
+
+double fdim(double, double);
+float fdimf(float, float);
+ldouble fdiml(ldouble, ldouble);
+
+double remainder(double, double);
+float remainderf(float, float);
+ldouble remainderl(ldouble, ldouble);
+
+double drem(double, double);
+float dremf(float, float);
+ldouble dreml(ldouble, ldouble);
+
+double nearbyint(double);
+float nearbyintf(float);
+ldouble nearbyintl(ldouble);
+
+double rint(double);
+float rintf(float);
+ldouble rintl(ldouble);
+
+long lrint(double);
+long lrintf(float);
+long lrintl(ldouble);
+
+llong llrint(double);
+llong llrintf(float);
+llong llrintl(ldouble);
+
+double exp(double);
+float expf(float);
+ldouble expl(ldouble);
+
+double exp10(double);
+float exp10f(float);
+ldouble exp10l(ldouble);
+
+double exp2(double);
+float exp2f(float);
+ldouble exp2l(ldouble);
+
+double expm1(double);
+float expm1f(float);
+ldouble expm1l(ldouble);
+
+double frexp(double, +int *);
+float frexpf(float, +int *);
+ldouble frexpl(ldouble, +int *);
+
+double ldexp(double, int);
+float ldexpf(float, int);
+ldouble ldexpl(ldouble, int);
+
+double_complex cexp(double_complex);
+float_complex cexpf(float_complex);
+ldouble_complex cexpl(ldouble_complex);
+
+double significand(double);
+float significandf(float);
+ldouble significandl(ldouble);
+
+int finite(double);
+int finitef(float);
+int finitel(ldouble);
+
+int isinf(double);
+int isinff(float);
+int isinfl(ldouble);
+
+int isnan(double);
+int isnanf(float);
+int isnanl(ldouble);
+
+double nan(string);
+float nanf(string);
+ldouble nanl(string);
+
+double fabs(double);
+float fabsf(float);
+ldouble fabsl(ldouble);
+
+double cabs(double_complex);
+float cabsf(float_complex);
+ldouble cabsl(ldouble_complex);
+
+double modf(double, +double *);
+float modff(float, +float *);
+ldouble modfl(ldouble, +ldouble *);
+
+double fmod(double, double);
+float fmodf(float, float);
+ldouble fmodl(ldouble, ldouble);
+
+double remquo(double, double, +int *);
+float remquof(float, float, +int *);
+ldouble remquol(ldouble, ldouble, +int *);
+
+double erf(double);
+float erff(float);
+ldouble erfl(ldouble);
+
+double erfc(double);
+float erfcf(float);
+ldouble erfcl(ldouble);
+
+double fmax(double, double);
+float fmaxf(float, float);
+ldouble fmaxl(ldouble, ldouble);
+
+double fmin(double, double);
+float fminf(float, float);
+ldouble fminl(ldouble, ldouble);
+
+double carg(double_complex);
+float cargf(float_complex);
+ldouble cargl(ldouble_complex);
+
+double hypot(double, double);
+float hypotf(float, float);
+ldouble hypotl(ldouble, ldouble);
+
+double scalb(double, double);
+float scalbf(float, double);
+ldouble scalbl(ldouble, double);
+
+double scalbn(double, int);
+float scalbnf(float, int);
+ldouble scalbnl(ldouble, int);
+
+double scalbln(double, long);
+float scalblnf(float, long);
+ldouble scalblnl(ldouble, long);
+
+double fma(double, double, double);
+float fmaf(float, float, float);
+ldouble fmal(ldouble, ldouble, ldouble);
+
+double_complex cproj(double_complex);
+float_complex cprojf(float_complex);
+ldouble_complex cprojl(ldouble_complex);
+
+double copysign(double, double);
+float copysignf(float, float);
+ldouble copysignl(ldouble, ldouble);
+
+double nextafter(double, double);
+float nextafterf(float, float);
+ldouble nextafterl(ldouble, ldouble);
+
+double nexttoward(double, ldouble);
+float nexttowardf(float, ldouble);
+ldouble nexttowardl(ldouble, ldouble);
+
+double_complex conj(double_complex);
+float_complex conjf(float_complex);
+ldouble_complex conjl(ldouble_complex);
+
+;    15: 000000000003c000     15 FUNC    GLOBAL DEFAULT       13 __finitel@@GLIBC_2.2.5
+;    44: 0000000000027be0    286 FUNC    GLOBAL DEFAULT       13 __clog10@@GLIBC_2.2.5
+;    50: 00000000000068d0     85 FUNC    GLOBAL DEFAULT       13 feholdexcept@@GLIBC_2.2.5
+;    56: 0000000000028900     10 FUNC    GLOBAL DEFAULT       13 __signbit@@GLIBC_2.2.5
+;    61: 0000000000006ae0     53 FUNC    GLOBAL DEFAULT       13 feenableexcept@@GLIBC_2.2.5
+;    65: 0000000000006760     29 FUNC    GLOBAL DEFAULT       13 fegetexceptflag@@GLIBC_2.2.5
+;    68: 0000000000006a60     52 FUNC    GLOBAL DEFAULT       13 feupdateenv@@GLIBC_2.2.5
+;    75: 0000000000006840     25 FUNC    GLOBAL DEFAULT       13 fetestexcept@@GLIBC_2.2.5
+;    89: 0000000000025500     80 FUNC    GLOBAL DEFAULT       13 __fpclassify@@GLIBC_2.2.5
+;    99: 0000000000033370    310 FUNC    GLOBAL DEFAULT       13 __clog10f@@GLIBC_2.2.5
+;   104: 000000000003b600    307 FUNC    GLOBAL DEFAULT       13 __clog10l@@GLIBC_2.2.5
+;   127: 0000000000028560     29 FUNC    GLOBAL DEFAULT       13 __finite@@GLIBC_2.2.5
+;   134: 0000000000006870     66 FUNC    GLOBAL DEFAULT       13 fesetround@@GLIBC_2.2.5
+;   136: 0000000000006780     99 FUNC    GLOBAL DEFAULT       13 feraiseexcept@@GLIBC_2.2.5
+;   146: 0000000000006aa0     49 FUNC    GLOBAL DEFAULT       13 fedisableexcept@@GLIBC_2.2.5
+;   155: 0000000000006730     40 FUNC    GLOBAL DEFAULT       13 feclearexcept@@GLIBC_2.2.5
+;   175: 0000000000006860     14 FUNC    GLOBAL DEFAULT       13 fegetround@@GLIBC_2.2.5
+;   199: 0000000000006b20     16 FUNC    GLOBAL DEFAULT       13 fegetexcept@@GLIBC_2.2.5
+;   213: 00000000000067f0     71 FUNC    GLOBAL DEFAULT       13 fesetexceptflag@@GLIBC_2.2.5
+;   229: 00000000000068c0      9 FUNC    GLOBAL DEFAULT       13 fegetenv@@GLIBC_2.2.5
+;   249: 0000000000006930    303 FUNC    GLOBAL DEFAULT       13 fesetenv@@GLIBC_2.2.5
+;   256: 00000000000308c0     56 FUNC    GLOBAL DEFAULT       13 __fpclassifyf@@GLIBC_2.2.5
+;   261: 0000000000039020     94 FUNC    GLOBAL DEFAULT       13 __fpclassifyl@@GLIBC_2.2.5
+;   263: 0000000000033a80      8 FUNC    GLOBAL DEFAULT       13 __signbitf@@GLIBC_2.2.5
+;   267: 000000000003c2f0     29 FUNC    GLOBAL DEFAULT       13 __signbitl@@GLIBC_2.2.5
+;   318: 0000000000006720      3 FUNC    WEAK   DEFAULT       13 matherr@@GLIBC_2.2.5
+;   328: 00000000000337f0     18 FUNC    GLOBAL DEFAULT       13 __finitef@@GLIBC_2.2.5