feat(headers): stddef/stdint/stdbool/limits/float/assert + features wiring

include/stdbit.h

@@ -0,0 +1,496 @@
+#ifndef VLIBC_STDBIT_H
+#define VLIBC_STDBIT_H
+
+/*
+ * vlibc — <stdbit.h>.
+ *
+ * Bit and byte manipulation (C23 7.18). Every per-width operation is a
+ * static inline function over the GCC counting builtins
+ * (__builtin_clz/clzl/clzll, __builtin_ctz/ctzl/ctzll,
+ * __builtin_popcount/popcountl/popcountll), so no call escapes into the
+ * library. The type-generic names (stdc_leading_zeros, ...) dispatch through
+ * _Generic to the per-width functions; signed arguments convert to the
+ * unsigned type of the same rank, which preserves the bit pattern exactly as
+ * C23 specifies. Widths match x86_64: int is 32-bit, long is 64-bit.
+ *
+ * This header is ISO C core and is present in every profile.
+ */
+
+#include <vlibc/features.h>
+
+#include <limits.h>
+
+/* stdc_leading_zeros: number of 0 bits before the first 1 bit, or the width. */
+static inline unsigned int
+stdc_leading_zeros_uc(unsigned char x)
+{
+    return x == 0 ? 8u : (unsigned int)(__builtin_clz(x) - 24);
+}
+
+static inline unsigned int
+stdc_leading_zeros_us(unsigned short x)
+{
+    return x == 0 ? 16u : (unsigned int)(__builtin_clz(x) - 16);
+}
+
+static inline unsigned int
+stdc_leading_zeros_ui(unsigned int x)
+{
+    return x == 0 ? 32u : (unsigned int)__builtin_clz(x);
+}
+
+static inline unsigned int
+stdc_leading_zeros_ul(unsigned long x)
+{
+    return x == 0 ? 64u : (unsigned int)__builtin_clzl(x);
+}
+
+static inline unsigned int
+stdc_leading_zeros_ull(unsigned long long x)
+{
+    return x == 0 ? 64u : (unsigned int)__builtin_clzll(x);
+}
+
+/* stdc_leading_ones: number of 1 bits before the first 0 bit, or the width. */
+static inline unsigned int
+stdc_leading_ones_uc(unsigned char x)
+{
+    return x == UCHAR_MAX ? 8u : (unsigned int)(__builtin_clz((unsigned char)~x) - 24);
+}
+
+static inline unsigned int
+stdc_leading_ones_us(unsigned short x)
+{
+    return x == USHRT_MAX ? 16u : (unsigned int)(__builtin_clz((unsigned short)~x) - 16);
+}
+
+static inline unsigned int
+stdc_leading_ones_ui(unsigned int x)
+{
+    return x == UINT_MAX ? 32u : (unsigned int)__builtin_clz(~x);
+}
+
+static inline unsigned int
+stdc_leading_ones_ul(unsigned long x)
+{
+    return x == ULONG_MAX ? 64u : (unsigned int)__builtin_clzl(~x);
+}
+
+static inline unsigned int
+stdc_leading_ones_ull(unsigned long long x)
+{
+    return x == ULLONG_MAX ? 64u : (unsigned int)__builtin_clzll(~x);
+}
+
+/* stdc_trailing_zeros: number of 0 bits after the last 1 bit, or the width. */
+static inline unsigned int
+stdc_trailing_zeros_uc(unsigned char x)
+{
+    return x == 0 ? 8u : (unsigned int)__builtin_ctz(x);
+}
+
+static inline unsigned int
+stdc_trailing_zeros_us(unsigned short x)
+{
+    return x == 0 ? 16u : (unsigned int)__builtin_ctz(x);
+}
+
+static inline unsigned int
+stdc_trailing_zeros_ui(unsigned int x)
+{
+    return x == 0 ? 32u : (unsigned int)__builtin_ctz(x);
+}
+
+static inline unsigned int
+stdc_trailing_zeros_ul(unsigned long x)
+{
+    return x == 0 ? 64u : (unsigned int)__builtin_ctzl(x);
+}
+
+static inline unsigned int
+stdc_trailing_zeros_ull(unsigned long long x)
+{
+    return x == 0 ? 64u : (unsigned int)__builtin_ctzll(x);
+}
+
+/* stdc_trailing_ones: number of 1 bits after the last 0 bit, or the width. */
+static inline unsigned int
+stdc_trailing_ones_uc(unsigned char x)
+{
+    return x == UCHAR_MAX ? 8u : (unsigned int)__builtin_ctz((unsigned char)~x);
+}
+
+static inline unsigned int
+stdc_trailing_ones_us(unsigned short x)
+{
+    return x == USHRT_MAX ? 16u : (unsigned int)__builtin_ctz((unsigned short)~x);
+}
+
+static inline unsigned int
+stdc_trailing_ones_ui(unsigned int x)
+{
+    return x == UINT_MAX ? 32u : (unsigned int)__builtin_ctz(~x);
+}
+
+static inline unsigned int
+stdc_trailing_ones_ul(unsigned long x)
+{
+    return x == ULONG_MAX ? 64u : (unsigned int)__builtin_ctzl(~x);
+}
+
+static inline unsigned int
+stdc_trailing_ones_ull(unsigned long long x)
+{
+    return x == ULLONG_MAX ? 64u : (unsigned int)__builtin_ctzll(~x);
+}
+
+/*
+ * stdc_first_*: index (from the most significant bit) of the first zero/one
+ * bit, or the width when no such bit exists. By construction, the index of
+ * the first zero from the top equals the count of leading ones, and so on.
+ */
+static inline unsigned int
+stdc_first_leading_zero_uc(unsigned char x)
+{
+    return stdc_leading_ones_uc(x);
+}
+
+static inline unsigned int
+stdc_first_leading_zero_us(unsigned short x)
+{
+    return stdc_leading_ones_us(x);
+}
+
+static inline unsigned int
+stdc_first_leading_zero_ui(unsigned int x)
+{
+    return stdc_leading_ones_ui(x);
+}
+
+static inline unsigned int
+stdc_first_leading_zero_ul(unsigned long x)
+{
+    return stdc_leading_ones_ul(x);
+}
+
+static inline unsigned int
+stdc_first_leading_zero_ull(unsigned long long x)
+{
+    return stdc_leading_ones_ull(x);
+}
+
+static inline unsigned int
+stdc_first_leading_one_uc(unsigned char x)
+{
+    return stdc_leading_zeros_uc(x);
+}
+
+static inline unsigned int
+stdc_first_leading_one_us(unsigned short x)
+{
+    return stdc_leading_zeros_us(x);
+}
+
+static inline unsigned int
+stdc_first_leading_one_ui(unsigned int x)
+{
+    return stdc_leading_zeros_ui(x);
+}
+
+static inline unsigned int
+stdc_first_leading_one_ul(unsigned long x)
+{
+    return stdc_leading_zeros_ul(x);
+}
+
+static inline unsigned int
+stdc_first_leading_one_ull(unsigned long long x)
+{
+    return stdc_leading_zeros_ull(x);
+}
+
+static inline unsigned int
+stdc_first_trailing_zero_uc(unsigned char x)
+{
+    return stdc_trailing_ones_uc(x);
+}
+
+static inline unsigned int
+stdc_first_trailing_zero_us(unsigned short x)
+{
+    return stdc_trailing_ones_us(x);
+}
+
+static inline unsigned int
+stdc_first_trailing_zero_ui(unsigned int x)
+{
+    return stdc_trailing_ones_ui(x);
+}
+
+static inline unsigned int
+stdc_first_trailing_zero_ul(unsigned long x)
+{
+    return stdc_trailing_ones_ul(x);
+}
+
+static inline unsigned int
+stdc_first_trailing_zero_ull(unsigned long long x)
+{
+    return stdc_trailing_ones_ull(x);
+}
+
+static inline unsigned int
+stdc_first_trailing_one_uc(unsigned char x)
+{
+    return stdc_trailing_zeros_uc(x);
+}
+
+static inline unsigned int
+stdc_first_trailing_one_us(unsigned short x)
+{
+    return stdc_trailing_zeros_us(x);
+}
+
+static inline unsigned int
+stdc_first_trailing_one_ui(unsigned int x)
+{
+    return stdc_trailing_zeros_ui(x);
+}
+
+static inline unsigned int
+stdc_first_trailing_one_ul(unsigned long x)
+{
+    return stdc_trailing_zeros_ul(x);
+}
+
+static inline unsigned int
+stdc_first_trailing_one_ull(unsigned long long x)
+{
+    return stdc_trailing_zeros_ull(x);
+}
+
+/* stdc_count_ones: number of 1 bits. */
+static inline unsigned int
+stdc_count_ones_uc(unsigned char x)
+{
+    return (unsigned int)__builtin_popcount(x);
+}
+
+static inline unsigned int
+stdc_count_ones_us(unsigned short x)
+{
+    return (unsigned int)__builtin_popcount(x);
+}
+
+static inline unsigned int
+stdc_count_ones_ui(unsigned int x)
+{
+    return (unsigned int)__builtin_popcount(x);
+}
+
+static inline unsigned int
+stdc_count_ones_ul(unsigned long x)
+{
+    return (unsigned int)__builtin_popcountl(x);
+}
+
+static inline unsigned int
+stdc_count_ones_ull(unsigned long long x)
+{
+    return (unsigned int)__builtin_popcountll(x);
+}
+
+/* stdc_count_zeros: number of 0 bits. */
+static inline unsigned int
+stdc_count_zeros_uc(unsigned char x)
+{
+    return 8u - stdc_count_ones_uc(x);
+}
+
+static inline unsigned int
+stdc_count_zeros_us(unsigned short x)
+{
+    return 16u - stdc_count_ones_us(x);
+}
+
+static inline unsigned int
+stdc_count_zeros_ui(unsigned int x)
+{
+    return 32u - stdc_count_ones_ui(x);
+}
+
+static inline unsigned int
+stdc_count_zeros_ul(unsigned long x)
+{
+    return 64u - stdc_count_ones_ul(x);
+}
+
+static inline unsigned int
+stdc_count_zeros_ull(unsigned long long x)
+{
+    return 64u - stdc_count_ones_ull(x);
+}
+
+/* stdc_has_single_bit: true iff exactly one bit is set. */
+static inline _Bool
+stdc_has_single_bit_uc(unsigned char x)
+{
+    return x != 0 && (x & (x - 1U)) == 0;
+}
+
+static inline _Bool
+stdc_has_single_bit_us(unsigned short x)
+{
+    return x != 0 && (x & (x - 1U)) == 0;
+}
+
+static inline _Bool
+stdc_has_single_bit_ui(unsigned int x)
+{
+    return x != 0 && (x & (x - 1U)) == 0;
+}
+
+static inline _Bool
+stdc_has_single_bit_ul(unsigned long x)
+{
+    return x != 0 && (x & (x - 1UL)) == 0;
+}
+
+static inline _Bool
+stdc_has_single_bit_ull(unsigned long long x)
+{
+    return x != 0 && (x & (x - 1ULL)) == 0;
+}
+
+/* stdc_bit_width: bits needed to represent x (0 for 0, 1 for 1). */
+static inline unsigned int
+stdc_bit_width_uc(unsigned char x)
+{
+    return x == 0 ? 0u : (unsigned int)(32 - __builtin_clz(x));
+}
+
+static inline unsigned int
+stdc_bit_width_us(unsigned short x)
+{
+    return x == 0 ? 0u : (unsigned int)(32 - __builtin_clz(x));
+}
+
+static inline unsigned int
+stdc_bit_width_ui(unsigned int x)
+{
+    return x == 0 ? 0u : (unsigned int)(32 - __builtin_clz(x));
+}
+
+static inline unsigned int
+stdc_bit_width_ul(unsigned long x)
+{
+    return x == 0 ? 0u : (unsigned int)(64 - __builtin_clzl(x));
+}
+
+static inline unsigned int
+stdc_bit_width_ull(unsigned long long x)
+{
+    return x == 0 ? 0u : (unsigned int)(64 - __builtin_clzll(x));
+}
+
+/* stdc_bit_floor: largest power of 2 not greater than x (0 for 0). */
+static inline unsigned char
+stdc_bit_floor_uc(unsigned char x)
+{
+    return (unsigned char)(x == 0 ? 0 : (1u << (32 - __builtin_clz(x) - 1)));
+}
+
+static inline unsigned short
+stdc_bit_floor_us(unsigned short x)
+{
+    return (unsigned short)(x == 0 ? 0 : (1u << (32 - __builtin_clz(x) - 1)));
+}
+
+static inline unsigned int
+stdc_bit_floor_ui(unsigned int x)
+{
+    return x == 0 ? 0u : (1u << (32 - __builtin_clz(x) - 1));
+}
+
+static inline unsigned long
+stdc_bit_floor_ul(unsigned long x)
+{
+    return x == 0 ? 0ul : (1ul << (64 - __builtin_clzl(x) - 1));
+}
+
+static inline unsigned long long
+stdc_bit_floor_ull(unsigned long long x)
+{
+    return x == 0 ? 0ull : (1ull << (64 - __builtin_clzll(x) - 1));
+}
+
+/*
+ * stdc_bit_ceil: smallest power of 2 not less than x. The result is
+ * undefined when it is not representable in the type of x, per C23.
+ */
+static inline unsigned char
+stdc_bit_ceil_uc(unsigned char x)
+{
+    return (unsigned char)(x <= 1 ? 1 : (1u << (32 - __builtin_clz(x - 1))));
+}
+
+static inline unsigned short
+stdc_bit_ceil_us(unsigned short x)
+{
+    return (unsigned short)(x <= 1 ? 1 : (1u << (32 - __builtin_clz(x - 1))));
+}
+
+static inline unsigned int
+stdc_bit_ceil_ui(unsigned int x)
+{
+    return x <= 1 ? 1u : (1u << (32 - __builtin_clz(x - 1)));
+}
+
+static inline unsigned long
+stdc_bit_ceil_ul(unsigned long x)
+{
+    return x <= 1 ? 1ul : (1ul << (64 - __builtin_clzl(x - 1)));
+}
+
+static inline unsigned long long
+stdc_bit_ceil_ull(unsigned long long x)
+{
+    return x <= 1 ? 1ull : (1ull << (64 - __builtin_clzll(x - 1)));
+}
+
+/*
+ * Type-generic dispatch: map the (lvalue-converted) argument type to the
+ * per-width function. Signed types route to the unsigned function of the
+ * same rank, which preserves the bit pattern as C23 requires.
+ */
+#define VLIBC_STDBIT_DISPATCH(fn, x)                                                               \
+    _Generic((x),                                                                                  \
+        _Bool: fn##_uc,                                                                            \
+        char: fn##_uc,                                                                             \
+        signed char: fn##_uc,                                                                      \
+        unsigned char: fn##_uc,                                                                    \
+        short: fn##_us,                                                                            \
+        unsigned short: fn##_us,                                                                   \
+        int: fn##_ui,                                                                              \
+        unsigned int: fn##_ui,                                                                     \
+        long: fn##_ul,                                                                             \
+        unsigned long: fn##_ul,                                                                    \
+        long long: fn##_ull,                                                                       \
+        unsigned long long: fn##_ull)(x)
+
+#define stdc_leading_zeros(x) VLIBC_STDBIT_DISPATCH(stdc_leading_zeros, x)
+#define stdc_leading_ones(x) VLIBC_STDBIT_DISPATCH(stdc_leading_ones, x)
+#define stdc_trailing_zeros(x) VLIBC_STDBIT_DISPATCH(stdc_trailing_zeros, x)
+#define stdc_trailing_ones(x) VLIBC_STDBIT_DISPATCH(stdc_trailing_ones, x)
+#define stdc_first_leading_zero(x) VLIBC_STDBIT_DISPATCH(stdc_first_leading_zero, x)
+#define stdc_first_leading_one(x) VLIBC_STDBIT_DISPATCH(stdc_first_leading_one, x)
+#define stdc_first_trailing_zero(x) VLIBC_STDBIT_DISPATCH(stdc_first_trailing_zero, x)
+#define stdc_first_trailing_one(x) VLIBC_STDBIT_DISPATCH(stdc_first_trailing_one, x)
+#define stdc_count_zeros(x) VLIBC_STDBIT_DISPATCH(stdc_count_zeros, x)
+#define stdc_count_ones(x) VLIBC_STDBIT_DISPATCH(stdc_count_ones, x)
+#define stdc_has_single_bit(x) VLIBC_STDBIT_DISPATCH(stdc_has_single_bit, x)
+#define stdc_bit_width(x) VLIBC_STDBIT_DISPATCH(stdc_bit_width, x)
+#define stdc_bit_floor(x) VLIBC_STDBIT_DISPATCH(stdc_bit_floor, x)
+#define stdc_bit_ceil(x) VLIBC_STDBIT_DISPATCH(stdc_bit_ceil, x)
+
+#endif /* VLIBC_STDBIT_H */