cc/
tool.rs

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

cc/
tool.rs
