Auto merge of rust-lang#131917 - jieyouxu:rmake-clang, r=<try>

[WIP] CI: try to drop `--test-args=clang` in `x86_64-gnu-debug`

Ok what if I open a separate PR...

r? `@ghost`

try-job: x86_64-gnu-debug

src/ci/docker/host-x86_64/x86_64-gnu-debug/Dockerfile

@@ -52,6 +52,6 @@ ENV RUST_CONFIGURE_ARGS \
 # - FIXME(https://github.com/rust-lang/rust/pull/126155#issuecomment-2156314273):
 # Currently we only run the subset of tests with "clang" in their name.
 
+# HACK(jieyouxu): just run stage 1 Nyehehehe
 ENV SCRIPT \
- python3 ../x.py --stage 2 build && \
- python3 ../x.py --stage 2 test tests/run-make --test-args clang
+ python3 ../x.py --stage 1 test tests/run-make

src/tools/run-make-support/src/command.rs

@@ -222,6 +222,12 @@ pub struct CompletedProcess {
 }
 
 impl CompletedProcess {
+ #[must_use]
+ #[track_caller]
+ pub fn stdout(&self) -> Vec<u8> {
+ self.output.stdout.clone()
+ }
+
  #[must_use]
  #[track_caller]
  pub fn stdout_utf8(&self) -> String {
@@ -234,12 +240,24 @@ impl CompletedProcess {
  String::from_utf8_lossy(&self.output.stdout.clone()).to_string()
  }
 
+ #[must_use]
+ #[track_caller]
+ pub fn stderr(&self) -> Vec<u8> {
+ self.output.stderr.clone()
+ }
+
  #[must_use]
  #[track_caller]
  pub fn stderr_utf8(&self) -> String {
  String::from_utf8(self.output.stderr.clone()).expect("stderr is not valid UTF-8")
  }
 
+ #[must_use]
+ #[track_caller]
+ pub fn invalid_stderr_utf8(&self) -> String {
+ String::from_utf8_lossy(&self.output.stderr.clone()).to_string()
+ }
+
  #[must_use]
  pub fn status(&self) -> ExitStatus {
  self.output.status

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

@@ -60,6 +60,18 @@ pub fn llvm_pdbutil() -> LlvmPdbutil {
  LlvmPdbutil::new()
 }
 
+/// Construct a new `llvm-dis` invocation. This assumes that `llvm-dis` is available
+/// at `$LLVM_BIN_DIR/llvm-dis`.
+pub fn llvm_dis() -> LlvmDis {
+ LlvmDis::new()
+}
+
+/// Construct a new `llvm-objcopy` invocation. This assumes that `llvm-objcopy` is available
+/// at `$LLVM_BIN_DIR/llvm-objcopy`.
+pub fn llvm_objcopy() -> LlvmObjcopy {
+ LlvmObjcopy::new()
+}
+
 /// A `llvm-readobj` invocation builder.
 #[derive(Debug)]
 #[must_use]
@@ -123,6 +135,20 @@ pub struct LlvmPdbutil {
  cmd: Command,
 }
 
+/// A `llvm-dis` invocation builder.
+#[derive(Debug)]
+#[must_use]
+pub struct LlvmDis {
+ cmd: Command,
+}
+
+/// A `llvm-objcopy` invocation builder.
+#[derive(Debug)]
+#[must_use]
+pub struct LlvmObjcopy {
+ cmd: Command,
+}
+
 crate::macros::impl_common_helpers!(LlvmReadobj);
 crate::macros::impl_common_helpers!(LlvmProfdata);
 crate::macros::impl_common_helpers!(LlvmFilecheck);
@@ -132,6 +158,8 @@ crate::macros::impl_common_helpers!(LlvmNm);
 crate::macros::impl_common_helpers!(LlvmBcanalyzer);
 crate::macros::impl_common_helpers!(LlvmDwarfdump);
 crate::macros::impl_common_helpers!(LlvmPdbutil);
+crate::macros::impl_common_helpers!(LlvmDis);
+crate::macros::impl_common_helpers!(LlvmObjcopy);
 
 /// Generate the path to the bin directory of LLVM.
 #[must_use]
@@ -390,3 +418,41 @@ impl LlvmPdbutil {
  self
  }
 }
+
+impl LlvmObjcopy {
+ /// Construct a new `llvm-objcopy` invocation. This assumes that `llvm-objcopy` is available
+ /// at `$LLVM_BIN_DIR/llvm-objcopy`.
+ pub fn new() -> Self {
+ let llvm_objcopy = llvm_bin_dir().join("llvm-objcopy");
+ let cmd = Command::new(llvm_objcopy);
+ Self { cmd }
+ }
+
+ /// Dump the contents of `section` into the file at `path`.
+ #[track_caller]
+ pub fn dump_section<S: AsRef<str>, P: AsRef<Path>>(
+ &mut self,
+ section_name: S,
+ path: P,
+ ) -> &mut Self {
+ self.cmd.arg("--dump-section");
+ self.cmd.arg(format!("{}={}", section_name.as_ref(), path.as_ref().to_str().unwrap()));
+ self
+ }
+}
+
+impl LlvmDis {
+ /// Construct a new `llvm-dis` invocation. This assumes that `llvm-dis` is available
+ /// at `$LLVM_BIN_DIR/llvm-dis`.
+ pub fn new() -> Self {
+ let llvm_dis = llvm_bin_dir().join("llvm-dis");
+ let cmd = Command::new(llvm_dis);
+ Self { cmd }
+ }
+
+ /// Provide an input file.
+ pub fn input<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
+ self.cmd.arg(path.as_ref());
+ self
+ }
+}

src/tools/run-make-support/src/lib.rs

@@ -49,14 +49,17 @@ pub use external_deps::{c_build, cc, clang, htmldocck, llvm, python, rustc, rust
 
 // These rely on external dependencies.
 pub use cc::{cc, cxx, extra_c_flags, extra_cxx_flags, Cc};
-pub use c_build::{build_native_dynamic_lib, build_native_static_lib, build_native_static_lib_optimized, build_native_static_lib_cxx};
+pub use c_build::{
+ build_native_dynamic_lib, build_native_static_lib, build_native_static_lib_cxx,
+ build_native_static_lib_optimized,
+};
 pub use cargo::cargo;
 pub use clang::{clang, Clang};
 pub use htmldocck::htmldocck;
 pub use llvm::{
- llvm_ar, llvm_bcanalyzer, llvm_dwarfdump, llvm_filecheck, llvm_nm, llvm_objdump, llvm_profdata,
- llvm_readobj, LlvmAr, LlvmBcanalyzer, LlvmDwarfdump, LlvmFilecheck, LlvmNm, LlvmObjdump,
- LlvmProfdata, LlvmReadobj,
+ llvm_ar, llvm_bcanalyzer, llvm_dis, llvm_dwarfdump, llvm_filecheck, llvm_nm, llvm_objcopy,
+ llvm_objdump, llvm_profdata, llvm_readobj, LlvmAr, LlvmBcanalyzer, LlvmDis, LlvmDwarfdump,
+ LlvmFilecheck, LlvmNm, LlvmObjcopy, LlvmObjdump, LlvmProfdata, LlvmReadobj,
 };
 pub use python::python_command;
 pub use rustc::{aux_build, bare_rustc, rustc, rustc_path, Rustc};

src/tools/tidy/src/allowed_run_make_makefiles.txt

@@ -2,7 +2,6 @@ run-make/branch-protection-check-IBT/Makefile
 run-make/cat-and-grep-sanity-check/Makefile
 run-make/extern-fn-reachable/Makefile
 run-make/incr-add-rust-src-component/Makefile
-run-make/issue-84395-lto-embed-bitcode/Makefile
 run-make/jobserver-error/Makefile
 run-make/libs-through-symlinks/Makefile
 run-make/split-debuginfo/Makefile

tests/run-make/cross-lang-lto-riscv-abi/rmake.rs

@@ -1,21 +1,20 @@
-//! Make sure that cross-language LTO works on riscv targets,
-//! which requires extra `target-abi` metadata to be emitted.
+//! Make sure that cross-language LTO works on riscv targets, which requires extra `target-abi`
+//! metadata to be emitted.
 //@ needs-force-clang-based-tests
-//@ needs-llvm-components riscv
+//@ needs-llvm-components: riscv
 
-//@ needs-force-clang-based-tests
-// FIXME(#126180): This test can only run on `x86_64-gnu-debug`, because that CI job sets
-// RUSTBUILD_FORCE_CLANG_BASED_TESTS and only runs tests which contain "clang" in their
-// name.
-// However, this test does not run at all as its name does not contain "clang".
-
-use std::path::PathBuf;
-use std::process::{Command, Output};
-use std::{env, str};
+// ignore-tidy-linelength
 
-use run_make_support::{bin_name, clang, llvm_readobj, rustc};
+use object::elf;
+use object::read::elf as readelf;
+use run_make_support::{bin_name, clang, object, rfs, rustc};
 
-fn check_target(target: &str, clang_target: &str, carch: &str, is_double_float: bool) {
+fn check_target<H: readelf::FileHeader<Endian = object::Endianness>>(
+ target: &str,
+ clang_target: &str,
+ carch: &str,
+ is_double_float: bool,
+) {
  eprintln!("Checking target {target}");
  // Rust part
  rustc()
@@ -39,16 +38,55 @@ fn check_target(target: &str, clang_target: &str, carch: &str, is_double_float:
 
  // Check that the built binary has correct float abi
  let executable = bin_name("riscv-xlto");
- let output = llvm_readobj().input(&executable).file_header().run();
- let stdout = String::from_utf8_lossy(&output.stdout);
- eprintln!("obj:\n{}", stdout);
-
- assert!(!(is_double_float ^ stdout.contains("EF_RISCV_FLOAT_ABI_DOUBLE")));
+ let data = rfs::read(&executable);
+ let header = <H>::parse(&*data).unwrap();
+ let endian = match header.e_ident().data {
+ elf::ELFDATA2LSB => object::Endianness::Little,
+ elf::ELFDATA2MSB => object::Endianness::Big,
+ x => unreachable!("invalid e_ident data: {:#010b}", x),
+ };
+ // Check `(e_flags & EF_RISCV_FLOAT_ABI) == EF_RISCV_FLOAT_ABI_DOUBLE`.
+ //
+ // See
+ // <https://github.com/riscv-non-isa/riscv-elf-psabi-doc/blob/master/riscv-elf.adoc#elf-object-files>.
+ if is_double_float {
+ assert_eq!(
+ header.e_flags(endian) & elf::EF_RISCV_FLOAT_ABI,
+ elf::EF_RISCV_FLOAT_ABI_DOUBLE,
+ "expected {target} to use double ABI, but it did not"
+ );
+ } else {
+ assert_ne!(
+ header.e_flags(endian) & elf::EF_RISCV_FLOAT_ABI,
+ elf::EF_RISCV_FLOAT_ABI_DOUBLE,
+ "did not expected {target} to use double ABI"
+ );
+ }
 }
 
 fn main() {
- check_target("riscv64gc-unknown-linux-gnu", "riscv64-linux-gnu", "rv64gc", true);
- check_target("riscv64imac-unknown-none-elf", "riscv64-unknown-elf", "rv64imac", false);
- check_target("riscv32imac-unknown-none-elf", "riscv32-unknown-elf", "rv32imac", false);
- check_target("riscv32gc-unknown-linux-gnu", "riscv32-linux-gnu", "rv32gc", true);
+ check_target::<elf::FileHeader64<object::Endianness>>(
+ "riscv64gc-unknown-linux-gnu",
+ "riscv64-linux-gnu",
+ "rv64gc",
+ true,
+ );
+ check_target::<elf::FileHeader64<object::Endianness>>(
+ "riscv64imac-unknown-none-elf",
+ "riscv64-unknown-elf",
+ "rv64imac",
+ false,
+ );
+ check_target::<elf::FileHeader32<object::Endianness>>(
+ "riscv32imac-unknown-none-elf",
+ "riscv32-unknown-elf",
+ "rv32imac",
+ false,
+ );
+ check_target::<elf::FileHeader32<object::Endianness>>(
+ "riscv32gc-unknown-linux-gnu",
+ "riscv32-linux-gnu",
+ "rv32gc",
+ true,
+ );
 }

tests/run-make/issue-84395-lto-embed-bitcode/rmake.rs

@@ -0,0 +1,27 @@
+//! Smoke test to make sure the embed bitcode in elf created with
+//! `--plugin-opt=-lto-embed-bitcode=optimized` is valid llvm BC module.
+//!
+//! See <https://github.com/rust-lang/rust/issues/84395> where passing
+//! `-lto-embed-bitcode=optimized` to lld when linking rust code via `linker-plugin-lto` doesn't
+//! produce the expected result.
+//!
+//! See PR <https://github.com/rust-lang/rust/pull/98162> which initially introduced this test.
+
+//@ needs-force-clang-based-tests
+
+use run_make_support::{env_var, llvm_dis, llvm_objcopy, rustc};
+
+fn main() {
+ rustc()
+ .input("test.rs")
+ .arg("-Clink-arg=-fuse-ld=lld")
+ .arg("-Clinker-plugin-lto")
+ .arg(format!("-Clinker={}", env_var("CLANG")))
+ .arg("-Clink-arg=-Wl,--plugin-opt=-lto-embed-bitcode=optimized")
+ .arg("-Zemit-thin-lto=no")
+ .run();
+
+ llvm_objcopy().dump_section(".llvmbc", "test.bc").arg("test").run();
+
+ llvm_dis().arg("test.bc").run();
+}