run_make_support/external_deps/
rustc.rs

1use std::ffi::{OsStr, OsString};
2use std::path::{Path, PathBuf};
3use std::str::FromStr as _;
4
5use crate::command::Command;
6use crate::env::env_var;
7use crate::path_helpers::cwd;
8use crate::util::set_host_compiler_dylib_path;
9use crate::{is_aix, is_darwin, is_windows, is_windows_msvc, target, uname};
10
11/// Construct a new `rustc` invocation. This will automatically set the library
12/// search path as `-L cwd()`. Use [`bare_rustc`] to avoid this.
13#[track_caller]
14pub fn rustc() -> Rustc {
15    Rustc::new()
16}
17
18/// Construct a plain `rustc` invocation with no flags set. Note that [`set_host_compiler_dylib_path`]
19/// still presets the environment variable `HOST_RUSTC_DYLIB_PATH` by default.
20#[track_caller]
21pub fn bare_rustc() -> Rustc {
22    Rustc::bare()
23}
24
25/// A `rustc` invocation builder.
26#[derive(Debug)]
27#[must_use]
28pub struct Rustc {
29    cmd: Command,
30    target: Option<String>,
31}
32
33// Only fill in the target just before execution, so that it can be overridden.
34crate::macros::impl_common_helpers!(Rustc, |rustc: &mut Rustc| {
35    if let Some(target) = &rustc.target {
36        rustc.cmd.arg(&format!("--target={target}"));
37    }
38});
39
40pub fn rustc_path() -> String {
41    env_var("RUSTC")
42}
43
44#[track_caller]
45fn setup_common() -> Command {
46    let mut cmd = Command::new(rustc_path());
47    set_host_compiler_dylib_path(&mut cmd);
48    cmd
49}
50
51impl Rustc {
52    // `rustc` invocation constructor methods
53
54    /// Construct a new `rustc` invocation. This will automatically set the library
55    /// search path as `-L cwd()`, configure the compilation target and enable
56    /// dynamic linkage by default on musl hosts.
57    /// Use [`bare_rustc`] to avoid this.
58    #[track_caller]
59    pub fn new() -> Self {
60        let mut cmd = setup_common();
61        cmd.arg("-L").arg(cwd());
62
63        // FIXME: On musl hosts, we currently default to static linkage, while
64        // for running run-make tests, we rely on dynamic linkage by default
65        if std::env::var("IS_MUSL_HOST").is_ok_and(|i| i == "1") {
66            cmd.arg("-Ctarget-feature=-crt-static");
67        }
68
69        // Automatically default to cross-compilation
70        Self { cmd, target: Some(target()) }
71    }
72
73    /// Construct a bare `rustc` invocation with no flags set.
74    #[track_caller]
75    pub fn bare() -> Self {
76        let cmd = setup_common();
77        Self { cmd, target: None }
78    }
79
80    // Argument provider methods
81
82    /// Configure the compilation environment.
83    pub fn cfg(&mut self, s: &str) -> &mut Self {
84        self.cmd.arg("--cfg");
85        self.cmd.arg(s);
86        self
87    }
88
89    /// Specify default optimization level `-O` (alias for `-C opt-level=3`).
90    pub fn opt(&mut self) -> &mut Self {
91        self.cmd.arg("-O");
92        self
93    }
94
95    /// Specify a specific optimization level.
96    pub fn opt_level(&mut self, option: &str) -> &mut Self {
97        self.cmd.arg(format!("-Copt-level={option}"));
98        self
99    }
100
101    /// Incorporate a hashed string to mangled symbols.
102    pub fn metadata(&mut self, meta: &str) -> &mut Self {
103        self.cmd.arg(format!("-Cmetadata={meta}"));
104        self
105    }
106
107    /// Add a suffix in each output filename.
108    pub fn extra_filename(&mut self, suffix: &str) -> &mut Self {
109        self.cmd.arg(format!("-Cextra-filename={suffix}"));
110        self
111    }
112
113    /// Specify type(s) of output files to generate.
114    pub fn emit<S: AsRef<str>>(&mut self, kinds: S) -> &mut Self {
115        let kinds = kinds.as_ref();
116        self.cmd.arg(format!("--emit={kinds}"));
117        self
118    }
119
120    /// Specify where an external library is located.
121    pub fn extern_<P: AsRef<Path>>(&mut self, crate_name: &str, path: P) -> &mut Self {
122        assert!(
123            !crate_name.contains(|c: char| c.is_whitespace() || c == '\\' || c == '/'),
124            "crate name cannot contain whitespace or path separators"
125        );
126
127        let path = path.as_ref().to_string_lossy();
128
129        self.cmd.arg("--extern");
130        self.cmd.arg(format!("{crate_name}={path}"));
131
132        self
133    }
134
135    /// Remap source path prefixes in all output.
136    pub fn remap_path_prefix<P: AsRef<Path>, P2: AsRef<Path>>(
137        &mut self,
138        from: P,
139        to: P2,
140    ) -> &mut Self {
141        let from = from.as_ref().to_string_lossy();
142        let to = to.as_ref().to_string_lossy();
143
144        self.cmd.arg("--remap-path-prefix");
145        self.cmd.arg(format!("{from}={to}"));
146
147        self
148    }
149
150    /// Specify path to the input file.
151    pub fn input<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
152        self.cmd.arg(path.as_ref());
153        self
154    }
155
156    //Adjust the backtrace level, displaying more detailed information at higher levels.
157    pub fn set_backtrace_level<R: AsRef<OsStr>>(&mut self, level: R) -> &mut Self {
158        self.cmd.env("RUST_BACKTRACE", level);
159        self
160    }
161
162    /// Specify path to the output file. Equivalent to `-o`` in rustc.
163    pub fn output<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
164        self.cmd.arg("-o");
165        self.cmd.arg(path.as_ref());
166        self
167    }
168
169    /// Specify path to the output directory. Equivalent to `--out-dir`` in rustc.
170    pub fn out_dir<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
171        self.cmd.arg("--out-dir");
172        self.cmd.arg(path.as_ref());
173        self
174    }
175
176    /// This flag enables LTO in the specified form.
177    pub fn lto(&mut self, option: &str) -> &mut Self {
178        self.cmd.arg(format!("-Clto={option}"));
179        self
180    }
181
182    /// This flag defers LTO optimizations to the linker.
183    pub fn linker_plugin_lto(&mut self, option: &str) -> &mut Self {
184        self.cmd.arg(format!("-Clinker-plugin-lto={option}"));
185        self
186    }
187
188    /// Specify what happens when the code panics.
189    pub fn panic(&mut self, option: &str) -> &mut Self {
190        self.cmd.arg(format!("-Cpanic={option}"));
191        self
192    }
193
194    /// Specify number of codegen units
195    pub fn codegen_units(&mut self, units: usize) -> &mut Self {
196        self.cmd.arg(format!("-Ccodegen-units={units}"));
197        self
198    }
199
200    /// Specify directory path used for incremental cache
201    pub fn incremental<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
202        let mut arg = OsString::new();
203        arg.push("-Cincremental=");
204        arg.push(path.as_ref());
205        self.cmd.arg(&arg);
206        self
207    }
208
209    /// Specify directory path used for profile generation
210    pub fn profile_generate<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
211        let mut arg = OsString::new();
212        arg.push("-Cprofile-generate=");
213        arg.push(path.as_ref());
214        self.cmd.arg(&arg);
215        self
216    }
217
218    /// Specify directory path used for profile usage
219    pub fn profile_use<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
220        let mut arg = OsString::new();
221        arg.push("-Cprofile-use=");
222        arg.push(path.as_ref());
223        self.cmd.arg(&arg);
224        self
225    }
226
227    /// Specify option of `-C symbol-mangling-version`.
228    pub fn symbol_mangling_version(&mut self, option: &str) -> &mut Self {
229        self.cmd.arg(format!("-Csymbol-mangling-version={option}"));
230        self
231    }
232
233    /// Specify `-C prefer-dynamic`.
234    pub fn prefer_dynamic(&mut self) -> &mut Self {
235        self.cmd.arg(format!("-Cprefer-dynamic"));
236        self
237    }
238
239    /// Specify error format to use
240    pub fn error_format(&mut self, format: &str) -> &mut Self {
241        self.cmd.arg(format!("--error-format={format}"));
242        self
243    }
244
245    /// Specify json messages printed by the compiler
246    pub fn json(&mut self, items: &str) -> &mut Self {
247        self.cmd.arg(format!("--json={items}"));
248        self
249    }
250
251    /// Normalize the line number in the stderr output
252    pub fn ui_testing(&mut self) -> &mut Self {
253        self.cmd.arg(format!("-Zui-testing"));
254        self
255    }
256
257    /// Specify the target triple, or a path to a custom target json spec file.
258    pub fn target<S: AsRef<str>>(&mut self, target: S) -> &mut Self {
259        // We store the target as a separate field, so that it can be specified multiple times.
260        // This is in particular useful to override the default target set in Rustc::new().
261        self.target = Some(target.as_ref().to_string());
262        self
263    }
264
265    /// Specify the target CPU.
266    pub fn target_cpu<S: AsRef<str>>(&mut self, target_cpu: S) -> &mut Self {
267        let target_cpu = target_cpu.as_ref();
268        self.cmd.arg(format!("-Ctarget-cpu={target_cpu}"));
269        self
270    }
271
272    /// Specify the crate type.
273    pub fn crate_type(&mut self, crate_type: &str) -> &mut Self {
274        self.cmd.arg("--crate-type");
275        self.cmd.arg(crate_type);
276        self
277    }
278
279    /// Add a directory to the library search path. Equivalent to `-L` in rustc.
280    pub fn library_search_path<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
281        self.cmd.arg("-L");
282        self.cmd.arg(path.as_ref());
283        self
284    }
285
286    /// Add a directory to the library search path with a restriction, where `kind` is a dependency
287    /// type. Equivalent to `-L KIND=PATH` in rustc.
288    pub fn specific_library_search_path<P: AsRef<Path>>(
289        &mut self,
290        kind: &str,
291        path: P,
292    ) -> &mut Self {
293        assert!(["dependency", "native", "all", "framework", "crate"].contains(&kind));
294        let path = path.as_ref().to_string_lossy();
295        self.cmd.arg(format!("-L{kind}={path}"));
296        self
297    }
298
299    /// Override the system root. Equivalent to `--sysroot` in rustc.
300    pub fn sysroot<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
301        self.cmd.arg("--sysroot");
302        self.cmd.arg(path.as_ref());
303        self
304    }
305
306    /// Specify the edition year.
307    pub fn edition(&mut self, edition: &str) -> &mut Self {
308        self.cmd.arg("--edition");
309        self.cmd.arg(edition);
310        self
311    }
312
313    /// Specify the print request.
314    pub fn print(&mut self, request: &str) -> &mut Self {
315        self.cmd.arg("--print");
316        self.cmd.arg(request);
317        self
318    }
319
320    /// Add an extra argument to the linker invocation, via `-Clink-arg`.
321    pub fn link_arg(&mut self, link_arg: &str) -> &mut Self {
322        self.cmd.arg(format!("-Clink-arg={link_arg}"));
323        self
324    }
325
326    /// Add multiple extra arguments to the linker invocation, via `-Clink-args`.
327    pub fn link_args(&mut self, link_args: &str) -> &mut Self {
328        self.cmd.arg(format!("-Clink-args={link_args}"));
329        self
330    }
331
332    /// Specify a stdin input buffer.
333    pub fn stdin_buf<I: AsRef<[u8]>>(&mut self, input: I) -> &mut Self {
334        self.cmd.stdin_buf(input);
335        self
336    }
337
338    /// Specify the crate name.
339    pub fn crate_name<S: AsRef<OsStr>>(&mut self, name: S) -> &mut Self {
340        self.cmd.arg("--crate-name");
341        self.cmd.arg(name.as_ref());
342        self
343    }
344
345    /// Specify the linker
346    pub fn linker(&mut self, linker: &str) -> &mut Self {
347        self.cmd.arg(format!("-Clinker={linker}"));
348        self
349    }
350
351    /// Specify the linker flavor
352    pub fn linker_flavor(&mut self, linker_flavor: &str) -> &mut Self {
353        self.cmd.arg(format!("-Clinker-flavor={linker_flavor}"));
354        self
355    }
356
357    /// Specify `-C debuginfo=...`.
358    pub fn debuginfo(&mut self, level: &str) -> &mut Self {
359        self.cmd.arg(format!("-Cdebuginfo={level}"));
360        self
361    }
362
363    /// Specify `-C split-debuginfo={packed,unpacked,off}`.
364    pub fn split_debuginfo(&mut self, split_kind: &str) -> &mut Self {
365        self.cmd.arg(format!("-Csplit-debuginfo={split_kind}"));
366        self
367    }
368
369    /// Pass the `--verbose` flag.
370    pub fn verbose(&mut self) -> &mut Self {
371        self.cmd.arg("--verbose");
372        self
373    }
374
375    /// `EXTRARSCXXFLAGS`
376    pub fn extra_rs_cxx_flags(&mut self) -> &mut Self {
377        if is_windows() {
378            // So this is a bit hacky: we can't use the DLL version of libstdc++ because
379            // it pulls in the DLL version of libgcc, which means that we end up with 2
380            // instances of the DW2 unwinding implementation. This is a problem on
381            // i686-pc-windows-gnu because each module (DLL/EXE) needs to register its
382            // unwind information with the unwinding implementation, and libstdc++'s
383            // __cxa_throw won't see the unwinding info we registered with our statically
384            // linked libgcc.
385            //
386            // Now, simply statically linking libstdc++ would fix this problem, except
387            // that it is compiled with the expectation that pthreads is dynamically
388            // linked as a DLL and will fail to link with a statically linked libpthread.
389            //
390            // So we end up with the following hack: we link use static:-bundle to only
391            // link the parts of libstdc++ that we actually use, which doesn't include
392            // the dependency on the pthreads DLL.
393            if !is_windows_msvc() {
394                self.cmd.arg("-lstatic:-bundle=stdc++");
395            };
396        } else if is_darwin() {
397            self.cmd.arg("-lc++");
398        } else if is_aix() {
399            self.cmd.arg("-lc++");
400            self.cmd.arg("-lc++abi");
401        } else {
402            if !matches!(&uname()[..], "FreeBSD" | "SunOS" | "OpenBSD") {
403                self.cmd.arg("-lstdc++");
404            };
405        };
406        self
407    }
408}
409
410/// Query the sysroot path corresponding `rustc --print=sysroot`.
411#[track_caller]
412pub fn sysroot() -> PathBuf {
413    let path = rustc().print("sysroot").run().stdout_utf8();
414    PathBuf::from_str(path.trim()).unwrap()
415}
run_make_support/external_deps/rustc.rs

run_make_support/external_deps/
rustc.rs
