Add import library target libi{}, make libs{} the DLL

In the end, having libs{} be the DLL with import library being its member is
more natural than making libs{} the import library and having dll{} as its
member.

11 files changed, 291 insertions, 173 deletions

diff --git a/build2/bin/module.cxx b/build2/bin/module.cxx
index 334384a..194b409 100644
--- a/build2/bin/module.cxx
+++ b/build2/bin/module.cxx
@@ -348,19 +348,59 @@ namespace build2
       //
       const string& tclass (cast<string> (r["bin.target.class"]));
 
-      // Register target types.
+      // Register target types and configure their default "installability".
       //
+      using namespace install;
+
       {
         auto& t (b.target_types);
 
+        t.insert<obj>  ();
         t.insert<obje> ();
         t.insert<obja> ();
         t.insert<objs> ();
-        t.insert<obj>  ();
+
         t.insert<exe>  ();
+        install_path<exe> (b, dir_path ("bin")); // Install into install.bin.
+
+        t.insert<lib>  ();
         t.insert<liba> ();
         t.insert<libs> ();
-        t.insert<lib>  ();
+
+        install_path<liba> (b, dir_path ("lib")); // Install into install.lib.
+        install_mode<liba> (b, "644");
+
+        // Should shared libraries have the executable bit? That depends on
+        // who you ask. In Debian, for example, it should not unless, it
+        // really is executable (i.e., has main()). On the other hand, on
+        // some systems, this may be required in order for the dynamic
+        // linker to be able to load the library. So, by default, we will
+        // keep it executable, especially seeing that this is also the
+        // behavior of autotools. At the same time, it is easy to override
+        // this, for example:
+        //
+        // config.install.lib.mode=644
+        //
+        // And a library that wants to override any such overrides (e.g.,
+        // because it does have main()) can do:
+        //
+        // libs{foo}: install.mode=755
+        //
+        // Everyone is happy then? On Windows libs{} is the DLL and goes to
+        // bin/, not lib/.
+        //
+        install_path<libs> (b, dir_path (tclass == "windows" ? "bin" : "lib"));
+
+        // Create additional target types for certain targets.
+        //
+        if (tclass == "windows")
+        {
+          // Import library.
+          //
+          t.insert<libi> ();
+          install_path<libi> (b, dir_path ("lib"));
+          install_mode<libi> (b, "644");
+        }
       }
 
       // Register rules.
@@ -388,39 +428,6 @@ namespace build2
         r.insert<lib> (perform_install_id, "bin.lib", lib_);
       }
 
-      // Configure "installability" of our target types.
-      //
-      using namespace install;
-
-      install_path<exe> (b, dir_path ("bin"));  // Install into install.bin.
-
-      // Should shared libraries have executable bit? That depends on
-      // who you ask. In Debian, for example, it should not unless, it
-      // really is executable (i.e., has main()). On the other hand, on
-      // some systems, this may be required in order for the dynamic
-      // linker to be able to load the library. So, by default, we will
-      // keep it executable, especially seeing that this is also the
-      // behavior of autotools. At the same time, it is easy to override
-      // this, for example:
-      //
-      // config.install.lib.mode=644
-      //
-      // And a library that wants to override any such overrides (e.g.,
-      // because it does have main()) can do:
-      //
-      // libs{foo}: install.mode=755
-      //
-      // Everyone is happy then? Not Windows users. When targeting Windows
-      // libs{} is an import library and shouldn't be exec.
-      //
-      install_path<libs> (b, dir_path ("lib")); // Install into install.lib.
-
-      if (tclass == "windows")
-        install_mode<libs> (b, "644");
-
-      install_path<liba> (b, dir_path ("lib"));  // Install into install.lib.
-      install_mode<liba> (b, "644");
-
       return true;
     }
 
@@ -485,6 +492,19 @@ namespace build2
         r.assign<string> ("bin.ld.checksum") = move (ldi.checksum);
       }
 
+      const string& lid (cast<string> (r["bin.ld.id"]));
+
+      // Register the pdb{} target if using the VC toolchain.
+      //
+      using namespace install;
+
+      if (lid == "msvc")
+      {
+        const target_type& pdb (b.derive_target_type<file> ("pdb").first);
+        install_path (pdb, b, dir_path ("bin")); // Goes to install.bin
+        install_mode (pdb, b, "644");            // But not executable.
+      }
+
       return true;
     }
 
diff --git a/build2/bin/target b/build2/bin/target
index 8c32e84..849316e 100644
--- a/build2/bin/target
+++ b/build2/bin/target
@@ -107,6 +107,18 @@ namespace build2
       static const target_type static_type;
       virtual const target_type& dynamic_type () const {return static_type;}
     };
+
+    // Windows import library.
+    //
+    class libi: public file
+    {
+    public:
+      using file::file;
+
+    public:
+      static const target_type static_type;
+      virtual const target_type& dynamic_type () const {return static_type;}
+    };
   }
 }
 
diff --git a/build2/bin/target.cxx b/build2/bin/target.cxx
index 3f16467..d78d34c 100644
--- a/build2/bin/target.cxx
+++ b/build2/bin/target.cxx
@@ -261,5 +261,18 @@ namespace build2
       &search_target,
       false
     };
+
+    // libi
+    //
+    const target_type libi::static_type
+    {
+      "libi",
+      &file::static_type,
+      &target_factory<libi>,
+      &target_extension_var<ext_var, nullptr>,
+      nullptr,
+      &search_file,
+      false
+    };
   }
 }
diff --git a/build2/cxx/compile.cxx b/build2/cxx/compile.cxx
index 9efa0b6..432b485 100644
--- a/build2/cxx/compile.cxx
+++ b/build2/cxx/compile.cxx
@@ -67,7 +67,7 @@ namespace build2
     {
       tracer trace ("cxx::compile");
 
-      path_target& t (static_cast<path_target&> (xt));
+      file& t (static_cast<file&> (xt));
 
       scope& bs (t.base_scope ());
       scope& rs (*bs.root_scope ());
@@ -1235,7 +1235,7 @@ namespace build2
     target_state compile::
     perform_update (action a, target& xt)
     {
-      path_target& t (static_cast<path_target&> (xt));
+      file& t (static_cast<file&> (xt));
       cxx* s (execute_prerequisites<cxx> (a, t, t.mtime ()));
 
       if (s == nullptr)
diff --git a/build2/cxx/link.cxx b/build2/cxx/link.cxx
index e13cfe3..b80fc8b 100644
--- a/build2/cxx/link.cxx
+++ b/build2/cxx/link.cxx
@@ -202,6 +202,10 @@ namespace build2
     {
       tracer trace ("cxx::link::search_library");
 
+      // @@ This is hairy enough to warrant a separate implementation for
+      //    Windows.
+      //
+
       // First check the cache.
       //
       if (p.target != nullptr)
@@ -210,6 +214,7 @@ namespace build2
       scope& rs (*p.scope.root_scope ());
       const string& cid (cast<string> (rs["cxx.id"]));
       const string& tsys (cast<string> (rs["cxx.target.system"]));
+      const string& tclass (cast<string> (rs["cxx.target.class"]));
 
       bool l (p.is_a<lib> ());
       const string* ext (l ? nullptr : p.ext); // Only for liba/libs.
@@ -321,7 +326,48 @@ namespace build2
           f /= sn;
           mt = file_mtime (f);
 
-          if (tsys == "mingw32")
+          if (mt != timestamp_nonexistent)
+          {
+            // On Windows what we found is the import library which we need
+            // to make the first ad hoc member of libs{}.
+            //
+            if (tclass == "windows")
+            {
+              s = &targets.insert<libs> (
+                d, dir_path (), p.name, nullptr, trace);
+
+              if (s->member == nullptr)
+              {
+                libi& i (
+                  targets.insert<libi> (
+                    d, dir_path (), p.name, se, trace));
+
+                if (i.path ().empty ())
+                  i.path (move (f));
+
+                i.mtime (mt);
+
+                // Presumably there is a DLL somewhere, we just don't know
+                // where (and its possible we might have to look for one if we
+                // decide we need to do rpath emulation for installed
+                // libraries as well). We will represent this as empty path
+                // but valid timestamp (aka "trust me, it's there").
+                //
+                s->mtime (mt);
+                s->member = &i;
+              }
+            }
+            else
+            {
+              s = &targets.insert<libs> (d, dir_path (), p.name, se, trace);
+
+              if (s->path ().empty ())
+                s->path (move (f));
+
+              s->mtime (mt);
+            }
+          }
+          else if (ext == nullptr && tsys == "mingw32")
           {
             // Above we searched for the import library (.dll.a) but if it's
             // not found, then we also search for the .dll (unless the
@@ -329,22 +375,19 @@ namespace build2
             // directly. Note also that the resulting libs{} would end up
             // being the .dll.
             //
-            if (mt == timestamp_nonexistent && ext == nullptr)
-            {
-              se = &extension_pool.find ("dll");
-              f = f.base (); // Remove .a from .dll.a.
-              mt = file_mtime (f);
-            }
-          }
+            se = &extension_pool.find ("dll");
+            f = f.base (); // Remove .a from .dll.a.
+            mt = file_mtime (f);
 
-          if (mt != timestamp_nonexistent)
-          {
-            s = &targets.insert<libs> (d, dir_path (), p.name, se, trace);
+            if (mt != timestamp_nonexistent)
+            {
+              s = &targets.insert<libs> (d, dir_path (), p.name, se, trace);
 
-            if (s->path ().empty ())
-              s->path (move (f));
+              if (s->path ().empty ())
+                s->path (move (f));
 
-            s->mtime (mt);
+              s->mtime (mt);
+            }
           }
         }
 
@@ -595,7 +638,7 @@ namespace build2
     {
       tracer trace ("cxx::link::apply");
 
-      path_target& t (static_cast<path_target&> (xt));
+      file& t (static_cast<file&> (xt));
 
       scope& bs (t.base_scope ());
       scope& rs (*bs.root_scope ());
@@ -656,28 +699,13 @@ namespace build2
             else if (tclass == "windows")
             {
               // On Windows libs{} is an ad hoc group. The libs{} itself is
-              // the import library and we add dll{} as a member (see below).
-              // While at first it may seem strange that libs{} is the import
-              // library and not the DLL, if you meditate on it, you will see
-              // it makes a lot of sense: our main task here is building and
-              // for that we need the import library, not the DLL.
+              // the DLL and we add libi{} import library as its member (see
+              // below).
               //
               if (tsys == "mingw32")
-              {
                 p = "lib";
-                e = "dll.a";
-              }
-              else
-              {
-                // Usually on Windows the import library is called the same as
-                // the DLL but with the .lib extension. Which means it clashes
-                // with the static library. Instead of decorating the static
-                // library name with ugly suffixes (as is customary), let's
-                // use the MinGW approach (one must admit it's quite elegant)
-                // and call it .dll.lib.
-                //
-                e = "dll.lib";
-              }
+
+              e = "dll";
             }
             else
             {
@@ -713,14 +741,21 @@ namespace build2
 
       if (tclass == "windows")
       {
-        // DLL
+        // Import library.
         //
         if (lt == otype::s)
         {
-          file& dll (add_adhoc (t, "dll"));
-
-          if (dll.path ().empty ())
-            dll.derive_path ("dll", tsys == "mingw32" ? "lib" : nullptr);
+          file& imp (add_adhoc (t, "libi"));
+
+          // Usually on Windows the import library is called the same as the
+          // DLL but with the .lib extension. Which means it clashes with the
+          // static library. Instead of decorating the static library name
+          // with ugly suffixes (as is customary), let's use the MinGW
+          // approach (one must admit it's quite elegant) and call it
+          // .dll.lib.
+          //
+          if (imp.path ().empty ())
+            imp.derive_path (t.path (), tsys == "mingw32" ? "a" : "lib");
         }
 
         // PDB
@@ -729,10 +764,13 @@ namespace build2
             cid == "msvc" &&
             find_option ("/DEBUG", t, "cxx.loptions", true))
         {
-          // Add after the DLL if any.
+          // Add after the import library if any.
           //
           file& pdb (add_adhoc (t.member == nullptr ? t : *t.member, "pdb"));
 
+          // We call it foo.{exe,dll}.pdb rather than just foo.pdb because we
+          // can have both foo.exe and foo.dll in the same directory.
+          //
           if (pdb.path ().empty ())
             pdb.derive_path (t.path (), "pdb");
         }
@@ -1360,17 +1398,28 @@ namespace build2
 
         for (target* pt: t.prerequisite_targets)
         {
-          path_target* ppt;
+          file* f;
           liba* a (nullptr);
+          libs* s (nullptr);
 
-          if ((ppt = pt->is_a<obje> ()) ||
-              (ppt = pt->is_a<obja> ()) ||
-              (ppt = pt->is_a<objs> ()) ||
+          if ((f = pt->is_a<obje> ()) ||
+              (f = pt->is_a<obja> ()) ||
+              (f = pt->is_a<objs> ()) ||
               (lt != otype::a &&
-               ((ppt = a = pt->is_a<liba> ()) ||
-                (ppt =     pt->is_a<libs> ()))))
+               ((f = a = pt->is_a<liba> ()) ||
+                (f = s = pt->is_a<libs> ()))))
           {
-            cs.append (ppt->path ().string ());
+            // On Windows a shared library is a DLL with the import library as
+            // a first ad hoc group member. MinGW though can link directly to
+            // DLLs (see search_library() for details).
+            //
+            if (s != nullptr && tclass == "windows")
+            {
+              if (s->member != nullptr)
+                f = static_cast<file*> (s->member);
+            }
+
+            cs.append (f->path ().string ());
 
             // If this is a static library, link all the libraries it depends
             // on, recursively.
@@ -1487,26 +1536,26 @@ namespace build2
 
             if (lt == otype::s)
             {
-              // On Windows libs{} is the import stub and its first ad hoc
-              // group member is dll{}.
+              // On Windows libs{} is the DLL and its first ad hoc group
+              // member is the import library.
               //
               // This will also create the .exp export file. Its name will be
               // derived from the import library by changing the extension.
-              // Lucky us -- there is no option to name it.
+              // Lucky for us -- there is no option to name it.
               //
-              out2 = "/IMPLIB:" + relt.string ();
+              auto imp (static_cast<file*> (t.member));
+              out2 = "/IMPLIB:" + relative (imp->path ()).string ();
               args.push_back (out2.c_str ());
-
-              relt = relative (static_cast<file*> (t.member)->path ());
             }
 
-            // If we have /DEBUG then name the .pdb file. We call it
-            // foo.{exe,dll}.pdb rather than just foo.pdb because we can have,
-            // both foo.exe and foo.dll in the same directory.
+            // If we have /DEBUG then name the .pdb file. It is either the
+            // first (exe) or the second (dll) ad hoc group member.
             //
             if (find_option ("/DEBUG", args, true))
             {
-              out1 = "/PDB:" + relt.string () + ".pdb";
+              auto pdb (static_cast<file*> (
+                          lt == otype::e ? t.member : t.member->member));
+              out1 = "/PDB:" + relative (pdb->path ()).string ();
               args.push_back (out1.c_str ());
             }
 
@@ -1533,13 +1582,12 @@ namespace build2
 
               if (tsys == "mingw32")
               {
-                // On Windows libs{} is the import stub and its first ad hoc
-                // group member is dll{}.
+                // On Windows libs{} is the DLL and its first ad hoc group
+                // member is the import library.
                 //
-                out = "-Wl,--out-implib=" + relt.string ();
+                auto imp (static_cast<file*> (t.member));
+                out = "-Wl,--out-implib=" + relative (imp->path ()).string ();
                 args.push_back (out.c_str ());
-
-                relt = relative (static_cast<file*> (t.member)->path ());
               }
             }
 
@@ -1553,17 +1601,28 @@ namespace build2
 
       for (target* pt: t.prerequisite_targets)
       {
-        path_target* ppt;
+        file* f;
         liba* a (nullptr);
+        libs* s (nullptr);
 
-        if ((ppt = pt->is_a<obje> ()) ||
-            (ppt = pt->is_a<obja> ()) ||
-            (ppt = pt->is_a<objs> ()) ||
+        if ((f = pt->is_a<obje> ()) ||
+            (f = pt->is_a<obja> ()) ||
+            (f = pt->is_a<objs> ()) ||
             (lt != otype::a &&
-             ((ppt = a = pt->is_a<liba> ()) ||
-              (ppt     = pt->is_a<libs> ()))))
+             ((f = a = pt->is_a<liba> ()) ||
+              (f = s = pt->is_a<libs> ()))))
         {
-          sargs.push_back (relative (ppt->path ()).string ()); // string()&&
+          // On Windows a shared library is a DLL with the import library as a
+          // first ad hoc group member. MinGW though can link directly to DLLs
+          // (see search_library() for details).
+          //
+          if (s != nullptr && tclass == "windows")
+          {
+            if (s->member != nullptr)
+              f = static_cast<file*> (s->member);
+          }
+
+          sargs.push_back (relative (f->path ()).string ()); // string()&&
 
           // If this is a static library, link all the libraries it depends
           // on, recursively.
@@ -1687,7 +1746,7 @@ namespace build2
       {
       case otype::a:
         {
-          e = {"+.d"};
+          e = {".d"};
           break;
         }
       case otype::e:
@@ -1717,7 +1776,7 @@ namespace build2
           {
             // Assuming it's VC or alike. Clean up .exp and .ilk.
             //
-            e = {".d", "-.exp", "--.ilk"};
+            e = {".d", ".exp", "-.ilk"};
           }
           else
             e = {".d"};
diff --git a/build2/cxx/module.cxx b/build2/cxx/module.cxx
index 69e76a3..8972bf9 100644
--- a/build2/cxx/module.cxx
+++ b/build2/cxx/module.cxx
@@ -258,7 +258,6 @@ namespace build2
 
       const string& cid (cast<string> (r["cxx.id"]));
       const string& tsys (cast<string> (r["cxx.target.system"]));
-      const string& tclass (cast<string> (r["cxx.target.class"]));
 
       // Initialize the bin module. Only do this if it hasn't already been
       // loaded so that we don't overwrite user's bin.* settings.
@@ -361,21 +360,6 @@ namespace build2
       install_path<txx> (b, dir_path ("include"));
       install_path<h>   (b, dir_path ("include"));
 
-      // Create additional target types for certain target platforms.
-      //
-      if (tclass == "windows")
-      {
-        const target_type& dll (b.derive_target_type<file> ("dll").first);
-        install_path (dll, b, dir_path ("bin"));
-
-        if (cid == "msvc")
-        {
-          const target_type& pdb (b.derive_target_type<file> ("pdb").first);
-          install_path (pdb, b, dir_path ("bin"));
-          install_mode (pdb, b, "644");
-        }
-      }
-
       return true;
     }
   }
diff --git a/build2/cxx/msvc.cxx b/build2/cxx/msvc.cxx
index 1c5a3fa..ff91018 100644
--- a/build2/cxx/msvc.cxx
+++ b/build2/cxx/msvc.cxx
@@ -227,11 +227,24 @@ namespace build2
     libs*
     msvc_search_shared (const path& ld, const dir_path& d, prerequisite& p)
     {
+      tracer trace ("cxx::msvc_search_shared");
+
       libs* r (nullptr);
 
-      auto search = [&r, &ld, &d, &p] (const char* pf, const char* sf) -> bool
+      auto search = [&r, &ld, &d, &p, &trace] (
+        const char* pf, const char* sf) -> bool
       {
-        r = search_library<libs> (ld, d, p, otype::s, pf, sf);
+        if (libi* i = search_library<libi> (ld, d, p, otype::s, pf, sf))
+        {
+          r = &targets.insert<libs> (d, dir_path (), p.name, nullptr, trace);
+
+          if (r->member == nullptr)
+          {
+            r->mtime (i->mtime ());
+            r->member = i;
+          }
+        }
+
         return r != nullptr;
       };
 
diff --git a/build2/cxx/windows-rpath.cxx b/build2/cxx/windows-rpath.cxx
index 0bd4bc5..b5bad5e 100644
--- a/build2/cxx/windows-rpath.cxx
+++ b/build2/cxx/windows-rpath.cxx
@@ -51,22 +51,18 @@ namespace build2
       {
         if (libs* ls = pt->is_a<libs> ())
         {
-          // This can be an installed library in which case we will have just
-          // the import stub but may also have just the DLL. For now we don't
-          // bother with installed libraries.
+          // Skip installed DLLs.
           //
-          if (ls->member == nullptr)
+          if (ls->path ().empty ())
             continue;
 
-          file& dll (static_cast<file&> (*ls->member));
-
           // What if the DLL is in the same directory as the executable, will
           // it still be found even if there is an assembly? On the other
           // hand, handling it as any other won't hurt us much.
           //
           timestamp t;
 
-          if ((t = dll.mtime ()) > r)
+          if ((t = ls->mtime ()) > r)
             r = t;
 
           if ((t = windows_rpath_timestamp (*ls)) > r)
@@ -80,18 +76,18 @@ namespace build2
     // Like *_timestamp() but actually collect the DLLs.
     //
     static void
-    rpath_dlls (set<file*>& s, file& t)
+    rpath_dlls (set<libs*>& s, file& t)
     {
       for (target* pt: t.prerequisite_targets)
       {
         if (libs* ls = pt->is_a<libs> ())
         {
-          if (ls->member == nullptr)
+          // Skip installed DLLs.
+          //
+          if (ls->path ().empty ())
             continue;
 
-          file& dll (static_cast<file&> (*ls->member));
-
-          s.insert (&dll);
+          s.insert (ls);
           rpath_dlls (s, *ls);
         }
       }
@@ -143,7 +139,7 @@ namespace build2
       //
       bool empty (ts == timestamp_nonexistent);
 
-      set<file*> dlls;
+      set<libs*> dlls;
       if (!empty)
         rpath_dlls (dlls, t);
 
@@ -185,16 +181,12 @@ namespace build2
 
         scope& as (*rs.weak_scope ()); // Amalgamation scope.
 
-        for (file* dt: dlls)
+        auto link = [&as, &ad] (const path& f, const path& l)
         {
-          const path& dp (dt->path ()); // DLL path.
-          const path dn (dp.leaf ());   // DLL name.
-          const path lp (ad / dn);      // Link path.
-
-          auto print = [&dp, &lp] (const char* cmd)
+          auto print = [&f, &l] (const char* cmd)
           {
             if (verb >= 3)
-              text << cmd << ' ' << dp << ' ' << lp;
+              text << cmd << ' ' << f << ' ' << l;
           };
 
           // First we try to create a symlink. If that fails (e.g., "Windows
@@ -208,10 +200,10 @@ namespace build2
             // part of the same amalgamation. This way if the amalgamation is
             // moved as a whole, the links will remain valid.
             //
-            if (dp.sub (as.out_path ()))
-              mksymlink (dp.relative (ad), lp);
+            if (f.sub (as.out_path ()))
+              mksymlink (f.relative (ad), l);
             else
-              mksymlink (dp, lp);
+              mksymlink (f, l);
 
             print ("ln -s");
           }
@@ -222,12 +214,12 @@ namespace build2
             if (c != EPERM && c != ENOSYS)
             {
               print ("ln -s");
-              fail << "unable to create symlink " << lp << ": " << e.what ();
+              fail << "unable to create symlink " << l << ": " << e.what ();
             }
 
             try
             {
-              mkhardlink (dp, lp);
+              mkhardlink (f, l);
               print ("ln");
             }
             catch (const system_error& e)
@@ -237,23 +229,38 @@ namespace build2
               if (c != EPERM && c != ENOSYS)
               {
                 print ("ln");
-                fail << "unable to create hard link " << lp << ": "
-                     << e.what ();
+                fail << "unable to create hardlink " << l << ": " << e.what ();
               }
 
               try
               {
-                cpfile (dp, lp);
+                cpfile (f, l);
                 print ("cp");
               }
               catch (const system_error& e)
               {
                 print ("cp");
-                fail << "unable to create copy " << lp << ": " << e.what ();
+                fail << "unable to create copy " << l << ": " << e.what ();
               }
             }
           }
 
+        };
+
+        for (libs* dll: dlls)
+        {
+          const path& dp (dll->path ()); // DLL path.
+          const path dn (dp.leaf ());    // DLL name.
+          link (dp, ad / dn);
+
+          // Link .pdb if there is one (second member of the ad hoc group).
+          //
+          if (dll->member != nullptr && dll->member->member != nullptr)
+          {
+            file& pdb (static_cast<file&> (*dll->member->member));
+            link (pdb.path (), ad / pdb.path ().leaf ());
+          }
+
           ofs << "  <file name='" << dn.string () << "'/>\n";
         }
 
diff --git a/build2/rule.cxx b/build2/rule.cxx
index cbb7d08..0fcfde2 100644
--- a/build2/rule.cxx
+++ b/build2/rule.cxx
@@ -44,18 +44,25 @@ namespace build2
       {
         path_target& pt (dynamic_cast<path_target&> (t));
 
-        // Assign the path. While normally we shouldn't do this in match(),
-        // no other rule should ever be ambiguous with the fallback one.
+        // First check the timestamp. This allows for the special "trust me,
+        // this file exists" situations (used, for example, for installed
+        // stuff where we know it's there, just not exactly where).
         //
-        if (pt.path ().empty ())
-          pt.derive_path ();
-
-        // We cannot just call pt.mtime() since we haven't matched yet.
-        //
-        timestamp ts (file_mtime (pt.path ()));
-        pt.mtime (ts);
-
-        if (ts != timestamp_nonexistent)
+        timestamp ts (pt.mtime ());
+
+        if (ts == timestamp_unknown)
+        {
+          // Assign the path. While normally we shouldn't do this in match(),
+          // no other rule should ever be ambiguous with the fallback one.
+          //
+          if (pt.path ().empty ())
+          {
+            pt.derive_path ();
+            ts = pt.mtime ();
+          }
+        }
+
+        if (ts != timestamp_unknown && ts != timestamp_nonexistent)
           return t;
 
         l4 ([&]{trace << "no existing file for target " << t;});
diff --git a/build2/target b/build2/target
index 28753df..dfc6abc 100644
--- a/build2/target
+++ b/build2/target
@@ -954,10 +954,12 @@ namespace build2
   public:
     using target::target;
 
-    // Generally, modification time for a target can only be queried
-    // after a rule has been matched since that's where the path is
-    // normally gets assigned. Normally, however, it would make sense
-    // to first execute the rule to get the "updated" timestamp.
+    // Generally, modification time for a target can only be queried after a
+    // rule has been matched since that's where the path is normally gets
+    // assigned (if the path was not assigned and no timestamp was set
+    // manually, this function will return timestamp_unknown). Normally,
+    // however, it would make sense to first execute the rule to get the
+    // "updated" timestamp.
     //
     // The rule for groups that utilize the group state is as follows:
     // if it has any members that are mtime_targets, then the group
@@ -986,6 +988,8 @@ namespace build2
     }
 
   protected:
+    // Return timestamp_unknown if the mtime cannot be loaded.
+    //
     virtual timestamp
     load_mtime () const = 0;
 
diff --git a/build2/target.cxx b/build2/target.cxx
index a8fae39..b0fc92d 100644
--- a/build2/target.cxx
+++ b/build2/target.cxx
@@ -383,8 +383,7 @@ namespace build2
   load_mtime () const
   {
     const path_type& f (path ());
-    assert (!f.empty ());
-    return file_mtime (f);
+    return f.empty () ? timestamp_unknown : file_mtime (f);
   }
 
   // Search functions.