| This is |
| /tmp/dgboter/bbs/rhev-vm2--rhe6x86_64/buildbot/rhe6x86_64--aarch64-none-linux-gnu/build/build-aarch64-none-linux-gnu/obj/glibc/manual/libc.info, |
| produced by makeinfo version 4.13 from libc.texinfo. |
| |
| INFO-DIR-SECTION Software libraries |
| START-INFO-DIR-ENTRY |
| * Libc: (libc). C library. |
| END-INFO-DIR-ENTRY |
| |
| INFO-DIR-SECTION GNU C library functions and macros |
| START-INFO-DIR-ENTRY |
| * ALTWERASE: (libc)Local Modes. |
| * ARGP_ERR_UNKNOWN: (libc)Argp Parser Functions. |
| * ARG_MAX: (libc)General Limits. |
| * BC_BASE_MAX: (libc)Utility Limits. |
| * BC_DIM_MAX: (libc)Utility Limits. |
| * BC_SCALE_MAX: (libc)Utility Limits. |
| * BC_STRING_MAX: (libc)Utility Limits. |
| * BRKINT: (libc)Input Modes. |
| * BUFSIZ: (libc)Controlling Buffering. |
| * CCTS_OFLOW: (libc)Control Modes. |
| * CHAR_BIT: (libc)Width of Type. |
| * CHILD_MAX: (libc)General Limits. |
| * CIGNORE: (libc)Control Modes. |
| * CLK_TCK: (libc)Processor Time. |
| * CLOCAL: (libc)Control Modes. |
| * CLOCKS_PER_SEC: (libc)CPU Time. |
| * COLL_WEIGHTS_MAX: (libc)Utility Limits. |
| * CPU_CLR: (libc)CPU Affinity. |
| * CPU_ISSET: (libc)CPU Affinity. |
| * CPU_SET: (libc)CPU Affinity. |
| * CPU_SETSIZE: (libc)CPU Affinity. |
| * CPU_ZERO: (libc)CPU Affinity. |
| * CREAD: (libc)Control Modes. |
| * CRTS_IFLOW: (libc)Control Modes. |
| * CS5: (libc)Control Modes. |
| * CS6: (libc)Control Modes. |
| * CS7: (libc)Control Modes. |
| * CS8: (libc)Control Modes. |
| * CSIZE: (libc)Control Modes. |
| * CSTOPB: (libc)Control Modes. |
| * DTTOIF: (libc)Directory Entries. |
| * E2BIG: (libc)Error Codes. |
| * EACCES: (libc)Error Codes. |
| * EADDRINUSE: (libc)Error Codes. |
| * EADDRNOTAVAIL: (libc)Error Codes. |
| * EADV: (libc)Error Codes. |
| * EAFNOSUPPORT: (libc)Error Codes. |
| * EAGAIN: (libc)Error Codes. |
| * EALREADY: (libc)Error Codes. |
| * EAUTH: (libc)Error Codes. |
| * EBACKGROUND: (libc)Error Codes. |
| * EBADE: (libc)Error Codes. |
| * EBADF: (libc)Error Codes. |
| * EBADFD: (libc)Error Codes. |
| * EBADMSG: (libc)Error Codes. |
| * EBADR: (libc)Error Codes. |
| * EBADRPC: (libc)Error Codes. |
| * EBADRQC: (libc)Error Codes. |
| * EBADSLT: (libc)Error Codes. |
| * EBFONT: (libc)Error Codes. |
| * EBUSY: (libc)Error Codes. |
| * ECANCELED: (libc)Error Codes. |
| * ECHILD: (libc)Error Codes. |
| * ECHO: (libc)Local Modes. |
| * ECHOCTL: (libc)Local Modes. |
| * ECHOE: (libc)Local Modes. |
| * ECHOK: (libc)Local Modes. |
| * ECHOKE: (libc)Local Modes. |
| * ECHONL: (libc)Local Modes. |
| * ECHOPRT: (libc)Local Modes. |
| * ECHRNG: (libc)Error Codes. |
| * ECOMM: (libc)Error Codes. |
| * ECONNABORTED: (libc)Error Codes. |
| * ECONNREFUSED: (libc)Error Codes. |
| * ECONNRESET: (libc)Error Codes. |
| * ED: (libc)Error Codes. |
| * EDEADLK: (libc)Error Codes. |
| * EDEADLOCK: (libc)Error Codes. |
| * EDESTADDRREQ: (libc)Error Codes. |
| * EDIED: (libc)Error Codes. |
| * EDOM: (libc)Error Codes. |
| * EDOTDOT: (libc)Error Codes. |
| * EDQUOT: (libc)Error Codes. |
| * EEXIST: (libc)Error Codes. |
| * EFAULT: (libc)Error Codes. |
| * EFBIG: (libc)Error Codes. |
| * EFTYPE: (libc)Error Codes. |
| * EGRATUITOUS: (libc)Error Codes. |
| * EGREGIOUS: (libc)Error Codes. |
| * EHOSTDOWN: (libc)Error Codes. |
| * EHOSTUNREACH: (libc)Error Codes. |
| * EHWPOISON: (libc)Error Codes. |
| * EIDRM: (libc)Error Codes. |
| * EIEIO: (libc)Error Codes. |
| * EILSEQ: (libc)Error Codes. |
| * EINPROGRESS: (libc)Error Codes. |
| * EINTR: (libc)Error Codes. |
| * EINVAL: (libc)Error Codes. |
| * EIO: (libc)Error Codes. |
| * EISCONN: (libc)Error Codes. |
| * EISDIR: (libc)Error Codes. |
| * EISNAM: (libc)Error Codes. |
| * EKEYEXPIRED: (libc)Error Codes. |
| * EKEYREJECTED: (libc)Error Codes. |
| * EKEYREVOKED: (libc)Error Codes. |
| * EL2HLT: (libc)Error Codes. |
| * EL2NSYNC: (libc)Error Codes. |
| * EL3HLT: (libc)Error Codes. |
| * EL3RST: (libc)Error Codes. |
| * ELIBACC: (libc)Error Codes. |
| * ELIBBAD: (libc)Error Codes. |
| * ELIBEXEC: (libc)Error Codes. |
| * ELIBMAX: (libc)Error Codes. |
| * ELIBSCN: (libc)Error Codes. |
| * ELNRNG: (libc)Error Codes. |
| * ELOOP: (libc)Error Codes. |
| * EMEDIUMTYPE: (libc)Error Codes. |
| * EMFILE: (libc)Error Codes. |
| * EMLINK: (libc)Error Codes. |
| * EMSGSIZE: (libc)Error Codes. |
| * EMULTIHOP: (libc)Error Codes. |
| * ENAMETOOLONG: (libc)Error Codes. |
| * ENAVAIL: (libc)Error Codes. |
| * ENEEDAUTH: (libc)Error Codes. |
| * ENETDOWN: (libc)Error Codes. |
| * ENETRESET: (libc)Error Codes. |
| * ENETUNREACH: (libc)Error Codes. |
| * ENFILE: (libc)Error Codes. |
| * ENOANO: (libc)Error Codes. |
| * ENOBUFS: (libc)Error Codes. |
| * ENOCSI: (libc)Error Codes. |
| * ENODATA: (libc)Error Codes. |
| * ENODEV: (libc)Error Codes. |
| * ENOENT: (libc)Error Codes. |
| * ENOEXEC: (libc)Error Codes. |
| * ENOKEY: (libc)Error Codes. |
| * ENOLCK: (libc)Error Codes. |
| * ENOLINK: (libc)Error Codes. |
| * ENOMEDIUM: (libc)Error Codes. |
| * ENOMEM: (libc)Error Codes. |
| * ENOMSG: (libc)Error Codes. |
| * ENONET: (libc)Error Codes. |
| * ENOPKG: (libc)Error Codes. |
| * ENOPROTOOPT: (libc)Error Codes. |
| * ENOSPC: (libc)Error Codes. |
| * ENOSR: (libc)Error Codes. |
| * ENOSTR: (libc)Error Codes. |
| * ENOSYS: (libc)Error Codes. |
| * ENOTBLK: (libc)Error Codes. |
| * ENOTCONN: (libc)Error Codes. |
| * ENOTDIR: (libc)Error Codes. |
| * ENOTEMPTY: (libc)Error Codes. |
| * ENOTNAM: (libc)Error Codes. |
| * ENOTRECOVERABLE: (libc)Error Codes. |
| * ENOTSOCK: (libc)Error Codes. |
| * ENOTSUP: (libc)Error Codes. |
| * ENOTTY: (libc)Error Codes. |
| * ENOTUNIQ: (libc)Error Codes. |
| * ENXIO: (libc)Error Codes. |
| * EOF: (libc)EOF and Errors. |
| * EOPNOTSUPP: (libc)Error Codes. |
| * EOVERFLOW: (libc)Error Codes. |
| * EOWNERDEAD: (libc)Error Codes. |
| * EPERM: (libc)Error Codes. |
| * EPFNOSUPPORT: (libc)Error Codes. |
| * EPIPE: (libc)Error Codes. |
| * EPROCLIM: (libc)Error Codes. |
| * EPROCUNAVAIL: (libc)Error Codes. |
| * EPROGMISMATCH: (libc)Error Codes. |
| * EPROGUNAVAIL: (libc)Error Codes. |
| * EPROTO: (libc)Error Codes. |
| * EPROTONOSUPPORT: (libc)Error Codes. |
| * EPROTOTYPE: (libc)Error Codes. |
| * EQUIV_CLASS_MAX: (libc)Utility Limits. |
| * ERANGE: (libc)Error Codes. |
| * EREMCHG: (libc)Error Codes. |
| * EREMOTE: (libc)Error Codes. |
| * EREMOTEIO: (libc)Error Codes. |
| * ERESTART: (libc)Error Codes. |
| * ERFKILL: (libc)Error Codes. |
| * EROFS: (libc)Error Codes. |
| * ERPCMISMATCH: (libc)Error Codes. |
| * ESHUTDOWN: (libc)Error Codes. |
| * ESOCKTNOSUPPORT: (libc)Error Codes. |
| * ESPIPE: (libc)Error Codes. |
| * ESRCH: (libc)Error Codes. |
| * ESRMNT: (libc)Error Codes. |
| * ESTALE: (libc)Error Codes. |
| * ESTRPIPE: (libc)Error Codes. |
| * ETIME: (libc)Error Codes. |
| * ETIMEDOUT: (libc)Error Codes. |
| * ETOOMANYREFS: (libc)Error Codes. |
| * ETXTBSY: (libc)Error Codes. |
| * EUCLEAN: (libc)Error Codes. |
| * EUNATCH: (libc)Error Codes. |
| * EUSERS: (libc)Error Codes. |
| * EWOULDBLOCK: (libc)Error Codes. |
| * EXDEV: (libc)Error Codes. |
| * EXFULL: (libc)Error Codes. |
| * EXIT_FAILURE: (libc)Exit Status. |
| * EXIT_SUCCESS: (libc)Exit Status. |
| * EXPR_NEST_MAX: (libc)Utility Limits. |
| * FD_CLOEXEC: (libc)Descriptor Flags. |
| * FD_CLR: (libc)Waiting for I/O. |
| * FD_ISSET: (libc)Waiting for I/O. |
| * FD_SET: (libc)Waiting for I/O. |
| * FD_SETSIZE: (libc)Waiting for I/O. |
| * FD_ZERO: (libc)Waiting for I/O. |
| * FE_SNANS_ALWAYS_SIGNAL: (libc)Infinity and NaN. |
| * FILENAME_MAX: (libc)Limits for Files. |
| * FLUSHO: (libc)Local Modes. |
| * FOPEN_MAX: (libc)Opening Streams. |
| * FP_ILOGB0: (libc)Exponents and Logarithms. |
| * FP_ILOGBNAN: (libc)Exponents and Logarithms. |
| * FP_LLOGB0: (libc)Exponents and Logarithms. |
| * FP_LLOGBNAN: (libc)Exponents and Logarithms. |
| * F_DUPFD: (libc)Duplicating Descriptors. |
| * F_GETFD: (libc)Descriptor Flags. |
| * F_GETFL: (libc)Getting File Status Flags. |
| * F_GETLK: (libc)File Locks. |
| * F_GETOWN: (libc)Interrupt Input. |
| * F_OFD_GETLK: (libc)Open File Description Locks. |
| * F_OFD_SETLK: (libc)Open File Description Locks. |
| * F_OFD_SETLKW: (libc)Open File Description Locks. |
| * F_OK: (libc)Testing File Access. |
| * F_SETFD: (libc)Descriptor Flags. |
| * F_SETFL: (libc)Getting File Status Flags. |
| * F_SETLK: (libc)File Locks. |
| * F_SETLKW: (libc)File Locks. |
| * F_SETOWN: (libc)Interrupt Input. |
| * HUGE_VAL: (libc)Math Error Reporting. |
| * HUGE_VALF: (libc)Math Error Reporting. |
| * HUGE_VALL: (libc)Math Error Reporting. |
| * HUGE_VAL_FN: (libc)Math Error Reporting. |
| * HUGE_VAL_FNx: (libc)Math Error Reporting. |
| * HUPCL: (libc)Control Modes. |
| * I: (libc)Complex Numbers. |
| * ICANON: (libc)Local Modes. |
| * ICRNL: (libc)Input Modes. |
| * IEXTEN: (libc)Local Modes. |
| * IFNAMSIZ: (libc)Interface Naming. |
| * IFTODT: (libc)Directory Entries. |
| * IGNBRK: (libc)Input Modes. |
| * IGNCR: (libc)Input Modes. |
| * IGNPAR: (libc)Input Modes. |
| * IMAXBEL: (libc)Input Modes. |
| * INADDR_ANY: (libc)Host Address Data Type. |
| * INADDR_BROADCAST: (libc)Host Address Data Type. |
| * INADDR_LOOPBACK: (libc)Host Address Data Type. |
| * INADDR_NONE: (libc)Host Address Data Type. |
| * INFINITY: (libc)Infinity and NaN. |
| * INLCR: (libc)Input Modes. |
| * INPCK: (libc)Input Modes. |
| * IPPORT_RESERVED: (libc)Ports. |
| * IPPORT_USERRESERVED: (libc)Ports. |
| * ISIG: (libc)Local Modes. |
| * ISTRIP: (libc)Input Modes. |
| * IXANY: (libc)Input Modes. |
| * IXOFF: (libc)Input Modes. |
| * IXON: (libc)Input Modes. |
| * LINE_MAX: (libc)Utility Limits. |
| * LINK_MAX: (libc)Limits for Files. |
| * L_ctermid: (libc)Identifying the Terminal. |
| * L_cuserid: (libc)Who Logged In. |
| * L_tmpnam: (libc)Temporary Files. |
| * MAXNAMLEN: (libc)Limits for Files. |
| * MAXSYMLINKS: (libc)Symbolic Links. |
| * MAX_CANON: (libc)Limits for Files. |
| * MAX_INPUT: (libc)Limits for Files. |
| * MB_CUR_MAX: (libc)Selecting the Conversion. |
| * MB_LEN_MAX: (libc)Selecting the Conversion. |
| * MDMBUF: (libc)Control Modes. |
| * MSG_DONTROUTE: (libc)Socket Data Options. |
| * MSG_OOB: (libc)Socket Data Options. |
| * MSG_PEEK: (libc)Socket Data Options. |
| * NAME_MAX: (libc)Limits for Files. |
| * NAN: (libc)Infinity and NaN. |
| * NCCS: (libc)Mode Data Types. |
| * NGROUPS_MAX: (libc)General Limits. |
| * NOFLSH: (libc)Local Modes. |
| * NOKERNINFO: (libc)Local Modes. |
| * NSIG: (libc)Standard Signals. |
| * NULL: (libc)Null Pointer Constant. |
| * ONLCR: (libc)Output Modes. |
| * ONOEOT: (libc)Output Modes. |
| * OPEN_MAX: (libc)General Limits. |
| * OPOST: (libc)Output Modes. |
| * OXTABS: (libc)Output Modes. |
| * O_ACCMODE: (libc)Access Modes. |
| * O_APPEND: (libc)Operating Modes. |
| * O_ASYNC: (libc)Operating Modes. |
| * O_CREAT: (libc)Open-time Flags. |
| * O_DIRECTORY: (libc)Open-time Flags. |
| * O_EXCL: (libc)Open-time Flags. |
| * O_EXEC: (libc)Access Modes. |
| * O_EXLOCK: (libc)Open-time Flags. |
| * O_FSYNC: (libc)Operating Modes. |
| * O_IGNORE_CTTY: (libc)Open-time Flags. |
| * O_NDELAY: (libc)Operating Modes. |
| * O_NOATIME: (libc)Operating Modes. |
| * O_NOCTTY: (libc)Open-time Flags. |
| * O_NOLINK: (libc)Open-time Flags. |
| * O_NONBLOCK: (libc)Open-time Flags. |
| * O_NONBLOCK: (libc)Operating Modes. |
| * O_NOTRANS: (libc)Open-time Flags. |
| * O_RDONLY: (libc)Access Modes. |
| * O_RDWR: (libc)Access Modes. |
| * O_READ: (libc)Access Modes. |
| * O_SHLOCK: (libc)Open-time Flags. |
| * O_SYNC: (libc)Operating Modes. |
| * O_TMPFILE: (libc)Open-time Flags. |
| * O_TRUNC: (libc)Open-time Flags. |
| * O_WRITE: (libc)Access Modes. |
| * O_WRONLY: (libc)Access Modes. |
| * PARENB: (libc)Control Modes. |
| * PARMRK: (libc)Input Modes. |
| * PARODD: (libc)Control Modes. |
| * PATH_MAX: (libc)Limits for Files. |
| * PA_FLAG_MASK: (libc)Parsing a Template String. |
| * PENDIN: (libc)Local Modes. |
| * PF_FILE: (libc)Local Namespace Details. |
| * PF_INET6: (libc)Internet Namespace. |
| * PF_INET: (libc)Internet Namespace. |
| * PF_LOCAL: (libc)Local Namespace Details. |
| * PF_UNIX: (libc)Local Namespace Details. |
| * PIPE_BUF: (libc)Limits for Files. |
| * P_tmpdir: (libc)Temporary Files. |
| * RAND_MAX: (libc)ISO Random. |
| * RE_DUP_MAX: (libc)General Limits. |
| * RLIM_INFINITY: (libc)Limits on Resources. |
| * R_OK: (libc)Testing File Access. |
| * SA_NOCLDSTOP: (libc)Flags for Sigaction. |
| * SA_ONSTACK: (libc)Flags for Sigaction. |
| * SA_RESTART: (libc)Flags for Sigaction. |
| * SEEK_CUR: (libc)File Positioning. |
| * SEEK_END: (libc)File Positioning. |
| * SEEK_SET: (libc)File Positioning. |
| * SIGABRT: (libc)Program Error Signals. |
| * SIGALRM: (libc)Alarm Signals. |
| * SIGBUS: (libc)Program Error Signals. |
| * SIGCHLD: (libc)Job Control Signals. |
| * SIGCLD: (libc)Job Control Signals. |
| * SIGCONT: (libc)Job Control Signals. |
| * SIGEMT: (libc)Program Error Signals. |
| * SIGFPE: (libc)Program Error Signals. |
| * SIGHUP: (libc)Termination Signals. |
| * SIGILL: (libc)Program Error Signals. |
| * SIGINFO: (libc)Miscellaneous Signals. |
| * SIGINT: (libc)Termination Signals. |
| * SIGIO: (libc)Asynchronous I/O Signals. |
| * SIGIOT: (libc)Program Error Signals. |
| * SIGKILL: (libc)Termination Signals. |
| * SIGLOST: (libc)Operation Error Signals. |
| * SIGPIPE: (libc)Operation Error Signals. |
| * SIGPOLL: (libc)Asynchronous I/O Signals. |
| * SIGPROF: (libc)Alarm Signals. |
| * SIGQUIT: (libc)Termination Signals. |
| * SIGSEGV: (libc)Program Error Signals. |
| * SIGSTOP: (libc)Job Control Signals. |
| * SIGSYS: (libc)Program Error Signals. |
| * SIGTERM: (libc)Termination Signals. |
| * SIGTRAP: (libc)Program Error Signals. |
| * SIGTSTP: (libc)Job Control Signals. |
| * SIGTTIN: (libc)Job Control Signals. |
| * SIGTTOU: (libc)Job Control Signals. |
| * SIGURG: (libc)Asynchronous I/O Signals. |
| * SIGUSR1: (libc)Miscellaneous Signals. |
| * SIGUSR2: (libc)Miscellaneous Signals. |
| * SIGVTALRM: (libc)Alarm Signals. |
| * SIGWINCH: (libc)Miscellaneous Signals. |
| * SIGXCPU: (libc)Operation Error Signals. |
| * SIGXFSZ: (libc)Operation Error Signals. |
| * SIG_ERR: (libc)Basic Signal Handling. |
| * SNAN: (libc)Infinity and NaN. |
| * SNANF: (libc)Infinity and NaN. |
| * SNANFN: (libc)Infinity and NaN. |
| * SNANFNx: (libc)Infinity and NaN. |
| * SNANL: (libc)Infinity and NaN. |
| * SOCK_DGRAM: (libc)Communication Styles. |
| * SOCK_RAW: (libc)Communication Styles. |
| * SOCK_RDM: (libc)Communication Styles. |
| * SOCK_SEQPACKET: (libc)Communication Styles. |
| * SOCK_STREAM: (libc)Communication Styles. |
| * SOL_SOCKET: (libc)Socket-Level Options. |
| * SSIZE_MAX: (libc)General Limits. |
| * STREAM_MAX: (libc)General Limits. |
| * SUN_LEN: (libc)Local Namespace Details. |
| * S_IFMT: (libc)Testing File Type. |
| * S_ISBLK: (libc)Testing File Type. |
| * S_ISCHR: (libc)Testing File Type. |
| * S_ISDIR: (libc)Testing File Type. |
| * S_ISFIFO: (libc)Testing File Type. |
| * S_ISLNK: (libc)Testing File Type. |
| * S_ISREG: (libc)Testing File Type. |
| * S_ISSOCK: (libc)Testing File Type. |
| * S_TYPEISMQ: (libc)Testing File Type. |
| * S_TYPEISSEM: (libc)Testing File Type. |
| * S_TYPEISSHM: (libc)Testing File Type. |
| * TMP_MAX: (libc)Temporary Files. |
| * TOSTOP: (libc)Local Modes. |
| * TZNAME_MAX: (libc)General Limits. |
| * VDISCARD: (libc)Other Special. |
| * VDSUSP: (libc)Signal Characters. |
| * VEOF: (libc)Editing Characters. |
| * VEOL2: (libc)Editing Characters. |
| * VEOL: (libc)Editing Characters. |
| * VERASE: (libc)Editing Characters. |
| * VINTR: (libc)Signal Characters. |
| * VKILL: (libc)Editing Characters. |
| * VLNEXT: (libc)Other Special. |
| * VMIN: (libc)Noncanonical Input. |
| * VQUIT: (libc)Signal Characters. |
| * VREPRINT: (libc)Editing Characters. |
| * VSTART: (libc)Start/Stop Characters. |
| * VSTATUS: (libc)Other Special. |
| * VSTOP: (libc)Start/Stop Characters. |
| * VSUSP: (libc)Signal Characters. |
| * VTIME: (libc)Noncanonical Input. |
| * VWERASE: (libc)Editing Characters. |
| * WCHAR_MAX: (libc)Extended Char Intro. |
| * WCHAR_MIN: (libc)Extended Char Intro. |
| * WCOREDUMP: (libc)Process Completion Status. |
| * WEOF: (libc)EOF and Errors. |
| * WEOF: (libc)Extended Char Intro. |
| * WEXITSTATUS: (libc)Process Completion Status. |
| * WIFEXITED: (libc)Process Completion Status. |
| * WIFSIGNALED: (libc)Process Completion Status. |
| * WIFSTOPPED: (libc)Process Completion Status. |
| * WSTOPSIG: (libc)Process Completion Status. |
| * WTERMSIG: (libc)Process Completion Status. |
| * W_OK: (libc)Testing File Access. |
| * X_OK: (libc)Testing File Access. |
| * _Complex_I: (libc)Complex Numbers. |
| * _Exit: (libc)Termination Internals. |
| * _IOFBF: (libc)Controlling Buffering. |
| * _IOLBF: (libc)Controlling Buffering. |
| * _IONBF: (libc)Controlling Buffering. |
| * _Imaginary_I: (libc)Complex Numbers. |
| * _PATH_UTMP: (libc)Manipulating the Database. |
| * _PATH_WTMP: (libc)Manipulating the Database. |
| * _POSIX2_C_DEV: (libc)System Options. |
| * _POSIX2_C_VERSION: (libc)Version Supported. |
| * _POSIX2_FORT_DEV: (libc)System Options. |
| * _POSIX2_FORT_RUN: (libc)System Options. |
| * _POSIX2_LOCALEDEF: (libc)System Options. |
| * _POSIX2_SW_DEV: (libc)System Options. |
| * _POSIX_CHOWN_RESTRICTED: (libc)Options for Files. |
| * _POSIX_JOB_CONTROL: (libc)System Options. |
| * _POSIX_NO_TRUNC: (libc)Options for Files. |
| * _POSIX_SAVED_IDS: (libc)System Options. |
| * _POSIX_VDISABLE: (libc)Options for Files. |
| * _POSIX_VERSION: (libc)Version Supported. |
| * __fbufsize: (libc)Controlling Buffering. |
| * __flbf: (libc)Controlling Buffering. |
| * __fpending: (libc)Controlling Buffering. |
| * __fpurge: (libc)Flushing Buffers. |
| * __freadable: (libc)Opening Streams. |
| * __freading: (libc)Opening Streams. |
| * __fsetlocking: (libc)Streams and Threads. |
| * __fwritable: (libc)Opening Streams. |
| * __fwriting: (libc)Opening Streams. |
| * __gconv_end_fct: (libc)glibc iconv Implementation. |
| * __gconv_fct: (libc)glibc iconv Implementation. |
| * __gconv_init_fct: (libc)glibc iconv Implementation. |
| * __ppc_get_timebase: (libc)PowerPC. |
| * __ppc_get_timebase_freq: (libc)PowerPC. |
| * __ppc_mdoio: (libc)PowerPC. |
| * __ppc_mdoom: (libc)PowerPC. |
| * __ppc_set_ppr_low: (libc)PowerPC. |
| * __ppc_set_ppr_med: (libc)PowerPC. |
| * __ppc_set_ppr_med_high: (libc)PowerPC. |
| * __ppc_set_ppr_med_low: (libc)PowerPC. |
| * __ppc_set_ppr_very_low: (libc)PowerPC. |
| * __ppc_yield: (libc)PowerPC. |
| * __riscv_flush_icache: (libc)RISC-V. |
| * __va_copy: (libc)Argument Macros. |
| * _exit: (libc)Termination Internals. |
| * _flushlbf: (libc)Flushing Buffers. |
| * _tolower: (libc)Case Conversion. |
| * _toupper: (libc)Case Conversion. |
| * a64l: (libc)Encode Binary Data. |
| * abort: (libc)Aborting a Program. |
| * abs: (libc)Absolute Value. |
| * accept: (libc)Accepting Connections. |
| * access: (libc)Testing File Access. |
| * acos: (libc)Inverse Trig Functions. |
| * acosf: (libc)Inverse Trig Functions. |
| * acosfN: (libc)Inverse Trig Functions. |
| * acosfNx: (libc)Inverse Trig Functions. |
| * acosh: (libc)Hyperbolic Functions. |
| * acoshf: (libc)Hyperbolic Functions. |
| * acoshfN: (libc)Hyperbolic Functions. |
| * acoshfNx: (libc)Hyperbolic Functions. |
| * acoshl: (libc)Hyperbolic Functions. |
| * acosl: (libc)Inverse Trig Functions. |
| * addmntent: (libc)mtab. |
| * addseverity: (libc)Adding Severity Classes. |
| * adjtime: (libc)High-Resolution Calendar. |
| * adjtimex: (libc)High-Resolution Calendar. |
| * aio_cancel64: (libc)Cancel AIO Operations. |
| * aio_cancel: (libc)Cancel AIO Operations. |
| * aio_error64: (libc)Status of AIO Operations. |
| * aio_error: (libc)Status of AIO Operations. |
| * aio_fsync64: (libc)Synchronizing AIO Operations. |
| * aio_fsync: (libc)Synchronizing AIO Operations. |
| * aio_init: (libc)Configuration of AIO. |
| * aio_read64: (libc)Asynchronous Reads/Writes. |
| * aio_read: (libc)Asynchronous Reads/Writes. |
| * aio_return64: (libc)Status of AIO Operations. |
| * aio_return: (libc)Status of AIO Operations. |
| * aio_suspend64: (libc)Synchronizing AIO Operations. |
| * aio_suspend: (libc)Synchronizing AIO Operations. |
| * aio_write64: (libc)Asynchronous Reads/Writes. |
| * aio_write: (libc)Asynchronous Reads/Writes. |
| * alarm: (libc)Setting an Alarm. |
| * aligned_alloc: (libc)Aligned Memory Blocks. |
| * alloca: (libc)Variable Size Automatic. |
| * alphasort64: (libc)Scanning Directory Content. |
| * alphasort: (libc)Scanning Directory Content. |
| * argp_error: (libc)Argp Helper Functions. |
| * argp_failure: (libc)Argp Helper Functions. |
| * argp_help: (libc)Argp Help. |
| * argp_parse: (libc)Argp. |
| * argp_state_help: (libc)Argp Helper Functions. |
| * argp_usage: (libc)Argp Helper Functions. |
| * argz_add: (libc)Argz Functions. |
| * argz_add_sep: (libc)Argz Functions. |
| * argz_append: (libc)Argz Functions. |
| * argz_count: (libc)Argz Functions. |
| * argz_create: (libc)Argz Functions. |
| * argz_create_sep: (libc)Argz Functions. |
| * argz_delete: (libc)Argz Functions. |
| * argz_extract: (libc)Argz Functions. |
| * argz_insert: (libc)Argz Functions. |
| * argz_next: (libc)Argz Functions. |
| * argz_replace: (libc)Argz Functions. |
| * argz_stringify: (libc)Argz Functions. |
| * asctime: (libc)Formatting Calendar Time. |
| * asctime_r: (libc)Formatting Calendar Time. |
| * asin: (libc)Inverse Trig Functions. |
| * asinf: (libc)Inverse Trig Functions. |
| * asinfN: (libc)Inverse Trig Functions. |
| * asinfNx: (libc)Inverse Trig Functions. |
| * asinh: (libc)Hyperbolic Functions. |
| * asinhf: (libc)Hyperbolic Functions. |
| * asinhfN: (libc)Hyperbolic Functions. |
| * asinhfNx: (libc)Hyperbolic Functions. |
| * asinhl: (libc)Hyperbolic Functions. |
| * asinl: (libc)Inverse Trig Functions. |
| * asprintf: (libc)Dynamic Output. |
| * assert: (libc)Consistency Checking. |
| * assert_perror: (libc)Consistency Checking. |
| * atan2: (libc)Inverse Trig Functions. |
| * atan2f: (libc)Inverse Trig Functions. |
| * atan2fN: (libc)Inverse Trig Functions. |
| * atan2fNx: (libc)Inverse Trig Functions. |
| * atan2l: (libc)Inverse Trig Functions. |
| * atan: (libc)Inverse Trig Functions. |
| * atanf: (libc)Inverse Trig Functions. |
| * atanfN: (libc)Inverse Trig Functions. |
| * atanfNx: (libc)Inverse Trig Functions. |
| * atanh: (libc)Hyperbolic Functions. |
| * atanhf: (libc)Hyperbolic Functions. |
| * atanhfN: (libc)Hyperbolic Functions. |
| * atanhfNx: (libc)Hyperbolic Functions. |
| * atanhl: (libc)Hyperbolic Functions. |
| * atanl: (libc)Inverse Trig Functions. |
| * atexit: (libc)Cleanups on Exit. |
| * atof: (libc)Parsing of Floats. |
| * atoi: (libc)Parsing of Integers. |
| * atol: (libc)Parsing of Integers. |
| * atoll: (libc)Parsing of Integers. |
| * backtrace: (libc)Backtraces. |
| * backtrace_symbols: (libc)Backtraces. |
| * backtrace_symbols_fd: (libc)Backtraces. |
| * basename: (libc)Finding Tokens in a String. |
| * basename: (libc)Finding Tokens in a String. |
| * bcmp: (libc)String/Array Comparison. |
| * bcopy: (libc)Copying Strings and Arrays. |
| * bind: (libc)Setting Address. |
| * bind_textdomain_codeset: (libc)Charset conversion in gettext. |
| * bindtextdomain: (libc)Locating gettext catalog. |
| * brk: (libc)Resizing the Data Segment. |
| * bsearch: (libc)Array Search Function. |
| * btowc: (libc)Converting a Character. |
| * bzero: (libc)Copying Strings and Arrays. |
| * cabs: (libc)Absolute Value. |
| * cabsf: (libc)Absolute Value. |
| * cabsfN: (libc)Absolute Value. |
| * cabsfNx: (libc)Absolute Value. |
| * cabsl: (libc)Absolute Value. |
| * cacos: (libc)Inverse Trig Functions. |
| * cacosf: (libc)Inverse Trig Functions. |
| * cacosfN: (libc)Inverse Trig Functions. |
| * cacosfNx: (libc)Inverse Trig Functions. |
| * cacosh: (libc)Hyperbolic Functions. |
| * cacoshf: (libc)Hyperbolic Functions. |
| * cacoshfN: (libc)Hyperbolic Functions. |
| * cacoshfNx: (libc)Hyperbolic Functions. |
| * cacoshl: (libc)Hyperbolic Functions. |
| * cacosl: (libc)Inverse Trig Functions. |
| * call_once: (libc)Call Once. |
| * calloc: (libc)Allocating Cleared Space. |
| * canonicalize: (libc)FP Bit Twiddling. |
| * canonicalize_file_name: (libc)Symbolic Links. |
| * canonicalizef: (libc)FP Bit Twiddling. |
| * canonicalizefN: (libc)FP Bit Twiddling. |
| * canonicalizefNx: (libc)FP Bit Twiddling. |
| * canonicalizel: (libc)FP Bit Twiddling. |
| * carg: (libc)Operations on Complex. |
| * cargf: (libc)Operations on Complex. |
| * cargfN: (libc)Operations on Complex. |
| * cargfNx: (libc)Operations on Complex. |
| * cargl: (libc)Operations on Complex. |
| * casin: (libc)Inverse Trig Functions. |
| * casinf: (libc)Inverse Trig Functions. |
| * casinfN: (libc)Inverse Trig Functions. |
| * casinfNx: (libc)Inverse Trig Functions. |
| * casinh: (libc)Hyperbolic Functions. |
| * casinhf: (libc)Hyperbolic Functions. |
| * casinhfN: (libc)Hyperbolic Functions. |
| * casinhfNx: (libc)Hyperbolic Functions. |
| * casinhl: (libc)Hyperbolic Functions. |
| * casinl: (libc)Inverse Trig Functions. |
| * catan: (libc)Inverse Trig Functions. |
| * catanf: (libc)Inverse Trig Functions. |
| * catanfN: (libc)Inverse Trig Functions. |
| * catanfNx: (libc)Inverse Trig Functions. |
| * catanh: (libc)Hyperbolic Functions. |
| * catanhf: (libc)Hyperbolic Functions. |
| * catanhfN: (libc)Hyperbolic Functions. |
| * catanhfNx: (libc)Hyperbolic Functions. |
| * catanhl: (libc)Hyperbolic Functions. |
| * catanl: (libc)Inverse Trig Functions. |
| * catclose: (libc)The catgets Functions. |
| * catgets: (libc)The catgets Functions. |
| * catopen: (libc)The catgets Functions. |
| * cbrt: (libc)Exponents and Logarithms. |
| * cbrtf: (libc)Exponents and Logarithms. |
| * cbrtfN: (libc)Exponents and Logarithms. |
| * cbrtfNx: (libc)Exponents and Logarithms. |
| * cbrtl: (libc)Exponents and Logarithms. |
| * ccos: (libc)Trig Functions. |
| * ccosf: (libc)Trig Functions. |
| * ccosfN: (libc)Trig Functions. |
| * ccosfNx: (libc)Trig Functions. |
| * ccosh: (libc)Hyperbolic Functions. |
| * ccoshf: (libc)Hyperbolic Functions. |
| * ccoshfN: (libc)Hyperbolic Functions. |
| * ccoshfNx: (libc)Hyperbolic Functions. |
| * ccoshl: (libc)Hyperbolic Functions. |
| * ccosl: (libc)Trig Functions. |
| * ceil: (libc)Rounding Functions. |
| * ceilf: (libc)Rounding Functions. |
| * ceilfN: (libc)Rounding Functions. |
| * ceilfNx: (libc)Rounding Functions. |
| * ceill: (libc)Rounding Functions. |
| * cexp: (libc)Exponents and Logarithms. |
| * cexpf: (libc)Exponents and Logarithms. |
| * cexpfN: (libc)Exponents and Logarithms. |
| * cexpfNx: (libc)Exponents and Logarithms. |
| * cexpl: (libc)Exponents and Logarithms. |
| * cfgetispeed: (libc)Line Speed. |
| * cfgetospeed: (libc)Line Speed. |
| * cfmakeraw: (libc)Noncanonical Input. |
| * cfsetispeed: (libc)Line Speed. |
| * cfsetospeed: (libc)Line Speed. |
| * cfsetspeed: (libc)Line Speed. |
| * chdir: (libc)Working Directory. |
| * chmod: (libc)Setting Permissions. |
| * chown: (libc)File Owner. |
| * cimag: (libc)Operations on Complex. |
| * cimagf: (libc)Operations on Complex. |
| * cimagfN: (libc)Operations on Complex. |
| * cimagfNx: (libc)Operations on Complex. |
| * cimagl: (libc)Operations on Complex. |
| * clearenv: (libc)Environment Access. |
| * clearerr: (libc)Error Recovery. |
| * clearerr_unlocked: (libc)Error Recovery. |
| * clock: (libc)CPU Time. |
| * clog10: (libc)Exponents and Logarithms. |
| * clog10f: (libc)Exponents and Logarithms. |
| * clog10fN: (libc)Exponents and Logarithms. |
| * clog10fNx: (libc)Exponents and Logarithms. |
| * clog10l: (libc)Exponents and Logarithms. |
| * clog: (libc)Exponents and Logarithms. |
| * clogf: (libc)Exponents and Logarithms. |
| * clogfN: (libc)Exponents and Logarithms. |
| * clogfNx: (libc)Exponents and Logarithms. |
| * clogl: (libc)Exponents and Logarithms. |
| * close: (libc)Opening and Closing Files. |
| * closedir: (libc)Reading/Closing Directory. |
| * closelog: (libc)closelog. |
| * cnd_broadcast: (libc)ISO C Condition Variables. |
| * cnd_destroy: (libc)ISO C Condition Variables. |
| * cnd_init: (libc)ISO C Condition Variables. |
| * cnd_signal: (libc)ISO C Condition Variables. |
| * cnd_timedwait: (libc)ISO C Condition Variables. |
| * cnd_wait: (libc)ISO C Condition Variables. |
| * confstr: (libc)String Parameters. |
| * conj: (libc)Operations on Complex. |
| * conjf: (libc)Operations on Complex. |
| * conjfN: (libc)Operations on Complex. |
| * conjfNx: (libc)Operations on Complex. |
| * conjl: (libc)Operations on Complex. |
| * connect: (libc)Connecting. |
| * copy_file_range: (libc)Copying File Data. |
| * copysign: (libc)FP Bit Twiddling. |
| * copysignf: (libc)FP Bit Twiddling. |
| * copysignfN: (libc)FP Bit Twiddling. |
| * copysignfNx: (libc)FP Bit Twiddling. |
| * copysignl: (libc)FP Bit Twiddling. |
| * cos: (libc)Trig Functions. |
| * cosf: (libc)Trig Functions. |
| * cosfN: (libc)Trig Functions. |
| * cosfNx: (libc)Trig Functions. |
| * cosh: (libc)Hyperbolic Functions. |
| * coshf: (libc)Hyperbolic Functions. |
| * coshfN: (libc)Hyperbolic Functions. |
| * coshfNx: (libc)Hyperbolic Functions. |
| * coshl: (libc)Hyperbolic Functions. |
| * cosl: (libc)Trig Functions. |
| * cpow: (libc)Exponents and Logarithms. |
| * cpowf: (libc)Exponents and Logarithms. |
| * cpowfN: (libc)Exponents and Logarithms. |
| * cpowfNx: (libc)Exponents and Logarithms. |
| * cpowl: (libc)Exponents and Logarithms. |
| * cproj: (libc)Operations on Complex. |
| * cprojf: (libc)Operations on Complex. |
| * cprojfN: (libc)Operations on Complex. |
| * cprojfNx: (libc)Operations on Complex. |
| * cprojl: (libc)Operations on Complex. |
| * creal: (libc)Operations on Complex. |
| * crealf: (libc)Operations on Complex. |
| * crealfN: (libc)Operations on Complex. |
| * crealfNx: (libc)Operations on Complex. |
| * creall: (libc)Operations on Complex. |
| * creat64: (libc)Opening and Closing Files. |
| * creat: (libc)Opening and Closing Files. |
| * crypt: (libc)Passphrase Storage. |
| * crypt_r: (libc)Passphrase Storage. |
| * csin: (libc)Trig Functions. |
| * csinf: (libc)Trig Functions. |
| * csinfN: (libc)Trig Functions. |
| * csinfNx: (libc)Trig Functions. |
| * csinh: (libc)Hyperbolic Functions. |
| * csinhf: (libc)Hyperbolic Functions. |
| * csinhfN: (libc)Hyperbolic Functions. |
| * csinhfNx: (libc)Hyperbolic Functions. |
| * csinhl: (libc)Hyperbolic Functions. |
| * csinl: (libc)Trig Functions. |
| * csqrt: (libc)Exponents and Logarithms. |
| * csqrtf: (libc)Exponents and Logarithms. |
| * csqrtfN: (libc)Exponents and Logarithms. |
| * csqrtfNx: (libc)Exponents and Logarithms. |
| * csqrtl: (libc)Exponents and Logarithms. |
| * ctan: (libc)Trig Functions. |
| * ctanf: (libc)Trig Functions. |
| * ctanfN: (libc)Trig Functions. |
| * ctanfNx: (libc)Trig Functions. |
| * ctanh: (libc)Hyperbolic Functions. |
| * ctanhf: (libc)Hyperbolic Functions. |
| * ctanhfN: (libc)Hyperbolic Functions. |
| * ctanhfNx: (libc)Hyperbolic Functions. |
| * ctanhl: (libc)Hyperbolic Functions. |
| * ctanl: (libc)Trig Functions. |
| * ctermid: (libc)Identifying the Terminal. |
| * ctime: (libc)Formatting Calendar Time. |
| * ctime_r: (libc)Formatting Calendar Time. |
| * cuserid: (libc)Who Logged In. |
| * daddl: (libc)Misc FP Arithmetic. |
| * dcgettext: (libc)Translation with gettext. |
| * dcngettext: (libc)Advanced gettext functions. |
| * ddivl: (libc)Misc FP Arithmetic. |
| * dgettext: (libc)Translation with gettext. |
| * difftime: (libc)Elapsed Time. |
| * dirfd: (libc)Opening a Directory. |
| * dirname: (libc)Finding Tokens in a String. |
| * div: (libc)Integer Division. |
| * dmull: (libc)Misc FP Arithmetic. |
| * dngettext: (libc)Advanced gettext functions. |
| * drand48: (libc)SVID Random. |
| * drand48_r: (libc)SVID Random. |
| * drem: (libc)Remainder Functions. |
| * dremf: (libc)Remainder Functions. |
| * dreml: (libc)Remainder Functions. |
| * dsubl: (libc)Misc FP Arithmetic. |
| * dup2: (libc)Duplicating Descriptors. |
| * dup: (libc)Duplicating Descriptors. |
| * ecvt: (libc)System V Number Conversion. |
| * ecvt_r: (libc)System V Number Conversion. |
| * endfsent: (libc)fstab. |
| * endgrent: (libc)Scanning All Groups. |
| * endhostent: (libc)Host Names. |
| * endmntent: (libc)mtab. |
| * endnetent: (libc)Networks Database. |
| * endnetgrent: (libc)Lookup Netgroup. |
| * endprotoent: (libc)Protocols Database. |
| * endpwent: (libc)Scanning All Users. |
| * endservent: (libc)Services Database. |
| * endutent: (libc)Manipulating the Database. |
| * endutxent: (libc)XPG Functions. |
| * envz_add: (libc)Envz Functions. |
| * envz_entry: (libc)Envz Functions. |
| * envz_get: (libc)Envz Functions. |
| * envz_merge: (libc)Envz Functions. |
| * envz_remove: (libc)Envz Functions. |
| * envz_strip: (libc)Envz Functions. |
| * erand48: (libc)SVID Random. |
| * erand48_r: (libc)SVID Random. |
| * erf: (libc)Special Functions. |
| * erfc: (libc)Special Functions. |
| * erfcf: (libc)Special Functions. |
| * erfcfN: (libc)Special Functions. |
| * erfcfNx: (libc)Special Functions. |
| * erfcl: (libc)Special Functions. |
| * erff: (libc)Special Functions. |
| * erffN: (libc)Special Functions. |
| * erffNx: (libc)Special Functions. |
| * erfl: (libc)Special Functions. |
| * err: (libc)Error Messages. |
| * errno: (libc)Checking for Errors. |
| * error: (libc)Error Messages. |
| * error_at_line: (libc)Error Messages. |
| * errx: (libc)Error Messages. |
| * execl: (libc)Executing a File. |
| * execle: (libc)Executing a File. |
| * execlp: (libc)Executing a File. |
| * execv: (libc)Executing a File. |
| * execve: (libc)Executing a File. |
| * execvp: (libc)Executing a File. |
| * exit: (libc)Normal Termination. |
| * exp10: (libc)Exponents and Logarithms. |
| * exp10f: (libc)Exponents and Logarithms. |
| * exp10fN: (libc)Exponents and Logarithms. |
| * exp10fNx: (libc)Exponents and Logarithms. |
| * exp10l: (libc)Exponents and Logarithms. |
| * exp2: (libc)Exponents and Logarithms. |
| * exp2f: (libc)Exponents and Logarithms. |
| * exp2fN: (libc)Exponents and Logarithms. |
| * exp2fNx: (libc)Exponents and Logarithms. |
| * exp2l: (libc)Exponents and Logarithms. |
| * exp: (libc)Exponents and Logarithms. |
| * expf: (libc)Exponents and Logarithms. |
| * expfN: (libc)Exponents and Logarithms. |
| * expfNx: (libc)Exponents and Logarithms. |
| * expl: (libc)Exponents and Logarithms. |
| * explicit_bzero: (libc)Erasing Sensitive Data. |
| * expm1: (libc)Exponents and Logarithms. |
| * expm1f: (libc)Exponents and Logarithms. |
| * expm1fN: (libc)Exponents and Logarithms. |
| * expm1fNx: (libc)Exponents and Logarithms. |
| * expm1l: (libc)Exponents and Logarithms. |
| * fMaddfN: (libc)Misc FP Arithmetic. |
| * fMaddfNx: (libc)Misc FP Arithmetic. |
| * fMdivfN: (libc)Misc FP Arithmetic. |
| * fMdivfNx: (libc)Misc FP Arithmetic. |
| * fMmulfN: (libc)Misc FP Arithmetic. |
| * fMmulfNx: (libc)Misc FP Arithmetic. |
| * fMsubfN: (libc)Misc FP Arithmetic. |
| * fMsubfNx: (libc)Misc FP Arithmetic. |
| * fMxaddfN: (libc)Misc FP Arithmetic. |
| * fMxaddfNx: (libc)Misc FP Arithmetic. |
| * fMxdivfN: (libc)Misc FP Arithmetic. |
| * fMxdivfNx: (libc)Misc FP Arithmetic. |
| * fMxmulfN: (libc)Misc FP Arithmetic. |
| * fMxmulfNx: (libc)Misc FP Arithmetic. |
| * fMxsubfN: (libc)Misc FP Arithmetic. |
| * fMxsubfNx: (libc)Misc FP Arithmetic. |
| * fabs: (libc)Absolute Value. |
| * fabsf: (libc)Absolute Value. |
| * fabsfN: (libc)Absolute Value. |
| * fabsfNx: (libc)Absolute Value. |
| * fabsl: (libc)Absolute Value. |
| * fadd: (libc)Misc FP Arithmetic. |
| * faddl: (libc)Misc FP Arithmetic. |
| * fchdir: (libc)Working Directory. |
| * fchmod: (libc)Setting Permissions. |
| * fchown: (libc)File Owner. |
| * fclose: (libc)Closing Streams. |
| * fcloseall: (libc)Closing Streams. |
| * fcntl: (libc)Control Operations. |
| * fcvt: (libc)System V Number Conversion. |
| * fcvt_r: (libc)System V Number Conversion. |
| * fdatasync: (libc)Synchronizing I/O. |
| * fdim: (libc)Misc FP Arithmetic. |
| * fdimf: (libc)Misc FP Arithmetic. |
| * fdimfN: (libc)Misc FP Arithmetic. |
| * fdimfNx: (libc)Misc FP Arithmetic. |
| * fdiml: (libc)Misc FP Arithmetic. |
| * fdiv: (libc)Misc FP Arithmetic. |
| * fdivl: (libc)Misc FP Arithmetic. |
| * fdopen: (libc)Descriptors and Streams. |
| * fdopendir: (libc)Opening a Directory. |
| * feclearexcept: (libc)Status bit operations. |
| * fedisableexcept: (libc)Control Functions. |
| * feenableexcept: (libc)Control Functions. |
| * fegetenv: (libc)Control Functions. |
| * fegetexcept: (libc)Control Functions. |
| * fegetexceptflag: (libc)Status bit operations. |
| * fegetmode: (libc)Control Functions. |
| * fegetround: (libc)Rounding. |
| * feholdexcept: (libc)Control Functions. |
| * feof: (libc)EOF and Errors. |
| * feof_unlocked: (libc)EOF and Errors. |
| * feraiseexcept: (libc)Status bit operations. |
| * ferror: (libc)EOF and Errors. |
| * ferror_unlocked: (libc)EOF and Errors. |
| * fesetenv: (libc)Control Functions. |
| * fesetexcept: (libc)Status bit operations. |
| * fesetexceptflag: (libc)Status bit operations. |
| * fesetmode: (libc)Control Functions. |
| * fesetround: (libc)Rounding. |
| * fetestexcept: (libc)Status bit operations. |
| * fetestexceptflag: (libc)Status bit operations. |
| * feupdateenv: (libc)Control Functions. |
| * fflush: (libc)Flushing Buffers. |
| * fflush_unlocked: (libc)Flushing Buffers. |
| * fgetc: (libc)Character Input. |
| * fgetc_unlocked: (libc)Character Input. |
| * fgetgrent: (libc)Scanning All Groups. |
| * fgetgrent_r: (libc)Scanning All Groups. |
| * fgetpos64: (libc)Portable Positioning. |
| * fgetpos: (libc)Portable Positioning. |
| * fgetpwent: (libc)Scanning All Users. |
| * fgetpwent_r: (libc)Scanning All Users. |
| * fgets: (libc)Line Input. |
| * fgets_unlocked: (libc)Line Input. |
| * fgetwc: (libc)Character Input. |
| * fgetwc_unlocked: (libc)Character Input. |
| * fgetws: (libc)Line Input. |
| * fgetws_unlocked: (libc)Line Input. |
| * fileno: (libc)Descriptors and Streams. |
| * fileno_unlocked: (libc)Descriptors and Streams. |
| * finite: (libc)Floating Point Classes. |
| * finitef: (libc)Floating Point Classes. |
| * finitel: (libc)Floating Point Classes. |
| * flockfile: (libc)Streams and Threads. |
| * floor: (libc)Rounding Functions. |
| * floorf: (libc)Rounding Functions. |
| * floorfN: (libc)Rounding Functions. |
| * floorfNx: (libc)Rounding Functions. |
| * floorl: (libc)Rounding Functions. |
| * fma: (libc)Misc FP Arithmetic. |
| * fmaf: (libc)Misc FP Arithmetic. |
| * fmafN: (libc)Misc FP Arithmetic. |
| * fmafNx: (libc)Misc FP Arithmetic. |
| * fmal: (libc)Misc FP Arithmetic. |
| * fmax: (libc)Misc FP Arithmetic. |
| * fmaxf: (libc)Misc FP Arithmetic. |
| * fmaxfN: (libc)Misc FP Arithmetic. |
| * fmaxfNx: (libc)Misc FP Arithmetic. |
| * fmaxl: (libc)Misc FP Arithmetic. |
| * fmaxmag: (libc)Misc FP Arithmetic. |
| * fmaxmagf: (libc)Misc FP Arithmetic. |
| * fmaxmagfN: (libc)Misc FP Arithmetic. |
| * fmaxmagfNx: (libc)Misc FP Arithmetic. |
| * fmaxmagl: (libc)Misc FP Arithmetic. |
| * fmemopen: (libc)String Streams. |
| * fmin: (libc)Misc FP Arithmetic. |
| * fminf: (libc)Misc FP Arithmetic. |
| * fminfN: (libc)Misc FP Arithmetic. |
| * fminfNx: (libc)Misc FP Arithmetic. |
| * fminl: (libc)Misc FP Arithmetic. |
| * fminmag: (libc)Misc FP Arithmetic. |
| * fminmagf: (libc)Misc FP Arithmetic. |
| * fminmagfN: (libc)Misc FP Arithmetic. |
| * fminmagfNx: (libc)Misc FP Arithmetic. |
| * fminmagl: (libc)Misc FP Arithmetic. |
| * fmod: (libc)Remainder Functions. |
| * fmodf: (libc)Remainder Functions. |
| * fmodfN: (libc)Remainder Functions. |
| * fmodfNx: (libc)Remainder Functions. |
| * fmodl: (libc)Remainder Functions. |
| * fmtmsg: (libc)Printing Formatted Messages. |
| * fmul: (libc)Misc FP Arithmetic. |
| * fmull: (libc)Misc FP Arithmetic. |
| * fnmatch: (libc)Wildcard Matching. |
| * fopen64: (libc)Opening Streams. |
| * fopen: (libc)Opening Streams. |
| * fopencookie: (libc)Streams and Cookies. |
| * fork: (libc)Creating a Process. |
| * forkpty: (libc)Pseudo-Terminal Pairs. |
| * fpathconf: (libc)Pathconf. |
| * fpclassify: (libc)Floating Point Classes. |
| * fprintf: (libc)Formatted Output Functions. |
| * fputc: (libc)Simple Output. |
| * fputc_unlocked: (libc)Simple Output. |
| * fputs: (libc)Simple Output. |
| * fputs_unlocked: (libc)Simple Output. |
| * fputwc: (libc)Simple Output. |
| * fputwc_unlocked: (libc)Simple Output. |
| * fputws: (libc)Simple Output. |
| * fputws_unlocked: (libc)Simple Output. |
| * fread: (libc)Block Input/Output. |
| * fread_unlocked: (libc)Block Input/Output. |
| * free: (libc)Freeing after Malloc. |
| * freopen64: (libc)Opening Streams. |
| * freopen: (libc)Opening Streams. |
| * frexp: (libc)Normalization Functions. |
| * frexpf: (libc)Normalization Functions. |
| * frexpfN: (libc)Normalization Functions. |
| * frexpfNx: (libc)Normalization Functions. |
| * frexpl: (libc)Normalization Functions. |
| * fromfp: (libc)Rounding Functions. |
| * fromfpf: (libc)Rounding Functions. |
| * fromfpfN: (libc)Rounding Functions. |
| * fromfpfNx: (libc)Rounding Functions. |
| * fromfpl: (libc)Rounding Functions. |
| * fromfpx: (libc)Rounding Functions. |
| * fromfpxf: (libc)Rounding Functions. |
| * fromfpxfN: (libc)Rounding Functions. |
| * fromfpxfNx: (libc)Rounding Functions. |
| * fromfpxl: (libc)Rounding Functions. |
| * fscanf: (libc)Formatted Input Functions. |
| * fseek: (libc)File Positioning. |
| * fseeko64: (libc)File Positioning. |
| * fseeko: (libc)File Positioning. |
| * fsetpos64: (libc)Portable Positioning. |
| * fsetpos: (libc)Portable Positioning. |
| * fstat64: (libc)Reading Attributes. |
| * fstat: (libc)Reading Attributes. |
| * fsub: (libc)Misc FP Arithmetic. |
| * fsubl: (libc)Misc FP Arithmetic. |
| * fsync: (libc)Synchronizing I/O. |
| * ftell: (libc)File Positioning. |
| * ftello64: (libc)File Positioning. |
| * ftello: (libc)File Positioning. |
| * ftruncate64: (libc)File Size. |
| * ftruncate: (libc)File Size. |
| * ftrylockfile: (libc)Streams and Threads. |
| * ftw64: (libc)Working with Directory Trees. |
| * ftw: (libc)Working with Directory Trees. |
| * funlockfile: (libc)Streams and Threads. |
| * futimes: (libc)File Times. |
| * fwide: (libc)Streams and I18N. |
| * fwprintf: (libc)Formatted Output Functions. |
| * fwrite: (libc)Block Input/Output. |
| * fwrite_unlocked: (libc)Block Input/Output. |
| * fwscanf: (libc)Formatted Input Functions. |
| * gamma: (libc)Special Functions. |
| * gammaf: (libc)Special Functions. |
| * gammal: (libc)Special Functions. |
| * gcvt: (libc)System V Number Conversion. |
| * get_avphys_pages: (libc)Query Memory Parameters. |
| * get_current_dir_name: (libc)Working Directory. |
| * get_nprocs: (libc)Processor Resources. |
| * get_nprocs_conf: (libc)Processor Resources. |
| * get_phys_pages: (libc)Query Memory Parameters. |
| * getauxval: (libc)Auxiliary Vector. |
| * getc: (libc)Character Input. |
| * getc_unlocked: (libc)Character Input. |
| * getchar: (libc)Character Input. |
| * getchar_unlocked: (libc)Character Input. |
| * getcontext: (libc)System V contexts. |
| * getcpu: (libc)CPU Affinity. |
| * getcwd: (libc)Working Directory. |
| * getdate: (libc)General Time String Parsing. |
| * getdate_r: (libc)General Time String Parsing. |
| * getdelim: (libc)Line Input. |
| * getdents64: (libc)Low-level Directory Access. |
| * getdomainnname: (libc)Host Identification. |
| * getegid: (libc)Reading Persona. |
| * getentropy: (libc)Unpredictable Bytes. |
| * getenv: (libc)Environment Access. |
| * geteuid: (libc)Reading Persona. |
| * getfsent: (libc)fstab. |
| * getfsfile: (libc)fstab. |
| * getfsspec: (libc)fstab. |
| * getgid: (libc)Reading Persona. |
| * getgrent: (libc)Scanning All Groups. |
| * getgrent_r: (libc)Scanning All Groups. |
| * getgrgid: (libc)Lookup Group. |
| * getgrgid_r: (libc)Lookup Group. |
| * getgrnam: (libc)Lookup Group. |
| * getgrnam_r: (libc)Lookup Group. |
| * getgrouplist: (libc)Setting Groups. |
| * getgroups: (libc)Reading Persona. |
| * gethostbyaddr: (libc)Host Names. |
| * gethostbyaddr_r: (libc)Host Names. |
| * gethostbyname2: (libc)Host Names. |
| * gethostbyname2_r: (libc)Host Names. |
| * gethostbyname: (libc)Host Names. |
| * gethostbyname_r: (libc)Host Names. |
| * gethostent: (libc)Host Names. |
| * gethostid: (libc)Host Identification. |
| * gethostname: (libc)Host Identification. |
| * getitimer: (libc)Setting an Alarm. |
| * getline: (libc)Line Input. |
| * getloadavg: (libc)Processor Resources. |
| * getlogin: (libc)Who Logged In. |
| * getmntent: (libc)mtab. |
| * getmntent_r: (libc)mtab. |
| * getnetbyaddr: (libc)Networks Database. |
| * getnetbyname: (libc)Networks Database. |
| * getnetent: (libc)Networks Database. |
| * getnetgrent: (libc)Lookup Netgroup. |
| * getnetgrent_r: (libc)Lookup Netgroup. |
| * getopt: (libc)Using Getopt. |
| * getopt_long: (libc)Getopt Long Options. |
| * getopt_long_only: (libc)Getopt Long Options. |
| * getpagesize: (libc)Query Memory Parameters. |
| * getpass: (libc)getpass. |
| * getpayload: (libc)FP Bit Twiddling. |
| * getpayloadf: (libc)FP Bit Twiddling. |
| * getpayloadfN: (libc)FP Bit Twiddling. |
| * getpayloadfNx: (libc)FP Bit Twiddling. |
| * getpayloadl: (libc)FP Bit Twiddling. |
| * getpeername: (libc)Who is Connected. |
| * getpgid: (libc)Process Group Functions. |
| * getpgrp: (libc)Process Group Functions. |
| * getpid: (libc)Process Identification. |
| * getppid: (libc)Process Identification. |
| * getpriority: (libc)Traditional Scheduling Functions. |
| * getprotobyname: (libc)Protocols Database. |
| * getprotobynumber: (libc)Protocols Database. |
| * getprotoent: (libc)Protocols Database. |
| * getpt: (libc)Allocation. |
| * getpwent: (libc)Scanning All Users. |
| * getpwent_r: (libc)Scanning All Users. |
| * getpwnam: (libc)Lookup User. |
| * getpwnam_r: (libc)Lookup User. |
| * getpwuid: (libc)Lookup User. |
| * getpwuid_r: (libc)Lookup User. |
| * getrandom: (libc)Unpredictable Bytes. |
| * getrlimit64: (libc)Limits on Resources. |
| * getrlimit: (libc)Limits on Resources. |
| * getrusage: (libc)Resource Usage. |
| * gets: (libc)Line Input. |
| * getservbyname: (libc)Services Database. |
| * getservbyport: (libc)Services Database. |
| * getservent: (libc)Services Database. |
| * getsid: (libc)Process Group Functions. |
| * getsockname: (libc)Reading Address. |
| * getsockopt: (libc)Socket Option Functions. |
| * getsubopt: (libc)Suboptions. |
| * gettext: (libc)Translation with gettext. |
| * gettid: (libc)Process Identification. |
| * gettimeofday: (libc)High-Resolution Calendar. |
| * getuid: (libc)Reading Persona. |
| * getumask: (libc)Setting Permissions. |
| * getutent: (libc)Manipulating the Database. |
| * getutent_r: (libc)Manipulating the Database. |
| * getutid: (libc)Manipulating the Database. |
| * getutid_r: (libc)Manipulating the Database. |
| * getutline: (libc)Manipulating the Database. |
| * getutline_r: (libc)Manipulating the Database. |
| * getutmp: (libc)XPG Functions. |
| * getutmpx: (libc)XPG Functions. |
| * getutxent: (libc)XPG Functions. |
| * getutxid: (libc)XPG Functions. |
| * getutxline: (libc)XPG Functions. |
| * getw: (libc)Character Input. |
| * getwc: (libc)Character Input. |
| * getwc_unlocked: (libc)Character Input. |
| * getwchar: (libc)Character Input. |
| * getwchar_unlocked: (libc)Character Input. |
| * getwd: (libc)Working Directory. |
| * glob64: (libc)Calling Glob. |
| * glob: (libc)Calling Glob. |
| * globfree64: (libc)More Flags for Globbing. |
| * globfree: (libc)More Flags for Globbing. |
| * gmtime: (libc)Broken-down Time. |
| * gmtime_r: (libc)Broken-down Time. |
| * grantpt: (libc)Allocation. |
| * gsignal: (libc)Signaling Yourself. |
| * gtty: (libc)BSD Terminal Modes. |
| * hasmntopt: (libc)mtab. |
| * hcreate: (libc)Hash Search Function. |
| * hcreate_r: (libc)Hash Search Function. |
| * hdestroy: (libc)Hash Search Function. |
| * hdestroy_r: (libc)Hash Search Function. |
| * hsearch: (libc)Hash Search Function. |
| * hsearch_r: (libc)Hash Search Function. |
| * htonl: (libc)Byte Order. |
| * htons: (libc)Byte Order. |
| * hypot: (libc)Exponents and Logarithms. |
| * hypotf: (libc)Exponents and Logarithms. |
| * hypotfN: (libc)Exponents and Logarithms. |
| * hypotfNx: (libc)Exponents and Logarithms. |
| * hypotl: (libc)Exponents and Logarithms. |
| * iconv: (libc)Generic Conversion Interface. |
| * iconv_close: (libc)Generic Conversion Interface. |
| * iconv_open: (libc)Generic Conversion Interface. |
| * if_freenameindex: (libc)Interface Naming. |
| * if_indextoname: (libc)Interface Naming. |
| * if_nameindex: (libc)Interface Naming. |
| * if_nametoindex: (libc)Interface Naming. |
| * ilogb: (libc)Exponents and Logarithms. |
| * ilogbf: (libc)Exponents and Logarithms. |
| * ilogbfN: (libc)Exponents and Logarithms. |
| * ilogbfNx: (libc)Exponents and Logarithms. |
| * ilogbl: (libc)Exponents and Logarithms. |
| * imaxabs: (libc)Absolute Value. |
| * imaxdiv: (libc)Integer Division. |
| * in6addr_any: (libc)Host Address Data Type. |
| * in6addr_loopback: (libc)Host Address Data Type. |
| * index: (libc)Search Functions. |
| * inet_addr: (libc)Host Address Functions. |
| * inet_aton: (libc)Host Address Functions. |
| * inet_lnaof: (libc)Host Address Functions. |
| * inet_makeaddr: (libc)Host Address Functions. |
| * inet_netof: (libc)Host Address Functions. |
| * inet_network: (libc)Host Address Functions. |
| * inet_ntoa: (libc)Host Address Functions. |
| * inet_ntop: (libc)Host Address Functions. |
| * inet_pton: (libc)Host Address Functions. |
| * initgroups: (libc)Setting Groups. |
| * initstate: (libc)BSD Random. |
| * initstate_r: (libc)BSD Random. |
| * innetgr: (libc)Netgroup Membership. |
| * ioctl: (libc)IOCTLs. |
| * isalnum: (libc)Classification of Characters. |
| * isalpha: (libc)Classification of Characters. |
| * isascii: (libc)Classification of Characters. |
| * isatty: (libc)Is It a Terminal. |
| * isblank: (libc)Classification of Characters. |
| * iscanonical: (libc)Floating Point Classes. |
| * iscntrl: (libc)Classification of Characters. |
| * isdigit: (libc)Classification of Characters. |
| * iseqsig: (libc)FP Comparison Functions. |
| * isfinite: (libc)Floating Point Classes. |
| * isgraph: (libc)Classification of Characters. |
| * isgreater: (libc)FP Comparison Functions. |
| * isgreaterequal: (libc)FP Comparison Functions. |
| * isinf: (libc)Floating Point Classes. |
| * isinff: (libc)Floating Point Classes. |
| * isinfl: (libc)Floating Point Classes. |
| * isless: (libc)FP Comparison Functions. |
| * islessequal: (libc)FP Comparison Functions. |
| * islessgreater: (libc)FP Comparison Functions. |
| * islower: (libc)Classification of Characters. |
| * isnan: (libc)Floating Point Classes. |
| * isnan: (libc)Floating Point Classes. |
| * isnanf: (libc)Floating Point Classes. |
| * isnanl: (libc)Floating Point Classes. |
| * isnormal: (libc)Floating Point Classes. |
| * isprint: (libc)Classification of Characters. |
| * ispunct: (libc)Classification of Characters. |
| * issignaling: (libc)Floating Point Classes. |
| * isspace: (libc)Classification of Characters. |
| * issubnormal: (libc)Floating Point Classes. |
| * isunordered: (libc)FP Comparison Functions. |
| * isupper: (libc)Classification of Characters. |
| * iswalnum: (libc)Classification of Wide Characters. |
| * iswalpha: (libc)Classification of Wide Characters. |
| * iswblank: (libc)Classification of Wide Characters. |
| * iswcntrl: (libc)Classification of Wide Characters. |
| * iswctype: (libc)Classification of Wide Characters. |
| * iswdigit: (libc)Classification of Wide Characters. |
| * iswgraph: (libc)Classification of Wide Characters. |
| * iswlower: (libc)Classification of Wide Characters. |
| * iswprint: (libc)Classification of Wide Characters. |
| * iswpunct: (libc)Classification of Wide Characters. |
| * iswspace: (libc)Classification of Wide Characters. |
| * iswupper: (libc)Classification of Wide Characters. |
| * iswxdigit: (libc)Classification of Wide Characters. |
| * isxdigit: (libc)Classification of Characters. |
| * iszero: (libc)Floating Point Classes. |
| * j0: (libc)Special Functions. |
| * j0f: (libc)Special Functions. |
| * j0fN: (libc)Special Functions. |
| * j0fNx: (libc)Special Functions. |
| * j0l: (libc)Special Functions. |
| * j1: (libc)Special Functions. |
| * j1f: (libc)Special Functions. |
| * j1fN: (libc)Special Functions. |
| * j1fNx: (libc)Special Functions. |
| * j1l: (libc)Special Functions. |
| * jn: (libc)Special Functions. |
| * jnf: (libc)Special Functions. |
| * jnfN: (libc)Special Functions. |
| * jnfNx: (libc)Special Functions. |
| * jnl: (libc)Special Functions. |
| * jrand48: (libc)SVID Random. |
| * jrand48_r: (libc)SVID Random. |
| * kill: (libc)Signaling Another Process. |
| * killpg: (libc)Signaling Another Process. |
| * l64a: (libc)Encode Binary Data. |
| * labs: (libc)Absolute Value. |
| * lcong48: (libc)SVID Random. |
| * lcong48_r: (libc)SVID Random. |
| * ldexp: (libc)Normalization Functions. |
| * ldexpf: (libc)Normalization Functions. |
| * ldexpfN: (libc)Normalization Functions. |
| * ldexpfNx: (libc)Normalization Functions. |
| * ldexpl: (libc)Normalization Functions. |
| * ldiv: (libc)Integer Division. |
| * lfind: (libc)Array Search Function. |
| * lgamma: (libc)Special Functions. |
| * lgamma_r: (libc)Special Functions. |
| * lgammaf: (libc)Special Functions. |
| * lgammafN: (libc)Special Functions. |
| * lgammafN_r: (libc)Special Functions. |
| * lgammafNx: (libc)Special Functions. |
| * lgammafNx_r: (libc)Special Functions. |
| * lgammaf_r: (libc)Special Functions. |
| * lgammal: (libc)Special Functions. |
| * lgammal_r: (libc)Special Functions. |
| * link: (libc)Hard Links. |
| * linkat: (libc)Hard Links. |
| * lio_listio64: (libc)Asynchronous Reads/Writes. |
| * lio_listio: (libc)Asynchronous Reads/Writes. |
| * listen: (libc)Listening. |
| * llabs: (libc)Absolute Value. |
| * lldiv: (libc)Integer Division. |
| * llogb: (libc)Exponents and Logarithms. |
| * llogbf: (libc)Exponents and Logarithms. |
| * llogbfN: (libc)Exponents and Logarithms. |
| * llogbfNx: (libc)Exponents and Logarithms. |
| * llogbl: (libc)Exponents and Logarithms. |
| * llrint: (libc)Rounding Functions. |
| * llrintf: (libc)Rounding Functions. |
| * llrintfN: (libc)Rounding Functions. |
| * llrintfNx: (libc)Rounding Functions. |
| * llrintl: (libc)Rounding Functions. |
| * llround: (libc)Rounding Functions. |
| * llroundf: (libc)Rounding Functions. |
| * llroundfN: (libc)Rounding Functions. |
| * llroundfNx: (libc)Rounding Functions. |
| * llroundl: (libc)Rounding Functions. |
| * localeconv: (libc)The Lame Way to Locale Data. |
| * localtime: (libc)Broken-down Time. |
| * localtime_r: (libc)Broken-down Time. |
| * log10: (libc)Exponents and Logarithms. |
| * log10f: (libc)Exponents and Logarithms. |
| * log10fN: (libc)Exponents and Logarithms. |
| * log10fNx: (libc)Exponents and Logarithms. |
| * log10l: (libc)Exponents and Logarithms. |
| * log1p: (libc)Exponents and Logarithms. |
| * log1pf: (libc)Exponents and Logarithms. |
| * log1pfN: (libc)Exponents and Logarithms. |
| * log1pfNx: (libc)Exponents and Logarithms. |
| * log1pl: (libc)Exponents and Logarithms. |
| * log2: (libc)Exponents and Logarithms. |
| * log2f: (libc)Exponents and Logarithms. |
| * log2fN: (libc)Exponents and Logarithms. |
| * log2fNx: (libc)Exponents and Logarithms. |
| * log2l: (libc)Exponents and Logarithms. |
| * log: (libc)Exponents and Logarithms. |
| * logb: (libc)Exponents and Logarithms. |
| * logbf: (libc)Exponents and Logarithms. |
| * logbfN: (libc)Exponents and Logarithms. |
| * logbfNx: (libc)Exponents and Logarithms. |
| * logbl: (libc)Exponents and Logarithms. |
| * logf: (libc)Exponents and Logarithms. |
| * logfN: (libc)Exponents and Logarithms. |
| * logfNx: (libc)Exponents and Logarithms. |
| * login: (libc)Logging In and Out. |
| * login_tty: (libc)Logging In and Out. |
| * logl: (libc)Exponents and Logarithms. |
| * logout: (libc)Logging In and Out. |
| * logwtmp: (libc)Logging In and Out. |
| * longjmp: (libc)Non-Local Details. |
| * lrand48: (libc)SVID Random. |
| * lrand48_r: (libc)SVID Random. |
| * lrint: (libc)Rounding Functions. |
| * lrintf: (libc)Rounding Functions. |
| * lrintfN: (libc)Rounding Functions. |
| * lrintfNx: (libc)Rounding Functions. |
| * lrintl: (libc)Rounding Functions. |
| * lround: (libc)Rounding Functions. |
| * lroundf: (libc)Rounding Functions. |
| * lroundfN: (libc)Rounding Functions. |
| * lroundfNx: (libc)Rounding Functions. |
| * lroundl: (libc)Rounding Functions. |
| * lsearch: (libc)Array Search Function. |
| * lseek64: (libc)File Position Primitive. |
| * lseek: (libc)File Position Primitive. |
| * lstat64: (libc)Reading Attributes. |
| * lstat: (libc)Reading Attributes. |
| * lutimes: (libc)File Times. |
| * madvise: (libc)Memory-mapped I/O. |
| * makecontext: (libc)System V contexts. |
| * mallinfo: (libc)Statistics of Malloc. |
| * malloc: (libc)Basic Allocation. |
| * mallopt: (libc)Malloc Tunable Parameters. |
| * mblen: (libc)Non-reentrant Character Conversion. |
| * mbrlen: (libc)Converting a Character. |
| * mbrtowc: (libc)Converting a Character. |
| * mbsinit: (libc)Keeping the state. |
| * mbsnrtowcs: (libc)Converting Strings. |
| * mbsrtowcs: (libc)Converting Strings. |
| * mbstowcs: (libc)Non-reentrant String Conversion. |
| * mbtowc: (libc)Non-reentrant Character Conversion. |
| * mcheck: (libc)Heap Consistency Checking. |
| * memalign: (libc)Aligned Memory Blocks. |
| * memccpy: (libc)Copying Strings and Arrays. |
| * memchr: (libc)Search Functions. |
| * memcmp: (libc)String/Array Comparison. |
| * memcpy: (libc)Copying Strings and Arrays. |
| * memfd_create: (libc)Memory-mapped I/O. |
| * memfrob: (libc)Obfuscating Data. |
| * memmem: (libc)Search Functions. |
| * memmove: (libc)Copying Strings and Arrays. |
| * mempcpy: (libc)Copying Strings and Arrays. |
| * memrchr: (libc)Search Functions. |
| * memset: (libc)Copying Strings and Arrays. |
| * mkdir: (libc)Creating Directories. |
| * mkdtemp: (libc)Temporary Files. |
| * mkfifo: (libc)FIFO Special Files. |
| * mknod: (libc)Making Special Files. |
| * mkstemp: (libc)Temporary Files. |
| * mktemp: (libc)Temporary Files. |
| * mktime: (libc)Broken-down Time. |
| * mlock2: (libc)Page Lock Functions. |
| * mlock: (libc)Page Lock Functions. |
| * mlockall: (libc)Page Lock Functions. |
| * mmap64: (libc)Memory-mapped I/O. |
| * mmap: (libc)Memory-mapped I/O. |
| * modf: (libc)Rounding Functions. |
| * modff: (libc)Rounding Functions. |
| * modffN: (libc)Rounding Functions. |
| * modffNx: (libc)Rounding Functions. |
| * modfl: (libc)Rounding Functions. |
| * mount: (libc)Mount-Unmount-Remount. |
| * mprobe: (libc)Heap Consistency Checking. |
| * mprotect: (libc)Memory Protection. |
| * mrand48: (libc)SVID Random. |
| * mrand48_r: (libc)SVID Random. |
| * mremap: (libc)Memory-mapped I/O. |
| * msync: (libc)Memory-mapped I/O. |
| * mtrace: (libc)Tracing malloc. |
| * mtx_destroy: (libc)ISO C Mutexes. |
| * mtx_init: (libc)ISO C Mutexes. |
| * mtx_lock: (libc)ISO C Mutexes. |
| * mtx_timedlock: (libc)ISO C Mutexes. |
| * mtx_trylock: (libc)ISO C Mutexes. |
| * mtx_unlock: (libc)ISO C Mutexes. |
| * munlock: (libc)Page Lock Functions. |
| * munlockall: (libc)Page Lock Functions. |
| * munmap: (libc)Memory-mapped I/O. |
| * muntrace: (libc)Tracing malloc. |
| * nan: (libc)FP Bit Twiddling. |
| * nanf: (libc)FP Bit Twiddling. |
| * nanfN: (libc)FP Bit Twiddling. |
| * nanfNx: (libc)FP Bit Twiddling. |
| * nanl: (libc)FP Bit Twiddling. |
| * nanosleep: (libc)Sleeping. |
| * nearbyint: (libc)Rounding Functions. |
| * nearbyintf: (libc)Rounding Functions. |
| * nearbyintfN: (libc)Rounding Functions. |
| * nearbyintfNx: (libc)Rounding Functions. |
| * nearbyintl: (libc)Rounding Functions. |
| * nextafter: (libc)FP Bit Twiddling. |
| * nextafterf: (libc)FP Bit Twiddling. |
| * nextafterfN: (libc)FP Bit Twiddling. |
| * nextafterfNx: (libc)FP Bit Twiddling. |
| * nextafterl: (libc)FP Bit Twiddling. |
| * nextdown: (libc)FP Bit Twiddling. |
| * nextdownf: (libc)FP Bit Twiddling. |
| * nextdownfN: (libc)FP Bit Twiddling. |
| * nextdownfNx: (libc)FP Bit Twiddling. |
| * nextdownl: (libc)FP Bit Twiddling. |
| * nexttoward: (libc)FP Bit Twiddling. |
| * nexttowardf: (libc)FP Bit Twiddling. |
| * nexttowardl: (libc)FP Bit Twiddling. |
| * nextup: (libc)FP Bit Twiddling. |
| * nextupf: (libc)FP Bit Twiddling. |
| * nextupfN: (libc)FP Bit Twiddling. |
| * nextupfNx: (libc)FP Bit Twiddling. |
| * nextupl: (libc)FP Bit Twiddling. |
| * nftw64: (libc)Working with Directory Trees. |
| * nftw: (libc)Working with Directory Trees. |
| * ngettext: (libc)Advanced gettext functions. |
| * nice: (libc)Traditional Scheduling Functions. |
| * nl_langinfo: (libc)The Elegant and Fast Way. |
| * nrand48: (libc)SVID Random. |
| * nrand48_r: (libc)SVID Random. |
| * ntohl: (libc)Byte Order. |
| * ntohs: (libc)Byte Order. |
| * ntp_adjtime: (libc)High Accuracy Clock. |
| * ntp_gettime: (libc)High Accuracy Clock. |
| * obstack_1grow: (libc)Growing Objects. |
| * obstack_1grow_fast: (libc)Extra Fast Growing. |
| * obstack_alignment_mask: (libc)Obstacks Data Alignment. |
| * obstack_alloc: (libc)Allocation in an Obstack. |
| * obstack_base: (libc)Status of an Obstack. |
| * obstack_blank: (libc)Growing Objects. |
| * obstack_blank_fast: (libc)Extra Fast Growing. |
| * obstack_chunk_size: (libc)Obstack Chunks. |
| * obstack_copy0: (libc)Allocation in an Obstack. |
| * obstack_copy: (libc)Allocation in an Obstack. |
| * obstack_finish: (libc)Growing Objects. |
| * obstack_free: (libc)Freeing Obstack Objects. |
| * obstack_grow0: (libc)Growing Objects. |
| * obstack_grow: (libc)Growing Objects. |
| * obstack_init: (libc)Preparing for Obstacks. |
| * obstack_int_grow: (libc)Growing Objects. |
| * obstack_int_grow_fast: (libc)Extra Fast Growing. |
| * obstack_next_free: (libc)Status of an Obstack. |
| * obstack_object_size: (libc)Growing Objects. |
| * obstack_object_size: (libc)Status of an Obstack. |
| * obstack_printf: (libc)Dynamic Output. |
| * obstack_ptr_grow: (libc)Growing Objects. |
| * obstack_ptr_grow_fast: (libc)Extra Fast Growing. |
| * obstack_room: (libc)Extra Fast Growing. |
| * obstack_vprintf: (libc)Variable Arguments Output. |
| * offsetof: (libc)Structure Measurement. |
| * on_exit: (libc)Cleanups on Exit. |
| * open64: (libc)Opening and Closing Files. |
| * open: (libc)Opening and Closing Files. |
| * open_memstream: (libc)String Streams. |
| * opendir: (libc)Opening a Directory. |
| * openlog: (libc)openlog. |
| * openpty: (libc)Pseudo-Terminal Pairs. |
| * parse_printf_format: (libc)Parsing a Template String. |
| * pathconf: (libc)Pathconf. |
| * pause: (libc)Using Pause. |
| * pclose: (libc)Pipe to a Subprocess. |
| * perror: (libc)Error Messages. |
| * pipe: (libc)Creating a Pipe. |
| * pkey_alloc: (libc)Memory Protection. |
| * pkey_free: (libc)Memory Protection. |
| * pkey_get: (libc)Memory Protection. |
| * pkey_mprotect: (libc)Memory Protection. |
| * pkey_set: (libc)Memory Protection. |
| * popen: (libc)Pipe to a Subprocess. |
| * posix_fallocate64: (libc)Storage Allocation. |
| * posix_fallocate: (libc)Storage Allocation. |
| * posix_memalign: (libc)Aligned Memory Blocks. |
| * pow: (libc)Exponents and Logarithms. |
| * powf: (libc)Exponents and Logarithms. |
| * powfN: (libc)Exponents and Logarithms. |
| * powfNx: (libc)Exponents and Logarithms. |
| * powl: (libc)Exponents and Logarithms. |
| * pread64: (libc)I/O Primitives. |
| * pread: (libc)I/O Primitives. |
| * preadv2: (libc)Scatter-Gather. |
| * preadv64: (libc)Scatter-Gather. |
| * preadv64v2: (libc)Scatter-Gather. |
| * preadv: (libc)Scatter-Gather. |
| * printf: (libc)Formatted Output Functions. |
| * printf_size: (libc)Predefined Printf Handlers. |
| * printf_size_info: (libc)Predefined Printf Handlers. |
| * psignal: (libc)Signal Messages. |
| * pthread_cond_clockwait: (libc)Default Thread Attributes. |
| * pthread_getattr_default_np: (libc)Default Thread Attributes. |
| * pthread_getspecific: (libc)Thread-specific Data. |
| * pthread_key_create: (libc)Thread-specific Data. |
| * pthread_key_delete: (libc)Thread-specific Data. |
| * pthread_rwlock_clockrdlock: (libc)Default Thread Attributes. |
| * pthread_rwlock_clockwrlock: (libc)Default Thread Attributes. |
| * pthread_setattr_default_np: (libc)Default Thread Attributes. |
| * pthread_setspecific: (libc)Thread-specific Data. |
| * ptsname: (libc)Allocation. |
| * ptsname_r: (libc)Allocation. |
| * putc: (libc)Simple Output. |
| * putc_unlocked: (libc)Simple Output. |
| * putchar: (libc)Simple Output. |
| * putchar_unlocked: (libc)Simple Output. |
| * putenv: (libc)Environment Access. |
| * putpwent: (libc)Writing a User Entry. |
| * puts: (libc)Simple Output. |
| * pututline: (libc)Manipulating the Database. |
| * pututxline: (libc)XPG Functions. |
| * putw: (libc)Simple Output. |
| * putwc: (libc)Simple Output. |
| * putwc_unlocked: (libc)Simple Output. |
| * putwchar: (libc)Simple Output. |
| * putwchar_unlocked: (libc)Simple Output. |
| * pwrite64: (libc)I/O Primitives. |
| * pwrite: (libc)I/O Primitives. |
| * pwritev2: (libc)Scatter-Gather. |
| * pwritev64: (libc)Scatter-Gather. |
| * pwritev64v2: (libc)Scatter-Gather. |
| * pwritev: (libc)Scatter-Gather. |
| * qecvt: (libc)System V Number Conversion. |
| * qecvt_r: (libc)System V Number Conversion. |
| * qfcvt: (libc)System V Number Conversion. |
| * qfcvt_r: (libc)System V Number Conversion. |
| * qgcvt: (libc)System V Number Conversion. |
| * qsort: (libc)Array Sort Function. |
| * raise: (libc)Signaling Yourself. |
| * rand: (libc)ISO Random. |
| * rand_r: (libc)ISO Random. |
| * random: (libc)BSD Random. |
| * random_r: (libc)BSD Random. |
| * rawmemchr: (libc)Search Functions. |
| * read: (libc)I/O Primitives. |
| * readdir64: (libc)Reading/Closing Directory. |
| * readdir64_r: (libc)Reading/Closing Directory. |
| * readdir: (libc)Reading/Closing Directory. |
| * readdir_r: (libc)Reading/Closing Directory. |
| * readlink: (libc)Symbolic Links. |
| * readv: (libc)Scatter-Gather. |
| * realloc: (libc)Changing Block Size. |
| * reallocarray: (libc)Changing Block Size. |
| * realpath: (libc)Symbolic Links. |
| * recv: (libc)Receiving Data. |
| * recvfrom: (libc)Receiving Datagrams. |
| * recvmsg: (libc)Receiving Datagrams. |
| * regcomp: (libc)POSIX Regexp Compilation. |
| * regerror: (libc)Regexp Cleanup. |
| * regexec: (libc)Matching POSIX Regexps. |
| * regfree: (libc)Regexp Cleanup. |
| * register_printf_function: (libc)Registering New Conversions. |
| * remainder: (libc)Remainder Functions. |
| * remainderf: (libc)Remainder Functions. |
| * remainderfN: (libc)Remainder Functions. |
| * remainderfNx: (libc)Remainder Functions. |
| * remainderl: (libc)Remainder Functions. |
| * remove: (libc)Deleting Files. |
| * rename: (libc)Renaming Files. |
| * rewind: (libc)File Positioning. |
| * rewinddir: (libc)Random Access Directory. |
| * rindex: (libc)Search Functions. |
| * rint: (libc)Rounding Functions. |
| * rintf: (libc)Rounding Functions. |
| * rintfN: (libc)Rounding Functions. |
| * rintfNx: (libc)Rounding Functions. |
| * rintl: (libc)Rounding Functions. |
| * rmdir: (libc)Deleting Files. |
| * round: (libc)Rounding Functions. |
| * roundeven: (libc)Rounding Functions. |
| * roundevenf: (libc)Rounding Functions. |
| * roundevenfN: (libc)Rounding Functions. |
| * roundevenfNx: (libc)Rounding Functions. |
| * roundevenl: (libc)Rounding Functions. |
| * roundf: (libc)Rounding Functions. |
| * roundfN: (libc)Rounding Functions. |
| * roundfNx: (libc)Rounding Functions. |
| * roundl: (libc)Rounding Functions. |
| * rpmatch: (libc)Yes-or-No Questions. |
| * sbrk: (libc)Resizing the Data Segment. |
| * scalb: (libc)Normalization Functions. |
| * scalbf: (libc)Normalization Functions. |
| * scalbl: (libc)Normalization Functions. |
| * scalbln: (libc)Normalization Functions. |
| * scalblnf: (libc)Normalization Functions. |
| * scalblnfN: (libc)Normalization Functions. |
| * scalblnfNx: (libc)Normalization Functions. |
| * scalblnl: (libc)Normalization Functions. |
| * scalbn: (libc)Normalization Functions. |
| * scalbnf: (libc)Normalization Functions. |
| * scalbnfN: (libc)Normalization Functions. |
| * scalbnfNx: (libc)Normalization Functions. |
| * scalbnl: (libc)Normalization Functions. |
| * scandir64: (libc)Scanning Directory Content. |
| * scandir: (libc)Scanning Directory Content. |
| * scanf: (libc)Formatted Input Functions. |
| * sched_get_priority_max: (libc)Basic Scheduling Functions. |
| * sched_get_priority_min: (libc)Basic Scheduling Functions. |
| * sched_getaffinity: (libc)CPU Affinity. |
| * sched_getparam: (libc)Basic Scheduling Functions. |
| * sched_getscheduler: (libc)Basic Scheduling Functions. |
| * sched_rr_get_interval: (libc)Basic Scheduling Functions. |
| * sched_setaffinity: (libc)CPU Affinity. |
| * sched_setparam: (libc)Basic Scheduling Functions. |
| * sched_setscheduler: (libc)Basic Scheduling Functions. |
| * sched_yield: (libc)Basic Scheduling Functions. |
| * secure_getenv: (libc)Environment Access. |
| * seed48: (libc)SVID Random. |
| * seed48_r: (libc)SVID Random. |
| * seekdir: (libc)Random Access Directory. |
| * select: (libc)Waiting for I/O. |
| * sem_clockwait: (libc)Default Thread Attributes. |
| * sem_close: (libc)Semaphores. |
| * sem_destroy: (libc)Semaphores. |
| * sem_getvalue: (libc)Semaphores. |
| * sem_init: (libc)Semaphores. |
| * sem_open: (libc)Semaphores. |
| * sem_post: (libc)Semaphores. |
| * sem_timedwait: (libc)Semaphores. |
| * sem_trywait: (libc)Semaphores. |
| * sem_unlink: (libc)Semaphores. |
| * sem_wait: (libc)Semaphores. |
| * semctl: (libc)Semaphores. |
| * semget: (libc)Semaphores. |
| * semop: (libc)Semaphores. |
| * semtimedop: (libc)Semaphores. |
| * send: (libc)Sending Data. |
| * sendmsg: (libc)Receiving Datagrams. |
| * sendto: (libc)Sending Datagrams. |
| * setbuf: (libc)Controlling Buffering. |
| * setbuffer: (libc)Controlling Buffering. |
| * setcontext: (libc)System V contexts. |
| * setdomainname: (libc)Host Identification. |
| * setegid: (libc)Setting Groups. |
| * setenv: (libc)Environment Access. |
| * seteuid: (libc)Setting User ID. |
| * setfsent: (libc)fstab. |
| * setgid: (libc)Setting Groups. |
| * setgrent: (libc)Scanning All Groups. |
| * setgroups: (libc)Setting Groups. |
| * sethostent: (libc)Host Names. |
| * sethostid: (libc)Host Identification. |
| * sethostname: (libc)Host Identification. |
| * setitimer: (libc)Setting an Alarm. |
| * setjmp: (libc)Non-Local Details. |
| * setlinebuf: (libc)Controlling Buffering. |
| * setlocale: (libc)Setting the Locale. |
| * setlogmask: (libc)setlogmask. |
| * setmntent: (libc)mtab. |
| * setnetent: (libc)Networks Database. |
| * setnetgrent: (libc)Lookup Netgroup. |
| * setpayload: (libc)FP Bit Twiddling. |
| * setpayloadf: (libc)FP Bit Twiddling. |
| * setpayloadfN: (libc)FP Bit Twiddling. |
| * setpayloadfNx: (libc)FP Bit Twiddling. |
| * setpayloadl: (libc)FP Bit Twiddling. |
| * setpayloadsig: (libc)FP Bit Twiddling. |
| * setpayloadsigf: (libc)FP Bit Twiddling. |
| * setpayloadsigfN: (libc)FP Bit Twiddling. |
| * setpayloadsigfNx: (libc)FP Bit Twiddling. |
| * setpayloadsigl: (libc)FP Bit Twiddling. |
| * setpgid: (libc)Process Group Functions. |
| * setpgrp: (libc)Process Group Functions. |
| * setpriority: (libc)Traditional Scheduling Functions. |
| * setprotoent: (libc)Protocols Database. |
| * setpwent: (libc)Scanning All Users. |
| * setregid: (libc)Setting Groups. |
| * setreuid: (libc)Setting User ID. |
| * setrlimit64: (libc)Limits on Resources. |
| * setrlimit: (libc)Limits on Resources. |
| * setservent: (libc)Services Database. |
| * setsid: (libc)Process Group Functions. |
| * setsockopt: (libc)Socket Option Functions. |
| * setstate: (libc)BSD Random. |
| * setstate_r: (libc)BSD Random. |
| * settimeofday: (libc)High-Resolution Calendar. |
| * setuid: (libc)Setting User ID. |
| * setutent: (libc)Manipulating the Database. |
| * setutxent: (libc)XPG Functions. |
| * setvbuf: (libc)Controlling Buffering. |
| * shm_open: (libc)Memory-mapped I/O. |
| * shm_unlink: (libc)Memory-mapped I/O. |
| * shutdown: (libc)Closing a Socket. |
| * sigaction: (libc)Advanced Signal Handling. |
| * sigaddset: (libc)Signal Sets. |
| * sigaltstack: (libc)Signal Stack. |
| * sigblock: (libc)BSD Signal Handling. |
| * sigdelset: (libc)Signal Sets. |
| * sigemptyset: (libc)Signal Sets. |
| * sigfillset: (libc)Signal Sets. |
| * siginterrupt: (libc)BSD Signal Handling. |
| * sigismember: (libc)Signal Sets. |
| * siglongjmp: (libc)Non-Local Exits and Signals. |
| * sigmask: (libc)BSD Signal Handling. |
| * signal: (libc)Basic Signal Handling. |
| * signbit: (libc)FP Bit Twiddling. |
| * significand: (libc)Normalization Functions. |
| * significandf: (libc)Normalization Functions. |
| * significandl: (libc)Normalization Functions. |
| * sigpause: (libc)BSD Signal Handling. |
| * sigpending: (libc)Checking for Pending Signals. |
| * sigprocmask: (libc)Process Signal Mask. |
| * sigsetjmp: (libc)Non-Local Exits and Signals. |
| * sigsetmask: (libc)BSD Signal Handling. |
| * sigstack: (libc)Signal Stack. |
| * sigsuspend: (libc)Sigsuspend. |
| * sin: (libc)Trig Functions. |
| * sincos: (libc)Trig Functions. |
| * sincosf: (libc)Trig Functions. |
| * sincosfN: (libc)Trig Functions. |
| * sincosfNx: (libc)Trig Functions. |
| * sincosl: (libc)Trig Functions. |
| * sinf: (libc)Trig Functions. |
| * sinfN: (libc)Trig Functions. |
| * sinfNx: (libc)Trig Functions. |
| * sinh: (libc)Hyperbolic Functions. |
| * sinhf: (libc)Hyperbolic Functions. |
| * sinhfN: (libc)Hyperbolic Functions. |
| * sinhfNx: (libc)Hyperbolic Functions. |
| * sinhl: (libc)Hyperbolic Functions. |
| * sinl: (libc)Trig Functions. |
| * sleep: (libc)Sleeping. |
| * snprintf: (libc)Formatted Output Functions. |
| * socket: (libc)Creating a Socket. |
| * socketpair: (libc)Socket Pairs. |
| * sprintf: (libc)Formatted Output Functions. |
| * sqrt: (libc)Exponents and Logarithms. |
| * sqrtf: (libc)Exponents and Logarithms. |
| * sqrtfN: (libc)Exponents and Logarithms. |
| * sqrtfNx: (libc)Exponents and Logarithms. |
| * sqrtl: (libc)Exponents and Logarithms. |
| * srand48: (libc)SVID Random. |
| * srand48_r: (libc)SVID Random. |
| * srand: (libc)ISO Random. |
| * srandom: (libc)BSD Random. |
| * srandom_r: (libc)BSD Random. |
| * sscanf: (libc)Formatted Input Functions. |
| * ssignal: (libc)Basic Signal Handling. |
| * stat64: (libc)Reading Attributes. |
| * stat: (libc)Reading Attributes. |
| * stime: (libc)Simple Calendar Time. |
| * stpcpy: (libc)Copying Strings and Arrays. |
| * stpncpy: (libc)Truncating Strings. |
| * strcasecmp: (libc)String/Array Comparison. |
| * strcasestr: (libc)Search Functions. |
| * strcat: (libc)Concatenating Strings. |
| * strchr: (libc)Search Functions. |
| * strchrnul: (libc)Search Functions. |
| * strcmp: (libc)String/Array Comparison. |
| * strcoll: (libc)Collation Functions. |
| * strcpy: (libc)Copying Strings and Arrays. |
| * strcspn: (libc)Search Functions. |
| * strdup: (libc)Copying Strings and Arrays. |
| * strdupa: (libc)Copying Strings and Arrays. |
| * strerror: (libc)Error Messages. |
| * strerror_r: (libc)Error Messages. |
| * strfmon: (libc)Formatting Numbers. |
| * strfromd: (libc)Printing of Floats. |
| * strfromf: (libc)Printing of Floats. |
| * strfromfN: (libc)Printing of Floats. |
| * strfromfNx: (libc)Printing of Floats. |
| * strfroml: (libc)Printing of Floats. |
| * strfry: (libc)Shuffling Bytes. |
| * strftime: (libc)Formatting Calendar Time. |
| * strlen: (libc)String Length. |
| * strncasecmp: (libc)String/Array Comparison. |
| * strncat: (libc)Truncating Strings. |
| * strncmp: (libc)String/Array Comparison. |
| * strncpy: (libc)Truncating Strings. |
| * strndup: (libc)Truncating Strings. |
| * strndupa: (libc)Truncating Strings. |
| * strnlen: (libc)String Length. |
| * strpbrk: (libc)Search Functions. |
| * strptime: (libc)Low-Level Time String Parsing. |
| * strrchr: (libc)Search Functions. |
| * strsep: (libc)Finding Tokens in a String. |
| * strsignal: (libc)Signal Messages. |
| * strspn: (libc)Search Functions. |
| * strstr: (libc)Search Functions. |
| * strtod: (libc)Parsing of Floats. |
| * strtof: (libc)Parsing of Floats. |
| * strtofN: (libc)Parsing of Floats. |
| * strtofNx: (libc)Parsing of Floats. |
| * strtoimax: (libc)Parsing of Integers. |
| * strtok: (libc)Finding Tokens in a String. |
| * strtok_r: (libc)Finding Tokens in a String. |
| * strtol: (libc)Parsing of Integers. |
| * strtold: (libc)Parsing of Floats. |
| * strtoll: (libc)Parsing of Integers. |
| * strtoq: (libc)Parsing of Integers. |
| * strtoul: (libc)Parsing of Integers. |
| * strtoull: (libc)Parsing of Integers. |
| * strtoumax: (libc)Parsing of Integers. |
| * strtouq: (libc)Parsing of Integers. |
| * strverscmp: (libc)String/Array Comparison. |
| * strxfrm: (libc)Collation Functions. |
| * stty: (libc)BSD Terminal Modes. |
| * swapcontext: (libc)System V contexts. |
| * swprintf: (libc)Formatted Output Functions. |
| * swscanf: (libc)Formatted Input Functions. |
| * symlink: (libc)Symbolic Links. |
| * sync: (libc)Synchronizing I/O. |
| * syscall: (libc)System Calls. |
| * sysconf: (libc)Sysconf Definition. |
| * sysctl: (libc)System Parameters. |
| * syslog: (libc)syslog; vsyslog. |
| * system: (libc)Running a Command. |
| * sysv_signal: (libc)Basic Signal Handling. |
| * tan: (libc)Trig Functions. |
| * tanf: (libc)Trig Functions. |
| * tanfN: (libc)Trig Functions. |
| * tanfNx: (libc)Trig Functions. |
| * tanh: (libc)Hyperbolic Functions. |
| * tanhf: (libc)Hyperbolic Functions. |
| * tanhfN: (libc)Hyperbolic Functions. |
| * tanhfNx: (libc)Hyperbolic Functions. |
| * tanhl: (libc)Hyperbolic Functions. |
| * tanl: (libc)Trig Functions. |
| * tcdrain: (libc)Line Control. |
| * tcflow: (libc)Line Control. |
| * tcflush: (libc)Line Control. |
| * tcgetattr: (libc)Mode Functions. |
| * tcgetpgrp: (libc)Terminal Access Functions. |
| * tcgetsid: (libc)Terminal Access Functions. |
| * tcsendbreak: (libc)Line Control. |
| * tcsetattr: (libc)Mode Functions. |
| * tcsetpgrp: (libc)Terminal Access Functions. |
| * tdelete: (libc)Tree Search Function. |
| * tdestroy: (libc)Tree Search Function. |
| * telldir: (libc)Random Access Directory. |
| * tempnam: (libc)Temporary Files. |
| * textdomain: (libc)Locating gettext catalog. |
| * tfind: (libc)Tree Search Function. |
| * tgamma: (libc)Special Functions. |
| * tgammaf: (libc)Special Functions. |
| * tgammafN: (libc)Special Functions. |
| * tgammafNx: (libc)Special Functions. |
| * tgammal: (libc)Special Functions. |
| * tgkill: (libc)Signaling Another Process. |
| * thrd_create: (libc)ISO C Thread Management. |
| * thrd_current: (libc)ISO C Thread Management. |
| * thrd_detach: (libc)ISO C Thread Management. |
| * thrd_equal: (libc)ISO C Thread Management. |
| * thrd_exit: (libc)ISO C Thread Management. |
| * thrd_join: (libc)ISO C Thread Management. |
| * thrd_sleep: (libc)ISO C Thread Management. |
| * thrd_yield: (libc)ISO C Thread Management. |
| * time: (libc)Simple Calendar Time. |
| * timegm: (libc)Broken-down Time. |
| * timelocal: (libc)Broken-down Time. |
| * times: (libc)Processor Time. |
| * tmpfile64: (libc)Temporary Files. |
| * tmpfile: (libc)Temporary Files. |
| * tmpnam: (libc)Temporary Files. |
| * tmpnam_r: (libc)Temporary Files. |
| * toascii: (libc)Case Conversion. |
| * tolower: (libc)Case Conversion. |
| * totalorder: (libc)FP Comparison Functions. |
| * totalorderf: (libc)FP Comparison Functions. |
| * totalorderfN: (libc)FP Comparison Functions. |
| * totalorderfNx: (libc)FP Comparison Functions. |
| * totalorderl: (libc)FP Comparison Functions. |
| * totalordermag: (libc)FP Comparison Functions. |
| * totalordermagf: (libc)FP Comparison Functions. |
| * totalordermagfN: (libc)FP Comparison Functions. |
| * totalordermagfNx: (libc)FP Comparison Functions. |
| * totalordermagl: (libc)FP Comparison Functions. |
| * toupper: (libc)Case Conversion. |
| * towctrans: (libc)Wide Character Case Conversion. |
| * towlower: (libc)Wide Character Case Conversion. |
| * towupper: (libc)Wide Character Case Conversion. |
| * trunc: (libc)Rounding Functions. |
| * truncate64: (libc)File Size. |
| * truncate: (libc)File Size. |
| * truncf: (libc)Rounding Functions. |
| * truncfN: (libc)Rounding Functions. |
| * truncfNx: (libc)Rounding Functions. |
| * truncl: (libc)Rounding Functions. |
| * tsearch: (libc)Tree Search Function. |
| * tss_create: (libc)ISO C Thread-local Storage. |
| * tss_delete: (libc)ISO C Thread-local Storage. |
| * tss_get: (libc)ISO C Thread-local Storage. |
| * tss_set: (libc)ISO C Thread-local Storage. |
| * ttyname: (libc)Is It a Terminal. |
| * ttyname_r: (libc)Is It a Terminal. |
| * twalk: (libc)Tree Search Function. |
| * twalk_r: (libc)Tree Search Function. |
| * tzset: (libc)Time Zone Functions. |
| * ufromfp: (libc)Rounding Functions. |
| * ufromfpf: (libc)Rounding Functions. |
| * ufromfpfN: (libc)Rounding Functions. |
| * ufromfpfNx: (libc)Rounding Functions. |
| * ufromfpl: (libc)Rounding Functions. |
| * ufromfpx: (libc)Rounding Functions. |
| * ufromfpxf: (libc)Rounding Functions. |
| * ufromfpxfN: (libc)Rounding Functions. |
| * ufromfpxfNx: (libc)Rounding Functions. |
| * ufromfpxl: (libc)Rounding Functions. |
| * ulimit: (libc)Limits on Resources. |
| * umask: (libc)Setting Permissions. |
| * umount2: (libc)Mount-Unmount-Remount. |
| * umount: (libc)Mount-Unmount-Remount. |
| * uname: (libc)Platform Type. |
| * ungetc: (libc)How Unread. |
| * ungetwc: (libc)How Unread. |
| * unlink: (libc)Deleting Files. |
| * unlockpt: (libc)Allocation. |
| * unsetenv: (libc)Environment Access. |
| * updwtmp: (libc)Manipulating the Database. |
| * utime: (libc)File Times. |
| * utimes: (libc)File Times. |
| * utmpname: (libc)Manipulating the Database. |
| * utmpxname: (libc)XPG Functions. |
| * va_arg: (libc)Argument Macros. |
| * va_copy: (libc)Argument Macros. |
| * va_end: (libc)Argument Macros. |
| * va_start: (libc)Argument Macros. |
| * valloc: (libc)Aligned Memory Blocks. |
| * vasprintf: (libc)Variable Arguments Output. |
| * verr: (libc)Error Messages. |
| * verrx: (libc)Error Messages. |
| * versionsort64: (libc)Scanning Directory Content. |
| * versionsort: (libc)Scanning Directory Content. |
| * vfork: (libc)Creating a Process. |
| * vfprintf: (libc)Variable Arguments Output. |
| * vfscanf: (libc)Variable Arguments Input. |
| * vfwprintf: (libc)Variable Arguments Output. |
| * vfwscanf: (libc)Variable Arguments Input. |
| * vlimit: (libc)Limits on Resources. |
| * vprintf: (libc)Variable Arguments Output. |
| * vscanf: (libc)Variable Arguments Input. |
| * vsnprintf: (libc)Variable Arguments Output. |
| * vsprintf: (libc)Variable Arguments Output. |
| * vsscanf: (libc)Variable Arguments Input. |
| * vswprintf: (libc)Variable Arguments Output. |
| * vswscanf: (libc)Variable Arguments Input. |
| * vsyslog: (libc)syslog; vsyslog. |
| * vtimes: (libc)Resource Usage. |
| * vwarn: (libc)Error Messages. |
| * vwarnx: (libc)Error Messages. |
| * vwprintf: (libc)Variable Arguments Output. |
| * vwscanf: (libc)Variable Arguments Input. |
| * wait3: (libc)BSD Wait Functions. |
| * wait4: (libc)Process Completion. |
| * wait: (libc)Process Completion. |
| * waitpid: (libc)Process Completion. |
| * warn: (libc)Error Messages. |
| * warnx: (libc)Error Messages. |
| * wcpcpy: (libc)Copying Strings and Arrays. |
| * wcpncpy: (libc)Truncating Strings. |
| * wcrtomb: (libc)Converting a Character. |
| * wcscasecmp: (libc)String/Array Comparison. |
| * wcscat: (libc)Concatenating Strings. |
| * wcschr: (libc)Search Functions. |
| * wcschrnul: (libc)Search Functions. |
| * wcscmp: (libc)String/Array Comparison. |
| * wcscoll: (libc)Collation Functions. |
| * wcscpy: (libc)Copying Strings and Arrays. |
| * wcscspn: (libc)Search Functions. |
| * wcsdup: (libc)Copying Strings and Arrays. |
| * wcsftime: (libc)Formatting Calendar Time. |
| * wcslen: (libc)String Length. |
| * wcsncasecmp: (libc)String/Array Comparison. |
| * wcsncat: (libc)Truncating Strings. |
| * wcsncmp: (libc)String/Array Comparison. |
| * wcsncpy: (libc)Truncating Strings. |
| * wcsnlen: (libc)String Length. |
| * wcsnrtombs: (libc)Converting Strings. |
| * wcspbrk: (libc)Search Functions. |
| * wcsrchr: (libc)Search Functions. |
| * wcsrtombs: (libc)Converting Strings. |
| * wcsspn: (libc)Search Functions. |
| * wcsstr: (libc)Search Functions. |
| * wcstod: (libc)Parsing of Floats. |
| * wcstof: (libc)Parsing of Floats. |
| * wcstofN: (libc)Parsing of Floats. |
| * wcstofNx: (libc)Parsing of Floats. |
| * wcstoimax: (libc)Parsing of Integers. |
| * wcstok: (libc)Finding Tokens in a String. |
| * wcstol: (libc)Parsing of Integers. |
| * wcstold: (libc)Parsing of Floats. |
| * wcstoll: (libc)Parsing of Integers. |
| * wcstombs: (libc)Non-reentrant String Conversion. |
| * wcstoq: (libc)Parsing of Integers. |
| * wcstoul: (libc)Parsing of Integers. |
| * wcstoull: (libc)Parsing of Integers. |
| * wcstoumax: (libc)Parsing of Integers. |
| * wcstouq: (libc)Parsing of Integers. |
| * wcswcs: (libc)Search Functions. |
| * wcsxfrm: (libc)Collation Functions. |
| * wctob: (libc)Converting a Character. |
| * wctomb: (libc)Non-reentrant Character Conversion. |
| * wctrans: (libc)Wide Character Case Conversion. |
| * wctype: (libc)Classification of Wide Characters. |
| * wmemchr: (libc)Search Functions. |
| * wmemcmp: (libc)String/Array Comparison. |
| * wmemcpy: (libc)Copying Strings and Arrays. |
| * wmemmove: (libc)Copying Strings and Arrays. |
| * wmempcpy: (libc)Copying Strings and Arrays. |
| * wmemset: (libc)Copying Strings and Arrays. |
| * wordexp: (libc)Calling Wordexp. |
| * wordfree: (libc)Calling Wordexp. |
| * wprintf: (libc)Formatted Output Functions. |
| * write: (libc)I/O Primitives. |
| * writev: (libc)Scatter-Gather. |
| * wscanf: (libc)Formatted Input Functions. |
| * y0: (libc)Special Functions. |
| * y0f: (libc)Special Functions. |
| * y0fN: (libc)Special Functions. |
| * y0fNx: (libc)Special Functions. |
| * y0l: (libc)Special Functions. |
| * y1: (libc)Special Functions. |
| * y1f: (libc)Special Functions. |
| * y1fN: (libc)Special Functions. |
| * y1fNx: (libc)Special Functions. |
| * y1l: (libc)Special Functions. |
| * yn: (libc)Special Functions. |
| * ynf: (libc)Special Functions. |
| * ynfN: (libc)Special Functions. |
| * ynfNx: (libc)Special Functions. |
| * ynl: (libc)Special Functions. |
| END-INFO-DIR-ENTRY |
| |
| This file documents the GNU C Library. |
| |
| This is `The GNU C Library Reference Manual', for version 2.30 |
| (GNU Toolchain for the A-profile Architecture 9.2-2019.12 (arm-9.10)). |
| |
| Copyright (C) 1993-2019 Free Software Foundation, Inc. |
| |
| Permission is granted to copy, distribute and/or modify this document |
| under the terms of the GNU Free Documentation License, Version |
| 1.3 or any later version published by the Free Software Foundation; |
| with the Invariant Sections being "Free Software Needs Free |
| Documentation" and "GNU Lesser General Public License", the Front-Cover |
| texts being "A GNU Manual", and with the Back-Cover Texts as in (a) |
| below. A copy of the license is included in the section entitled "GNU |
| Free Documentation License". |
| |
| (a) The FSF's Back-Cover Text is: "You have the freedom to copy and |
| modify this GNU manual. Buying copies from the FSF supports it in |
| developing GNU and promoting software freedom." |
| |
| |
| File: libc.info, Node: Memory Allocation Tunables, Next: Elision Tunables, Prev: Tunable names, Up: Tunables |
| |
| 37.2 Memory Allocation Tunables |
| =============================== |
| |
| -- Tunable namespace: glibc.malloc |
| Memory allocation behavior can be modified by setting any of the |
| following tunables in the `malloc' namespace: |
| |
| -- Tunable: glibc.malloc.check |
| This tunable supersedes the `MALLOC_CHECK_' environment variable |
| and is identical in features. |
| |
| Setting this tunable to a non-zero value enables a special (less |
| efficient) memory allocator for the malloc family of functions |
| that is designed to be tolerant against simple errors such as |
| double calls of free with the same argument, or overruns of a |
| single byte (off-by-one bugs). Not all such errors can be |
| protected against, however, and memory leaks can result. Any |
| detected heap corruption results in immediate termination of the |
| process. |
| |
| Like `MALLOC_CHECK_', `glibc.malloc.check' has a problem in that it |
| diverges from normal program behavior by writing to `stderr', |
| which could by exploited in SUID and SGID binaries. Therefore, |
| `glibc.malloc.check' is disabled by default for SUID and SGID |
| binaries. This can be enabled again by the system administrator |
| by adding a file `/etc/suid-debug'; the content of the file could |
| be anything or even empty. |
| |
| -- Tunable: glibc.malloc.top_pad |
| This tunable supersedes the `MALLOC_TOP_PAD_' environment variable |
| and is identical in features. |
| |
| This tunable determines the amount of extra memory in bytes to |
| obtain from the system when any of the arenas need to be extended. |
| It also specifies the number of bytes to retain when shrinking any |
| of the arenas. This provides the necessary hysteresis in heap |
| size such that excessive amounts of system calls can be avoided. |
| |
| The default value of this tunable is `0'. |
| |
| -- Tunable: glibc.malloc.perturb |
| This tunable supersedes the `MALLOC_PERTURB_' environment variable |
| and is identical in features. |
| |
| If set to a non-zero value, memory blocks are initialized with |
| values depending on some low order bits of this tunable when they |
| are allocated (except when allocated by calloc) and freed. This |
| can be used to debug the use of uninitialized or freed heap |
| memory. Note that this option does not guarantee that the freed |
| block will have any specific values. It only guarantees that the |
| content the block had before it was freed will be overwritten. |
| |
| The default value of this tunable is `0'. |
| |
| -- Tunable: glibc.malloc.mmap_threshold |
| This tunable supersedes the `MALLOC_MMAP_THRESHOLD_' environment |
| variable and is identical in features. |
| |
| When this tunable is set, all chunks larger than this value in |
| bytes are allocated outside the normal heap, using the `mmap' |
| system call. This way it is guaranteed that the memory for these |
| chunks can be returned to the system on `free'. Note that requests |
| smaller than this threshold might still be allocated via `mmap'. |
| |
| If this tunable is not set, the default value is set to `131072' |
| bytes and the threshold is adjusted dynamically to suit the |
| allocation patterns of the program. If the tunable is set, the |
| dynamic adjustment is disabled and the value is set as static. |
| |
| -- Tunable: glibc.malloc.trim_threshold |
| This tunable supersedes the `MALLOC_TRIM_THRESHOLD_' environment |
| variable and is identical in features. |
| |
| The value of this tunable is the minimum size (in bytes) of the |
| top-most, releasable chunk in an arena that will trigger a system |
| call in order to return memory to the system from that arena. |
| |
| If this tunable is not set, the default value is set as 128 KB and |
| the threshold is adjusted dynamically to suit the allocation |
| patterns of the program. If the tunable is set, the dynamic |
| adjustment is disabled and the value is set as static. |
| |
| -- Tunable: glibc.malloc.mmap_max |
| This tunable supersedes the `MALLOC_MMAP_MAX_' environment |
| variable and is identical in features. |
| |
| The value of this tunable is maximum number of chunks to allocate |
| with `mmap'. Setting this to zero disables all use of `mmap'. |
| |
| The default value of this tunable is `65536'. |
| |
| -- Tunable: glibc.malloc.arena_test |
| This tunable supersedes the `MALLOC_ARENA_TEST' environment |
| variable and is identical in features. |
| |
| The `glibc.malloc.arena_test' tunable specifies the number of |
| arenas that can be created before the test on the limit to the |
| number of arenas is conducted. The value is ignored if |
| `glibc.malloc.arena_max' is set. |
| |
| The default value of this tunable is 2 for 32-bit systems and 8 |
| for 64-bit systems. |
| |
| -- Tunable: glibc.malloc.arena_max |
| This tunable supersedes the `MALLOC_ARENA_MAX' environment |
| variable and is identical in features. |
| |
| This tunable sets the number of arenas to use in a process |
| regardless of the number of cores in the system. |
| |
| The default value of this tunable is `0', meaning that the limit |
| on the number of arenas is determined by the number of CPU cores |
| online. For 32-bit systems the limit is twice the number of cores |
| online and on 64-bit systems, it is 8 times the number of cores |
| online. |
| |
| -- Tunable: glibc.malloc.tcache_max |
| The maximum size of a request (in bytes) which may be met via the |
| per-thread cache. The default (and maximum) value is 1032 bytes on |
| 64-bit systems and 516 bytes on 32-bit systems. |
| |
| -- Tunable: glibc.malloc.tcache_count |
| The maximum number of chunks of each size to cache. The default is |
| 7. The upper limit is 65535. If set to zero, the per-thread |
| cache is effectively disabled. |
| |
| The approximate maximum overhead of the per-thread cache is thus |
| equal to the number of bins times the chunk count in each bin |
| times the size of each chunk. With defaults, the approximate |
| maximum overhead of the per-thread cache is approximately 236 KB |
| on 64-bit systems and 118 KB on 32-bit systems. |
| |
| -- Tunable: glibc.malloc.tcache_unsorted_limit |
| When the user requests memory and the request cannot be met via the |
| per-thread cache, the arenas are used to meet the request. At this |
| time, additional chunks will be moved from existing arena lists to |
| pre-fill the corresponding cache. While copies from the fastbins, |
| smallbins, and regular bins are bounded and predictable due to the |
| bin sizes, copies from the unsorted bin are not bounded, and incur |
| additional time penalties as they need to be sorted as they're |
| scanned. To make scanning the unsorted list more predictable and |
| bounded, the user may set this tunable to limit the number of |
| chunks that are scanned from the unsorted list while searching for |
| chunks to pre-fill the per-thread cache with. The default, or |
| when set to zero, is no limit. |
| |
| -- Tunable: glibc.malloc.mxfast |
| One of the optimizations malloc uses is to maintain a series of |
| "fast bins" that hold chunks up to a specific size. The default |
| and maximum size which may be held this way is 80 bytes on 32-bit |
| systems or 160 bytes on 64-bit systems. Applications which value |
| size over speed may choose to reduce the size of requests which |
| are serviced from fast bins with this tunable. Note that the |
| value specified includes malloc's internal overhead, which is |
| normally the size of one pointer, so add 4 on 32-bit systems or 8 |
| on 64-bit systems to the size passed to `malloc' for the largest |
| bin size to enable. |
| |
| |
| File: libc.info, Node: Elision Tunables, Next: POSIX Thread Tunables, Prev: Memory Allocation Tunables, Up: Tunables |
| |
| 37.3 Elision Tunables |
| ===================== |
| |
| -- Tunable namespace: glibc.elision |
| Contended locks are usually slow and can lead to performance and |
| scalability issues in multithread code. Lock elision will use |
| memory transactions to under certain conditions, to elide locks |
| and improve performance. Elision behavior can be modified by |
| setting the following tunables in the `elision' namespace: |
| |
| -- Tunable: glibc.elision.enable |
| The `glibc.elision.enable' tunable enables lock elision if the |
| feature is supported by the hardware. If elision is not supported |
| by the hardware this tunable has no effect. |
| |
| Elision tunables are supported for 64-bit Intel, IBM POWER, and z |
| System architectures. |
| |
| -- Tunable: glibc.elision.skip_lock_busy |
| The `glibc.elision.skip_lock_busy' tunable sets how many times to |
| use a non-transactional lock after a transactional failure has |
| occurred because the lock is already acquired. Expressed in |
| number of lock acquisition attempts. |
| |
| The default value of this tunable is `3'. |
| |
| -- Tunable: glibc.elision.skip_lock_internal_abort |
| The `glibc.elision.skip_lock_internal_abort' tunable sets how many |
| times the thread should avoid using elision if a transaction |
| aborted for any reason other than a different thread's memory |
| accesses. Expressed in number of lock acquisition attempts. |
| |
| The default value of this tunable is `3'. |
| |
| -- Tunable: glibc.elision.skip_lock_after_retries |
| The `glibc.elision.skip_lock_after_retries' tunable sets how many |
| times to try to elide a lock with transactions, that only failed |
| due to a different thread's memory accesses, before falling back |
| to regular lock. Expressed in number of lock elision attempts. |
| |
| This tunable is supported only on IBM POWER, and z System |
| architectures. |
| |
| The default value of this tunable is `3'. |
| |
| -- Tunable: glibc.elision.tries |
| The `glibc.elision.tries' sets how many times to retry elision if |
| there is chance for the transaction to finish execution e.g., it |
| wasn't aborted due to the lock being already acquired. If elision |
| is not supported by the hardware this tunable is set to `0' to |
| avoid retries. |
| |
| The default value of this tunable is `3'. |
| |
| -- Tunable: glibc.elision.skip_trylock_internal_abort |
| The `glibc.elision.skip_trylock_internal_abort' tunable sets how |
| many times the thread should avoid trying the lock if a |
| transaction aborted due to reasons other than a different thread's |
| memory accesses. Expressed in number of try lock attempts. |
| |
| The default value of this tunable is `3'. |
| |
| |
| File: libc.info, Node: POSIX Thread Tunables, Next: Hardware Capability Tunables, Prev: Elision Tunables, Up: Tunables |
| |
| 37.4 POSIX Thread Tunables |
| ========================== |
| |
| -- Tunable namespace: glibc.pthread |
| The behavior of POSIX threads can be tuned to gain performance |
| improvements according to specific hardware capabilities and |
| workload characteristics by setting the following tunables in the |
| `pthread' namespace: |
| |
| -- Tunable: glibc.pthread.mutex_spin_count |
| The `glibc.pthread.mutex_spin_count' tunable sets the maximum |
| number of times a thread should spin on the lock before calling |
| into the kernel to block. Adaptive spin is used for mutexes |
| initialized with the `PTHREAD_MUTEX_ADAPTIVE_NP' GNU extension. |
| It affects both `pthread_mutex_lock' and `pthread_mutex_timedlock'. |
| |
| The thread spins until either the maximum spin count is reached or |
| the lock is acquired. |
| |
| The default value of this tunable is `100'. |
| |
| |
| File: libc.info, Node: Hardware Capability Tunables, Prev: POSIX Thread Tunables, Up: Tunables |
| |
| 37.5 Hardware Capability Tunables |
| ================================= |
| |
| -- Tunable namespace: glibc.cpu |
| Behavior of the GNU C Library can be tuned to assume specific |
| hardware capabilities by setting the following tunables in the |
| `cpu' namespace: |
| |
| -- Tunable: glibc.cpu.hwcap_mask |
| This tunable supersedes the `LD_HWCAP_MASK' environment variable |
| and is identical in features. |
| |
| The `AT_HWCAP' key in the Auxiliary Vector specifies instruction |
| set extensions available in the processor at runtime for some |
| architectures. The `glibc.cpu.hwcap_mask' tunable allows the user |
| to mask out those capabilities at runtime, thus disabling use of |
| those extensions. |
| |
| -- Tunable: glibc.cpu.hwcaps |
| The `glibc.cpu.hwcaps=-xxx,yyy,-zzz...' tunable allows the user to |
| enable CPU/ARCH feature `yyy', disable CPU/ARCH feature `xxx' and |
| `zzz' where the feature name is case-sensitive and has to match |
| the ones in `sysdeps/x86/cpu-features.h'. |
| |
| This tunable is specific to i386 and x86-64. |
| |
| -- Tunable: glibc.cpu.cached_memopt |
| The `glibc.cpu.cached_memopt=[0|1]' tunable allows the user to |
| enable optimizations recommended for cacheable memory. If set to |
| `1', the GNU C Library assumes that the process memory image |
| consists of cacheable (non-device) memory only. The default, `0', |
| indicates that the process may use device memory. |
| |
| This tunable is specific to powerpc, powerpc64 and powerpc64le. |
| |
| -- Tunable: glibc.cpu.name |
| The `glibc.cpu.name=xxx' tunable allows the user to tell the GNU C |
| Library to assume that the CPU is `xxx' where xxx may have one of |
| these values: `generic', `falkor', `thunderxt88', `thunderx2t99', |
| `thunderx2t99p1', `ares', `emag'. |
| |
| This tunable is specific to aarch64. |
| |
| -- Tunable: glibc.cpu.x86_data_cache_size |
| The `glibc.cpu.x86_data_cache_size' tunable allows the user to set |
| data cache size in bytes for use in memory and string routines. |
| |
| This tunable is specific to i386 and x86-64. |
| |
| -- Tunable: glibc.cpu.x86_shared_cache_size |
| The `glibc.cpu.x86_shared_cache_size' tunable allows the user to |
| set shared cache size in bytes for use in memory and string |
| routines. |
| |
| -- Tunable: glibc.cpu.x86_non_temporal_threshold |
| The `glibc.cpu.x86_non_temporal_threshold' tunable allows the user |
| to set threshold in bytes for non temporal store. |
| |
| This tunable is specific to i386 and x86-64. |
| |
| -- Tunable: glibc.cpu.x86_ibt |
| The `glibc.cpu.x86_ibt' tunable allows the user to control how |
| indirect branch tracking (IBT) should be enabled. Accepted values |
| are `on', `off', and `permissive'. `on' always turns on IBT |
| regardless of whether IBT is enabled in the executable and its |
| dependent shared libraries. `off' always turns off IBT regardless |
| of whether IBT is enabled in the executable and its dependent |
| shared libraries. `permissive' is the same as the default which |
| disables IBT on non-CET executables and shared libraries. |
| |
| This tunable is specific to i386 and x86-64. |
| |
| -- Tunable: glibc.cpu.x86_shstk |
| The `glibc.cpu.x86_shstk' tunable allows the user to control how |
| the shadow stack (SHSTK) should be enabled. Accepted values are |
| `on', `off', and `permissive'. `on' always turns on SHSTK |
| regardless of whether SHSTK is enabled in the executable and its |
| dependent shared libraries. `off' always turns off SHSTK |
| regardless of whether SHSTK is enabled in the executable and its |
| dependent shared libraries. `permissive' changes how dlopen works |
| on non-CET shared libraries. By default, when SHSTK is enabled, |
| dlopening a non-CET shared library returns an error. With |
| `permissive', it turns off SHSTK instead. |
| |
| This tunable is specific to i386 and x86-64. |
| |
| |
| File: libc.info, Node: Language Features, Next: Library Summary, Prev: Tunables, Up: Top |
| |
| Appendix A C Language Facilities in the Library |
| *********************************************** |
| |
| Some of the facilities implemented by the C library really should be |
| thought of as parts of the C language itself. These facilities ought to |
| be documented in the C Language Manual, not in the library manual; but |
| since we don't have the language manual yet, and documentation for these |
| features has been written, we are publishing it here. |
| |
| * Menu: |
| |
| * Consistency Checking:: Using `assert' to abort if |
| something ``impossible'' happens. |
| * Variadic Functions:: Defining functions with varying numbers |
| of args. |
| * Null Pointer Constant:: The macro `NULL'. |
| * Important Data Types:: Data types for object sizes. |
| * Data Type Measurements:: Parameters of data type representations. |
| |
| |
| File: libc.info, Node: Consistency Checking, Next: Variadic Functions, Up: Language Features |
| |
| A.1 Explicitly Checking Internal Consistency |
| ============================================ |
| |
| When you're writing a program, it's often a good idea to put in checks |
| at strategic places for "impossible" errors or violations of basic |
| assumptions. These kinds of checks are helpful in debugging problems |
| with the interfaces between different parts of the program, for example. |
| |
| The `assert' macro, defined in the header file `assert.h', provides |
| a convenient way to abort the program while printing a message about |
| where in the program the error was detected. |
| |
| Once you think your program is debugged, you can disable the error |
| checks performed by the `assert' macro by recompiling with the macro |
| `NDEBUG' defined. This means you don't actually have to change the |
| program source code to disable these checks. |
| |
| But disabling these consistency checks is undesirable unless they |
| make the program significantly slower. All else being equal, more error |
| checking is good no matter who is running the program. A wise user |
| would rather have a program crash, visibly, than have it return nonsense |
| without indicating anything might be wrong. |
| |
| -- Macro: void assert (int EXPRESSION) |
| Preliminary: | MT-Safe | AS-Unsafe heap corrupt | AC-Unsafe mem |
| lock corrupt | *Note POSIX Safety Concepts::. |
| |
| Verify the programmer's belief that EXPRESSION is nonzero at this |
| point in the program. |
| |
| If `NDEBUG' is not defined, `assert' tests the value of |
| EXPRESSION. If it is false (zero), `assert' aborts the program |
| (*note Aborting a Program::) after printing a message of the form: |
| |
| `FILE':LINENUM: FUNCTION: Assertion `EXPRESSION' failed. |
| |
| on the standard error stream `stderr' (*note Standard Streams::). |
| The filename and line number are taken from the C preprocessor |
| macros `__FILE__' and `__LINE__' and specify where the call to |
| `assert' was made. When using the GNU C compiler, the name of the |
| function which calls `assert' is taken from the built-in variable |
| `__PRETTY_FUNCTION__'; with older compilers, the function name and |
| following colon are omitted. |
| |
| If the preprocessor macro `NDEBUG' is defined before `assert.h' is |
| included, the `assert' macro is defined to do absolutely nothing. |
| |
| *Warning:* Even the argument expression EXPRESSION is not |
| evaluated if `NDEBUG' is in effect. So never use `assert' with |
| arguments that involve side effects. For example, `assert (++i > |
| 0);' is a bad idea, because `i' will not be incremented if |
| `NDEBUG' is defined. |
| |
| Sometimes the "impossible" condition you want to check for is an |
| error return from an operating system function. Then it is useful to |
| display not only where the program crashes, but also what error was |
| returned. The `assert_perror' macro makes this easy. |
| |
| -- Macro: void assert_perror (int ERRNUM) |
| Preliminary: | MT-Safe | AS-Unsafe heap corrupt | AC-Unsafe mem |
| lock corrupt | *Note POSIX Safety Concepts::. |
| |
| Similar to `assert', but verifies that ERRNUM is zero. |
| |
| If `NDEBUG' is not defined, `assert_perror' tests the value of |
| ERRNUM. If it is nonzero, `assert_perror' aborts the program |
| after printing a message of the form: |
| |
| `FILE':LINENUM: FUNCTION: ERROR TEXT |
| |
| on the standard error stream. The file name, line number, and |
| function name are as for `assert'. The error text is the result of |
| `strerror (ERRNUM)'. *Note Error Messages::. |
| |
| Like `assert', if `NDEBUG' is defined before `assert.h' is |
| included, the `assert_perror' macro does absolutely nothing. It |
| does not evaluate the argument, so ERRNUM should not have any side |
| effects. It is best for ERRNUM to be just a simple variable |
| reference; often it will be `errno'. |
| |
| This macro is a GNU extension. |
| |
| *Usage note:* The `assert' facility is designed for detecting |
| _internal inconsistency_; it is not suitable for reporting invalid |
| input or improper usage by the _user_ of the program. |
| |
| The information in the diagnostic messages printed by the `assert' |
| and `assert_perror' macro is intended to help you, the programmer, |
| track down the cause of a bug, but is not really useful for telling a |
| user of your program why his or her input was invalid or why a command |
| could not be carried out. What's more, your program should not abort |
| when given invalid input, as `assert' would do--it should exit with |
| nonzero status (*note Exit Status::) after printing its error messages, |
| or perhaps read another command or move on to the next input file. |
| |
| *Note Error Messages::, for information on printing error messages |
| for problems that _do not_ represent bugs in the program. |
| |
| |
| File: libc.info, Node: Variadic Functions, Next: Null Pointer Constant, Prev: Consistency Checking, Up: Language Features |
| |
| A.2 Variadic Functions |
| ====================== |
| |
| ISO C defines a syntax for declaring a function to take a variable |
| number or type of arguments. (Such functions are referred to as |
| "varargs functions" or "variadic functions".) However, the language |
| itself provides no mechanism for such functions to access their |
| non-required arguments; instead, you use the variable arguments macros |
| defined in `stdarg.h'. |
| |
| This section describes how to declare variadic functions, how to |
| write them, and how to call them properly. |
| |
| *Compatibility Note:* Many older C dialects provide a similar, but |
| incompatible, mechanism for defining functions with variable numbers of |
| arguments, using `varargs.h'. |
| |
| * Menu: |
| |
| * Why Variadic:: Reasons for making functions take |
| variable arguments. |
| * How Variadic:: How to define and call variadic functions. |
| * Variadic Example:: A complete example. |
| |
| |
| File: libc.info, Node: Why Variadic, Next: How Variadic, Up: Variadic Functions |
| |
| A.2.1 Why Variadic Functions are Used |
| ------------------------------------- |
| |
| Ordinary C functions take a fixed number of arguments. When you define |
| a function, you specify the data type for each argument. Every call to |
| the function should supply the expected number of arguments, with types |
| that can be converted to the specified ones. Thus, if the function |
| `foo' is declared with `int foo (int, char *);' then you must call it |
| with two arguments, a number (any kind will do) and a string pointer. |
| |
| But some functions perform operations that can meaningfully accept an |
| unlimited number of arguments. |
| |
| In some cases a function can handle any number of values by |
| operating on all of them as a block. For example, consider a function |
| that allocates a one-dimensional array with `malloc' to hold a |
| specified set of values. This operation makes sense for any number of |
| values, as long as the length of the array corresponds to that number. |
| Without facilities for variable arguments, you would have to define a |
| separate function for each possible array size. |
| |
| The library function `printf' (*note Formatted Output::) is an |
| example of another class of function where variable arguments are |
| useful. This function prints its arguments (which can vary in type as |
| well as number) under the control of a format template string. |
| |
| These are good reasons to define a "variadic" function which can |
| handle as many arguments as the caller chooses to pass. |
| |
| Some functions such as `open' take a fixed set of arguments, but |
| occasionally ignore the last few. Strict adherence to ISO C requires |
| these functions to be defined as variadic; in practice, however, the GNU |
| C compiler and most other C compilers let you define such a function to |
| take a fixed set of arguments--the most it can ever use--and then only |
| _declare_ the function as variadic (or not declare its arguments at |
| all!). |
| |
| |
| File: libc.info, Node: How Variadic, Next: Variadic Example, Prev: Why Variadic, Up: Variadic Functions |
| |
| A.2.2 How Variadic Functions are Defined and Used |
| ------------------------------------------------- |
| |
| Defining and using a variadic function involves three steps: |
| |
| * _Define_ the function as variadic, using an ellipsis (`...') in |
| the argument list, and using special macros to access the variable |
| arguments. *Note Receiving Arguments::. |
| |
| * _Declare_ the function as variadic, using a prototype with an |
| ellipsis (`...'), in all the files which call it. *Note Variadic |
| Prototypes::. |
| |
| * _Call_ the function by writing the fixed arguments followed by the |
| additional variable arguments. *Note Calling Variadics::. |
| |
| * Menu: |
| |
| * Variadic Prototypes:: How to make a prototype for a function |
| with variable arguments. |
| * Receiving Arguments:: Steps you must follow to access the |
| optional argument values. |
| * How Many Arguments:: How to decide whether there are more arguments. |
| * Calling Variadics:: Things you need to know about calling |
| variable arguments functions. |
| * Argument Macros:: Detailed specification of the macros |
| for accessing variable arguments. |
| |
| |
| File: libc.info, Node: Variadic Prototypes, Next: Receiving Arguments, Up: How Variadic |
| |
| A.2.2.1 Syntax for Variable Arguments |
| ..................................... |
| |
| A function that accepts a variable number of arguments must be declared |
| with a prototype that says so. You write the fixed arguments as usual, |
| and then tack on `...' to indicate the possibility of additional |
| arguments. The syntax of ISO C requires at least one fixed argument |
| before the `...'. For example, |
| |
| int |
| func (const char *a, int b, ...) |
| { |
| ... |
| } |
| |
| defines a function `func' which returns an `int' and takes two required |
| arguments, a `const char *' and an `int'. These are followed by any |
| number of anonymous arguments. |
| |
| *Portability note:* For some C compilers, the last required argument |
| must not be declared `register' in the function definition. |
| Furthermore, this argument's type must be "self-promoting": that is, |
| the default promotions must not change its type. This rules out array |
| and function types, as well as `float', `char' (whether signed or not) |
| and `short int' (whether signed or not). This is actually an ISO C |
| requirement. |
| |
| |
| File: libc.info, Node: Receiving Arguments, Next: How Many Arguments, Prev: Variadic Prototypes, Up: How Variadic |
| |
| A.2.2.2 Receiving the Argument Values |
| ..................................... |
| |
| Ordinary fixed arguments have individual names, and you can use these |
| names to access their values. But optional arguments have no |
| names--nothing but `...'. How can you access them? |
| |
| The only way to access them is sequentially, in the order they were |
| written, and you must use special macros from `stdarg.h' in the |
| following three step process: |
| |
| 1. You initialize an argument pointer variable of type `va_list' using |
| `va_start'. The argument pointer when initialized points to the |
| first optional argument. |
| |
| 2. You access the optional arguments by successive calls to `va_arg'. |
| The first call to `va_arg' gives you the first optional argument, |
| the next call gives you the second, and so on. |
| |
| You can stop at any time if you wish to ignore any remaining |
| optional arguments. It is perfectly all right for a function to |
| access fewer arguments than were supplied in the call, but you |
| will get garbage values if you try to access too many arguments. |
| |
| 3. You indicate that you are finished with the argument pointer |
| variable by calling `va_end'. |
| |
| (In practice, with most C compilers, calling `va_end' does nothing. |
| This is always true in the GNU C compiler. But you might as well |
| call `va_end' just in case your program is someday compiled with a |
| peculiar compiler.) |
| |
| *Note Argument Macros::, for the full definitions of `va_start', |
| `va_arg' and `va_end'. |
| |
| Steps 1 and 3 must be performed in the function that accepts the |
| optional arguments. However, you can pass the `va_list' variable as an |
| argument to another function and perform all or part of step 2 there. |
| |
| You can perform the entire sequence of three steps multiple times |
| within a single function invocation. If you want to ignore the optional |
| arguments, you can do these steps zero times. |
| |
| You can have more than one argument pointer variable if you like. |
| You can initialize each variable with `va_start' when you wish, and |
| then you can fetch arguments with each argument pointer as you wish. |
| Each argument pointer variable will sequence through the same set of |
| argument values, but at its own pace. |
| |
| *Portability note:* With some compilers, once you pass an argument |
| pointer value to a subroutine, you must not keep using the same |
| argument pointer value after that subroutine returns. For full |
| portability, you should just pass it to `va_end'. This is actually an |
| ISO C requirement, but most ANSI C compilers work happily regardless. |
| |
| |
| File: libc.info, Node: How Many Arguments, Next: Calling Variadics, Prev: Receiving Arguments, Up: How Variadic |
| |
| A.2.2.3 How Many Arguments Were Supplied |
| ........................................ |
| |
| There is no general way for a function to determine the number and type |
| of the optional arguments it was called with. So whoever designs the |
| function typically designs a convention for the caller to specify the |
| number and type of arguments. It is up to you to define an appropriate |
| calling convention for each variadic function, and write all calls |
| accordingly. |
| |
| One kind of calling convention is to pass the number of optional |
| arguments as one of the fixed arguments. This convention works provided |
| all of the optional arguments are of the same type. |
| |
| A similar alternative is to have one of the required arguments be a |
| bit mask, with a bit for each possible purpose for which an optional |
| argument might be supplied. You would test the bits in a predefined |
| sequence; if the bit is set, fetch the value of the next argument, |
| otherwise use a default value. |
| |
| A required argument can be used as a pattern to specify both the |
| number and types of the optional arguments. The format string argument |
| to `printf' is one example of this (*note Formatted Output Functions::). |
| |
| Another possibility is to pass an "end marker" value as the last |
| optional argument. For example, for a function that manipulates an |
| arbitrary number of pointer arguments, a null pointer might indicate the |
| end of the argument list. (This assumes that a null pointer isn't |
| otherwise meaningful to the function.) The `execl' function works in |
| just this way; see *note Executing a File::. |
| |
| |
| File: libc.info, Node: Calling Variadics, Next: Argument Macros, Prev: How Many Arguments, Up: How Variadic |
| |
| A.2.2.4 Calling Variadic Functions |
| .................................. |
| |
| You don't have to do anything special to call a variadic function. |
| Just put the arguments (required arguments, followed by optional ones) |
| inside parentheses, separated by commas, as usual. But you must declare |
| the function with a prototype and know how the argument values are |
| converted. |
| |
| In principle, functions that are _defined_ to be variadic must also |
| be _declared_ to be variadic using a function prototype whenever you |
| call them. (*Note Variadic Prototypes::, for how.) This is because |
| some C compilers use a different calling convention to pass the same set |
| of argument values to a function depending on whether that function |
| takes variable arguments or fixed arguments. |
| |
| In practice, the GNU C compiler always passes a given set of argument |
| types in the same way regardless of whether they are optional or |
| required. So, as long as the argument types are self-promoting, you can |
| safely omit declaring them. Usually it is a good idea to declare the |
| argument types for variadic functions, and indeed for all functions. |
| But there are a few functions which it is extremely convenient not to |
| have to declare as variadic--for example, `open' and `printf'. |
| |
| Since the prototype doesn't specify types for optional arguments, in |
| a call to a variadic function the "default argument promotions" are |
| performed on the optional argument values. This means the objects of |
| type `char' or `short int' (whether signed or not) are promoted to |
| either `int' or `unsigned int', as appropriate; and that objects of |
| type `float' are promoted to type `double'. So, if the caller passes a |
| `char' as an optional argument, it is promoted to an `int', and the |
| function can access it with `va_arg (AP, int)'. |
| |
| Conversion of the required arguments is controlled by the function |
| prototype in the usual way: the argument expression is converted to the |
| declared argument type as if it were being assigned to a variable of |
| that type. |
| |
| |
| File: libc.info, Node: Argument Macros, Prev: Calling Variadics, Up: How Variadic |
| |
| A.2.2.5 Argument Access Macros |
| .............................. |
| |
| Here are descriptions of the macros used to retrieve variable arguments. |
| These macros are defined in the header file `stdarg.h'. |
| |
| -- Data Type: va_list |
| The type `va_list' is used for argument pointer variables. |
| |
| -- Macro: void va_start (va_list AP, LAST-REQUIRED) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This macro initializes the argument pointer variable AP to point |
| to the first of the optional arguments of the current function; |
| LAST-REQUIRED must be the last required argument to the function. |
| |
| -- Macro: TYPE va_arg (va_list AP, TYPE) |
| Preliminary: | MT-Safe race:ap | AS-Safe | AC-Unsafe corrupt | |
| *Note POSIX Safety Concepts::. |
| |
| The `va_arg' macro returns the value of the next optional argument, |
| and modifies the value of AP to point to the subsequent argument. |
| Thus, successive uses of `va_arg' return successive optional |
| arguments. |
| |
| The type of the value returned by `va_arg' is TYPE as specified in |
| the call. TYPE must be a self-promoting type (not `char' or |
| `short int' or `float') that matches the type of the actual |
| argument. |
| |
| -- Macro: void va_end (va_list AP) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This ends the use of AP. After a `va_end' call, further `va_arg' |
| calls with the same AP may not work. You should invoke `va_end' |
| before returning from the function in which `va_start' was invoked |
| with the same AP argument. |
| |
| In the GNU C Library, `va_end' does nothing, and you need not ever |
| use it except for reasons of portability. |
| |
| |
| Sometimes it is necessary to parse the list of parameters more than |
| once or one wants to remember a certain position in the parameter list. |
| To do this, one will have to make a copy of the current value of the |
| argument. But `va_list' is an opaque type and one cannot necessarily |
| assign the value of one variable of type `va_list' to another variable |
| of the same type. |
| |
| -- Macro: void va_copy (va_list DEST, va_list SRC) |
| -- Macro: void __va_copy (va_list DEST, va_list SRC) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The `va_copy' macro allows copying of objects of type `va_list' |
| even if this is not an integral type. The argument pointer in |
| DEST is initialized to point to the same argument as the pointer |
| in SRC. |
| |
| `va_copy' was added in ISO C99. When building for strict |
| conformance to ISO C90 (`gcc -std=c90'), it is not available. GCC |
| provides `__va_copy', as an extension, in any standards mode; |
| before GCC 3.0, it was the only macro for this functionality. |
| |
| These macros are no longer provided by the GNU C Library, but |
| rather by the compiler. |
| |
| If you want to use `va_copy' and be portable to pre-C99 systems, you |
| should always be prepared for the possibility that this macro will not |
| be available. On architectures where a simple assignment is invalid, |
| hopefully `va_copy' _will_ be available, so one should always write |
| something like this if concerned about pre-C99 portability: |
| |
| { |
| va_list ap, save; |
| ... |
| #ifdef va_copy |
| va_copy (save, ap); |
| #else |
| save = ap; |
| #endif |
| ... |
| } |
| |
| |
| File: libc.info, Node: Variadic Example, Prev: How Variadic, Up: Variadic Functions |
| |
| A.2.3 Example of a Variadic Function |
| ------------------------------------ |
| |
| Here is a complete sample function that accepts a variable number of |
| arguments. The first argument to the function is the count of remaining |
| arguments, which are added up and the result returned. While trivial, |
| this function is sufficient to illustrate how to use the variable |
| arguments facility. |
| |
| |
| #include <stdarg.h> |
| #include <stdio.h> |
| |
| int |
| add_em_up (int count,...) |
| { |
| va_list ap; |
| int i, sum; |
| |
| va_start (ap, count); /* Initialize the argument list. */ |
| |
| sum = 0; |
| for (i = 0; i < count; i++) |
| sum += va_arg (ap, int); /* Get the next argument value. */ |
| |
| va_end (ap); /* Clean up. */ |
| return sum; |
| } |
| |
| int |
| main (void) |
| { |
| /* This call prints 16. */ |
| printf ("%d\n", add_em_up (3, 5, 5, 6)); |
| |
| /* This call prints 55. */ |
| printf ("%d\n", add_em_up (10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)); |
| |
| return 0; |
| } |
| |
| |
| File: libc.info, Node: Null Pointer Constant, Next: Important Data Types, Prev: Variadic Functions, Up: Language Features |
| |
| A.3 Null Pointer Constant |
| ========================= |
| |
| The null pointer constant is guaranteed not to point to any real object. |
| You can assign it to any pointer variable since it has type `void *'. |
| The preferred way to write a null pointer constant is with `NULL'. |
| |
| -- Macro: void * NULL |
| This is a null pointer constant. |
| |
| You can also use `0' or `(void *)0' as a null pointer constant, but |
| using `NULL' is cleaner because it makes the purpose of the constant |
| more evident. |
| |
| If you use the null pointer constant as a function argument, then for |
| complete portability you should make sure that the function has a |
| prototype declaration. Otherwise, if the target machine has two |
| different pointer representations, the compiler won't know which |
| representation to use for that argument. You can avoid the problem by |
| explicitly casting the constant to the proper pointer type, but we |
| recommend instead adding a prototype for the function you are calling. |
| |
| |
| File: libc.info, Node: Important Data Types, Next: Data Type Measurements, Prev: Null Pointer Constant, Up: Language Features |
| |
| A.4 Important Data Types |
| ======================== |
| |
| The result of subtracting two pointers in C is always an integer, but |
| the precise data type varies from C compiler to C compiler. Likewise, |
| the data type of the result of `sizeof' also varies between compilers. |
| ISO C defines standard aliases for these two types, so you can refer to |
| them in a portable fashion. They are defined in the header file |
| `stddef.h'. |
| |
| -- Data Type: ptrdiff_t |
| This is the signed integer type of the result of subtracting two |
| pointers. For example, with the declaration `char *p1, *p2;', the |
| expression `p2 - p1' is of type `ptrdiff_t'. This will probably |
| be one of the standard signed integer types (`short int', `int' or |
| `long int'), but might be a nonstandard type that exists only for |
| this purpose. |
| |
| -- Data Type: size_t |
| This is an unsigned integer type used to represent the sizes of |
| objects. The result of the `sizeof' operator is of this type, and |
| functions such as `malloc' (*note Unconstrained Allocation::) and |
| `memcpy' (*note Copying Strings and Arrays::) accept arguments of |
| this type to specify object sizes. On systems using the GNU C |
| Library, this will be `unsigned int' or `unsigned long int'. |
| |
| *Usage Note:* `size_t' is the preferred way to declare any |
| arguments or variables that hold the size of an object. |
| |
| *Compatibility Note:* Implementations of C before the advent of |
| ISO C generally used `unsigned int' for representing object sizes and |
| `int' for pointer subtraction results. They did not necessarily define |
| either `size_t' or `ptrdiff_t'. Unix systems did define `size_t', in |
| `sys/types.h', but the definition was usually a signed type. |
| |
| |
| File: libc.info, Node: Data Type Measurements, Prev: Important Data Types, Up: Language Features |
| |
| A.5 Data Type Measurements |
| ========================== |
| |
| Most of the time, if you choose the proper C data type for each object |
| in your program, you need not be concerned with just how it is |
| represented or how many bits it uses. When you do need such |
| information, the C language itself does not provide a way to get it. |
| The header files `limits.h' and `float.h' contain macros which give you |
| this information in full detail. |
| |
| * Menu: |
| |
| * Width of Type:: How many bits does an integer type hold? |
| * Range of Type:: What are the largest and smallest values |
| that an integer type can hold? |
| * Floating Type Macros:: Parameters that measure the floating point types. |
| * Structure Measurement:: Getting measurements on structure types. |
| |
| |
| File: libc.info, Node: Width of Type, Next: Range of Type, Up: Data Type Measurements |
| |
| A.5.1 Width of an Integer Type |
| ------------------------------ |
| |
| TS 18661-1:2014 defines macros for the width of integer types (the |
| number of value and sign bits). One benefit of these macros is they |
| can be used in `#if' preprocessor directives, whereas `sizeof' cannot. |
| The following macros are defined in `limits.h'. |
| |
| `CHAR_WIDTH' |
| `SCHAR_WIDTH' |
| `UCHAR_WIDTH' |
| `SHRT_WIDTH' |
| `USHRT_WIDTH' |
| `INT_WIDTH' |
| `UINT_WIDTH' |
| `LONG_WIDTH' |
| `ULONG_WIDTH' |
| `LLONG_WIDTH' |
| `ULLONG_WIDTH' |
| These are the widths of the types `char', `signed char', `unsigned |
| char', `short int', `unsigned short int', `int', `unsigned int', |
| `long int', `unsigned long int', `long long int' and `unsigned |
| long long int', respectively. |
| |
| Further such macros are defined in `stdint.h'. Apart from those for |
| types specified by width (*note Integers::), the following are defined: |
| |
| `INTPTR_WIDTH' |
| `UINTPTR_WIDTH' |
| `PTRDIFF_WIDTH' |
| `SIG_ATOMIC_WIDTH' |
| `SIZE_WIDTH' |
| `WCHAR_WIDTH' |
| `WINT_WIDTH' |
| These are the widths of the types `intptr_t', `uintptr_t', |
| `ptrdiff_t', `sig_atomic_t', `size_t', `wchar_t' and `wint_t', |
| respectively. |
| |
| A common reason that a program needs to know how many bits are in an |
| integer type is for using an array of `unsigned long int' as a bit |
| vector. You can access the bit at index N with: |
| |
| vector[N / ULONG_WIDTH] & (1UL << (N % ULONG_WIDTH)) |
| |
| Before `ULONG_WIDTH' was a part of the C language, `CHAR_BIT' was |
| used to compute the number of bits in an integer data type. |
| |
| -- Macro: int CHAR_BIT |
| This is the number of bits in a `char'. POSIX.1-2001 requires |
| this to be 8. |
| |
| The number of bits in any data type TYPE can be computed like this: |
| |
| sizeof (TYPE) * CHAR_BIT |
| |
| That expression includes padding bits as well as value and sign bits. |
| On all systems supported by the GNU C Library, standard integer types |
| other than `_Bool' do not have any padding bits. |
| |
| *Portability Note:* One cannot actually easily compute the number of |
| usable bits in a portable manner. |
| |
| |
| File: libc.info, Node: Range of Type, Next: Floating Type Macros, Prev: Width of Type, Up: Data Type Measurements |
| |
| A.5.2 Range of an Integer Type |
| ------------------------------ |
| |
| Suppose you need to store an integer value which can range from zero to |
| one million. Which is the smallest type you can use? There is no |
| general rule; it depends on the C compiler and target machine. You can |
| use the `MIN' and `MAX' macros in `limits.h' to determine which type |
| will work. |
| |
| Each signed integer type has a pair of macros which give the smallest |
| and largest values that it can hold. Each unsigned integer type has one |
| such macro, for the maximum value; the minimum value is, of course, |
| zero. |
| |
| The values of these macros are all integer constant expressions. The |
| `MAX' and `MIN' macros for `char' and `short int' types have values of |
| type `int'. The `MAX' and `MIN' macros for the other types have values |
| of the same type described by the macro--thus, `ULONG_MAX' has type |
| `unsigned long int'. |
| |
| `SCHAR_MIN' |
| This is the minimum value that can be represented by a |
| `signed char'. |
| |
| `SCHAR_MAX' |
| `UCHAR_MAX' |
| These are the maximum values that can be represented by a |
| `signed char' and `unsigned char', respectively. |
| |
| `CHAR_MIN' |
| This is the minimum value that can be represented by a `char'. |
| It's equal to `SCHAR_MIN' if `char' is signed, or zero otherwise. |
| |
| `CHAR_MAX' |
| This is the maximum value that can be represented by a `char'. |
| It's equal to `SCHAR_MAX' if `char' is signed, or `UCHAR_MAX' |
| otherwise. |
| |
| `SHRT_MIN' |
| This is the minimum value that can be represented by a |
| `signed short int'. On most machines that the GNU C Library runs |
| on, `short' integers are 16-bit quantities. |
| |
| `SHRT_MAX' |
| `USHRT_MAX' |
| These are the maximum values that can be represented by a |
| `signed short int' and `unsigned short int', respectively. |
| |
| `INT_MIN' |
| This is the minimum value that can be represented by a |
| `signed int'. On most machines that the GNU C Library runs on, an |
| `int' is a 32-bit quantity. |
| |
| `INT_MAX' |
| `UINT_MAX' |
| These are the maximum values that can be represented by, |
| respectively, the type `signed int' and the type `unsigned int'. |
| |
| `LONG_MIN' |
| This is the minimum value that can be represented by a |
| `signed long int'. On most machines that the GNU C Library runs |
| on, `long' integers are 32-bit quantities, the same size as `int'. |
| |
| `LONG_MAX' |
| `ULONG_MAX' |
| These are the maximum values that can be represented by a |
| `signed long int' and `unsigned long int', respectively. |
| |
| `LLONG_MIN' |
| This is the minimum value that can be represented by a |
| `signed long long int'. On most machines that the GNU C Library |
| runs on, `long long' integers are 64-bit quantities. |
| |
| `LLONG_MAX' |
| `ULLONG_MAX' |
| These are the maximum values that can be represented by a `signed |
| long long int' and `unsigned long long int', respectively. |
| |
| `LONG_LONG_MIN' |
| `LONG_LONG_MAX' |
| `ULONG_LONG_MAX' |
| These are obsolete names for `LLONG_MIN', `LLONG_MAX', and |
| `ULLONG_MAX'. They are only available if `_GNU_SOURCE' is defined |
| (*note Feature Test Macros::). In GCC versions prior to 3.0, |
| these were the only names available. |
| |
| `WCHAR_MAX' |
| This is the maximum value that can be represented by a `wchar_t'. |
| *Note Extended Char Intro::. |
| |
| The header file `limits.h' also defines some additional constants |
| that parameterize various operating system and file system limits. |
| These constants are described in *note System Configuration::. |
| |
| |
| File: libc.info, Node: Floating Type Macros, Next: Structure Measurement, Prev: Range of Type, Up: Data Type Measurements |
| |
| A.5.3 Floating Type Macros |
| -------------------------- |
| |
| The specific representation of floating point numbers varies from |
| machine to machine. Because floating point numbers are represented |
| internally as approximate quantities, algorithms for manipulating |
| floating point data often need to take account of the precise details of |
| the machine's floating point representation. |
| |
| Some of the functions in the C library itself need this information; |
| for example, the algorithms for printing and reading floating point |
| numbers (*note I/O on Streams::) and for calculating trigonometric and |
| irrational functions (*note Mathematics::) use it to avoid round-off |
| error and loss of accuracy. User programs that implement numerical |
| analysis techniques also often need this information in order to |
| minimize or compute error bounds. |
| |
| The header file `float.h' describes the format used by your machine. |
| |
| * Menu: |
| |
| * Floating Point Concepts:: Definitions of terminology. |
| * Floating Point Parameters:: Details of specific macros. |
| * IEEE Floating Point:: The measurements for one common |
| representation. |
| |
| |
| File: libc.info, Node: Floating Point Concepts, Next: Floating Point Parameters, Up: Floating Type Macros |
| |
| A.5.3.1 Floating Point Representation Concepts |
| .............................................. |
| |
| This section introduces the terminology for describing floating point |
| representations. |
| |
| You are probably already familiar with most of these concepts in |
| terms of scientific or exponential notation for floating point numbers. |
| For example, the number `123456.0' could be expressed in exponential |
| notation as `1.23456e+05', a shorthand notation indicating that the |
| mantissa `1.23456' is multiplied by the base `10' raised to power `5'. |
| |
| More formally, the internal representation of a floating point number |
| can be characterized in terms of the following parameters: |
| |
| * The "sign" is either `-1' or `1'. |
| |
| * The "base" or "radix" for exponentiation, an integer greater than |
| `1'. This is a constant for a particular representation. |
| |
| * The "exponent" to which the base is raised. The upper and lower |
| bounds of the exponent value are constants for a particular |
| representation. |
| |
| Sometimes, in the actual bits representing the floating point |
| number, the exponent is "biased" by adding a constant to it, to |
| make it always be represented as an unsigned quantity. This is |
| only important if you have some reason to pick apart the bit |
| fields making up the floating point number by hand, which is |
| something for which the GNU C Library provides no support. So |
| this is ignored in the discussion that follows. |
| |
| * The "mantissa" or "significand" is an unsigned integer which is a |
| part of each floating point number. |
| |
| * The "precision" of the mantissa. If the base of the representation |
| is B, then the precision is the number of base-B digits in the |
| mantissa. This is a constant for a particular representation. |
| |
| Many floating point representations have an implicit "hidden bit" |
| in the mantissa. This is a bit which is present virtually in the |
| mantissa, but not stored in memory because its value is always 1 |
| in a normalized number. The precision figure (see above) includes |
| any hidden bits. |
| |
| Again, the GNU C Library provides no facilities for dealing with |
| such low-level aspects of the representation. |
| |
| The mantissa of a floating point number represents an implicit |
| fraction whose denominator is the base raised to the power of the |
| precision. Since the largest representable mantissa is one less than |
| this denominator, the value of the fraction is always strictly less |
| than `1'. The mathematical value of a floating point number is then |
| the product of this fraction, the sign, and the base raised to the |
| exponent. |
| |
| We say that the floating point number is "normalized" if the |
| fraction is at least `1/B', where B is the base. In other words, the |
| mantissa would be too large to fit if it were multiplied by the base. |
| Non-normalized numbers are sometimes called "denormal"; they contain |
| less precision than the representation normally can hold. |
| |
| If the number is not normalized, then you can subtract `1' from the |
| exponent while multiplying the mantissa by the base, and get another |
| floating point number with the same value. "Normalization" consists of |
| doing this repeatedly until the number is normalized. Two distinct |
| normalized floating point numbers cannot be equal in value. |
| |
| (There is an exception to this rule: if the mantissa is zero, it is |
| considered normalized. Another exception happens on certain machines |
| where the exponent is as small as the representation can hold. Then it |
| is impossible to subtract `1' from the exponent, so a number may be |
| normalized even if its fraction is less than `1/B'.) |
| |
| |
| File: libc.info, Node: Floating Point Parameters, Next: IEEE Floating Point, Prev: Floating Point Concepts, Up: Floating Type Macros |
| |
| A.5.3.2 Floating Point Parameters |
| ................................. |
| |
| These macro definitions can be accessed by including the header file |
| `float.h' in your program. |
| |
| Macro names starting with `FLT_' refer to the `float' type, while |
| names beginning with `DBL_' refer to the `double' type and names |
| beginning with `LDBL_' refer to the `long double' type. (If GCC does |
| not support `long double' as a distinct data type on a target machine |
| then the values for the `LDBL_' constants are equal to the |
| corresponding constants for the `double' type.) |
| |
| Of these macros, only `FLT_RADIX' is guaranteed to be a constant |
| expression. The other macros listed here cannot be reliably used in |
| places that require constant expressions, such as `#if' preprocessing |
| directives or in the dimensions of static arrays. |
| |
| Although the ISO C standard specifies minimum and maximum values for |
| most of these parameters, the GNU C implementation uses whatever values |
| describe the floating point representation of the target machine. So in |
| principle GNU C actually satisfies the ISO C requirements only if the |
| target machine is suitable. In practice, all the machines currently |
| supported are suitable. |
| |
| `FLT_ROUNDS' |
| This value characterizes the rounding mode for floating point |
| addition. The following values indicate standard rounding modes: |
| |
| `-1' |
| The mode is indeterminable. |
| |
| `0' |
| Rounding is towards zero. |
| |
| `1' |
| Rounding is to the nearest number. |
| |
| `2' |
| Rounding is towards positive infinity. |
| |
| `3' |
| Rounding is towards negative infinity. |
| |
| Any other value represents a machine-dependent nonstandard rounding |
| mode. |
| |
| On most machines, the value is `1', in accordance with the IEEE |
| standard for floating point. |
| |
| Here is a table showing how certain values round for each possible |
| value of `FLT_ROUNDS', if the other aspects of the representation |
| match the IEEE single-precision standard. |
| |
| 0 1 2 3 |
| 1.00000003 1.0 1.0 1.00000012 1.0 |
| 1.00000007 1.0 1.00000012 1.00000012 1.0 |
| -1.00000003 -1.0 -1.0 -1.0 -1.00000012 |
| -1.00000007 -1.0 -1.00000012 -1.0 -1.00000012 |
| |
| `FLT_RADIX' |
| This is the value of the base, or radix, of the exponent |
| representation. This is guaranteed to be a constant expression, |
| unlike the other macros described in this section. The value is 2 |
| on all machines we know of except the IBM 360 and derivatives. |
| |
| `FLT_MANT_DIG' |
| This is the number of base-`FLT_RADIX' digits in the floating point |
| mantissa for the `float' data type. The following expression |
| yields `1.0' (even though mathematically it should not) due to the |
| limited number of mantissa digits: |
| |
| float radix = FLT_RADIX; |
| |
| 1.0f + 1.0f / radix / radix / ... / radix |
| |
| where `radix' appears `FLT_MANT_DIG' times. |
| |
| `DBL_MANT_DIG' |
| `LDBL_MANT_DIG' |
| This is the number of base-`FLT_RADIX' digits in the floating point |
| mantissa for the data types `double' and `long double', |
| respectively. |
| |
| `FLT_DIG' |
| This is the number of decimal digits of precision for the `float' |
| data type. Technically, if P and B are the precision and base |
| (respectively) for the representation, then the decimal precision |
| Q is the maximum number of decimal digits such that any floating |
| point number with Q base 10 digits can be rounded to a floating |
| point number with P base B digits and back again, without change |
| to the Q decimal digits. |
| |
| The value of this macro is supposed to be at least `6', to satisfy |
| ISO C. |
| |
| `DBL_DIG' |
| `LDBL_DIG' |
| These are similar to `FLT_DIG', but for the data types `double' |
| and `long double', respectively. The values of these macros are |
| supposed to be at least `10'. |
| |
| `FLT_MIN_EXP' |
| This is the smallest possible exponent value for type `float'. |
| More precisely, it is the minimum negative integer such that the |
| value `FLT_RADIX' raised to this power minus 1 can be represented |
| as a normalized floating point number of type `float'. |
| |
| `DBL_MIN_EXP' |
| `LDBL_MIN_EXP' |
| These are similar to `FLT_MIN_EXP', but for the data types |
| `double' and `long double', respectively. |
| |
| `FLT_MIN_10_EXP' |
| This is the minimum negative integer such that `10' raised to this |
| power minus 1 can be represented as a normalized floating point |
| number of type `float'. This is supposed to be `-37' or even less. |
| |
| `DBL_MIN_10_EXP' |
| `LDBL_MIN_10_EXP' |
| These are similar to `FLT_MIN_10_EXP', but for the data types |
| `double' and `long double', respectively. |
| |
| `FLT_MAX_EXP' |
| This is the largest possible exponent value for type `float'. More |
| precisely, this is the maximum positive integer such that value |
| `FLT_RADIX' raised to this power minus 1 can be represented as a |
| floating point number of type `float'. |
| |
| `DBL_MAX_EXP' |
| `LDBL_MAX_EXP' |
| These are similar to `FLT_MAX_EXP', but for the data types |
| `double' and `long double', respectively. |
| |
| `FLT_MAX_10_EXP' |
| This is the maximum positive integer such that `10' raised to this |
| power minus 1 can be represented as a normalized floating point |
| number of type `float'. This is supposed to be at least `37'. |
| |
| `DBL_MAX_10_EXP' |
| `LDBL_MAX_10_EXP' |
| These are similar to `FLT_MAX_10_EXP', but for the data types |
| `double' and `long double', respectively. |
| |
| `FLT_MAX' |
| The value of this macro is the maximum number representable in type |
| `float'. It is supposed to be at least `1E+37'. The value has |
| type `float'. |
| |
| The smallest representable number is `- FLT_MAX'. |
| |
| `DBL_MAX' |
| `LDBL_MAX' |
| These are similar to `FLT_MAX', but for the data types `double' |
| and `long double', respectively. The type of the macro's value is |
| the same as the type it describes. |
| |
| `FLT_MIN' |
| The value of this macro is the minimum normalized positive floating |
| point number that is representable in type `float'. It is supposed |
| to be no more than `1E-37'. |
| |
| `DBL_MIN' |
| `LDBL_MIN' |
| These are similar to `FLT_MIN', but for the data types `double' |
| and `long double', respectively. The type of the macro's value is |
| the same as the type it describes. |
| |
| `FLT_EPSILON' |
| This is the difference between 1 and the smallest floating point |
| number of type `float' that is greater than 1. It's supposed to |
| be no greater than `1E-5'. |
| |
| `DBL_EPSILON' |
| `LDBL_EPSILON' |
| These are similar to `FLT_EPSILON', but for the data types |
| `double' and `long double', respectively. The type of the macro's |
| value is the same as the type it describes. The values are not |
| supposed to be greater than `1E-9'. |
| |
| |
| File: libc.info, Node: IEEE Floating Point, Prev: Floating Point Parameters, Up: Floating Type Macros |
| |
| A.5.3.3 IEEE Floating Point |
| ........................... |
| |
| Here is an example showing how the floating type measurements come out |
| for the most common floating point representation, specified by the |
| `IEEE Standard for Binary Floating Point Arithmetic (ANSI/IEEE Std |
| 754-1985)'. Nearly all computers designed since the 1980s use this |
| format. |
| |
| The IEEE single-precision float representation uses a base of 2. |
| There is a sign bit, a mantissa with 23 bits plus one hidden bit (so |
| the total precision is 24 base-2 digits), and an 8-bit exponent that |
| can represent values in the range -125 to 128, inclusive. |
| |
| So, for an implementation that uses this representation for the |
| `float' data type, appropriate values for the corresponding parameters |
| are: |
| |
| FLT_RADIX 2 |
| FLT_MANT_DIG 24 |
| FLT_DIG 6 |
| FLT_MIN_EXP -125 |
| FLT_MIN_10_EXP -37 |
| FLT_MAX_EXP 128 |
| FLT_MAX_10_EXP +38 |
| FLT_MIN 1.17549435E-38F |
| FLT_MAX 3.40282347E+38F |
| FLT_EPSILON 1.19209290E-07F |
| |
| Here are the values for the `double' data type: |
| |
| DBL_MANT_DIG 53 |
| DBL_DIG 15 |
| DBL_MIN_EXP -1021 |
| DBL_MIN_10_EXP -307 |
| DBL_MAX_EXP 1024 |
| DBL_MAX_10_EXP 308 |
| DBL_MAX 1.7976931348623157E+308 |
| DBL_MIN 2.2250738585072014E-308 |
| DBL_EPSILON 2.2204460492503131E-016 |
| |
| |
| File: libc.info, Node: Structure Measurement, Prev: Floating Type Macros, Up: Data Type Measurements |
| |
| A.5.4 Structure Field Offset Measurement |
| ---------------------------------------- |
| |
| You can use `offsetof' to measure the location within a structure type |
| of a particular structure member. |
| |
| -- Macro: size_t offsetof (TYPE, MEMBER) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This expands to an integer constant expression that is the offset |
| of the structure member named MEMBER in the structure type TYPE. |
| For example, `offsetof (struct s, elem)' is the offset, in bytes, |
| of the member `elem' in a `struct s'. |
| |
| This macro won't work if MEMBER is a bit field; you get an error |
| from the C compiler in that case. |
| |
| |
| |
| Local Variables: |
| coding: utf-8 |
| End: |
