WIP: apply/perform_update

9 files changed, 845 insertions, 360 deletions

diff --git a/libbuild2/adhoc-rule-buildscript.cxx b/libbuild2/adhoc-rule-buildscript.cxx
index 61b4cb2..aa320e2 100644
--- a/libbuild2/adhoc-rule-buildscript.cxx
+++ b/libbuild2/adhoc-rule-buildscript.cxx
@@ -9,6 +9,7 @@
 #include <libbuild2/scope.hxx>
 #include <libbuild2/target.hxx>
 #include <libbuild2/context.hxx>
+#include <libbuild2/dynamic.hxx>
 #include <libbuild2/algorithm.hxx>
 #include <libbuild2/filesystem.hxx>  // path_perms(), auto_rmfile
 #include <libbuild2/diagnostics.hxx>
@@ -22,6 +23,110 @@ using namespace std;
 
 namespace build2
 {
+  static inline void
+  hash_script_vars (sha256& cs,
+                    const build::script::script& s,
+                    const target& t,
+                    names& storage)
+  {
+    context& ctx (t.ctx);
+
+    for (const string& n: s.vars)
+    {
+      cs.append (n);
+
+      lookup l;
+
+      if (const variable* var = ctx.var_pool.find (n))
+        l = t[var];
+
+      cs.append (!l.defined () ? '\x1' : l->null ? '\x2' : '\x3');
+
+      if (l)
+      {
+        storage.clear ();
+        names_view ns (reverse (*l, storage));
+
+        for (const name& n: ns)
+          to_checksum (cs, n);
+      }
+    }
+  }
+
+  // How should we hash target and prerequisite sets ($> and $<)? We could
+  // hash them as target names (i.e., the same as the $>/< content) or as
+  // paths (only for path-based targets). While names feel more general, they
+  // are also more expensive to compute. And for path-based targets, path is
+  // generally a good proxy for the target name. Since the bulk of the ad hoc
+  // recipes will presumably be operating exclusively on path-based targets,
+  // let's do it both ways.
+  //
+  static inline void
+  hash_target (sha256& cs, const target& t, names& storage)
+  {
+    if (const path_target* pt = t.is_a<path_target> ())
+      cs.append (pt->path ().string ());
+    else
+    {
+      storage.clear ();
+      t.as_name (storage);
+      for (const name& n: storage)
+        to_checksum (cs, n);
+    }
+  };
+
+  // The script can reference a program in one of four ways:
+  //
+  // 1. As an (imported) target (e.g., $cli)
+  //
+  // 2. As a process_path_ex (e.g., $cxx.path).
+  //
+  // 3. As a builtin (e.g., sed)
+  //
+  // 4. As a program path/name.
+  //
+  // When it comes to change tracking, there is nothing we can do for (4) (the
+  // user can track its environment manually with depdb-env) and there is
+  // nothing to do for (3) (assuming builtin semantics is stable/backwards-
+  // compatible). The (2) case is handled automatically by hashing all the
+  // variable values referenced by the script (see below), which in case of
+  // process_path_ex includes the checksums (both executable and environment),
+  // if available.
+  //
+  // This leaves the (1) case, which itself splits into two sub-cases: the
+  // target comes with the dependency information (e.g., imported from a
+  // project via an export stub) or it does not (e.g., imported as installed).
+  // We don't need to do anything extra for the first sub-case since the
+  // target's state/mtime can be relied upon like any other prerequisite.
+  // Which cannot be said about the second sub-case, where we reply on
+  // checksum that may be included as part of the target metadata.
+  //
+  // So what we are going to do is hash checksum metadata of every executable
+  // prerequisite target that has it (we do it here in order to include ad hoc
+  // prerequisites, which feels like the right thing to do; the user may mark
+  // tools as ad hoc in order to omit them from $<).
+  //
+  static inline void
+  hash_prerequisite_target (sha256& cs, sha256& exe_cs, sha256& env_cs,
+                            const target& pt,
+                            names& storage)
+  {
+    hash_target (cs, pt, storage);
+
+    if (const exe* et = pt.is_a<exe> ())
+    {
+      if (const string* c = et->lookup_metadata<string> ("checksum"))
+      {
+        exe_cs.append (*c);
+      }
+
+      if (const strings* e = et->lookup_metadata<strings> ("environment"))
+      {
+        hash_environment (env_cs, *e);
+      }
+    }
+  }
+
   bool adhoc_buildscript_rule::
   recipe_text (const scope& s,
                const target_type& tt,
@@ -113,6 +218,19 @@ namespace build2
             perform_update_id) != actions.end ();
   }
 
+  struct adhoc_buildscript_rule::match_data
+  {
+    match_data (action a, const target& t, bool temp_dir)
+        : env (a, t, temp_dir) {}
+
+    build::script::environment env;
+    build::script::default_runner run;
+
+    const scope* bs;
+    timestamp mt;
+    path dd;
+  };
+
   bool adhoc_buildscript_rule::
   match (action a, target& t, const string& h, match_extra& me) const
   {
@@ -140,15 +258,17 @@ namespace build2
 
   recipe adhoc_buildscript_rule::
   apply (action a,
-         target& t,
+         target& xt,
          match_extra& me,
          const optional<timestamp>& d) const
   {
+    tracer trace ("adhoc_buildscript_rule::apply");
+
     // We don't support deadlines for any of these cases (see below).
     //
     if (d && (a.outer ()  ||
               me.fallback ||
-              (a == perform_update_id && t.is_a<file> ())))
+              (a == perform_update_id && xt.is_a<file> ())))
       return empty_recipe;
 
     // If this is an outer operation (e.g., update-for-test), then delegate to
@@ -156,20 +276,20 @@ namespace build2
     //
     if (a.outer ())
     {
-      match_inner (a, t);
+      match_inner (a, xt);
       return execute_inner;
     }
 
     // Inject pattern's ad hoc group members, if any.
     //
     if (pattern != nullptr)
-      pattern->apply_adhoc_members (a, t, me);
+      pattern->apply_adhoc_members (a, xt, me);
 
     // Derive file names for the target and its ad hoc group members, if any.
     //
     if (a == perform_update_id || a == perform_clean_id)
     {
-      for (target* m (&t); m != nullptr; m = m->adhoc_member)
+      for (target* m (&xt); m != nullptr; m = m->adhoc_member)
       {
         if (auto* p = m->is_a<path_target> ())
           p->derive_path ();
@@ -181,68 +301,297 @@ namespace build2
     // We do it always instead of only if one of the targets is path-based in
     // case the recipe creates temporary files or some such.
     //
-    inject_fsdir (a, t);
+    const fsdir* dir (inject_fsdir (a, xt));
 
     // Match prerequisites.
     //
-    match_prerequisite_members (a, t);
+    match_prerequisite_members (a, xt);
 
     // Inject pattern's prerequisites, if any.
     //
     if (pattern != nullptr)
-      pattern->apply_prerequisites (a, t, me);
+      pattern->apply_prerequisites (a, xt, me);
 
     // See if we are providing the standard clean as a fallback.
     //
     if (me.fallback)
       return &perform_clean_depdb;
 
-    if (a == perform_update_id && t.is_a<file> ())
+    // See if this is not update or not on a file-based target.
+    //
+    if (a != perform_update_id || !xt.is_a<file> ())
+    {
+      return [d, this] (action a, const target& t)
+      {
+        return default_action (a, t, d);
+      };
+    }
+
+    // See if this is the simple case with only static dependencies.
+    //
+    if (!script.depdb_pre_dynamic)
     {
       return [this] (action a, const target& t)
       {
-        return perform_update_file (a, t);
+        return perform_update_file_static (a, t);
       };
     }
+
+    // This is a perform update on a file target with extraction of dynamic
+    // dependency information in the depdb preamble (depdb-pre-dynamic).
+    //
+    // This means we may need to add additional prerequisites (or even target
+    // group members). We also have to save any such additional prerequisites
+    // in depdb so that we can check if any of them have changed on subsequent
+    // updates. So all this means that have to take care of depdb here in
+    // apply() instead of perform_*() like we normally do. We also do things
+    // in slightly different order due to the restrictions impose by the match
+    // phase.
+    //
+    // Note that the C/C++ header dependency extraction is the canonical
+    // example and all this logic is based on the prior work in the cc module
+    // where you can often find more detailed rationale for some of the steps
+    // performed (like the fsdir update below).
+    //
+    context& ctx (xt.ctx);
+
+    const file& t (xt.as<file> ());
+    const path& tp (t.path ());
+
+    if (dir != nullptr)
+      fsdir_rule::perform_update_direct (a, t);
+
+    // Because the depdb preamble can access $<, we have to blank out all the
+    // ad hoc prerequisites. Since we will still need them later, we "move"
+    // them to the auxiliary data member in prerequisite_target (which also
+    // means we cannot use the standard execute_prerequisites()).
+    //
+    auto& pts (t.prerequisite_targets[a]);
+    for (prerequisite_target& p: pts)
+    {
+      if (p.target != nullptr && p.adhoc)
+      {
+        // Blank out injected fsdir{} for good.
+        //
+        if (p.target != dir)
+          p.data = reinterpret_cast<uintptr_t> (p.target);
+      }
+    }
+
+    // NOTE: see the "static dependencies" version (with comments) below.
+    //
+    depdb dd (tp + ".d");
+
+    if (dd.expect ("<ad hoc buildscript recipe> 1") != nullptr)
+      l4 ([&]{trace << "rule mismatch forcing update of " << t;});
+
+    if (dd.expect (checksum) != nullptr)
+      l4 ([&]{trace << "recipe text change forcing update of " << t;});
+
+    if (!script.depdb_clear)
+    {
+      names storage;
+
+      sha256 prq_cs, exe_cs, env_cs;
+
+      for (const prerequisite_target& p: pts)
+      {
+        if (const target* pt =
+            (p.target != nullptr ? p.target :
+             p.data   != 0       ? reinterpret_cast<target*> (p.data) :
+             nullptr))
+        {
+          hash_prerequisite_target (prq_cs, exe_cs, env_cs, *pt, storage);
+        }
+      }
+
+      {
+        sha256 cs;
+        hash_script_vars (cs, script, t, storage);
+
+        if (dd.expect (cs.string ()) != nullptr)
+          l4 ([&]{trace << "recipe variable change forcing update of " << t;});
+      }
+
+      {
+        sha256 tcs;
+        for (const target* m (&t); m != nullptr; m = m->adhoc_member)
+          hash_target (tcs, *m, storage);
+
+        if (dd.expect (tcs.string ()) != nullptr)
+          l4 ([&]{trace << "target set change forcing update of " << t;});
+
+        if (dd.expect (prq_cs.string ()) != nullptr)
+          l4 ([&]{trace << "prerequisite set change forcing update of " << t;});
+      }
+
+      {
+        if (dd.expect (exe_cs.string ()) != nullptr)
+          l4 ([&]{trace << "program checksum change forcing update of " << t;});
+
+        if (dd.expect (env_cs.string ()) != nullptr)
+          l4 ([&]{trace << "environment change forcing update of " << t;});
+      }
+    }
+
+    const scope& bs (t.base_scope ());
+
+    unique_ptr<match_data> md (
+      new match_data (a, t, script.depdb_preamble_temp_dir));
+
+    build::script::environment& env (md->env);
+    build::script::default_runner& run (md->run);
+
+    run.enter (env, script.start_loc);
+
+    // Run the first half of the preamble (before depdb-pre-dynamic).
+    //
+    {
+      build::script::parser p (ctx);
+      p.execute_depdb_preamble (bs, env, script, run, dd);
+    }
+
+    // Determine if we need to do an update based on the above checks.
+    //
+    bool update;
+    timestamp mt;
+
+    if (dd.writing ())
+      update = true;
     else
     {
-      return [d, this] (action a, const target& t)
+      if ((mt = t.mtime ()) == timestamp_unknown)
+        t.mtime (mt = mtime (tp)); // Cache.
+
+      update = dd.mtime > mt;
+    }
+
+    if (update)
+      mt = timestamp_nonexistent;
+
+    // Update our prerequisite targets. While strictly speaking we only need
+    // to update those that are referenced by depdb-pre-dynamic, communicating
+    // this is both tedious and error-prone. So we update them all.
+    //
+    for (const prerequisite_target& p: pts)
+    {
+      if (const target* pt =
+          (p.target != nullptr ? p.target :
+           p.data   != 0       ? reinterpret_cast<target*> (p.data) : nullptr))
       {
-        return default_action (a, t, d);
-      };
+        update = dyndep_rule::update (
+          trace, a, *pt, update ? timestamp_unknown : mt) || update;
+      }
     }
+
+    // Run the second half of the preamble (depdb-pre-dynamic commands) to
+    // extract dynamic dependencies.
+    //
+    // Note that this should be the last update to depdb (the invalidation
+    // order semantics).
+    {
+      build::script::parser p (ctx);
+      p.execute_depdb_preamble_dynamic (bs, env, script, run, dd, update, mt);
+    }
+
+    if (update && dd.reading () && !ctx.dry_run)
+      dd.touch = true;
+
+    dd.close ();
+    md->dd = move (dd.path);
+
+    // Pass on base scope and update/mtime.
+    //
+    md->bs = &bs;
+    md->mt = update ? timestamp_nonexistent : mt;
+
+    // @@ TMP: re-enable once recipe becomes move_only_function.
+    //
+#if 0
+    return [this, md = move (md)] (action a, const target& t) mutable
+    {
+      auto r (perform_update_file_dynamic (a, t, *md));
+      md.reset (); // @@ TMP: is this really necessary (+mutable)?
+      return r;
+    };
+#else
+    t.data (move (md));
+    return recipe ([this] (action a, const target& t) mutable
+    {
+      auto md (move (t.data<unique_ptr<match_data>> ()));
+      return perform_update_file_dynamic (a, t, *md);
+    });
+#endif
   }
 
   target_state adhoc_buildscript_rule::
-  perform_update_file (action a, const target& xt) const
+  perform_update_file_dynamic (action a, const target& xt,
+                               match_data& md) const
   {
-    tracer trace ("adhoc_buildscript_rule::perform_update_file");
+    tracer trace ("adhoc_buildscript_rule::perform_update_file_dynamic");
 
     context& ctx (xt.ctx);
 
     const file& t (xt.as<file> ());
     const path& tp (t.path ());
 
-    // How should we hash target and prerequisite sets ($> and $<)? We could
-    // hash them as target names (i.e., the same as the $>/< content) or as
-    // paths (only for path-based targets). While names feel more general,
-    // they are also more expensive to compute. And for path-based targets,
-    // path is generally a good proxy for the target name. Since the bulk of
-    // the ad hoc recipes will presumably be operating exclusively on
-    // path-based targets, let's do it both ways.
+    // While we've updated all our prerequisites in apply(), we still need to
+    // execute them here to keep the dependency counts straight.
     //
-    auto hash_target = [ns = names ()] (sha256& cs, const target& t) mutable
+    for (const prerequisite_target& p: t.prerequisite_targets[a])
     {
-      if (const path_target* pt = t.is_a<path_target> ())
-        cs.append (pt->path ().string ());
-      else
+      if (const target* pt =
+          (p.target != nullptr ? p.target :
+           p.data   != 0       ? reinterpret_cast<target*> (p.data) : nullptr))
       {
-        ns.clear ();
-        t.as_name (ns);
-        for (const name& n: ns)
-          to_checksum (cs, n);
+        target_state ts (execute (a, *pt));
+        assert (ts == target_state::unchanged || ts == target_state::changed);
       }
-    };
+    }
+
+    build::script::environment& env (md.env);
+    build::script::default_runner& run (md.run);
+
+    if (md.mt != timestamp_nonexistent)
+    {
+      run.leave (env, script.end_loc);
+      return target_state::unchanged;
+    }
+
+    // Sequence start time for mtime checks below.
+    //
+    timestamp start (!ctx.dry_run && depdb::mtime_check ()
+                     ? system_clock::now ()
+                     : timestamp_unknown);
+
+    if (!ctx.dry_run || verb != 0)
+    {
+      if (execute_update_file (*md.bs, a, t, env, run))
+        ;
+      else
+        run.leave (env, script.end_loc);
+    }
+    else
+      run.leave (env, script.end_loc);
+
+    timestamp now (system_clock::now ());
+
+    if (!ctx.dry_run)
+      depdb::check_mtime (start, md.dd, tp, now);
+
+    t.mtime (now);
+    return target_state::changed;
+  }
+
+  target_state adhoc_buildscript_rule::
+  perform_update_file_static (action a, const target& xt) const
+  {
+    tracer trace ("adhoc_buildscript_rule::perform_update_file_static");
+
+    context& ctx (xt.ctx);
+
+    const file& t (xt.as<file> ());
+    const path& tp (t.path ());
 
     // Update prerequisites and determine if any of them render this target
     // out-of-date.
@@ -250,6 +599,8 @@ namespace build2
     timestamp mt (t.load_mtime ());
     optional<target_state> ps;
 
+    names storage;
+
     sha256 prq_cs, exe_cs, env_cs;
     {
       // This is essentially ps=execute_prerequisites(a, t, mt) which we
@@ -262,7 +613,9 @@ namespace build2
 
       wait_guard wg (ctx, busy, t[a].task_count);
 
-      for (const target*& pt: t.prerequisite_targets[a])
+      auto& pts (t.prerequisite_targets[a]);
+
+      for (const target*& pt: pts)
       {
         if (pt == nullptr) // Skipped.
           continue;
@@ -279,7 +632,7 @@ namespace build2
       wg.wait ();
 
       bool e (mt == timestamp_nonexistent);
-      for (prerequisite_target& p: t.prerequisite_targets[a])
+      for (prerequisite_target& p: pts)
       {
         if (p == nullptr)
           continue;
@@ -318,56 +671,10 @@ namespace build2
         // As part of this loop calculate checksums that need to include ad
         // hoc prerequisites (unless the script tracks changes itself).
         //
-        if (script.depdb_clear)
-          continue;
-
-        hash_target (prq_cs, pt);
-
-        // The script can reference a program in one of four ways:
-        //
-        // 1. As an (imported) target (e.g., $cli)
+        // @@ TODO: skip fsdir{}?
         //
-        // 2. As a process_path_ex (e.g., $cxx.path).
-        //
-        // 3. As a builtin (e.g., sed)
-        //
-        // 4. As a program path/name.
-        //
-        // When it comes to change tracking, there is nothing we can do for
-        // (4) (the user can track its environment manually with depdb-env)
-        // and there is nothing to do for (3) (assuming builtin semantics is
-        // stable/backwards-compatible). The (2) case is handled automatically
-        // by hashing all the variable values referenced by the script (see
-        // below), which in case of process_path_ex includes the checksums
-        // (both executable and environment), if available.
-        //
-        // This leaves the (1) case, which itself splits into two sub-cases:
-        // the target comes with the dependency information (e.g., imported
-        // from a project via an export stub) or it does not (e.g., imported
-        // as installed). We don't need to do anything extra for the first
-        // sub-case since the target's state/mtime can be relied upon like any
-        // other prerequisite. Which cannot be said about the second sub-case,
-        // where we reply on checksum that may be included as part of the
-        // target metadata.
-        //
-        // So what we are going to do is hash checksum metadata of every
-        // executable prerequisite target that has it (we do it here in order
-        // to include ad hoc prerequisites, which feels like the right thing
-        // to do; the user may mark tools as ad hoc in order to omit them from
-        // $<).
-        //
-        if (auto* et = pt.is_a<exe> ())
-        {
-          if (auto* c = et->lookup_metadata<string> ("checksum"))
-          {
-            exe_cs.append (*c);
-          }
-
-          if (auto* e = et->lookup_metadata<strings> ("environment"))
-          {
-            hash_environment (env_cs, *e);
-          }
-        }
+        if (!script.depdb_clear)
+          hash_prerequisite_target (prq_cs, exe_cs, env_cs, pt, storage);
       }
 
       if (!e)
@@ -379,6 +686,8 @@ namespace build2
     // We use depdb to track changes to the script itself, input/output file
     // names, tools, etc.
     //
+    // NOTE: see the "dynamic dependencies" version above.
+    //
     depdb dd (tp + ".d");
 
     // First should come the rule name/version.
@@ -411,76 +720,53 @@ namespace build2
       l4 ([&]{trace << "recipe text change forcing update of " << t;});
 
     // Track the variables, targets, and prerequisites changes, unless the
-    // script doesn't track the dependency changes itself.
-    //
-
-    // For each variable hash its name, undefined/null/non-null indicator,
-    // and the value if non-null.
-    //
-    // Note that this excludes the special $< and $> variables which we
-    // handle below.
-    //
-    // @@ TODO: maybe detect and decompose process_path_ex in order to
-    //    properly attribute checksum and environment changes?
+    // script tracks the dependency changes itself.
     //
     if (!script.depdb_clear)
     {
-      sha256 cs;
-      names storage;
-
-      for (const string& n: script.vars)
+      // For each variable hash its name, undefined/null/non-null indicator,
+      // and the value if non-null.
+      //
+      // Note that this excludes the special $< and $> variables which we
+      // handle below.
+      //
+      // @@ TODO: maybe detect and decompose process_path_ex in order to
+      //    properly attribute checksum and environment changes?
+      //
       {
-        cs.append (n);
+        sha256 cs;
+        hash_script_vars (cs, script, t, storage);
 
-        lookup l;
-
-        if (const variable* var = ctx.var_pool.find (n))
-          l = t[var];
-
-        cs.append (!l.defined () ? '\x1' : l->null ? '\x2' : '\x3');
-
-        if (l)
-        {
-          storage.clear ();
-          names_view ns (reverse (*l, storage));
-
-          for (const name& n: ns)
-            to_checksum (cs, n);
-        }
+        if (dd.expect (cs.string ()) != nullptr)
+          l4 ([&]{trace << "recipe variable change forcing update of " << t;});
       }
 
-      if (dd.expect (cs.string ()) != nullptr)
-        l4 ([&]{trace << "recipe variable change forcing update of " << t;});
-    }
-
-    // Target and prerequisite sets ($> and $<).
-    //
-    if (!script.depdb_clear)
-    {
-      sha256 tcs;
-      for (const target* m (&t); m != nullptr; m = m->adhoc_member)
-        hash_target (tcs, *m);
+      // Target and prerequisite sets ($> and $<).
+      //
+      {
+        sha256 tcs;
+        for (const target* m (&t); m != nullptr; m = m->adhoc_member)
+          hash_target (tcs, *m, storage);
 
-      if (dd.expect (tcs.string ()) != nullptr)
-        l4 ([&]{trace << "target set change forcing update of " << t;});
+        if (dd.expect (tcs.string ()) != nullptr)
+          l4 ([&]{trace << "target set change forcing update of " << t;});
 
-      if (dd.expect (prq_cs.string ()) != nullptr)
-        l4 ([&]{trace << "prerequisite set change forcing update of " << t;});
-    }
+        if (dd.expect (prq_cs.string ()) != nullptr)
+          l4 ([&]{trace << "prerequisite set change forcing update of " << t;});
+      }
 
-    // Finally the programs and environment checksums.
-    //
-    if (!script.depdb_clear)
-    {
-      if (dd.expect (exe_cs.string ()) != nullptr)
-        l4 ([&]{trace << "program checksum change forcing update of " << t;});
+      // Finally the programs and environment checksums.
+      //
+      {
+        if (dd.expect (exe_cs.string ()) != nullptr)
+          l4 ([&]{trace << "program checksum change forcing update of " << t;});
 
-      if (dd.expect (env_cs.string ()) != nullptr)
-        l4 ([&]{trace << "environment change forcing update of " << t;});
+        if (dd.expect (env_cs.string ()) != nullptr)
+          l4 ([&]{trace << "environment change forcing update of " << t;});
+      }
     }
 
     const scope* bs (nullptr);
-    const scope* rs (nullptr);
 
     // Execute the custom dependency change tracking commands, if present.
     //
@@ -507,20 +793,19 @@ namespace build2
     }
 
     build::script::environment env (a, t, false /* temp_dir */);
-    build::script::default_runner r;
+    build::script::default_runner run;
 
     if (depdb_preamble)
     {
       bs = &t.base_scope ();
-      rs = bs->root_scope ();
 
       if (script.depdb_preamble_temp_dir)
         env.set_temp_dir_variable ();
 
       build::script::parser p (ctx);
 
-      r.enter (env, script.start_loc);
-      p.execute_depdb_preamble (*rs, *bs, env, script, r, dd);
+      run.enter (env, script.start_loc);
+      p.execute_depdb_preamble (*bs, env, script, run, dd);
     }
 
     // Update if depdb mismatch.
@@ -539,104 +824,118 @@ namespace build2
       // below).
       //
       if (depdb_preamble)
-        r.leave (env, script.end_loc);
+        run.leave (env, script.end_loc);
 
       return *ps;
     }
 
     if (!ctx.dry_run || verb != 0)
     {
-      // Prepare to executing the script diag line and/or body.
-      //
-      // Note that it doesn't make much sense to use the temporary directory
-      // variable ($~) in the 'diag' builtin call, so we postpone setting it
-      // until the script body execution, that can potentially be omitted.
+      // Prepare to execute the script diag line and/or body.
       //
       if (bs == nullptr)
-      {
         bs = &t.base_scope ();
-        rs = bs->root_scope ();
+
+      if (execute_update_file (*bs, a, t, env, run))
+      {
+        if (!ctx.dry_run)
+          dd.check_mtime (tp);
       }
+      else if (depdb_preamble)
+        run.leave (env, script.end_loc);
+    }
+    else if (depdb_preamble)
+      run.leave (env, script.end_loc);
 
-      build::script::parser p (ctx);
+    t.mtime (system_clock::now ());
+    return target_state::changed;
+  }
 
-      if (verb == 1)
+  bool adhoc_buildscript_rule::
+  execute_update_file (const scope& bs,
+                       action, const file& t,
+                       build::script::environment& env,
+                       build::script::default_runner& run) const
+  {
+    context& ctx (t.ctx);
+
+    // Note that it doesn't make much sense to use the temporary directory
+    // variable ($~) in the 'diag' builtin call, so we postpone setting it
+    // until the script body execution, that can potentially be omitted.
+    //
+    build::script::parser p (ctx);
+
+    if (verb == 1)
+    {
+      if (script.diag_line)
       {
-        if (script.diag_line)
-        {
-          text << p.execute_special (*rs, *bs, env, *script.diag_line);
-        }
-        else
-        {
-          // @@ TODO (and below):
-          //
-          // - we are printing target, not source (like in most other places)
-          //
-          // - printing of ad hoc target group (the {hxx cxx}{foo} idea)
-          //
-          // - if we are printing prerequisites, should we print all of them
-          //   (including tools)?
-          //
-          text << *script.diag_name << ' ' << t;
-        }
+        text << p.execute_special (bs, env, *script.diag_line);
       }
-
-      if (!ctx.dry_run || verb >= 2)
+      else
       {
-        // On failure remove the target files that may potentially exist but
-        // be invalid.
+        // @@ TODO (and in default_action() below):
         //
-        small_vector<auto_rmfile, 8> rms;
+        // - we are printing target, not source (like in most other places)
+        //
+        // - printing of ad hoc target group (the {hxx cxx}{foo} idea)
+        //
+        // - if we are printing prerequisites, should we print all of them
+        //   (including tools)?
+        //
+        text << *script.diag_name << ' ' << t;
+      }
+    }
 
-        if (!ctx.dry_run)
+    if (!ctx.dry_run || verb >= 2)
+    {
+      // On failure remove the target files that may potentially exist but
+      // be invalid.
+      //
+      small_vector<auto_rmfile, 8> rms;
+
+      if (!ctx.dry_run)
+      {
+        for (const target* m (&t); m != nullptr; m = m->adhoc_member)
         {
-          for (const target* m (&t); m != nullptr; m = m->adhoc_member)
-          {
-            if (auto* f = m->is_a<file> ())
-              rms.emplace_back (f->path ());
-          }
+          if (auto* f = m->is_a<file> ())
+            rms.emplace_back (f->path ());
         }
+      }
 
-        if (script.body_temp_dir && !script.depdb_preamble_temp_dir)
-          env.set_temp_dir_variable ();
+      if (script.body_temp_dir && !script.depdb_preamble_temp_dir)
+        env.set_temp_dir_variable ();
 
-        p.execute_body (*rs, *bs, env, script, r, !depdb_preamble);
+      p.execute_body (bs, env, script, run, script.depdb_preamble.empty ());
 
-        if (!ctx.dry_run)
-        {
-          // If this is an executable, let's be helpful to the user and set
-          // the executable bit on POSIX.
-          //
+      if (!ctx.dry_run)
+      {
+        // If this is an executable, let's be helpful to the user and set
+        // the executable bit on POSIX.
+        //
 #ifndef _WIN32
-          auto chmod = [] (const path& p)
-          {
-            path_perms (p,
-                        (path_perms (p)  |
-                         permissions::xu |
-                         permissions::xg |
-                         permissions::xo));
-          };
-
-          for (const target* m (&t); m != nullptr; m = m->adhoc_member)
-          {
-            if (auto* p = m->is_a<exe> ())
-              chmod (p->path ());
-          }
-#endif
-          dd.check_mtime (tp);
-
-          for (auto& rm: rms)
-            rm.cancel ();
+        auto chmod = [] (const path& p)
+        {
+          path_perms (p,
+                      (path_perms (p)  |
+                       permissions::xu |
+                       permissions::xg |
+                       permissions::xo));
+        };
+
+        for (const target* m (&t); m != nullptr; m = m->adhoc_member)
+        {
+          if (auto* p = m->is_a<exe> ())
+            chmod (p->path ());
         }
+#endif
+        for (auto& rm: rms)
+          rm.cancel ();
       }
-      else if (depdb_preamble)
-        r.leave (env, script.end_loc);
-    }
-    else if (depdb_preamble)
-      r.leave (env, script.end_loc);
 
-    t.mtime (system_clock::now ());
-    return target_state::changed;
+      return true;
+    }
+    else
+      return false;
   }
 
   target_state adhoc_buildscript_rule::
@@ -653,7 +952,6 @@ namespace build2
     if (!ctx.dry_run || verb != 0)
     {
       const scope& bs (t.base_scope ());
-      const scope& rs (*bs.root_scope ());
 
       build::script::environment e (a, t, script.body_temp_dir, deadline);
       build::script::parser p (ctx);
@@ -662,11 +960,11 @@ namespace build2
       {
         if (script.diag_line)
         {
-          text << p.execute_special (rs, bs, e, *script.diag_line);
+          text << p.execute_special (bs, e, *script.diag_line);
         }
         else
         {
-          // @@ TODO: as above
+          // @@ TODO: as above (execute_update_file()).
           //
           text << *script.diag_name << ' ' << t;
         }
@@ -675,7 +973,7 @@ namespace build2
       if (!ctx.dry_run || verb >= 2)
       {
         build::script::default_runner r;
-        p.execute_body (rs, bs, e, script, r);
+        p.execute_body (bs, e, script, r);
       }
     }
 
diff --git a/libbuild2/adhoc-rule-buildscript.hxx b/libbuild2/adhoc-rule-buildscript.hxx
index 7f9c10a..7ec647b 100644
--- a/libbuild2/adhoc-rule-buildscript.hxx
+++ b/libbuild2/adhoc-rule-buildscript.hxx
@@ -36,7 +36,18 @@ namespace build2
            const optional<timestamp>&) const override;
 
     target_state
-    perform_update_file (action, const target&) const;
+    perform_update_file_static (action, const target&) const;
+
+    struct match_data;
+
+    target_state
+    perform_update_file_dynamic (action, const target&, match_data&) const;
+
+    bool
+    execute_update_file (const scope&,
+                         action a, const file&,
+                         build::script::environment&,
+                         build::script::default_runner&) const;
 
     target_state
     default_action (action, const target&, const optional<timestamp>&) const;
diff --git a/libbuild2/build/script/parser.cxx b/libbuild2/build/script/parser.cxx
index 0d0ad0a..c6d7d49 100644
--- a/libbuild2/build/script/parser.cxx
+++ b/libbuild2/build/script/parser.cxx
@@ -5,6 +5,7 @@
 
 #include <libbutl/builtin.hxx>
 
+#include <libbuild2/depdb.hxx>
 #include <libbuild2/function.hxx>
 #include <libbuild2/algorithm.hxx>
 
@@ -128,6 +129,8 @@ namespace build2
         // Save the custom dependency change tracking lines, if present.
         //
         s.depdb_clear = depdb_clear_.has_value ();
+        if (depdb_pre_dynamic_)
+          s.depdb_pre_dynamic = depdb_pre_dynamic_->second;
         s.depdb_preamble = move (depdb_preamble_);
 
         return s;
@@ -494,7 +497,7 @@ namespace build2
                  v != "hash"   &&
                  v != "string" &&
                  v != "env"    &&
-                 v != "dep"))
+                 v != "pre-dynamic"))
             {
               fail (get_location (t))
                 << "expected 'depdb' builtin command instead of " << t;
@@ -534,32 +537,34 @@ namespace build2
               // the referenced variable list, since it won't be used.
               //
               depdb_clear_ = l;
-              save_line_   = nullptr;
+              save_line_ = nullptr;
 
               script_->vars.clear ();
             }
             else
             {
-              // Verify depdb-dep is last.
+              // Verify depdb-pre-dynamic is last.
               //
-              if (v == "dep")
+              if (v == "pre-dynamic")
               {
-                // Note that for now we do not allow multiple depdb-dep calls.
-                // But we may wan to relax this later (though alternating
-                // targets with prerequisites may be tricky -- maybe still
-                // only allow additional targets in the first call).
+                // Note that for now we do not allow multiple pre-dynamic
+                // calls. But we may wan to relax this later (though
+                // alternating targets with prerequisites may be tricky --
+                // maybe still only allow additional targets in the first
+                // call).
                 //
-                if (!depdb_dep_)
-                  depdb_dep_ = l;
+                if (!depdb_pre_dynamic_)
+                  depdb_pre_dynamic_ = make_pair (l, depdb_preamble_.size ());
                 else
-                  fail (l) << "multiple 'depdb dep' calls" <<
-                    info (*depdb_dep_) << "previous call is here";
+                  fail (l) << "multiple 'depdb pre-dynamic' calls" <<
+                    info (depdb_pre_dynamic_->first) << "previous call is here";
               }
               else
               {
-                if (depdb_dep_)
-                  fail (l) << "'depdb " << v << "' after 'depdb dep'" <<
-                    info (*depdb_dep_) << "'depdb dep' call is here";
+                if (depdb_pre_dynamic_)
+                  fail (l) << "'depdb " << v << "' after 'depdb pre-dynamic'" <<
+                    info (depdb_pre_dynamic_->first)
+                           << "'depdb pre-dynamic' call is here";
               }
 
               // Move the script body to the end of the depdb preamble.
@@ -880,11 +885,11 @@ namespace build2
       }
 
       void parser::
-      execute_body (const scope& rs, const scope& bs,
+      execute_body (const scope& bs,
                     environment& e, const script& s, runner& r,
                     bool enter, bool leave)
       {
-        pre_exec (rs, bs, e, &s, &r);
+        pre_exec (*bs.root_scope (), bs, e, &s, &r);
 
         if (enter)
           runner_->enter (e, s.start_loc);
@@ -914,35 +919,37 @@ namespace build2
       }
 
       void parser::
-      execute_depdb_preamble (const scope& rs, const scope& bs,
-                              environment& e, const script& s, runner& r,
-                              depdb& dd)
+      exec_depdb_preamble (const scope& bs,
+                           environment& e, const script& s, runner& r,
+                           lines_iterator begin, lines_iterator end,
+                           depdb& dd, bool* update, optional<timestamp> mt)
       {
-        tracer trace ("execute_depdb_preamble");
+        tracer trace ("exec_depdb_preamble");
 
         // The only valid lines in the depdb preamble are the depdb builtin
         // itself as well as the variable assignments, including via the set
         // builtin.
 
-        pre_exec (rs, bs, e, &s, &r);
+        pre_exec (*bs.root_scope (), bs, e, &s, &r);
 
         // Let's "wrap up" the objects we operate upon into the single object
         // to rely on "small function object" optimization.
         //
         struct
         {
+          tracer& trace;
           environment& env;
           const script& scr;
           depdb& dd;
-          tracer& trace;
-        } ctx {e, s, dd, trace};
-
-        auto exec_cmd = [&ctx, this]
-                        (token& t,
-                         build2::script::token_type& tt,
-                         size_t li,
-                         bool /* single */,
-                         const location& ll)
+          bool* update;
+          optional<timestamp> mt;
+        } data {trace, e, s, dd, update, mt};
+
+        auto exec_cmd = [this, &data] (token& t,
+                                       build2::script::token_type& tt,
+                                       size_t li,
+                                       bool /* single */,
+                                       const location& ll)
         {
           // Note that we never reset the line index to zero (as we do in
           // execute_body()) assuming that there are some script body
@@ -958,9 +965,14 @@ namespace build2
 
             string cmd (move (t.value));
 
-            if (cmd == "dep")
+            if (cmd == "pre-dynamic")
             {
-              exec_depdb_dep (t, tt, li, ll);
+              exec_depdb_pre_dynamic (t, tt,
+                                      li, ll,
+                                      data.env.target,
+                                      data.dd,
+                                      *data.update,
+                                      *data.mt);
             }
             else
             {
@@ -972,11 +984,11 @@ namespace build2
                 for (const name& n: ns)
                   to_checksum (cs, n);
 
-                if (ctx.dd.expect (cs.string ()) != nullptr)
+                if (data.dd.expect (cs.string ()) != nullptr)
                   l4 ([&] {
-                      ctx.trace (ll)
+                      data.trace (ll)
                         << "'depdb hash' argument change forcing update of "
-                        << ctx.env.target;});
+                        << data.env.target;});
               }
               else if (cmd == "string")
               {
@@ -990,11 +1002,11 @@ namespace build2
                   fail (ll) << "invalid 'depdb string' argument: " << e;
                 }
 
-                if (ctx.dd.expect (s) != nullptr)
+                if (data.dd.expect (s) != nullptr)
                   l4 ([&] {
-                      ctx.trace (ll)
+                      data.trace (ll)
                         << "'depdb string' argument change forcing update of "
-                        << ctx.env.target;});
+                        << data.env.target;});
               }
               else if (cmd == "env")
               {
@@ -1015,11 +1027,11 @@ namespace build2
                   fail (ll) << pf << e;
                 }
 
-                if (ctx.dd.expect (cs.string ()) != nullptr)
+                if (data.dd.expect (cs.string ()) != nullptr)
                   l4 ([&] {
-                      ctx.trace (ll)
+                      data.trace (ll)
                         << "'depdb env' environment change forcing update of "
-                        << ctx.env.target;});
+                        << data.env.target;});
               }
               else
                 assert (false);
@@ -1040,7 +1052,7 @@ namespace build2
                                   p.recall.string () == "set";
                          }) == ce.end ())
             {
-              const replay_tokens& rt (ctx.scr.depdb_preamble.back ().tokens);
+              const replay_tokens& rt (data.scr.depdb_preamble.back ().tokens);
               assert (!rt.empty ());
 
               fail (ll) << "disallowed command in depdb preamble" <<
@@ -1053,7 +1065,7 @@ namespace build2
           }
         };
 
-        exec_lines (s.depdb_preamble, exec_cmd);
+        exec_lines (begin, end, exec_cmd);
       }
 
       void parser::
@@ -1085,7 +1097,7 @@ namespace build2
       }
 
       void parser::
-      exec_lines (const lines& lns,
+      exec_lines (lines_iterator begin, lines_iterator end,
                   const function<exec_cmd_function>& exec_cmd)
       {
         // Note that we rely on "small function object" optimization for the
@@ -1124,7 +1136,7 @@ namespace build2
           return runner_->run_if (*environment_, ce, li, ll);
         };
 
-        build2::script::parser::exec_lines (lns.begin (), lns.end (),
+        build2::script::parser::exec_lines (begin, end,
                                             exec_set, exec_cmd, exec_if,
                                             environment_->exec_line,
                                             &environment_->var_pool);
@@ -1145,12 +1157,15 @@ namespace build2
       }
 
       names parser::
-      execute_special (const scope& rs, const scope& bs,
+      execute_special (const scope& bs,
                        environment& e,
                        const line& ln,
                        bool omit_builtin)
       {
-        pre_exec (rs, bs, e, nullptr /* script */, nullptr /* runner */);
+        pre_exec (*bs.root_scope (), bs,
+                  e,
+                  nullptr /* script */,
+                  nullptr /* runner */);
 
         // Copy the tokens and start playing.
         //
@@ -1167,9 +1182,12 @@ namespace build2
       }
 
       void parser::
-      exec_depdb_dep (token& t, build2::script::token_type& tt,
-                      size_t li,
-                      const location& ll)
+      exec_depdb_pre_dynamic (token& t, build2::script::token_type& tt,
+                              size_t li, const location& ll,
+                              const target& tgt,
+                              depdb& dd,
+                              bool& update,
+                              timestamp /*mt*/)
       {
         // Similar approach to parse_env_builtin().
         //
@@ -1197,14 +1215,14 @@ namespace build2
           location l (get_location (t));
 
           if (!start_names (tt))
-            fail (l) << "depdb dep: expected option or '--' separator "
+            fail (l) << "depdb pre-dynamic: expected option or '--' separator "
                      << "instead of " << t;
 
           parse_names (t, tt,
                        ns,
                        pattern_mode::ignore,
                        true /* chunk */,
-                       "depdb dep builtin argument",
+                       "depdb pre-dynamic builtin argument",
                        nullptr);
 
           for (name& n: ns)
@@ -1229,7 +1247,8 @@ namespace build2
           next (t, tt); // Skip '--'.
 
           if (tt == type::newline || tt == type::eos)
-            fail (t) << "depdb dep: expected program name instead of " << t;
+            fail (t) << "depdb pre-dynamic: expected program name instead of "
+                     << t;
         }
 
         // Parse the options.
@@ -1241,12 +1260,65 @@ namespace build2
           ops = depdb_dep_options (scan);
 
           if (scan.more ())
-            fail (ll) << "depdb dep: unexpected argument '" << scan.next ()
-                      << "'";
+            fail (ll) << "depdb pre-dynamic: unexpected argument '"
+                      << scan.next () << "'";
         }
         catch (const cli::exception& e)
         {
-          fail (ll) << "depdb dep: " << e;
+          fail (ll) << "depdb pre-dynamic: " << e;
+        }
+
+        // This code is based on the prior work in the cc module (specifically
+        // extract_headers()) where you can often find more detailed rationale
+        // for some of the steps performed.
+
+        // If things go wrong (and they often do in this area), give the user
+        // a bit extra context.
+        //
+        auto df = make_diag_frame (
+          [this, &tgt](const diag_record& dr)
+          {
+            if (verb != 0)
+              dr << info << "while extracting dynamic dependencies for " << tgt;
+          });
+
+        // If nothing so far has invalidated the dependency database, then try
+        // the cached data before running the program.
+        //
+        bool cache (!update);
+        size_t skip_count (0);
+
+        for (bool restart (true); restart; cache = false)
+        {
+          restart = false;
+
+          if (cache)
+          {
+            // If any, this is always the first run.
+            //
+            assert (skip_count == 0);
+
+            // We should always end with a blank line.
+            //
+            for (;;)
+            {
+              string* l (dd.read ());
+
+              // If the line is invalid, run the compiler.
+              //
+              if (l == nullptr)
+              {
+                restart = true;
+                break;
+              }
+
+              if (l->empty ()) // Done, nothing changed.
+                return;
+            }
+          }
+          else
+          {
+          }
         }
 
         optional<path> file;
@@ -1277,7 +1349,8 @@ namespace build2
           // @@ TODO: improve diagnostics.
           //
           if (!file && ce.size () != 1)
-            fail (ll) << "depdb dep: command cannot contain logical operators";
+            fail (ll) << "depdb pre-dynamic: command cannot contain "
+                      << "logical operators";
 
           string s;
           build2::script::run (*environment_,
@@ -1295,7 +1368,7 @@ namespace build2
           // Assume file is one of the prerequisites.
           //
           if (!file)
-            fail (ll) << "depdb dep: program or --file expected";
+            fail (ll) << "depdb pre-dynamic: program or --file expected";
         }
       }
 
diff --git a/libbuild2/build/script/parser.hxx b/libbuild2/build/script/parser.hxx
index d2c99d9..f957f82 100644
--- a/libbuild2/build/script/parser.hxx
+++ b/libbuild2/build/script/parser.hxx
@@ -8,7 +8,6 @@
 #include <libbuild2/forward.hxx>
 #include <libbuild2/utility.hxx>
 
-#include <libbuild2/depdb.hxx>
 #include <libbuild2/diagnostics.hxx>
 
 #include <libbuild2/script/parser.hxx>
@@ -83,27 +82,54 @@ namespace build2
         // execution.
         //
         void
-        execute_body (const scope& root, const scope& base,
+        execute_body (const scope& base,
                       environment&, const script&, runner&,
                       bool enter = true, bool leave = true);
 
 
+        // Execute the first or the second (pre-dynamic) half of the depdb
+        // preamble.
+        //
         // Note that it's the caller's responsibility to make sure that the
         // runner's enter() function is called before the first preamble/body
         // command execution and leave() -- after the last command.
         //
         void
-        execute_depdb_preamble (const scope& root, const scope& base,
-                                environment&, const script&, runner&,
-                                depdb&);
+        execute_depdb_preamble (const scope& base,
+                                environment& e, const script& s, runner& r,
+                                depdb& dd)
+        {
+          auto b (s.depdb_preamble.begin ());
+          exec_depdb_preamble (
+            base,
+            e, s, r,
+            b,
+            (s.depdb_pre_dynamic
+             ? b + *s.depdb_pre_dynamic
+             : s.depdb_preamble.end ()),
+            dd);
+        }
 
+        void
+        execute_depdb_preamble_dynamic (
+          const scope& base,
+          environment& e, const script& s, runner& r,
+          depdb& dd, bool& update, timestamp mt)
+        {
+          exec_depdb_preamble (
+            base,
+            e, s, r,
+            s.depdb_preamble.begin () + *s.depdb_pre_dynamic,
+            s.depdb_preamble.end (),
+            dd, &update, mt);
+        }
 
         // Parse a special builtin line into names, performing the variable
         // and pattern expansions. If omit_builtin is true, then omit the
         // builtin name from the result.
         //
         names
-        execute_special (const scope& root, const scope& base,
+        execute_special (const scope& base,
                          environment&,
                          const line&,
                          bool omit_builtin = true);
@@ -115,16 +141,36 @@ namespace build2
         pre_exec (const scope& root, const scope& base,
                   environment&, const script*, runner*);
 
+        using lines_iterator = lines::const_iterator;
+
         void
-        exec_lines (const lines&, const function<exec_cmd_function>&);
+        exec_lines (lines_iterator, lines_iterator,
+                    const function<exec_cmd_function>&);
+
+        void
+        exec_lines (const lines& l, const function<exec_cmd_function>& c)
+        {
+          exec_lines (l.begin (), l.end (), c);
+        }
 
         names
         exec_special (token&, build2::script::token_type&, bool skip_first);
 
         void
-        exec_depdb_dep (token&, build2::script::token_type&,
-                        size_t line_index,
-                        const location&);
+        exec_depdb_preamble (const scope& base,
+                             environment&, const script&, runner&,
+                             lines_iterator begin, lines_iterator end,
+                             depdb&,
+                             bool* update = nullptr,
+                             optional<timestamp> mt = nullopt);
+
+        void
+        exec_depdb_pre_dynamic (token&, build2::script::token_type&,
+                                size_t line_index, const location&,
+                                const target&,
+                                depdb&,
+                                bool& update,
+                                timestamp);
 
         // Helpers.
         //
@@ -223,12 +269,14 @@ namespace build2
         // depdb env <var-names> - Track the environment variables change as a
         //                         hash.
         //
-        // depdb dep ...         - Extract additional dependency information.
-        //                         Can only be the last depdb builtin call.
+        // depdb pre-dynamic ... - Extract dynamic dependency information.
+        //                         Can only be the last depdb builtin call
+        //                         in the preamble.
         //
-        optional<location> depdb_clear_;    // depdb-clear location if any.
-        optional<location> depdb_dep_;      // depdb-dep location if any.
-        lines              depdb_preamble_; // Note: excludes depdb-clear.
+        optional<location> depdb_clear_;    // depdb-clear location.
+        optional<pair<location, size_t>>
+          depdb_pre_dynamic_;               // depdb-pre-dynamic location.
+        lines              depdb_preamble_; // Note: excluding depdb-clear.
 
         // If present, the first impure function called in the body of the
         // script that performs update of a file-based target.
diff --git a/libbuild2/build/script/script.hxx b/libbuild2/build/script/script.hxx
index e11cb45..bdfbe51 100644
--- a/libbuild2/build/script/script.hxx
+++ b/libbuild2/build/script/script.hxx
@@ -29,6 +29,10 @@ namespace build2
       using build2::script::deadline;
       using build2::script::timeout;
 
+      // Forward declarations.
+      //
+      class default_runner;
+
       // Notes:
       //
       // - Once parsed, the script can be executed in multiple threads with
@@ -70,9 +74,10 @@ namespace build2
         // The script's custom dependency change tracking lines (see the
         // script parser for details).
         //
-        bool       depdb_clear;
-        lines_type depdb_preamble;
-        bool       depdb_preamble_temp_dir = false; // True if references $~.
+        bool             depdb_clear;
+        optional<size_t> depdb_pre_dynamic; // Position of first pre-dynamic.
+        lines_type       depdb_preamble;
+        bool             depdb_preamble_temp_dir = false; // True if refs $~.
 
         location start_loc;
         location end_loc;
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
diff --git a/libbuild2/cc/compile-rule.hxx b/libbuild2/cc/compile-rule.hxx
index f573968..a211590 100644
--- a/libbuild2/cc/compile-rule.hxx
+++ b/libbuild2/cc/compile-rule.hxx
@@ -8,6 +8,7 @@
 #include <libbuild2/utility.hxx>
 
 #include <libbuild2/rule.hxx>
+#include <libbuild2/dynamic.hxx>
 #include <libbuild2/file-cache.hxx>
 
 #include <libbuild2/cc/types.hxx>
@@ -37,7 +38,8 @@ namespace build2
     };
 
     class LIBBUILD2_CC_SYMEXPORT compile_rule: public simple_rule,
-                                               virtual common
+                                               virtual common,
+                                               dyndep_rule
     {
     public:
       compile_rule (data&&);
diff --git a/libbuild2/dynamic.cxx b/libbuild2/dynamic.cxx
new file mode 100644
index 0000000..6dd439b
--- /dev/null
+++ b/libbuild2/dynamic.cxx
@@ -0,0 +1,76 @@
+// file      : libbuild2/dynamic.cxx -*- C++ -*-
+// license   : MIT; see accompanying LICENSE file
+
+#include <libbuild2/dynamic.hxx>
+
+#include <libbuild2/scope.hxx>
+#include <libbuild2/target.hxx>
+#include <libbuild2/context.hxx>
+#include <libbuild2/algorithm.hxx>
+#include <libbuild2/diagnostics.hxx>
+
+using namespace std;
+using namespace butl;
+
+namespace build2
+{
+  bool
+  update_during_match (tracer& trace, action a, const target& t, timestamp ts)
+  {
+    // In particular, 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".
+    //
+    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 the dynamic dependency extraction
+      // run for some other target.
+      //
+      // @@ 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;
+    }
+  }
+}
diff --git a/libbuild2/dynamic.hxx b/libbuild2/dynamic.hxx
new file mode 100644
index 0000000..395a839
--- /dev/null
+++ b/libbuild2/dynamic.hxx
@@ -0,0 +1,33 @@
+// file      : libbuild2/dynamic.hxx -*- C++ -*-
+// license   : MIT; see accompanying LICENSE file
+
+#ifndef LIBBUILD2_DYNAMIC_HXX
+#define LIBBUILD2_DYNAMIC_HXX
+
+#include <libbuild2/types.hxx>
+#include <libbuild2/forward.hxx>
+#include <libbuild2/utility.hxx>
+
+#include <libbuild2/action.hxx>
+#include <libbuild2/target.hxx>
+
+#include <libbuild2/export.hxx>
+
+// Additional functionality that is normally only useful for implementing
+// rules with dynamic dependencies.
+//
+namespace build2
+{
+  class LIBBUILD2_SYMEXPORT dyndep_rule
+  {
+  public:
+    // 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.
+    //
+    static bool
+    update (tracer&, action, const target&, timestamp);
+  };
+}
+
+#endif // LIBBUILD2_DYNAMIC_HXX