Implement missing pieces in utility libraries support

In particular, we can now build static libraries out of utility libraries.

14 files changed, 624 insertions, 313 deletions

diff --git a/build2/bin/init.cxx b/build2/bin/init.cxx
index 7e022fda..6d99e26 100644
--- a/build2/bin/init.cxx
+++ b/build2/bin/init.cxx
@@ -38,7 +38,7 @@ namespace build2
     static const strings libs_lib {"shared", "static"};
 
     bool
-    vars_init (scope& r,
+    vars_init (scope& rs,
                scope&,
                const location&,
                unique_ptr<module_base>&,
@@ -47,7 +47,7 @@ namespace build2
                const variable_map&)
     {
       tracer trace ("bin::vars_init");
-      l5 ([&]{trace << "for " << r.out_path ();});
+      l5 ([&]{trace << "for " << rs.out_path ();});
 
       assert (first);
 
@@ -56,7 +56,7 @@ namespace build2
       // Target is a string and not target_triplet because it can be
       // specified by the user.
       //
-      auto& vp (var_pool.rw (r));
+      auto& vp (var_pool.rw (rs));
 
       vp.insert<string>    ("config.bin.target",   true);
       vp.insert<string>    ("config.bin.pattern",  true);
@@ -91,7 +91,7 @@ namespace build2
       // example:
       //
       // exe{test}: liba{foo}
-      // liba{foo}: libu{foo1 foo2}
+      // liba{foo}: libua{foo1 foo2}
       // liba{foo}: bin.whole = false # Affects test but not foo1 and foo2.
       //
       // If unspecified, defaults to false for liba{} and to true for libux{}.
@@ -121,6 +121,11 @@ namespace build2
       tracer trace ("bin::config_init");
       l5 ([&]{trace << "for " << bs.out_path ();});
 
+      // We only support root loading (which means there can only be one).
+      //
+      if (&rs != &bs)
+        fail (loc) << "bin.config module must be loaded in project root";
+
       // Load bin.vars.
       //
       if (!cast_false<bool> (rs["bin.vars.loaded"]))
@@ -149,7 +154,7 @@ namespace build2
       // config.bin.lib
       //
       {
-        value& v (bs.assign ("bin.lib"));
+        value& v (rs.assign ("bin.lib"));
         if (!v)
           v = *required (rs, "config.bin.lib", "both").first;
       }
@@ -157,7 +162,7 @@ namespace build2
       // config.bin.exe.lib
       //
       {
-        value& v (bs.assign ("bin.exe.lib"));
+        value& v (rs.assign ("bin.exe.lib"));
         if (!v)
           v = *required (rs, "config.bin.exe.lib", exe_lib).first;
       }
@@ -165,7 +170,7 @@ namespace build2
       // config.bin.liba.lib
       //
       {
-        value& v (bs.assign ("bin.liba.lib"));
+        value& v (rs.assign ("bin.liba.lib"));
         if (!v)
           v = *required (rs, "config.bin.liba.lib", liba_lib).first;
       }
@@ -173,7 +178,7 @@ namespace build2
       // config.bin.libs.lib
       //
       {
-        value& v (bs.assign ("bin.libs.lib"));
+        value& v (rs.assign ("bin.libs.lib"));
         if (!v)
           v = *required (rs, "config.bin.libs.lib", libs_lib).first;
       }
@@ -183,7 +188,7 @@ namespace build2
       // This one is optional and we merge it into bin.rpath, if any.
       // See the cxx module for details on merging.
       //
-      bs.assign ("bin.rpath") += cast_null<dir_paths> (
+      rs.assign ("bin.rpath") += cast_null<dir_paths> (
         optional (rs, "config.bin.rpath"));
 
       // config.bin.{lib,exe}.{prefix,suffix}
@@ -196,13 +201,13 @@ namespace build2
         lookup p (omitted (rs, "config.bin.prefix").first);
         lookup s (omitted (rs, "config.bin.suffix").first);
 
-        auto set = [&rs, &bs] (const char* bv, const char* cv, lookup l)
+        auto set = [&rs] (const char* bv, const char* cv, lookup l)
         {
           if (lookup o = omitted (rs, cv).first)
             l = o;
 
           if (l)
-            bs.assign (bv) = *l;
+            rs.assign (bv) = *l;
         };
 
         set ("bin.lib.prefix", "config.bin.lib.prefix", p);
@@ -364,8 +369,8 @@ namespace build2
 
       // Load bin.config.
       //
-      if (!cast_false<bool> (bs["bin.config.loaded"]))
-        load_module (rs, bs, "bin.config", loc, false, hints);
+      if (!cast_false<bool> (rs["bin.config.loaded"]))
+        load_module (rs, rs, "bin.config", loc, false, hints);
 
       // Cache some config values we will be needing below.
       //
@@ -391,6 +396,7 @@ namespace build2
         t.insert<bmis> ();
 
         t.insert<libu>  ();
+        t.insert<libul> ();
         t.insert<libue> ();
         t.insert<libua> ();
         t.insert<libus> ();
@@ -466,6 +472,9 @@ namespace build2
         r.insert<libu> (perform_update_id, "bin.libu", fail_);
         r.insert<libu> (perform_clean_id,  "bin.libu", fail_);
 
+        r.insert<libul> (perform_update_id, "bin.libul", fail_);
+        r.insert<libul> (perform_clean_id,  "bin.libul", fail_);
+
         // Similar to alias.
         //
 
@@ -493,8 +502,8 @@ namespace build2
     }
 
     bool
-    ar_config_init (scope& r,
-                    scope& b,
+    ar_config_init (scope& rs,
+                    scope& bs,
                     const location& loc,
                     unique_ptr<module_base>&,
                     bool first,
@@ -502,18 +511,18 @@ namespace build2
                     const variable_map& hints)
     {
       tracer trace ("bin::ar_config_init");
-      l5 ([&]{trace << "for " << b.out_path ();});
+      l5 ([&]{trace << "for " << bs.out_path ();});
 
       // Make sure bin.config is loaded.
       //
-      if (!cast_false<bool> (b["bin.config.loaded"]))
-        load_module (r, b, "bin.config", loc, false, hints);
+      if (!cast_false<bool> (rs["bin.config.loaded"]))
+        load_module (rs, bs, "bin.config", loc, false, hints);
 
       // Enter configuration variables.
       //
       if (first)
       {
-        auto& v (var_pool.rw (r));
+        auto& v (var_pool.rw (rs));
 
         v.insert<process_path> ("bin.rc.path");
         v.insert<process_path> ("bin.ranlib.path");
@@ -543,12 +552,12 @@ namespace build2
 
         // Use the target to decide on the default binutils program names.
         //
-        const string& tsys (cast<string> (r["bin.target.system"]));
+        const string& tsys (cast<string> (rs["bin.target.system"]));
         const char* ar_d (tsys == "win32-msvc" ? "lib" : "ar");
 
         // This can be either a pattern or a fallback search directory.
         //
-        const string* pat (cast_null<string> (r["bin.pattern"]));
+        const string* pat (cast_null<string> (rs["bin.pattern"]));
         bool fb (pat != nullptr && path::traits::is_separator (pat->back ()));
 
         // Don't save the default value to config.build so that if the user
@@ -557,7 +566,7 @@ namespace build2
         //
         auto ap (
           config::required (
-            r,
+            rs,
             "config.bin.ar",
             path (apply_pattern (ar_d, fb ? nullptr : pat)),
             false,
@@ -565,7 +574,7 @@ namespace build2
 
         auto rp (
           config::required (
-            r,
+            rs,
             "config.bin.ranlib",
             nullptr,
             false,
@@ -585,7 +594,7 @@ namespace build2
           diag_record dr (text);
 
           {
-            dr << "bin.ar " << project (r) << '@' << r.out_path () << '\n'
+            dr << "bin.ar " << project (rs) << '@' << rs.out_path () << '\n'
                << "  ar         " << ari.ar_path << '\n'
                << "  id         " << ari.ar_id << '\n'
                << "  version    " << ari.ar_version.string () << '\n'
@@ -614,28 +623,28 @@ namespace build2
           }
         }
 
-        r.assign<process_path> ("bin.ar.path")      = move (ari.ar_path);
-        r.assign<string>       ("bin.ar.id")        = move (ari.ar_id);
-        r.assign<string>       ("bin.ar.signature") = move (ari.ar_signature);
-        r.assign<string>       ("bin.ar.checksum")  = move (ari.ar_checksum);
+        rs.assign<process_path> ("bin.ar.path")      = move (ari.ar_path);
+        rs.assign<string>       ("bin.ar.id")        = move (ari.ar_id);
+        rs.assign<string>       ("bin.ar.signature") = move (ari.ar_signature);
+        rs.assign<string>       ("bin.ar.checksum")  = move (ari.ar_checksum);
 
         {
           semantic_version& v (ari.ar_version);
 
-          r.assign<string>   ("bin.ar.version")       = v.string ();
-          r.assign<uint64_t> ("bin.ar.version.major") = v.major;
-          r.assign<uint64_t> ("bin.ar.version.minor") = v.minor;
-          r.assign<uint64_t> ("bin.ar.version.patch") = v.patch;
-          r.assign<string>   ("bin.ar.version.build") = move (v.build);
+          rs.assign<string>   ("bin.ar.version")       = v.string ();
+          rs.assign<uint64_t> ("bin.ar.version.major") = v.major;
+          rs.assign<uint64_t> ("bin.ar.version.minor") = v.minor;
+          rs.assign<uint64_t> ("bin.ar.version.patch") = v.patch;
+          rs.assign<string>   ("bin.ar.version.build") = move (v.build);
         }
 
         if (ranlib != nullptr)
         {
-          r.assign<process_path> ("bin.ranlib.path") = move (ari.ranlib_path);
-          r.assign<string>       ("bin.ranlib.id")   = move (ari.ranlib_id);
-          r.assign<string>       ("bin.ranlib.signature") =
+          rs.assign<process_path> ("bin.ranlib.path") = move (ari.ranlib_path);
+          rs.assign<string>       ("bin.ranlib.id")   = move (ari.ranlib_id);
+          rs.assign<string>       ("bin.ranlib.signature") =
             move (ari.ranlib_signature);
-          r.assign<string>       ("bin.ranlib.checksum") =
+          rs.assign<string>       ("bin.ranlib.checksum") =
             move (ari.ranlib_checksum);
         }
       }
@@ -644,8 +653,8 @@ namespace build2
     }
 
     bool
-    ar_init (scope& r,
-             scope& b,
+    ar_init (scope& rs,
+             scope& bs,
              const location& loc,
              unique_ptr<module_base>&,
              bool,
@@ -653,22 +662,22 @@ namespace build2
              const variable_map& hints)
     {
       tracer trace ("bin::ar_init");
-      l5 ([&]{trace << "for " << b.out_path ();});
+      l5 ([&]{trace << "for " << bs.out_path ();});
 
       // Make sure the bin core and ar.config are loaded.
       //
-      if (!cast_false<bool> (b["bin.loaded"]))
-        load_module (r, b, "bin", loc, false, hints);
+      if (!cast_false<bool> (bs["bin.loaded"]))
+        load_module (rs, bs, "bin", loc, false, hints);
 
-      if (!cast_false<bool> (b["bin.ar.config.loaded"]))
-        load_module (r, b, "bin.ar.config", loc, false, hints);
+      if (!cast_false<bool> (bs["bin.ar.config.loaded"]))
+        load_module (rs, bs, "bin.ar.config", loc, false, hints);
 
       return true;
     }
 
     bool
-    ld_config_init (scope& r,
-                    scope& b,
+    ld_config_init (scope& rs,
+                    scope& bs,
                     const location& loc,
                     unique_ptr<module_base>&,
                     bool first,
@@ -676,18 +685,18 @@ namespace build2
                     const variable_map& hints)
     {
       tracer trace ("bin::ld_config_init");
-      l5 ([&]{trace << "for " << b.out_path ();});
+      l5 ([&]{trace << "for " << bs.out_path ();});
 
       // Make sure bin.config is loaded.
       //
-      if (!cast_false<bool> (b["bin.config.loaded"]))
-        load_module (r, b, "bin.config", loc, false, hints);
+      if (!cast_false<bool> (rs["bin.config.loaded"]))
+        load_module (rs, rs, "bin.config", loc, false, hints);
 
       // Enter configuration variables.
       //
       if (first)
       {
-        auto& v (var_pool.rw (r));
+        auto& v (var_pool.rw (rs));
 
         v.insert<process_path> ("bin.ld.path");
         v.insert<path>         ("config.bin.ld", true);
@@ -701,17 +710,17 @@ namespace build2
         //
         // Use the target to decide on the default ld name.
         //
-        const string& tsys (cast<string> (r["bin.target.system"]));
+        const string& tsys (cast<string> (rs["bin.target.system"]));
         const char* ld_d (tsys == "win32-msvc" ? "link" : "ld");
 
         // This can be either a pattern or a fallback search directory.
         //
-        const string* pat (cast_null<string> (r["bin.pattern"]));
+        const string* pat (cast_null<string> (rs["bin.pattern"]));
         bool fb (pat != nullptr && path::traits::is_separator (pat->back ()));
 
         auto p (
           config::required (
-            r,
+            rs,
             "config.bin.ld",
             path (apply_pattern (ld_d, fb ? nullptr : pat)),
             false,
@@ -725,25 +734,25 @@ namespace build2
         //
         if (verb >= (p.second ? 2 : 3))
         {
-          text << "bin.ld " << project (r) << '@' << r.out_path () << '\n'
+          text << "bin.ld " << project (rs) << '@' << rs.out_path () << '\n'
                << "  ld         " << ldi.path << '\n'
                << "  id         " << ldi.id << '\n'
                << "  signature  " << ldi.signature << '\n'
                << "  checksum   " << ldi.checksum;
         }
 
-        r.assign<process_path> ("bin.ld.path")      = move (ldi.path);
-        r.assign<string>       ("bin.ld.id")        = move (ldi.id);
-        r.assign<string>       ("bin.ld.signature") = move (ldi.signature);
-        r.assign<string>       ("bin.ld.checksum")  = move (ldi.checksum);
+        rs.assign<process_path> ("bin.ld.path")      = move (ldi.path);
+        rs.assign<string>       ("bin.ld.id")        = move (ldi.id);
+        rs.assign<string>       ("bin.ld.signature") = move (ldi.signature);
+        rs.assign<string>       ("bin.ld.checksum")  = move (ldi.checksum);
       }
 
       return true;
     }
 
     bool
-    ld_init (scope& r,
-             scope& b,
+    ld_init (scope& rs,
+             scope& bs,
              const location& loc,
              unique_ptr<module_base>&,
              bool,
@@ -751,17 +760,17 @@ namespace build2
              const variable_map& hints)
     {
       tracer trace ("bin::ld_init");
-      l5 ([&]{trace << "for " << b.out_path ();});
+      l5 ([&]{trace << "for " << bs.out_path ();});
 
       // Make sure the bin core and ld.config are loaded.
       //
-      if (!cast_false<bool> (b["bin.loaded"]))
-        load_module (r, b, "bin", loc, false, hints);
+      if (!cast_false<bool> (bs["bin.loaded"]))
+        load_module (rs, bs, "bin", loc, false, hints);
 
-      if (!cast_false<bool> (b["bin.ld.config.loaded"]))
-        load_module (r, b, "bin.ld.config", loc, false, hints);
+      if (!cast_false<bool> (bs["bin.ld.config.loaded"]))
+        load_module (rs, bs, "bin.ld.config", loc, false, hints);
 
-      const string& lid (cast<string> (r["bin.ld.id"]));
+      const string& lid (cast<string> (rs["bin.ld.id"]));
 
       // Register the pdb{} target if using the VC toolchain.
       //
@@ -769,17 +778,17 @@ namespace build2
 
       if (lid == "msvc")
       {
-        const target_type& pdb (b.derive_target_type<file> ("pdb").first);
-        install_path (b, pdb, dir_path ("bin")); // Goes to install.bin
-        install_mode (b, pdb, "644");            // But not executable.
+        const target_type& pdb (bs.derive_target_type<file> ("pdb").first);
+        install_path (bs, pdb, dir_path ("bin")); // Goes to install.bin
+        install_mode (bs, pdb, "644");            // But not executable.
       }
 
       return true;
     }
 
     bool
-    rc_config_init (scope& r,
-                    scope& b,
+    rc_config_init (scope& rs,
+                    scope& bs,
                     const location& loc,
                     unique_ptr<module_base>&,
                     bool first,
@@ -787,18 +796,18 @@ namespace build2
                     const variable_map& hints)
     {
       tracer trace ("bin::rc_config_init");
-      l5 ([&]{trace << "for " << b.out_path ();});
+      l5 ([&]{trace << "for " << bs.out_path ();});
 
       // Make sure bin.config is loaded.
       //
-      if (!cast_false<bool> (b["bin.config.loaded"]))
-        load_module (r, b, "bin.config", loc, false, hints);
+      if (!cast_false<bool> (bs["bin.config.loaded"]))
+        load_module (rs, bs, "bin.config", loc, false, hints);
 
       // Enter configuration variables.
       //
       if (first)
       {
-        auto& v (var_pool.rw (r));
+        auto& v (var_pool.rw (rs));
 
         v.insert<process_path> ("bin.rc.path");
         v.insert<path>         ("config.bin.rc", true);
@@ -812,17 +821,17 @@ namespace build2
         //
         // Use the target to decide on the default rc name.
         //
-        const string& tsys (cast<string> (r["bin.target.system"]));
+        const string& tsys (cast<string> (rs["bin.target.system"]));
         const char* rc_d (tsys == "win32-msvc" ? "rc" : "windres");
 
         // This can be either a pattern or a fallback search directory.
         //
-        const string* pat (cast_null<string> (r["bin.pattern"]));
+        const string* pat (cast_null<string> (rs["bin.pattern"]));
         bool fb (pat != nullptr && path::traits::is_separator (pat->back ()));
 
         auto p (
           config::required (
-            r,
+            rs,
             "config.bin.rc",
             path (apply_pattern (rc_d, fb ? nullptr : pat)),
             false,
@@ -836,25 +845,25 @@ namespace build2
         //
         if (verb >= (p.second ? 2 : 3))
         {
-          text << "bin.rc " << project (r) << '@' << r.out_path () << '\n'
+          text << "bin.rc " << project (rs) << '@' << rs.out_path () << '\n'
                << "  rc         " << rci.path << '\n'
                << "  id         " << rci.id << '\n'
                << "  signature  " << rci.signature << '\n'
                << "  checksum   " << rci.checksum;
         }
 
-        r.assign<process_path> ("bin.rc.path")      = move (rci.path);
-        r.assign<string>       ("bin.rc.id")        = move (rci.id);
-        r.assign<string>       ("bin.rc.signature") = move (rci.signature);
-        r.assign<string>       ("bin.rc.checksum")  = move (rci.checksum);
+        rs.assign<process_path> ("bin.rc.path")      = move (rci.path);
+        rs.assign<string>       ("bin.rc.id")        = move (rci.id);
+        rs.assign<string>       ("bin.rc.signature") = move (rci.signature);
+        rs.assign<string>       ("bin.rc.checksum")  = move (rci.checksum);
       }
 
       return true;
     }
 
     bool
-    rc_init (scope& r,
-             scope& b,
+    rc_init (scope& rs,
+             scope& bs,
              const location& loc,
              unique_ptr<module_base>&,
              bool,
@@ -862,15 +871,15 @@ namespace build2
              const variable_map& hints)
     {
       tracer trace ("bin::rc_init");
-      l5 ([&]{trace << "for " << b.out_path ();});
+      l5 ([&]{trace << "for " << bs.out_path ();});
 
       // Make sure the bin core and rc.config are loaded.
       //
-      if (!cast_false<bool> (b["bin.loaded"]))
-        load_module (r, b, "bin", loc, false, hints);
+      if (!cast_false<bool> (bs["bin.loaded"]))
+        load_module (rs, bs, "bin", loc, false, hints);
 
-      if (!cast_false<bool> (b["bin.rc.config.loaded"]))
-        load_module (r, b, "bin.rc.config", loc, false, hints);
+      if (!cast_false<bool> (bs["bin.rc.config.loaded"]))
+        load_module (rs, bs, "bin.rc.config", loc, false, hints);
 
       return true;
     }
diff --git a/build2/bin/rule.cxx b/build2/bin/rule.cxx
index 9427697..b609c9a 100644
--- a/build2/bin/rule.cxx
+++ b/build2/bin/rule.cxx
@@ -37,15 +37,10 @@ namespace build2
     // The whole logic is pretty much as if we had our two group members as
     // our prerequisites.
     //
-    bool lib_rule::
-    match (action, target& xt, const string&) const
+    lib_rule::members lib_rule::
+    build_members (const scope& rs)
     {
-      lib& t (xt.as<lib> ());
-
-      // Get the library type to build. If not set for a target, this should
-      // be configured at the project scope by init().
-      //
-      const string& type (cast<string> (t["bin.lib"]));
+      const string& type (cast<string> (rs["bin.lib"]));
 
       bool a (type == "static" || type == "both");
       bool s (type == "shared" || type == "both");
@@ -54,8 +49,17 @@ namespace build2
         fail << "unknown library type: " << type <<
           info << "'static', 'shared', or 'both' expected";
 
-      t.a = a ? &search<liba> (t, t.dir, t.out, t.name) : nullptr;
-      t.s = s ? &search<libs> (t, t.dir, t.out, t.name) : nullptr;
+      return members {a, s};
+    }
+
+    bool lib_rule::
+    match (action, target& xt, const string&) const
+    {
+      lib& t (xt.as<lib> ());
+
+      members bm (build_members (t.root_scope ()));
+      t.a = bm.a ? &search<liba> (t, t.dir, t.out, t.name) : nullptr;
+      t.s = bm.s ? &search<libs> (t, t.dir, t.out, t.name) : nullptr;
 
       return true;
     }
diff --git a/build2/bin/rule.hxx b/build2/bin/rule.hxx
index d656f62..ab8d64b 100644
--- a/build2/bin/rule.hxx
+++ b/build2/bin/rule.hxx
@@ -44,6 +44,18 @@ namespace build2
 
       static target_state
       perform (action, const target&);
+
+      // Return library types to build according to the bin.lib value (set
+      // on project's root scope by init()).
+      //
+      struct members
+      {
+        bool a; // static
+        bool s; // shared
+      };
+
+      static members
+      build_members (const scope&);
     };
   }
 }
diff --git a/build2/bin/target.cxx b/build2/bin/target.cxx
index 0560b8e..6c62258 100644
--- a/build2/bin/target.cxx
+++ b/build2/bin/target.cxx
@@ -71,7 +71,7 @@ namespace build2
     // running serial. For the members it is also safe to set the group during
     // creation.
 
-    // obj*{}, bmi*{}, libu*{} member factory.
+    // obj*{} and bmi*{} member factory.
     //
     template <typename M, typename G>
     static target*
@@ -111,11 +111,11 @@ namespace build2
       false
     };
 
-    const target_type libue::static_type
+    const target_type obja::static_type
     {
-      "libue",
-      &libux::static_type,
-      &m_factory<libue, libu>,
+      "obja",
+      &objx::static_type,
+      &m_factory<obja, obj>,
       nullptr, /* fixed_extension */
       &target_extension_var<var_extension, nullptr>,
       &target_pattern_var<var_extension, nullptr>,
@@ -124,11 +124,11 @@ namespace build2
       false
     };
 
-    const target_type obja::static_type
+    const target_type bmia::static_type
     {
-      "obja",
-      &objx::static_type,
-      &m_factory<obja, obj>,
+      "bmia",
+      &bmix::static_type,
+      &m_factory<bmia, bmi>,
       nullptr, /* fixed_extension */
       &target_extension_var<var_extension, nullptr>,
       &target_pattern_var<var_extension, nullptr>,
@@ -137,11 +137,11 @@ namespace build2
       false
     };
 
-    const target_type bmia::static_type
+    const target_type objs::static_type
     {
-      "bmia",
-      &bmix::static_type,
-      &m_factory<bmia, bmi>,
+      "objs",
+      &objx::static_type,
+      &m_factory<objs, obj>,
       nullptr, /* fixed_extension */
       &target_extension_var<var_extension, nullptr>,
       &target_pattern_var<var_extension, nullptr>,
@@ -150,11 +150,11 @@ namespace build2
       false
     };
 
-    const target_type libua::static_type
+    const target_type bmis::static_type
     {
-      "libua",
-      &libux::static_type,
-      &m_factory<libua, libu>,
+      "bmis",
+      &bmix::static_type,
+      &m_factory<bmis, bmi>,
       nullptr, /* fixed_extension */
       &target_extension_var<var_extension, nullptr>,
       &target_pattern_var<var_extension, nullptr>,
@@ -163,11 +163,33 @@ namespace build2
       false
     };
 
-    const target_type objs::static_type
+    // libu*{} member factory.
+    //
+    template <typename M>
+    static target*
+    libux_factory (const target_type&, dir_path dir, dir_path out, string n)
     {
-      "objs",
-      &objx::static_type,
-      &m_factory<objs, obj>,
+      const target* g (targets.find<libu> (dir, out, n));
+
+      if (const target* g2 = targets.find<libul> (dir, out, n))
+      {
+        if (g != 0)
+          fail << "both " << *g << " and " << g2 << " targets declared";
+
+        g = g2;
+      }
+
+      M* m (new M (move (dir), move (out), move (n)));
+      m->group = g;
+
+      return m;
+    }
+
+    const target_type libue::static_type
+    {
+      "libue",
+      &libux::static_type,
+      &libux_factory<libue>,
       nullptr, /* fixed_extension */
       &target_extension_var<var_extension, nullptr>,
       &target_pattern_var<var_extension, nullptr>,
@@ -176,11 +198,12 @@ namespace build2
       false
     };
 
-    const target_type bmis::static_type
+
+    const target_type libua::static_type
     {
-      "bmis",
-      &bmix::static_type,
-      &m_factory<bmis, bmi>,
+      "libua",
+      &libux::static_type,
+      &libux_factory<libua>,
       nullptr, /* fixed_extension */
       &target_extension_var<var_extension, nullptr>,
       &target_pattern_var<var_extension, nullptr>,
@@ -193,7 +216,7 @@ namespace build2
     {
       "libus",
       &libux::static_type,
-      &m_factory<libus, libu>,
+      &libux_factory<libus>,
       nullptr, /* fixed_extension */
       &target_extension_var<var_extension, nullptr>,
       &target_pattern_var<var_extension, nullptr>,
@@ -255,6 +278,39 @@ namespace build2
       false
     };
 
+    // The same as g_factory() but without E.
+    //
+    static target*
+    libul_factory (const target_type&, dir_path dir, dir_path out, string n)
+    {
+      libua* a (phase == run_phase::load
+                ? const_cast<libua*> (targets.find<libua> (dir, out, n))
+                : nullptr);
+      libus* s (phase == run_phase::load
+                ? const_cast<libus*> (targets.find<libus> (dir, out, n))
+                : nullptr);
+
+      libul* g (new libul (move (dir), move (out), move (n)));
+
+      if (a != nullptr) a->group = g;
+      if (s != nullptr) s->group = g;
+
+      return g;
+    }
+
+    const target_type libul::static_type
+    {
+      "libul",
+      &libx::static_type,
+      &libul_factory,
+      nullptr,
+      nullptr,
+      nullptr,
+      nullptr,
+      &target_search,
+      false
+    };
+
     const target_type libu::static_type
     {
       "libu",
diff --git a/build2/bin/target.hxx b/build2/bin/target.hxx
index f0b427f..0bcdf90 100644
--- a/build2/bin/target.hxx
+++ b/build2/bin/target.hxx
@@ -135,7 +135,7 @@ namespace build2
       virtual const target_type& dynamic_type () const {return static_type;}
     };
 
-    // Common base for lib{} and libu{} groups.
+    // Common base for lib{} and libul{}/libu{} groups.
     //
     // We use mtime_target as a base for the "trust me it exists" functionality
     // which we use, for example, to have installed lib{} prerequisites that
@@ -150,13 +150,21 @@ namespace build2
       static const target_type static_type;
     };
 
-    // The libu{} target group (utility library).
+    // The libul{}/libu{} target groups (utility library).
     //
-    // All the members are static libraries that differ base on the kind of
+    // All the members are static libraries that differ based on the kind of
     // object files they contains. Note that the group is more like obj{}
     // rather than lib{} in that one does not build the group directly rather
     // picking a suitable member.
     //
+    // libul{} is a "library utility library" in that the choice of members is
+    // libua{} or libus{}, even when linking an executable (normally a unit
+    // test).
+    //
+    // libu{} is a general utility library with all three types of members. It
+    // would normally be used when you want to build both a library from
+    // libua{}/libus{} and an executable from libue{}.
+    //
     class libux: public file // Common base of all libuX{} static libraries.
     {
     public:
@@ -196,6 +204,16 @@ namespace build2
       virtual const target_type& dynamic_type () const {return static_type;}
     };
 
+    class libul: public libx
+    {
+    public:
+      using libx::libx;
+
+    public:
+      static const target_type static_type;
+      virtual const target_type& dynamic_type () const {return static_type;}
+    };
+
     class libu: public libx
     {
     public:
diff --git a/build2/cc/common.cxx b/build2/cc/common.cxx
index c6ef3bd..23c37ff 100644
--- a/build2/cc/common.cxx
+++ b/build2/cc/common.cxx
@@ -41,9 +41,14 @@ namespace build2
     //
     // 1. options
     // 2. lib itself (if self is true)
-    // 3. dependency libs (prerequisite_targets)
+    // 3. dependency libs (prerequisite_targets, left to right, depth-first)
     // 4. dependency libs (*.libs variables).
     //
+    // The first argument to proc_lib is a pointer to the last element of an
+    // array that contains the current library dependency chain all the way to
+    // the library passes to process_libraries(). The first element of this
+    // array is NULL.
+    //
     void common::
     process_libraries (
       action a,
@@ -55,7 +60,7 @@ namespace build2
       lflags lf,
       const function<bool (const file&,
                            bool la)>& proc_impl, // Implementation?
-      const function<void (const file*,          // Can be NULL.
+      const function<void (const file* const*,   // Can be NULL.
                            const string& path,   // Library path.
                            lflags,               // Link flags.
                            bool sys)>& proc_lib, // True if system library.
@@ -63,8 +68,16 @@ namespace build2
                            const string& type,   // cc.type
                            bool com,             // cc. or x.
                            bool exp)>& proc_opt, // *.export.
-      bool self /*= false*/) const               // Call proc_lib on l?
+      bool self /*= false*/,                     // Call proc_lib on l?
+      small_vector<const file*, 16>* chain) const
     {
+      small_vector<const file*, 16> chain_storage;
+      if (chain == nullptr)
+      {
+        chain = &chain_storage;
+        chain->push_back (nullptr);
+      }
+
       // See what type of library this is (C, C++, etc). Use it do decide
       // which x.libs variable name to use. If it's unknown, then we only
       // look into prerequisites.
@@ -177,6 +190,8 @@ namespace build2
       //
       if (self && proc_lib)
       {
+        chain->push_back (&l);
+
         // Note that while normally the path is assigned, in case of an import
         // stub the path to the DLL may not be known and so the path will be
         // empty (but proc_lib() will use the import stub).
@@ -187,7 +202,7 @@ namespace build2
                 ? cast_false<bool> (l.vars[c_system])
                 : !p.empty () && sys (top_sysd, p.string ()));
 
-        proc_lib (&l, p.string (), lf, s);
+        proc_lib (&chain->back (), p.string (), lf, s);
       }
 
       const scope& bs (t == nullptr || cc ? top_bs : l.base_scope ());
@@ -242,7 +257,7 @@ namespace build2
 
             process_libraries (a, bs, *li, *sysd,
                                *f, la, pt.data,
-                               proc_impl, proc_lib, proc_opt, true);
+                               proc_impl, proc_lib, proc_opt, true, chain);
           }
         }
       }
@@ -251,148 +266,154 @@ namespace build2
       // handling import, etc.
       //
       // If it is not a C-common library, then it probably doesn't have any of
-      // the *.libs and we are done.
-      //
-      if (t == nullptr)
-        return;
-
-      optional<dir_paths> usrd;                  // Extract lazily.
-
-      // Determine if a "simple path" is a system library.
+      // the *.libs.
       //
-      auto sys_simple = [&sysd, &sys, &find_sysd] (const string& p) -> bool
+      if (t != nullptr)
       {
-        bool s (!path::traits::absolute (p));
+        optional<dir_paths> usrd; // Extract lazily.
 
-        if (!s)
+        // Determine if a "simple path" is a system library.
+        //
+        auto sys_simple = [&sysd, &sys, &find_sysd] (const string& p) -> bool
         {
-          if (sysd == nullptr) find_sysd ();
+          bool s (!path::traits::absolute (p));
 
-          s = sys (*sysd, p);
-        }
+          if (!s)
+          {
+            if (sysd == nullptr) find_sysd ();
 
-        return s;
-      };
+            s = sys (*sysd, p);
+          }
 
-      auto proc_int = [&l,
-                       &proc_impl, &proc_lib, &proc_opt,
-                       &sysd, &usrd,
-                       &find_sysd, &find_linfo, &sys_simple,
-                       &bs, a, &li, this] (const lookup& lu)
-      {
-        const vector<name>* ns (cast_null<vector<name>> (lu));
-        if (ns == nullptr || ns->empty ())
-          return;
+          return s;
+        };
 
-        for (const name& n: *ns)
+        auto proc_int = [&l,
+                         &proc_impl, &proc_lib, &proc_opt, chain,
+                         &sysd, &usrd,
+                         &find_sysd, &find_linfo, &sys_simple,
+                         &bs, a, &li, this] (const lookup& lu)
         {
-          if (n.simple ())
-          {
-            // This is something like -lpthread or shell32.lib so should be a
-            // valid path. But it can also be an absolute library path (e.g.,
-            // something that in the future will come from our -static/-shared
-            // .pc files.
-            //
-            if (proc_lib)
-              proc_lib (nullptr, n.value, 0, sys_simple (n.value));
-          }
-          else
+          const vector<name>* ns (cast_null<vector<name>> (lu));
+          if (ns == nullptr || ns->empty ())
+            return;
+
+          for (const name& n: *ns)
           {
-            // This is a potentially project-qualified target.
-            //
-            if (sysd == nullptr) find_sysd ();
-            if (!li) find_linfo ();
+            if (n.simple ())
+            {
+              // This is something like -lpthread or shell32.lib so should be
+              // a valid path. But it can also be an absolute library path
+              // (e.g., something that in the future will come from our
+              // -static/-shared .pc files.
+              //
+              if (proc_lib)
+                proc_lib (nullptr, n.value, 0, sys_simple (n.value));
+            }
+            else
+            {
+              // This is a potentially project-qualified target.
+              //
+              if (sysd == nullptr) find_sysd ();
+              if (!li) find_linfo ();
 
-            const file& t (resolve_library (a, bs, n, *li, *sysd, usrd));
+              const file& t (resolve_library (a, bs, n, *li, *sysd, usrd));
 
-            if (proc_lib)
-            {
-              // This can happen if the target is mentioned in *.export.libs
-              // (i.e., it is an interface dependency) but not in the
-              // library's prerequisites (i.e., it is not an implementation
-              // dependency).
+              if (proc_lib)
+              {
+                // This can happen if the target is mentioned in *.export.libs
+                // (i.e., it is an interface dependency) but not in the
+                // library's prerequisites (i.e., it is not an implementation
+                // dependency).
+                //
+                // Note that we used to just check for path being assigned but
+                // on Windows import-installed DLLs may legally have empty
+                // paths.
+                //
+                if (t.mtime () == timestamp_unknown)
+                  fail << "interface dependency " << t << " is out of date" <<
+                    info << "mentioned in *.export.libs of target " << l <<
+                    info << "is it a prerequisite of " << l << "?";
+              }
+
+              // Process it recursively.
               //
-              // Note that we used to just check for path being assigned but
-              // on Windows import-installed DLLs may legally have empty
-              // paths.
+              // @@ Where can we get the link flags? Should we try to find
+              //    them in the library's prerequisites? What about installed
+              //    stuff?
               //
-              if (t.mtime () == timestamp_unknown)
-                fail << "interface dependency " << t << " is out of date" <<
-                  info << "mentioned in *.export.libs of target " << l <<
-                  info << "is it a prerequisite of " << l << "?";
+              process_libraries (a, bs, *li, *sysd,
+                                 t, t.is_a<liba> () || t.is_a<libux> (), 0,
+                                 proc_impl, proc_lib, proc_opt, true, chain);
             }
+          }
+        };
 
-            // Process it recursively.
-            //
-            // @@ Where can we get the link flags? Should we try to find them
-            //    in the library's prerequisites? What about installed stuff?
+        // Process libraries from *.libs (of type strings).
+        //
+        auto proc_imp = [&proc_lib, &sys_simple] (const lookup& lu)
+        {
+          const strings* ns (cast_null<strings> (lu));
+          if (ns == nullptr || ns->empty ())
+            return;
+
+          for (const string& n: *ns)
+          {
+            // This is something like -lpthread or shell32.lib so should be a
+            // valid path.
             //
-            process_libraries (a, bs, *li, *sysd,
-                               t, t.is_a<liba> () || t.is_a<libux> (), 0,
-                               proc_impl, proc_lib, proc_opt, true);
+            proc_lib (nullptr, n, 0, sys_simple (n));
           }
-        }
-      };
-
-      // Process libraries from *.libs (of type strings).
-      //
-      auto proc_imp = [&proc_lib, &sys_simple] (const lookup& lu)
-      {
-        const strings* ns (cast_null<strings> (lu));
-        if (ns == nullptr || ns->empty ())
-          return;
+        };
 
-        for (const string& n: *ns)
+        // Note: the same structure as when processing options above.
+        //
+        // If all we know is it's a C-common library, then in both cases we
+        // only look for cc.export.libs.
+        //
+        if (cc)
         {
-          // This is something like -lpthread or shell32.lib so should be a
-          // valid path.
-          //
-          proc_lib (nullptr, n, 0, sys_simple (n));
+          if (c_e_libs) proc_int (c_e_libs);
         }
-      };
-
-      // Note: the same structure as when processing options above.
-      //
-      // If all we know is it's a C-common library, then in both cases we only
-      // look for cc.export.libs.
-      //
-      if (cc)
-      {
-        if (c_e_libs) proc_int (c_e_libs);
-      }
-      else
-      {
-        if (impl)
+        else
         {
-          // Interface and implementation: as discussed above, we can have two
-          // situations: overriden export or default export.
-          //
-          if (c_e_libs.defined () || x_e_libs.defined ())
+          if (impl)
           {
-            if (c_e_libs) proc_int (c_e_libs);
-            if (x_e_libs) proc_int (x_e_libs);
+            // Interface and implementation: as discussed above, we can have
+            // two situations: overriden export or default export.
+            //
+            if (c_e_libs.defined () || x_e_libs.defined ())
+            {
+              if (c_e_libs) proc_int (c_e_libs);
+              if (x_e_libs) proc_int (x_e_libs);
+            }
+            else
+            {
+              // For default export we use the same options/libs as were used
+              // to build the library. Since libraries in (non-export) *.libs
+              // are not targets, we don't need to recurse.
+              //
+              if (proc_lib)
+              {
+                proc_imp (l[c_libs]);
+                proc_imp (l[same ? x_libs : vp[*t + ".libs"]]);
+              }
+            }
           }
           else
           {
-            // For default export we use the same options/libs as were used to
-            // build the library. Since libraries in (non-export) *.libs are
-            // not targets, we don't need to recurse.
+            // Interface: only add *.export.* (interface dependencies).
             //
-            if (proc_lib)
-            {
-              proc_imp (l[c_libs]);
-              proc_imp (l[same ? x_libs : vp[*t + ".libs"]]);
-            }
+            if (c_e_libs) proc_int (c_e_libs);
+            if (x_e_libs) proc_int (x_e_libs);
           }
         }
-        else
-        {
-          // Interface: only add *.export.* (interface dependencies).
-          //
-          if (c_e_libs) proc_int (c_e_libs);
-          if (x_e_libs) proc_int (x_e_libs);
-        }
       }
+
+      // Remove this library from the chain.
+      //
+      if (self && proc_lib)
+        chain->pop_back ();
     }
 
     // The name can be an absolute target name (e.g., /tmp/libfoo/lib{foo}) or
@@ -456,7 +477,7 @@ namespace build2
           fail << "unable to find library " << pk;
       }
 
-      // If this is lib{}/libu{}, pick appropriate member.
+      // If this is lib{}/libu*{}, pick appropriate member.
       //
       if (const libx* l = xt->is_a<libx> ())
         xt = &link_member (*l, a, li); // Pick lib*{e,a,s}{}.
diff --git a/build2/cc/common.hxx b/build2/cc/common.hxx
index 18824cb..d809050 100644
--- a/build2/cc/common.hxx
+++ b/build2/cc/common.hxx
@@ -220,9 +220,10 @@ namespace build2
         bool,
         lflags,
         const function<bool (const file&, bool)>&,
-        const function<void (const file*, const string&, lflags, bool)>&,
+        const function<void (const file* const*, const string&, lflags, bool)>&,
         const function<void (const file&, const string&, bool, bool)>&,
-        bool = false) const;
+        bool = false,
+        small_vector<const file*, 16>* = nullptr) const;
 
       const target*
       search_library (action a,
diff --git a/build2/cc/install-rule.cxx b/build2/cc/install-rule.cxx
index ee290e3..9e6b93f 100644
--- a/build2/cc/install-rule.cxx
+++ b/build2/cc/install-rule.cxx
@@ -53,8 +53,8 @@ namespace build2
       {
         const target* pt (&search (t, p));
 
-        // If this is the lib{}/libu{} group, pick a member which we would
-        // link. For libu{} we want the "see through" logic.
+        // If this is the lib{}/libu*{} group, pick a member which we would
+        // link. For libu*{} we want the "see through" logic.
         //
         if (const libx* l = pt->is_a<libx> ())
           pt = &link_member (*l, a, link_info (t.base_scope (), ot));
diff --git a/build2/cc/link-rule.cxx b/build2/cc/link-rule.cxx
index 0bfef09..5ebb97a 100644
--- a/build2/cc/link-rule.cxx
+++ b/build2/cc/link-rule.cxx
@@ -130,14 +130,19 @@ namespace build2
       }
 
       if (!(seen_x || seen_c || seen_obj || seen_lib))
+      {
+        l4 ([&]{trace << "no " << x_lang << ", C, or obj/lib prerequisite "
+                      << "for target " << t;});
         return false;
+      }
 
       // We will only chain a C source if there is also an X source or we were
       // explicitly told to.
       //
       if (seen_c && !seen_x && hint < x)
       {
-        l4 ([&]{trace << "C prerequisite without " << x_lang << " or hint";});
+        l4 ([&]{trace << "C prerequisite without " << x_lang << " or hint "
+                      << "for target " << t;});
         return false;
       }
 
@@ -1070,47 +1075,126 @@ namespace build2
                       const file& l, bool la, lflags lf,
                       const scope& bs, action a, linfo li) const
     {
-      // Note: lack of the "small function object" optimization will really
-      // kill us here since we are called in a loop.
-      //
+      struct data
+      {
+        strings&    args;
+        const file& l;
+        action      a;
+        linfo       li;
+      } d {args, l, a, li};
+
       auto imp = [] (const file&, bool la) {return la;};
 
-      auto lib = [&args, this] (const file* l, const string& p, lflags f, bool)
+      auto lib = [&d, this] (const file* const* lc,
+                             const string& p,
+                             lflags f,
+                             bool)
       {
-        if (l != nullptr)
+        const file* l (lc != nullptr ? *lc : nullptr);
+
+        if (l == nullptr)
         {
-          // 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 (l->member != nullptr && l->is_a<libs> () && tclass == "windows")
-            l = &l->member->as<file> ();
+          d.args.push_back (p);
+        }
+        else
+        {
+          bool lu (l->is_a<libux> ());
 
-          string p (relative (l->path ()).string ());
+          // The utility/non-utility case is tricky. Consider these two
+          // scenarios:
+          //
+          // exe -> (libu1-e -> libu1-e) -> (liba) -> libu-a -> (liba1)
+          // exe -> (liba) -> libu1-a -> libu1-a -> (liba1) -> libu-a1
+          //
+          // Libraries that should be linked are in '()'. That is, we need to
+          // link the initial sequence of utility libraries and then, after
+          // encountering a first non-utility, only link non-utilities
+          // (because they already contain their utility's object files).
+          //
+          if (lu)
+          {
+            for (ptrdiff_t i (-1); lc[i] != nullptr; --i)
+              if (!lc[i]->is_a<libux> ())
+                return;
+          }
 
-          if (f & lflag_whole)
+          if (d.li.type == otype::a)
           {
-            if (tsys == "win32-msvc")
-            {
-              p.insert (0, "/WHOLEARCHIVE:"); // Only available from VC14U2.
-            }
-            else if (tsys == "darwin")
+            // Linking a utility library to a static library.
+            //
+            // Note that utility library prerequisites of utility libraries
+            // are automatically handled by process_libraries(). So all we
+            // have to do is implement the "thin archive" logic.
+            //
+            // We may also end up trying to link a non-utility library to a
+            // static library via a utility library (direct linking is taken
+            // care of by perform_update()). So we cut it off here.
+            //
+            if (!lu)
+              return;
+
+            for (const target* pt: l->prerequisite_targets[d.a])
             {
-              p.insert (0, "-Wl,-force_load,");
+              if (pt == nullptr)
+                continue;
+
+              if (modules)
+              {
+                if (pt->is_a<bmix> ())
+                  pt = pt->member;
+              }
+
+              // We could have dependency diamonds with utility libraries.
+              // Repeats will be handled by the linker (in fact, it could be
+              // required to repeat them to satisfy all the symbols) but here
+              // we have to suppress duplicates ourselves.
+              //
+              if (const file* f = pt->is_a<objx> ())
+              {
+                string p (relative (f->path ()).string ());
+                if (find (d.args.begin (), d.args.end (), p) == d.args.end ())
+                  d.args.push_back (move (p));
+              }
             }
-            else
+          }
+          else
+          {
+            // Linking a library to a shared library or executable.
+            //
+
+            // 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 (l->member != nullptr &&
+                l->is_a<libs> ()     &&
+                tclass == "windows")
+              l = &l->member->as<file> ();
+
+            string p (relative (l->path ()).string ());
+
+            if (f & lflag_whole)
             {
-              args.push_back ("-Wl,--whole-archive");
-              args.push_back (move (p));
-              args.push_back ("-Wl,--no-whole-archive");
-              return;
+              if (tsys == "win32-msvc")
+              {
+                p.insert (0, "/WHOLEARCHIVE:"); // Only available from VC14U2.
+              }
+              else if (tsys == "darwin")
+              {
+                p.insert (0, "-Wl,-force_load,");
+              }
+              else
+              {
+                d.args.push_back ("-Wl,--whole-archive");
+                d.args.push_back (move (p));
+                d.args.push_back ("-Wl,--no-whole-archive");
+                return;
+              }
             }
-          }
 
-          args.push_back (move (p));
+            d.args.push_back (move (p));
+          }
         }
-        else
-          args.push_back (p);
       };
 
       auto opt = [&args, this] (
@@ -1149,12 +1233,43 @@ namespace build2
         const dir_path& out_root;
         bool&           update;
         timestamp       mt;
-      } d {cs, bs.root_scope ()->out_path (), update, mt};
+        linfo           li;
+      } d {cs, bs.root_scope ()->out_path (), update, mt, li};
 
-      auto lib = [&d, this] (const file* l, const string& p, lflags f, bool)
+      auto lib = [&d, this] (const file* const* lc,
+                             const string& p,
+                             lflags f,
+                             bool)
       {
-        if (l != nullptr)
+        const file* l (lc != nullptr ? *lc : nullptr);
+
+        if (l == nullptr)
         {
+          d.cs.append (p);
+        }
+        else
+        {
+          bool lu (l->is_a<libux> ());
+
+          if (lu)
+          {
+            for (ptrdiff_t i (-1); lc[i] != nullptr; --i)
+              if (!lc[i]->is_a<libux> ())
+                return;
+          }
+
+          // We also don't need to do anything special for linking a utility
+          // library to a static library. If any of its object files (or the
+          // set of its object files) changes, then the library will have to
+          // be updated as well. In other words, we use the library timestamp
+          // as a proxy for all of its member's timestamps.
+          //
+          // We do need to cut of the static to static linking, just as in
+          // append_libraries().
+          //
+          if (d.li.type == otype::a && !lu)
+            return;
+
           // Check if this library renders us out of date.
           //
           d.update = d.update || l->newer (d.mt);
@@ -1169,8 +1284,6 @@ namespace build2
           d.cs.append (f);
           hash_path (d.cs, l->path (), d.out_root);
         }
-        else
-          d.cs.append (p);
       };
 
       auto opt = [&cs, this] (
@@ -1238,8 +1351,13 @@ namespace build2
         bool for_install;
       } d {args, for_install};
 
-      auto lib = [&d, this] (const file* l, const string& f, lflags, bool sys)
+      auto lib = [&d, this] (const file* const* lc,
+                             const string& f,
+                             lflags,
+                             bool sys)
       {
+        const file* l (lc != nullptr ? *lc : nullptr);
+
         // We don't rpath system libraries. Why, you may ask? There are many
         // good reasons and I have them written on a napkin somewhere...
         //
@@ -1293,7 +1411,8 @@ namespace build2
       // In case we don't have the "small function object" optimization.
       //
       const function<bool (const file&, bool)> impf (imp);
-      const function<void (const file*, const string&, lflags, bool)> libf (lib);
+      const function<
+        void (const file* const*, const string&, lflags, bool)> libf (lib);
 
       for (const prerequisite_target& pt: t.prerequisite_targets[a])
       {
@@ -1544,7 +1663,10 @@ namespace build2
 
       if (lt.static_library ())
       {
-        if (tsys == "win32-msvc") ;
+        if (tsys == "win32-msvc")
+        {
+          // No options for lib.exe.
+        }
         else
         {
           // If the user asked for ranlib, don't try to do its function with
@@ -1700,7 +1822,7 @@ namespace build2
       // pinpoint exactly what is causing the update. On the other hand, the
       // checksum is faster and simpler. And we like simple.
       //
-      const file* def (nullptr); // Cache if present.
+      const file* def (nullptr); // Cached if present.
       {
         sha256 cs;
 
@@ -1722,10 +1844,16 @@ namespace build2
           const file* f;
           bool la (false), ls (false);
 
-          if ((f = pt->is_a<objx> ()) ||
-              (!lt.static_library () && // @@ UTL: TODO libua to liba link.
+          // We link utility libraries to everything except other utility
+          // libraries. In case of linking to liba{} we follow the "thin
+          // archive" lead and "see through" to their object file
+          // prerequisites (recursively, until we encounter a non-utility).
+          //
+          if ((f = pt->is_a<objx> ())           ||
+              (!lt.utility &&
+               (la = (f = pt->is_a<libux> ()))) ||
+              (!lt.static_library () &&
                ((la = (f = pt->is_a<liba>  ())) ||
-                (la = (f = pt->is_a<libux> ())) ||
                 (ls = (f = pt->is_a<libs>  ())))))
           {
             // Link all the dependent interface libraries (shared) or interface
@@ -1774,7 +1902,7 @@ namespace build2
         if (!manifest.empty ())
           hash_path (cs, manifest, rs.out_path ());
 
-        // Treat .libs as inputs, not options.
+        // Treat *.libs variable values as inputs, not options.
         //
         if (!lt.static_library ())
         {
@@ -2020,6 +2148,8 @@ namespace build2
 
       // The same logic as during hashing above.
       //
+      // See also a similar loop inside append_libraries().
+      //
       for (const prerequisite_target& p: t.prerequisite_targets[a])
       {
         const target* pt (p.target);
@@ -2036,15 +2166,13 @@ namespace build2
         const file* f;
         bool la (false), ls (false);
 
-        if ((f = pt->is_a<objx> ()) ||
-            (!lt.static_library () && // @@ UTL: TODO libua to liba link.
+        if ((f = pt->is_a<objx> ())           ||
+            (!lt.utility &&
+             (la = (f = pt->is_a<libux> ()))) ||
+            (!lt.static_library () &&
              ((la = (f = pt->is_a<liba>  ())) ||
-              (la = (f = pt->is_a<libux> ())) ||
               (ls = (f = pt->is_a<libs>  ())))))
         {
-          // Link all the dependent interface libraries (shared) or interface
-          // and implementation (static), recursively.
-          //
           if (la || ls)
             append_libraries (sargs, *f, la, p.data, bs, a, li);
           else
@@ -2199,6 +2327,27 @@ namespace build2
         throw failed ();
       }
 
+      // VC link.exe creates an import library and .exp file for an executable
+      // if any of its object files export any symbols (think a unit test
+      // linking libus{}). And, no, there is no way to suppress it. Well,
+      // there is a way: create a .def file with an empty EXPORTS section,
+      // pass it to lib.exe to create a dummy .exp (and .lib), and then pass
+      // this empty .exp to link.exe. Wanna go this way? Didn't think so.
+      // Having no way to disable this, the next simplest thing seems to be
+      // just cleaning the mess up.
+      //
+      // Note also that if at some point we decide to support such "shared
+      // executables" (-rdynamic, etc), then it will probably have to be a
+      // different target type (exes{}?) since it will need a different set
+      // of object files (-fPIC so probably objs{}), etc.
+      //
+      if (lt.executable () && tsys == "win32-msvc")
+      {
+        path b (relt.base ());
+        try_rmfile (b + ".lib", true /* ignore_errors */);
+        try_rmfile (b + ".exp", true /* ignore_errors */);
+      }
+
       if (ranlib)
       {
         const process_path& rl (cast<process_path> (ranlib));
diff --git a/build2/cc/msvc.cxx b/build2/cc/msvc.cxx
index 4346872..9eb3de0 100644
--- a/build2/cc/msvc.cxx
+++ b/build2/cc/msvc.cxx
@@ -65,12 +65,22 @@ namespace build2
       {
         // "   Creating library foo\foo.dll.lib and object foo\foo.dll.exp"
         //
-        if (lt == otype::s && l.compare (0, 3, "   ") == 0)
+        // This can also appear when linking executables if any of the object
+        // files export any symbols.
+        //
+        if (l.compare (0, 3, "   ") == 0)
         {
-          path imp (t.member->as<file> ().path ().leaf ());
+          // Use the actual import library name if this is a library (since we
+          // override this name) and the executable name otherwise (by default
+          // .lib/.exp are named by replacing the .exe extension).
+          //
+          path i (
+            lt == otype::s
+            ? t.member->as<file> ().path ().leaf ()
+            : t.path ().leaf ().base () + ".lib");
 
-          if (l.find (imp.string ()) != string::npos &&
-              l.find (imp.base ().string () + ".exp") != string::npos)
+          if (l.find (i.string ())                  != string::npos &&
+              l.find (i.base ().string () + ".exp") != string::npos)
             continue;
         }
 
diff --git a/build2/cc/pkgconfig.cxx b/build2/cc/pkgconfig.cxx
index 55c8b35..d331f7e 100644
--- a/build2/cc/pkgconfig.cxx
+++ b/build2/cc/pkgconfig.cxx
@@ -1265,11 +1265,13 @@ namespace build2
         bool priv (false);
         auto imp = [&priv] (const file&, bool la) {return priv && la;};
 
-        auto lib = [&os, &save_library] (const file* l,
+        auto lib = [&os, &save_library] (const file* const* c,
                                          const string& p,
                                          lflags,
                                          bool)
         {
+          const file* l (c != nullptr ? *c : nullptr);
+
           if (l != nullptr)
           {
             if (l->is_a<libs> () || l->is_a<liba> ()) // See through libux.
diff --git a/build2/cc/utility.cxx b/build2/cc/utility.cxx
index 830a957..080578c 100644
--- a/build2/cc/utility.cxx
+++ b/build2/cc/utility.cxx
@@ -8,6 +8,7 @@
 #include <build2/variable.hxx>
 #include <build2/algorithm.hxx> // search()
 
+#include <build2/bin/rule.hxx>
 #include <build2/bin/target.hxx>
 
 using namespace std;
@@ -45,17 +46,35 @@ namespace build2
     const target&
     link_member (const bin::libx& x, action a, linfo li)
     {
-      if (const libu* u = x.is_a<libu> ())
+      bool ul;
+
+      if ((ul = x.is_a<libul> ()) || x.is_a<libu> ())
       {
-        const target_type& tt (li.type == otype::e ? libue::static_type :
-                               li.type == otype::a ? libua::static_type :
-                               libus::static_type);
+        // If this is a libul{} and we are linking an executable, then the
+        // member choice should be dictated by the members of lib{} this
+        // libul{} is "primarily" for. If both are being built, then it seems
+        // natural to prefer static over shared since it could be faster (but
+        // I am sure someone will probably want this configurable).
+        //
+        if (ul && li.type == otype::e)
+        {
+          // Utility libraries are project-local which means the primarily
+          // target should be in the same project as us.
+          //
+          li.type = lib_rule::build_members (x.root_scope ()).a
+            ? otype::a
+            : otype::s;
+        }
+
+        const target_type& tt (li.type == otype::a ? libua::static_type :
+                               li.type == otype::s ? libus::static_type :
+                               libue::static_type);
 
         // Called by the compile rule during execute.
         //
         return phase == run_phase::match
-          ? search (*u, tt, u->dir, u->out, u->name)
-          : *search_existing (tt, u->dir, u->out, u->name);
+          ? search (x, tt, x.dir, x.out, x.name)
+          : *search_existing (tt, x.dir, x.out, x.name);
       }
       else
       {
diff --git a/build2/cc/utility.hxx b/build2/cc/utility.hxx
index 18de360..c378e74 100644
--- a/build2/cc/utility.hxx
+++ b/build2/cc/utility.hxx
@@ -54,7 +54,7 @@ namespace build2
     }
 
     // Given the link order return the library member to link. That is, liba{}
-    // or libs{} for lib{} and libue{}, libua{} or libus{} for libu{}.
+    // or libs{} for lib{} and libue{}, libua{} or libus{} for libu*{}.
     //
     const target&
     link_member (const bin::libx&, action, linfo);
diff --git a/build2/cc/windows-rpath.cxx b/build2/cc/windows-rpath.cxx
index c710e66..268bab2 100644
--- a/build2/cc/windows-rpath.cxx
+++ b/build2/cc/windows-rpath.cxx
@@ -59,8 +59,13 @@ namespace build2
       //
       auto imp = [] (const file&, bool) {return true;};
 
-      auto lib = [&r] (const file* l, const string& f, lflags, bool sys)
+      auto lib = [&r] (const file* const* lc,
+                       const string& f,
+                       lflags,
+                       bool sys)
       {
+        const file* l (lc != nullptr ? *lc : nullptr);
+
         // We don't rpath system libraries.
         //
         if (sys)
@@ -135,8 +140,13 @@ namespace build2
 
       auto imp = [] (const file&, bool) {return true;};
 
-      auto lib = [&r, &bs] (const file* l, const string& f, lflags, bool sys)
+      auto lib = [&r, &bs] (const file* const* lc,
+                            const string& f,
+                            lflags,
+                            bool sys)
       {
+        const file* l (lc != nullptr ? *lc : nullptr);
+
         if (sys)
           return;