Debian Codegraph @

third_party/rust/cc/src/tool.rs

raw
1 use std::{
2 borrow::Cow,
3 collections::HashMap,
4 env,
5 ffi::{OsStr, OsString},
6 io::Write,
7 path::{Path, PathBuf},
8 process::{Command, Stdio},
9 sync::RwLock,
10 };
11
12 use crate::{
13 command_helpers::{run_output, CargoOutput},
14 run,
15 tempfile::NamedTempfile,
16 Error, ErrorKind, OutputKind,
17 };
18
19 pub(crate) type CompilerFamilyLookupCache = HashMap<Box<[Box<OsStr>]>, ToolFamily>;
20
21 /// Configuration used to represent an invocation of a C compiler.
22 ///
23 /// This can be used to figure out what compiler is in use, what the arguments
24 /// to it are, and what the environment variables look like for the compiler.
25 /// This can be used to further configure other build systems (e.g. forward
26 /// along CC and/or CFLAGS) or the `to_command` method can be used to run the
27 /// compiler itself.
28 #[derive(Clone, Debug)]
29 #[allow(missing_docs)]
30 pub struct Tool {
31 pub(crate) path: PathBuf,
32 pub(crate) cc_wrapper_path: Option<PathBuf>,
33 pub(crate) cc_wrapper_args: Vec<OsString>,
34 pub(crate) args: Vec<OsString>,
35 pub(crate) env: Vec<(OsString, OsString)>,
36 pub(crate) family: ToolFamily,
37 pub(crate) cuda: bool,
38 pub(crate) removed_args: Vec<OsString>,
39 pub(crate) has_internal_target_arg: bool,
40 }
41
42 impl Tool {
43 pub(crate) fn new(
44 path: PathBuf,
45 cached_compiler_family: &RwLock<CompilerFamilyLookupCache>,
46 cargo_output: &CargoOutput,
47 out_dir: Option<&Path>,
48 ) -> Self {
49 Self::with_features(
50 path,
51 vec![],
52 false,
53 cached_compiler_family,
54 cargo_output,
55 out_dir,
56 )
57 }
58
59 pub(crate) fn with_args(
60 path: PathBuf,
61 args: Vec<String>,
62 cached_compiler_family: &RwLock<CompilerFamilyLookupCache>,
63 cargo_output: &CargoOutput,
64 out_dir: Option<&Path>,
65 ) -> Self {
66 Self::with_features(
67 path,
68 args,
69 false,
70 cached_compiler_family,
71 cargo_output,
72 out_dir,
73 )
74 }
75
76 /// Explicitly set the `ToolFamily`, skipping name-based detection.
77 pub(crate) fn with_family(path: PathBuf, family: ToolFamily) -> Self {
78 Self {
79 path,
80 cc_wrapper_path: None,
81 cc_wrapper_args: Vec::new(),
82 args: Vec::new(),
83 env: Vec::new(),
84 family,
85 cuda: false,
86 removed_args: Vec::new(),
87 has_internal_target_arg: false,
88 }
89 }
90
91 pub(crate) fn with_features(
92 path: PathBuf,
93 args: Vec<String>,
94 cuda: bool,
95 cached_compiler_family: &RwLock<CompilerFamilyLookupCache>,
96 cargo_output: &CargoOutput,
97 out_dir: Option<&Path>,
98 ) -> Self {
99 fn is_zig_cc(path: &Path, cargo_output: &CargoOutput) -> bool {
100 run_output(
101 Command::new(path).arg("--version"),
102 path,
103 // tool detection issues should always be shown as warnings
104 cargo_output,
105 )
106 .map(|o| String::from_utf8_lossy(&o).contains("ziglang"))
107 .unwrap_or_default()
108 || {
109 match path.file_name().map(OsStr::to_string_lossy) {
110 Some(fname) => fname.contains("zig"),
111 _ => false,
112 }
113 }
114 }
115
116 fn guess_family_from_stdout(
117 stdout: &str,
118 path: &Path,
119 args: &[String],
120 cargo_output: &CargoOutput,
121 ) -> Result<ToolFamily, Error> {
122 cargo_output.print_debug(&stdout);
123
124 // https://gitlab.kitware.com/cmake/cmake/-/blob/69a2eeb9dff5b60f2f1e5b425002a0fd45b7cadb/Modules/CMakeDetermineCompilerId.cmake#L267-271
125 // stdin is set to null to ensure that the help output is never paginated.
126 let accepts_cl_style_flags = run(
127 Command::new(path).args(args).arg("-?").stdin(Stdio::null()),
128 path,
129 &{
130 // the errors are not errors!
131 let mut cargo_output = cargo_output.clone();
132 cargo_output.warnings = cargo_output.debug;
133 cargo_output.output = OutputKind::Discard;
134 cargo_output
135 },
136 )
137 .is_ok();
138
139 let clang = stdout.contains(r#""clang""#);
140 let gcc = stdout.contains(r#""gcc""#);
141 let emscripten = stdout.contains(r#""emscripten""#);
142 let vxworks = stdout.contains(r#""VxWorks""#);
143
144 match (clang, accepts_cl_style_flags, gcc, emscripten, vxworks) {
145 (clang_cl, true, _, false, false) => Ok(ToolFamily::Msvc { clang_cl }),
146 (true, _, _, _, false) | (_, _, _, true, false) => Ok(ToolFamily::Clang {
147 zig_cc: is_zig_cc(path, cargo_output),
148 }),
149 (false, false, true, _, false) | (_, _, _, _, true) => Ok(ToolFamily::Gnu),
150 (false, false, false, false, false) => {
151 cargo_output.print_warning(&"Compiler family detection failed since it does not define `__clang__`, `__GNUC__`, `__EMSCRIPTEN__` or `__VXWORKS__`, also does not accept cl style flag `-?`, fallback to treating it as GNU");
152 Err(Error::new(
153 ErrorKind::ToolFamilyMacroNotFound,
154 "Expects macro `__clang__`, `__GNUC__` or `__EMSCRIPTEN__`, `__VXWORKS__` or accepts cl style flag `-?`, but found none",
155 ))
156 }
157 }
158 }
159
160 fn detect_family_inner(
161 path: &Path,
162 args: &[String],
163 cargo_output: &CargoOutput,
164 out_dir: Option<&Path>,
165 ) -> Result<ToolFamily, Error> {
166 let out_dir = out_dir
167 .map(Cow::Borrowed)
168 .unwrap_or_else(|| Cow::Owned(env::temp_dir()));
169
170 // Ensure all the parent directories exist otherwise temp file creation
171 // will fail
172 std::fs::create_dir_all(&out_dir).map_err(|err| Error {
173 kind: ErrorKind::IOError,
174 message: format!("failed to create OUT_DIR '{}': {}", out_dir.display(), err)
175 .into(),
176 })?;
177
178 let mut tmp =
179 NamedTempfile::new(&out_dir, "detect_compiler_family.c").map_err(|err| Error {
180 kind: ErrorKind::IOError,
181 message: format!(
182 "failed to create detect_compiler_family.c temp file in '{}': {}",
183 out_dir.display(),
184 err
185 )
186 .into(),
187 })?;
188 let mut tmp_file = tmp.take_file().unwrap();
189 tmp_file.write_all(include_bytes!("detect_compiler_family.c"))?;
190 // Close the file handle *now*, otherwise the compiler may fail to open it on Windows
191 // (#1082). The file stays on disk and its path remains valid until `tmp` is dropped.
192 tmp_file.flush()?;
193 tmp_file.sync_data()?;
194 drop(tmp_file);
195
196 // When expanding the file, the compiler prints a lot of information to stderr
197 // that it is not an error, but related to expanding itself.
198 //
199 // cc would have to disable warning here to prevent generation of too many warnings.
200 let mut compiler_detect_output = cargo_output.clone();
201 compiler_detect_output.warnings = compiler_detect_output.debug;
202
203 let stdout = run_output(
204 Command::new(path).arg("-E").arg(tmp.path()),
205 path,
206 &compiler_detect_output,
207 )?;
208 let stdout = String::from_utf8_lossy(&stdout);
209
210 if stdout.contains("-Wslash-u-filename") {
211 let stdout = run_output(
212 Command::new(path).arg("-E").arg("--").arg(tmp.path()),
213 path,
214 &compiler_detect_output,
215 )?;
216 let stdout = String::from_utf8_lossy(&stdout);
217 guess_family_from_stdout(&stdout, path, args, cargo_output)
218 } else {
219 guess_family_from_stdout(&stdout, path, args, cargo_output)
220 }
221 }
222 let detect_family = |path: &Path, args: &[String]| -> Result<ToolFamily, Error> {
223 let cache_key = [path.as_os_str()]
224 .iter()
225 .cloned()
226 .chain(args.iter().map(OsStr::new))
227 .map(Into::into)
228 .collect();
229 if let Some(family) = cached_compiler_family.read().unwrap().get(&cache_key) {
230 return Ok(*family);
231 }
232
233 let family = detect_family_inner(path, args, cargo_output, out_dir)?;
234 cached_compiler_family
235 .write()
236 .unwrap()
237 .insert(cache_key, family);
238 Ok(family)
239 };
240
241 let family = detect_family(&path, &args).unwrap_or_else(|e| {
242 cargo_output.print_warning(&format_args!(
243 "Compiler family detection failed due to error: {}",
244 e
245 ));
246 match path.file_name().map(OsStr::to_string_lossy) {
247 Some(fname) if fname.contains("clang-cl") => ToolFamily::Msvc { clang_cl: true },
248 Some(fname) if fname.ends_with("cl") || fname == "cl.exe" => {
249 ToolFamily::Msvc { clang_cl: false }
250 }
251 Some(fname) if fname.contains("clang") => {
252 let is_clang_cl = args
253 .iter()
254 .any(|a| a.strip_prefix("--driver-mode=") == Some("cl"));
255 if is_clang_cl {
256 ToolFamily::Msvc { clang_cl: true }
257 } else {
258 ToolFamily::Clang {
259 zig_cc: is_zig_cc(&path, cargo_output),
260 }
261 }
262 }
263 Some(fname) if fname.contains("zig") => ToolFamily::Clang { zig_cc: true },
264 _ => ToolFamily::Gnu,
265 }
266 });
267
268 Tool {
269 path,
270 cc_wrapper_path: None,
271 cc_wrapper_args: Vec::new(),
272 args: Vec::new(),
273 env: Vec::new(),
274 family,
275 cuda,
276 removed_args: Vec::new(),
277 has_internal_target_arg: false,
278 }
279 }
280
281 /// Add an argument to be stripped from the final command arguments.
282 pub(crate) fn remove_arg(&mut self, flag: OsString) {
283 self.removed_args.push(flag);
284 }
285
286 /// Push an "exotic" flag to the end of the compiler's arguments list.
287 ///
288 /// Nvidia compiler accepts only the most common compiler flags like `-D`,
289 /// `-I`, `-c`, etc. Options meant specifically for the underlying
290 /// host C++ compiler have to be prefixed with `-Xcompiler`.
291 /// [Another possible future application for this function is passing
292 /// clang-specific flags to clang-cl, which otherwise accepts only
293 /// MSVC-specific options.]
294 pub(crate) fn push_cc_arg(&mut self, flag: OsString) {
295 if self.cuda {
296 self.args.push("-Xcompiler".into());
297 }
298 self.args.push(flag);
299 }
300
301 /// Checks if an argument or flag has already been specified or conflicts.
302 ///
303 /// Currently only checks optimization flags.
304 pub(crate) fn is_duplicate_opt_arg(&self, flag: &OsString) -> bool {
305 let flag = flag.to_str().unwrap();
306 let mut chars = flag.chars();
307
308 // Only duplicate check compiler flags
309 if self.is_like_msvc() {
310 if chars.next() != Some('/') {
311 return false;
312 }
313 } else if (self.is_like_gnu() || self.is_like_clang()) && chars.next() != Some('-') {
314 return false;
315 }
316
317 // Check for existing optimization flags (-O, /O)
318 if chars.next() == Some('O') {
319 return self
320 .args()
321 .iter()
322 .any(|a| a.to_str().unwrap_or("").chars().nth(1) == Some('O'));
323 }
324
325 // TODO Check for existing -m..., -m...=..., /arch:... flags
326 false
327 }
328
329 /// Don't push optimization arg if it conflicts with existing args.
330 pub(crate) fn push_opt_unless_duplicate(&mut self, flag: OsString) {
331 if self.is_duplicate_opt_arg(&flag) {
332 eprintln!("Info: Ignoring duplicate arg {:?}", &flag);
333 } else {
334 self.push_cc_arg(flag);
335 }
336 }
337
338 /// Converts this compiler into a `Command` that's ready to be run.
339 ///
340 /// This is useful for when the compiler needs to be executed and the
341 /// command returned will already have the initial arguments and environment
342 /// variables configured.
343 pub fn to_command(&self) -> Command {
344 let mut cmd = match self.cc_wrapper_path {
345 Some(ref cc_wrapper_path) => {
346 let mut cmd = Command::new(cc_wrapper_path);
347 cmd.arg(&self.path);
348 cmd
349 }
350 None => Command::new(&self.path),
351 };
352 cmd.args(&self.cc_wrapper_args);
353
354 let value = self
355 .args
356 .iter()
357 .filter(|a| !self.removed_args.contains(a))
358 .collect::<Vec<_>>();
359 cmd.args(&value);
360
361 for (k, v) in self.env.iter() {
362 cmd.env(k, v);
363 }
364 cmd
365 }
366
367 /// Returns the path for this compiler.
368 ///
369 /// Note that this may not be a path to a file on the filesystem, e.g. "cc",
370 /// but rather something which will be resolved when a process is spawned.
371 pub fn path(&self) -> &Path {
372 &self.path
373 }
374
375 /// Returns the default set of arguments to the compiler needed to produce
376 /// executables for the target this compiler generates.
377 pub fn args(&self) -> &[OsString] {
378 &self.args
379 }
380
381 /// Returns the set of environment variables needed for this compiler to
382 /// operate.
383 ///
384 /// This is typically only used for MSVC compilers currently.
385 pub fn env(&self) -> &[(OsString, OsString)] {
386 &self.env
387 }
388
389 /// Returns the compiler command in format of CC environment variable.
390 /// Or empty string if CC env was not present
391 ///
392 /// This is typically used by configure script
393 pub fn cc_env(&self) -> OsString {
394 match self.cc_wrapper_path {
395 Some(ref cc_wrapper_path) => {
396 let mut cc_env = cc_wrapper_path.as_os_str().to_owned();
397 cc_env.push(" ");
398 cc_env.push(self.path.to_path_buf().into_os_string());
399 for arg in self.cc_wrapper_args.iter() {
400 cc_env.push(" ");
401 cc_env.push(arg);
402 }
403 cc_env
404 }
405 None => OsString::from(""),
406 }
407 }
408
409 /// Returns the compiler flags in format of CFLAGS environment variable.
410 /// Important here - this will not be CFLAGS from env, its internal gcc's flags to use as CFLAGS
411 /// This is typically used by configure script
412 pub fn cflags_env(&self) -> OsString {
413 let mut flags = OsString::new();
414 for (i, arg) in self.args.iter().enumerate() {
415 if i > 0 {
416 flags.push(" ");
417 }
418 flags.push(arg);
419 }
420 flags
421 }
422
423 /// Whether the tool is GNU Compiler Collection-like.
424 pub fn is_like_gnu(&self) -> bool {
425 self.family == ToolFamily::Gnu
426 }
427
428 /// Whether the tool is Clang-like.
429 pub fn is_like_clang(&self) -> bool {
430 matches!(self.family, ToolFamily::Clang { .. })
431 }
432
433 /// Whether the tool is AppleClang under .xctoolchain
434 #[cfg(target_vendor = "apple")]
435 pub(crate) fn is_xctoolchain_clang(&self) -> bool {
436 let path = self.path.to_string_lossy();
437 path.contains(".xctoolchain/")
438 }
439 #[cfg(not(target_vendor = "apple"))]
440 pub(crate) fn is_xctoolchain_clang(&self) -> bool {
441 false
442 }
443
444 /// Whether the tool is MSVC-like.
445 pub fn is_like_msvc(&self) -> bool {
446 matches!(self.family, ToolFamily::Msvc { .. })
447 }
448
449 /// Whether the tool is `clang-cl`-based MSVC-like.
450 pub fn is_like_clang_cl(&self) -> bool {
451 matches!(self.family, ToolFamily::Msvc { clang_cl: true })
452 }
453
454 /// Supports using `--` delimiter to separate arguments and path to source files.
455 pub(crate) fn supports_path_delimiter(&self) -> bool {
456 // homebrew clang and zig-cc does not support this while stock version does
457 matches!(self.family, ToolFamily::Msvc { clang_cl: true }) && !self.cuda
458 }
459 }
460
461 /// Represents the family of tools this tool belongs to.
462 ///
463 /// Each family of tools differs in how and what arguments they accept.
464 ///
465 /// Detection of a family is done on best-effort basis and may not accurately reflect the tool.
466 #[derive(Copy, Clone, Debug, PartialEq)]
467 pub enum ToolFamily {
468 /// Tool is GNU Compiler Collection-like.
469 Gnu,
470 /// Tool is Clang-like. It differs from the GCC in a sense that it accepts superset of flags
471 /// and its cross-compilation approach is different.
472 Clang { zig_cc: bool },
473 /// Tool is the MSVC cl.exe.
474 Msvc { clang_cl: bool },
475 }
476
477 impl ToolFamily {
478 /// What the flag to request debug info for this family of tools look like
479 pub(crate) fn add_debug_flags(&self, cmd: &mut Tool, dwarf_version: Option<u32>) {
480 match *self {
481 ToolFamily::Msvc { .. } => {
482 cmd.push_cc_arg("-Z7".into());
483 }
484 ToolFamily::Gnu | ToolFamily::Clang { .. } => {
485 cmd.push_cc_arg(
486 dwarf_version
487 .map_or_else(|| "-g".into(), |v| format!("-gdwarf-{}", v))
488 .into(),
489 );
490 }
491 }
492 }
493
494 /// What the flag to force frame pointers.
495 pub(crate) fn add_force_frame_pointer(&self, cmd: &mut Tool) {
496 match *self {
497 ToolFamily::Gnu | ToolFamily::Clang { .. } => {
498 cmd.push_cc_arg("-fno-omit-frame-pointer".into());
499 }
500 _ => (),
501 }
502 }
503
504 /// What the flags to enable all warnings
505 pub(crate) fn warnings_flags(&self) -> &'static str {
506 match *self {
507 ToolFamily::Msvc { .. } => "-W4",
508 ToolFamily::Gnu | ToolFamily::Clang { .. } => "-Wall",
509 }
510 }
511
512 /// What the flags to enable extra warnings
513 pub(crate) fn extra_warnings_flags(&self) -> Option<&'static str> {
514 match *self {
515 ToolFamily::Msvc { .. } => None,
516 ToolFamily::Gnu | ToolFamily::Clang { .. } => Some("-Wextra"),
517 }
518 }
519
520 /// What the flag to turn warning into errors
521 pub(crate) fn warnings_to_errors_flag(&self) -> &'static str {
522 match *self {
523 ToolFamily::Msvc { .. } => "-WX",
524 ToolFamily::Gnu | ToolFamily::Clang { .. } => "-Werror",
525 }
526 }
527
528 pub(crate) fn verbose_stderr(&self) -> bool {
529 matches!(*self, ToolFamily::Clang { .. })
530 }
531 }