diff options
Diffstat (limited to 'tests')
6 files changed, 127 insertions, 88 deletions
diff --git a/tests/run-make/native-link-modifier-whole-archive/Makefile b/tests/run-make/native-link-modifier-whole-archive/Makefile deleted file mode 100644 index 5eb7a416f91..00000000000 --- a/tests/run-make/native-link-modifier-whole-archive/Makefile +++ /dev/null @@ -1,52 +0,0 @@ -# ignore-cross-compile -- compiling C++ code does not work well when cross-compiling - -# This test case makes sure that native libraries are linked with appropriate semantics -# when the `[+-]bundle,[+-]whole-archive` modifiers are applied to them. -# -# The test works by checking that the resulting executables produce the expected output, -# part of which is emitted by otherwise unreferenced C code. If +whole-archive didn't work -# that code would never make it into the final executable and we'd thus be missing some -# of the output. - -include ../tools.mk - -all: $(TMPDIR)/$(call BIN,directly_linked) \ - $(TMPDIR)/$(call BIN,directly_linked_test_plus_whole_archive) \ - $(TMPDIR)/$(call BIN,directly_linked_test_minus_whole_archive) \ - $(TMPDIR)/$(call BIN,indirectly_linked) \ - $(TMPDIR)/$(call BIN,indirectly_linked_via_attr) - $(call RUN,directly_linked) | $(CGREP) 'static-initializer.directly_linked.' - $(call RUN,directly_linked_test_plus_whole_archive) --nocapture | $(CGREP) 'static-initializer.' - $(call RUN,directly_linked_test_minus_whole_archive) --nocapture | $(CGREP) -v 'static-initializer.' - $(call RUN,indirectly_linked) | $(CGREP) 'static-initializer.indirectly_linked.' - $(call RUN,indirectly_linked_via_attr) | $(CGREP) 'static-initializer.native_lib_in_src.' - -# Native lib linked directly into executable -$(TMPDIR)/$(call BIN,directly_linked): $(call NATIVE_STATICLIB,c_static_lib_with_constructor) - $(RUSTC) directly_linked.rs -l static:+whole-archive=c_static_lib_with_constructor - -# Native lib linked into test executable, +whole-archive -$(TMPDIR)/$(call BIN,directly_linked_test_plus_whole_archive): $(call NATIVE_STATICLIB,c_static_lib_with_constructor) - $(RUSTC) directly_linked_test_plus_whole_archive.rs --test -l static:+whole-archive=c_static_lib_with_constructor -# Native lib linked into test executable, -whole-archive -$(TMPDIR)/$(call BIN,directly_linked_test_minus_whole_archive): $(call NATIVE_STATICLIB,c_static_lib_with_constructor) - $(RUSTC) directly_linked_test_minus_whole_archive.rs --test -l static:-whole-archive=c_static_lib_with_constructor - -# Native lib linked into RLIB via `-l static:-bundle,+whole-archive`, RLIB linked into executable -$(TMPDIR)/$(call BIN,indirectly_linked): $(TMPDIR)/librlib_with_cmdline_native_lib.rlib - $(RUSTC) indirectly_linked.rs - -# Native lib linked into RLIB via #[link] attribute, RLIB linked into executable -$(TMPDIR)/$(call BIN,indirectly_linked_via_attr): $(TMPDIR)/libnative_lib_in_src.rlib - $(RUSTC) indirectly_linked_via_attr.rs - -# Native lib linked into rlib with via commandline -$(TMPDIR)/librlib_with_cmdline_native_lib.rlib: $(call NATIVE_STATICLIB,c_static_lib_with_constructor) - $(RUSTC) rlib_with_cmdline_native_lib.rs --crate-type=rlib -l static:-bundle,+whole-archive=c_static_lib_with_constructor - -# Native lib linked into rlib via `#[link()]` attribute on extern block. -$(TMPDIR)/libnative_lib_in_src.rlib: $(call NATIVE_STATICLIB,c_static_lib_with_constructor) - $(RUSTC) native_lib_in_src.rs --crate-type=rlib - -$(TMPDIR)/libc_static_lib_with_constructor.o: c_static_lib_with_constructor.cpp - $(call COMPILE_OBJ_CXX,$@,$<) diff --git a/tests/run-make/native-link-modifier-whole-archive/rmake.rs b/tests/run-make/native-link-modifier-whole-archive/rmake.rs new file mode 100644 index 00000000000..b8b814043e5 --- /dev/null +++ b/tests/run-make/native-link-modifier-whole-archive/rmake.rs @@ -0,0 +1,86 @@ +// This test case makes sure that native libraries are linked with appropriate semantics +// when the `[+-]bundle,[+-]whole-archive` modifiers are applied to them. +// The test works by checking that the resulting executables produce the expected output, +// part of which is emitted by otherwise unreferenced C code. If +whole-archive didn't work +// that code would never make it into the final executable and we'd thus be missing some +// of the output. +// See https://github.com/rust-lang/rust/issues/88085 + +//@ ignore-cross-compile +// Reason: compiling C++ code does not work well when cross-compiling +// plus, the compiled binary is executed + +use run_make_support::{cxx, is_msvc, llvm_ar, run, run_with_args, rustc, static_lib_name}; + +fn main() { + let mut cxx = cxx(); + if is_msvc() { + cxx.arg("-EHs"); + } + cxx.input("c_static_lib_with_constructor.cpp") + .arg("-c") + .out_exe("libc_static_lib_with_constructor") + .run(); + + let mut llvm_ar = llvm_ar(); + llvm_ar.obj_to_ar(); + if is_msvc() { + llvm_ar + .output_input( + static_lib_name("c_static_lib_with_constructor"), + "libc_static_lib_with_constructor.obj", + ) + .run(); + } else { + llvm_ar + .output_input( + static_lib_name("c_static_lib_with_constructor"), + "libc_static_lib_with_constructor", + ) + .run(); + } + + // Native lib linked directly into executable + rustc() + .input("directly_linked.rs") + .arg("-lstatic:+whole-archive=c_static_lib_with_constructor") + .run(); + + // Native lib linked into test executable, +whole-archive + rustc() + .input("directly_linked_test_plus_whole_archive.rs") + .arg("--test") + .arg("-lstatic:+whole-archive=c_static_lib_with_constructor") + .run(); + + // Native lib linked into test executable, -whole-archive + rustc() + .input("directly_linked_test_minus_whole_archive.rs") + .arg("--test") + .arg("-lstatic:-whole-archive=c_static_lib_with_constructor") + .run(); + + // Native lib linked into rlib with via commandline + rustc() + .input("rlib_with_cmdline_native_lib.rs") + .crate_type("rlib") + .arg("-lstatic:-bundle,+whole-archive=c_static_lib_with_constructor") + .run(); + // Native lib linked into RLIB via `-l static:-bundle,+whole-archive` + // RLIB linked into executable + rustc().input("indirectly_linked.rs").run(); + + // Native lib linked into rlib via `#[link()]` attribute on extern block. + rustc().input("native_lib_in_src.rs").crate_type("rlib").run(); + // Native lib linked into RLIB via #[link] attribute, RLIB linked into executable + rustc().input("indirectly_linked_via_attr.rs").run(); + + run("directly_linked").assert_stdout_contains("static-initializer.directly_linked."); + run_with_args("directly_linked_test_plus_whole_archive", &["--nocapture"]) + .assert_stdout_contains("static-initializer."); + run_with_args("directly_linked_test_minus_whole_archive", &["--nocapture"]) + .assert_stdout_not_contains("static-initializer."); + run("indirectly_linked").assert_stdout_contains("static-initializer.indirectly_linked."); + run("indirectly_linked_via_attr") + .assert_stdout_contains("static-initializer.native_lib_in_src."); +} diff --git a/tests/run-make/no-builtins-attribute/Makefile b/tests/run-make/no-builtins-attribute/Makefile deleted file mode 100644 index 0ce95facaea..00000000000 --- a/tests/run-make/no-builtins-attribute/Makefile +++ /dev/null @@ -1,9 +0,0 @@ -include ../tools.mk - -# We want to check if `no-builtins` is also added to the function declarations in the used crate. - -all: - $(RUSTC) no_builtins.rs --emit=link - $(RUSTC) main.rs --emit=llvm-ir - - cat "$(TMPDIR)"/main.ll | "$(LLVM_FILECHECK)" filecheck.main.txt diff --git a/tests/run-make/no-builtins-attribute/rmake.rs b/tests/run-make/no-builtins-attribute/rmake.rs new file mode 100644 index 00000000000..1e15b0c03f1 --- /dev/null +++ b/tests/run-make/no-builtins-attribute/rmake.rs @@ -0,0 +1,13 @@ +// `no_builtins` is an attribute related to LLVM's optimizations. In order to ensure that it has an +// effect on link-time optimizations (LTO), it should be added to function declarations in a crate. +// This test uses the `llvm-filecheck` tool to determine that this attribute is successfully +// being added to these function declarations. +// See https://github.com/rust-lang/rust/pull/113716 + +use run_make_support::{llvm_filecheck, rfs, rustc}; + +fn main() { + rustc().input("no_builtins.rs").emit("link").run(); + rustc().input("main.rs").emit("llvm-ir").run(); + llvm_filecheck().patterns("filecheck.main.txt").stdin(rfs::read("main.ll")).run(); +} diff --git a/tests/run-make/rlib-format-packed-bundled-libs-2/Makefile b/tests/run-make/rlib-format-packed-bundled-libs-2/Makefile deleted file mode 100644 index d2a740b06b3..00000000000 --- a/tests/run-make/rlib-format-packed-bundled-libs-2/Makefile +++ /dev/null @@ -1,27 +0,0 @@ -include ../tools.mk - -# ignore-cross-compile - -# Make sure -Zpacked_bundled_libs is compatible with verbatim. - -# We're using the llvm-nm instead of the system nm to ensure it is compatible -# with the LLVM bitcode generated by rustc. -# Except on Windows where piping/IO redirection under MSYS2 is wonky with llvm-nm. -ifndef IS_WINDOWS -NM = "$(LLVM_BIN_DIR)"/llvm-nm -else -NM = nm -endif - -all: - # Build strange-named dep. - $(RUSTC) native_dep.rs --crate-type=staticlib -o $(TMPDIR)/native_dep.ext - - $(RUSTC) rust_dep.rs --crate-type=rlib -Zpacked_bundled_libs - $(NM) $(TMPDIR)/librust_dep.rlib | $(CGREP) -e "U.*native_f1" - $(AR) t $(TMPDIR)/librust_dep.rlib | $(CGREP) "native_dep.ext" - - # Make sure compiler doesn't use files, that it shouldn't know about. - rm $(TMPDIR)/native_dep.ext - - $(RUSTC) main.rs --extern rust_dep=$(TMPDIR)/librust_dep.rlib -Zpacked_bundled_libs diff --git a/tests/run-make/rlib-format-packed-bundled-libs-2/rmake.rs b/tests/run-make/rlib-format-packed-bundled-libs-2/rmake.rs new file mode 100644 index 00000000000..5a1460963b6 --- /dev/null +++ b/tests/run-make/rlib-format-packed-bundled-libs-2/rmake.rs @@ -0,0 +1,28 @@ +// `-Z packed_bundled_libs` is an unstable rustc flag that makes the compiler +// only require a native library and no supplementary object files to compile. +// This test simply checks that this flag can be passed alongside verbatim syntax +// in rustc flags without a compilation failure or the removal of expected symbols. +// See https://github.com/rust-lang/rust/pull/100101 + +use run_make_support::{llvm_ar, llvm_nm, rfs, rust_lib_name, rustc}; + +fn main() { + // Build a strangely named dependency. + rustc().input("native_dep.rs").crate_type("staticlib").output("native_dep.ext").run(); + + rustc().input("rust_dep.rs").crate_type("rlib").arg("-Zpacked_bundled_libs").run(); + llvm_nm().input(rust_lib_name("rust_dep")).run().assert_stdout_contains_regex("U.*native_f1"); + llvm_ar() + .arg("t") + .arg(rust_lib_name("rust_dep")) + .run() + .assert_stdout_contains("native_dep.ext"); + + // Ensure the compiler does not use files it should not be aware of. + rfs::remove_file("native_dep.ext"); + rustc() + .input("main.rs") + .extern_("rust_dep", rust_lib_name("rust_dep")) + .arg("-Zpacked_bundled_libs") + .run(); +} |