From b5083221dad8084deb4a7949cb9fc487aa09e080 Mon Sep 17 00:00:00 2001
From: Boris Kolpackov <boris@codesynthesis.com>
Date: Tue, 16 Nov 2021 10:46:19 +0200
Subject: WIP: apply/perform_update

---
 libbuild2/cc/compile-rule.cxx | 65 ++-----------------------------------------
 1 file changed, 2 insertions(+), 63 deletions(-)

(limited to 'libbuild2/cc/compile-rule.cxx')

diff --git a/libbuild2/cc/compile-rule.cxx b/libbuild2/cc/compile-rule.cxx
index 87fce90..5a3ed95 100644
--- a/libbuild2/cc/compile-rule.cxx
+++ b/libbuild2/cc/compile-rule.cxx
@@ -775,69 +775,6 @@ namespace build2
       }
     }
 
-    // Update the target during the match phase. Return true if it has changed
-    // or if the passed timestamp is not timestamp_unknown and is older than
-    // the target.
-    //
-    // This function is used to make sure header dependencies are up to date.
-    //
-    // There would normally be a lot of headers for every source file (think
-    // all the system headers) and just calling execute_direct() on all of
-    // them can get expensive. At the same time, most of these headers are
-    // existing files that we will never be updating (again, system headers,
-    // for example) and the rule that will match them is the fallback
-    // file_rule. That rule has an optimization: it returns noop_recipe (which
-    // causes the target state to be automatically set to unchanged) if the
-    // file is known to be up to date. So we do the update "smartly".
-    //
-    static bool
-    update (tracer& trace, action a, const target& t, timestamp ts)
-    {
-      const path_target* pt (t.is_a<path_target> ());
-
-      if (pt == nullptr)
-        ts = timestamp_unknown;
-
-      target_state os (t.matched_state (a));
-
-      if (os == target_state::unchanged)
-      {
-        if (ts == timestamp_unknown)
-          return false;
-        else
-        {
-          // We expect the timestamp to be known (i.e., existing file).
-          //
-          timestamp mt (pt->mtime ());
-          assert (mt != timestamp_unknown);
-          return mt > ts;
-        }
-      }
-      else
-      {
-        // We only want to return true if our call to execute() actually
-        // caused an update. In particular, the target could already have been
-        // in target_state::changed because of a dependency extraction run for
-        // some other source file.
-        //
-        // @@ MT perf: so we are going to switch the phase and execute for
-        //    any generated header.
-        //
-        phase_switch ps (t.ctx, run_phase::execute);
-        target_state ns (execute_direct (a, t));
-
-        if (ns != os && ns != target_state::unchanged)
-        {
-          l6 ([&]{trace << "updated " << t
-                        << "; old state " << os
-                        << "; new state " << ns;});
-          return true;
-        }
-        else
-          return ts != timestamp_unknown ? pt->newer (ts, ns) : false;
-      }
-    }
-
     recipe compile_rule::
     apply (action a, target& xt) const
     {
@@ -1097,6 +1034,8 @@ namespace build2
           md.symexport = l ? cast<bool> (l) : symexport;
         }
 
+        // NOTE: see similar code in adhoc_buildscript_rule::apply().
+
         // Make sure the output directory exists.
         //
         // Is this the right thing to do? It does smell a bit, but then we do
-- 
cgit v1.1