rubycc 1.0.0

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

@@ -0,0 +1,108 @@
+/* rubycc bundled <ctype.h>: character classification (ISO C 7.4). glibc does
+   not return a bare 0/1 from isalpha() and kin -- it returns the masked bits of
+   a per-locale classification table reached through __ctype_b_loc(), so the
+   result values are part of its ABI. This header reproduces that mechanism clean
+   room from the published _ISbit formula and accessor signatures (not copied
+   from glibc, not derived from musl, whose ctype returns 0/1); the accessor
+   functions themselves are resolved from the host libc at link time. The whole
+   mechanism is glibc's, so under __RUBYCC_LIBC_MUSL__ (see the preprocessor's
+   LIBCS) the classification macros are switched off and the plain function
+   calls stand instead -- see the note above them. Placed in the glibc layer
+   because that is where the arch-switched headers live; the values themselves
+   are arch independent. */
+
+#ifndef _RUBYCC_CTYPE_H
+#define _RUBYCC_CTYPE_H
+
+/* The classification bit for each property, as glibc lays them out in the table
+   entry: properties 0-7 occupy the high byte, 8-11 the low byte. */
+#ifndef _ISbit
+# define _ISbit(bit) ((bit) < 8 ? ((1 << (bit)) << 8) : ((1 << (bit)) >> 8))
+#endif
+
+enum {
+  _ISupper  = _ISbit(0),
+  _ISlower  = _ISbit(1),
+  _ISalpha  = _ISbit(2),
+  _ISdigit  = _ISbit(3),
+  _ISxdigit = _ISbit(4),
+  _ISspace  = _ISbit(5),
+  _ISprint  = _ISbit(6),
+  _ISgraph  = _ISbit(7),
+  _ISblank  = _ISbit(8),
+  _IScntrl  = _ISbit(9),
+  _ISpunct  = _ISbit(10),
+  _ISalnum  = _ISbit(11)
+};
+
+extern const unsigned short int **__ctype_b_loc(void);
+extern const int **__ctype_tolower_loc(void);
+extern const int **__ctype_toupper_loc(void);
+
+/* The out-of-line entry points (declared so code taking their address still
+   links); the macros below inline the common case. */
+extern int isalnum(int __c);
+extern int isalpha(int __c);
+extern int iscntrl(int __c);
+extern int isdigit(int __c);
+extern int islower(int __c);
+extern int isgraph(int __c);
+extern int isprint(int __c);
+extern int ispunct(int __c);
+extern int isspace(int __c);
+extern int isupper(int __c);
+extern int isxdigit(int __c);
+extern int isblank(int __c);
+extern int tolower(int __c);
+extern int toupper(int __c);
+extern int isascii(int __c);
+extern int toascii(int __c);
+
+/* The classification macros are glibc's mechanism and glibc's result values,
+   so on musl they must not be used at all: the two libraries differ in the
+   *shape* of the answer, not merely in a constant. glibc's isalpha('a') is the
+   masked table entry (measured 1024, and 2048/8192/... for the other
+   properties) while musl's is a bare 1; and musl has no __ctype_b_loc() /
+   __ctype_tolower_loc() / __ctype_toupper_loc() to reach a table through in the
+   first place, so a table-lookup macro would not even link there. Both
+   behaviours measured with the ABI harness, glibc's on this host and musl's on
+   the CI musl run (docs/STEPS.md Step 193). Under musl the macros are therefore
+   left undefined and every classifier resolves to the out-of-line function
+   declared above, which is what returns musl's 0/1. The accessor prototypes and
+   the _IS* enumerators stay declared on both: a prototype that is never called
+   emits nothing, and code that does call one is asking for glibc's own
+   interface by name. */
+#if !defined(__RUBYCC_LIBC_MUSL__)
+
+#define __isctype(c, type) ((*__ctype_b_loc())[(int)(c)] & (unsigned short int)(type))
+
+#define isalnum(c)  __isctype((c), _ISalnum)
+#define isalpha(c)  __isctype((c), _ISalpha)
+#define iscntrl(c)  __isctype((c), _IScntrl)
+#define isdigit(c)  __isctype((c), _ISdigit)
+#define islower(c)  __isctype((c), _ISlower)
+#define isgraph(c)  __isctype((c), _ISgraph)
+#define isprint(c)  __isctype((c), _ISprint)
+#define ispunct(c)  __isctype((c), _ISpunct)
+#define isspace(c)  __isctype((c), _ISspace)
+#define isupper(c)  __isctype((c), _ISupper)
+#define isxdigit(c) __isctype((c), _ISxdigit)
+#define isblank(c)  __isctype((c), _ISblank)
+
+#define tolower(c) ((int) (*__ctype_tolower_loc())[(int)(c)])
+#define toupper(c) ((int) (*__ctype_toupper_loc())[(int)(c)])
+
+#endif /* !__RUBYCC_LIBC_MUSL__ */
+
+/* isascii/toascii: glibc declares these under __USE_MISC || __USE_XOPEN and
+   defines them as pure bit tests (no locale classification table), so the
+   inline value matches glibc's out-of-line result exactly -- no ABI subtlety
+   like the isalpha() family above. Real sources (e.g. redcarpet's html.c) call
+   isascii() with only <ctype.h> included. They stay macros under either C
+   library: the probed values (isascii of 'a'/200/0/127, toascii of 0x1FF/'A')
+   measured identical on glibc and musl (docs/STEPS.md Step 193), which is why
+   they sit outside the branch above. */
+#define isascii(c) (((c) & ~0x7f) == 0)
+#define toascii(c) ((c) & 0x7f)
+
+#endif /* _RUBYCC_CTYPE_H */

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

@@ -0,0 +1,54 @@
+/* rubycc bundled <endian.h>: byte-order identity macros and the host<->big/
+   little conversions (glibc/BSD extension). Derived from musl's <endian.h>
+   shape; the byte order and the glibc spellings (__BYTE_ORDER, bswap via the
+   compiler builtins) are pinned to the little-endian x86-64 ABI. ABI switch
+   layer: the byte order is arch specific. */
+
+#ifndef _RUBYCC_ENDIAN_H
+#define _RUBYCC_ENDIAN_H
+
+#define __LITTLE_ENDIAN 1234
+#define __BIG_ENDIAN    4321
+#define __PDP_ENDIAN    3412
+#define __BYTE_ORDER    __LITTLE_ENDIAN
+#define __FLOAT_WORD_ORDER __BYTE_ORDER
+
+/* BSD-style spellings (glibc exposes both under _DEFAULT_SOURCE). */
+#define LITTLE_ENDIAN   __LITTLE_ENDIAN
+#define BIG_ENDIAN      __BIG_ENDIAN
+#define PDP_ENDIAN      __PDP_ENDIAN
+#define BYTE_ORDER      __BYTE_ORDER
+
+/* Byte reversals as static inline helpers (arithmetic, so no compiler byte-swap
+   builtin is required and each argument is evaluated once). */
+static inline unsigned short __rubycc_bswap16(unsigned short __x) {
+  return (unsigned short) ((__x << 8) | (__x >> 8));
+}
+static inline unsigned int __rubycc_bswap32(unsigned int __x) {
+  return ((__x & 0x000000ffU) << 24) | ((__x & 0x0000ff00U) << 8)
+       | ((__x & 0x00ff0000U) >> 8) | ((__x & 0xff000000U) >> 24);
+}
+static inline unsigned long __rubycc_bswap64(unsigned long __x) {
+  return ((__x & 0x00000000000000ffUL) << 56) | ((__x & 0x000000000000ff00UL) << 40)
+       | ((__x & 0x0000000000ff0000UL) << 24) | ((__x & 0x00000000ff000000UL) << 8)
+       | ((__x & 0x000000ff00000000UL) >> 8)  | ((__x & 0x0000ff0000000000UL) >> 24)
+       | ((__x & 0x00ff000000000000UL) >> 40) | ((__x & 0xff00000000000000UL) >> 56);
+}
+
+/* Host is little-endian: the "le" forms are identities, the "be" forms swap. */
+#define htobe16(x) __rubycc_bswap16(x)
+#define htole16(x) ((unsigned short)(x))
+#define be16toh(x) __rubycc_bswap16(x)
+#define le16toh(x) ((unsigned short)(x))
+
+#define htobe32(x) __rubycc_bswap32(x)
+#define htole32(x) ((unsigned int)(x))
+#define be32toh(x) __rubycc_bswap32(x)
+#define le32toh(x) ((unsigned int)(x))
+
+#define htobe64(x) __rubycc_bswap64(x)
+#define htole64(x) ((unsigned long)(x))
+#define be64toh(x) __rubycc_bswap64(x)
+#define le64toh(x) ((unsigned long)(x))
+
+#endif /* _RUBYCC_ENDIAN_H */

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

@@ -0,0 +1,154 @@
+/* rubycc bundled <errno.h>: the error-number macros and the errno lvalue
+   (POSIX). Provenance: clean room against the Linux/asm-generic UAPI, not
+   derived from musl. The error numbers are the kernel ABI, reproduced here as
+   measured integer constants (an ABI fact, not copied text -- see
+   docs/HEADER-LICENSING.md); glibc reaches them via __errno_location, which
+   resolves from the host libc at link time. Placed in the glibc/x86-64 layer
+   because the numeric values are kernel-ABI specific. */
+
+#ifndef _RUBYCC_ERRNO_H
+#define _RUBYCC_ERRNO_H
+
+extern int *__errno_location(void);
+#define errno (*__errno_location())
+
+#define EPERM            1
+#define ENOENT           2
+#define ESRCH            3
+#define EINTR            4
+#define EIO              5
+#define ENXIO            6
+#define E2BIG            7
+#define ENOEXEC          8
+#define EBADF            9
+#define ECHILD           10
+#define EAGAIN           11
+#define ENOMEM           12
+#define EACCES           13
+#define EFAULT           14
+#define ENOTBLK          15
+#define EBUSY            16
+#define EEXIST           17
+#define EXDEV            18
+#define ENODEV           19
+#define ENOTDIR          20
+#define EISDIR           21
+#define EINVAL           22
+#define ENFILE           23
+#define EMFILE           24
+#define ENOTTY           25
+#define ETXTBSY          26
+#define EFBIG            27
+#define ENOSPC           28
+#define ESPIPE           29
+#define EROFS            30
+#define EMLINK           31
+#define EPIPE            32
+#define EDOM             33
+#define ERANGE           34
+#define EDEADLK          35
+#define ENAMETOOLONG     36
+#define ENOLCK           37
+#define ENOSYS           38
+#define ENOTEMPTY        39
+#define ELOOP            40
+#define ENOMSG           42
+#define EIDRM            43
+#define ECHRNG           44
+#define EL2NSYNC         45
+#define EL3HLT           46
+#define EL3RST           47
+#define ELNRNG           48
+#define EUNATCH          49
+#define ENOCSI           50
+#define EL2HLT           51
+#define EBADE            52
+#define EBADR            53
+#define EXFULL           54
+#define ENOANO           55
+#define EBADRQC          56
+#define EBADSLT          57
+#define EBFONT           59
+#define ENOSTR           60
+#define ENODATA          61
+#define ETIME            62
+#define ENOSR            63
+#define ENONET           64
+#define ENOPKG           65
+#define EREMOTE          66
+#define ENOLINK          67
+#define EADV             68
+#define ESRMNT           69
+#define ECOMM            70
+#define EPROTO           71
+#define EMULTIHOP        72
+#define EDOTDOT          73
+#define EBADMSG          74
+#define EOVERFLOW        75
+#define ENOTUNIQ         76
+#define EBADFD           77
+#define EREMCHG          78
+#define ELIBACC          79
+#define ELIBBAD          80
+#define ELIBSCN          81
+#define ELIBMAX          82
+#define ELIBEXEC         83
+#define EILSEQ           84
+#define ERESTART         85
+#define ESTRPIPE         86
+#define EUSERS           87
+#define ENOTSOCK         88
+#define EDESTADDRREQ     89
+#define EMSGSIZE         90
+#define EPROTOTYPE       91
+#define ENOPROTOOPT      92
+#define EPROTONOSUPPORT  93
+#define ESOCKTNOSUPPORT  94
+#define EOPNOTSUPP       95
+#define EPFNOSUPPORT     96
+#define EAFNOSUPPORT     97
+#define EADDRINUSE       98
+#define EADDRNOTAVAIL    99
+#define ENETDOWN         100
+#define ENETUNREACH      101
+#define ENETRESET        102
+#define ECONNABORTED     103
+#define ECONNRESET       104
+#define ENOBUFS          105
+#define EISCONN          106
+#define ENOTCONN         107
+#define ESHUTDOWN        108
+#define ETOOMANYREFS     109
+#define ETIMEDOUT        110
+#define ECONNREFUSED     111
+#define EHOSTDOWN        112
+#define EHOSTUNREACH     113
+#define EALREADY         114
+#define EINPROGRESS      115
+#define ESTALE           116
+#define EUCLEAN          117
+#define ENOTNAM          118
+#define ENAVAIL          119
+#define EISNAM           120
+#define EREMOTEIO        121
+#define EDQUOT           122
+#define ENOMEDIUM        123
+#define EMEDIUMTYPE      124
+#define ECANCELED        125
+#define ENOKEY           126
+#define EKEYEXPIRED      127
+#define EKEYREVOKED      128
+#define EKEYREJECTED     129
+#define EOWNERDEAD       130
+#define ENOTRECOVERABLE  131
+#define ERFKILL          132
+#define EHWPOISON        133
+
+/* Common aliases. */
+#define EWOULDBLOCK EAGAIN
+#define EDEADLOCK   EDEADLK
+
+extern char *program_invocation_name;
+extern char *program_invocation_short_name;
+
+#endif /* _RUBYCC_ERRNO_H */

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

@@ -0,0 +1,134 @@
+/* rubycc bundled <fcntl.h>: the open/fcntl flag macros, the fcntl commands,
+   the *at family constants, and struct flock (POSIX). Provenance: clean room
+   against the Linux kernel UAPI (asm-generic/fcntl.h plus the arch-specific
+   uapi/asm/fcntl.h), not derived from musl. The O_*, F_* and AT_* values and
+   the struct flock layout are ABI facts reproduced as measured integers, not
+   copied text (see docs/HEADER-LICENSING.md) -- the same treatment as
+   errno.h and sys/stat.h. open/openat/creat/fcntl are POSIX declarations.
+   Placed in the glibc/x86-64 layer because O_DIRECT, O_DIRECTORY and
+   O_NOFOLLOW swap bit assignments against aarch64's uapi/asm/fcntl.h.
+   Two macros -- O_ACCMODE and O_LARGEFILE -- additionally differ between the
+   two C libraries; both measured values are carried below, selected by
+   __RUBYCC_LIBC_MUSL__ (see the preprocessor's LIBCS). */
+
+#ifndef _RUBYCC_FCNTL_H
+#define _RUBYCC_FCNTL_H
+
+#ifndef _RUBYCC_MODE_T
+#define _RUBYCC_MODE_T
+typedef unsigned int mode_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
+
+/* Access modes (octal). */
+#define O_RDONLY  0
+#define O_WRONLY  01
+#define O_RDWR    02
+/* O_ACCMODE is one of the two flag macros the two libcs disagree on: musl's
+   access-mode mask spans the O_PATH bit as well (measured 2097155, i.e.
+   010000003), glibc's is the low two bits only (measured 3, i.e. 03). Both
+   figures are measurements of the ABI harness, glibc's on this host and musl's
+   on the CI musl run (docs/STEPS.md Step 193), not values read off either
+   library's headers. */
+#if defined(__RUBYCC_LIBC_MUSL__)
+#define O_ACCMODE 010000003
+#else
+#define O_ACCMODE 03
+#endif
+
+/* Creation and status flags (octal, kernel ABI). */
+#define O_CREAT     0100
+#define O_EXCL      0200
+#define O_NOCTTY    0400
+#define O_TRUNC     01000
+#define O_APPEND    02000
+#define O_NONBLOCK  04000
+#define O_NDELAY    O_NONBLOCK
+#define O_DSYNC     010000
+#define O_ASYNC     020000
+#define O_SYNC      04010000
+#define O_RSYNC     O_SYNC
+#define O_CLOEXEC   02000000
+/* O_LARGEFILE is the other flag macro the two libcs disagree on: musl hands
+   out the kernel's own large-file bit (measured 32768, i.e. 0100000) while
+   glibc, whose LP64 off_t is already 64-bit, leaves it empty (measured 0).
+   Both measured with the ABI harness, glibc's here and musl's on the CI musl
+   run (docs/STEPS.md Step 193). */
+#if defined(__RUBYCC_LIBC_MUSL__)
+#define O_LARGEFILE 0100000
+#else
+#define O_LARGEFILE 0
+#endif
+#define O_NOATIME   01000000
+#define O_PATH      010000000
+
+/* Arch-specific bits (kernel uapi/asm/fcntl.h): O_DIRECT/O_DIRECTORY/
+   O_NOFOLLOW swap values between x86-64 and aarch64. */
+#define O_DIRECT    040000
+#define O_DIRECTORY 0200000
+#define O_NOFOLLOW  0400000
+
+#define __O_TMPFILE 020000000
+#define O_TMPFILE   (__O_TMPFILE | O_DIRECTORY)
+
+/* fcntl commands. */
+#define F_DUPFD  0
+#define F_GETFD  1
+#define F_SETFD  2
+#define F_GETFL  3
+#define F_SETFL  4
+#define F_GETLK  5
+#define F_SETLK  6
+#define F_SETLKW 7
+#define F_SETOWN 8
+#define F_GETOWN 9
+#define F_DUPFD_CLOEXEC 1030
+/* Linux pipe-buffer sizing (Fcntl exposes both). Measured on this target
+   rather than derived: 1024 + 7 and 1024 + 8 off the Linux-specific base,
+   the same pair on x86-64 and aarch64. */
+#define F_SETPIPE_SZ 1031
+#define F_GETPIPE_SZ 1032
+
+/* FD_CLOEXEC: the sole close-on-exec bit for F_GETFD/F_SETFD. */
+#define FD_CLOEXEC 1
+
+/* struct flock l_type / l_whence values. */
+#define F_RDLCK 0
+#define F_WRLCK 1
+#define F_UNLCK 2
+
+/* *at family flags. */
+#define AT_FDCWD            (-100)
+#define AT_SYMLINK_NOFOLLOW 0x100
+#define AT_REMOVEDIR        0x200
+#define AT_SYMLINK_FOLLOW   0x400
+#define AT_EACCESS          0x200
+
+#ifndef SEEK_SET
+#define SEEK_SET 0
+#define SEEK_CUR 1
+#define SEEK_END 2
+#endif
+
+/* struct flock: 32 bytes, 8-byte aligned (LP64, measured). */
+struct flock {
+  short l_type;
+  short l_whence;
+  off_t l_start;
+  off_t l_len;
+  pid_t l_pid;
+};
+
+int open(const char *__file, int __oflag, ...);
+int openat(int __fd, const char *__file, int __oflag, ...);
+int creat(const char *__file, mode_t __mode);
+int fcntl(int __fd, int __cmd, ...);
+
+#endif /* _RUBYCC_FCNTL_H */

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

@@ -0,0 +1,182 @@
+/* rubycc bundled <inttypes.h>: the <stdint.h> types plus the printf/scanf
+   format-specifier macros (ISO C 7.8) and the greatest-width integer calls.
+   Derived from musl's <inttypes.h> shape; the PRI and SCN length modifiers are
+   pinned to the glibc x86-64 LP64 ABI (the 64-bit, MAX, PTR and fast16+ forms
+   use "l", measured). ABI switch layer: the format widths track the type
+   widths, which are arch specific. */
+
+#ifndef _RUBYCC_INTTYPES_H
+#define _RUBYCC_INTTYPES_H
+
+#include <stdint.h>
+
+#ifndef _RUBYCC_WCHAR_T
+#define _RUBYCC_WCHAR_T
+typedef int wchar_t;
+#endif
+
+typedef struct { intmax_t quot; intmax_t rem; } imaxdiv_t;
+
+#define PRId8 "d"
+#define PRId16 "d"
+#define PRId32 "d"
+#define PRId64 "ld"
+#define PRIdLEAST8 "d"
+#define PRIdLEAST16 "d"
+#define PRIdLEAST32 "d"
+#define PRIdLEAST64 "ld"
+#define PRIdFAST8 "d"
+#define PRIdFAST16 "ld"
+#define PRIdFAST32 "ld"
+#define PRIdFAST64 "ld"
+#define PRIdMAX "ld"
+#define PRIdPTR "ld"
+#define PRIi8 "i"
+#define PRIi16 "i"
+#define PRIi32 "i"
+#define PRIi64 "li"
+#define PRIiLEAST8 "i"
+#define PRIiLEAST16 "i"
+#define PRIiLEAST32 "i"
+#define PRIiLEAST64 "li"
+#define PRIiFAST8 "i"
+#define PRIiFAST16 "li"
+#define PRIiFAST32 "li"
+#define PRIiFAST64 "li"
+#define PRIiMAX "li"
+#define PRIiPTR "li"
+#define PRIo8 "o"
+#define PRIo16 "o"
+#define PRIo32 "o"
+#define PRIo64 "lo"
+#define PRIoLEAST8 "o"
+#define PRIoLEAST16 "o"
+#define PRIoLEAST32 "o"
+#define PRIoLEAST64 "lo"
+#define PRIoFAST8 "o"
+#define PRIoFAST16 "lo"
+#define PRIoFAST32 "lo"
+#define PRIoFAST64 "lo"
+#define PRIoMAX "lo"
+#define PRIoPTR "lo"
+#define PRIu8 "u"
+#define PRIu16 "u"
+#define PRIu32 "u"
+#define PRIu64 "lu"
+#define PRIuLEAST8 "u"
+#define PRIuLEAST16 "u"
+#define PRIuLEAST32 "u"
+#define PRIuLEAST64 "lu"
+#define PRIuFAST8 "u"
+#define PRIuFAST16 "lu"
+#define PRIuFAST32 "lu"
+#define PRIuFAST64 "lu"
+#define PRIuMAX "lu"
+#define PRIuPTR "lu"
+#define PRIx8 "x"
+#define PRIx16 "x"
+#define PRIx32 "x"
+#define PRIx64 "lx"
+#define PRIxLEAST8 "x"
+#define PRIxLEAST16 "x"
+#define PRIxLEAST32 "x"
+#define PRIxLEAST64 "lx"
+#define PRIxFAST8 "x"
+#define PRIxFAST16 "lx"
+#define PRIxFAST32 "lx"
+#define PRIxFAST64 "lx"
+#define PRIxMAX "lx"
+#define PRIxPTR "lx"
+#define PRIX8 "X"
+#define PRIX16 "X"
+#define PRIX32 "X"
+#define PRIX64 "lX"
+#define PRIXLEAST8 "X"
+#define PRIXLEAST16 "X"
+#define PRIXLEAST32 "X"
+#define PRIXLEAST64 "lX"
+#define PRIXFAST8 "X"
+#define PRIXFAST16 "lX"
+#define PRIXFAST32 "lX"
+#define PRIXFAST64 "lX"
+#define PRIXMAX "lX"
+#define PRIXPTR "lX"
+#define SCNd8 "hhd"
+#define SCNd16 "hd"
+#define SCNd32 "d"
+#define SCNd64 "ld"
+#define SCNdLEAST8 "hhd"
+#define SCNdLEAST16 "hd"
+#define SCNdLEAST32 "d"
+#define SCNdLEAST64 "ld"
+#define SCNdFAST8 "hhd"
+#define SCNdFAST16 "ld"
+#define SCNdFAST32 "ld"
+#define SCNdFAST64 "ld"
+#define SCNdMAX "ld"
+#define SCNdPTR "ld"
+#define SCNi8 "hhi"
+#define SCNi16 "hi"
+#define SCNi32 "i"
+#define SCNi64 "li"
+#define SCNiLEAST8 "hhi"
+#define SCNiLEAST16 "hi"
+#define SCNiLEAST32 "i"
+#define SCNiLEAST64 "li"
+#define SCNiFAST8 "hhi"
+#define SCNiFAST16 "li"
+#define SCNiFAST32 "li"
+#define SCNiFAST64 "li"
+#define SCNiMAX "li"
+#define SCNiPTR "li"
+#define SCNo8 "hho"
+#define SCNo16 "ho"
+#define SCNo32 "o"
+#define SCNo64 "lo"
+#define SCNoLEAST8 "hho"
+#define SCNoLEAST16 "ho"
+#define SCNoLEAST32 "o"
+#define SCNoLEAST64 "lo"
+#define SCNoFAST8 "hho"
+#define SCNoFAST16 "lo"
+#define SCNoFAST32 "lo"
+#define SCNoFAST64 "lo"
+#define SCNoMAX "lo"
+#define SCNoPTR "lo"
+#define SCNu8 "hhu"
+#define SCNu16 "hu"
+#define SCNu32 "u"
+#define SCNu64 "lu"
+#define SCNuLEAST8 "hhu"
+#define SCNuLEAST16 "hu"
+#define SCNuLEAST32 "u"
+#define SCNuLEAST64 "lu"
+#define SCNuFAST8 "hhu"
+#define SCNuFAST16 "lu"
+#define SCNuFAST32 "lu"
+#define SCNuFAST64 "lu"
+#define SCNuMAX "lu"
+#define SCNuPTR "lu"
+#define SCNx8 "hhx"
+#define SCNx16 "hx"
+#define SCNx32 "x"
+#define SCNx64 "lx"
+#define SCNxLEAST8 "hhx"
+#define SCNxLEAST16 "hx"
+#define SCNxLEAST32 "x"
+#define SCNxLEAST64 "lx"
+#define SCNxFAST8 "hhx"
+#define SCNxFAST16 "lx"
+#define SCNxFAST32 "lx"
+#define SCNxFAST64 "lx"
+#define SCNxMAX "lx"
+#define SCNxPTR "lx"
+
+intmax_t  imaxabs(intmax_t __n);
+imaxdiv_t imaxdiv(intmax_t __numer, intmax_t __denom);
+intmax_t  strtoimax(const char *__restrict __nptr, char **__restrict __endptr, int __base);
+uintmax_t strtoumax(const char *__restrict __nptr, char **__restrict __endptr, int __base);
+intmax_t  wcstoimax(const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base);
+uintmax_t wcstoumax(const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base);
+
+#endif /* _RUBYCC_INTTYPES_H */

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

@@ -0,0 +1,61 @@
+/* rubycc bundled <limits.h>: the arithmetic-type ranges (ISO C 5.2.4.2.1).
+   Derived from the ISO-mandated values with the `long`/`char` widths pinned to
+   the x86-64 LP64 ABI (`long` is 64-bit); the arithmetic ranges are the same
+   under either C library, and only MB_LEN_MAX differs between them (carried
+   below under __RUBYCC_LIBC_MUSL__, see the preprocessor's LIBCS). ABI switch
+   layer: LONG_MAX is arch specific, and so is the signedness of plain char --
+   that one is taken from the compiler's own __CHAR_UNSIGNED__ rather than from
+   this directory. */
+
+#ifndef _RUBYCC_LIMITS_H
+#define _RUBYCC_LIMITS_H
+
+#define CHAR_BIT    8
+/* MB_LEN_MAX is the one value in this header the two C libraries disagree on:
+   musl reports 4 (its widest multibyte character, UTF-8's four bytes) and glibc
+   16. Both measured with the ABI harness, glibc's on this host and musl's on
+   the CI musl run (docs/STEPS.md Step 193). */
+#if defined(__RUBYCC_LIBC_MUSL__)
+#define MB_LEN_MAX  4
+#else
+#define MB_LEN_MAX  16
+#endif
+
+#define SCHAR_MIN   (-128)
+#define SCHAR_MAX   127
+#define UCHAR_MAX   255
+
+/* Plain char's signedness is implementation-defined and pinned per ABI: signed
+   on the x86-64 SysV ABI, unsigned on AAPCS64. rubycc predefines
+   __CHAR_UNSIGNED__ on a target of the latter kind (as gcc does), so the range
+   follows the compilation target rather than this header's directory. */
+#ifdef __CHAR_UNSIGNED__
+#define CHAR_MIN    0
+#define CHAR_MAX    UCHAR_MAX
+#else
+#define CHAR_MIN    SCHAR_MIN
+#define CHAR_MAX    SCHAR_MAX
+#endif
+
+#define SHRT_MIN    (-32768)
+#define SHRT_MAX    32767
+#define USHRT_MAX   65535
+
+#define INT_MIN     (-INT_MAX-1)
+#define INT_MAX     2147483647
+#define UINT_MAX    4294967295U
+
+#define LONG_MIN    (-LONG_MAX-1L)
+#define LONG_MAX    9223372036854775807L
+#define ULONG_MAX   18446744073709551615UL
+
+#define LLONG_MIN   (-LLONG_MAX-1LL)
+#define LLONG_MAX   9223372036854775807LL
+#define ULLONG_MAX  18446744073709551615ULL
+
+/* GNU spellings some code still uses. */
+#define LONG_LONG_MIN   LLONG_MIN
+#define LONG_LONG_MAX   LLONG_MAX
+#define ULONG_LONG_MAX  ULLONG_MAX
+
+#endif /* _RUBYCC_LIMITS_H */