build: Only replace cl.exe with clang-cl for ARM64 Windows builds

When cross-compiling to Windows from Linux or similar, it's common to
use the `clang-cl` driver from the LLVM toolchain which supports parsing
`cl.exe`-like arguments.

Ring however doesn't seem to compile for ARM64 Windows using `cl.exe`,
and contains a `// FIXME`-style workaround to use `clang` to compile its
C files instead.

The command-line interface for `clang` isn't always compatible with that
of `cl.exe` and `clang-cl`.  There didn't seem to be any trouble with
this yet, but when cross-compiling from Linux it's common to explicitly
provide "sysroots" via `-vctoolsdir` and `-winsdkdir` in `CFLAGS`.
In such a setup this workaround in `ring` would pass those arguments
to `clang`, resulting in "unknown argument" errors.

`cc-rs` can tell us exactly what compiler it found, and we can use
this information to decide how to fill in this workaround.  If the user
was already compiling their code with `clang-cl`, nothing has to be
replaced. In the end, all this entails is changing the workaround to not
compile with `clang`, but with `clang-cl` instead.

Author: MarijnS95

BUILDING.md

@@ -22,9 +22,11 @@ edition of Visual Studio, like Community, Standard, or Enterprise). The
 “Desktop development with C++” workflow must be installed. Visual Studio
 2022 Version 17.5 is supported; earlier versions of Visual Studio may work.
 
+### (Cross-)compiling to Windows ARM64
+
 For Windows ARM64 targets (aarch64-pc-windows-msvc), the Visual Studio Build
 Tools “VS 2022 C++ ARM64 build tools” and "clang" components must be installed.
-Add Microsoft's provided version of `clang` to `%PATH%`, which will allow the
+Add Microsoft's provided version of `clang-cl` to `%PATH%`, which will allow the
 build to work in GitHub Actions without installing anything:
 ```
 $env:Path += ";C:\Program Files (x86)\Microsoft Visual Studio\2022\Enterprise\VC\Tools\Llvm\x64\bin"

build.rs

@@ -148,10 +148,8 @@ fn cpp_flags(compiler: &cc::Tool) -> &'static [&'static str] {
         NON_MSVC_FLAGS
     } else {
         static MSVC_FLAGS: &[&str] = &[
+            "/std:c11",
             "/Gy", // Enable function-level linking.
-            "/Zc:wchar_t",
-            "/Zc:forScope",
-            "/Zc:inline",
             // Warnings.
             "/Wall",
             "/wd4127", // C4127: conditional expression is constant
@@ -162,6 +160,11 @@ fn cpp_flags(compiler: &cc::Tool) -> &'static [&'static str] {
             "/wd4820", // C4820: <struct>: <n> bytes padding added after <name>
             "/wd5045", /* C5045: Compiler will insert Spectre mitigation for memory load if
                         * /Qspectre switch specified */
+            "-Wno-declaration-after-statement",
+            "-Wno-pre-c11-compat",
+            "-Wno-reserved-macro-identifier", // Stuff in asm_base.h
+            "-Wno-switch-default",
+            "-Wno-unsafe-buffer-usage",
         ];
         MSVC_FLAGS
     }
@@ -559,9 +562,15 @@ fn obj_path(out_dir: &Path, src: &Path) -> PathBuf {
 
 fn configure_cc(c: &mut cc::Build, target: &Target, c_root_dir: &Path, include_dir: &Path) {
     let compiler = c.get_compiler();
-    // FIXME: On Windows AArch64 we currently must use Clang to compile C code
-    let compiler = if target.os == WINDOWS && target.arch == AARCH64 && !compiler.is_like_clang() {
-        let _ = c.compiler("clang");
+    let is_msvc_not_clang_cl = compiler.is_like_msvc() && !compiler.is_like_clang_cl();
+
+    // FIXME: On Windows AArch64, ring C code cannot be compiled using cl.exe, but must be compiled
+    // using the LLVM toolchain.  Use clang-cl, which is compatible with flags that are already in
+    // place (i.e. custom CFLAGS that the user provided to cc).
+    let compiler = if target.os == WINDOWS && target.arch == AARCH64 && is_msvc_not_clang_cl {
+        // FIXME: This requires clang-cl to be available in PATH, regardless of any explicit
+        // or custom path that the user might have provided to cc via the CC flag.
+        c.compiler("clang-cl");
         c.get_compiler()
     } else {
         compiler
@@ -584,11 +593,8 @@ fn configure_cc(c: &mut cc::Build, target: &Target, c_root_dir: &Path, include_d
         let _ = c.define("NDEBUG", None);
     }
 
-    if target.arch == X86 {
-        let is_msvc_not_clang_cl = compiler.is_like_msvc() && !compiler.is_like_clang_cl();
-        if !is_msvc_not_clang_cl {
-            let _ = c.flag("-msse2");
-        }
+    if target.arch == X86 && !is_msvc_not_clang_cl {
+        let _ = c.flag("-msse2");
     }
 
     // Allow cross-compiling without a target sysroot for these targets.