add tests for a thumb program calling arm code

and in particular for naked functions in that scenario

Author: folkertdev

src/tools/run-make-support/src/external_deps/llvm.rs

@@ -302,6 +302,12 @@ impl LlvmFilecheck {
         self.cmd.arg(input_file.as_ref());
         self
     }
+
+    /// Set a single `--check-prefix`.
+    pub fn check_prefix<S: AsRef<str>>(&mut self, prefix: S) -> &mut Self {
+        self.cmd.arg(format!("--check-prefix={}", prefix.as_ref()));
+        self
+    }
 }
 
 impl LlvmObjdump {
@@ -324,6 +330,12 @@ impl LlvmObjdump {
         self.cmd.arg("-d");
         self
     }
+
+    /// Demangle symbols.
+    pub fn demangle(&mut self) -> &mut Self {
+        self.cmd.arg("--demangle");
+        self
+    }
 }
 
 impl LlvmAr {

tests/run-make/thumb-calling-arm/a32.rs

@@ -0,0 +1,47 @@
+#![feature(no_core)]
+#![no_core]
+#![no_main]
+
+extern crate minicore;
+use minicore::*;
+
+#[unsafe(no_mangle)]
+pub fn entry() {
+    // thumbv5te: blx {{0x[0-9a-f]+}} <a32::normalfn>
+    // thumbv5te: blx {{0x[0-9a-f]+}} <globalfn>
+    // thumbv5te: blx {{0x[0-9a-f]+}} <a32::nakedfn>
+
+    // thumbv4t: bl {{0x[0-9a-f]+}} <__Thumbv4ABSLongBXThunk__RNvCsdN8C8f0sPJt_3a328normalfn>
+    // thumbv4t: bl {{0x[0-9a-f]+}} <__Thumbv4ABSLongBXThunk_globalfn>
+    // thumbv4t: bl {{0x[0-9a-f]+}} <__Thumbv4ABSLongBXThunk__RNvCsdN8C8f0sPJt_3a327nakedfn>
+    normalfn();
+    globalfn();
+    nakedfn();
+}
+
+#[instruction_set(arm::a32)]
+extern "C" fn normalfn() {
+    unsafe { asm!("nop") }
+}
+
+unsafe extern "C" {
+    safe fn globalfn();
+}
+
+global_asm!(
+    r#"
+    .arm
+    .global globalfn
+    .type globalfn, %function
+    globalfn:
+        nop
+        bx lr
+    .size globalfn, . - globalfn
+"#
+);
+
+#[unsafe(naked)]
+#[instruction_set(arm::a32)]
+extern "C" fn nakedfn() {
+    naked_asm!("nop", "bx lr",);
+}

tests/run-make/thumb-calling-arm/link.ld

@@ -0,0 +1 @@
+ENTRY(entry);

tests/run-make/thumb-calling-arm/rmake.rs

@@ -0,0 +1,56 @@
+//@ needs-rust-lld
+use run_make_support::{llvm_filecheck, llvm_objdump, path, rfs, run, rustc, source_root};
+
+// Test a thumb target calling arm functions. Doing so requires switching from thumb mode to arm
+// mode, calling the arm code, then switching back to thumb mode. Depending on the thumb version,
+// this happens using a special calling instruction, or by calling a generated thunk that performs
+// the mode switching.
+//
+// In particular this tests that naked functions behave like normal functions. Before LLVM 22, a
+// bug in LLVM caused thumb mode to be used unconditonally when symbols were .hidden, miscompiling
+// calls to arm functions.
+//
+// - https://github.com/llvm/llvm-project/pull/181156
+// - https://github.com/rust-lang/rust/issues/151946
+
+macro_rules! helper {
+    ($prefix:literal, $test:literal) => {
+        rustc()
+            .input(source_root().join("tests/auxiliary/minicore.rs"))
+            .crate_name("minicore")
+            .crate_type("rlib")
+            .target(concat!($prefix, "-none-eabi"))
+            .output("libminicore.rlib")
+            .run();
+        let minicore = path("libminicore.rlib");
+
+        rustc()
+            .input(concat!($test, ".rs"))
+            .panic("abort")
+            .link_arg("-Tlink.ld")
+            .arg("--extern")
+            .arg(format!("minicore={}", minicore.display()))
+            .target(concat!($prefix, "-none-eabi"))
+            .output(concat!($prefix, "-", $test))
+            .run();
+
+        let dump =
+            llvm_objdump().disassemble().demangle().input(path(concat!($prefix, "-", $test))).run();
+
+        llvm_filecheck()
+            .patterns(concat!($test, ".rs"))
+            .check_prefix($prefix)
+            .stdin_buf(dump.stdout())
+            .run();
+    };
+}
+
+fn main() {
+    // Thumb calling thumb.
+    helper!("thumbv5te", "t32");
+    helper!("thumbv4t", "t32");
+
+    // Thumb calling arm.
+    helper!("thumbv5te", "a32");
+    helper!("thumbv4t", "a32");
+}

tests/run-make/thumb-calling-arm/t32.rs

@@ -0,0 +1,47 @@
+#![feature(no_core)]
+#![no_core]
+#![no_main]
+
+extern crate minicore;
+use minicore::*;
+
+#[unsafe(no_mangle)]
+pub fn entry() {
+    // thumbv5te: bl {{0x[0-9a-f]+}} <t32::normalfn>
+    // thumbv5te: bl {{0x[0-9a-f]+}} <globalfn>
+    // thumbv5te: bl {{0x[0-9a-f]+}} <t32::nakedfn>
+
+    // thumbv4t: bl {{0x[0-9a-f]+}} <t32::normalfn>
+    // thumbv4t: bl {{0x[0-9a-f]+}} <globalfn>
+    // thumbv4t: bl {{0x[0-9a-f]+}} <t32::nakedfn>
+    normalfn();
+    globalfn();
+    nakedfn();
+}
+
+#[instruction_set(arm::t32)]
+extern "C" fn normalfn() {
+    unsafe { asm!("nop") }
+}
+
+unsafe extern "C" {
+    safe fn globalfn();
+}
+
+global_asm!(
+    r#"
+    .thumb
+    .global globalfn
+    .type globalfn, %function
+    globalfn:
+        nop
+        bx lr
+    .size globalfn, . - globalfn
+"#
+);
+
+#[unsafe(naked)]
+#[instruction_set(arm::t32)]
+extern "C" fn nakedfn() {
+    naked_asm!("nop", "bx lr",);
+}