feat: add clang sysroot

Author: scootermon

openthread-sys/build.rs

@@ -17,6 +17,7 @@ fn main() -> Result<()> {
     let host = env::var("HOST").unwrap();
     let target = env::var("TARGET").unwrap();
 
+    let use_gcc = env::var("CARGO_FEATURE_USE_GCC").is_ok();
     let force_esp_riscv_toolchain = env::var("CARGO_FEATURE_FORCE_ESP_RISCV_TOOLCHAIN").is_ok();
 
     let pregen_bindings = env::var("CARGO_FEATURE_FORCE_GENERATE_BINDINGS").is_err();
@@ -33,16 +34,20 @@ fn main() -> Result<()> {
         // Nothing to do for ESP-IDF, `esp-idf-sys` will do everything for us
         None
     } else {
+        // For clang, we can use our own cross-platform sysroot.
+        // TODO: explicitly let cargo track changes to sysroot
+        let clang_sysroot = (!use_gcc).then(|| crate_root_path.join("gen").join("sysroot"));
+
         // Need to do on-the-fly build and bindings' generation
         let out = PathBuf::from(env::var_os("OUT_DIR").unwrap());
 
         let builder = builder::OpenThreadBuilder::new(
-            false,
+            !use_gcc,
             crate_root_path.clone(),
             Some(target),
             Some(host),
             None,
-            None,
+            clang_sysroot,
             None,
             force_esp_riscv_toolchain,
         );

openthread-sys/gen/sysroot/include/assert.h

@@ -0,0 +1,22 @@
+// See: <https://en.cppreference.com/w/c/header/assert.html>
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// This is inspired by Clang's implementation of <assert.h>.
+#ifdef NDEBUG
+# define assert(...) ((void)0)
+#else
+// We just delegate to the `otPlatAssertFail` function, which will be provided
+// by our platform implementation.
+// TODO: Actually set OPENTHREAD_CONFIG_PLATFORM_ASSERT_MANAGEMENT to 1 so our
+//       platform can handle this!
+_Noreturn void otPlatAssertFail(const char *aFilename, int aLineNumber);
+# define assert(...) ((__VA_ARGS__) ? ((void)0) : otPlatAssertFail(__FILE__, __LINE__))
+#endif
+
+#ifdef __cplusplus
+} // extern "C"
+#endif

openthread-sys/gen/sysroot/include/ctype.h

@@ -0,0 +1,14 @@
+// See: <https://en.cppreference.com/w/c/header/ctype.html>
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int iscntrl(int c);
+int isprint(int c);
+int isupper(int c);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif

openthread-sys/gen/sysroot/include/errno.h

@@ -0,0 +1,35 @@
+// See: <https://en.cppreference.com/w/c/header/errno.html>
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// HACK: By defining this we tell OpenThread's spinel.c that we don't provide
+//       a `errno` macro. This makes our life slightly easier as long as we
+//       don't actually use `errno` at runtime.
+#define SPINEL_PLATFORM_DOESNT_IMPLEMENT_ERRNO_VAR 1
+
+#define EPERM 1
+#define ENOMEM 12
+#define EINVAL 22
+#define EPIPE 32
+#define ERANGE 34
+#define ENOBUFS 64
+#define EOVERFLOW 75
+#define EMSGSIZE 90
+#define EAFNOSUPPORT 97
+#define ENETDOWN 100
+#define ENETUNREACH 101
+#define ECONNABORTED 103
+#define ECONNRESET 104
+#define EISCONN 106
+#define ENOTCONN 107
+#define ETIMEDOUT 110
+#define ECONNREFUSED 111
+#define EHOSTDOWN 112
+#define EHOSTUNREACH 113
+
+#ifdef __cplusplus
+} // extern "C"
+#endif

openthread-sys/gen/sysroot/include/inttypes.h

@@ -0,0 +1,12 @@
+// See: <https://en.cppreference.com/w/c/header/inttypes.html>
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// This file only needs to exist for mbedtls.
+
+#ifdef __cplusplus
+} // extern "C"
+#endif

openthread-sys/gen/sysroot/include/stdarg.h

@@ -0,0 +1,18 @@
+// See: <https://en.cppreference.com/w/c/header/stdarg.html>
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define va_start(ap, param) __builtin_va_start(ap, param)
+#define va_end(ap) __builtin_va_end(ap)
+#define va_arg(ap, type) __builtin_va_arg(ap, type)
+
+#define va_copy(dest, src) __builtin_va_copy(dest, src)
+
+typedef __builtin_va_list va_list;
+
+#ifdef __cplusplus
+} // extern "C"
+#endif

openthread-sys/gen/sysroot/include/stddef.h

@@ -0,0 +1,20 @@
+// See: <https://en.cppreference.com/w/c/header/stddef.html>
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef __SIZE_TYPE__ size_t;
+
+#ifdef __cplusplus
+#define NULL __null
+#else
+#define NULL ((void*)0)
+#endif
+
+#define offsetof(t, d) __builtin_offsetof(t, d)
+
+#ifdef __cplusplus
+} // extern "C"
+#endif

openthread-sys/gen/sysroot/include/stdio.h

@@ -0,0 +1,24 @@
+// See: <https://en.cppreference.com/w/c/header/stdio.html>
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdarg.h>
+#include <stddef.h>
+
+// mbedtls uses `FILE` for one of its function declarations.
+// To ensure we're not actually using `FILE` at runtime we define it as an
+// opaque struct.
+typedef struct __forbidden_FILE FILE;
+
+// The following two functions are defined by our `snprintf.c` file in `gen/support`.
+
+int snprintf(char* s, size_t n, const char* format, ...);
+
+int vsnprintf(char* s, size_t n, const char* format, va_list arg);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif

openthread-sys/gen/sysroot/include/stdlib.h

@@ -0,0 +1,16 @@
+// See: <https://en.cppreference.com/w/c/header/stdlib.html>
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdarg.h>
+#include <stddef.h>
+
+// Called by both mbedtls and OpenThread in case of assertion failures.
+_Noreturn void exit(int status);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif

openthread-sys/gen/sysroot/include/string.h

@@ -0,0 +1,37 @@
+// See: <https://en.cppreference.com/w/c/header/string.html>
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Since <string.h> has to define `NULL` and `size_t`, let's re-export the
+// contents of <stddef.h> here.
+#include <stddef.h>
+
+#define strcpy __builtin_strcpy
+#define strncpy __builtin_strncpy
+
+#define strlen __builtin_strlen
+#define strcmp __builtin_strcmp
+#define strncmp __builtin_strncmp
+#define strchr __builtin_strchr
+#define strrchr __builtin_strrchr
+#define strstr __builtin_strstr
+
+#define memcmp __builtin_memcmp
+
+// We need memset to be a function rather than a macro because mbedtls
+// assigns it to a static variable. Clang doesn't allow built-in functions
+// to be called through a function pointer, so we have to wrap it in an inline
+// function.
+static inline void* memset(void* s, int c, size_t n) {
+  return __builtin_memset(s, c, n);
+}
+
+#define memcpy __builtin_memcpy
+#define memmove __builtin_memmove
+
+#ifdef __cplusplus
+} // extern "C"
+#endif