Add clang support

configure

@@ -126,7 +126,7 @@ fi
 
 # Add default CFLAGS and LDFLAGS.
 if [[ "$default_cflags" = 1 ]]; then
-	CFLAGS="-g -O3 -Wall -Werror ${CFLAGS:-}"
+	CFLAGS="-g -O3 -Wall ${CFLAGS:-}"
 fi
 if [[ "$default_ldflags" = 1 ]]; then
 	LDFLAGS="-z max-page-size=4096 ${LDFLAGS:-}"

flake.nix

@@ -45,6 +45,8 @@
               pkgs.perl
               pkgs.pkgsCross.riscv64-embedded.stdenv.cc.bintools.bintools
               pkgs.pkgsCross.riscv64-embedded.stdenv.cc.cc
+              pkgs.pkgsCross.riscv64-embedded.llvmPackages.stdenv.cc.bintools.bintools
+              pkgs.pkgsCross.riscv64-embedded.llvmPackages.stdenv.cc.cc
               pkgs.python3
             ];
 
@@ -101,7 +103,8 @@
             pkgs.tio
           ];
           shellHook = ''
-            export CC=riscv64-none-elf-gcc
+            export CC=clang
+            export CFLAGS="-target riscv64-none-elf -std=c23"
             export OBJDUMP=riscv64-none-elf-objdump
             export STRIP=riscv64-none-elf-strip
           '';

src/kernel/arch/riscv64/include.mak

@@ -74,7 +74,7 @@ src/kernel/arch/riscv64/kernel-unstripped.elf: $(srcdir)/src/kernel/arch/riscv64
 	@echo "LD      $@"
 	$(Q)$(CC) $(kernel-cflags) $(kernel-ldflags) \
 		-T $(srcdir)/src/kernel/arch/riscv64/kernel.ld -o $@ \
-		$(kernel-objs) -lgcc
+		$(kernel-objs)
 
 # Split the kernel into the actual binary we want to load and its debug
 # symbols. Using these does mean we won't get debug symbols for the bootstub,

src/kernel/include/compiler.h

@@ -41,18 +41,238 @@ typedef __builtin_va_list va_list;
 
 #define stdc_leading_zeros __builtin_stdc_leading_zeros
 #define stdc_leading_ones __builtin_stdc_leading_ones
-#define stdc_trailing_zeros __builtin_stdc_trailing_zeros
 #define stdc_trailing_ones __builtin_stdc_trailing_ones
 #define stdc_first_leading_zero __builtin_stdc_first_leading_zero
 #define stdc_first_leading_one __builtin_stdc_first_leading_one
 #define stdc_first_trailing_zero __builtin_stdc_first_trailing_zero
-#define stdc_first_trailing_one __builtin_stdc_first_trailing_one
 #define stdc_count_zeros __builtin_stdc_count_zeros
 #define stdc_count_ones __builtin_stdc_count_ones
+
+#if __has_builtin(__builtin_stdc_first_trailing_one)
+#define stdc_first_trailing_one __builtin_stdc_first_trailing_one
+#else
+// https://gcc.gnu.org/onlinedocs/gcc/Bit-Operation-Builtins.html#index-_005f_005fbuiltin_005fstdc_005ffirst_005ftrailing_005fone
+[[gnu::const]]
+static inline __UINT8_TYPE__
+__stdc_first_trailing_one_u8(__UINT8_TYPE__ value) {
+  return (__UINT8_TYPE__)(__builtin_ctzg(value, -1) + 1);
+}
+
+[[gnu::const]]
+static inline __UINT16_TYPE__
+__stdc_first_trailing_one_u16(__UINT16_TYPE__ value) {
+  return (__UINT16_TYPE__)(__builtin_ctzg(value, -1) + 1);
+}
+
+[[gnu::const]]
+static inline __UINT32_TYPE__
+__stdc_first_trailing_one_u32(__UINT32_TYPE__ value) {
+  return (__UINT32_TYPE__)(__builtin_ctzg(value, -1) + 1);
+}
+
+[[gnu::const]]
+static inline __UINT64_TYPE__
+__stdc_first_trailing_one_u64(__UINT64_TYPE__ value) {
+  return (__UINT64_TYPE__)(__builtin_ctzg(value, -1) + 1);
+}
+
+#define stdc_first_trailing_one(VALUE)                                         \
+  (_Generic(VALUE,                                                             \
+       u8: __stdc_first_trailing_one_u8,                                       \
+       u16: __stdc_first_trailing_one_u16,                                     \
+       u32: __stdc_first_trailing_one_u32,                                     \
+       u64: __stdc_first_trailing_one_u64)(VALUE))
+#endif
+
+#if __has_builtin(__builtin_stdc_has_single_bit)
 #define stdc_has_single_bit __builtin_stdc_has_single_bit
-#define stdc_bit_width __builtin_stdc_bit_width
+#else
+// https://gcc.gnu.org/onlinedocs/gcc/Bit-Operation-Builtins.html#index-_005f_005fbuiltin_005fstdc_005fhas_005fsingle_005fbit
+[[gnu::const]]
+static inline __UINT8_TYPE__ __stdc_has_single_bit_u8(__UINT8_TYPE__ value) {
+  return (bool)(__builtin_popcountg(value) == 1);
+}
+
+[[gnu::const]]
+static inline __UINT16_TYPE__ __stdc_has_single_bit_u16(__UINT8_TYPE__ value) {
+  return (bool)(__builtin_popcountg(value) == 1);
+}
+
+[[gnu::const]]
+static inline __UINT32_TYPE__ __stdc_has_single_bit_u32(__UINT8_TYPE__ value) {
+  return (bool)(__builtin_popcountg(value) == 1);
+}
+
+[[gnu::const]]
+static inline __UINT64_TYPE__ __stdc_has_single_bit_u64(__UINT8_TYPE__ value) {
+  return (bool)(__builtin_popcountg(value) == 1);
+}
+
+#define stdc_has_single_bit(VALUE)                                             \
+  (_Generic(VALUE,                                                             \
+       u8: __stdc_has_single_bit_u8,                                           \
+       u16: __stdc_has_single_bit_u16,                                         \
+       u32: __stdc_has_single_bit_u32,                                         \
+       u64: __stdc_has_single_bit_u64)(VALUE))
+#endif
+
+#if __has_builtin(__builtin_stdc_bit_floor)
 #define stdc_bit_floor __builtin_stdc_bit_floor
+#else
+// https://gcc.gnu.org/onlinedocs/gcc/Bit-Operation-Builtins.html#index-_005f_005fbuiltin_005fstdc_005fbit_005ffloor
+[[gnu::const]]
+static inline __UINT8_TYPE__ __stdc_bit_floor_u8(__UINT8_TYPE__ value) {
+  return value == 0 ? (__UINT8_TYPE__)0
+                    : (__UINT8_TYPE__)1 << (8 - 1 - __builtin_clzg(value));
+}
+
+[[gnu::const]]
+static inline __UINT16_TYPE__ __stdc_bit_floor_u16(__UINT16_TYPE__ value) {
+  return value == 0 ? (__UINT16_TYPE__)0
+                    : (__UINT16_TYPE__)1 << (16 - 1 - __builtin_clzg(value));
+}
+
+[[gnu::const]]
+static inline __UINT32_TYPE__ __stdc_bit_floor_u32(__UINT32_TYPE__ value) {
+  return value == 0 ? (__UINT32_TYPE__)0
+                    : (__UINT32_TYPE__)1 << (32 - 1 - __builtin_clzg(value));
+}
+
+[[gnu::const]]
+static inline __UINT64_TYPE__ __stdc_bit_floor_u64(__UINT64_TYPE__ value) {
+  return value == 0 ? (__UINT64_TYPE__)0
+                    : (__UINT64_TYPE__)1 << (64 - 1 - __builtin_clzg(value));
+}
+
+#define stdc_bit_floor(VALUE)                                                  \
+  (_Generic(VALUE,                                                             \
+       u8: __stdc_bit_floor_u8,                                                \
+       u16: __stdc_bit_floor_u16,                                              \
+       u32: __stdc_bit_floor_u32,                                              \
+       u64: __stdc_bit_floor_u64)(VALUE))
+#endif
+
+#if __has_builtin(__builtin_stdc_bit_width)
+#define stdc_bit_width __builtin_stdc_bit_width
+#else
+// https://gcc.gnu.org/onlinedocs/gcc/Bit-Operation-Builtins.html#index-_005f_005fbuiltin_005fstdc_005fbit_005fwidth
+[[gnu::const]]
+static inline __UINT8_TYPE__ __stdc_bit_width_u8(__UINT8_TYPE__ value) {
+  return (__UINT8_TYPE__)(8 - __builtin_clzg(value, 8));
+}
+
+[[gnu::const]]
+static inline __UINT16_TYPE__ __stdc_bit_width_u16(__UINT16_TYPE__ value) {
+  return (__UINT16_TYPE__)(16 - __builtin_clzg(value, 16));
+}
+
+[[gnu::const]]
+static inline __UINT32_TYPE__ __stdc_bit_width_u32(__UINT32_TYPE__ value) {
+  return (__UINT32_TYPE__)(32 - __builtin_clzg(value, 32));
+}
+
+[[gnu::const]]
+static inline __UINT64_TYPE__ __stdc_bit_width_u64(__UINT64_TYPE__ value) {
+  return (__UINT64_TYPE__)(64 - __builtin_clzg(value, 64));
+}
+
+#define stdc_bit_width(VALUE)                                                  \
+  (_Generic(VALUE,                                                             \
+       u8: __stdc_bit_width_u8,                                                \
+       u16: __stdc_bit_width_u16,                                              \
+       u32: __stdc_bit_width_u32,                                              \
+       u64: __stdc_bit_width_u64)(VALUE))
+#endif
+
+#if __has_builtin(__builtin_stdc_trailing_zeros)
+#define stdc_trailing_zeros __builtin_stdc_trailing_zeros
+#else
+[[gnu::const]]
+static inline __UINT8_TYPE__ __stdc_trailing_zeros_u8(__UINT8_TYPE__ value) {
+  return (__UINT8_TYPE__)(__builtin_ctzg((__UINT8_TYPE__)~value, -1) + 1);
+}
+
+[[gnu::const]]
+static inline __UINT16_TYPE__ __stdc_trailing_zeros_u16(__UINT16_TYPE__ value) {
+  return (__UINT16_TYPE__)(__builtin_ctzg((__UINT16_TYPE__)~value, -1) + 1);
+}
+
+[[gnu::const]]
+static inline __UINT32_TYPE__ __stdc_trailing_zeros_u32(__UINT32_TYPE__ value) {
+  return (__UINT32_TYPE__)(__builtin_ctzg((__UINT32_TYPE__)~value, -1) + 1);
+}
+
+[[gnu::const]]
+static inline __UINT64_TYPE__ __stdc_trailing_zeros_u64(__UINT64_TYPE__ value) {
+  return (__UINT64_TYPE__)(__builtin_ctzg((__UINT64_TYPE__)~value, -1) + 1);
+}
+
+[[gnu::const]]
+static inline __SIZE_TYPE__ __stdc_trailing_zeros_usize(__SIZE_TYPE__ value) {
+  return (__SIZE_TYPE__)(__builtin_ctzg((__SIZE_TYPE__)~value, -1) + 1);
+}
+
+#define stdc_trailing_zeros(VALUE)                                             \
+  (_Generic(VALUE,                                                             \
+       u8: __stdc_trailing_zeros_u8,                                           \
+       u16: __stdc_trailing_zeros_u16,                                         \
+       u32: __stdc_trailing_zeros_u32,                                         \
+       u64: __stdc_trailing_zeros_u64,                                         \
+       usize: __stdc_trailing_zeros_usize)(VALUE))
+#endif
+
+#if __has_builtin(__builtin_stdc_bit_ceil)
 #define stdc_bit_ceil __builtin_stdc_bit_ceil
+#else
+// https://gcc.gnu.org/onlinedocs/gcc/Bit-Operation-Builtins.html#index-_005f_005fbuiltin_005fstdc_005fbit_005fceil
+[[gnu::const]]
+static inline __UINT8_TYPE__ __stdc_bit_ceil_u8(__UINT8_TYPE__ value) {
+  return value <= 1
+             ? (__UINT8_TYPE__)1
+             : (__UINT8_TYPE__)2
+                   << (8 - 1 - __builtin_clzg((__UINT8_TYPE__)(value - 1)));
+}
+
+[[gnu::const]]
+static inline __UINT16_TYPE__ __stdc_bit_ceil_u16(__UINT16_TYPE__ value) {
+  return value <= 1
+             ? (__UINT16_TYPE__)1
+             : (__UINT16_TYPE__)2
+                   << (16 - 1 - __builtin_clzg((__UINT16_TYPE__)(value - 1)));
+}
+
+[[gnu::const]]
+static inline __UINT32_TYPE__ __stdc_bit_ceil_u32(__UINT32_TYPE__ value) {
+  return value <= 1
+             ? (__UINT32_TYPE__)1
+             : (__UINT32_TYPE__)2
+                   << (32 - 1 - __builtin_clzg((__UINT32_TYPE__)(value - 1)));
+}
+
+[[gnu::const]]
+static inline __UINT64_TYPE__ __stdc_bit_ceil_u64(__UINT64_TYPE__ value) {
+  return value <= 1
+             ? (__UINT64_TYPE__)1
+             : (__UINT64_TYPE__)2
+                   << (64 - 1 - __builtin_clzg((__UINT64_TYPE__)(value - 1)));
+}
+
+[[gnu::const]]
+static inline __SIZE_TYPE__ __stdc_bit_ceil_usize(__SIZE_TYPE__ value) {
+  return value <= 1
+             ? (__SIZE_TYPE__)1
+             : (__SIZE_TYPE__)2 << (sizeof(__SIZE_TYPE__) * 8 - 1 -
+                                    __builtin_clzg((__SIZE_TYPE__)(value - 1)));
+}
+
+#define stdc_bit_ceil(VALUE)                                                   \
+  (_Generic(VALUE,                                                             \
+       u8: __stdc_bit_ceil_u8,                                                 \
+       u16: __stdc_bit_ceil_u16,                                               \
+       u32: __stdc_bit_ceil_u32,                                               \
+       u64: __stdc_bit_ceil_u64,                                               \
+       usize: __stdc_bit_ceil_usize)(VALUE))
+#endif
 
 #if __has_builtin(__builtin_stdc_rotate_left)
 #define stdc_rotate_left __builtin_stdc_rotate_left

src/kernel/include/types.h

@@ -137,7 +137,7 @@ static inline uaddr _addr_of_ptr_uptr(uptr ptr) {
     constexpr auto __addr_of_ptr_PTR_type =                                    \
         __builtin_classify_type(__addr_of_ptr_PTR);                            \
     const auto __addr_of_ptr_PTR_or_null = __builtin_choose_expr(              \
-        __addr_of_ptr_PTR_type == __builtin_classify_type(void *),             \
+        __addr_of_ptr_PTR_type == __builtin_classify_type((void *)nullptr),    \
         __addr_of_ptr_PTR, (void **)nullptr);                                  \
     const auto __addr_of_ptr_func = _Generic(__addr_of_ptr_PTR,                \
         typeof(*__addr_of_ptr_PTR_or_null) *: _addr_of_ptr,                    \
@@ -173,7 +173,7 @@ static inline const uptr _ptr_with_addr_uptr(const uptr ptr_uptr, uaddr addr) {
     constexpr auto __ptr_with_addr_PTR_type =                                  \
         __builtin_classify_type(__ptr_with_addr_PTR);                          \
     const auto __ptr_with_addr_PTR_or_null = __builtin_choose_expr(            \
-        __ptr_with_addr_PTR_type == __builtin_classify_type(void *),           \
+        __ptr_with_addr_PTR_type == __builtin_classify_type((void *)nullptr),  \
         __ptr_with_addr_PTR, (void **)nullptr);                                \
     const auto __ptr_with_addr_func = _Generic(__ptr_with_addr_PTR,            \
         typeof(*__ptr_with_addr_PTR_or_null) *: _ptr_with_addr,                \