Build with clang by default

Author: ivmarkov

.github/workflows/ci.yml

@@ -135,7 +135,7 @@ jobs:
           source "$HOME/.cargo/env"
           "$HOME/.cargo/bin/espup" install -e -r
           source "$HOME/exports"
-          echo "$PATH" >> "$GITHUB_PATH"
+          echo "${LIBCLANG_PATH}/../bin:$PATH" >> "$GITHUB_PATH"
           echo "LIBCLANG_PATH=${LIBCLANG_PATH}" >> "$GITHUB_ENV"
           echo "CLANG_PATH=${CLANG_PATH}" >> "$GITHUB_ENV"
   

esp-mbedtls-sys/Cargo.toml

@@ -13,10 +13,12 @@ harness = false
 default = []
 # Always generate the bindings during build, even if pre-built bindings for the build target are available
 force-generate-bindings = []
+# Use GCC instead of clang
+use-gcc = []
 # Force the use of the Espressif Riscv GCC toolchain, if the target is a `riscv32*-` target
 # If this feature is not enabled, the build will assume and use the "official" RiscV GCC toolchain:
 # https://github.com/riscv-collab/riscv-gnu-toolchain
-force-esp-riscv-toolchain = []
+force-esp-riscv-gcc = ["use-gcc"]
 # Disable all or some hooks; this would preclude hooking custom HW-accelerated algos
 nohook = ["nohook-sha1", "nohook-sha256", "nohook-sha512", "nohook-exp-mod"]
 nohook-sha1 = []

esp-mbedtls-sys/README.md

@@ -18,15 +18,19 @@
 
 ## Precompilation
 
-For user-convenience, the MbedTLS C library also comes pre-compiled for the following Rust targets:
+For user-convenience, the MbedTLS C library also comes pre-built for the following Rust targets:
 - `rsicv32imc-unknown-none-elf`
 - `rsicv32imac-unknown-none-elf`
 - `xtensa-esp32-none-elf`
 - `xtensa-esp32s2-none-elf`
 - `xtensa-esp32s3-none-elf`
 - (PRs for other Rust baremetal targets appreciated!)
 
-For other MCU baremetal targets as well as for STD platforms, the MbedTLS C library will be compiled on the fly, but that requires GCC (the cross-compiler flavor for your MCU) and Clang pre-installed.
+For other MCU baremetal targets as well as for STD platforms, the MbedTLS C library will be compiled on the fly with `clang` (by default), or with GCC (if the `use-gcc` feature is enabled). 
+
+Note that for the latter, you DO need to have the GCC cross-compiler flavor for your MCU pre-installed and on your $PATH, while with `clang` _ANY_ `clang` instance would do, as `clang` is natively a cross-compiler. `clang` is anyway always necessary during on-the-fly compilation for the Rust bindings' generation, so that's why it is used by default for compiling the MbedTLS C library as well.
+
+The on-the-fly compilation process also needs `cmake` and `ninja` pre-installed (for now).
 
 ESP-IDF is also supported and in that case `esp-mbedtls-sys` becomes just an alias for `esp-idf-sys` and uses the MbedTLS library which is built-in inside ESP-IDF.
 

esp-mbedtls-sys/build.rs

@@ -17,7 +17,9 @@ fn main() -> Result<()> {
     let host = env::var("HOST").unwrap();
     let target = env::var("TARGET").unwrap();
 
-    let force_esp_riscv_toolchain = env::var("CARGO_FEATURE_FORCE_ESP_RISCV_TOOLCHAIN").is_ok();
+    let use_gcc = env::var("CARGO_FEATURE_USE_GCC").is_ok();
+    let force_esp_riscv_gcc = env::var("CARGO_FEATURE_FORCE_ESP_RISCV_GCC").is_ok();
+
     let pregen_bindings = env::var("CARGO_FEATURE_FORCE_GENERATE_BINDINGS").is_err();
     let pregen_bindings_rs_file = crate_root_path
         .join("src")
@@ -54,19 +56,22 @@ fn main() -> Result<()> {
             }
         }
 
+        // For clang, use our own cross-platform sysroot
+        let 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::MbedtlsBuilder::new(
             removed_hooks.complement(),
-            false,
+            !use_gcc,
             crate_root_path.clone(),
             Some(target),
             Some(host),
             None,
+            sysroot,
             None,
-            None,
-            force_esp_riscv_toolchain,
+            force_esp_riscv_gcc,
         );
 
         let libs_dir = builder.compile(&out, None)?;

esp-mbedtls-sys/gen/builder.rs

@@ -34,6 +34,7 @@ impl MbedtlsBuilder {
     ///
     /// Arguments:
     /// - `hooks` - Set of algorithm hooks to enable
+    /// - `force_clang`: If true, force the use of Clang as the C/C++ compiler
     /// - `crate_root_path`: Path to the root of the crate
     /// - `cmake_rust_target`: Optional target for CMake when building MbedTLS, with Rust target-triple syntax. If not specified, the "TARGET" env variable will be used
     /// - `cmake_host_rust_target`: Optional host target for the build
@@ -54,16 +55,17 @@ impl MbedtlsBuilder {
         clang_path: Option<PathBuf>,
         clang_sysroot_path: Option<PathBuf>,
         clang_target: Option<String>,
-        force_esp_riscv_toolchain: bool,
+        force_esp_riscv_gcc: bool,
     ) -> Self {
         Self {
             hooks,
             cmake_configurer: CMakeConfigurer::new(
                 force_clang,
+                clang_sysroot_path.clone(),
                 crate_root_path.join("mbedtls"),
                 cmake_rust_target,
                 cmake_host_rust_target,
-                force_esp_riscv_toolchain,
+                force_esp_riscv_gcc,
                 crate_root_path.join("gen").join("toolchain.cmake"),
             ),
             crate_root_path,
@@ -291,37 +293,41 @@ impl MbedtlsBuilder {
 #[derive(Debug, Clone)]
 pub struct CMakeConfigurer {
     pub force_clang: bool,
+    pub clang_sysroot_path: Option<PathBuf>,
     pub project_path: PathBuf,
     pub cmake_rust_target: Option<String>,
     pub cmake_host_rust_target: Option<String>,
-    pub force_esp_riscv_toolchain: bool,
+    pub force_esp_riscv_gcc: bool,
     pub empty_toolchain_file: PathBuf,
 }
 
 impl CMakeConfigurer {
     /// Create a new CMakeConfigurer
     ///
     /// Arguments:
+    /// - `force_clang`: If true, force the use of Clang as the C/C++ compiler
     /// - `project_path`: Path to the root of the CMake project
     /// - `cmake_rust_target`: Optional target for CMake when building MbedTLS, with Rust target-triple syntax. If not specified, the "TARGET" env variable will be used
     /// - `cmake_host_rust_target`: Optional host target for the build
-    /// - `force_esp_riscv_toolchain`: If true, and if the target is a riscv32 target, force the use of the Espressif RISCV GCC toolchain
+    /// - `force_esp_riscv_gcc`: If true, and if the target is a riscv32 target, force the use of the Espressif RISCV GCC toolchain
     ///   (`riscv32-esp-elf-gcc`) rather than the derived `riscv32-unknown-elf-gcc` toolchain which is the "official" RISC-V one
     ///   (https://github.com/riscv-collab/riscv-gnu-toolchain)
     pub const fn new(
         force_clang: bool,
+        clang_sysroot_path: Option<PathBuf>,
         project_path: PathBuf,
         cmake_rust_target: Option<String>,
         cmake_host_rust_target: Option<String>,
-        force_esp_riscv_toolchain: bool,
+        force_esp_riscv_gcc: bool,
         empty_toolchain_file: PathBuf,
     ) -> Self {
         Self {
             force_clang,
+            clang_sysroot_path,
             project_path,
             cmake_rust_target,
             cmake_host_rust_target,
-            force_esp_riscv_toolchain,
+            force_esp_riscv_gcc,
             empty_toolchain_file,
         }
     }
@@ -377,7 +383,7 @@ impl CMakeConfigurer {
         }
 
         for arg in self.derive_c_args() {
-            config.cflag(arg).cxxflag(arg);
+            config.cflag(&arg).cxxflag(arg);
         }
 
         if let Some(target) = &self.cmake_rust_target {
@@ -392,6 +398,13 @@ impl CMakeConfigurer {
     }
 
     pub fn derive_sysroot(&self) -> Option<PathBuf> {
+        if self.force_clang {
+            if let Some(clang_sysroot_path) = self.clang_sysroot_path.clone() {
+                // If clang is used and there is a pre-defined sysroot path for it, use it
+                return Some(clang_sysroot_path);
+            }
+        }
+
         // Only GCC has a sysroot, so try to locate the sysroot using GCC first
         let unforce_clang = Self {
             force_clang: false,
@@ -456,7 +469,7 @@ impl CMakeConfigurer {
                 | "riscv32imac-esp-espidf"
                 | "riscv32imafc-unknown-none-elf"
                 | "riscv32imafc-esp-espidf" => {
-                    if self.force_esp_riscv_toolchain {
+                    if self.force_esp_riscv_gcc {
                         Some((PathBuf::from("riscv32-esp-elf-gcc"), true))
                     } else {
                         None
@@ -467,7 +480,27 @@ impl CMakeConfigurer {
         }
     }
 
-    fn derive_c_args(&self) -> &[&str] {
+    fn derive_c_args(&self) -> Vec<String> {
+        let mut args = Vec::new();
+
+        args.extend(
+            self.derive_c_target_args()
+                .iter()
+                .map(|arg| arg.to_string()),
+        );
+
+        if self.force_clang {
+            if let Some(sysroot_path) = self.derive_sysroot() {
+                args.push("-fbuiltin".to_string());
+                args.push(format!("-I{}", sysroot_path.join("include").display()));
+                args.push(format!("--sysroot={}", sysroot_path.display()));
+            }
+        }
+
+        args
+    }
+
+    fn derive_c_target_args(&self) -> &[&str] {
         if self.force_clang {
             match self.target().as_str() {
                 "riscv32imc-unknown-none-elf" | "riscv32imc-esp-espidf" => {

esp-mbedtls-sys/gen/sysroot/include/assert.h

@@ -0,0 +1,5 @@
+#ifndef __ASSERT_H__
+#define __ASSERT_H__
+
+#endif
+

esp-mbedtls-sys/gen/sysroot/include/stdio.h

@@ -0,0 +1,8 @@
+#ifndef __STDIO_H__
+#define __STDIO_H__
+
+#define printf __builtin_printf
+#define snprintf __builtin_snprintf
+#define vsnprintf __builtin_vsnprintf
+
+#endif

esp-mbedtls-sys/gen/sysroot/include/stdlib.h

@@ -0,0 +1,11 @@
+#ifndef __STDLIB_H__
+#define __STDLIB_H__
+
+#include <stddef.h>
+
+void* calloc(size_t num, size_t size);
+void free(void *ptr);
+
+int rand(void);
+
+#endif

esp-mbedtls-sys/gen/sysroot/include/string.h

@@ -0,0 +1,16 @@
+#ifndef __STRING_H__
+#define __STRING_H__
+
+#define memcpy __builtin_memcpy
+#define memcmp __builtin_memcmp
+#define memset __builtin_memset
+#define memmove __builtin_memmove
+
+#define strlen __builtin_strlen
+#define strcmp __builtin_strcmp
+#define strncmp __builtin_strncmp
+#define strstr __builtin_strstr
+#define strchr __builtin_strchr
+#define strncpy __builtin_strncpy
+
+#endif