rubycc 1.0.0

data/include/libc/glibc/x86_64/sys/syscall.h

@@ -0,0 +1,188 @@
+/* rubycc bundled <sys/syscall.h> (x86-64): the system-call numbers, as the
+   SYS_ names callers pass to syscall(2). Provenance: clean room against the
+   Linux kernel's x86-64 system-call table, not derived from musl or glibc
+   source. Every number below was printed from the glibc oracle (an ABI fact,
+   not copied text -- see docs/HEADER-LICENSING.md sec. 4).
+
+   Arch layer, necessarily. glibc's <sys/syscall.h> is a thin shim that pulls
+   in <asm/unistd.h> and then defines each SYS_ name as an alias of the
+   corresponding __NR_ name, and __NR_ numbering is per-architecture: x86-64
+   carries its own historical table while aarch64 uses the modern
+   asm-generic one. Measured side by side, the two disagree on essentially
+   every entry -- SYS_read is 0 here and 63 there, SYS_write 1 vs 64,
+   SYS_openat 257 vs 56, SYS_epoll_ctl 233 vs 21 -- so there is no common
+   layer to be had and this header has an aarch64 sibling. The only
+   agreements found were the io_uring trio (425/426/427), which entered the
+   kernel late enough to be allocated from the shared modern range. The
+   __NR_/SYS_ two-level spelling is reproduced rather than collapsed because
+   callers do write __NR_ names directly, and because it is what makes the
+   `#if SYS_foo` feature tests third-party code performs behave as they do
+   against the real header.
+
+   Scope: this is deliberately NOT the whole table. glibc's copy is generated
+   from the kernel headers and runs to several hundred entries; reproducing
+   all of them by measurement would add a large surface with no consumer and
+   would need re-measuring on every kernel release. The set below is (a)
+   everything nio4r, the gem that put this header on the list, can reach --
+   libev routes clock_gettime, the eventfd/signalfd/inotify/epoll creation
+   calls, and its linuxaio and io_uring backends through raw syscall numbers
+   -- and (b) a representative core of process, memory, file and socket
+   calls, chosen so the numbering itself is verifiable across a wide span of
+   the table rather than at one end of it.
+
+   One consequence of the scope rule used here is worth stating: only names
+   that exist on BOTH targets are defined, so the two arch copies differ in
+   their numbers and in nothing else. That excludes the legacy x86-64-only
+   entry points (open, poll, select, pipe, dup2, access, unlink, rename,
+   creat, fork, and their kin), for which the asm-generic table aarch64 uses
+   has no entry at all -- their callers are expected to use the *at / *2 /
+   p* replacements that are listed below. No corpus census hit reaches any of
+   them through syscall(2).
+
+   Note that this header intentionally does not declare syscall() itself;
+   measured, neither does glibc's -- the prototype lives in <unistd.h>. */
+
+#ifndef _RUBYCC_SYS_SYSCALL_H
+#define _RUBYCC_SYS_SYSCALL_H
+
+/* Basic file I/O. */
+#define __NR_read     0
+#define __NR_write    1
+#define __NR_close    3
+#define __NR_lseek    8
+#define __NR_openat   257
+#define __NR_readlinkat 267
+#define __NR_faccessat  269
+#define __NR_ioctl    16
+#define __NR_fcntl    72
+#define __NR_pipe2    293
+#define __NR_dup3     292
+
+/* Filesystem statistics (the calls behind <sys/statfs.h>). */
+#define __NR_statfs   137
+#define __NR_fstatfs  138
+
+/* Memory. */
+#define __NR_mmap     9
+#define __NR_mprotect 10
+#define __NR_munmap   11
+
+/* Processes, threads and signals. */
+#define __NR_clone          56
+#define __NR_exit           60
+#define __NR_exit_group     231
+#define __NR_getpid         39
+#define __NR_gettid         186
+#define __NR_kill           62
+#define __NR_tgkill         234
+#define __NR_rt_sigaction   13
+#define __NR_rt_sigprocmask 14
+#define __NR_futex          202
+#define __NR_sched_yield    24
+#define __NR_getcpu         309
+#define __NR_membarrier     324
+#define __NR_getrandom      318
+
+/* Time. */
+#define __NR_nanosleep       35
+#define __NR_clock_gettime   228
+#define __NR_clock_nanosleep 230
+
+/* Event notification: the file-descriptor-based interfaces libev drives
+   through raw syscalls when the libc wrappers are not available. */
+#define __NR_epoll_create1     291
+#define __NR_epoll_ctl         233
+#define __NR_epoll_pwait       281
+#define __NR_ppoll             271
+#define __NR_pselect6          270
+#define __NR_eventfd2          290
+#define __NR_signalfd4         289
+#define __NR_inotify_init1     294
+#define __NR_inotify_add_watch 254
+#define __NR_inotify_rm_watch  255
+#define __NR_timerfd_create    283
+#define __NR_timerfd_settime   286
+#define __NR_timerfd_gettime   287
+
+/* Asynchronous I/O: the legacy linux-aio calls and io_uring. These have no
+   libc wrappers at all, which is why libev issues them by number. */
+#define __NR_io_setup          206
+#define __NR_io_destroy        207
+#define __NR_io_getevents      208
+#define __NR_io_submit         209
+#define __NR_io_cancel         210
+#define __NR_io_uring_setup    425
+#define __NR_io_uring_enter    426
+#define __NR_io_uring_register 427
+
+/* Sockets. */
+#define __NR_socket     41
+#define __NR_setsockopt 54
+
+/* The SYS_ spellings: aliases of the __NR_ names above, which is the
+   relationship measured against the real header. */
+#define SYS_read     __NR_read
+#define SYS_write    __NR_write
+#define SYS_close    __NR_close
+#define SYS_lseek    __NR_lseek
+#define SYS_openat   __NR_openat
+#define SYS_readlinkat __NR_readlinkat
+#define SYS_faccessat  __NR_faccessat
+#define SYS_ioctl    __NR_ioctl
+#define SYS_fcntl    __NR_fcntl
+#define SYS_pipe2    __NR_pipe2
+#define SYS_dup3     __NR_dup3
+
+#define SYS_statfs   __NR_statfs
+#define SYS_fstatfs  __NR_fstatfs
+
+#define SYS_mmap     __NR_mmap
+#define SYS_mprotect __NR_mprotect
+#define SYS_munmap   __NR_munmap
+
+#define SYS_clone          __NR_clone
+#define SYS_exit           __NR_exit
+#define SYS_exit_group     __NR_exit_group
+#define SYS_getpid         __NR_getpid
+#define SYS_gettid         __NR_gettid
+#define SYS_kill           __NR_kill
+#define SYS_tgkill         __NR_tgkill
+#define SYS_rt_sigaction   __NR_rt_sigaction
+#define SYS_rt_sigprocmask __NR_rt_sigprocmask
+#define SYS_futex          __NR_futex
+#define SYS_sched_yield    __NR_sched_yield
+#define SYS_getcpu         __NR_getcpu
+#define SYS_membarrier     __NR_membarrier
+#define SYS_getrandom      __NR_getrandom
+
+#define SYS_nanosleep       __NR_nanosleep
+#define SYS_clock_gettime   __NR_clock_gettime
+#define SYS_clock_nanosleep __NR_clock_nanosleep
+
+#define SYS_epoll_create1     __NR_epoll_create1
+#define SYS_epoll_ctl         __NR_epoll_ctl
+#define SYS_epoll_pwait       __NR_epoll_pwait
+#define SYS_ppoll             __NR_ppoll
+#define SYS_pselect6          __NR_pselect6
+#define SYS_eventfd2          __NR_eventfd2
+#define SYS_signalfd4         __NR_signalfd4
+#define SYS_inotify_init1     __NR_inotify_init1
+#define SYS_inotify_add_watch __NR_inotify_add_watch
+#define SYS_inotify_rm_watch  __NR_inotify_rm_watch
+#define SYS_timerfd_create    __NR_timerfd_create
+#define SYS_timerfd_settime   __NR_timerfd_settime
+#define SYS_timerfd_gettime   __NR_timerfd_gettime
+
+#define SYS_io_setup          __NR_io_setup
+#define SYS_io_destroy        __NR_io_destroy
+#define SYS_io_getevents      __NR_io_getevents
+#define SYS_io_submit         __NR_io_submit
+#define SYS_io_cancel         __NR_io_cancel
+#define SYS_io_uring_setup    __NR_io_uring_setup
+#define SYS_io_uring_enter    __NR_io_uring_enter
+#define SYS_io_uring_register __NR_io_uring_register
+
+#define SYS_socket     __NR_socket
+#define SYS_setsockopt __NR_setsockopt
+
+#endif /* _RUBYCC_SYS_SYSCALL_H */

data/include/libc/glibc/x86_64/sys/time.h

@@ -0,0 +1,74 @@
+/* rubycc bundled <sys/time.h>: struct timeval and the BSD time calls (POSIX).
+   Derived from musl's <sys/time.h> shape; struct timeval's members are pinned to
+   the glibc x86-64 ABI (time_t and suseconds_t are both `long`, giving a 16-byte
+   layout, measured). The struct guard reuses glibc's __timeval_defined. ABI
+   switch layer: the member widths are arch specific. */
+
+#ifndef _RUBYCC_SYS_TIME_H
+#define _RUBYCC_SYS_TIME_H
+
+#ifndef _RUBYCC_TIME_T
+#define _RUBYCC_TIME_T
+typedef long time_t;
+#endif
+#ifndef _RUBYCC_SUSECONDS_T
+#define _RUBYCC_SUSECONDS_T
+typedef long suseconds_t;
+#endif
+
+#ifndef __timeval_defined
+#define __timeval_defined 1
+struct timeval {
+  time_t      tv_sec;
+  suseconds_t tv_usec;
+};
+#endif
+
+struct timezone {
+  int tz_minuteswest;
+  int tz_dsttime;
+};
+
+struct itimerval {
+  struct timeval it_interval;
+  struct timeval it_value;
+};
+
+#define ITIMER_REAL    0
+#define ITIMER_VIRTUAL 1
+#define ITIMER_PROF    2
+
+int gettimeofday(struct timeval *__restrict __tv, void *__restrict __tz);
+int settimeofday(const struct timeval *__tv, const struct timezone *__tz);
+int getitimer(int __which, struct itimerval *__value);
+int setitimer(int __which, const struct itimerval *__restrict __new,
+              struct itimerval *__restrict __old);
+int utimes(const char *__file, const struct timeval __tvp[2]);
+
+/* Convenience timeval arithmetic macros (glibc/BSD, under _DEFAULT_SOURCE). */
+#define timerisset(tvp)   ((tvp)->tv_sec || (tvp)->tv_usec)
+#define timerclear(tvp)   ((tvp)->tv_sec = (tvp)->tv_usec = 0)
+#define timercmp(a, b, CMP) \
+  (((a)->tv_sec == (b)->tv_sec) ? \
+   ((a)->tv_usec CMP (b)->tv_usec) : \
+   ((a)->tv_sec CMP (b)->tv_sec))
+#define timeradd(a, b, result)                        \
+  do {                                                \
+    (result)->tv_sec = (a)->tv_sec + (b)->tv_sec;     \
+    (result)->tv_usec = (a)->tv_usec + (b)->tv_usec;  \
+    if ((result)->tv_usec >= 1000000) {               \
+      ++(result)->tv_sec;                             \
+      (result)->tv_usec -= 1000000;                   \
+    }                                                 \
+  } while (0)
+#define timersub(a, b, result)                        \
+  do {                                                \
+    (result)->tv_sec = (a)->tv_sec - (b)->tv_sec;     \
+    (result)->tv_usec = (a)->tv_usec - (b)->tv_usec;  \
+    if ((result)->tv_usec < 0) {                      \
+      --(result)->tv_sec;                             \
+      (result)->tv_usec += 1000000;                   \
+    }                                                 \
+  } while (0)
+
+#endif /* _RUBYCC_SYS_TIME_H */

data/include/libc/glibc/x86_64/sys/types.h

@@ -0,0 +1,123 @@
+/* rubycc bundled <sys/types.h>: the width-critical POSIX typedefs. Derived from
+   musl's <sys/types.h> shape; every width and signedness is pinned to the glibc
+   x86-64 LP64 ABI (measured): off_t/time_t/ssize_t are `long`, pid_t is `int`,
+   dev_t/ino_t/nlink_t are `unsigned long`. Each typedef is guarded by a shared
+   _RUBYCC_* tag so the other bundled headers that also spell these types agree
+   rather than redefine. ABI switch layer: the widths are arch specific. */
+
+#ifndef _RUBYCC_SYS_TYPES_H
+#define _RUBYCC_SYS_TYPES_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
+#ifndef _RUBYCC_OFF_T
+#define _RUBYCC_OFF_T
+typedef long off_t;
+#endif
+typedef long off64_t;
+typedef long loff_t;
+#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_MODE_T
+#define _RUBYCC_MODE_T
+typedef unsigned int mode_t;
+#endif
+#ifndef _RUBYCC_INO_T
+#define _RUBYCC_INO_T
+typedef unsigned long ino_t;
+#endif
+typedef unsigned long ino64_t;
+#ifndef _RUBYCC_DEV_T
+#define _RUBYCC_DEV_T
+typedef unsigned long dev_t;
+#endif
+#ifndef _RUBYCC_NLINK_T
+#define _RUBYCC_NLINK_T
+typedef unsigned long nlink_t;
+#endif
+#ifndef _RUBYCC_BLKSIZE_T
+#define _RUBYCC_BLKSIZE_T
+typedef long blksize_t;
+#endif
+#ifndef _RUBYCC_BLKCNT_T
+#define _RUBYCC_BLKCNT_T
+typedef long blkcnt_t;
+#endif
+typedef long blkcnt64_t;
+#ifndef _RUBYCC_FSBLKCNT_T
+#define _RUBYCC_FSBLKCNT_T
+typedef unsigned long fsblkcnt_t;
+#endif
+typedef unsigned long fsblkcnt64_t;
+#ifndef _RUBYCC_FSFILCNT_T
+#define _RUBYCC_FSFILCNT_T
+typedef unsigned long fsfilcnt_t;
+#endif
+typedef unsigned long fsfilcnt64_t;
+#ifndef _RUBYCC_TIME_T
+#define _RUBYCC_TIME_T
+typedef long time_t;
+#endif
+#ifndef _RUBYCC_CLOCK_T
+#define _RUBYCC_CLOCK_T
+typedef long clock_t;
+#endif
+#ifndef _RUBYCC_CLOCKID_T
+#define _RUBYCC_CLOCKID_T
+typedef int clockid_t;
+#endif
+#ifndef _RUBYCC_TIMER_T
+#define _RUBYCC_TIMER_T
+typedef void *timer_t;
+#endif
+#ifndef _RUBYCC_SUSECONDS_T
+#define _RUBYCC_SUSECONDS_T
+typedef long suseconds_t;
+#endif
+#ifndef _RUBYCC_USECONDS_T
+#define _RUBYCC_USECONDS_T
+typedef unsigned int useconds_t;
+#endif
+#ifndef _RUBYCC_ID_T
+#define _RUBYCC_ID_T
+typedef unsigned int id_t;
+#endif
+#ifndef _RUBYCC_KEY_T
+#define _RUBYCC_KEY_T
+typedef int key_t;
+#endif
+
+typedef long register_t;
+typedef int  daddr_t;
+typedef char *caddr_t;
+
+/* BSD short-hand integer names (glibc exposes them under _DEFAULT_SOURCE). */
+typedef unsigned char  u_char;
+typedef unsigned short u_short;
+typedef unsigned int   u_int;
+typedef unsigned long  u_long;
+typedef unsigned char  ushort;
+typedef unsigned int   uint;
+typedef unsigned long  ulong;
+typedef unsigned char  u_int8_t;
+typedef unsigned short u_int16_t;
+typedef unsigned int   u_int32_t;
+typedef unsigned long  u_int64_t;
+
+#endif /* _RUBYCC_SYS_TYPES_H */

data/include/libc/glibc/x86_64/time.h

@@ -0,0 +1,113 @@
+/* rubycc bundled <time.h>: the calendar/clock types and declarations (ISO C
+   7.27, POSIX). Derived from musl's <time.h> shape; time_t is pinned to `long`
+   and `struct tm` carries glibc's tm_gmtoff/tm_zone extension so its 56-byte
+   layout matches the reference ABI (measured). The struct guards reuse glibc's
+   (__struct_tm_defined, _STRUCT_TIMESPEC) so a host header coexisting on the
+   path does not redefine. ABI switch layer: time_t width and struct tm layout
+   are arch specific. */
+
+#ifndef _RUBYCC_TIME_H
+#define _RUBYCC_TIME_H
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+#ifndef _RUBYCC_SIZE_T
+#define _RUBYCC_SIZE_T
+typedef unsigned long size_t;
+#endif
+#ifndef _RUBYCC_TIME_T
+#define _RUBYCC_TIME_T
+typedef long time_t;
+#endif
+#ifndef _RUBYCC_CLOCK_T
+#define _RUBYCC_CLOCK_T
+typedef long clock_t;
+#endif
+#ifndef _RUBYCC_CLOCKID_T
+#define _RUBYCC_CLOCKID_T
+typedef int clockid_t;
+#endif
+#ifndef _RUBYCC_TIMER_T
+#define _RUBYCC_TIMER_T
+typedef void *timer_t;
+#endif
+#ifndef _RUBYCC_PID_T
+#define _RUBYCC_PID_T
+typedef int pid_t;
+#endif
+
+#define CLOCKS_PER_SEC ((clock_t) 1000000)
+#define TIME_UTC 1
+
+/* POSIX clock ids. */
+#define CLOCK_REALTIME           0
+#define CLOCK_MONOTONIC          1
+#define CLOCK_PROCESS_CPUTIME_ID 2
+#define CLOCK_THREAD_CPUTIME_ID  3
+#define CLOCK_MONOTONIC_RAW      4
+#define CLOCK_REALTIME_COARSE    5
+#define CLOCK_MONOTONIC_COARSE   6
+#define CLOCK_BOOTTIME           7
+#define TIMER_ABSTIME            1
+
+#ifndef _STRUCT_TIMESPEC
+#define _STRUCT_TIMESPEC 1
+struct timespec {
+  time_t tv_sec;
+  long   tv_nsec;
+};
+#endif
+
+#ifndef __struct_tm_defined
+#define __struct_tm_defined 1
+struct tm {
+  int tm_sec;
+  int tm_min;
+  int tm_hour;
+  int tm_mday;
+  int tm_mon;
+  int tm_year;
+  int tm_wday;
+  int tm_yday;
+  int tm_isdst;
+  long tm_gmtoff;
+  const char *tm_zone;
+};
+#endif
+
+struct itimerspec {
+  struct timespec it_interval;
+  struct timespec it_value;
+};
+
+clock_t clock(void);
+time_t time(time_t *__timer);
+double difftime(time_t __time1, time_t __time0);
+time_t mktime(struct tm *__tp);
+size_t strftime(char *__restrict __s, size_t __maxsize,
+                const char *__restrict __format, const struct tm *__restrict __tp);
+struct tm *gmtime(const time_t *__timer);
+struct tm *localtime(const time_t *__timer);
+struct tm *gmtime_r(const time_t *__restrict __timer, struct tm *__restrict __tp);
+struct tm *localtime_r(const time_t *__restrict __timer, struct tm *__restrict __tp);
+char *asctime(const struct tm *__tp);
+char *ctime(const time_t *__timer);
+char *asctime_r(const struct tm *__restrict __tp, char *__restrict __buf);
+char *ctime_r(const time_t *__restrict __timer, char *__restrict __buf);
+char *strptime(const char *__restrict __s, const char *__restrict __fmt, struct tm *__tp);
+
+int nanosleep(const struct timespec *__requested_time, struct timespec *__remaining);
+int clock_gettime(clockid_t __clock_id, struct timespec *__tp);
+int clock_settime(clockid_t __clock_id, const struct timespec *__tp);
+int clock_getres(clockid_t __clock_id, struct timespec *__res);
+time_t timegm(struct tm *__tp);
+time_t timelocal(struct tm *__tp);
+
+extern char *tzname[2];
+extern long timezone;
+extern int daylight;
+void tzset(void);
+
+#endif /* _RUBYCC_TIME_H */

data/include/libc/grp.h

@@ -0,0 +1,50 @@
+/* rubycc bundled <grp.h>: the group database access interface (POSIX.1 9.2.1).
+   Provenance: clean room against the POSIX public interface -- struct group's
+   member names, types and order are POSIX's own public contract, not glibc
+   implementation detail. Every member is used directly by callers, so it
+   cannot be an opaque byte blob; its size and every member's offset were
+   measured against the glibc oracle on both x86-64 and aarch64 (see
+   test/test_header_abi.rb's GRP case) and the two agreed exactly (an
+   all-pointer/gid_t struct has no arch-dependent field widths on either LP64
+   target), so this header lives in the common layer. gid_t reuses the shared
+   _RUBYCC_GID_T guard sys/types.h and unistd.h also carry. getgrnam/getgrgid/
+   getgrent/setgrent/endgrent/getgrnam_r/getgrgid_r are POSIX declarations
+   whose bodies resolve from the host libc at link time (the _r variants
+   answer through NSS, a host runtime fact, not something rubycc computes).
+   Not included: fgetgrent/putgrent (glibc/BSD extensions no corpus sample
+   census hit needs), left out to keep the surface to what etc's use of
+   getgrnam/getgrgid actually requires (Step 123, M5 H2). */
+
+#ifndef _RUBYCC_GRP_H
+#define _RUBYCC_GRP_H
+
+#ifndef _RUBYCC_SIZE_T
+#define _RUBYCC_SIZE_T
+typedef unsigned long size_t;
+#endif
+#ifndef _RUBYCC_GID_T
+#define _RUBYCC_GID_T
+typedef unsigned int gid_t;
+#endif
+
+/* A record in the group database. Member names, types and order are the
+   POSIX.1 public contract; every offset below was measured against the glibc
+   oracle on both x86-64 and aarch64 and the two agreed byte for byte. */
+struct group {
+  char *gr_name;   /* Group name. */
+  char *gr_passwd; /* Password. */
+  gid_t gr_gid;    /* Group ID. */
+  char **gr_mem;   /* Member list (NULL-terminated). */
+};
+
+struct group *getgrnam(const char *__name);
+struct group *getgrgid(gid_t __gid);
+struct group *getgrent(void);
+void setgrent(void);
+void endgrent(void);
+int getgrnam_r(const char *__restrict __name, struct group *__restrict __resultbuf,
+               char *__restrict __buffer, size_t __buflen, struct group **__restrict __result);
+int getgrgid_r(gid_t __gid, struct group *__restrict __resultbuf,
+               char *__restrict __buffer, size_t __buflen, struct group **__restrict __result);
+
+#endif /* _RUBYCC_GRP_H */

data/include/libc/langinfo.h

@@ -0,0 +1,126 @@
+/* rubycc bundled <langinfo.h>: locale-dependent string lookup (POSIX.1).
+   Provenance: clean room against the POSIX public interface and the glibc
+   runtime ABI, not derived from musl or glibc source. nl_langinfo is answered
+   by the host libc, so the nl_item numbers must match the host's own
+   enumeration exactly -- the same reasoning <locale.h>'s LC_* values and
+   <unistd.h>'s _SC_* values rest on -- and every value below was therefore
+   printed from the glibc oracle rather than guessed.
+
+   The numbering is not a flat sequence: an nl_item packs the locale category
+   in the upper 16 bits and an index within that category in the lower 16, so
+   e.g. D_T_FMT measures 0x20028 = category 2 (LC_TIME) index 40. That
+   composition was itself measured, not assumed: a probe compared rubycc's
+   own _NL_ITEM/_NL_ITEM_CATEGORY/_NL_ITEM_INDEX formulas against the glibc
+   oracle's over every (category, index) pair in range and found them equal,
+   and the category numbers the items carry match the LC_* values the bundled
+   <locale.h> already reproduces. The constants below are still written out as
+   their measured composed values so this header does not depend on
+   <locale.h> being included.
+
+   Common layer: every nl_item value measured identical on x86-64 and on
+   aarch64 (cross gcc + qemu), and nl_item is `int` (4 bytes) on both, so the
+   header is arch-neutral.
+
+   Not included: nl_langinfo_l (its locale_t parameter is part of the glibc
+   locale extension set the bundled <locale.h> deliberately leaves out), and
+   glibc's _NL_* internal item names beyond the three composition helpers.
+   nkf, the gem that put this header on the list, reaches nl_langinfo with the
+   POSIX item set. */
+
+#ifndef _RUBYCC_LANGINFO_H
+#define _RUBYCC_LANGINFO_H
+
+/* The item selector. Measured: 4 bytes, 4-byte aligned, signed. glibc reaches
+   for this typedef through <nl_types.h>; rubycc has no such header, so it is
+   given here under its own guard. */
+#ifndef _RUBYCC_NL_ITEM
+#define _RUBYCC_NL_ITEM
+typedef int nl_item;
+#endif
+
+/* The category/index composition, re-derived from the measured values (see
+   the note above): category in bits 16.., index in bits 0..15. */
+#define _NL_ITEM(category, index) (((category) << 16) | (index))
+#define _NL_ITEM_CATEGORY(item)   ((item) >> 16)
+#define _NL_ITEM_INDEX(item)      ((item) & 0xffff)
+
+/* LC_CTYPE items (category 0). */
+#define CODESET 14
+
+/* LC_NUMERIC items (category 1). DECIMAL_POINT / THOUSANDS_SEP are glibc's
+   alternate spellings of the same two items. */
+#define RADIXCHAR     0x10000
+#define THOUSEP       0x10001
+#define DECIMAL_POINT 0x10000
+#define THOUSANDS_SEP 0x10001
+
+/* LC_TIME items (category 2), in the order glibc numbers them: the seven
+   abbreviated day names, the seven full day names, the twelve abbreviated
+   month names, the twelve full month names, then the format strings. */
+#define ABDAY_1 0x20000
+#define ABDAY_2 0x20001
+#define ABDAY_3 0x20002
+#define ABDAY_4 0x20003
+#define ABDAY_5 0x20004
+#define ABDAY_6 0x20005
+#define ABDAY_7 0x20006
+
+#define DAY_1 0x20007
+#define DAY_2 0x20008
+#define DAY_3 0x20009
+#define DAY_4 0x2000a
+#define DAY_5 0x2000b
+#define DAY_6 0x2000c
+#define DAY_7 0x2000d
+
+#define ABMON_1  0x2000e
+#define ABMON_2  0x2000f
+#define ABMON_3  0x20010
+#define ABMON_4  0x20011
+#define ABMON_5  0x20012
+#define ABMON_6  0x20013
+#define ABMON_7  0x20014
+#define ABMON_8  0x20015
+#define ABMON_9  0x20016
+#define ABMON_10 0x20017
+#define ABMON_11 0x20018
+#define ABMON_12 0x20019
+
+#define MON_1  0x2001a
+#define MON_2  0x2001b
+#define MON_3  0x2001c
+#define MON_4  0x2001d
+#define MON_5  0x2001e
+#define MON_6  0x2001f
+#define MON_7  0x20020
+#define MON_8  0x20021
+#define MON_9  0x20022
+#define MON_10 0x20023
+#define MON_11 0x20024
+#define MON_12 0x20025
+
+#define AM_STR      0x20026
+#define PM_STR      0x20027
+#define D_T_FMT     0x20028
+#define D_FMT       0x20029
+#define T_FMT       0x2002a
+#define T_FMT_AMPM  0x2002b
+#define ERA         0x2002c
+#define ERA_D_FMT   0x2002e
+#define ALT_DIGITS  0x2002f
+#define ERA_D_T_FMT 0x20030
+#define ERA_T_FMT   0x20031
+
+/* LC_MONETARY item (category 4). */
+#define CRNCYSTR 0x4000f
+
+/* LC_MESSAGES items (category 5). YESSTR / NOSTR are glibc legacy items kept
+   for callers that still ask for them. */
+#define YESEXPR 0x50000
+#define NOEXPR  0x50001
+#define YESSTR  0x50002
+#define NOSTR   0x50003
+
+char *nl_langinfo(nl_item __item);
+
+#endif /* _RUBYCC_LANGINFO_H */

data/include/libc/link.h

@@ -0,0 +1,18 @@
+/* Clean-room ABI subset: rubycc bundled <link.h> exposes the leading fields of
+   glibc's link_map ABI used by
+   dlinfo(RTLD_DI_LINKMAP). The dynamic-loader extension only exposes the
+   object's load bias and name to this C subset; the remaining loader-private
+   fields are deliberately not presented as a false public surface. */
+
+#ifndef _RUBYCC_LINK_H
+#define _RUBYCC_LINK_H
+
+struct link_map {
+    unsigned long l_addr;
+    char *l_name;
+    void *l_ld;
+    struct link_map *l_next;
+    struct link_map *l_prev;
+};
+
+#endif /* _RUBYCC_LINK_H */