diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt index 6b3533c25785f..03d28e03b7f4e 100644 --- a/src/tools/tidy/src/allowed_run_make_makefiles.txt +++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt @@ -1,7 +1,6 @@ run-make/branch-protection-check-IBT/Makefile run-make/c-dynamic-dylib/Makefile run-make/c-dynamic-rlib/Makefile -run-make/c-unwind-abi-catch-lib-panic/Makefile run-make/cat-and-grep-sanity-check/Makefile run-make/cdylib-dylib-linkage/Makefile run-make/compiler-rt-works-on-mingw/Makefile @@ -14,7 +13,6 @@ run-make/dep-info-spaces/Makefile run-make/dep-info/Makefile run-make/dump-ice-to-disk/Makefile run-make/emit-to-stdout/Makefile -run-make/export-executable-symbols/Makefile run-make/extern-diff-internal-name/Makefile run-make/extern-flag-disambiguates/Makefile run-make/extern-fn-reachable/Makefile @@ -23,7 +21,6 @@ run-make/extern-multiple-copies2/Makefile run-make/fmt-write-bloat/Makefile run-make/foreign-double-unwind/Makefile run-make/foreign-exceptions/Makefile -run-make/foreign-rust-exceptions/Makefile run-make/incr-add-rust-src-component/Makefile run-make/incr-foreign-head-span/Makefile run-make/interdependent-c-libraries/Makefile diff --git a/tests/run-make/c-unwind-abi-catch-lib-panic/Makefile b/tests/run-make/c-unwind-abi-catch-lib-panic/Makefile deleted file mode 100644 index 2bb8d42495d3c..0000000000000 --- a/tests/run-make/c-unwind-abi-catch-lib-panic/Makefile +++ /dev/null @@ -1,35 +0,0 @@ -# Exercise unwinding a panic. This catches a panic across an FFI boundary and downcasts it into an integer. The Rust code that panics is in a separate crate. -# See https://github.com/rust-lang/rust/commit/baf227ea0c1e07fc54395a51e4b3881d701180cb - -# ignore-cross-compile -# needs-unwind -include ../tools.mk - -all: archive - # Compile `main.rs`, which will link into our library, and run it. - $(RUSTC) main.rs - $(call RUN,main) - -ifdef IS_MSVC -archive: add.o panic.o - # Now, create an archive using these two objects. - $(AR) crus $(TMPDIR)/add.lib $(TMPDIR)/add.o $(TMPDIR)/panic.o -else -archive: add.o panic.o - # Now, create an archive using these two objects. - $(AR) crus $(TMPDIR)/libadd.a $(TMPDIR)/add.o $(TMPDIR)/panic.o -endif - -# Compile `panic.rs` into an object file. -# -# Note that we invoke `rustc` directly, so we may emit an object rather -# than an archive. We'll do that later. -panic.o: - $(BARE_RUSTC) $(RUSTFLAGS) \ - --out-dir $(TMPDIR) \ - --emit=obj panic.rs - -# Compile `add.c` into an object file. -add.o: - $(call COMPILE_OBJ,$(TMPDIR)/add.o,add.c) - diff --git a/tests/run-make/c-unwind-abi-catch-lib-panic/rmake.rs b/tests/run-make/c-unwind-abi-catch-lib-panic/rmake.rs new file mode 100644 index 0000000000000..4bdb8579af5fd --- /dev/null +++ b/tests/run-make/c-unwind-abi-catch-lib-panic/rmake.rs @@ -0,0 +1,36 @@ +// Exercise unwinding a panic. This catches a panic across an FFI (foreign function interface) +// boundary and downcasts it into an integer. +// The Rust code that panics is in a separate crate. +// See https://github.com/rust-lang/rust/commit/baf227ea0c1e07fc54395a51e4b3881d701180cb + +//@ ignore-cross-compile +// Reason: the compiled binary is executed +//@ needs-unwind +// Reason: this test exercises unwinding a panic + +use run_make_support::{cc, is_msvc, llvm_ar, run, rustc}; + +fn main() { + // Compile `add.c` into an object file. + if is_msvc() { + cc().arg("-c").out_exe("add").input("add.c").run(); + } else { + cc().arg("-v").arg("-c").out_exe("add.o").input("add.c").run(); + }; + + // Compile `panic.rs` into an object file. + // Note that we invoke `rustc` directly, so we may emit an object rather + // than an archive. We'll do that later. + rustc().emit("obj").input("panic.rs").run(); + + // Now, create an archive using these two objects. + if is_msvc() { + llvm_ar().obj_to_ar().args(&["libadd.a", "add.obj", "panic.o"]).run(); + } else { + llvm_ar().obj_to_ar().args(&["libadd.a", "add.o", "panic.o"]).run(); + }; + + // Compile `main.rs`, which will link into our library, and run it. + rustc().input("main.rs").run(); + run("main"); +} diff --git a/tests/run-make/export-executable-symbols/Makefile b/tests/run-make/export-executable-symbols/Makefile deleted file mode 100644 index c4d29aa2bf450..0000000000000 --- a/tests/run-make/export-executable-symbols/Makefile +++ /dev/null @@ -1,11 +0,0 @@ -include ../tools.mk - -# ignore-wasm32 -# ignore-wasm64 -# ignore-none no-std is not supported -# only-linux - -all: - $(RUSTC) -Zexport-executable-symbols main.rs --target $(TARGET) --crate-type=bin - nm $(TMPDIR)/main | $(CGREP) exported_symbol - diff --git a/tests/run-make/export-executable-symbols/rmake.rs b/tests/run-make/export-executable-symbols/rmake.rs new file mode 100644 index 0000000000000..a01380ac917f0 --- /dev/null +++ b/tests/run-make/export-executable-symbols/rmake.rs @@ -0,0 +1,18 @@ +// The unstable flag `-Z export-executable-symbols` exports symbols from executables, as if +// they were dynamic libraries. This test is a simple smoke test to check that this feature +// works by using it in compilation, then checking that the output binary contains the exported +// symbol. +// See https://github.com/rust-lang/rust/pull/85673 + +//@ ignore-wasm32 +//@ ignore-wasm64 +//@ ignore-none +// Reason: no-std is not supported +//FIXME(Oneirical): try it on more than only-linux + +use run_make_support::{llvm_readobj, rustc}; + +fn main() { + rustc().arg("-Zexport-executable-symbols").input("main.rs").crate_type("bin").run(); + llvm_readobj().symbols().input("main").run().assert_stdout_contains("exported_symbol"); +} diff --git a/tests/run-make/foreign-rust-exceptions/Makefile b/tests/run-make/foreign-rust-exceptions/Makefile deleted file mode 100644 index 59cee2842004e..0000000000000 --- a/tests/run-make/foreign-rust-exceptions/Makefile +++ /dev/null @@ -1,13 +0,0 @@ -# ignore-cross-compile -# ignore-i686-pc-windows-gnu -# needs-unwind - -# This test doesn't work on 32-bit MinGW as cdylib has its own copy of unwinder -# so cross-DLL unwinding does not work. - -include ../tools.mk - -all: - $(RUSTC) bar.rs --crate-type=cdylib - $(RUSTC) foo.rs - $(call RUN,foo) 2>&1 | $(CGREP) "Rust cannot catch foreign exceptions" diff --git a/tests/run-make/foreign-rust-exceptions/rmake.rs b/tests/run-make/foreign-rust-exceptions/rmake.rs new file mode 100644 index 0000000000000..06f7a07c62d49 --- /dev/null +++ b/tests/run-make/foreign-rust-exceptions/rmake.rs @@ -0,0 +1,23 @@ +// Rust exceptions can be foreign (from C code, in this test) or local. Foreign +// exceptions should not be caught, as that can cause undefined behaviour. Instead +// of catching them, #102721 made it so that the binary panics in execution with a helpful message. +// This test checks that the correct message appears and that execution fails when trying to catch +// a foreign exception. +// See https://github.com/rust-lang/rust/issues/102715 + +//@ ignore-cross-compile +// Reason: the compiled binary is executed +//@ needs-unwind +// Reason: unwinding panics is exercised in this test + +//FIXME(Oneirical): ignore-i686-pc-windows-gnu +// This test doesn't work on 32-bit MinGW as cdylib has its own copy of unwinder +// so cross-DLL unwinding does not work. + +use run_make_support::{run_fail, rustc}; + +fn main() { + rustc().input("bar.rs").crate_type("cdylib").run(); + rustc().input("foo.rs").run(); + run_fail("foo").assert_stderr_contains("Rust cannot catch foreign exceptions"); +}