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;
@@ -2197,7 +2198,12 @@ 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.triple.contains("pauthtest") {
+                // Embed rpath to the shared object
+                targetflags.push(format!("-Clink-arg=-Wl,-rpath,{}", target_helpers.display()));
+            }
         }
 
         for flag in hostflags {
@@ -3812,32 +3818,58 @@ 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.triple.contains("pauthtest") {
+            let so = dst.join("librust_test_helpers.so");
+            if up_to_date(&src, &so) {
+                return;
+            }
+
+            let pauthtest_sysroot = std::env::var("PAUTHTEST_SYSROOT").unwrap_or_default();
+            let status = Command::new("clang")
+                .arg("-target")
+                .arg(target.triple)
+                .arg("-fuse-ld=lld")
+                .arg(format!("--sysroot={}", pauthtest_sysroot))
+                .arg("-nostdlib")
+                .arg("-march=armv8.3-a")
+                .arg("-fPIC")
+                .arg("-shared")
+                .arg("-O0") // Use O0 to match what static library is compiled at.
+                .arg("-o")
+                .arg(&so)
+                .arg(&src)
+                .status()
+                .expect("Failed to run pauthtest clang for librust_test_helpers.so");
+
+            if !status.success() {
+                panic!("Linking of pauthtest librust_test_helpers.so failed");
             }
-            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");
     }
 }
 

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/pauth-quicksort-c-driver/main.c

@@ -0,0 +1,53 @@
+#include <stdint.h>
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NUM_ELEMS 5
+
+void quickSort(void *Base, size_t N, size_t Size,
+               int (*Cmp)(const void *, const void *));
+
+#ifdef __cplusplus
+}
+#endif
+
+int cmpI32Ascending(const void *LHS, const void *RHS) {
+  int32_t x = *(const int32_t *)LHS;
+  int32_t y = *(const int32_t *)RHS;
+
+  if (x < y)
+    return -1;
+  else if (x > y)
+    return 1;
+  else
+    return 0;
+}
+
+int main() {
+  int32_t Data[NUM_ELEMS] = {4, 2, 5, 3, 1};
+
+  printf("Before sorting: ");
+  for (int i = 0; i < NUM_ELEMS; i++)
+    printf("%d ", Data[i]);
+  printf("\n");
+
+  quickSort(Data, NUM_ELEMS, sizeof(int32_t), cmpI32Ascending);
+
+  printf("After sorting:  ");
+  for (int i = 0; i < NUM_ELEMS; i++)
+    printf("%d ", Data[i]);
+  printf("\n");
+
+  for (size_t i = 1; i < NUM_ELEMS; i++)
+    if (Data[i - 1] > Data[i])
+      return 42;
+
+  return 0;
+}
+
+#ifdef __cplusplus
+}
+#endif

tests/run-make/pauth-quicksort-c-driver/quicksort.rs

@@ -0,0 +1,66 @@
+use std::mem::size_of;
+use std::os::raw::{c_int, c_void};
+use std::ptr;
+
+unsafe fn swap_i32(lhs: *mut i32, rhs: *mut i32) {
+    ptr::swap(lhs, rhs);
+}
+
+unsafe fn partition(
+    arr: *mut i32,
+    low: isize,
+    high: isize,
+    cmp: extern "C" fn(*const c_void, *const c_void) -> c_int,
+) -> isize {
+    let pivot = arr.offset(low);
+    let mut i = low;
+    let mut j = high;
+
+    while i < j {
+        while i <= high - 1 && cmp(arr.offset(i) as *const c_void, pivot as *const c_void) <= 0 {
+            i += 1;
+        }
+
+        while j >= low + 1 && cmp(arr.offset(j) as *const c_void, pivot as *const c_void) > 0 {
+            j -= 1;
+        }
+
+        if i < j {
+            swap_i32(arr.offset(i), arr.offset(j));
+        }
+    }
+
+    swap_i32(arr.offset(low), arr.offset(j));
+    j
+}
+
+unsafe fn quicksort_rec(
+    arr: *mut i32,
+    low: isize,
+    high: isize,
+    cmp: extern "C" fn(*const c_void, *const c_void) -> c_int,
+) {
+    if low < high {
+        let part = partition(arr, low, high, cmp);
+        quicksort_rec(arr, low, part - 1, cmp);
+        quicksort_rec(arr, part + 1, high, cmp);
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn quickSort(
+    base: *mut c_void,
+    n: usize,
+    size: usize,
+    cmp: extern "C" fn(*const c_void, *const c_void) -> c_int,
+) {
+    if size != size_of::<i32>() {
+        std::process::abort();
+    }
+
+    if n > 1 {
+        unsafe {
+            quicksort_rec(base as *mut i32, 0, (n as isize) - 1, cmp);
+        }
+    }
+}

tests/run-make/pauth-quicksort-c-driver/rmake.rs

@@ -0,0 +1,57 @@
+// Test compilation flow using custom pauth-enabled toolchain and signing extern "C" function
+// pointers used from within rust. Note that in order for the test to work the location of the
+// toolchain's sysroot has to be provided via env variable (`PAUTHTEST_SYSROOT`). The test assumes
+// that pauthtest-enabled `clang` is available on the path.
+// In this test rust is the driver - providing the data and the comparison function; while c -
+// provides the implementation of quicksort algorithm and is the user of  the data and comparator.
+
+//@ only-aarch64-unknown-linux-pauthtest
+
+use run_make_support::{cc, rfs, run, run_fail, rustc};
+
+fn main() {
+    unsafe {
+        std::env::set_var("CC", "clang");
+    }
+    let pauthtest_sysroot = std::env::var("PAUTHTEST_SYSROOT").unwrap_or_default();
+    let dynamic_linker = format!("-Wl,--dynamic-linker={}/usr/lib/libc.so", pauthtest_sysroot);
+    let rpath = format!("-Wl,--rpath={}/usr/lib", pauthtest_sysroot);
+
+    let rust_lib_name = "rust_quicksort";
+    rustc()
+        .target("aarch64-unknown-linux-pauthtest")
+        .crate_type("cdylib")
+        .input("quicksort.rs")
+        .crate_name(rust_lib_name)
+        .args(&[&dynamic_linker, &rpath])
+        .run();
+
+    let exe_name = "main";
+    cc().out_exe(exe_name)
+        .input("main.c")
+        .args(&[
+            "-march=armv8.3-a",
+            "-lc",
+            "-nostdlib",
+            "-target",
+            "aarch64-unknown-linux-pauthtest",
+            "-fuse-ld=lld".into(),
+            &format!("--sysroot={}", pauthtest_sysroot),
+            "-I",
+            &format!("{}/usr/include", pauthtest_sysroot),
+            &format!("-Wl,--rpath={}/usr/lib", pauthtest_sysroot),
+            &format!("-Wl,{}/usr/lib/crt1.o", pauthtest_sysroot),
+            &format!("-Wl,{}/usr/lib/crti.o", pauthtest_sysroot),
+            &format!("-Wl,{}/usr/lib/crtn.o", pauthtest_sysroot),
+            "-L.",
+            &format!("-l{}", rust_lib_name),
+            &dynamic_linker,
+            &rpath,
+        ])
+        .run();
+
+    run(exe_name);
+
+    rfs::remove_file(format!("{}{rust_lib_name}.{}", "lib", "so"));
+    run_fail(exe_name);
+}

tests/run-make/pauth-quicksort-c-driver/rmake.rs_backup

@@ -0,0 +1,76 @@
+// Test compilation flow using custom pauth-enabled toolchain and signing extern "C" function
+// pointers used from within rust. Note that in order for the test to work the location of the
+// toolchain's sysroot has to be provided via env variable (`PAUTHTEST_SYSROOT`). The test assumes
+// that `clang` is available on the path.
+// In this test rust is the driver - providing the data and the comparison function; while c -
+// provides the implementation of quicksort algorithm and is the user of  the data and comparator.
+
+//@ only-aarch64-unknown-linux-pauthtest
+
+use run_make_support::{cc, rfs, run, run_fail, rustc};
+
+fn main() {
+    let pauthtest_sysroot = std::env::var("PAUTHTEST_SYSROOT").unwrap_or_default();
+
+    unsafe {
+        //std::env::set_var("CC", "/opt/llvm-pauth/bin/aarch64-linux-pauthtest-clang");
+        std::env::set_var("CC", "clang");
+    }
+    let dynamic_linker =
+        format!("-Wl,--dynamic-linker={}/usr/lib/libc.so", pauthtest_sysroot);
+    let rpath = format!("-Wl,--rpath={}/usr/lib", pauthtest_sysroot);
+    let rust_lib_name = "rust_quicksort";
+    // rustc()
+    //     .target("aarch64-unknown-linux-pauthtest")
+    //     .crate_type("cdylib")
+    //     .input("quicksort.rs")
+    //     .crate_name(rust_lib_name)
+    //     .args(&[&dynamic_linker, &rpath, "-C", "link-arg=-fuse-ld=lld"])
+    //     .run();
+    rustc()
+        .target("aarch64-unknown-linux-pauthtest")
+        .crate_type("cdylib")
+        .input("quicksort.rs")
+        .crate_name(rust_lib_name)
+        .args(&[
+            "-C", "link-arg=-fuse-ld=lld",
+            "-C", &format!("link-arg=--sysroot={}", pauthtest_sysroot),
+            "-C", &format!("link-arg=-Wl,--dynamic-linker={}/usr/lib/libc.so", pauthtest_sysroot),
+            "-C", &format!("link-arg=-Wl,--rpath={}/usr/lib", pauthtest_sysroot),
+        ])
+        .run();
+
+    let exe_name = "main";
+    cc().out_exe(exe_name)
+        .input("main.c")
+        .args(&[
+            "-v",
+            "-march=armv8.3-a",
+            "-target", "aarch64-unknown-linux-pauthtest",
+            &format!("--sysroot={}", pauthtest_sysroot), // <<< important
+            "-fuse-ld=lld",
+            "-L.",
+            &format!("-l{}", rust_lib_name),
+            &dynamic_linker,
+            &rpath,
+        ])
+        .run();
+    // cc().out_exe(exe_name)
+    //     .input("main.c")
+    //     .args(&[
+    //         "-march=armv8.3-a",
+    //         "-target",
+    //         "aarch64-unknown-linux-pauthtest",
+    //         "-fuse-ld=lld",
+    //         "-L.",
+    //         &format!("-l{}", rust_lib_name),
+    //         &dynamic_linker,
+    //         &rpath,
+    //     ])
+    //     .run();
+
+    run(exe_name);
+
+    rfs::remove_file(format!("{}{rust_lib_name}.{}", "lib", "so"));
+    run_fail(exe_name);
+}