got it working

trxcllnt · Aug 8, 2024 · 358c47c · 358c47c
1 parent ba71715
commit 358c47c
Show file tree

Hide file tree

Showing 16 changed files with 1,019 additions and 301 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -120,6 +120,7 @@ rouille = { version = "3.6", optional = true, default-features = false, features
 ] }
 syslog = { version = "6", optional = true }
 version-compare = { version = "0.1.1", optional = true }
+shlex = "=1.3.0"
 
 [dev-dependencies]
 assert_cmd = "2.0.13"

diff --git a/src/compiler/c.rs b/src/compiler/c.rs
@@ -197,15 +197,17 @@ pub trait CCompilerImpl: Clone + fmt::Debug + Send + Sync + 'static {
         T: CommandCreatorSync;
     /// Generate a command that can be used to invoke the C compiler to perform
     /// the compilation.
-    fn generate_compile_commands(
+    fn generate_compile_commands<T>(
         &self,
         path_transformer: &mut dist::PathTransformer,
         executable: &Path,
         parsed_args: &ParsedArguments,
         cwd: &Path,
         env_vars: &[(OsString, OsString)],
         rewrite_includes_only: bool,
-    ) -> Result<(CompileCommand, Option<dist::CompileCommand>, Cacheable)>;
+    ) -> Result<(Box<dyn CompileCommand<T>>, Option<dist::CompileCommand>, Cacheable)>
+    where
+        T: CommandCreatorSync;
 }
 
 impl<I> CCompiler<I>
@@ -362,7 +364,7 @@ where
         rewrite_includes_only: bool,
         storage: Arc<dyn Storage>,
         cache_control: CacheControl,
-    ) -> Result<HashResult> {
+    ) -> Result<HashResult<T>> {
         let start_of_compilation = std::time::SystemTime::now();
         let CCompilerHasher {
             parsed_args,
@@ -396,10 +398,36 @@ where
                 arg
             );
         }
+
+        let use_preprocessor_cache_mode = {
+            let can_use_preprocessor_cache_mode = !may_dist
+                && preprocessor_cache_mode_config.use_preprocessor_cache_mode
+                && !too_hard_for_preprocessor_cache_mode;
+
+            let mut use_preprocessor_cache_mode = can_use_preprocessor_cache_mode;
+
+            // Allow overrides from the env
+            for (key, val) in env_vars.iter() {
+                if key == "SCCACHE_DIRECT" {
+                    if let Some(val) = val.to_str() {
+                        use_preprocessor_cache_mode = match val.to_lowercase().as_str() {
+                            "false" | "off" | "0" => false,
+                            _ => can_use_preprocessor_cache_mode,
+                        };
+                    }
+                    break;
+                }
+            }
+
+            if can_use_preprocessor_cache_mode && !use_preprocessor_cache_mode {
+                debug!("parse_arguments: Disabling preprocessor cache because SCCACHE_DIRECT=false");
+            }
+
+            use_preprocessor_cache_mode
+        };
+
         // Disable preprocessor cache when doing distributed compilation
-        let mut preprocessor_key = if !may_dist
-            && preprocessor_cache_mode_config.use_preprocessor_cache_mode
-            && !too_hard_for_preprocessor_cache_mode
+        let mut preprocessor_key = if use_preprocessor_cache_mode
         {
             preprocessor_cache_entry_hash_key(
                 &executable_digest,
@@ -1113,12 +1141,12 @@ fn include_is_too_new(
     false
 }
 
-impl<I: CCompilerImpl> Compilation for CCompilation<I> {
+impl<T: CommandCreatorSync, I: CCompilerImpl> Compilation<T> for CCompilation<I> {
     fn generate_compile_commands(
         &self,
         path_transformer: &mut dist::PathTransformer,
         rewrite_includes_only: bool,
-    ) -> Result<(CompileCommand, Option<dist::CompileCommand>, Cacheable)> {
+    ) -> Result<(Box<dyn CompileCommand<T>>, Option<dist::CompileCommand>, Cacheable)> {
         let CCompilation {
             ref parsed_args,
             ref executable,

diff --git a/src/compiler/cicc.rs b/src/compiler/cicc.rs
@@ -16,7 +16,7 @@
 #![allow(unused_imports, dead_code, unused_variables)]
 
 use crate::compiler::args::*;
-use crate::compiler::{Cacheable, ColorMode, CompileCommand, CompilerArguments, Language};
+use crate::compiler::{Cacheable, ColorMode, CompileCommand, CCompileCommand, CompilerArguments, Language, SingleCompileCommand};
 use crate::compiler::c::{ArtifactDescriptor, CCompilerImpl, CCompilerKind, ParsedArguments};
 use crate::{counted_array, dist};
 
@@ -68,22 +68,30 @@ impl CCompilerImpl for Cicc {
         trace!("cicc preprocessed input file: cwd={:?} path={:?}", cwd, &parsed_args.input);
         preprocess(cwd, parsed_args).await
     }
-    fn generate_compile_commands(
+    fn generate_compile_commands<T>(
         &self,
         path_transformer: &mut dist::PathTransformer,
         executable: &Path,
         parsed_args: &ParsedArguments,
         cwd: &Path,
         env_vars: &[(OsString, OsString)],
         _rewrite_includes_only: bool,
-    ) -> Result<(CompileCommand, Option<dist::CompileCommand>, Cacheable)> {
+    ) -> Result<(Box<dyn CompileCommand<T>>, Option<dist::CompileCommand>, Cacheable)>
+    where
+        T: CommandCreatorSync,
+    {
         generate_compile_commands(
             path_transformer,
             executable,
             parsed_args,
             cwd,
             env_vars
         )
+        .map(|(command, dist_command, cacheable)| (
+            CCompileCommand::new(command),
+            dist_command,
+            cacheable
+        ))
     }
 }
 
@@ -204,7 +212,7 @@ pub fn generate_compile_commands(
     parsed_args: &ParsedArguments,
     cwd: &Path,
     env_vars: &[(OsString, OsString)],
-) -> Result<(CompileCommand, Option<dist::CompileCommand>, Cacheable)> {
+) -> Result<(SingleCompileCommand, Option<dist::CompileCommand>, Cacheable)> {
     // Unused arguments
     #[cfg(not(feature = "dist-client"))]
     {
@@ -228,7 +236,7 @@ pub fn generate_compile_commands(
         out_file.into()
     ]);
 
-    let command = CompileCommand {
+    let command = SingleCompileCommand {
         executable: executable.to_owned(),
         arguments,
         env_vars: env_vars.to_owned(),

diff --git a/src/compiler/clang.rs b/src/compiler/clang.rs
@@ -18,7 +18,7 @@ use crate::compiler::args::*;
 use crate::compiler::c::{ArtifactDescriptor, CCompilerImpl, CCompilerKind, ParsedArguments};
 use crate::compiler::gcc::ArgData::*;
 use crate::compiler::{
-    gcc, write_temp_file, Cacheable, CompileCommand, CompilerArguments, Language,
+    gcc, write_temp_file, Cacheable, CompileCommand, CCompileCommand, CompilerArguments, Language
 };
 use crate::mock_command::{CommandCreator, CommandCreatorSync, RunCommand};
 use crate::util::{run_input_output, OsStrExt};
@@ -144,15 +144,18 @@ impl CCompilerImpl for Clang {
         .await
     }
 
-    fn generate_compile_commands(
+    fn generate_compile_commands<T>(
         &self,
         path_transformer: &mut dist::PathTransformer,
         executable: &Path,
         parsed_args: &ParsedArguments,
         cwd: &Path,
         env_vars: &[(OsString, OsString)],
         rewrite_includes_only: bool,
-    ) -> Result<(CompileCommand, Option<dist::CompileCommand>, Cacheable)> {
+    ) -> Result<(Box<dyn CompileCommand<T>>, Option<dist::CompileCommand>, Cacheable)>
+    where
+        T: CommandCreatorSync
+    {
         gcc::generate_compile_commands(
             path_transformer,
             executable,
@@ -162,6 +165,11 @@ impl CCompilerImpl for Clang {
             self.kind(),
             rewrite_includes_only,
         )
+        .map(|(command, dist_command, cacheable)| (
+            CCompileCommand::new(command),
+            dist_command,
+            cacheable
+        ))
     }
 }