WIP: Add clang-cl windows cross compilation

Hi, this is going to be a little insane and a little strange but I would
like to get a read on the following as I refine it towards a potential
addition to these rules.

The following code allows for cross compiling windows (with MSVC ABI
rather than GNU, and I hope to adapt it to cope with clang on windows
too.

If this is something wanted I can polish these rules further rather than
fork and adapt.

This is very much an initial read, so there are some hacks, a hardcoded
path I could use help with and probably constructions that I am sure we
want to change.

Author: GregBowyer

platforms/BUILD.bazel

@@ -37,3 +37,11 @@ platform(
         "@platforms//cpu:x86_64",
     ],
 )
+
+platform(
+    name = "windows-x86_64",
+    constraint_values = [
+        "@platforms//os:windows",
+        "@platforms//cpu:x86_64",
+    ],
+)

toolchain/BUILD.llvm_repo

@@ -31,13 +31,41 @@ filegroup(
     ],
 )
 
+filegroup(
+    name = "clang-cl",
+    srcs = [
+        "bin/clang-cl",
+    ],
+)
+
+filegroup(
+    name = "llvm-ml",
+    srcs = [
+        "bin/llvm-ml",
+    ],
+)
+
 filegroup(
     name = "ld",
     srcs = [
         "bin/ld.lld",
     ],
 )
 
+filegroup(
+    name = "lld-link",
+    srcs = [
+        "bin/lld-link",
+    ],
+)
+
+filegroup(
+    name = "llvm-lib",
+    srcs = [
+        "bin/llvm-lib",
+    ]
+)
+
 filegroup(
     name = "include",
     srcs = glob([

toolchain/cc_toolchain_config.bzl

@@ -16,6 +16,10 @@ load(
     "@bazel_tools//tools/cpp:unix_cc_toolchain_config.bzl",
     unix_cc_toolchain_config = "cc_toolchain_config",
 )
+load(
+    "@bazel_tools//tools/cpp:windows_cc_toolchain_config.bzl",
+    windows_cc_toolchain_config = "cc_toolchain_config",
+)
 load(
     "//toolchain/internal:common.bzl",
     _check_os_arch_keys = "check_os_arch_keys",
@@ -43,6 +47,14 @@ def cc_toolchain_config(
         compiler_configuration,
         llvm_version,
         host_tools_info = {}):
+
+    # Windows even if cross compiling is different to the point of just using a
+    # different configuration step
+    if target_os == "windows":
+        return windows_cc_toolchain(name, host_arch, host_os, target_arch, target_os,
+                                    toolchain_path_prefix, tools_path_prefix, wrapper_bin_prefix,
+                                    compiler_configuration, llvm_version, host_tools_info = {})
+
     host_os_arch_key = _os_arch_pair(host_os, host_arch)
     target_os_arch_key = _os_arch_pair(target_os, target_arch)
     _check_os_arch_keys([host_os_arch_key, target_os_arch_key])
@@ -169,6 +181,7 @@ def cc_toolchain_config(
     stdlib = compiler_configuration["stdlib"]
     if stdlib == "builtin-libc++" and is_xcompile:
         stdlib = "stdc++"
+
     if stdlib == "builtin-libc++":
         cxx_flags = [
             "-std=" + cxx_standard,
@@ -245,8 +258,10 @@ def cc_toolchain_config(
 
     sysroot_path = compiler_configuration["sysroot_path"]
     sysroot_prefix = ""
+
     if sysroot_path:
         sysroot_prefix = "%sysroot%"
+
     if target_os == "linux":
         cxx_builtin_include_directories.extend([
             sysroot_prefix + "/include",
@@ -285,8 +300,6 @@ def cc_toolchain_config(
         else:
             ar_binary = host_tools_info["libtool"]["path"]
 
-    # The tool names come from [here](https://github.com/bazelbuild/bazel/blob/c7e58e6ce0a78fdaff2d716b4864a5ace8917626/src/main/java/com/google/devtools/build/lib/rules/cpp/CppConfiguration.java#L76-L90):
-    # NOTE: Ensure these are listed in toolchain_tools in toolchain/internal/common.bzl.
     tool_paths = {
         "ar": ar_binary,
         "cpp": tools_path_prefix + "clang-cpp",
@@ -358,3 +371,131 @@ def cc_toolchain_config(
         supports_start_end_lib = supports_start_end_lib,
         builtin_sysroot = sysroot_path,
     )
+
+def windows_cc_toolchain(
+        name,
+        host_arch,
+        host_os,
+        target_arch,
+        target_os,
+        toolchain_path_prefix,
+        tools_path_prefix,
+        wrapper_bin_prefix,
+        compiler_configuration,
+        llvm_version,
+        host_tools_info = {}):
+
+    sysroot_path = compiler_configuration["sysroot_path"]
+
+    # For the bring your own sysroot crowd, we assume xwin
+    # These are the defaults ...
+    msvc_env_tmp = "msvc_not_found"
+    msvc_env_path = "msvc_not_found"
+    msvc_env_include = "msvc_not_found"
+    msvc_env_lib = "msvc_not_found"
+    msvc_cl_path = tools_path_prefix + "clang-cl"
+    msvc_ml_path = tools_path_prefix + "clang-cl" # llvm-ml"
+    msvc_link_path = tools_path_prefix + "lld-link"
+    msvc_lib_path = tools_path_prefix + "llvm-lib"
+
+    cxx_builtin_include_directories = []
+
+    raw_llvm_repo_path = compiler_configuration['raw_llvm_repo_path']
+    if raw_llvm_repo_path:
+        cxx_builtin_include_directories.extend([
+            raw_llvm_repo_path + "include/c++/v1",
+            raw_llvm_repo_path + "include/windows/c++/v1",
+            raw_llvm_repo_path + "lib/clang/{}/include".format(llvm_version),
+            raw_llvm_repo_path + "lib64/clang/{}/include".format(llvm_version),
+        ])
+
+    if host_os == "windows":
+        script_lang = ".bat"
+        # TODO: Make work on windows ;)
+        # sysroot = figure_out_sysroot_vs_msvc_install()
+        fail("Not currently working on windows")
+    else:
+        script_lang = ".sh"
+        if not sysroot_path:
+            fail("In cross compilation of windows artifacts an MSVCRT sysroot needs to be prepared")
+
+        includes = [
+            sysroot_path + "/crt/include",
+            sysroot_path + "/sdk/include/ucrt",
+            sysroot_path + "/sdk/include/um",
+            sysroot_path + "/sdk/include/shared",
+        ]
+
+        lib_paths = [
+            # TODO: Arch should be inferred
+            sysroot_path + "/crt/lib/x86_64",
+            sysroot_path + "/sdk/lib/um/x86_64",
+            sysroot_path + "/sdk/lib/ucrt/x86_64",
+            # TODO: How to get this in a sysroot
+            sysroot_path + "/clang-rt-14.0.0",
+        ]
+
+        # HACK we combine paths with `;` which is not a unix idiom, since windows_cc_toolchain_config
+        # HACK breaks this apart with split :/
+        msvc_env_include = ';'.join(includes)
+        cxx_builtin_include_directories.extend(includes)
+
+        msvc_env_lib = ';'.join(lib_paths)
+        #msvc_link_path = ';'.join(lib_paths)
+
+    # These are the defaults, how to configure?
+    archiver_flags = []
+    default_link_flags = []
+
+    tool_paths = {
+        "ar": tools_path_prefix + "clang-cl",
+        "ml": tools_path_prefix + "clang-cl", # llvm-ml",
+        "cpp": tools_path_prefix + "clang-cl",
+        "gcc": tools_path_prefix + "clang-cl",
+        "ld": tools_path_prefix + "lld-link",
+        "gcov": wrapper_bin_prefix + "msvc_nop" + script_lang,
+        "nm": wrapper_bin_prefix + "msvc_nop" + script_lang,
+        "objcopy": wrapper_bin_prefix + "msvc_nop" + script_lang,
+        "objdump": wrapper_bin_prefix + "msvc_nop" + script_lang,
+        "strip": wrapper_bin_prefix + "msvc_nop" + script_lang,
+    }
+
+    tool_bin_path = "not_found"
+
+    cxx_builtin_include_directories.extend(compiler_configuration["additional_include_dirs"])
+
+    dbg_mode_debug_flag = "/DEBUG"
+    fastbuild_mode_debug_flag = "/DEBUG"
+
+    windows_cc_toolchain_config(
+        name = name,
+        cpu = "x64_windows",
+        # The compiler is hardcoded, we only support clang (suprise!) and its
+        # required to satisify https://cs.opensource.google/bazel/bazel/+/master:tools/cpp/windows_cc_toolchain_config.bzl;l=82
+        compiler = "clang-cl",
+        # TODO: To support Arm or x86_32 this needs to be configured
+        toolchain_identifier = "clang_cl_x64",
+        host_system_name = "linux",
+        target_system_name = "windows",
+        # TODO: On windows this should probably figure out where the VC install is
+        # This toolchain only supports MSCRT as the ABI, I would suggest zig-cc-bazel for GNU ABI
+        # These values are related to the provided sysroot
+        target_libc = "msvcrt",
+        abi_version = "local",
+        abi_libc_version = "local",
+        cxx_builtin_include_directories = cxx_builtin_include_directories,
+        tool_paths = tool_paths,
+        archiver_flags = ["/MACHINE:X64"],
+        default_link_flags = ["/MACHINE:X64", "/DEFAULTLIB:clang_rt.builtins-x86_64.lib"],
+        msvc_env_tmp = msvc_env_tmp,
+        msvc_env_path = msvc_env_path,
+        msvc_env_include = msvc_env_include,
+        msvc_env_lib = msvc_env_lib,
+        msvc_cl_path = msvc_cl_path,
+        msvc_ml_path = msvc_ml_path,
+        msvc_link_path = msvc_link_path,
+        msvc_lib_path = msvc_lib_path,
+        dbg_mode_debug_flag = dbg_mode_debug_flag,
+        fastbuild_mode_debug_flag = fastbuild_mode_debug_flag,
+        tool_bin_path = tool_bin_path,
+    )

toolchain/internal/common.bzl

@@ -12,19 +12,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-SUPPORTED_TARGETS = [("linux", "x86_64"), ("linux", "aarch64"), ("darwin", "x86_64")]
+SUPPORTED_TARGETS = [("linux", "x86_64"), ("linux", "aarch64"), ("darwin", "x86_64"), ("windows", "x86_64")]
 
 host_tool_features = struct(
     SUPPORTS_ARG_FILE = "supports_arg_file",
 )
 
 toolchain_tools = [
     "clang-cpp",
+    "clang-cl",
     "ld.lld",
+    "lld-link",
+    "llvm-lib",
     "llvm-ar",
     "llvm-dwp",
     "llvm-profdata",
     "llvm-cov",
+    "llvm-ml",
     "llvm-nm",
     "llvm-objcopy",
     "llvm-objdump",
@@ -58,7 +62,7 @@ def os(rctx):
 
 def os_bzl(os):
     # Return the OS string as used in bazel platform constraints.
-    return {"darwin": "osx", "linux": "linux"}[os]
+    return {"darwin": "osx", "linux": "linux", "windows": "windows"}[os]
 
 def arch(rctx):
     exec_result = rctx.execute([

toolchain/internal/configure.bzl

@@ -67,6 +67,8 @@ def llvm_register_toolchains():
     if toolchain_root[0] == "/" and (len(toolchain_root) == 1 or toolchain_root[1] != "/"):
         use_absolute_paths = True
 
+    raw_llvm_repo_path = ""
+
     if use_absolute_paths:
         llvm_repo_label = Label(toolchain_root + ":BUILD.bazel")  # Exact target does not matter.
         llvm_repo_path = _canonical_dir_path(str(rctx.path(llvm_repo_label).dirname))
@@ -79,6 +81,7 @@ def llvm_register_toolchains():
     else:
         llvm_repo_label = Label(toolchain_root + ":BUILD.bazel")  # Exact target does not matter.
         llvm_repo_path = _pkg_path_from_label(llvm_repo_label)
+        raw_llvm_repo_path = _canonical_dir_path(str(rctx.path(llvm_repo_label).dirname))
         config_repo_path = "external/%s/" % rctx.name
 
         # tools can only be defined in a subdirectory of config_repo_path,
@@ -97,6 +100,7 @@ def llvm_register_toolchains():
         tools_path_prefix = "bin/"
         for tool_name in _toolchain_tools:
             rctx.symlink("../../" + llvm_repo_path + "/bin/" + tool_name, tools_path_prefix + tool_name)
+
         symlinked_tools_str = "\n".join([" " * 8 + "\"" + tools_path_prefix + name + "\"," for name in _toolchain_tools])
         llvm_repo_label_prefix = toolchain_root + ":"
         toolchain_path_prefix = llvm_repo_path
@@ -128,6 +132,7 @@ def llvm_register_toolchains():
         coverage_link_flags_dict = rctx.attr.coverage_link_flags,
         unfiltered_compile_flags_dict = rctx.attr.unfiltered_compile_flags,
         llvm_version = rctx.attr.llvm_version,
+        raw_llvm_repo_path = raw_llvm_repo_path,
     )
     host_dl_ext = "dylib" if os == "darwin" else "so"
     host_tools_info = dict([
@@ -257,6 +262,7 @@ def _cc_toolchain_str(
         target_os,
         target_arch,
     )
+
     if not sysroot_path:
         if host_os == target_os and host_arch == target_arch:
             # For darwin -> darwin, we can use the macOS SDK path.
@@ -265,6 +271,7 @@ def _cc_toolchain_str(
             # We are trying to cross-compile without a sysroot, let's bail.
             # TODO: Are there situations where we can continue?
             return ""
+
     sysroot_label_str = "\"%s\"" % str(sysroot) if sysroot else ""
 
     extra_files_str = ", \":internal-use-symlinked-tools\", \":internal-use-wrapped-tools\""
@@ -302,6 +309,7 @@ cc_toolchain_config(
       "coverage_compile_flags": {coverage_compile_flags},
       "coverage_link_flags": {coverage_link_flags},
       "unfiltered_compile_flags": {unfiltered_compile_flags},
+      "raw_llvm_repo_path": "{raw_llvm_repo_path}",
     }},
     llvm_version = "{llvm_version}",
     host_tools_info = {host_tools_info},
@@ -322,6 +330,8 @@ toolchain(
 )
 """
 
+    # TODO: Should this look at windows and not require lld-link / clang-cl for all platforms?
+
     if use_absolute_paths:
         template = template + """
 cc_toolchain(
@@ -346,6 +356,8 @@ filegroup(
     name = "compiler-components-{suffix}",
     srcs = [
         "{llvm_repo_label_prefix}clang",
+        "{llvm_repo_label_prefix}clang-cl",
+        "{llvm_repo_label_prefix}llvm-lib",
         "{llvm_repo_label_prefix}include",
         ":sysroot-components-{suffix}",
     ],
@@ -356,6 +368,8 @@ filegroup(
     srcs = [
         "{llvm_repo_label_prefix}clang",
         "{llvm_repo_label_prefix}ld",
+        "{llvm_repo_label_prefix}lld-link",
+        "{llvm_repo_label_prefix}llvm-lib",
         "{llvm_repo_label_prefix}ar",
         "{llvm_repo_label_prefix}lib",
         ":sysroot-components-{suffix}",
@@ -403,6 +417,7 @@ cc_toolchain(
         target_os_bzl = target_os_bzl,
         host_os_bzl = host_os_bzl,
         llvm_repo_label_prefix = toolchain_info.llvm_repo_label_prefix,
+        raw_llvm_repo_path = toolchain_info.raw_llvm_repo_path,
         toolchain_path_prefix = toolchain_info.toolchain_path_prefix,
         tools_path_prefix = toolchain_info.tools_path_prefix,
         wrapper_bin_prefix = toolchain_info.wrapper_bin_prefix,

toolchain/internal/sysroot.bzl

@@ -30,6 +30,7 @@ def _darwin_sdk_path(rctx):
 # sysroot for the target, and when host platform is the same as target
 # platform.
 def default_sysroot_path(rctx, os):
+    # TODO: Add windows
     if os == "darwin":
         return _darwin_sdk_path(rctx)
     else:

toolchain/tools/host_os_key.py

@@ -19,7 +19,8 @@
 import sys
 
 
-_known_distros = ["freebsd", "suse", "ubuntu", "arch", "manjaro", "debian", "fedora", "centos", "amzn", "raspbian", "pop"]
+_known_distros = ["freebsd", "suse", "ubuntu", "arch", "manjaro", "debian",
+    "fedora", "centos", "amzn", "raspbian", "pop", "nixos"]
 
 
 def _linux_dist():

toolchain/tools/llvm_release_name.py

@@ -122,6 +122,9 @@ def _linux(llvm_version, distname, version, arch):
     elif distname == "raspbian":
         arch = "armv7a"
         os_name = "linux-gnueabihf"
+    elif distname == "nixos":
+        # This is a lie that works with nix-ld
+        os_name = "linux-gnu-ubuntu-18.04"
     else:
         sys.exit("Unsupported linux distribution and version: %s, %s" % (distname, version))