Skip to content

Commit f3c4813

Browse files
borsbors
committed
Auto merge of rust-lang#128456 - Oneirical:clantestine-operations, r=<try>
Migrate `reproducible-build` `run-make` test to rmake Part of rust-lang#121876 and the associated [Google Summer of Code project](https://blog.rust-lang.org/2024/05/01/gsoc-2024-selected-projects.html). This will likely fail. Locally, rustc errors with `linker 'linker' not found` on line 36 while the file exists according to the dir-debug statement before it. If this gets fixed and the test passes, further developments may include: - [x] There may be some leftovers from each test - `test_in_tmpdir` may therefore be required. - [ ] Try jobs on all ignored architectures. - [x] A potential refactor with a struct and a custom function like rust-lang#128410 so this isn't just a huge stream of `rfs` and `rustc`. This is a little bit harder to do in this test considering the variability present in each test case. // try-job: aarch64-apple // try-job: aarch64-gnu // try-job: armhf-gnu // try-job: test-various // try-job: dist-various-1 try-job: x86_64-msvc try-job: x86_64-mingw try-job: i686-msvc try-job: i686-mingw
2 parents 3139ff0 + b80db63 commit f3c4813

File tree

3 files changed

+246
-141
lines changed

3 files changed

+246
-141
lines changed

‎src/tools/tidy/src/allowed_run_make_makefiles.txt

-1
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,6 @@ run-make/libtest-junit/Makefile
1414
run-make/libtest-thread-limit/Makefile
1515
run-make/macos-deployment-target/Makefile
1616
run-make/native-link-modifier-bundle/Makefile
17-
run-make/reproducible-build/Makefile
1817
run-make/rlib-format-packed-bundled-libs/Makefile
1918
run-make/split-debuginfo/Makefile
2019
run-make/symbol-mangling-hashed/Makefile

‎tests/run-make/reproducible-build/Makefile

-140
This file was deleted.

‎tests/run-make/reproducible-build/rmake.rs

+246
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,246 @@
1+
// This test case makes sure that two identical invocations of the compiler
2+
// (i.e. same code base, same compile-flags, same compiler-versions, etc.)
3+
// produce the same output. In the past, symbol names of monomorphized functions
4+
// were not deterministic (which we want to avoid).
5+
//
6+
// The test tries to exercise as many different paths into symbol name
7+
// generation as possible:
8+
//
9+
// - regular functions
10+
// - generic functions
11+
// - methods
12+
// - statics
13+
// - closures
14+
// - enum variant constructors
15+
// - tuple struct constructors
16+
// - drop glue
17+
// - FnOnce adapters
18+
// - Trait object shims
19+
// - Fn Pointer shims
20+
// See https://github.com/rust-lang/rust/pull/32293
21+
// Tracking Issue: https://github.com/rust-lang/rust/issues/129080
22+
23+
// FIXME(Oneirical): ignore-windows
24+
// # FIXME: Builds of `bin` crate types are not deterministic with debuginfo=2 on
25+
// # Windows.
26+
// # See: https://github.com/rust-lang/rust/pull/87320#issuecomment-920105533
27+
// # Issue: https://github.com/rust-lang/rust/issues/88982
28+
29+
use run_make_support::{
30+
bin_name, cwd, diff, is_darwin, is_windows, rfs, run_in_tmpdir, rust_lib_name, rustc,
31+
};
32+
33+
fn main() {
34+
// Smoke tests. Simple flags, build should be reproducible.
35+
eprintln!("smoke_test => None");
36+
smoke_test(None);
37+
eprintln!("smoke_test => SmokeFlag::Debug");
38+
smoke_test(Some(SmokeFlag::Debug));
39+
eprintln!("smoke_test => SmokeFlag::Opt");
40+
smoke_test(Some(SmokeFlag::Opt));
41+
42+
// Builds should be reproducible even through custom library search paths
43+
// or remap path prefixes.
44+
eprintln!("paths_test => PathsFlag::Link");
45+
paths_test(PathsFlag::Link);
46+
eprintln!("paths_test => PathsFlag::Remap");
47+
paths_test(PathsFlag::Remap);
48+
49+
// Builds should be reproducible even if each build is done in a different directory,
50+
// with both --remap-path-prefix and -Z remap-cwd-prefix.
51+
52+
// FIXME(Oneirical): Building with crate type set to `bin` AND having -Cdebuginfo=2
53+
// (or `-g`, the shorthand form) enabled will cause reproducibility failures.
54+
// See https://github.com/rust-lang/rust/issues/89911
55+
56+
if !is_darwin() && !is_windows() {
57+
// FIXME(Oneirical): Bin builds are not reproducible on non-Linux targets.
58+
eprintln!("diff_dir_test => Bin, Path");
59+
diff_dir_test(CrateType::Bin, RemapType::Path);
60+
}
61+
62+
eprintln!("diff_dir_test => Rlib, Path");
63+
diff_dir_test(CrateType::Rlib, RemapType::Path);
64+
65+
// FIXME(Oneirical): This specific case would fail on Linux, should -Cdebuginfo=2
66+
// be added.
67+
// FIXME(Oneirical): Bin builds are not reproducible on non-Linux targets.
68+
// See https://github.com/rust-lang/rust/issues/89911
69+
if !is_darwin() && !is_windows() {
70+
eprintln!("diff_dir_test => Bin, Cwd false");
71+
diff_dir_test(CrateType::Bin, RemapType::Cwd { is_empty: false });
72+
}
73+
74+
eprintln!("diff_dir_test => Rlib, Cwd false");
75+
diff_dir_test(CrateType::Rlib, RemapType::Cwd { is_empty: false });
76+
eprintln!("diff_dir_test => Rlib, Cwd true");
77+
diff_dir_test(CrateType::Rlib, RemapType::Cwd { is_empty: true });
78+
79+
eprintln!("final extern test");
80+
// Builds should be reproducible when using the --extern flag.
81+
run_in_tmpdir(|| {
82+
rustc().input("reproducible-build-aux.rs").run();
83+
rustc()
84+
.input("reproducible-build.rs")
85+
.crate_type("rlib")
86+
.extern_("reproducible_build_aux", rust_lib_name("reproducible_build_aux"))
87+
.run();
88+
rfs::copy(rust_lib_name("reproducible_build"), rust_lib_name("foo"));
89+
rfs::copy(rust_lib_name("reproducible_build_aux"), rust_lib_name("bar"));
90+
rustc()
91+
.input("reproducible-build.rs")
92+
.crate_type("rlib")
93+
.extern_("reproducible_build_aux", rust_lib_name("bar"))
94+
.run();
95+
assert!(rfs::read(rust_lib_name("foo")) == rfs::read(rust_lib_name("reproducible_build")))
96+
});
97+
}
98+
99+
#[track_caller]
100+
fn smoke_test(flag: Option<SmokeFlag>) {
101+
run_in_tmpdir(|| {
102+
rustc().input("linker.rs").opt().run();
103+
rustc().input("reproducible-build-aux.rs").run();
104+
let mut compiler1 = rustc();
105+
let mut compiler2 = rustc();
106+
if let Some(flag) = flag {
107+
match flag {
108+
SmokeFlag::Debug => {
109+
compiler1.arg("-g");
110+
compiler2.arg("-g");
111+
}
112+
SmokeFlag::Opt => {
113+
compiler1.opt();
114+
compiler2.opt();
115+
}
116+
};
117+
};
118+
compiler1
119+
.input("reproducible-build.rs")
120+
.linker(&cwd().join(bin_name("linker")).display().to_string())
121+
.run();
122+
compiler2
123+
.input("reproducible-build.rs")
124+
.linker(&cwd().join(bin_name("linker")).display().to_string())
125+
.run();
126+
diff().actual_file("linker-arguments1").expected_file("linker-arguments2").run();
127+
});
128+
}
129+
130+
#[track_caller]
131+
fn paths_test(flag: PathsFlag) {
132+
run_in_tmpdir(|| {
133+
rustc().input("reproducible-build-aux.rs").run();
134+
let mut compiler1 = rustc();
135+
let mut compiler2 = rustc();
136+
match flag {
137+
PathsFlag::Link => {
138+
compiler1.library_search_path("a");
139+
compiler2.library_search_path("b");
140+
}
141+
PathsFlag::Remap => {
142+
compiler1.arg("--remap-path-prefix=/a=/c");
143+
compiler2.arg("--remap-path-prefix=/b=/c");
144+
}
145+
}
146+
compiler1.input("reproducible-build.rs").crate_type("rlib").run();
147+
rfs::rename(rust_lib_name("reproducible_build"), rust_lib_name("foo"));
148+
compiler2.input("reproducible-build.rs").crate_type("rlib").run();
149+
assert!(rfs::read(rust_lib_name("foo")) == rfs::read(rust_lib_name("reproducible_build")))
150+
});
151+
}
152+
153+
#[track_caller]
154+
fn diff_dir_test(crate_type: CrateType, remap_type: RemapType) {
155+
run_in_tmpdir(|| {
156+
let base_dir = cwd();
157+
rustc().input("reproducible-build-aux.rs").run();
158+
rfs::create_dir("test");
159+
rfs::copy("reproducible-build.rs", "test/reproducible-build.rs");
160+
let mut compiler1 = rustc();
161+
let mut compiler2 = rustc();
162+
match crate_type {
163+
CrateType::Bin => {
164+
compiler1.crate_type("bin");
165+
compiler2.crate_type("bin");
166+
}
167+
CrateType::Rlib => {
168+
compiler1.crate_type("rlib");
169+
compiler2.crate_type("rlib");
170+
}
171+
}
172+
match remap_type {
173+
RemapType::Path => {
174+
compiler1.arg(&format!("--remap-path-prefix={}=/b", cwd().display()));
175+
compiler2
176+
.arg(format!("--remap-path-prefix={}=/b", base_dir.join("test").display()));
177+
}
178+
RemapType::Cwd { is_empty } => {
179+
// FIXME(Oneirical): Building with crate type set to `bin` AND having -Cdebuginfo=2
180+
// (or `-g`, the shorthand form) enabled will cause reproducibility failures
181+
// for multiple platforms.
182+
// See https://github.com/rust-lang/rust/issues/89911
183+
// FIXME(#129117): Windows rlib + `-Cdebuginfo=2` + `-Z remap-cwd-prefix=.` seems
184+
// to be unreproducible.
185+
if !matches!(crate_type, CrateType::Bin) && !is_windows() {
186+
compiler1.arg("-Cdebuginfo=2");
187+
compiler2.arg("-Cdebuginfo=2");
188+
}
189+
if is_empty {
190+
compiler1.arg("-Zremap-cwd-prefix=");
191+
compiler2.arg("-Zremap-cwd-prefix=");
192+
} else {
193+
compiler1.arg("-Zremap-cwd-prefix=.");
194+
compiler2.arg("-Zremap-cwd-prefix=.");
195+
}
196+
}
197+
}
198+
compiler1.input("reproducible-build.rs").run();
199+
match crate_type {
200+
CrateType::Bin => {
201+
rfs::rename(bin_name("reproducible-build"), bin_name("foo"));
202+
}
203+
CrateType::Rlib => {
204+
rfs::rename(rust_lib_name("reproducible_build"), rust_lib_name("foo"));
205+
}
206+
}
207+
std::env::set_current_dir("test").unwrap();
208+
compiler2
209+
.input("reproducible-build.rs")
210+
.library_search_path(&base_dir)
211+
.out_dir(&base_dir)
212+
.run();
213+
std::env::set_current_dir(&base_dir).unwrap();
214+
match crate_type {
215+
CrateType::Bin => {
216+
assert!(rfs::read(bin_name("reproducible-build")) == rfs::read(bin_name("foo")));
217+
}
218+
CrateType::Rlib => {
219+
assert!(
220+
rfs::read(rust_lib_name("foo"))
221+
== rfs::read(rust_lib_name("reproducible_build"))
222+
);
223+
}
224+
}
225+
});
226+
}
227+
228+
enum SmokeFlag {
229+
Debug,
230+
Opt,
231+
}
232+
233+
enum PathsFlag {
234+
Link,
235+
Remap,
236+
}
237+
238+
enum CrateType {
239+
Bin,
240+
Rlib,
241+
}
242+
243+
enum RemapType {
244+
Path,
245+
Cwd { is_empty: bool },
246+
}

0 commit comments

Comments
 (0)