Do not use GccCiMode for the libs directory

This will allow users to provide pre-built cross-compiled dylibs, while still downloading common (e.g. x64) dylibs from the CI.

Author: Kobzol

bootstrap.example.toml

@@ -190,6 +190,30 @@
 # modifications to the `src/gcc` submodule.
 # Currently, this is only supported for the `x86_64-unknown-linux-gnu` target.
 #gcc.download-ci-gcc = false
+
+# Provide a directory of prebuilt libgccjit.so dylibs for given (host, target) compilation pairs.
+# This is useful when you want to cross-compile `rustc` to another target since GCC is not a
+# multi-target compiler.
+# You have to use a directory structure that looks like this:
+# `<libgccjit-libs-dir>/<host>/<target>/libgccjit.so`.
+# For example:
+#
+# ```
+# <libgccjit-libs-dir>
+# ├── m68k-unknown-linux-gnu
+# │   └── m68k-unknown-linux-gnu
+# │       └── libgccjit.so
+# └── x86_64-unknown-linux-gnu
+#     ├── m68k-unknown-linux-gnu
+#     │   └── libgccjit.so
+#     └── x86_64-unknown-linux-gnu
+#         └── libgccjit.so
+# ```
+# The directory above would allow you to cross-compile rustc from x64 to m68k
+#
+# Note that this option has priority over `gcc.download-ci-gcc`.
+# If you set both, bootstrap will first try to load libgccjit.so from this directory.
+# Only if it isn't found, it will try to download it from CI or build it locally.
 #gcc.libgccjit-libs-dir = "/path/to/libgccjit-libs-dir"
 
 # =============================================================================

src/bootstrap/src/core/build_steps/gcc.rs

@@ -201,25 +201,28 @@ fn try_download_gcc(_builder: &Builder<'_>, _target: TargetSelection) -> Option<
 /// It's used to avoid busting caches during x.py check -- if we've already built
 /// GCC, it's fine for us to not try to avoid doing so.
 pub fn get_gcc_build_status(builder: &Builder<'_>, target: TargetSelection) -> GccBuildStatus {
-    if matches!(builder.config.gcc_ci_mode, crate::core::config::GccCiMode::CopyFromLibsDir) {
-        let directory = builder
-            .config
-            .libgccjit_libs_dir
-            .as_ref()
-            .expect("libgccjit_libs_dir should be set when the mode is CopyFromLibsDir")
-            .join(builder.build.host_target);
-        let path = directory.join(target).join("libgccjit.so");
+    // Prefer taking externally provided prebuilt libgccjit dylib
+    if let Some(dir) = &builder.config.libgccjit_libs_dir {
+        // The dir structure should be <root>/<host>/<target>/libgccjit.so
+        let host_dir = dir.join(builder.build.host_target);
+        let path = host_dir.join(target).join("libgccjit.so");
         if path.exists() {
             return GccBuildStatus::AlreadyBuilt(path);
         } else {
-            builder.info(&format!("libgccjit.so not found at `{}`", path.display()));
+            builder.info(&format!(
+                "libgccjit.so for host `{}` and target `{target}` was not found at `{}`",
+                builder.build.host_target,
+                path.display()
+            ));
         }
     }
 
+    // If not available, try to download from CI
     if let Some(path) = try_download_gcc(builder, target) {
         return GccBuildStatus::AlreadyBuilt(path);
     }
 
+    // If not available, try to build (or use already built libgccjit from disk)
     static STAMP_HASH_MEMO: OnceLock<String> = OnceLock::new();
     let smart_stamp_hash = STAMP_HASH_MEMO.get_or_init(|| {
         generate_smart_stamp_hash(

src/bootstrap/src/core/config/config.rs

@@ -621,8 +621,10 @@ impl Config {
             vendor: dist_vendor,
         } = toml.dist.unwrap_or_default();
 
-        let Gcc { download_ci_gcc: gcc_download_ci_gcc, libgccjit_libs_dir } =
-            toml.gcc.unwrap_or_default();
+        let Gcc {
+            download_ci_gcc: gcc_download_ci_gcc,
+            libgccjit_libs_dir: gcc_libgccjit_libs_dir,
+        } = toml.gcc.unwrap_or_default();
 
         if rust_bootstrap_override_lld.is_some() && rust_bootstrap_override_lld_legacy.is_some() {
             panic!(
@@ -1220,13 +1222,12 @@ impl Config {
             Warnings::Default => rust_deny_warnings.unwrap_or(true),
         };
 
-        let gcc_ci_mode = match (&libgccjit_libs_dir, gcc_download_ci_gcc) {
-            (Some(_), _) => GccCiMode::CopyFromLibsDir,
-            (None, Some(value)) => match value {
+        let gcc_ci_mode = match gcc_download_ci_gcc {
+            Some(value) => match value {
                 true => GccCiMode::DownloadFromCi,
                 false => GccCiMode::BuildLocally,
             },
-            (None, None) => GccCiMode::default(),
+            None => GccCiMode::default(),
         };
 
         let targets = flags_target
@@ -1349,7 +1350,7 @@ impl Config {
             keep_stage: flags_keep_stage,
             keep_stage_std: flags_keep_stage_std,
             libdir: install_libdir.map(PathBuf::from),
-            libgccjit_libs_dir,
+            libgccjit_libs_dir: gcc_libgccjit_libs_dir,
             library_docs_private_items: build_library_docs_private_items.unwrap_or(false),
             lld_enabled,
             lldb: build_lldb.map(PathBuf::from),

src/bootstrap/src/core/config/mod.rs

@@ -433,7 +433,6 @@ pub enum GccCiMode {
     /// If it is not available on CI, it will be built locally instead.
     #[default]
     DownloadFromCi,
-    CopyFromLibsDir,
 }
 
 pub fn threads_from_config(v: u32) -> u32 {