Add rustc versions to docker environment variables.

Author: Alexhuszagh

docker/aarch64-linux-musl-gcc.sh

@@ -8,13 +8,7 @@ set -x
 set -euo pipefail
 
 main() {
-    local release=
-    release=$(rustc -Vv | grep '^release:' | cut -d ':' -f2)
-    # NOTE we assume `major` is always "1"
-    local minor=
-    minor=$(echo "$release" | cut -d '.' -f2)
-
-    if (( minor >= 48 )) || [[ $# -eq 0 ]]; then
+    if (( CROSS_RUSTC_MINOR_VERSION >= 48 )) || [[ $# -eq 0 ]]; then
         # no workaround
         exec aarch64-linux-musl-gcc "${@}"
     else

docker/arm-linux-musleabi-gcc.sh

@@ -2,15 +2,15 @@
 
 # this linker wrapper works around the missing sync `sync_X_and_fetch`
 # routines. this affects rust versions with compiler-builtins <= 0.1.77,
-# which has not yet been merged into stable. this requires the `-lgcc`
+# which affects toolchains older than 1.65 which require the `-lgcc`
 # linker flag to provide the missing builtin.
 # https://github.com/rust-lang/compiler-builtins/pull/484
 
 set -x
 set -euo pipefail
 
 main() {
-    if [[ $# -eq 0 ]]; then
+    if (( CROSS_RUSTC_MINOR_VERSION >= 65 )) || [[ $# -eq 0 ]]; then
         exec arm-linux-musleabi-gcc "${@}"
     else
         exec arm-linux-musleabi-gcc "${@}" -lgcc -static-libgcc

docker/mips64-linux-musl-gcc.sh

@@ -2,15 +2,15 @@
 
 # this linker wrapper works around the missing soft-fp routine __trunctfsf2
 # this affects rust versions with compiler-builtins <= 0.1.77,
-# which has not yet been merged into stable. this requires the `-lgcc`
+# which affects toolchains older than 1.65 which require the `-lgcc`
 # linker flag to provide the missing builtin.
 # https://github.com/rust-lang/compiler-builtins/pull/483
 
 set -x
 set -euo pipefail
 
 main() {
-    if [[ $# -eq 0 ]]; then
+    if (( CROSS_RUSTC_MINOR_VERSION >= 65 )) || [[ $# -eq 0 ]]; then
         exec mips64-linux-musl-gcc "${@}"
     else
         exec mips64-linux-musl-gcc "${@}" -lgcc -static-libgcc

docker/mips64el-linux-musl-gcc.sh

@@ -2,15 +2,15 @@
 
 # this linker wrapper works around the missing soft-fp routine __trunctfsf2
 # this affects rust versions with compiler-builtins <= 0.1.77,
-# which has not yet been merged into stable. this requires the `-lgcc`
+# which affects toolchains older than 1.65 which require the `-lgcc`
 # linker flag to provide the missing builtin.
 # https://github.com/rust-lang/compiler-builtins/pull/483
 
 set -x
 set -euo pipefail
 
 main() {
-    if [[ $# -eq 0 ]]; then
+    if (( CROSS_RUSTC_MINOR_VERSION >= 65 )) || [[ $# -eq 0 ]]; then
         exec mips64el-linux-musl-gcc "${@}"
     else
         exec mips64el-linux-musl-gcc "${@}" -lgcc -static-libgcc

src/docker/local.rs

@@ -38,14 +38,7 @@ pub(crate) fn run(
         .image
         .platform
         .specify_platform(&options.engine, &mut docker);
-    docker_envvars(
-        &mut docker,
-        &options.config,
-        dirs,
-        &options.target,
-        options.cargo_variant,
-        msg_info,
-    )?;
+    docker_envvars(&mut docker, &options, dirs, msg_info)?;
 
     docker_mount(
         &mut docker,

src/docker/remote.rs

@@ -1209,14 +1209,7 @@ symlink_recurse \"${{prefix}}\"
     // 6. execute our cargo command inside the container
     let mut docker = subcommand(engine, "exec");
     docker_user_id(&mut docker, engine.kind);
-    docker_envvars(
-        &mut docker,
-        &options.config,
-        dirs,
-        target,
-        options.cargo_variant,
-        msg_info,
-    )?;
+    docker_envvars(&mut docker, &options, dirs, msg_info)?;
     docker_cwd(&mut docker, &paths)?;
     docker.arg(&container);
     docker.args(["sh", "-c", &build_command(dirs, &cmd)]);

src/docker/shared.rs

@@ -18,6 +18,8 @@ use crate::rustc::QualifiedToolchain;
 use crate::shell::{MessageInfo, Verbosity};
 use crate::{CargoVariant, Target};
 
+use rustc_version::Version as RustcVersion;
+
 pub use super::custom::CROSS_CUSTOM_DOCKERFILE_IMAGE_PREFIX;
 
 pub const CROSS_IMAGE: &str = "ghcr.io/cross-rs";
@@ -37,6 +39,8 @@ pub struct DockerOptions {
     pub config: Config,
     pub image: Image,
     pub cargo_variant: CargoVariant,
+    // not all toolchains will provide this
+    pub rustc_version: Option<RustcVersion>,
 }
 
 impl DockerOptions {
@@ -46,13 +50,15 @@ impl DockerOptions {
         config: Config,
         image: Image,
         cargo_variant: CargoVariant,
+        rustc_version: Option<RustcVersion>,
     ) -> DockerOptions {
         DockerOptions {
             engine,
             target,
             config,
             image,
             cargo_variant,
+            rustc_version,
         }
     }
 
@@ -514,29 +520,31 @@ fn add_cargo_configuration_envvars(docker: &mut Command) {
 
 pub(crate) fn docker_envvars(
     docker: &mut Command,
-    config: &Config,
+    options: &DockerOptions,
     dirs: &Directories,
-    target: &Target,
-    cargo_variant: CargoVariant,
     msg_info: &mut MessageInfo,
 ) -> Result<()> {
-    for ref var in config.env_passthrough(target)?.unwrap_or_default() {
+    for ref var in options
+        .config
+        .env_passthrough(&options.target)?
+        .unwrap_or_default()
+    {
         validate_env_var(var)?;
 
         // Only specifying the environment variable name in the "-e"
         // flag forwards the value from the parent shell
         docker.args(["-e", var]);
     }
 
-    let runner = config.runner(target)?;
+    let runner = options.config.runner(&options.target)?;
     let cross_runner = format!("CROSS_RUNNER={}", runner.unwrap_or_default());
     docker
         .args(["-e", "PKG_CONFIG_ALLOW_CROSS=1"])
         .args(["-e", &format!("XARGO_HOME={}", dirs.xargo_mount_path())])
         .args(["-e", &format!("CARGO_HOME={}", dirs.cargo_mount_path())])
         .args(["-e", "CARGO_TARGET_DIR=/target"])
         .args(["-e", &cross_runner]);
-    if cargo_variant.uses_zig() {
+    if options.cargo_variant.uses_zig() {
         // otherwise, zig has a permission error trying to create the cache
         docker.args(["-e", "XDG_CACHE_HOME=/target/.zig-cache"]);
     }
@@ -564,6 +572,18 @@ pub(crate) fn docker_envvars(
         docker.args(&parse_docker_opts(&value)?);
     };
 
+    let (major, minor, patch) = match options.rustc_version.as_ref() {
+        Some(version) => (version.major, version.minor, version.patch),
+        // no toolchain version available, always provide older
+        // compiler available. this isn't a major issue because
+        // linking will libgcc will not include symbols found in
+        // the builtins.
+        None => (1, 0, 0),
+    };
+    docker.args(["-e", &format!("CROSS_RUSTC_MAJOR_VERSION={}", major)]);
+    docker.args(["-e", &format!("CROSS_RUSTC_MINOR_VERSION={}", minor)]);
+    docker.args(["-e", &format!("CROSS_RUSTC_PATCH_VERSION={}", patch)]);
+
     Ok(())
 }
 

src/lib.rs

@@ -595,17 +595,19 @@ To override the toolchain mounted in the image, set `target.{}.image.toolchain =
                 }
             };
 
-            if let Some((rustc_version, channel, rustc_commit)) = toolchain.rustc_version()? {
+            let mut rustc_version = None;
+            if let Some((version, channel, commit)) = toolchain.rustc_version()? {
                 if toolchain.date.is_none() {
                     warn_host_version_mismatch(
                         &host_version_meta,
                         &toolchain,
-                        &rustc_version,
-                        &rustc_commit,
+                        &version,
+                        &commit,
                         msg_info,
                     )?;
                 }
                 is_nightly = channel == Channel::Nightly;
+                rustc_version = Some(version);
             }
 
             let uses_build_std = config.build_std(&target).unwrap_or(false);
@@ -711,6 +713,7 @@ To override the toolchain mounted in the image, set `target.{}.image.toolchain =
                     config,
                     image,
                     cargo_variant,
+                    rustc_version,
                 );
                 let status = docker::run(options, paths, &filtered_args, msg_info)
                     .wrap_err("could not run container")?;