Merge #1028

bors[bot] · Alexhuszagh · web-flow · commit ec03af4acb94 · 2022-10-02T16:26:43.000Z
1028: Fix tests, linkers, and specifications for various targets. r=Emilgardis a=Alexhuszagh

- Fixes linking to libgcc for `armv5te-unknown-linux-musleabi`.
- Adds C++ support for FreeBSD targets by linking to `libstdc++`.
- Tests dynamic library support for Android targets in CI.
- Tests C++ support for `mips64el-unknown-linux-muslabi64` in CI.
- Convert `mips64el-unknown-linux-muslabi64` to a hard-float toolchain to match the rust target.
- Convert `mips64el-unknown-linux-muslabi64` to use the `mips64r2` architecture.
- Convert `mips-unknown-linux-musl` and `mipsel-unknown-linux-musl` to use the `mips32r2` architecture, identical to the rust targets.
- Document whether MIPS musl targets are hard or soft float.

Co-authored-by: Alex Huszagh &lt;ahuszagh@gmail.com&gt;
Co-authored-by: Alexander Huszagh &lt;ahuszagh@gmail.com&gt;
diff --git a/.changes/1028.json b/.changes/1028.json
@@ -0,0 +1,33 @@
+[
+    {
+        "description": "link to libgcc for armv5te-unknown-linux-musleabi.",
+        "type": "fixed"
+    },
+    {
+        "description": "add C++ support for FreeBSD targets.",
+        "type": "added"
+    },
+    {
+        "description": "test dynamic library support for Android targets in CI.",
+        "type": "internal"
+    },
+    {
+        "description": "test partial C++ support for mips64el-unknown-linux-muslabi64 in CI.",
+        "type": "internal"
+    },
+    {
+        "description": "convert mips64el-unknown-linux-muslabi64 to a hard-float toolchain to match the rust target.",
+        "type": "changed",
+        "breaking": true
+    },
+    {
+        "description": "convert mips64el-unknown-linux-muslabi64 to use the mips64r2 architecture, identical to the rust target.",
+        "type": "changed",
+        "breaking": true
+    },
+    {
+        "description": "convert mips-unknown-linux-musl and mipsel-unknown-linux-musl to use the mips32r2 architecture, identical to the rust targets.",
+        "type": "changed",
+        "breaking": true
+    }
+]
diff --git a/docker/Dockerfile.armv5te-unknown-linux-musleabi b/docker/Dockerfile.armv5te-unknown-linux-musleabi
@@ -26,7 +26,9 @@ RUN /musl-symlink.sh $CROSS_MUSL_SYSROOT arm
 
 COPY qemu-runner base-runner.sh /
 
-ENV CARGO_TARGET_ARMV5TE_UNKNOWN_LINUX_MUSLEABI_LINKER=arm-linux-musleabi-gcc \
+COPY arm-linux-musleabi-gcc.sh /usr/bin/
+
+ENV CARGO_TARGET_ARMV5TE_UNKNOWN_LINUX_MUSLEABI_LINKER=arm-linux-musleabi-gcc.sh \
     CARGO_TARGET_ARMV5TE_UNKNOWN_LINUX_MUSLEABI_RUNNER="/qemu-runner arm" \
     CC_armv5te_unknown_linux_musleabi=arm-linux-musleabi-gcc \
     CXX_armv5te_unknown_linux_musleabi=arm-linux-musleabi-g++ \
diff --git a/docker/Dockerfile.i686-unknown-freebsd b/docker/Dockerfile.i686-unknown-freebsd
@@ -19,7 +19,9 @@ COPY freebsd-install.sh /
 COPY freebsd-extras.sh /
 RUN /freebsd-extras.sh
 
-ENV CARGO_TARGET_I686_UNKNOWN_FREEBSD_LINKER=i686-unknown-freebsd12-gcc \
+COPY i686-unknown-freebsd12-gcc.sh /usr/bin
+
+ENV CARGO_TARGET_I686_UNKNOWN_FREEBSD_LINKER=i686-unknown-freebsd12-gcc.sh \
     CC_i686_unknown_freebsd=i686-unknown-freebsd12-gcc \
     CXX_i686_unknown_freebsd=i686-unknown-freebsd12-g++ \
     BINDGEN_EXTRA_CLANG_ARGS_i686_unknown_freebsd="--sysroot=/usr/local/i686-unknown-freebsd12" \
diff --git a/docker/Dockerfile.mips-unknown-linux-musl b/docker/Dockerfile.mips-unknown-linux-musl
@@ -13,6 +13,8 @@ RUN /xargo.sh
 COPY qemu.sh /
 RUN /qemu.sh mips
 
+# this is a soft-float target for the mips32r2 architecture
+# https://github.com/rust-lang/rust/blob/75d3027fb5ce1af6712e4503c9574802212101bd/compiler/rustc_target/src/spec/mips_unknown_linux_musl.rs#L7
 COPY musl.sh /
 RUN /musl.sh \
     TARGET=mips-linux-muslsf \
diff --git a/docker/Dockerfile.mips64-unknown-linux-muslabi64 b/docker/Dockerfile.mips64-unknown-linux-muslabi64
@@ -12,6 +12,8 @@ RUN /xargo.sh
 COPY qemu.sh /
 RUN /qemu.sh mips64
 
+# this is a hard-float target for the mips64r2 architecture
+# https://github.com/rust-lang/rust/blob/75d3027fb5ce1af6712e4503c9574802212101bd/compiler/rustc_target/src/spec/mips64_unknown_linux_muslabi64.rs#L7
 COPY musl.sh /
 RUN /musl.sh \
     TARGET=mips64-linux-musl \
diff --git a/docker/Dockerfile.mips64el-unknown-linux-muslabi64 b/docker/Dockerfile.mips64el-unknown-linux-muslabi64
@@ -12,21 +12,29 @@ RUN /xargo.sh
 COPY qemu.sh /
 RUN /qemu.sh mips64el
 
+# this is a hard-float target for the mips64r2 architecture
+# https://github.com/rust-lang/rust/blob/75d3027fb5ce1af6712e4503c9574802212101bd/compiler/rustc_target/src/spec/mips64el_unknown_linux_muslabi64.rs#L6
 COPY musl.sh /
 RUN /musl.sh \
-    TARGET=mips64el-linux-muslsf \
-    "COMMON_CONFIG += -with-arch=mips64"
+    TARGET=mips64el-linux-musl \
+    "COMMON_CONFIG += -with-arch=mips64r2"
 
-ENV CROSS_MUSL_SYSROOT=/usr/local/mips64el-linux-muslsf
+ENV CROSS_MUSL_SYSROOT=/usr/local/mips64el-linux-musl
 COPY musl-symlink.sh /
-RUN /musl-symlink.sh $CROSS_MUSL_SYSROOT mips64el-sf
+RUN /musl-symlink.sh $CROSS_MUSL_SYSROOT mips64el
+RUN mkdir -p $CROSS_MUSL_SYSROOT/usr/lib64
+# needed for the C/C++ runners
+RUN ln -s $CROSS_MUSL_SYSROOT/usr/lib/libc.so $CROSS_MUSL_SYSROOT/usr/lib64/libc.so
+RUN ln -s $CROSS_MUSL_SYSROOT/usr/lib/libc.so.1 $CROSS_MUSL_SYSROOT/usr/lib64/libc.so.1
+
+COPY mips64el-linux-musl-gcc.sh /usr/bin/
 
 COPY qemu-runner base-runner.sh /
 
-ENV CARGO_TARGET_MIPS64EL_UNKNOWN_LINUX_MUSLABI64_LINKER=mips64el-linux-muslsf-gcc \
+ENV CARGO_TARGET_MIPS64EL_UNKNOWN_LINUX_MUSLABI64_LINKER=mips64el-linux-musl-gcc.sh \
     CARGO_TARGET_MIPS64EL_UNKNOWN_LINUX_MUSLABI64_RUNNER="/qemu-runner mips64el" \
-    CC_mips64el_unknown_linux_muslabi64=mips64el-linux-muslsf-gcc \
-    CXX_mips64el_unknown_linux_muslabi64=mips64el-linux-muslsf-g++ \
+    CC_mips64el_unknown_linux_muslabi64=mips64el-linux-musl-gcc \
+    CXX_mips64el_unknown_linux_muslabi64=mips64el-linux-musl-g++ \
     BINDGEN_EXTRA_CLANG_ARGS_mips64el_unknown_linux_muslabi64="--sysroot=$CROSS_MUSL_SYSROOT" \
     QEMU_LD_PREFIX=$CROSS_MUSL_SYSROOT \
     RUST_TEST_THREADS=1
diff --git a/docker/Dockerfile.mipsel-unknown-linux-musl b/docker/Dockerfile.mipsel-unknown-linux-musl
@@ -13,10 +13,12 @@ RUN /xargo.sh
 COPY qemu.sh /
 RUN /qemu.sh mipsel
 
+# this is a soft-float target for the mips32r2 architecture
+# https://github.com/rust-lang/rust/blob/75d3027fb5ce1af6712e4503c9574802212101bd/compiler/rustc_target/src/spec/mipsel_unknown_linux_musl.rs#L6
 COPY musl.sh /
 RUN /musl.sh \
     TARGET=mipsel-linux-muslsf \
-    "COMMON_CONFIG += -with-arch=mips32"
+    "COMMON_CONFIG += -with-arch=mips32r2"
 
 ENV CROSS_MUSL_SYSROOT=/usr/local/mipsel-linux-muslsf
 COPY musl-symlink.sh /
diff --git a/docker/Dockerfile.x86_64-unknown-freebsd b/docker/Dockerfile.x86_64-unknown-freebsd
@@ -19,7 +19,9 @@ COPY freebsd-install.sh /
 COPY freebsd-extras.sh /
 RUN /freebsd-extras.sh
 
-ENV CARGO_TARGET_X86_64_UNKNOWN_FREEBSD_LINKER=x86_64-unknown-freebsd12-gcc \
+COPY x86_64-unknown-freebsd12-gcc.sh /usr/bin
+
+ENV CARGO_TARGET_X86_64_UNKNOWN_FREEBSD_LINKER=x86_64-unknown-freebsd12-gcc.sh \
     CC_x86_64_unknown_freebsd=x86_64-unknown-freebsd12-gcc \
     CXX_x86_64_unknown_freebsd=x86_64-unknown-freebsd12-g++ \
     BINDGEN_EXTRA_CLANG_ARGS_x86_64_unknown_freebsd="--sysroot=/usr/local/x86_64-unknown-freebsd12" \
diff --git a/docker/aarch64-linux-musl-gcc.sh b/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
diff --git a/docker/arm-linux-musleabi-gcc.sh b/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
diff --git a/docker/i686-unknown-freebsd12-gcc.sh b/docker/i686-unknown-freebsd12-gcc.sh
@@ -0,0 +1,17 @@
+#!/bin/bash
+
+# the freebsd images need libstdc++ to be linked as well
+# otherwise, we get `undefined reference to `std::ios_base::Init::Init()'`
+
+set -x
+set -euo pipefail
+
+main() {
+    if [[ $# -eq 0 ]]; then
+        exec i686-unknown-freebsd12-gcc "${@}"
+    else
+        exec i686-unknown-freebsd12-gcc "${@}" -lc++ -lstdc++
+    fi
+}
+
+main "${@}"
diff --git a/docker/mips64-linux-musl-gcc.sh b/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
diff --git a/docker/mips64el-linux-musl-gcc.sh b/docker/mips64el-linux-musl-gcc.sh
@@ -0,0 +1,20 @@
+#!/bin/bash
+
+# this linker wrapper works around the missing soft-fp routine __trunctfsf2
+# this affects rust versions with compiler-builtins <= 0.1.77,
+# 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 (( CROSS_RUSTC_MINOR_VERSION >= 65 )) || [[ $# -eq 0 ]]; then
+        exec mips64el-linux-musl-gcc "${@}"
+    else
+        exec mips64el-linux-musl-gcc "${@}" -lgcc -static-libgcc
+    fi
+}
+
+main "${@}"
diff --git a/docker/x86_64-unknown-freebsd12-gcc.sh b/docker/x86_64-unknown-freebsd12-gcc.sh
@@ -0,0 +1,17 @@
+#!/bin/bash
+
+# the freebsd images need libstdc++ to be linked as well
+# otherwise, we get `undefined reference to `std::ios_base::Init::Init()'`
+
+set -x
+set -euo pipefail
+
+main() {
+    if [[ $# -eq 0 ]]; then
+        exec x86_64-unknown-freebsd12-gcc "${@}"
+    else
+        exec x86_64-unknown-freebsd12-gcc "${@}" -lc++ -lstdc++
+    fi
+}
+
+main "${@}"
diff --git a/src/docker/local.rs b/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,
diff --git a/src/docker/remote.rs b/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)]);
diff --git a/src/docker/shared.rs b/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 the oldest
+        // compiler available. this isn't a major issue because
+        // linking with 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(())
 }
 
diff --git a/src/lib.rs b/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")?;
diff --git a/targets.toml b/targets.toml
