rubycc 1.0.0

data/include/libc/signal.h

@@ -0,0 +1,204 @@
+/* rubycc bundled <signal.h>: the signal numbers, sigset_t / siginfo_t /
+   struct sigaction and the POSIX signalling calls. Provenance: clean room
+   against the Linux kernel UAPI and the glibc signal ABI (bits/signum-generic.h,
+   bits/signum-arch.h, bits/types/siginfo_t.h, bits/sigaction.h), not derived
+   from musl or glibc source. The signal numbers, the SA_ flag values and the
+   sigset_t / siginfo_t / struct sigaction layouts are that ABI reproduced as
+   measured integer constants and measured field offsets (an ABI fact, not
+   copied text -- see docs/HEADER-LICENSING.md), the same treatment as errno.h
+   and fcntl.h. signal, raise, kill, sigaction, the sigset_t manipulators and
+   kin are POSIX declarations whose bodies resolve from the host libc at link
+   time (the same way errno.h's __errno_location does), including glibc's
+   __libc_current_sigrtmin / __libc_current_sigrtmax behind SIGRTMIN / SIGRTMAX.
+   Common layer: every signal number, SA_ flag and struct layout (sigset_t,
+   siginfo_t and struct sigaction all included) is identical on x86-64 and
+   aarch64 -- both use glibc's generic sigaction with the trailing sa_restorer
+   and the 128-byte sigset_t / siginfo_t. sigset_t's typedef guard and
+   spelling (__sigset_t_defined / __sigset_t) are shared literally with
+   <sys/select.h>, so a program that pulls in both headers -- directly or via
+   ruby.h's <sys/select.h> include -- does not hit a conflicting redefinition,
+   regardless of which header is included first. */
+
+#ifndef _RUBYCC_SIGNAL_H
+#define _RUBYCC_SIGNAL_H
+
+#ifndef _RUBYCC_SIG_ATOMIC_T
+#define _RUBYCC_SIG_ATOMIC_T
+typedef int sig_atomic_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
+
+/* The signal-handler function-pointer type. */
+typedef void (*__sighandler_t)(int);
+
+/* Handler sentinels: default action, ignore, and the error return of signal. */
+#define SIG_DFL ((__sighandler_t) 0)
+#define SIG_IGN ((__sighandler_t) 1)
+#define SIG_ERR ((__sighandler_t) -1)
+
+/* The signal set: 128 bytes, 8-byte aligned (measured, both arches). The
+   typedef guard and spelling (__sigset_t_defined / __sigset_t) are shared
+   literally with <sys/select.h>, so the two headers do not redefine sigset_t
+   regardless of which one is included first. */
+#ifndef __sigset_t_defined
+#define __sigset_t_defined 1
+typedef struct { unsigned long __val[1024 / (8 * sizeof(unsigned long))]; } __sigset_t;
+typedef __sigset_t sigset_t;
+#endif
+
+/* The value delivered with a queued signal (POSIX real-time signals). */
+union sigval {
+  int   sival_int;
+  void *sival_ptr;
+};
+
+/* siginfo_t: 128 bytes, 8-byte aligned (measured). The common fields sit at
+   fixed offsets ahead of the _sifields union; the union's largest member is the
+   28-int pad that fixes the total size. The user-facing member names below are
+   provided as macros onto the union arms, exactly as glibc's ABI exposes them,
+   so si_pid / si_addr / si_band and kin resolve to the measured offsets. */
+typedef struct {
+  int si_signo;   /* offset 0 */
+  int si_errno;   /* offset 4 */
+  int si_code;    /* offset 8 */
+  int __pad0;     /* offset 12 */
+  union {
+    int __pad[28];
+    /* kill / SIGCHLD. */
+    struct {
+      pid_t si_pid;
+      uid_t si_uid;
+      int   si_status;
+    } __sigchld;
+    /* SIGSEGV / SIGBUS / SIGILL / SIGFPE. */
+    struct {
+      void *si_addr;
+    } __sigfault;
+    /* Real-time signal (sigqueue). */
+    struct {
+      pid_t si_pid;
+      uid_t si_uid;
+      union sigval si_value;
+    } __rt;
+    /* SIGPOLL / SIGIO. */
+    struct {
+      long si_band;
+      int  si_fd;
+    } __sigpoll;
+  } _sifields;
+} siginfo_t;
+
+#define si_pid    _sifields.__sigchld.si_pid
+#define si_uid    _sifields.__sigchld.si_uid
+#define si_status _sifields.__sigchld.si_status
+#define si_addr   _sifields.__sigfault.si_addr
+#define si_value  _sifields.__rt.si_value
+#define si_band   _sifields.__sigpoll.si_band
+#define si_fd     _sifields.__sigpoll.si_fd
+
+/* struct sigaction: 152 bytes, 8-byte aligned (measured, both arches). The
+   handler union is first, then the 128-byte sa_mask, sa_flags at offset 136 and
+   the trailing sa_restorer at offset 144. */
+struct sigaction {
+  union {
+    __sighandler_t sa_handler;
+    void (*sa_sigaction)(int, siginfo_t *, void *);
+  } __sigaction_handler;
+  sigset_t sa_mask;           /* offset 8 */
+  int sa_flags;               /* offset 136 */
+  void (*sa_restorer)(void);  /* offset 144 */
+};
+
+#define sa_handler   __sigaction_handler.sa_handler
+#define sa_sigaction __sigaction_handler.sa_sigaction
+
+/* Signal numbers (Linux kernel ABI). */
+#define SIGHUP     1
+#define SIGINT     2
+#define SIGQUIT    3
+#define SIGILL     4
+#define SIGTRAP    5
+#define SIGABRT    6
+#define SIGBUS     7
+#define SIGFPE     8
+#define SIGKILL    9
+#define SIGUSR1   10
+#define SIGSEGV   11
+#define SIGUSR2   12
+#define SIGPIPE   13
+#define SIGALRM   14
+#define SIGTERM   15
+#define SIGSTKFLT 16
+#define SIGCHLD   17
+#define SIGCONT   18
+#define SIGSTOP   19
+#define SIGTSTP   20
+#define SIGTTIN   21
+#define SIGTTOU   22
+#define SIGURG    23
+#define SIGXCPU   24
+#define SIGXFSZ   25
+#define SIGVTALRM 26
+#define SIGPROF   27
+#define SIGWINCH  28
+#define SIGIO     29
+#define SIGPWR    30
+#define SIGSYS    31
+
+/* Historical aliases. */
+#define SIGIOT  SIGABRT
+#define SIGCLD  SIGCHLD
+#define SIGPOLL SIGIO
+
+/* The signal-number ceiling and the real-time base. */
+#define _NSIG 65
+#define NSIG  _NSIG
+#define __SIGRTMIN 32
+
+/* The usable real-time signal range is a runtime property in glibc (the loader
+   reserves the lowest few for its own use), so SIGRTMIN / SIGRTMAX are function
+   calls, not constants; the bodies resolve from the host libc at link time. */
+extern int __libc_current_sigrtmin(void);
+extern int __libc_current_sigrtmax(void);
+#define SIGRTMIN (__libc_current_sigrtmin())
+#define SIGRTMAX (__libc_current_sigrtmax())
+
+/* sigprocmask direction (POSIX). */
+#define SIG_BLOCK   0
+#define SIG_UNBLOCK 1
+#define SIG_SETMASK 2
+
+/* struct sigaction flags. */
+#define SA_NOCLDSTOP 1
+#define SA_NOCLDWAIT 2
+#define SA_SIGINFO   4
+#define SA_ONSTACK   0x08000000
+#define SA_RESTART   0x10000000
+#define SA_NODEFER   0x40000000
+#define SA_RESETHAND 0x80000000
+
+/* BSD aliases. */
+#define SA_NOMASK  SA_NODEFER
+#define SA_ONESHOT SA_RESETHAND
+
+__sighandler_t signal(int __sig, __sighandler_t __handler);
+int raise(int __sig);
+int kill(pid_t __pid, int __sig);
+int sigaction(int __sig, const struct sigaction *__act, struct sigaction *__oact);
+int sigprocmask(int __how, const sigset_t *__set, sigset_t *__oset);
+int sigemptyset(sigset_t *__set);
+int sigfillset(sigset_t *__set);
+int sigaddset(sigset_t *__set, int __signo);
+int sigdelset(sigset_t *__set, int __signo);
+int sigismember(const sigset_t *__set, int __signo);
+int sigpending(sigset_t *__set);
+int sigsuspend(const sigset_t *__set);
+
+#endif /* _RUBYCC_SIGNAL_H */

data/include/libc/stdio.h

@@ -0,0 +1,157 @@
+/* rubycc bundled <stdio.h>: the standard I/O declarations and macros (ISO C
+   7.21, POSIX). Derived from musl's <stdio.h> declaration set. FILE is kept
+   opaque (an incomplete `struct _IO_FILE`, glibc's tag, reached only through
+   FILE*), which is all ruby.h and the surveyed gems need. The macro values
+   (BUFSIZ, TMP_MAX, ...) are measured, and the three of them the two C
+   libraries disagree on are carried under __RUBYCC_LIBC_MUSL__ (see the
+   preprocessor's LIBCS). Common layer: only FILE* crosses the ABI and it is a
+   pointer, so nothing here is width sensitive. */
+
+#ifndef _RUBYCC_STDIO_H
+#define _RUBYCC_STDIO_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_GNUC_VA_LIST
+#define _RUBYCC_GNUC_VA_LIST
+typedef __builtin_va_list __gnuc_va_list;
+#endif
+/* musl's spelling of the same type; see the note in <stdarg.h>. */
+#ifndef _RUBYCC_ISOC_VA_LIST
+#define _RUBYCC_ISOC_VA_LIST
+typedef __builtin_va_list __isoc_va_list;
+#endif
+
+/* FILE: opaque. glibc's tag and guard, so a host <stdio.h> reached later is a
+   no-op and code that spells `struct _IO_FILE` stays compatible. */
+#ifndef __FILE_defined
+#define __FILE_defined 1
+struct _IO_FILE;
+typedef struct _IO_FILE FILE;
+#endif
+
+/* fpos_t: opaque but sized to match glibc's 16-byte layout, in case a caller
+   stores one by value. */
+#ifndef _RUBYCC_FPOS_T
+#define _RUBYCC_FPOS_T
+typedef struct { long __pos; struct { int __count; int __value; } __state; } fpos_t;
+#endif
+
+#define EOF (-1)
+
+#define SEEK_SET 0
+#define SEEK_CUR 1
+#define SEEK_END 2
+
+#define _IOFBF 0
+#define _IOLBF 1
+#define _IONBF 2
+
+/* BUFSIZ, FOPEN_MAX and TMP_MAX are the three values in this header the two C
+   libraries disagree on: musl reports 1024, 1000 and 10000 where glibc reports
+   8192, 16 and 238328. All six measured with the ABI harness, glibc's on this
+   host and musl's on the CI musl run (docs/STEPS.md Step 193). EOF, the SEEK_*
+   and _IO*BF sets, FILENAME_MAX and L_tmpnam are probed too and measured
+   identical on both; L_ctermid and P_tmpdir are not probed on either. */
+#if defined(__RUBYCC_LIBC_MUSL__)
+#define BUFSIZ       1024
+#define FOPEN_MAX    1000
+#define TMP_MAX      10000
+#else
+#define BUFSIZ       8192
+#define FOPEN_MAX    16
+#define TMP_MAX      238328
+#endif
+#define FILENAME_MAX 4096
+#define L_tmpnam     20
+#define L_ctermid    9
+#define P_tmpdir     "/tmp"
+
+extern FILE *stdin;
+extern FILE *stdout;
+extern FILE *stderr;
+#define stdin  stdin
+#define stdout stdout
+#define stderr stderr
+
+int    remove(const char *__filename);
+int    rename(const char *__old, const char *__new);
+FILE  *tmpfile(void);
+char  *tmpnam(char *__s);
+
+int    fclose(FILE *__stream);
+int    fflush(FILE *__stream);
+FILE  *fopen(const char *__restrict __filename, const char *__restrict __modes);
+FILE  *freopen(const char *__restrict __filename, const char *__restrict __modes, FILE *__restrict __stream);
+FILE  *fdopen(int __fd, const char *__modes);
+void   setbuf(FILE *__restrict __stream, char *__restrict __buf);
+int    setvbuf(FILE *__restrict __stream, char *__restrict __buf, int __modes, size_t __n);
+
+int    fprintf(FILE *__restrict __stream, const char *__restrict __format, ...);
+int    printf(const char *__restrict __format, ...);
+int    sprintf(char *__restrict __s, const char *__restrict __format, ...);
+int    snprintf(char *__restrict __s, size_t __maxlen, const char *__restrict __format, ...);
+int    vfprintf(FILE *__restrict __stream, const char *__restrict __format, __gnuc_va_list __arg);
+int    vprintf(const char *__restrict __format, __gnuc_va_list __arg);
+int    vsprintf(char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg);
+int    vsnprintf(char *__restrict __s, size_t __maxlen, const char *__restrict __format, __gnuc_va_list __arg);
+int    dprintf(int __fd, const char *__restrict __format, ...);
+int    asprintf(char **__restrict __ptr, const char *__restrict __format, ...);
+int    vasprintf(char **__restrict __ptr, const char *__restrict __format, __gnuc_va_list __arg);
+
+int    fscanf(FILE *__restrict __stream, const char *__restrict __format, ...);
+int    scanf(const char *__restrict __format, ...);
+int    sscanf(const char *__restrict __s, const char *__restrict __format, ...);
+int    vfscanf(FILE *__restrict __stream, const char *__restrict __format, __gnuc_va_list __arg);
+int    vscanf(const char *__restrict __format, __gnuc_va_list __arg);
+int    vsscanf(const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg);
+
+int    fgetc(FILE *__stream);
+int    getc(FILE *__stream);
+int    getchar(void);
+int    fputc(int __c, FILE *__stream);
+int    putc(int __c, FILE *__stream);
+int    putchar(int __c);
+int    ungetc(int __c, FILE *__stream);
+
+char  *fgets(char *__restrict __s, int __n, FILE *__restrict __stream);
+int    fputs(const char *__restrict __s, FILE *__restrict __stream);
+int    puts(const char *__s);
+ssize_t getline(char **__restrict __lineptr, size_t *__restrict __n, FILE *__restrict __stream);
+ssize_t getdelim(char **__restrict __lineptr, size_t *__restrict __n, int __delimiter, FILE *__restrict __stream);
+
+size_t fread(void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream);
+size_t fwrite(const void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream);
+
+int    fseek(FILE *__stream, long __off, int __whence);
+long   ftell(FILE *__stream);
+void   rewind(FILE *__stream);
+int    fseeko(FILE *__stream, off_t __off, int __whence);
+off_t  ftello(FILE *__stream);
+int    fgetpos(FILE *__restrict __stream, fpos_t *__restrict __pos);
+int    fsetpos(FILE *__stream, const fpos_t *__pos);
+
+void   clearerr(FILE *__stream);
+int    feof(FILE *__stream);
+int    ferror(FILE *__stream);
+int    fileno(FILE *__stream);
+void   perror(const char *__s);
+
+FILE  *popen(const char *__command, const char *__modes);
+int    pclose(FILE *__stream);
+
+#endif /* _RUBYCC_STDIO_H */

data/include/libc/stdlib.h

@@ -0,0 +1,92 @@
+/* rubycc bundled <stdlib.h>: general utilities (ISO C 7.22, POSIX). Derived from
+   musl's <stdlib.h> declaration set; div_t/ldiv_t/lldiv_t carry the LP64 layout
+   (measured: ldiv_t is two `long`s), and RAND_MAX/EXIT_* are the glibc values.
+   Common layer: the div_t family layout is the same on any LP64 target. */
+
+#ifndef _RUBYCC_STDLIB_H
+#define _RUBYCC_STDLIB_H
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+#ifndef _RUBYCC_SIZE_T
+#define _RUBYCC_SIZE_T
+typedef unsigned long size_t;
+#endif
+#ifndef _RUBYCC_WCHAR_T
+#define _RUBYCC_WCHAR_T
+typedef int wchar_t;
+#endif
+
+typedef struct { int quot; int rem; } div_t;
+typedef struct { long quot; long rem; } ldiv_t;
+typedef struct { long long quot; long long rem; } lldiv_t;
+
+#define EXIT_SUCCESS 0
+#define EXIT_FAILURE 1
+#define RAND_MAX     2147483647
+
+extern size_t __ctype_get_mb_cur_max(void);
+#define MB_CUR_MAX (__ctype_get_mb_cur_max())
+
+double  atof(const char *__nptr);
+int     atoi(const char *__nptr);
+long    atol(const char *__nptr);
+long long atoll(const char *__nptr);
+
+double      strtod(const char *__restrict __nptr, char **__restrict __endptr);
+float       strtof(const char *__restrict __nptr, char **__restrict __endptr);
+long double strtold(const char *__restrict __nptr, char **__restrict __endptr);
+long        strtol(const char *__restrict __nptr, char **__restrict __endptr, int __base);
+unsigned long strtoul(const char *__restrict __nptr, char **__restrict __endptr, int __base);
+long long   strtoll(const char *__restrict __nptr, char **__restrict __endptr, int __base);
+unsigned long long strtoull(const char *__restrict __nptr, char **__restrict __endptr, int __base);
+
+int    rand(void);
+void   srand(unsigned int __seed);
+long   random(void);
+void   srandom(unsigned int __seed);
+
+void  *malloc(size_t __size);
+void  *calloc(size_t __nmemb, size_t __size);
+void  *realloc(void *__ptr, size_t __size);
+void   free(void *__ptr);
+void  *aligned_alloc(size_t __alignment, size_t __size);
+void  *reallocarray(void *__ptr, size_t __nmemb, size_t __size);
+int    posix_memalign(void **__memptr, size_t __alignment, size_t __size);
+
+void   abort(void) __attribute__((__noreturn__));
+int    atexit(void (*__func)(void));
+int    at_quick_exit(void (*__func)(void));
+void   exit(int __status) __attribute__((__noreturn__));
+void   quick_exit(int __status) __attribute__((__noreturn__));
+void   _Exit(int __status) __attribute__((__noreturn__));
+
+char  *getenv(const char *__name);
+int    setenv(const char *__name, const char *__value, int __replace);
+int    unsetenv(const char *__name);
+int    putenv(char *__string);
+int    system(const char *__command);
+char  *realpath(const char *__restrict __name, char *__restrict __resolved);
+int    mkstemp(char *__template);
+
+void  *bsearch(const void *__key, const void *__base, size_t __nmemb, size_t __size,
+               int (*__compar)(const void *, const void *));
+void   qsort(void *__base, size_t __nmemb, size_t __size,
+             int (*__compar)(const void *, const void *));
+
+int    abs(int __x);
+long   labs(long __x);
+long long llabs(long long __x);
+div_t  div(int __numer, int __denom);
+ldiv_t ldiv(long __numer, long __denom);
+lldiv_t lldiv(long long __numer, long long __denom);
+
+int    mblen(const char *__s, size_t __n);
+int    mbtowc(wchar_t *__restrict __pwc, const char *__restrict __s, size_t __n);
+int    wctomb(char *__s, wchar_t __wchar);
+size_t mbstowcs(wchar_t *__restrict __pwcs, const char *__restrict __s, size_t __n);
+size_t wcstombs(char *__restrict __s, const wchar_t *__restrict __pwcs, size_t __n);
+
+#endif /* _RUBYCC_STDLIB_H */

data/include/libc/string.h

@@ -0,0 +1,74 @@
+/* rubycc bundled <string.h>: the memory- and string-manipulation declarations
+   (ISO C 7.24, POSIX). Derived from musl's <string.h> declaration set, kept as
+   pure prototypes (size_t is the only ABI-typed name, shared via _RUBYCC_SIZE_T)
+   so nothing here is arch specific. Common layer. */
+
+#ifndef _RUBYCC_STRING_H
+#define _RUBYCC_STRING_H
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+#ifndef _RUBYCC_SIZE_T
+#define _RUBYCC_SIZE_T
+typedef unsigned long size_t;
+#endif
+
+void *memcpy(void *__restrict __dest, const void *__restrict __src, size_t __n);
+void *memmove(void *__dest, const void *__src, size_t __n);
+void *memset(void *__s, int __c, size_t __n);
+int   memcmp(const void *__s1, const void *__s2, size_t __n);
+void *memchr(const void *__s, int __c, size_t __n);
+
+char  *strcpy(char *__restrict __dest, const char *__restrict __src);
+char  *strncpy(char *__restrict __dest, const char *__restrict __src, size_t __n);
+char  *strcat(char *__restrict __dest, const char *__restrict __src);
+char  *strncat(char *__restrict __dest, const char *__restrict __src, size_t __n);
+int    strcmp(const char *__s1, const char *__s2);
+int    strncmp(const char *__s1, const char *__s2, size_t __n);
+int    strcoll(const char *__s1, const char *__s2);
+size_t strxfrm(char *__restrict __dest, const char *__restrict __src, size_t __n);
+
+char  *strchr(const char *__s, int __c);
+char  *strrchr(const char *__s, int __c);
+size_t strcspn(const char *__s, const char *__reject);
+size_t strspn(const char *__s, const char *__accept);
+char  *strpbrk(const char *__s, const char *__accept);
+char  *strstr(const char *__haystack, const char *__needle);
+char  *strtok(char *__restrict __s, const char *__restrict __delim);
+char  *strtok_r(char *__restrict __s, const char *__restrict __delim, char **__restrict __save_ptr);
+
+size_t strlen(const char *__s);
+size_t strnlen(const char *__s, size_t __maxlen);
+
+char  *strerror(int __errnum);
+int    strerror_r(int __errnum, char *__buf, size_t __buflen);
+
+char  *strdup(const char *__s);
+char  *strndup(const char *__s, size_t __n);
+
+/* POSIX/glibc extensions commonly relied on. */
+void  *memccpy(void *__restrict __dest, const void *__restrict __src, int __c, size_t __n);
+void  *mempcpy(void *__restrict __dest, const void *__restrict __src, size_t __n);
+void  *memmem(const void *__haystack, size_t __haystacklen, const void *__needle, size_t __needlelen);
+void  *memrchr(const void *__s, int __c, size_t __n);
+char  *stpcpy(char *__restrict __dest, const char *__restrict __src);
+char  *stpncpy(char *__restrict __dest, const char *__restrict __src, size_t __n);
+/* BSD size-bounded copies, in glibc since 2.38; used by date's strftime. */
+size_t strlcpy(char *__restrict __dest, const char *__restrict __src, size_t __size);
+size_t strlcat(char *__restrict __dest, const char *__restrict __src, size_t __size);
+char  *strsep(char **__restrict __stringp, const char *__restrict __delim);
+char  *strchrnul(const char *__s, int __c);
+char  *strcasestr(const char *__haystack, const char *__needle);
+char  *strsignal(int __sig);
+
+/* glibc's <string.h> pulls in <strings.h> under __USE_MISC (the default GNU
+   environment), so a translation unit that includes only <string.h> still sees
+   strcasecmp/strncasecmp. Real-world sources (e.g. redcarpet's autolink.c) rely
+   on that, so mirror it here. Our headers don't gate glibc extensions behind
+   feature-test macros, so include it unconditionally. The lone overlapping
+   prototype (memchr) is an identical, compatible redeclaration. */
+#include <strings.h>
+
+#endif /* _RUBYCC_STRING_H */

data/include/libc/strings.h

@@ -0,0 +1,25 @@
+/* rubycc bundled <strings.h>: the BSD byte-string declarations (POSIX). Derived
+   from musl's <strings.h> declaration set; pure prototypes, nothing arch
+   specific. Common layer. */
+
+#ifndef _RUBYCC_STRINGS_H
+#define _RUBYCC_STRINGS_H
+
+#ifndef _RUBYCC_SIZE_T
+#define _RUBYCC_SIZE_T
+typedef unsigned long size_t;
+#endif
+
+int  bcmp(const void *__s1, const void *__s2, size_t __n);
+void bcopy(const void *__src, void *__dest, size_t __n);
+void bzero(void *__s, size_t __n);
+void *memchr(const void *__s, int __c, size_t __n);
+int  ffs(int __i);
+int  ffsl(long __i);
+int  ffsll(long long __i);
+char *index(const char *__s, int __c);
+char *rindex(const char *__s, int __c);
+int  strcasecmp(const char *__s1, const char *__s2);
+int  strncasecmp(const char *__s1, const char *__s2, size_t __n);
+
+#endif /* _RUBYCC_STRINGS_H */

data/include/libc/sys/cdefs.h

@@ -0,0 +1,126 @@
+/* rubycc bundled <sys/cdefs.h>: the glibc compiler-abstraction macros
+   (__BEGIN_DECLS, __THROW, __attribute_* and kin) that glibc's own headers lean
+   on. Written clean room against glibc's published macro contract rather than
+   derived from musl (which has no equivalent) or copied from glibc: the bodies
+   reproduce the observable behaviour (a name that expands to a usable attribute
+   or to nothing), not glibc's source. Common layer: the definitions are the same
+   for any x86-64 target. */
+
+#ifndef _RUBYCC_SYS_CDEFS_H
+#define _RUBYCC_SYS_CDEFS_H
+
+/* glibc's own guard, so a later real <sys/cdefs.h> (reached via the host path in
+   the non-distroless configuration) becomes a no-op and does not redefine. */
+#ifndef _SYS_CDEFS_H
+#define _SYS_CDEFS_H 1
+
+#ifdef __cplusplus
+# define __BEGIN_DECLS extern "C" {
+# define __END_DECLS   }
+#else
+# define __BEGIN_DECLS
+# define __END_DECLS
+#endif
+
+/* Token-pasting and stringizing helpers. */
+#define __CONCAT(x, y) x ## y
+#define __STRING(x)    #x
+
+/* Pre-standard spellings still used by a few headers. */
+#define __P(args)      args
+#define __PMT(args)    args
+#define __ptr_t        void *
+
+/* GCC version predicate. rubycc identifies as a recent GCC-compatible compiler,
+   so headers gate their newest spellings on this. */
+#if defined __GNUC__ && defined __GNUC_MINOR__
+# define __GNUC_PREREQ(maj, min) \
+    ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
+#else
+# define __GNUC_PREREQ(maj, min) 0
+#endif
+
+#ifndef __glibc_clang_prereq
+# define __glibc_clang_prereq(maj, min) 0
+#endif
+
+/* Function-annotation macros. They carry no ABI meaning, so expanding them to
+   nothing (or, for the wrappers, to their argument) is behaviourally faithful
+   while keeping the token stream simple. */
+#define __THROW
+#define __THROWNL
+#define __NTH(fct)   fct
+#define __NTHNL(fct) fct
+
+#define __attribute_malloc__
+#define __attribute_pure__
+#define __attribute_const__
+#define __attribute_used__
+#define __attribute_unused__
+#define __attribute_noinline__
+#define __attribute_deprecated__
+#define __attribute_deprecated_msg__(msg)
+#define __attribute_warn_unused_result__
+#define __attribute_alloc_size__(params)
+#define __attribute_alloc_align__(param)
+#define __attribute_nonstring__
+#define __attribute_maybe_unused__
+#define __attribute_returns_twice__
+#define __attribute_format_arg__(x)
+#define __attribute_format_strfmon__(a, b)
+#define __wur
+#define __result_use_check
+#define __COLD
+
+#define __nonnull(params)
+#define __always_inline    __inline
+#define __extern_inline    extern __inline
+#define __extern_always_inline extern __inline
+#define __fortify_function __extern_always_inline __attribute_artificial__
+#define __attribute_artificial__
+
+/* restrict/inline keyword spellings for pre-C99 fallbacks. */
+#ifndef __restrict
+# define __restrict restrict
+#endif
+#define __restrict_arr
+
+/* Branch-prediction hints: identities without the underlying builtin. */
+#define __glibc_likely(cond)   (cond)
+#define __glibc_unlikely(cond) (cond)
+#define __glibc_unsigned_or_positive(v) 1
+
+/* Flexible array members: C99 spelling is available. */
+#define __flexarr [ ]
+#define __glibc_c99_flexarr_available 1
+#define __glibc_flexarr_length(arr)   1
+
+/* Symbol-redirection and asm-name helpers: the plain (unredirected) form is what
+   a bundled libc offers, so these degrade to a straight declaration. */
+#define __ASMNAME(cname)  cname
+#define __ASMNAME2(prefix, cname) cname
+#define __REDIRECT(name, proto, alias)     name proto
+#define __REDIRECT_NTH(name, proto, alias) name proto
+#define __REDIRECT_NTHNL(name, proto, alias) name proto
+#define __LDBL_REDIR(name, proto)     name proto
+#define __LDBL_REDIR_NTH(name, proto) name proto
+#define __LDBL_REDIR1(name, proto, alias) name proto
+#define __LDBL_REDIR1_NTH(name, proto, alias) name proto
+#define __LDBL_REDIR_DECL(name)
+
+/* Variadic-macro argument pack forwarding (GCC builtins). */
+#define __va_arg_pack()       __builtin_va_arg_pack()
+#define __va_arg_pack_len()   __builtin_va_arg_pack_len()
+
+/* Bounds/fortify plumbing: no fortification, no BOS instrumentation. */
+#define __bos(ptr)  __builtin_object_size(ptr, __USE_FORTIFY_LEVEL > 1)
+#define __bos0(ptr) __builtin_object_size(ptr, 0)
+#define __glibc_objsize(obj)  __bos(obj)
+#define __glibc_objsize0(obj) __bos0(obj)
+
+/* Wide-character / locale plumbing spellings some headers reference. */
+#define __LEAF
+#define __LEAF_ATTR
+
+#endif /* !_SYS_CDEFS_H */
+#endif /* _RUBYCC_SYS_CDEFS_H */