Teach bootstrap how to build rust_test_helpers for pauthtest

Also:
* update tests to force dynamic library when targetting pauthtest
* various test fixes
* introduce end-to-end tests for pauthtest (in run-make)

Author: jchlanda

src/bootstrap/src/core/build_steps/test.rs

@@ -10,6 +10,7 @@ use std::collections::HashSet;
 use std::env::split_paths;
 use std::ffi::{OsStr, OsString};
 use std::path::{Path, PathBuf};
+use std::process::Command;
 use std::{env, fs, iter};
 
 use build_helper::exit;
@@ -2227,7 +2228,13 @@ Please disable assertions with `rust.debug-assertions = false`.
                 "-Lnative={}",
                 builder.test_helpers_out(test_compiler.host).display()
             ));
-            targetflags.push(format!("-Lnative={}", builder.test_helpers_out(target).display()));
+            let target_helpers = builder.test_helpers_out(target);
+            targetflags.push(format!("-Lnative={}", target_helpers.display()));
+            if target.is_pauthtest() {
+                // For the pauthtest target, embed an rpath to the directory containing the helper
+                // dynamic library.
+                targetflags.push(format!("-Clink-arg=-Wl,-rpath,{}", target_helpers.display()));
+            }
         }
 
         for flag in hostflags {
@@ -3858,32 +3865,54 @@ impl Step for TestHelpers {
         };
         let dst = builder.test_helpers_out(target);
         let src = builder.src.join("tests/auxiliary/rust_test_helpers.c");
-        if up_to_date(&src, &dst.join("librust_test_helpers.a")) {
-            return;
-        }
-
         let _guard = builder.msg_unstaged(Kind::Build, "test helpers", target);
         t!(fs::create_dir_all(&dst));
-        let mut cfg = cc::Build::new();
 
-        // We may have found various cross-compilers a little differently due to our
-        // extra configuration, so inform cc of these compilers. Note, though, that
-        // on MSVC we still need cc's detection of env vars (ugh).
-        if !target.is_msvc() {
-            if let Some(ar) = builder.ar(target) {
-                cfg.archiver(ar);
+        if !up_to_date(&src, &dst.join("librust_test_helpers.a")) {
+            let mut cfg = cc::Build::new();
+
+            // We may have found various cross-compilers a little differently due to our
+            // extra configuration, so inform cc of these compilers. Note, though, that
+            // on MSVC we still need cc's detection of env vars (ugh).
+            if !target.is_msvc() {
+                if let Some(ar) = builder.ar(target) {
+                    cfg.archiver(ar);
+                }
+                cfg.compiler(builder.cc(target));
+            }
+            cfg.cargo_metadata(false)
+                .out_dir(&dst)
+                .target(&target.triple)
+                .host(&builder.config.host_target.triple)
+                .opt_level(0)
+                .warnings(false)
+                .debug(false)
+                .file(builder.src.join("tests/auxiliary/rust_test_helpers.c"))
+                .compile("rust_test_helpers");
+        }
+        if target.is_pauthtest() {
+            let so = dst.join("librust_test_helpers.so");
+            if up_to_date(&src, &so) {
+                return;
+            }
+
+            let status = Command::new(builder.cc(target))
+                .arg("-target")
+                .arg(target.triple)
+                .arg("-march=armv8.3-a+pauth")
+                .arg("-fPIC")
+                .arg("-shared")
+                .arg("-O0") // Use O0 to match what static library is compiled at.
+                .arg("-o")
+                .arg(&so)
+                .arg(&src)
+                .status()
+                .unwrap_or_else(|_| panic!("Failed to run clang for {} toolchain", target.triple));
+
+            if !status.success() {
+                panic!("Linking of librust_test_helpers.so failed (target: {})", target.triple);
             }
-            cfg.compiler(builder.cc(target));
         }
-        cfg.cargo_metadata(false)
-            .out_dir(&dst)
-            .target(&target.triple)
-            .host(&builder.config.host_target.triple)
-            .opt_level(0)
-            .warnings(false)
-            .debug(false)
-            .file(builder.src.join("tests/auxiliary/rust_test_helpers.c"))
-            .compile("rust_test_helpers");
     }
 }
 

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

@@ -78,6 +78,10 @@ impl TargetSelection {
         self.contains("msvc")
     }
 
+    pub fn is_pauthtest(&self) -> bool {
+        self.triple == "aarch64-unknown-linux-pauthtest"
+    }
+
     pub fn is_windows(&self) -> bool {
         self.contains("windows")
     }

src/bootstrap/src/core/sanity.rs

@@ -21,7 +21,7 @@ use crate::builder::Kind;
 use crate::core::build_steps::tool;
 use crate::core::config::{CompilerBuiltins, Target};
 use crate::utils::exec::command;
-use crate::{Build, Subcommand};
+use crate::{Build, Subcommand, t};
 
 pub struct Finder {
     cache: HashMap<OsString, Option<PathBuf>>,
@@ -37,7 +37,7 @@ pub struct Finder {
 /// when the newly-bumped stage 0 compiler now knows about the formerly-missing targets.
 const STAGE0_MISSING_TARGETS: &[&str] = &[
     // just a dummy comment so the list doesn't get onelined
-    "aarch64-unknown-linux-pauthtest", // Stage 0 compiler is not guaranteed to see pauthtest yet.
+    "aarch64-unknown-linux-pauthtest", // Stage 0 compiler is not guaranteed to see the target yet.
 ];
 
 /// Minimum version threshold for libstdc++ required when using prebuilt LLVM
@@ -412,6 +412,53 @@ $ pacman -R cmake && pacman -S mingw-w64-x86_64-cmake
         {
             cmd_finder.must_have("wasm-component-ld");
         }
+
+        // aarch64-unknown-linux-pauthtest must use clang
+        if !skip_tools_checks && target.is_pauthtest() {
+            let cc_tool = build.cc_tool(*target);
+            let linker_path = build
+                .linker(*target)
+                .unwrap_or_else(|| panic!("{} requires an explicit clang linker", target.triple));
+
+            if !cc_tool.is_like_clang() {
+                panic!(
+                    "Clang is required to build C code for {} target, got:\n\
+                     cc tool: `{}`,\n\
+                     linker: `{}`\n",
+                    target.triple,
+                    cc_tool.path().display(),
+                    linker_path.display(),
+                );
+            }
+            let cc_canon = t!(fs::canonicalize(cc_tool.path()));
+            let linker_canon = t!(fs::canonicalize(&linker_path));
+            if cc_canon != linker_canon {
+                panic!(
+                    "CC and Linker are expected to be the same for {} target, got:\n\
+                     CC: `{}`,\n\
+                     Linker: `{}`\n",
+                    target.triple,
+                    cc_canon.display(),
+                    linker_canon.display(),
+                );
+            }
+
+            let output =
+                command(cc_tool.path()).arg("-dumpversion").run_capture_stdout(&build).stdout();
+            let version_str = output.trim();
+            let mut parts = version_str.split('.').map(|s| s.parse::<u32>().unwrap_or(0));
+            let major = parts.next().unwrap_or(0);
+            let minor = parts.next().unwrap_or(0);
+            let patch = parts.next().unwrap_or(0);
+            if (major, minor, patch) < (22, 1, 0) {
+                panic!(
+                    "clang version too old: {} ({} target trequires >= 22.1.0), path: {}",
+                    target.triple,
+                    version_str,
+                    cc_tool.path().display()
+                );
+            }
+        }
     }
 
     if let Some(ref s) = build.config.ccache {

tests/assembly-llvm/asm/aarch64-outline-atomics.rs

@@ -2,6 +2,9 @@
 //@ compile-flags: -Copt-level=3
 //@ only-aarch64
 //@ only-linux
+// aarch64-unknown-linux-pauthtest requires armv8.3-a, which includes Large System Extensions,
+// providing hardware implementations of atomic operations.
+//@ ignore-aarch64-unknown-linux-pauthtest
 
 #![crate_type = "rlib"]
 

tests/codegen-llvm/box-uninit-bytes.rs

@@ -43,4 +43,4 @@ pub fn box_lotsa_padding() -> Box<LotsaPadding> {
 // from the CHECK-NOT above, and also verify the attributes got set reasonably.
 // CHECK: declare {{(dso_local )?}}noalias noundef ptr @{{.*}}__rust_alloc(i{{[0-9]+}} noundef, i{{[0-9]+}} allocalign noundef range(i{{[0-9]+}} 1, {{-2147483647|-9223372036854775807}})) unnamed_addr [[RUST_ALLOC_ATTRS:#[0-9]+]]
 
-// CHECK-DAG: attributes [[RUST_ALLOC_ATTRS]] = { {{.*}} allockind("alloc,uninitialized,aligned") allocsize(0) {{(uwtable )?}}"alloc-family"="__rust_alloc" {{.*}} }
+// CHECK-DAG: attributes [[RUST_ALLOC_ATTRS]] = { {{.*}} allockind("alloc,uninitialized,aligned"){{.*}} allocsize(0) {{(uwtable )?}}{{.*}}"alloc-family"="__rust_alloc" {{.*}} }

tests/codegen-llvm/cffi/c-variadic.rs

@@ -1,5 +1,9 @@
 //@ needs-unwind
 //@ compile-flags: -C no-prepopulate-passes -Copt-level=0
+// Pauthtest generates pointer authentication metadata for call instructions
+// and wraps function pointers in ConstPtrAuth. Disable this test for this target
+// to avoid clutter from pointer authentication complexity.
+//@ ignore-aarch64-unknown-linux-pauthtest
 
 #![crate_type = "lib"]
 #![feature(c_variadic)]

tests/codegen-llvm/inline-always-works-always.rs

@@ -2,6 +2,8 @@
 //@[NO-OPT] compile-flags: -Copt-level=0
 //@[SIZE-OPT] compile-flags: -Copt-level=s
 //@[SPEED-OPT] compile-flags: -Copt-level=3
+// Pointer authenticated calls are not guaranteed to be inlined.
+//@ ignore-aarch64-unknown-linux-pauthtest
 
 #![crate_type = "rlib"]
 

tests/codegen-llvm/issues/issue-73258.rs

@@ -3,6 +3,8 @@
 #![crate_type = "lib"]
 
 // Adapted from <https://github.com/rust-lang/rust/issues/73258#issue-637346014>
+// We explicitly match against `call{{.*}}(` because the aarch64-unknown-linux-pauthtest target
+// emits `ptrauth-calls` attribute, which would otherwise make a plain `call` match ambiguous.
 
 #[derive(Clone, Copy)]
 #[repr(u8)]
@@ -17,22 +19,22 @@ pub enum Foo {
 #[no_mangle]
 pub unsafe fn issue_73258(ptr: *const Foo) -> Foo {
     // CHECK-NOT: icmp
-    // CHECK-NOT: call
+    // CHECK-NOT: call{{.*}}(
     // CHECK-NOT: br {{.*}}
     // CHECK-NOT: select
 
     // CHECK: %[[R:.+]] = load i8
     // CHECK-SAME: !range !
 
     // CHECK-NOT: icmp
-    // CHECK-NOT: call
+    // CHECK-NOT: call{{.*}}(
     // CHECK-NOT: br {{.*}}
     // CHECK-NOT: select
 
     // CHECK: ret i8 %[[R]]
 
     // CHECK-NOT: icmp
-    // CHECK-NOT: call
+    // CHECK-NOT: call{{.*}}(
     // CHECK-NOT: br {{.*}}
     // CHECK-NOT: select
     let k: Option<Foo> = Some(ptr.read());

tests/incremental/auxiliary/issue-54059.rs

@@ -40,7 +40,8 @@ proc_macro_expr_impl! {
     }
 }
 
-#[link(name="rust_test_helpers")]
+#[cfg_attr(target_env = "pauthtest", link(name = "rust_test_helpers", kind = "dylib"))]
+#[cfg_attr(not(target_env = "pauthtest"), link(name = "rust_test_helpers"))]
 extern "C" {
     pub fn rust_dbg_extern_identity_u64(v: u64) -> u64;
 }

tests/run-make/c-link-to-rust-va-list-fn/rmake.rs

@@ -6,6 +6,8 @@
 //@ needs-target-std
 //@ ignore-android: FIXME(#142855)
 //@ ignore-sgx: (x86 machine code cannot be directly executed)
+//@ ignore-aarch64-unknown-linux-pauthtest: (it requires non-trivial compilation of c sources,
+// and only supports dynamic linking, ignore the test).
 
 use run_make_support::{cc, extra_c_flags, run, rustc, static_lib_name};