rubycc 1.0.0

data/include/libc/sys/uio.h

@@ -0,0 +1,40 @@
+/* rubycc bundled <sys/uio.h>: scatter/gather I/O (POSIX.1). Provenance: clean
+   room against the POSIX public interface and the Linux kernel UAPI
+   (linux/uio.h); struct iovec's member names, types and order are that ABI's
+   own public contract, not glibc implementation detail. Reuses the
+   _RUBYCC_STRUCT_IOVEC guard sys/socket.h already defines the struct under, so
+   the two headers agree rather than redefine when both are included; its
+   16-byte size and both members' offsets were measured against the glibc
+   oracle on both x86-64 and aarch64 (see sys/socket.h's SOCKET case and this
+   header's UIO case in test/test_header_abi.rb) and the two agreed exactly (a
+   pointer-and-size_t struct has no arch-dependent field widths on either LP64
+   target), so this header lives in the common layer. readv/writev are POSIX
+   declarations whose bodies resolve from the host libc at link time
+   (Step 123, M5 H2). */
+
+#ifndef _RUBYCC_SYS_UIO_H
+#define _RUBYCC_SYS_UIO_H
+
+#ifndef _RUBYCC_SIZE_T
+#define _RUBYCC_SIZE_T
+typedef unsigned long size_t;
+#endif
+#ifndef _RUBYCC_SSIZE_T
+#define _RUBYCC_SSIZE_T
+typedef long ssize_t;
+#endif
+
+/* struct iovec: 16 bytes, 8-byte aligned (measured, both arches). Shared with
+   sys/socket.h under the same guard. */
+#ifndef _RUBYCC_STRUCT_IOVEC
+#define _RUBYCC_STRUCT_IOVEC
+struct iovec {
+  void  *iov_base; /* offset 0 */
+  size_t iov_len;  /* offset 8 */
+};
+#endif
+
+ssize_t readv(int __fd, const struct iovec *__iov, int __iovcnt);
+ssize_t writev(int __fd, const struct iovec *__iov, int __iovcnt);
+
+#endif /* _RUBYCC_SYS_UIO_H */

data/include/libc/sys/un.h

@@ -0,0 +1,25 @@
+/* rubycc bundled <sys/un.h>: struct sockaddr_un, the AF_UNIX (local) socket
+   address. Provenance: clean room against the Linux kernel UAPI (linux/un.h)
+   and the glibc socket ABI, not derived from musl. The 110-byte layout
+   (sun_family then a 108-byte sun_path) is that ABI reproduced as a measured
+   field layout (an ABI fact, not copied text -- see docs/HEADER-LICENSING.md),
+   the same treatment as sys/socket.h. Common layer: the layout is identical on
+   x86-64 and aarch64. sa_family_t is shared with <sys/socket.h> and
+   <netinet/in.h> through the same guard, so including any combination never
+   redefines it. */
+
+#ifndef _RUBYCC_SYS_UN_H
+#define _RUBYCC_SYS_UN_H
+
+#ifndef _RUBYCC_SA_FAMILY_T
+#define _RUBYCC_SA_FAMILY_T
+typedef unsigned short sa_family_t;
+#endif
+
+/* struct sockaddr_un: 110 bytes, 2-byte aligned (measured, both arches). */
+struct sockaddr_un {
+  sa_family_t sun_family;    /* offset 0 */
+  char        sun_path[108]; /* offset 2 */
+};
+
+#endif /* _RUBYCC_SYS_UN_H */

data/include/libc/sys/utsname.h

@@ -0,0 +1,35 @@
+/* rubycc bundled <sys/utsname.h>: system identification (POSIX.1 4.4).
+   Provenance: clean room against the Linux kernel ABI (struct new_utsname,
+   returned by the uname(2) syscall) and the POSIX public interface. Member
+   names, order and per-field length (65) are the ABI's own public contract --
+   the raw syscall fills exactly six 65-byte fields (sysname, nodename,
+   release, version, machine, domainname; the sixth is the NIS domain name the
+   kernel added alongside the original five POSIX fields) -- so reproducing
+   them is not a glibc derivation. Every member is used directly by callers, so
+   it cannot be an opaque byte blob; the struct's size (390) and every member's
+   offset were measured against the glibc oracle on both x86-64 and aarch64
+   (see test/test_header_abi.rb's UTSNAME case) and the two agreed exactly (a
+   plain char-array struct has no arch-dependent field widths), so this header
+   lives in the common layer. glibc gates the sixth field's name behind
+   __USE_GNU (plain `domainname' vs. `__domainname'); rubycc's bundled header
+   exposes the flat `domainname' spelling unconditionally, the same choice
+   sys/stat.h's unconditional st_atim makes. uname is a POSIX declaration whose
+   body resolves from the host libc at link time (Step 123, M5 H2). */
+
+#ifndef _RUBYCC_SYS_UTSNAME_H
+#define _RUBYCC_SYS_UTSNAME_H
+
+#define _UTSNAME_LENGTH 65
+
+struct utsname {
+  char sysname[_UTSNAME_LENGTH];    /* Operating system name. */
+  char nodename[_UTSNAME_LENGTH];   /* Name on the network. */
+  char release[_UTSNAME_LENGTH];    /* Release level. */
+  char version[_UTSNAME_LENGTH];    /* Version level. */
+  char machine[_UTSNAME_LENGTH];    /* Hardware type. */
+  char domainname[_UTSNAME_LENGTH]; /* NIS/YP domain name. */
+};
+
+int uname(struct utsname *__name);
+
+#endif /* _RUBYCC_SYS_UTSNAME_H */

data/include/libc/sys/wait.h

@@ -0,0 +1,135 @@
+/* rubycc bundled <sys/wait.h>: waiting for process state changes (POSIX.1).
+   Provenance: clean room against the POSIX public interface and the Linux
+   kernel's wait-status encoding, not derived from musl or glibc source. Two
+   kinds of ABI fact are reproduced here, both measured rather than copied
+   (see docs/HEADER-LICENSING.md sec. 4):
+
+   (a) The option flags (WNOHANG/WUNTRACED/WCONTINUED and the waitid
+       WEXITED/WSTOPPED/WNOWAIT set, plus glibc's __WALL family) and the
+       idtype_t enumerators, printed from the glibc oracle on x86-64 and on
+       aarch64 (cross gcc + qemu); the two agreed on every value.
+
+   (b) The wait-status *encoding* behind WIFEXITED and kin. Rather than copy
+       glibc's macro bodies, rubycc re-derived the encoding from observed
+       behaviour and then proved the re-derivation exact: a probe compared
+       rubycc's formula against the host glibc macro for *every* one of the
+       2^32 int status values, for all eight macros, on both x86-64 and
+       aarch64, and found zero mismatches (including the exact non-boolean
+       return of WCOREDUMP, which yields the 0x80 flag bit rather than 1).
+       The formulas below are therefore rubycc's own spelling of a measured
+       fact; they are also written to evaluate their argument exactly once,
+       which glibc's differently-shaped bodies also do. That exhaustive
+       comparison had a glibc oracle; on musl the harness measured a
+       difference in WIFSTOPPED alone, so that macro (and only that one) has a
+       musl branch below.
+
+   Common layer: every value and every macro result above is identical on
+   x86-64 and aarch64, so this header is arch-neutral (unlike sys/epoll.h,
+   whose struct packing differs between the two).
+
+   <signal.h> is included for siginfo_t, which waitid's third parameter needs:
+   glibc reaches for its own bits/types/siginfo_t.h here under
+   __USE_XOPEN_EXTENDED, and rubycc has no split types layer to reach for, so
+   it includes the whole bundled <signal.h> (the same way the bundled
+   <string.h> reaches for <strings.h> to reproduce glibc's __USE_MISC
+   pull-in). pid_t arrives with it.
+
+   Not included: wait3/wait4 (they take a `struct rusage *`, which would mean
+   either cross-including <sys/resource.h> or duplicating struct rusage under
+   a shared guard, and no corpus census hit needs them -- nio4r, the gem that
+   put this header on the list, reaches only waitpid and the status macros),
+   the obsolete `union wait` overloads, and WAIT_ANY/WAIT_MYPGRP. */
+
+#ifndef _RUBYCC_SYS_WAIT_H
+#define _RUBYCC_SYS_WAIT_H
+
+#include <signal.h>
+
+#ifndef _RUBYCC_ID_T
+#define _RUBYCC_ID_T
+typedef unsigned int id_t;
+#endif
+
+/* waitpid / waitid options (measured, both arches). */
+#if defined(WNOHANG) && WNOHANG != 1
+/* ruby.h's ruby/missing.h supplies a zero fallback before this header.  That
+   fallback is only for platforms without waitpid; on Linux this measured ABI
+   value must replace it rather than trigger a conflicting redefinition. */
+#undef WNOHANG
+#endif
+#define WNOHANG    1
+#define WUNTRACED  2
+#define WSTOPPED   2
+#define WEXITED    4
+#define WCONTINUED 8
+#define WNOWAIT    0x01000000
+
+/* glibc's Linux-specific selectors for which children to wait on. */
+#define __WNOTHREAD 0x20000000
+#define __WALL      0x40000000
+#define __WCLONE    0x80000000
+
+/* The wait-status encoding (Linux kernel ABI), re-derived from measurement:
+     bits 0..6   terminating signal; 0 means "exited normally" and the
+                 reserved value 0x7f means "stopped"
+     bit 7       core-dump flag
+     bits 8..15  exit code, or the stopping signal when bits 0..7 are 0x7f
+     0xffff      the whole word, meaning "continued"
+   Each macro evaluates its argument once, WIFSTOPPED's musl branch excepted
+   (see its own note). WIFSIGNALED's unsigned compare is
+   the single-evaluation way to say "the signal field is neither 0 nor the
+   0x7f stopped marker": subtracting one wraps the 0 case past the range. */
+#define WTERMSIG(status)     ((status) & 0x7f)
+#define WEXITSTATUS(status)  (((status) & 0xff00) >> 8)
+#define WSTOPSIG(status)     (((status) & 0xff00) >> 8)
+#define WIFEXITED(status)    (((status) & 0x7f) == 0)
+#define WIFSIGNALED(status)  ((unsigned)(((status) & 0x7f) - 1) < 0x7eu)
+/* WIFSTOPPED is the one status macro the two C libraries answer differently:
+   musl also requires the stopping-signal byte to be non-zero, so the bare
+   0x007f word is not "stopped" there. Measured on the four status words the
+   ABI harness probes (docs/STEPS.md Step 193; glibc's side on this host):
+     status   glibc  musl
+     0x0000     0      0
+     0x007f     1      0
+     0x137f     1      1
+     0xffff     0      0
+   The musl form below is the narrowest formula that reproduces all four; no
+   other status word was measured on musl, so nothing stronger is claimed.
+   Unlike every other macro here it names its argument twice -- there is no
+   single-evaluation spelling of "low byte is 0x7f and high byte is not zero"
+   that does not go through a helper -- so an argument with a side effect is
+   evaluated twice under musl. */
+#if defined(__RUBYCC_LIBC_MUSL__)
+#define WIFSTOPPED(status)   (((status) & 0xff) == 0x7f && ((status) & 0xff00) != 0)
+#else
+#define WIFSTOPPED(status)   (((status) & 0xff) == 0x7f)
+#endif
+#define WIFCONTINUED(status) ((status) == 0xffff)
+#define WCOREDUMP(status)    ((status) & 0x80)
+
+/* waitid's id interpretation. Measured: a 4-byte, 4-byte-aligned enum whose
+   enumerators run 0, 1, 2 (and 3 for the recent P_PIDFD addition). */
+typedef enum {
+  P_ALL   = 0,
+  P_PID   = 1,
+  P_PGID  = 2,
+  P_PIDFD = 3
+} idtype_t;
+
+/* siginfo_t::si_code values for SIGCHLD, which is how waitid reports what
+   happened (measured, both arches). glibc keeps these in the same
+   bits/siginfo-consts.h that both <signal.h> and <sys/wait.h> reach for; the
+   bundled <signal.h> does not define them, so they live here, next to the one
+   call that needs them. */
+#define CLD_EXITED    1
+#define CLD_KILLED    2
+#define CLD_DUMPED    3
+#define CLD_TRAPPED   4
+#define CLD_STOPPED   5
+#define CLD_CONTINUED 6
+
+pid_t wait(int *__status);
+pid_t waitpid(pid_t __pid, int *__status, int __options);
+int   waitid(idtype_t __idtype, id_t __id, siginfo_t *__infop, int __options);
+
+#endif /* _RUBYCC_SYS_WAIT_H */

data/include/libc/termios.h

@@ -0,0 +1,179 @@
+/* rubycc bundled <termios.h>: general terminal interface (POSIX.1).
+   Provenance: clean room against the POSIX public interface and the glibc/
+   Linux ABI (bits/termios.h, the generic layout every mainline Linux arch
+   except a handful of legacy ports -- alpha/mips/powerpc/sparc -- shares;
+   x86-64 and aarch64 both use it). struct termios's member names, order and
+   the `c_cc` array holding NCCS control characters are that ABI's own public
+   contract, not glibc implementation detail (the same treatment sys/
+   resource.h gives struct rlimit/struct rusage). Every member (including
+   c_cc's individual slots, indexed by the V* constants) is read/written
+   directly by callers, so the struct cannot be an opaque byte blob; its size
+   (60), NCCS (32) and every member's offset were measured against the glibc
+   oracle on both x86-64 and aarch64 (see test/test_header_abi.rb's TERMIOS
+   case) and the two agreed exactly (tcflag_t/speed_t are `unsigned int` and
+   cc_t is `unsigned char` on either LP64 target, so no member has an
+   arch-dependent width), so this header lives in the common layer. speed_t/
+   tcflag_t/cc_t and every c_iflag/c_oflag/c_cflag/c_lflag bit and V* index
+   are the standard Linux/glibc values (measured, both arches agree).
+   Narrowed to the surface io-console's corpus sample actually reaches
+   (Step 124, M5 H2): the termios-path (HAVE_TERMIOS_H) getattr/setattr pair
+   built from tcgetattr/tcsetattr/TCSANOW, tcflush plus its TC*FLUSH queue
+   selectors, and the c_iflag/c_oflag/c_cflag/c_lflag bits and VMIN/VTIME/
+   VINTR/.../XCASE indices it flips to build raw mode. cfgetispeed/
+   cfsetispeed/cfgetospeed/cfsetospeed/tcdrain/tcsendbreak are declared as
+   the POSIX-mandated companions of tcgetattr/tcsetattr even though no corpus
+   sample calls them, the same completeness precedent pwd.h/grp.h set for
+   their reentrant *_r siblings. Not included: tcflow/tcgetsid/cfsetspeed and
+   the termio.h/sgtty.h fallback paths (BSD/pre-POSIX ioctl-based terminal
+   control that HAVE_TERMIOS_H skips on Linux), and the NLDLY/CRDLY/TABDLY/
+   BSDLY/VTDLY/FFDLY output-delay bits (line-printer timing, not used to
+   build raw mode). cfmakeraw was missing from that Step 124 pass: the corpus
+   census that drove it only looks at which headers a #include reaches, not
+   which functions the reached header's caller actually calls, so a function
+   io-console calls without pulling in any new header slipped past it.
+   Building io-console for real (Step 167) surfaced the gap -- mkmf's
+   have_func probe for it passed regardless (it declares the function itself
+   before linking), so -DHAVE_CFMAKERAW was set and the implicit-declaration
+   error only showed up compiling the body -- and cfmakeraw was added then. */
+
+#ifndef _RUBYCC_TERMIOS_H
+#define _RUBYCC_TERMIOS_H
+
+typedef unsigned char cc_t;
+typedef unsigned int speed_t;
+typedef unsigned int tcflag_t;
+
+/* Size of c_cc (measured, both arches). */
+#define NCCS 32
+
+/* struct termios: 60 bytes, 4-byte aligned (measured, both arches). */
+struct termios {
+  tcflag_t c_iflag;   /* offset 0:  input mode flags */
+  tcflag_t c_oflag;   /* offset 4:  output mode flags */
+  tcflag_t c_cflag;   /* offset 8:  control mode flags */
+  tcflag_t c_lflag;   /* offset 12: local mode flags */
+  cc_t c_line;         /* offset 16: line discipline */
+  cc_t c_cc[NCCS];     /* offset 17: control characters */
+  speed_t c_ispeed;    /* offset 52: input speed */
+  speed_t c_ospeed;    /* offset 56: output speed */
+};
+
+/* c_cc subscripts (measured, both arches agree). */
+#define VINTR    0
+#define VQUIT    1
+#define VERASE   2
+#define VKILL    3
+#define VEOF     4
+#define VTIME    5
+#define VMIN     6
+#define VSWTC    7
+#define VSTART   8
+#define VSTOP    9
+#define VSUSP    10
+#define VEOL     11
+#define VREPRINT 12
+#define VDISCARD 13
+#define VWERASE  14
+#define VLNEXT   15
+#define VEOL2    16
+
+/* c_iflag bits. */
+#define IGNBRK  0000001
+#define BRKINT  0000002
+#define IGNPAR  0000004
+#define PARMRK  0000010
+#define INPCK   0000020
+#define ISTRIP  0000040
+#define INLCR   0000100
+#define IGNCR   0000200
+#define ICRNL   0000400
+#define IXON    0002000
+#define IXANY   0004000
+#define IXOFF   0010000
+#define IMAXBEL 0020000
+#define IUTF8   0040000
+
+/* c_oflag bits. */
+#define OPOST  0000001
+#define ONLCR  0000004
+#define OCRNL  0000010
+#define ONOCR  0000020
+#define ONLRET 0000040
+#define OFILL  0000100
+#define OFDEL  0000200
+
+/* c_cflag bits. */
+#define CSIZE  0000060
+#define CS5    0000000
+#define CS6    0000020
+#define CS7    0000040
+#define CS8    0000060
+#define CSTOPB 0000100
+#define CREAD  0000200
+#define PARENB 0000400
+#define PARODD 0001000
+#define HUPCL  0002000
+#define CLOCAL 0004000
+
+/* c_lflag bits. */
+#define ISIG   0000001
+#define ICANON 0000002
+#define ECHO   0000010
+#define ECHOE  0000020
+#define ECHOK  0000040
+#define ECHONL 0000100
+#define NOFLSH 0000200
+#define TOSTOP 0000400
+#define IEXTEN 0100000
+/* Linux extension (glibc gates this behind __USE_MISC; rubycc exposes it
+   unconditionally, the same flat-surface choice sys/resource.h made for
+   RUSAGE_THREAD). */
+#define XCASE  0000004
+
+/* Baud rate selectors, for cfsetispeed/cfsetospeed (the traditional POSIX
+   set; the GNU-extension rates above B38400, e.g. B57600/B115200, are not
+   included -- no corpus sample needs them). */
+#define B0     0000000
+#define B50    0000001
+#define B75    0000002
+#define B110   0000003
+#define B134   0000004
+#define B150   0000005
+#define B200   0000006
+#define B300   0000007
+#define B600   0000010
+#define B1200  0000011
+#define B1800  0000012
+#define B2400  0000013
+#define B4800  0000014
+#define B9600  0000015
+#define B19200 0000016
+#define B38400 0000017
+
+/* tcsetattr's __optional_actions. */
+#define TCSANOW   0
+#define TCSADRAIN 1
+#define TCSAFLUSH 2
+
+/* tcflush's __queue_selector. */
+#define TCIFLUSH  0
+#define TCOFLUSH  1
+#define TCIOFLUSH 2
+
+int tcgetattr(int __fd, struct termios *__termios_p);
+int tcsetattr(int __fd, int __optional_actions, const struct termios *__termios_p);
+int tcflush(int __fd, int __queue_selector);
+int tcdrain(int __fd);
+int tcsendbreak(int __fd, int __duration);
+speed_t cfgetispeed(const struct termios *__termios_p);
+speed_t cfgetospeed(const struct termios *__termios_p);
+int cfsetispeed(struct termios *__termios_p, speed_t __speed);
+int cfsetospeed(struct termios *__termios_p, speed_t __speed);
+
+/* cfmakeraw is a BSD/GNU extension, not POSIX (POSIX only standardizes the
+   getattr/setattr/cfset*speed calls above); glibc and the BSDs all provide it
+   as the conventional shortcut that sets the termios flags/c_cc for raw mode
+   in one call, which is exactly what io-console uses it for. */
+void cfmakeraw(struct termios *__termios_p);
+
+#endif /* _RUBYCC_TERMIOS_H */

data/include/libc/unistd.h

@@ -0,0 +1,194 @@
+/* rubycc bundled <unistd.h>: the POSIX system-call declarations (POSIX.1).
+   Derived from musl's <unistd.h> declaration set; the few ABI-typed names
+   (ssize_t, off_t, pid_t, ...) reuse the shared _RUBYCC_* guards and carry the
+   LP64 widths. The STDIN_FILENO / *_OK values are the standard ones. Common
+   layer: the surface is declarations plus universal constants. */
+
+#ifndef _RUBYCC_UNISTD_H
+#define _RUBYCC_UNISTD_H
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+#ifndef _RUBYCC_SIZE_T
+#define _RUBYCC_SIZE_T
+typedef unsigned long size_t;
+#endif
+#ifndef _RUBYCC_SSIZE_T
+#define _RUBYCC_SSIZE_T
+typedef long ssize_t;
+#endif
+#ifndef _RUBYCC_OFF_T
+#define _RUBYCC_OFF_T
+typedef long off_t;
+#endif
+#ifndef _RUBYCC_PID_T
+#define _RUBYCC_PID_T
+typedef int pid_t;
+#endif
+#ifndef _RUBYCC_UID_T
+#define _RUBYCC_UID_T
+typedef unsigned int uid_t;
+#endif
+#ifndef _RUBYCC_GID_T
+#define _RUBYCC_GID_T
+typedef unsigned int gid_t;
+#endif
+#ifndef _RUBYCC_USECONDS_T
+#define _RUBYCC_USECONDS_T
+typedef unsigned int useconds_t;
+#endif
+#ifndef _RUBYCC_INTPTR_T
+#define _RUBYCC_INTPTR_T
+typedef long intptr_t;
+#endif
+
+#define STDIN_FILENO  0
+#define STDOUT_FILENO 1
+#define STDERR_FILENO 2
+
+#define F_OK 0
+#define X_OK 1
+#define W_OK 2
+#define R_OK 4
+
+/* POSIX option macro: the monotonic clock option is supported, and the two C
+   libraries say so with different strengths. glibc's value is 0, meaning
+   support must still be confirmed at runtime via
+   sysconf(_SC_MONOTONIC_CLOCK); musl's is 200809, the standard revision it
+   supports unconditionally. Both measured with the ABI harness, glibc's on
+   this host and musl's on the CI musl run (docs/STEPS.md Step 193). Needed for
+   stackprof: it branches on `#ifdef _POSIX_MONOTONIC_CLOCK`, and the #else arm
+   it would otherwise take is upstream dead code containing a real syntax
+   error, so a toolchain that never defines this macro cannot build stackprof
+   at all -- and both values above define it. Scope: only this one _POSIX_*
+   macro is added here, not the full POSIX options set (same scoping judgment
+   as sys/syscall.h's non-exhaustive number list). */
+#if defined(__RUBYCC_LIBC_MUSL__)
+#define _POSIX_MONOTONIC_CLOCK 200809
+#else
+#define _POSIX_MONOTONIC_CLOCK 0
+#endif
+#define _POSIX_TIMERS 200809L
+
+#ifndef SEEK_SET
+#define SEEK_SET 0
+#define SEEK_CUR 1
+#define SEEK_END 2
+#endif
+
+int     access(const char *__name, int __type);
+int     close(int __fd);
+ssize_t read(int __fd, void *__buf, size_t __nbytes);
+ssize_t write(int __fd, const void *__buf, size_t __n);
+/* Positioned I/O at __offset, without moving the file's own offset. */
+ssize_t pread(int __fd, void *__buf, size_t __nbytes, off_t __offset);
+ssize_t pwrite(int __fd, const void *__buf, size_t __n, off_t __offset);
+off_t   lseek(int __fd, off_t __offset, int __whence);
+int     pipe(int __pipedes[2]);
+int     dup(int __fd);
+int     dup2(int __fd, int __fd2);
+int     unlink(const char *__name);
+int     rmdir(const char *__path);
+int     chdir(const char *__path);
+char   *getcwd(char *__buf, size_t __size);
+int     fsync(int __fd);
+/* Linux exposes fdatasync() from <unistd.h>; bootsnap probes it and then calls
+   it when flushing its cache. Keep the declaration in the bundled surface so
+   the probe and the extension compile against the same measured ABI. */
+int     fdatasync(int __fd);
+int     ftruncate(int __fd, off_t __length);
+int     truncate(const char *__file, off_t __length);
+int     isatty(int __fd);
+char   *ttyname(int __fd);
+/* ttyname's POSIX reentrant pair: the caller supplies the buffer instead of
+   getting back a pointer into static storage. */
+int     ttyname_r(int __fd, char *__buf, size_t __buflen);
+int     link(const char *__from, const char *__to);
+int     symlink(const char *__from, const char *__to);
+ssize_t readlink(const char *__restrict __path, char *__restrict __buf, size_t __len);
+int     chown(const char *__file, uid_t __owner, gid_t __group);
+int     fchown(int __fd, uid_t __owner, gid_t __group);
+int     gethostname(char *__name, size_t __len);
+int     getpagesize(void);
+
+pid_t   fork(void);
+pid_t   getpid(void);
+pid_t   getppid(void);
+/* GNU's raw system-call escape hatch; libev's io_uring backend uses it when
+   the libc wrapper is not available. */
+long    syscall(long __number, ...);
+uid_t   getuid(void);
+uid_t   geteuid(void);
+gid_t   getgid(void);
+gid_t   getegid(void);
+int     setuid(uid_t __uid);
+int     setgid(gid_t __gid);
+
+unsigned int alarm(unsigned int __seconds);
+unsigned int sleep(unsigned int __seconds);
+int     usleep(useconds_t __useconds);
+int     pause(void);
+
+int     execv(const char *__path, char *const __argv[]);
+int     execvp(const char *__file, char *const __argv[]);
+int     execve(const char *__path, char *const __argv[], char *const __envp[]);
+int     execl(const char *__path, const char *__arg, ...);
+int     execlp(const char *__file, const char *__arg, ...);
+/* sysconf() is answered by the host's runtime libc, so its __name argument
+   must match the host's own numbering (glibc's <bits/confname.h> enum), not
+   a value rubycc invents. _SC_PAGE_SIZE is just an alias of _SC_PAGESIZE. */
+#define _SC_ARG_MAX          0
+#define _SC_CHILD_MAX        1
+#define _SC_CLK_TCK          2
+#define _SC_NGROUPS_MAX      3
+#define _SC_OPEN_MAX         4
+#define _SC_PAGESIZE         30
+#define _SC_PAGE_SIZE        _SC_PAGESIZE
+/* _SC_IOV_MAX answers how many struct iovec a single writev may carry; kgio's
+   writev.c asks for it once and caches the answer to size its own batches. */
+#define _SC_IOV_MAX          60
+#define _SC_NPROCESSORS_CONF 83
+#define _SC_NPROCESSORS_ONLN 84
+#define _SC_PHYS_PAGES       85
+#define _SC_AVPHYS_PAGES     86
+long    sysconf(int __name);
+
+/* confstr()/fpathconf()/pathconf() are likewise answered by the host's
+   runtime libc, so their __name arguments must match the host's own
+   <bits/confname.h> numbering, the same reasoning _SC_ rests on above
+   (measured with gcc on the reference platform; x86-64 and aarch64 agree to
+   the value, checked with a cross gcc + qemu run). Step 157 gap D: etc's
+   ext/etc/mkconstants.rb conditionally exposes about 50 _CS_ and _PC_ names
+   in total, and all of them exist on the host glibc, but the corpus has
+   exactly one consumer (etc) and its own test suite exercises only
+   Etc::CS_PATH and Etc::PC_PIPE_BUF (guarded by "if defined?", so the rest
+   silently vanishing costs coverage, not a failure). Following the same
+   non-exhaustive judgment as sys/syscall.h's number list and
+   _POSIX_MONOTONIC_CLOCK above, only those two are added -- the POSIX_V6/V7
+   build-environment names (CFLAGS/LDFLAGS/LIBS variants),
+   CS_GNU_LIBC_VERSION, CS_GNU_LIBPTHREAD_VERSION, and the rest of the SUSv4
+   _PC_ set have no consumer in the corpus and would just be an unconsumed
+   measurement surface to re-check every release. */
+#define _CS_PATH     0
+#define _PC_PIPE_BUF 5
+size_t  confstr(int __name, char *__buf, size_t __len);
+long    fpathconf(int __fd, int __name);
+/* pathconf() has no direct corpus consumer either (etc's io_pathconf() only
+   ever calls fpathconf()), but it is fpathconf()'s standard POSIX pair over
+   the same _PC_* names, its prototype carries no per-name numeric surface of
+   its own to re-measure, and this header's declaration layer is the general
+   POSIX surface (like execl/alarm/pause above) rather than a per-consumer
+   scoped one -- so it is kept alongside fpathconf() rather than left out. */
+long    pathconf(const char *__path, int __name);
+void    _exit(int __status) __attribute__((__noreturn__));
+void   *sbrk(intptr_t __delta);
+int     brk(void *__addr);
+
+/* getopt and its globals. */
+extern char *optarg;
+extern int optind, opterr, optopt;
+int getopt(int __argc, char *const __argv[], const char *__optstring);
+
+#endif /* _RUBYCC_UNISTD_H */

data/include/stdalign.h

@@ -0,0 +1,16 @@
+/* rubycc freestanding <stdalign.h>: alignment macros (ISO C 7.15).
+   alignas and alignof map onto rubycc's _Alignas specifier and _Alignof
+   operator, both of which the compiler implements. */
+
+#ifndef _RUBYCC_STDALIGN_H
+#define _RUBYCC_STDALIGN_H
+
+#ifndef __cplusplus
+#define alignas _Alignas
+#define alignof _Alignof
+#endif
+
+#define __alignas_is_defined 1
+#define __alignof_is_defined 1
+
+#endif

data/include/stdarg.h

@@ -0,0 +1,31 @@
+/* rubycc freestanding <stdarg.h>: variable arguments (ISO C 7.16).
+   Maps onto rubycc's __builtin_va_* intrinsics and __builtin_va_list. */
+
+/* __gnuc_va_list is provided for the glibc partial-include protocol
+   (stdio.h/wchar.h "#define __need___va_list" then include this). */
+#if !defined _RUBYCC_GNUC_VA_LIST
+#define _RUBYCC_GNUC_VA_LIST
+typedef __builtin_va_list __gnuc_va_list;
+#endif
+#undef __need___va_list
+
+/* __isoc_va_list is musl's name for the same type, where glibc writes
+   __gnuc_va_list. Both are provided unconditionally rather than per libc: they
+   are aliases of one type, so offering both costs nothing and lets a source
+   written against either libc's internal spelling compile. Repeating a typedef
+   with the same type is legal (C11 6.7p3), so a host header that defines its
+   own afterwards is not a conflict. Measured on musl in CI, where a probe
+   spelling it __isoc_va_list did not compile (docs/STEPS.md Step 190). */
+#if !defined _RUBYCC_ISOC_VA_LIST
+#define _RUBYCC_ISOC_VA_LIST
+typedef __builtin_va_list __isoc_va_list;
+#endif
+
+#ifndef _RUBYCC_STDARG_H
+#define _RUBYCC_STDARG_H
+typedef __builtin_va_list va_list;
+#define va_start(ap, last) __builtin_va_start(ap, last)
+#define va_arg(ap, type) __builtin_va_arg(ap, type)
+#define va_end(ap) __builtin_va_end(ap)
+#define va_copy(d, s) __builtin_va_copy(d, s)
+#endif