From 763a4684ebb7bcd058f6698e4f3a03c748e30e83 Mon Sep 17 00:00:00 2001
From: Daniel Paoliello <danpao@microsoft.com>
Date: Fri, 3 May 2024 15:39:09 -0700
Subject: [PATCH] Avoid recursive calls into try_get_compiler when items are in
 the cache

---
 src/lib.rs | 42 +++++++++++++++++++++++-------------------
 1 file changed, 23 insertions(+), 19 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 99c2fd9c8..22e3789b4 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -601,26 +601,12 @@ impl Build {
     /// `known_flag_support` field. If `is_flag_supported(flag)`
     /// is called again, the result will be read from the hash table.
     pub fn is_flag_supported(&self, flag: &str) -> Result<bool, Error> {
-        let target = self.get_target()?;
-
-        let mut compiler = {
-            let mut cfg = Build::new();
-            cfg.flag(flag)
-                .cargo_metadata(self.cargo_output.metadata)
-                .target(&target)
-                .opt_level(0)
-                .host(&self.get_host()?)
-                .debug(false)
-                .cpp(self.cpp)
-                .cuda(self.cuda);
-            if let Some(ref c) = self.compiler {
-                cfg.compiler(c.clone());
-            }
-            cfg.try_get_compiler()?
-        };
+        self.is_flag_supported_inner(flag, self.get_base_compiler()?.path())
+    }
 
+    fn is_flag_supported_inner(&self, flag: &str, compiler_path: &Path) -> Result<bool, Error> {
         let compiler_flag = CompilerFlag {
-            compiler: compiler.path.clone().into(),
+            compiler: compiler_path.into(),
             flag: flag.into(),
         };
 
@@ -637,6 +623,21 @@ impl Build {
         let out_dir = self.get_out_dir()?;
         let src = self.ensure_check_file()?;
         let obj = out_dir.join("flag_check");
+        let target = self.get_target()?;
+
+        let mut compiler = {
+            let mut cfg = Build::new();
+            cfg.flag(flag)
+                .compiler(compiler_path)
+                .cargo_metadata(self.cargo_output.metadata)
+                .target(&target)
+                .opt_level(0)
+                .host(&self.get_host()?)
+                .debug(false)
+                .cpp(self.cpp)
+                .cuda(self.cuda);
+            cfg.try_get_compiler()?
+        };
 
         // Clang uses stderr for verbose output, which yields a false positive
         // result if the CFLAGS/CXXFLAGS include -v to aid in debugging.
@@ -1805,7 +1806,10 @@ impl Build {
         }
 
         for flag in self.flags_supported.iter() {
-            if self.is_flag_supported(flag).unwrap_or(false) {
+            if self
+                .is_flag_supported_inner(flag, &cmd.path)
+                .unwrap_or(false)
+            {
                 cmd.push_cc_arg((**flag).into());
             }
         }