Merge #1733 #1792 #1816

1733: Validate `-fuse-ld=lld` is passed, enable on aarch64 r=Hoverbear a=Hoverbear

Also needed to edit the test harness to allow non-strict args.

[I am upstreaming the aarch64 enablement as well.](rust-lang/rust#146604). -- I do not expect it to merge as is, as Upstream is changing some stuff to make this story better. :)

This is manually backported to 1.90/25.11: #1804

1792: Add more tests to `coretests` r=Hoverbear a=pvdrz

Improve coverage numbers.

This will get upstreamed.

1816: Remove `compare_and_swap` from the subset r=Hoverbear a=pvdrz

This function is deprecated and not having it in the subset allows us to not write tests to increase coverage for a function that our users aren't supposed to use


Co-authored-by: Ana Hobden <operator@hoverbear.org>
Co-authored-by: Christian Poveda <christian.poveda@ferrous-systems.com>

Author: 3 people

bootstrap.example.toml

@@ -763,10 +763,11 @@
 #rust.codegen-backends = ["llvm"]
 
 # Indicates whether LLD will be compiled and made available in the sysroot for rustc to execute, and
-# whether to set it as rustc's default linker on `x86_64-unknown-linux-gnu`. This will also only be
-# when *not* building an external LLVM (so only when using `download-ci-llvm` or building LLVM from
-# the in-tree source): setting `llvm-config` in the `[target.x86_64-unknown-linux-gnu]` section will
-# make this default to false.
+# whether to set it as rustc's default linker on `x86_64-unknown-linux-gnu` and
+# `aarch64-unknown-linux-gnu`. This will also only be when *not* building an external LLVM (so only
+# when using `download-ci-llvm` or building LLVM from the in-tree source): setting `llvm-config` in
+# the `[target.x86_64-unknown-linux-gnu]` or `[target.aarch64-unknown-linux-gnu`] section will make
+# this default to false.
 #rust.lld = false in all cases, except on `x86_64-unknown-linux-gnu` as described above, where it is true
 
 # Indicates if we should override the linker used to link Rust crates during bootstrap to be LLD.

compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_gnu.rs

@@ -1,8 +1,41 @@
 use crate::spec::{
-    FramePointer, SanitizerSet, StackProbeType, Target, TargetMetadata, TargetOptions, base,
+    Cc, FramePointer, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetMetadata,
+    TargetOptions, base,
 };
 
 pub(crate) fn target() -> Target {
+    // Ferrocene annotation: Ferrocene has `lld` enabled for this target,
+    // so the `TargetOptions` are moved out of the `Target`,
+    // these changes can likely go away once https://github.com/rust-lang/rust/pull/146604
+    // lands.
+    let mut base = TargetOptions {
+        features: "+v8a,+outline-atomics".into(),
+        // the AAPCS64 expects use of non-leaf frame pointers per
+        // https://github.com/ARM-software/abi-aa/blob/4492d1570eb70c8fd146623e0db65b2d241f12e7/aapcs64/aapcs64.rst#the-frame-pointer
+        // and we tend to encounter interesting bugs in AArch64 unwinding code if we do not
+        frame_pointer: FramePointer::NonLeaf,
+        mcount: "\u{1}_mcount".into(),
+        max_atomic_width: Some(128),
+        stack_probes: StackProbeType::Inline,
+        supported_sanitizers: SanitizerSet::ADDRESS
+            | SanitizerSet::CFI
+            | SanitizerSet::KCFI
+            | SanitizerSet::LEAK
+            | SanitizerSet::MEMORY
+            | SanitizerSet::MEMTAG
+            | SanitizerSet::THREAD
+            | SanitizerSet::HWADDRESS,
+        supports_xray: true,
+        ..base::linux_gnu::opts()
+    };
+
+    // When we're asked to use the `rust-lld` linker by default, set the appropriate lld-using
+    // linker flavor, and self-contained linker component.
+    if option_env!("CFG_USE_SELF_CONTAINED_LINKER").is_some() {
+        base.linker_flavor = LinkerFlavor::Gnu(Cc::Yes, Lld::Yes);
+        base.link_self_contained = crate::spec::LinkSelfContainedDefault::with_linker();
+    }
+
     Target {
         llvm_target: "aarch64-unknown-linux-gnu".into(),
         metadata: TargetMetadata {
@@ -14,25 +47,6 @@ pub(crate) fn target() -> Target {
         pointer_width: 64,
         data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(),
         arch: "aarch64".into(),
-        options: TargetOptions {
-            features: "+v8a,+outline-atomics".into(),
-            // the AAPCS64 expects use of non-leaf frame pointers per
-            // https://github.com/ARM-software/abi-aa/blob/4492d1570eb70c8fd146623e0db65b2d241f12e7/aapcs64/aapcs64.rst#the-frame-pointer
-            // and we tend to encounter interesting bugs in AArch64 unwinding code if we do not
-            frame_pointer: FramePointer::NonLeaf,
-            mcount: "\u{1}_mcount".into(),
-            max_atomic_width: Some(128),
-            stack_probes: StackProbeType::Inline,
-            supported_sanitizers: SanitizerSet::ADDRESS
-                | SanitizerSet::CFI
-                | SanitizerSet::KCFI
-                | SanitizerSet::LEAK
-                | SanitizerSet::MEMORY
-                | SanitizerSet::MEMTAG
-                | SanitizerSet::THREAD
-                | SanitizerSet::HWADDRESS,
-            supports_xray: true,
-            ..base::linux_gnu::opts()
-        },
+        options: base,
     }
 }

ferrocene/tools/self-test/src/error.rs

@@ -37,6 +37,8 @@ pub(crate) enum Error {
     BinaryVersionMismatch { binary: String, field: String, expected: String, found: String },
     #[error("library {library} is missing from target {target}")]
     TargetLibraryMissing { target: String, library: String },
+    #[error("default link arg {link_arg} is missing from target {target}")]
+    TargetDefaultLinkArgMissing { target: String, link_arg: String },
     #[error("there are conflicting copies of library {library} for target {target}")]
     DuplicateTargetLibrary { target: String, library: String },
     #[error("failed to access {} while discovering target libraries", path.display())]
@@ -128,6 +130,7 @@ impl Error {
             Error::WrongLinkerArgs { .. } => 24,
             Error::RunningSampleProgramFailed { .. } => 25,
             Error::SampleProgramOutputWrong { .. } => 26,
+            Error::TargetDefaultLinkArgMissing { .. } => 27,
         }
     }
 

ferrocene/tools/self-test/src/main.rs

@@ -1,6 +1,5 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 // SPDX-FileCopyrightText: The Ferrocene Developers
-
 mod binaries;
 mod compile;
 mod env;

ferrocene/tools/self-test/src/targets.rs

@@ -4,10 +4,12 @@
 use std::collections::{HashMap, HashSet};
 use std::ops::Deref;
 use std::path::Path;
+use std::process::Command;
 
 use crate::error::Error;
 use crate::linkers::Linker;
 use crate::report::Reporter;
+use crate::utils::run_command;
 
 static SUPPORTED_TARGETS: &[TargetSpec] = &[
     // Targets with architecture specific tuning
@@ -127,11 +129,52 @@ fn check_target(
         false => ["core", "alloc"].as_slice(),
     };
     check_libraries(target, &target_dir, expected_libs)?;
+    check_default_link_args(sysroot, target)?;
 
     reporter.success(&format!("target installed correctly: {}", target.tuple));
     Ok(CheckTargetOutcome::Found)
 }
 
+/// Check if the default link args for the target are what is expected
+fn check_default_link_args(sysroot: &Path, target: &TargetSpec) -> Result<(), Error> {
+    match target.linker {
+        Linker::HostCc => (),
+        Linker::BundledLld | Linker::CrossCc(_) => return Ok(()), // No default link args expected
+    }
+
+    let rustc = sysroot.join("bin").join("rustc");
+    let temp_dir = tempfile::tempdir()
+        .map_err(|error| Error::TemporaryCompilationDirectoryCreationFailed { error })?;
+    let temp_main = temp_dir.path().join("main.rs");
+    std::fs::write(&temp_main, "fn main() {}").map_err(|error| {
+        Error::WritingSampleProgramFailed {
+            name: "link_arg_example".into(),
+            dest: temp_main.clone(),
+            error,
+        }
+    })?;
+
+    let mut command = Command::new(rustc);
+    command.arg("--target");
+    command.arg(target.tuple);
+    command.arg("--print");
+    command.arg("link-args");
+    command.arg(temp_main);
+    let output = run_command(&mut command)
+        .map_err(|error| Error::sample_program_compilation_failed("link-args", error))?;
+
+    // All our `HostCc` targets require `-fuse-ld=lld` to be passed
+    let fuse_ld_arg = "-fuse-ld=lld";
+    if !output.stdout.contains(fuse_ld_arg) {
+        Err(Error::TargetDefaultLinkArgMissing {
+            target: target.tuple.into(),
+            link_arg: fuse_ld_arg.into(),
+        })
+    } else {
+        Ok(())
+    }
+}
+
 #[derive(Debug, PartialEq, Eq)]
 enum CheckTargetOutcome {
     Missing,
@@ -210,13 +253,48 @@ mod tests {
             .lib("other", "0123456789abcdef") // Unknown libraries are ignored
             .create();
 
+        let _bin = utils
+            .bin("rustc")
+            .expected_args(&["--target", tuple, "--print", "link-args"])
+            .expected_args_strict(false)
+            .stdout("-fuse-ld=lld")
+            .create();
+
         assert_eq!(
             CheckTargetOutcome::Found,
             check_target(utils.reporter(), utils.sysroot(), &target).unwrap()
         );
         utils.assert_report_success("target installed correctly: x86_64-unknown-linux-gnu");
     }
 
+    #[cfg(all(target_os = "linux", target_arch = "x86_64"))] // Only on x86_64 Linux since the test is specific to that.
+    #[test]
+    #[should_panic]
+    fn test_check_target_std_fails_if_lld_not_used() {
+        let tuple = "x86_64-unknown-linux-gnu";
+        let target = TargetSpec { tuple, std: true, linker: Linker::HostCc };
+
+        let utils = TestUtils::new();
+        utils
+            .target(tuple)
+            .lib("core", "0123456789abcdef")
+            .lib("alloc", "0123456789abcdef")
+            .lib("std", "0123456789abcdef")
+            .lib("test", "0123456789abcdef")
+            .lib("proc_macro", "0123456789abcdef")
+            .lib("other", "0123456789abcdef") // Unknown libraries are ignored
+            .create();
+
+        let _bin = utils
+            .bin("rustc")
+            .expected_args(&["--target", tuple, "--print", "link-args"])
+            .expected_args_strict(false)
+            .stdout("-fuse-ld=not-lld-this-should-fail")
+            .create();
+
+        check_target(utils.reporter(), utils.sysroot(), &target).unwrap(); // Panic!
+    }
+
     #[test]
     fn test_check_target_no_std() {
         let tuple = "x86_64-unknown-none";
@@ -362,4 +440,29 @@ mod tests {
         assert_fail("libcore-0123456789abcdef.so"); // Different extension
         assert_fail("libcore-0123456789abcdef"); // No extension
     }
+
+    fn check_target_default_link_args(tuple: &'static str) -> Result<(), Error> {
+        let target = TargetSpec { tuple, std: true, linker: Linker::HostCc };
+
+        let utils = TestUtils::new();
+        let _bin = utils
+            .bin("rustc")
+            .expected_args(&["--target", tuple, "--print", "link-args"])
+            .expected_args_strict(false)
+            .stdout("-fuse-ld=lld")
+            .create();
+        check_default_link_args(utils.sysroot(), &target)
+    }
+
+    #[cfg(all(target_os = "linux", target_arch = "x86_64"))]
+    #[test]
+    fn test_check_target_default_link_args_x86_64() -> Result<(), Error> {
+        check_target_default_link_args("x86_64-unknown-linux-gnu")
+    }
+
+    #[cfg(all(target_os = "linux", target_arch = "aarch64"))]
+    #[test]
+    fn test_check_target_default_link_args_x86_64() -> Result<(), Error> {
+        check_target_default_link_args("aarch64-unknown-linux-gnu")
+    }
 }

ferrocene/tools/self-test/src/test_utils/bin_builder.rs

@@ -21,6 +21,10 @@ pub(crate) struct BinBuilder<'a> {
     stderr: Option<String>,
     exit: Option<i32>,
     expected_args: Option<&'a [&'a str]>,
+    /// If true test that all expected args and no additional ones are present.
+    /// If false only check expected args are present and in order,
+    /// but there can be additional arguments before, between, or after.
+    expected_args_strict: bool,
     dest: BinaryDestination,
     program: &'static str,
 }
@@ -36,6 +40,7 @@ impl<'a> BinBuilder<'a> {
             stderr: None,
             exit: None,
             expected_args: None,
+            expected_args_strict: true,
             dest: BinaryDestination::Sysroot,
             program: BIN_PROGRAM,
         }
@@ -91,6 +96,11 @@ impl<'a> BinBuilder<'a> {
         self
     }
 
+    pub(crate) fn expected_args_strict(mut self, strict: bool) -> Self {
+        self.expected_args_strict = strict;
+        self
+    }
+
     pub(crate) fn program_source(mut self, source: &'static str) -> Self {
         self.program = source;
         self
@@ -134,11 +144,13 @@ impl<'a> BinBuilder<'a> {
         if let Some(expected_args) = self.expected_args {
             rustc.env("EXPECTED_ARGS", expected_args.join("\t"));
         }
+        rustc.env("EXPECTED_ARGS_STRICT", self.expected_args_strict.to_string());
 
         let mut rustc = rustc.spawn().unwrap();
         let stdin = rustc.stdin.as_mut().unwrap();
         stdin.write_all(self.program.as_bytes()).unwrap();
-        assert!(rustc.wait().unwrap().success());
+        let res = rustc.wait_with_output().unwrap();
+        assert!(res.status.success(), "stdout: \n{}", String::from_utf8_lossy(&res.stdout));
 
         #[cfg(not(windows))]
         if let Some(mode) = self.mode {
@@ -160,8 +172,20 @@ const BIN_PROGRAM: &str = r#"
 fn main() {
     if let Some(expected_args) = option_env!("EXPECTED_ARGS") {
         let expected = expected_args.split("\t").collect::<Vec<_>>();
-        let found = std::env::args().skip(1).collect::<Vec<_>>();
-        assert_eq!(expected, found);
+        let mut found = std::env::args().skip(1).collect::<Vec<_>>();
+        if Some("true") == option_env!("EXPECTED_ARGS_STRICT") {
+            assert_eq!(expected, found);
+        } else {
+            // Validate each of the args is present in the order provided,
+            // ignore the rest.
+            for item in expected {
+                let val = found.iter().enumerate().find(|(_, v)| *v == &item.to_string());
+                assert!(val.is_some(), "Did not find argument");
+                // Get rid of all the previous args so that we can validate the expected
+                // args are in-order.
+                found = found.split_off(val.unwrap().0);
+            }
+        }
     }
     if let Some(stdout) = option_env!("OVERRIDE_STDOUT") {
         print!("{stdout}");

library/core/src/clone.rs

@@ -624,6 +624,8 @@ mod impls {
     #[stable(feature = "rust1", since = "1.0.0")]
     impl<T: PointeeSized> Clone for *const T {
         #[inline(always)]
+        // Ferrocene annotation: This function is thoroughly tested inside the `test_clone`
+        // test in `coretests`. It is unclear why this particular line is marked as uncovered.
         fn clone(&self) -> Self {
             *self
         }
@@ -632,6 +634,8 @@ mod impls {
     #[stable(feature = "rust1", since = "1.0.0")]
     impl<T: PointeeSized> Clone for *mut T {
         #[inline(always)]
+        // Ferrocene annotation: This function is thoroughly tested inside the `test_clone`
+        // test in `coretests`. It is unclear why this particular line is marked as uncovered.
         fn clone(&self) -> Self {
             *self
         }

library/core/src/intrinsics/mod.rs

@@ -2580,6 +2580,7 @@ pub(crate) macro const_eval_select {
         }
 
         $(#[$compiletime_attr])*
+        // Ferrocene annotation: Cannot be covered as this only runs during compilation.
         const fn compiletime$(<$($binders)*>)?($($arg: $ty),*) $( -> $ret )? {
             // Don't warn if one of the arguments is unused.
             $(let _ = $arg;)*
@@ -2738,6 +2739,8 @@ pub const unsafe fn typed_swap_nonoverlapping<T>(x: *mut T, y: *mut T) {
 #[rustc_intrinsic_const_stable_indirect] // just for UB checks
 #[inline(always)]
 #[rustc_intrinsic]
+// Ferrocene annotation: This function is always used in `assert_unsafe_precondition` which produces
+// an unwinding panic, meaning that we cannot cover it.
 pub const fn ub_checks() -> bool {
     cfg!(ub_checks)
 }
@@ -2785,6 +2788,8 @@ pub const unsafe fn const_deallocate(_ptr: *mut u8, _size: usize, _align: usize)
 #[rustc_nounwind]
 #[rustc_intrinsic]
 #[miri::intrinsic_fallback_is_spec]
+// Ferrocene annotation: This function is only used as part of the `ThinBox` inner implementation.
+// It is also a noop in runtime so we can't cover it currently.
 pub const unsafe fn const_make_global(ptr: *mut u8) -> *const u8 {
     // const eval overrides this function; at runtime, it is a NOP.
     ptr

library/core/src/ops/drop.rs

@@ -237,5 +237,7 @@ pub const trait Drop {
     /// [`mem::drop`]: drop
     /// [`ptr::drop_in_place`]: crate::ptr::drop_in_place
     #[stable(feature = "rust1", since = "1.0.0")]
+    // Ferrocene annotation: This method declaration has no code to be covered, the fact that this
+    // shows up as uncovered is a bug in our coverage tooling.
     fn drop(&mut self);
 }

library/core/src/option.rs

@@ -1203,6 +1203,10 @@ impl<T> Option<T> {
         F: [const] FnOnce(&T) + [const] Destruct,
     {
         if let Some(ref x) = self {
+            // Ferrocene annotation: This function is thoroughly tested inside the `option_methods`
+            // test in `coretests`. Additionally, the `inspect_option` test guarantees that `f` is
+            // being called by panicking inside the `predicate` body and marking the test as
+            // `#[should_panic]`.
             f(x);
         }
 
@@ -1591,6 +1595,10 @@ impl<T> Option<T> {
         T: [const] Destruct,
     {
         if let Some(x) = self {
+            // Ferrocene annotation: This function is thoroughly tested inside the `option_methods`
+            // test in `coretests`. Additionally, the `filter_option` test guarantees that
+            // `predicate` is being called by panicking inside the `predicate` body and marking the
+            // test as `#[should_panic]`.
             if predicate(&x) {
                 return Some(x);
             }