Support caching Clang invocations with -fprofile-use and -fprofile-instr-use.

Author: michaelwoerister

src/compiler/clang.rs

@@ -54,6 +54,7 @@ impl CCompilerImpl for Clang {
             cwd,
             (&gcc::ARGS[..], &ARGS[..]),
             self.clangplusplus,
+            CCompilerKind::Clang,
         )
     }
 
@@ -103,7 +104,7 @@ impl CCompilerImpl for Clang {
     }
 }
 
-counted_array!(pub static ARGS: [ArgInfo<gcc::ArgData>; _] = [
+pub static ARGS: &[ArgInfo<gcc::ArgData>] = &[
     take_arg!("--serialize-diagnostics", OsString, Separated, PassThrough),
     take_arg!("--target", OsString, Separated, PassThrough),
     take_arg!("-Xclang", OsString, Separated, XClang),
@@ -118,7 +119,7 @@ counted_array!(pub static ARGS: [ArgInfo<gcc::ArgData>; _] = [
     take_arg!("-fplugin", PathBuf, CanBeConcatenated('='), ExtraHashFile),
     flag!("-fprofile-instr-generate", ProfileGenerate),
     // Can be either -fprofile-instr-use or -fprofile-instr-use=path
-    take_arg!("-fprofile-instr-use", OsString, Concatenated, TooHard),
+    take_arg!("-fprofile-instr-use", PathBuf, Concatenated('='), ProfileUse),
     take_arg!("-fsanitize-blacklist", PathBuf, Concatenated('='), ExtraHashFile),
     take_arg!("-gcc-toolchain", OsString, Separated, PassThrough),
     take_arg!("-include-pch", PathBuf, CanBeSeparated, PreprocessorArgumentPath),
@@ -127,7 +128,7 @@ counted_array!(pub static ARGS: [ArgInfo<gcc::ArgData>; _] = [
     take_arg!("-plugin-arg", OsString, Concatenated('-'), PassThrough),
     take_arg!("-target", OsString, Separated, PassThrough),
     flag!("-verify", PreprocessorArgumentFlag),
-]);
+];
 
 #[cfg(test)]
 mod test {
@@ -403,4 +404,55 @@ mod test {
         let a = parses!("-c", "foo.c", "-o", "foo.o");
         assert_eq!(a.color_mode, ColorMode::Auto);
     }
+
+    #[test]
+    fn test_parse_arguments_profile_instr_use() {
+        let a = parses!(
+            "-c",
+            "foo.c",
+            "-o",
+            "foo.o",
+            "-fprofile-instr-use=foo.profdata"
+        );
+        assert_eq!(ovec!["-fprofile-instr-use=foo.profdata"], a.common_args);
+        assert_eq!(
+            ovec![std::env::current_dir().unwrap().join("foo.profdata")],
+            a.extra_hash_files
+        );
+    }
+
+    #[test]
+    fn test_parse_arguments_profile_use() {
+        let a = parses!(
+            "-c",
+            "foo.c",
+            "-o",
+            "foo.o",
+            "-fprofile-use=xyz.profdata"
+        );
+
+        assert_eq!(ovec!["-fprofile-use=xyz.profdata"], a.common_args);
+        assert_eq!(
+            ovec![std::env::current_dir().unwrap().join("xyz.profdata")],
+            a.extra_hash_files
+        );
+    }
+
+    #[test]
+    fn test_parse_arguments_profile_use_with_directory() {
+        let a = parses!(
+            "-c",
+            "foo.c",
+            "-o",
+            "foo.o",
+            "-fprofile-use=."
+        );
+
+        assert_eq!(ovec!["-fprofile-use=."], a.common_args);
+        assert_eq!(
+            ovec![std::env::current_dir().unwrap().join("default.profdata")],
+            a.extra_hash_files
+        );
+    }
+
 }

src/compiler/gcc.rs

@@ -46,7 +46,7 @@ impl CCompilerImpl for GCC {
         arguments: &[OsString],
         cwd: &Path,
     ) -> CompilerArguments<ParsedArguments> {
-        parse_arguments(arguments, cwd, &ARGS[..], self.gplusplus)
+        parse_arguments(arguments, cwd, &ARGS[..], self.gplusplus, CCompilerKind::GCC)
     }
 
     fn preprocess<T>(
@@ -119,6 +119,7 @@ ArgData! { pub
     Language(OsString),
     SplitDwarf,
     ProfileGenerate,
+    ProfileUse(PathBuf),
     TestCoverage,
     Coverage,
     ExtraHashFile(PathBuf),
@@ -169,7 +170,7 @@ counted_array!(pub static ARGS: [ArgInfo<ArgData>; _] = [
     flag!("-fplugin=libcc1plugin", TooHardFlag),
     flag!("-fprofile-arcs", ProfileGenerate),
     flag!("-fprofile-generate", ProfileGenerate),
-    take_arg!("-fprofile-use", OsString, Concatenated, TooHard),
+    take_arg!("-fprofile-use", PathBuf, Concatenated('='), ProfileUse),
     flag!("-frepo", TooHardFlag),
     flag!("-fsyntax-only", TooHardFlag),
     flag!("-ftest-coverage", TestCoverage),
@@ -214,6 +215,7 @@ pub fn parse_arguments<S>(
     cwd: &Path,
     arg_info: S,
     plusplus: bool,
+    compiler_kind: CCompilerKind,
 ) -> CompilerArguments<ParsedArguments>
 where
     S: SearchableArgInfo<ArgData>,
@@ -275,6 +277,14 @@ where
                     OsString::from(arg.flag_str().expect("Compilation flag expected"));
             }
             Some(ProfileGenerate) => profile_generate = true,
+            Some(ProfileUse(_)) => {
+                if compiler_kind != CCompilerKind::Clang {
+                    cannot_cache!(
+                        arg.flag_str().unwrap(),
+                        "only Clang supported".into()
+                    )
+                }
+            },
             Some(TestCoverage) => outputs_gcno = true,
             Some(Coverage) => {
                 outputs_gcno = true;
@@ -341,6 +351,20 @@ where
             | Some(Arch(_))
             | Some(PassThrough(_))
             | Some(PassThroughPath(_)) => &mut common_args,
+            Some(ProfileUse(path)) => {
+                debug_assert!(compiler_kind == CCompilerKind::Clang);
+
+                let mut path = cwd.join(path);
+
+                // Clang allows specifying a directory here, in which case it
+                // will look for the file `default.profdata` in that directory.
+                if path.is_dir() {
+                    path.push("default.profdata");
+                }
+
+                extra_hash_files.push(path);
+                &mut common_args
+            }
             Some(ExtraHashFile(path)) => {
                 extra_hash_files.push(cwd.join(path));
                 &mut common_args
@@ -376,6 +400,7 @@ where
         let args = match arg.get_data() {
             Some(SplitDwarf)
             | Some(ProfileGenerate)
+            | Some(ProfileUse(_))
             | Some(TestCoverage)
             | Some(Coverage)
             | Some(DoCompilation)
@@ -742,7 +767,7 @@ mod test {
         plusplus: bool,
     ) -> CompilerArguments<ParsedArguments> {
         let args = arguments.iter().map(OsString::from).collect::<Vec<_>>();
-        parse_arguments(&args, ".".as_ref(), &ARGS[..], plusplus)
+        parse_arguments(&args, ".".as_ref(), &ARGS[..], plusplus, CCompilerKind::GCC)
     }
 
     #[test]
@@ -1204,15 +1229,16 @@ mod test {
 
     #[test]
     fn test_parse_arguments_pgo() {
+        let only_clang_supported = || Some("only Clang supported".to_string());
         assert_eq!(
-            CompilerArguments::CannotCache("-fprofile-use", None),
+            CompilerArguments::CannotCache("-fprofile-use", only_clang_supported()),
             parse_arguments_(
                 stringvec!["-c", "foo.c", "-fprofile-use", "-o", "foo.o"],
                 false
             )
         );
         assert_eq!(
-            CompilerArguments::CannotCache("-fprofile-use", None),
+            CompilerArguments::CannotCache("-fprofile-use", only_clang_supported()),
             parse_arguments_(
                 stringvec!["-c", "foo.c", "-fprofile-use=file", "-o", "foo.o"],
                 false

src/compiler/msvc.rs

@@ -587,7 +587,7 @@ pub fn parse_arguments(
             let mut args = match arg.get_data() {
                 Some(SplitDwarf) | Some(TestCoverage) | Some(Coverage) | Some(DoCompilation)
                 | Some(Language(_)) | Some(Output(_)) | Some(TooHardFlag) | Some(XClang(_))
-                | Some(TooHard(_)) => cannot_cache!(arg
+                | Some(TooHard(_)) | Some(ProfileUse(_)) => cannot_cache!(arg
                     .flag_str()
                     .unwrap_or("Can't handle complex arguments through clang",)),
                 None => match arg {
@@ -605,6 +605,7 @@ pub fn parse_arguments(
                     profile_generate = true;
                     &mut common_args
                 }
+
                 Some(ExtraHashFile(path)) => {
                     extra_hash_files.push(cwd.join(path));
                     &mut common_args

src/compiler/nvcc.rs

@@ -47,7 +47,13 @@ impl CCompilerImpl for NVCC {
         arguments: &[OsString],
         cwd: &Path,
     ) -> CompilerArguments<ParsedArguments> {
-        gcc::parse_arguments(arguments, cwd, (&gcc::ARGS[..], &ARGS[..]), false)
+        gcc::parse_arguments(
+            arguments,
+            cwd,
+            (&gcc::ARGS[..], &ARGS[..]),
+            false,
+            CCompilerKind::NVCC
+        )
     }
 
     fn preprocess<T>(