Add pkg-config support for import installed

Redesign library importing/exporting while at it.

20 files changed, 1119 insertions, 307 deletions

diff --git a/build2/b.cxx b/build2/b.cxx
index 81e1b2f..bb4f0fe 100644
--- a/build2/b.cxx
+++ b/build2/b.cxx
@@ -47,6 +47,7 @@ using namespace std;
 #include <build2/cli/init>
 #include <build2/test/init>
 #include <build2/install/init>
+#include <build2/pkgconfig/init>
 
 using namespace build2;
 
@@ -228,6 +229,9 @@ main (int argc, char* argv[])
       bm["bin.rc.config"] = mf {nullptr, &bin::rc_config_init};
       bm["bin.rc"] = mf {nullptr, &bin::rc_init};
 
+      bm["pkgconfig.config"] = mf {nullptr, &pkgconfig::config_init};
+      bm["pkgconfig"] = mf {nullptr, &pkgconfig::init};
+
       bm["cc.core.vars"] = mf {nullptr, &cc::core_vars_init};
       bm["cc.core.config"] = mf {nullptr, &cc::core_config_init};
       bm["cc.core"] = mf {nullptr, &cc::core_init};
diff --git a/build2/bin/init.cxx b/build2/bin/init.cxx
index 125bc7d..bf7dd69 100644
--- a/build2/bin/init.cxx
+++ b/build2/bin/init.cxx
@@ -30,8 +30,8 @@ namespace build2
     // Default config.bin.*.lib values.
     //
     static const strings exe_lib {"shared", "static"};
-    static const strings liba_lib {"static"};
-    static const strings libs_lib {"shared"};
+    static const strings liba_lib {"static", "shared"};
+    static const strings libs_lib {"shared", "static"};
 
     bool
     config_init (scope& r,
diff --git a/build2/buildfile b/build2/buildfile
index 3aa515f..ad5a023 100644
--- a/build2/buildfile
+++ b/build2/buildfile
@@ -4,75 +4,77 @@
 
 import libs = libbutl%lib{butl}
 
-exe{b}:                                       \
-        {hxx ixx     cxx}{ algorithm        } \
-        {            cxx}{ b                } \
-        {hxx ixx     cxx}{ b-options        } \
-        {hxx     txx cxx}{ context          } \
-        {hxx         cxx}{ depdb            } \
-        {hxx         cxx}{ diagnostics      } \
-        {hxx         cxx}{ dump             } \
-        {hxx ixx     cxx}{ file             } \
-	{hxx     txx cxx}{ filesystem       } \
-        {hxx         cxx}{ lexer            } \
-        {hxx         cxx}{ module           } \
-        {hxx ixx     cxx}{ name             } \
-        {hxx         cxx}{ operation        } \
-        {hxx         cxx}{ parser           } \
-        {hxx         cxx}{ prerequisite     } \
-        {hxx         cxx}{ rule             } \
-        {hxx            }{ rule-map         } \
-        {hxx         cxx}{ scope            } \
-        {hxx         cxx}{ search           } \
-        {hxx         cxx}{ spec             } \
-        {hxx ixx txx cxx}{ target           } \
-        {hxx            }{ target-key       } \
-        {hxx            }{ target-type      } \
-        {hxx         cxx}{ token            } \
-        {hxx            }{ types            } \
-	{hxx         cxx}{ types-parsers    } \
-        {hxx ixx txx cxx}{ utility          } \
-        {hxx ixx txx cxx}{ variable         } \
-        {hxx            }{ version          } \
-    bin/{hxx         cxx}{ guess            } \
-    bin/{hxx         cxx}{ init             } \
-    bin/{hxx         cxx}{ rule             } \
-    bin/{hxx         cxx}{ target           } \
-      c/{hxx         cxx}{ init             } \
-      c/{hxx            }{ target           } \
-     cc/{hxx            }{ common           } \
-     cc/{hxx         cxx}{ compile          } \
-     cc/{hxx         cxx}{ guess            } \
-     cc/{hxx         cxx}{ init             } \
-     cc/{hxx         cxx}{ install          } \
-     cc/{hxx         cxx}{ link             } \
-     cc/{hxx         cxx}{ module           } \
-     cc/{            cxx}{ msvc             } \
-     cc/{hxx         cxx}{ target           } \
-     cc/{hxx            }{ types            } \
-     cc/{hxx ixx     cxx}{ utility          } \
-     cc/{            cxx}{ windows-manifest } \
-     cc/{            cxx}{ windows-rpath    } \
-    cli/{hxx         cxx}{ init             } \
-    cli/{hxx         cxx}{ rule             } \
-    cli/{hxx         cxx}{ target           } \
- config/{hxx         cxx}{ init             } \
- config/{hxx            }{ module           } \
- config/{hxx         cxx}{ operation        } \
- config/{hxx     txx cxx}{ utility          } \
-    cxx/{hxx         cxx}{ init             } \
-    cxx/{hxx         cxx}{ target           } \
-   dist/{hxx         cxx}{ init             } \
-   dist/{hxx         cxx}{ operation        } \
-   dist/{hxx         cxx}{ rule             } \
-install/{hxx         cxx}{ init             } \
-install/{hxx         cxx}{ operation        } \
-install/{hxx         cxx}{ rule             } \
-install/{hxx            }{ utility          } \
-   test/{hxx         cxx}{ init             } \
-   test/{hxx         cxx}{ operation        } \
-   test/{hxx         cxx}{ rule             } \
-$libs
+exe{b}:                                         \
+          {hxx ixx     cxx}{ algorithm        } \
+          {            cxx}{ b                } \
+          {hxx ixx     cxx}{ b-options        } \
+          {hxx     txx cxx}{ context          } \
+          {hxx         cxx}{ depdb            } \
+          {hxx         cxx}{ diagnostics      } \
+          {hxx         cxx}{ dump             } \
+          {hxx ixx     cxx}{ file             } \
+	  {hxx     txx cxx}{ filesystem       } \
+          {hxx         cxx}{ lexer            } \
+          {hxx         cxx}{ module           } \
+          {hxx ixx     cxx}{ name             } \
+          {hxx         cxx}{ operation        } \
+          {hxx         cxx}{ parser           } \
+          {hxx         cxx}{ prerequisite     } \
+          {hxx         cxx}{ rule             } \
+          {hxx            }{ rule-map         } \
+          {hxx         cxx}{ scope            } \
+          {hxx         cxx}{ search           } \
+          {hxx         cxx}{ spec             } \
+          {hxx ixx txx cxx}{ target           } \
+          {hxx            }{ target-key       } \
+          {hxx            }{ target-type      } \
+          {hxx         cxx}{ token            } \
+          {hxx            }{ types            } \
+	  {hxx         cxx}{ types-parsers    } \
+          {hxx ixx txx cxx}{ utility          } \
+          {hxx ixx txx cxx}{ variable         } \
+          {hxx            }{ version          } \
+      bin/{hxx         cxx}{ guess            } \
+      bin/{hxx         cxx}{ init             } \
+      bin/{hxx         cxx}{ rule             } \
+      bin/{hxx         cxx}{ target           } \
+        c/{hxx         cxx}{ init             } \
+        c/{hxx            }{ target           } \
+       cc/{hxx            }{ common           } \
+       cc/{hxx         cxx}{ compile          } \
+       cc/{hxx         cxx}{ guess            } \
+       cc/{hxx         cxx}{ init             } \
+       cc/{hxx         cxx}{ install          } \
+       cc/{hxx         cxx}{ link             } \
+       cc/{hxx         cxx}{ module           } \
+       cc/{            cxx}{ msvc             } \
+       cc/{            cxx}{ pkgconfig        } \
+       cc/{hxx         cxx}{ target           } \
+       cc/{hxx            }{ types            } \
+       cc/{hxx ixx     cxx}{ utility          } \
+       cc/{            cxx}{ windows-manifest } \
+       cc/{            cxx}{ windows-rpath    } \
+      cli/{hxx         cxx}{ init             } \
+      cli/{hxx         cxx}{ rule             } \
+      cli/{hxx         cxx}{ target           } \
+   config/{hxx         cxx}{ init             } \
+   config/{hxx            }{ module           } \
+   config/{hxx         cxx}{ operation        } \
+   config/{hxx     txx cxx}{ utility          } \
+      cxx/{hxx         cxx}{ init             } \
+      cxx/{hxx         cxx}{ target           } \
+     dist/{hxx         cxx}{ init             } \
+     dist/{hxx         cxx}{ operation        } \
+     dist/{hxx         cxx}{ rule             } \
+pkgconfig/{hxx         cxx}{ init             } \
+  install/{hxx         cxx}{ init             } \
+  install/{hxx         cxx}{ operation        } \
+  install/{hxx         cxx}{ rule             } \
+  install/{hxx            }{ utility          } \
+     test/{hxx         cxx}{ init             } \
+     test/{hxx         cxx}{ operation        } \
+     test/{hxx         cxx}{ rule             } \
+                            $libs
 
 # Pass our compiler target to be used as build2 host.
 #
diff --git a/build2/c/init.cxx b/build2/c/init.cxx
index be72655..c846ae1 100644
--- a/build2/c/init.cxx
+++ b/build2/c/init.cxx
@@ -228,6 +228,8 @@ namespace build2
           cast<string> (r[cm.x_target_system]),
           cast<string> (r[cm.x_target_class]),
 
+          cast_null<process_path> (r["pkgconfig.path"]),
+
           c::static_type,
           hdr,
           inc
diff --git a/build2/cc/common b/build2/cc/common
index ff6841f..c25683c 100644
--- a/build2/cc/common
+++ b/build2/cc/common
@@ -96,6 +96,8 @@ namespace build2
       const string& tsys;    // x.target.system
       const string& tclass;  // x.target.class
 
+      const process_path* pkgconfig; // pkgconfig.path (can be NULL).
+
       const target_type& x_src;  // Source target type (c{}, cxx{}).
 
       // Array of target types that are considered headers. Keep them in the
@@ -131,6 +133,7 @@ namespace build2
             const string& tg,
             const string& sys,
             const string& class_,
+            const process_path* pkgc,
             const target_type& src,
             const target_type* const* hdr,
             const target_type* const* inc)
@@ -140,6 +143,7 @@ namespace build2
             x_install (install),
             x_uninstall (uninstall),
             cid (id), ctg (tg), tsys (sys), tclass (class_),
+            pkgconfig (pkgc),
             x_src (src), x_hdr (hdr), x_inc (inc) {}
     };
 
diff --git a/build2/cc/compile b/build2/cc/compile
index 2f1a0eb..5bff6b1 100644
--- a/build2/cc/compile
+++ b/build2/cc/compile
@@ -41,6 +41,12 @@ namespace build2
       perform_clean (action, target&) const;
 
     private:
+      void
+      append_lib_options (cstrings&, target&) const;
+
+      void
+      hash_lib_options (sha256&, target&) const;
+
       // Mapping of include prefixes (e.g., foo in <foo/bar>) for auto-
       // generated headers to directories where they will be generated.
       //
@@ -57,7 +63,7 @@ namespace build2
       append_prefixes (prefix_map&, target&, const variable&) const;
 
       void
-      append_lib_prefixes (prefix_map&, target&, lorder) const;
+      append_lib_prefixes (prefix_map&, target&) const;
 
       prefix_map
       build_prefix_map (target&, lorder) const;
diff --git a/build2/cc/compile.cxx b/build2/cc/compile.cxx
index 56122e8..fdd4231 100644
--- a/build2/cc/compile.cxx
+++ b/build2/cc/compile.cxx
@@ -62,6 +62,49 @@ namespace build2
       return nullptr;
     }
 
+    // Append or hash library options from a pair of *.export.* variables
+    // (first one is cc.export.*) recursively, prerequisite libraries first.
+    //
+    void compile::
+    append_lib_options (cstrings& args, target& xt) const
+    {
+      file& l (static_cast<file&> (xt));
+
+      auto opt = [&args, this] (file& l, const string& t, bool com, bool exp)
+      {
+        assert (exp);
+
+        const variable& var (
+          com
+          ? c_export_poptions
+          : (t == x ? x_export_poptions : var_pool[t + ".export.poptions"]));
+
+        append_options (args, l, var);
+      };
+
+      link_.process_libraries (l, l.is_a<liba> (), true, nullptr, opt);
+    }
+
+    void compile::
+    hash_lib_options (sha256& cs, target& xt) const
+    {
+      file& l (static_cast<file&> (xt));
+
+      auto opt = [&cs, this] (file& l, const string& t, bool com, bool exp)
+      {
+        assert (exp);
+
+        const variable& var (
+          com
+          ? c_export_poptions
+          : (t == x ? x_export_poptions : var_pool[t + ".export.poptions"]));
+
+        hash_options (cs, l, var);
+      };
+
+      link_.process_libraries (l, l.is_a<liba> (), true, nullptr, opt);
+    }
+
     recipe compile::
     apply (action a, target& xt, const match_result& mr) const
     {
@@ -131,14 +174,18 @@ namespace build2
       //
       optional<dir_paths> lib_paths; // Extract lazily.
 
+      lorder lo;
+      if (a.operation () == update_id)
+        lo = link_order (bs, ct);
+
       for (prerequisite_member p: group_prerequisite_members (a, t))
       {
         // A dependency on a library is there so that we can get its
         // *.export.poptions. In particular, making sure it is executed before
         // us will only restrict parallelism. But we do need to pre-match it
-        // in order to get its prerequisite_targets populated. This is the
-        // "library meta-information protocol". See also append_lib_options()
-        // above.
+        // in order to get its imports resolved and prerequisite_targets
+        // populated. This is the "library meta-information protocol". See
+        // also append_lib_options().
         //
         if (p.is_a<lib> () || p.is_a<liba> () || p.is_a<libs> ())
         {
@@ -149,7 +196,8 @@ namespace build2
             // any, they would be set by search_library()).
             //
             if (p.proj () == nullptr ||
-                link_.search_library (lib_paths, p.prerequisite) == nullptr)
+                link_.search_library (
+                  lib_paths, p.prerequisite, lo) == nullptr)
             {
               match_only (a, p.search ());
             }
@@ -216,18 +264,16 @@ namespace build2
 
         // Hash *.export.poptions from prerequisite libraries.
         //
-        lorder lo (link_order (bs, ct));
         for (prerequisite& p: group_prerequisites (t))
         {
           target* pt (p.target); // Already searched and matched.
 
           if (lib* l = pt->is_a<lib> ())
             pt = &link_member (*l, lo);
+          else if (!pt->is_a<liba> () && !pt->is_a<libs> ())
+            continue;
 
-          if (pt->is_a<liba> () || pt->is_a<libs> ())
-            hash_lib_options (cs, *pt, lo,
-                              c_export_poptions,
-                              x_export_poptions);
+          hash_lib_options (cs, *pt);
         }
 
         hash_options (cs, t, c_poptions);
@@ -399,22 +445,23 @@ namespace build2
     // recursively, prerequisite libraries first.
     //
     void compile::
-    append_lib_prefixes (prefix_map& m, target& l, lorder lo) const
+    append_lib_prefixes (prefix_map& m, target& xt) const
     {
-      for (target* t: l.prerequisite_targets)
+      file& l (static_cast<file&> (xt));
+
+      auto opt = [&m, this] (file& l, const string& t, bool com, bool exp)
       {
-        if (t == nullptr)
-          continue;
+        assert (exp);
 
-        if (lib* l = t->is_a<lib> ())
-          t = &link_member (*l, lo); // Pick one of the members.
+        const variable& var (
+          com
+          ? c_export_poptions
+          : (t == x ? x_export_poptions : var_pool[t + ".export.poptions"]));
 
-        if (t->is_a<liba> () || t->is_a<libs> ())
-          append_lib_prefixes (m, *t, lo);
-      }
+        append_prefixes (m, l, var);
+      };
 
-      append_prefixes (m, l, c_export_poptions);
-      append_prefixes (m, l, x_export_poptions);
+      link_.process_libraries (l, l.is_a<liba> (), true, nullptr, opt);
     }
 
     auto compile::
@@ -430,10 +477,11 @@ namespace build2
         target* pt (p.target); // Already searched and matched.
 
         if (lib* l = pt->is_a<lib> ())
-          pt = &link_member (*l, lo); // Pick one of the members.
+          pt = &link_member (*l, lo);
+        else if (!pt->is_a<liba> () && !pt->is_a<libs> ())
+          continue;
 
-        if (pt->is_a<liba> () || pt->is_a<libs> ())
-          append_lib_prefixes (m, *pt, lo);
+        append_lib_prefixes (m, *pt);
       }
 
       // Then process our own.
@@ -657,11 +705,10 @@ namespace build2
 
           if (lib* l = pt->is_a<lib> ())
             pt = &link_member (*l, lo);
+          else if (!pt->is_a<liba> () && !pt->is_a<libs> ())
+            continue;
 
-          if (pt->is_a<liba> () || pt->is_a<libs> ())
-            append_lib_options (args, *pt, lo,
-                                c_export_poptions,
-                                x_export_poptions);
+          append_lib_options (args, *pt);
         }
 
         append_options (args, t, c_poptions);
@@ -1330,11 +1377,10 @@ namespace build2
 
         if (lib* l = pt->is_a<lib> ())
           pt = &link_member (*l, lo);
+        else if (!pt->is_a<liba> () && !pt->is_a<libs> ())
+          continue;
 
-        if (pt->is_a<liba> () || pt->is_a<libs> ())
-          append_lib_options (args, *pt, lo,
-                              c_export_poptions,
-                              x_export_poptions);
+        append_lib_options (args, *pt);
       }
 
       append_options (args, t, c_poptions);
diff --git a/build2/cc/init.cxx b/build2/cc/init.cxx
index 0f1fda7..066367d 100644
--- a/build2/cc/init.cxx
+++ b/build2/cc/init.cxx
@@ -65,6 +65,9 @@ namespace build2
       // "c", "cxx"). Currenly only set for libraries and is used to decide
       // which *.libs to use during static linking.
       //
+      // It can also be the special "cc" value which means a C-common library
+      // but specific language is not known. Used in import installed logic.
+      //
       v.insert<string> ("cc.type");
 
       return true;
@@ -228,6 +231,23 @@ namespace build2
           load_module ("bin.rc.config", r, b, loc);
       }
 
+      // Load (optionally) the pkgconfig.config module.
+      //
+      // @@ At some point we may also want to verify that targets matched
+      //    if it has already been loaded (by someone) else. Currently it
+      //    doesn't set pkgconfig.target. Perhaps only set if it was used
+      //    to derive the program name?
+      //
+      if (first && !cast_false<bool> (b["pkgconfig.config.loaded"]))
+      {
+        // Prepare configuration hints.
+        //
+        variable_map h;
+        h.assign ("config.pkgconfig.target") = cast<string> (r["cc.target"]);
+
+        load_module ("pkgconfig.config", r, r, loc, true, h);
+      }
+
       return true;
     }
 
diff --git a/build2/cc/link b/build2/cc/link
index aaf1cd7..474c299 100644
--- a/build2/cc/link
+++ b/build2/cc/link
@@ -40,6 +40,15 @@ namespace build2
       friend class compile;
 
       void
+      process_libraries (file&,
+                         bool,
+                         bool,
+                         const function<void (const path&)>&,
+                         const function<void (file&,
+                                              const string&,
+                                              bool,
+                                              bool)>&) const;
+      void
       append_libraries (strings&, file&, bool) const;
 
       void
@@ -62,6 +71,15 @@ namespace build2
       dir_paths
       extract_library_paths (scope&) const;
 
+      bool
+      pkgconfig_extract (scope&,
+                         file&,
+                         const string*,
+                         const string&,
+                         const dir_path&,
+                         optional<dir_paths>&,
+                         lorder) const;
+
       // Alternative search logic for VC (msvc.cxx).
       //
       bin::liba*
@@ -75,10 +93,12 @@ namespace build2
                           const prerequisite_key&) const;
 
       target*
-      search_library (optional<dir_paths>& spc, prerequisite& p) const
+      search_library (optional<dir_paths>& spc,
+                      prerequisite& p,
+                      lorder lo) const
       {
         if (p.target == nullptr) // First check the cache.
-          p.target = search_library (spc, p.key ());
+          p.target = search_library (spc, p.key (), lo);
 
         return p.target;
       }
@@ -86,7 +106,9 @@ namespace build2
       // Note that pk's scope should not be NULL (even if dir is absolute).
       //
       target*
-      search_library (optional<dir_paths>&, const prerequisite_key&) const;
+      search_library (optional<dir_paths>&,
+                      const prerequisite_key&,
+                      lorder) const;
 
       // Windows-specific (windows-manifest.cxx).
       //
diff --git a/build2/cc/link.cxx b/build2/cc/link.cxx
index 7e639ed..a4fa1dd 100644
--- a/build2/cc/link.cxx
+++ b/build2/cc/link.cxx
@@ -202,7 +202,9 @@ namespace build2
     }
 
     target* link::
-    search_library (optional<dir_paths>& spc, const prerequisite_key& p) const
+    search_library (optional<dir_paths>& spc,
+                    const prerequisite_key& p,
+                    lorder lo) const
     {
       tracer trace (x, "link::search_library");
 
@@ -437,7 +439,8 @@ namespace build2
 
       // Add the "using static/shared library" macro (used, for example, to
       // handle DLL export). The absence of either of these macros would mean
-      // some other build system that cannot distinguish between the two.
+      // some other build system that cannot distinguish between the two (and
+      // no pkg-config information).
       //
       auto add_macro = [this] (target& t, const char* suffix)
       {
@@ -446,6 +449,11 @@ namespace build2
         // messing with custom values. And if we are adding, then use the
         // generic cc.export.
         //
+        // The only way we could already have this value is if this same
+        // library was also imported as a project (as opposed to installed).
+        // Unlikely but possible. In this case the values were set by the
+        // export stub and we shouldn't touch them.
+        //
         if (!t.vars[x_export_poptions])
         {
           auto p (t.vars.insert (c_export_poptions));
@@ -478,11 +486,38 @@ namespace build2
         }
       };
 
-      if (a != nullptr)
-        add_macro (*a, "STATIC");
+      // Mark as a "cc" library unless already marked.
+      //
+      auto mark_cc = [this] (target& t) -> bool
+      {
+        auto p (t.vars.insert (c_type));
+
+        if (p.second)
+          p.first.get () = string ("cc");
+
+        return p.second;
+      };
+
+      // If the library already has cc.type, then assume it was either already
+      // imported or was matched by a rule.
+      //
+      if (a != nullptr && mark_cc (*a))
+      {
+        // Only add the default macro if we could not extract more precise
+        // information. The idea is that when we auto-generate .pc files, we
+        // will copy those macros (or custom ones) from *.export.poptions.
+        //
+        if (pkgconfig == nullptr ||
+            !pkgconfig_extract (*p.scope, *a, p.proj, name, *pd, spc, lo))
+          add_macro (*a, "STATIC");
+      }
 
-      if (s != nullptr)
-        add_macro (*s, "SHARED");
+      if (s != nullptr && mark_cc (*s))
+      {
+        if (pkgconfig == nullptr ||
+            !pkgconfig_extract (*p.scope, *s, p.proj, name, *pd, spc, lo))
+          add_macro (*s, "SHARED");
+      }
 
       if (l)
       {
@@ -606,6 +641,8 @@ namespace build2
         if (t.group != nullptr)
           t.group->prerequisite_targets.clear (); // lib{}'s
 
+        scope& bs (t.base_scope ());
+        lorder lo (link_order (bs, lt));
         optional<dir_paths> lib_paths; // Extract lazily.
 
         for (prerequisite_member p: group_prerequisite_members (a, t))
@@ -617,7 +654,7 @@ namespace build2
             // Handle imported libraries.
             //
             if (p.proj () != nullptr)
-              pt = search_library (lib_paths, p.prerequisite);
+              pt = search_library (lib_paths, p.prerequisite, lo);
 
             if (pt == nullptr)
             {
@@ -810,7 +847,7 @@ namespace build2
           // Handle imported libraries.
           //
           if (p.proj () != nullptr)
-            pt = search_library (lib_paths, p.prerequisite);
+            pt = search_library (lib_paths, p.prerequisite, lo);
 
           // The rest is the same basic logic as in search_and_match().
           //
@@ -1023,9 +1060,12 @@ namespace build2
       }
     }
 
-    // Recursively append/hash prerequisite libraries. Only interface
+    // Recursively process prerequisite libraries. Only interface
     // (*.export.libs) for shared libraries, interface and implementation
-    // (both prerequisite and from *.libs) for static libraries.
+    // (both prerequisite and from *.libs, unless overriden) for static
+    // libraries (unless iface_only is true, in which case we use
+    // *.export.libs even for static libraries which means *.export.libs
+    // should be set on lib{}, not libs{}).
     //
     // Note that here we assume that an interface library is also an
     // implementation (since we don't use *.export.libs in static link). We
@@ -1034,72 +1074,111 @@ namespace build2
     // listed as a prerequisite of this library).
     //
     void link::
-    append_libraries (strings& args, file& l, bool la) const
+    process_libraries (
+      file& l,
+      bool la,
+      bool iface_only,
+      const function<void (const path&)>& proc_lib,
+      const function<void (file&,
+                           const string& type,
+                           bool com, /* cc.     */
+                           bool exp) /* export. */>& proc_opt) const
     {
-      for (target* p: l.prerequisite_targets)
+      // 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.
+      //
+      const string* t (cast_null<string> (l.vars[c_type]));
+
+      lookup c_e_libs;
+      lookup x_e_libs;
+
+      if (t != nullptr)
       {
-        bool a;
-        file* f;
+        // If static, then the explicit export override should be set on the
+        // liba{} target itself. Note also that we only check for *.libs. If
+        // one doesn't have any libraries but needs to set, say, *.loptions,
+        // then *.libs should be set to NULL or empty (this is why we check
+        // for result being defined).
+        //
+        // @@ Should we set it in import installed then?
+        //
+        c_e_libs = la && !iface_only
+          ? l.vars[c_export_libs]
+          : l[c_export_libs];
 
-        if ((a = (f = p->is_a<liba> ()) != nullptr)
-            ||   (f = p->is_a<libs> ()) != nullptr)
+        if (*t != "cc")
         {
-          if (la)
-            args.push_back (relative (f->path ()).string ()); // string()&&
+          const variable& var (*t == x
+                               ? x_export_libs
+                               : var_pool[*t + ".export.libs"]);
 
-          append_libraries (args, *f, a);
+          x_e_libs = la && !iface_only ? l.vars[var] : l[var];
         }
       }
 
-      if (la)
+      // Only go into prerequisites (implementation dependencies) if this is a
+      // static library and it's not using explicit export. For shared library
+      // or if iface_only, we are only interested in interface dependencies
+      // which come from the *.export.libs below.
+      //
+      if (la && !iface_only && !c_e_libs.defined () && !x_e_libs.defined ())
       {
-        // See what type of library this is (C, C++, etc). Use it do decide
-        // which x.libs variable name. If it is not a C-common library, then
-        // it probably doesn't have cc.libs either.
-        //
-        if (const string* t = cast_null<string> (l.vars[c_type]))
+        for (target* p: l.prerequisite_targets)
         {
-          // @@ Shouldn't, ideally, we filter loptions to only include -L?
-          //
-          append_options (args, l, c_loptions);
-          append_options (args, l, c_libs);
-
-          append_options (args,
-                          l,
-                          *t == x ? x_loptions : var_pool[*t + ".loptions"]);
-          append_options (args,
-                          l,
-                          *t == x ? x_libs : var_pool[*t + ".libs"]);
+          bool a;
+          file* f;
+
+          if ((a = (f = p->is_a<liba> ()) != nullptr)
+              ||   (f = p->is_a<libs> ()) != nullptr)
+          {
+            if (proc_lib)
+              proc_lib (f->path ());
+
+            process_libraries (*f, a, iface_only, proc_lib, proc_opt);
+          }
         }
       }
-      else
-      {
-        scope* bs (nullptr);     // Resolve lazily.
-        optional<lorder> lo;     // Calculate lazily.
-        optional<dir_paths> spc; // Extract lazily.
 
-        auto append = [&args, &l, &bs, &lo, &spc, this] (const variable& var)
-        {
-          const names* ns (cast_null<names> (l[var]));
-          if (ns == nullptr || ns->empty ())
-            return;
+      // Process libraries (recursively) from *.export.libs (of type names)
+      // handling import, etc.
+      //
+      scope* bs (nullptr);     // Resolve lazily.
+      optional<lorder> lo;     // Calculate lazily.
+      optional<dir_paths> spc; // Extract lazily.
 
-          args.reserve (args.size () + ns->size ());
+      auto proc_int =
+        [&l, la, iface_only, &proc_lib, &proc_opt, &bs, &lo, &spc, this] (
+          const lookup& lu)
+      {
+        const names* ns (cast_null<names> (lu));
+        if (ns == nullptr || ns->empty ())
+          return;
 
-          for (const name& n: *ns)
+        for (const name& n: *ns)
+        {
+          if (n.simple ())
           {
-            if (n.simple ())
-              args.push_back (n.value);
-            else
-            {
-              if (bs == nullptr)
-                bs = &l.base_scope ();
+            // This is something like -lpthread or shell32.lib so should be
+            // a valid path.
+            //
+            if (proc_lib)
+              proc_lib (path (n.value));
+          }
+          else
+          {
+            // This is a potentially project-qualified target.
+            //
+            if (bs == nullptr)
+              bs = &l.base_scope ();
 
-              if (!lo)
-                lo = link_order (*bs, otype::s); // We know it's libs{}.
+            if (!lo)
+              lo = link_order (*bs, la ? otype::a : otype::s);
 
-              file& t (resolve_library (n, *bs, *lo, spc));
+            file& t (resolve_library (n, *bs, *lo, spc));
 
+            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
@@ -1107,116 +1186,148 @@ namespace build2
               //
               if (t.path ().empty ())
                 fail << "target " << t << " is out of date" <<
-                  info << "mentioned in " << var.name << " of target " << l <<
+                  info << "mentioned in *.export.libs of target " << l <<
                   info << "is it a prerequisite of " << l << "?";
 
-              args.push_back (relative (t.path ()).string ());
+              proc_lib (t.path ());
             }
-          }
-        };
-
-        // @@ Should we also pick one based on cc.type? And also *.poptions in
-        //    compile? Feels right.
-        //
-        append_options (args, l, c_export_loptions);
-        append (c_export_libs);
 
-        append_options (args, l, x_export_loptions);
-        append (x_export_libs);
-      }
-    }
+            // Process it recursively.
+            //
+            process_libraries (
+              t, t.is_a<liba> (), iface_only, proc_lib, proc_opt);
+          }
+        }
+      };
 
-    void link::
-    hash_libraries (sha256& cs, file& l, bool la) const
-    {
-      for (target* p: l.prerequisite_targets)
+      // Process libraries from *.libs (of type strings).
+      //
+      auto proc_imp = [&proc_lib] (const lookup& lu)
       {
-        bool a;
-        file* f;
+        const strings* ns (cast_null<strings> (lu));
+        if (ns == nullptr || ns->empty ())
+          return;
 
-        if ((a = (f = p->is_a<liba> ()) != nullptr)
-            ||   (f = p->is_a<libs> ()) != nullptr)
+        for (const string& n: *ns)
         {
-          if (la)
-            cs.append (f->path ().string ());
-
-          hash_libraries (cs, *f, a);
+          // This is something like -lpthread or shell32.lib so should be a
+          // valid path.
+          //
+          proc_lib (path (n));
         }
-      }
+      };
+
+      // 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;
 
-      if (la)
+      // If all we know it's a C-common library, then in both cases we only
+      // look for cc.export.libs.
+      //
+      if (*t == "cc")
       {
-        // See what type of library this is (C, C++, etc). Use it do decide
-        // which x.libs variable name. If it is not a C-common library, then
-        // it probably doesn't have cc.libs either.
-        //
-        if (const string* t = cast_null<string> (l.vars[c_type]))
-        {
-          // @@ Shouldn't, ideally, we filter loptions to only include -L?
-          //
-          hash_options (cs, l, c_loptions);
-          hash_options (cs, l, c_libs);
-
-          hash_options (cs,
-                        l,
-                        *t == x ? x_loptions : var_pool[*t + ".loptions"]);
-          hash_options (cs,
-                        l,
-                        *t == x ? x_libs : var_pool[*t + ".libs"]);
-        }
+        proc_opt (l, *t, true, true);
+        if (c_e_libs) proc_int (c_e_libs);
       }
       else
       {
-        scope* bs (nullptr);     // Resolve lazily.
-        optional<lorder> lo;     // Calculate lazily.
-        optional<dir_paths> spc; // Extract lazily.
+        bool same (*t == x); // Same as us.
+        auto& vp (var_pool);
 
-        auto hash = [&cs, &l, &bs, &lo, &spc, this] (const variable& var)
+        if (la && !iface_only)
         {
-          const names* ns (cast_null<names> (l[var]));
-          if (ns == nullptr || ns->empty ())
-            return;
+          // Static: as discussed above, here we can have two situations:
+          // explicit export or default export.
+          //
+          if (c_e_libs.defined () || x_e_libs.defined ())
+          {
+            // NOTE: should this not be from l.vars rather than l? Or perhaps
+            // we can assume non-common values will be set on libs{}/liba{}.
+            //
+            proc_opt (l, *t, true, true);
+            if (c_e_libs) proc_int (c_e_libs);
 
-          for (const name& n: *ns)
+            proc_opt (l, *t, false, true);
+            if (x_e_libs) proc_int (x_e_libs);
+          }
+          else
           {
-            if (n.simple ())
-              cs.append (n.value);
-            else
-            {
-              if (bs == nullptr)
-                bs = &l.base_scope ();
+            // 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.
+            //
+            proc_opt (l, *t, true, false);
+            if (proc_lib) proc_imp (l[c_libs]);
+
+            proc_opt (l, *t, false, false);
+            if (proc_lib) proc_imp (l[same ? x_libs : vp[*t + ".libs"]]);
+          }
+        }
+        else
+        {
+          // Shared or iface_only: only add *.export.* (interface
+          // dependencies).
+          //
+          proc_opt (l, *t, true, true);
+          if (c_e_libs) proc_int (c_e_libs);
+
+          proc_opt (l, *t, false, true);
+          if (x_e_libs) proc_int (x_e_libs);
+        }
+      }
+    }
 
-              if (!lo)
-                lo = link_order (*bs, otype::s); // We know it's libs{}.
+    void link::
+    append_libraries (strings& args, file& l, bool la) const
+    {
+      auto lib = [&args] (const path& l)
+      {
+        args.push_back (relative (l).string ());
+      };
 
-              file& t (resolve_library (n, *bs, *lo, spc));
+      auto opt = [&args, this] (file& l, const string& t, bool com, bool exp)
+      {
+        const variable& var (
+          com
+          ? (exp ? c_export_loptions : c_loptions)
+          : (t == x
+             ? (exp ? x_export_loptions : x_loptions)
+             : var_pool[t + (exp ? ".export.loptions" : ".loptions")]));
+
+        append_options (args, l, var);
+      };
 
-              // 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 (t.path ().empty ())
-                fail << "target " << t << " is out of date" <<
-                  info << "mentioned in " << var.name << " of target " << l <<
-                  info << "is it a prerequisite of " << l << "?";
+      process_libraries (l, la, false, lib, opt);
+    }
 
-              cs.append (t.path ().string ());
-            }
-          }
-        };
+    void link::
+    hash_libraries (sha256& cs, file& l, bool la) const
+    {
+      auto lib = [&cs] (const path& l)
+      {
+        cs.append (l.string ());
+      };
 
-        hash_options (cs, l, c_export_loptions);
-        hash (c_export_libs);
+      auto opt = [&cs, this] (file& l, const string& t, bool com, bool exp)
+      {
+        const variable& var (
+          com
+          ? (exp ? c_export_loptions : c_loptions)
+          : (t == x
+             ? (exp ? x_export_loptions : x_loptions)
+             : var_pool[t + (exp ? ".export.loptions" : ".loptions")]));
+
+        hash_options (cs, l, var);
+      };
 
-        hash_options (cs, l, x_export_loptions);
-        hash (x_export_libs);
-      }
+      process_libraries (l, la, false, lib, opt);
     }
 
-    // The name can be a simple value (e.g., -lpthread or shell32.lib), an
-    // absolute target name (e.g., /tmp/libfoo/lib{foo}) or a potentially
-    // project-qualified relative target name (e.g., libfoo%lib{foo}).
+    // The name can be an absolute target name (e.g., /tmp/libfoo/lib{foo}) or
+    // a potentially project-qualified relative target name (e.g.,
+    // libfoo%lib{foo}).
     //
     // Note that the scope, search paths, and the link order should all be
     // derived from the library target that mentioned this name. This way we
@@ -1257,7 +1368,7 @@ namespace build2
         dir_path out;
         prerequisite_key pk {n.proj, {tt, &n.dir, &out, &n.value, ext}, &s};
 
-        xt = search_library (spc, pk);
+        xt = search_library (spc, pk, lo);
 
         if (xt == nullptr)
         {
diff --git a/build2/cc/msvc.cxx b/build2/cc/msvc.cxx
index d088c5b..216bbf2 100644
--- a/build2/cc/msvc.cxx
+++ b/build2/cc/msvc.cxx
@@ -14,7 +14,6 @@
 #include <build2/bin/target>
 
 #include <build2/cc/types>
-
 #include <build2/cc/link>
 
 using namespace std;
diff --git a/build2/cc/pkgconfig.cxx b/build2/cc/pkgconfig.cxx
new file mode 100644
index 0000000..2122ea5
--- /dev/null
+++ b/build2/cc/pkgconfig.cxx
@@ -0,0 +1,446 @@
+// file      : build2/cc/msvc.cxx -*- C++ -*-
+// copyright : Copyright (c) 2014-2016 Code Synthesis Ltd
+// license   : MIT; see accompanying LICENSE file
+
+#include <build2/scope>
+#include <build2/target>
+#include <build2/context>
+#include <build2/variable>
+#include <build2/filesystem>
+#include <build2/diagnostics>
+
+#include <build2/bin/target>
+
+#include <build2/cc/link>
+#include <build2/cc/types>
+#include <build2/cc/utility>
+
+using namespace std;
+using namespace butl;
+
+namespace build2
+{
+  namespace cc
+  {
+    using namespace bin;
+
+    // Try to find a .pc file in the pkgconfig/ subdirectory of libd, trying
+    // several names derived from stem. If not found, return false. If found,
+    // extract poptions, loptions, and libs, set the corresponding *.export.*
+    // variables on lib, and return true.
+    //
+    // System library search paths (those extracted from the compiler) are
+    // passed in sys_sp and should already be extracted.
+    //
+    // Note that scope and link order should be "top-level" from the
+    // search_library() POV.
+    //
+    bool link::
+    pkgconfig_extract (scope& s,
+                       file& lt,
+                       const string* proj,
+                       const string& stem,
+                       const dir_path& libd,
+                       optional<dir_paths>& sys_sp,
+                       lorder lo) const
+    {
+      tracer trace (x, "link::pkgconfig_extract");
+
+      assert (sys_sp);
+      assert (pkgconfig != nullptr);
+
+      // Check if we have the pkgconfig/ subdirectory in this library's
+      // directory.
+      //
+      dir_path pkgd (dir_path (libd) /= "pkgconfig");
+
+      if (!dir_exists (pkgd))
+        return false;
+
+      // Now see if there is a corresponding .pc file. About half of them
+      // called foo.pc and half libfoo.pc (and one of the pkg-config's authors
+      // suggests that some of you should call yours foolib.pc, just to keep
+      // things interesting, you know).
+      //
+      // Given the (general) import in the form <proj>%lib{<stem>}, we will
+      // first try <stem>.pc, then lib<stem>.pc. Maybe it also makes sense to
+      // try <proj>.pc, just in case. Though, according to pkg-config docs,
+      // the .pc file should correspond to a library, not project. But then
+      // you get something like zlib which calls it zlib.pc. So let's just do
+      // it.
+      //
+      path f;
+      f = pkgd;
+      f /= stem;
+      f += ".pc";
+
+      if (!file_exists (f))
+      {
+        f = pkgd;
+        f /= "lib";
+        f += stem;
+        f += ".pc";
+
+        if (!file_exists (f))
+        {
+          if (proj != nullptr)
+          {
+            f = pkgd;
+            f /= *proj;
+            f += ".pc";
+
+            if (!file_exists (f))
+              return false;
+          }
+          else
+            return false;
+        }
+      }
+
+      // Ok, we are in business. Time to run pkg-config. To keep things
+      // simple, we run it twice, first time for --cflag, then for --libs.
+      //
+      bool la (lt.is_a<liba> ());
+
+      const char* args[] = {
+        pkgconfig->initial,
+        nullptr, // --cflags/--libs
+        (la ? "--static" : f.string ().c_str ()),
+        (la ? f.string ().c_str () : nullptr),
+        nullptr
+      };
+
+      auto retline = [] (string& s) -> string {return move (s);};
+
+      args[1] = "--cflags";
+      string cstr (run<string> (*pkgconfig, args, retline));
+
+      args[1] = "--libs";
+      string lstr (run<string> (*pkgconfig, args, retline));
+
+      // On Windows pkg-config (at least the MSYS2 one which we are using)
+      // will escape backslahses in paths. In fact, it may escape things
+      // even on non-Windows platforms, for example, spaces. So we use a
+      // slightly modified version of next_word().
+      //
+      auto next = [] (const string& s, size_t& b, size_t& e) -> string
+      {
+        string r;
+        size_t n (s.size ());
+
+        if (b != e)
+          b = e;
+
+        // Skip leading delimiters.
+        //
+        for (; b != n && s[b] == ' '; ++b) ;
+
+        if (b == n)
+        {
+          e = n;
+          return r;
+        }
+
+        // Find first trailing delimiter while taking care of escapes.
+        //
+        r = s[b];
+        for (e = b + 1; e != n && s[e] != ' '; ++e)
+        {
+          if (s[e] == '\\')
+          {
+            if (++e == n)
+              fail << "dangling escape in pkg-config output '" << s << "'";
+          }
+
+          r += s[e];
+        }
+
+        return r;
+      };
+
+      // Parse --cflags into poptions.
+      //
+      {
+        strings pops;
+
+        bool arg (false);
+        string o;
+        for (size_t b (0), e (0); !(o = next (cstr, b, e)).empty (); )
+        {
+          if (arg)
+          {
+            pops.push_back (move (o));
+            arg = false;
+            continue;
+          }
+
+          size_t n (o.size ());
+
+          // We only keep -I, -D and -U.
+          //
+          if (n >= 2 &&
+              o[0] == '-' &&
+              (o[1] == 'I' || o[1] == 'D' || o[1] == 'U'))
+          {
+            pops.push_back (move (o));
+            arg = (n == 2);
+            continue;
+          }
+
+          l4 ([&]{trace << "ignoring " << f << " --cflags option " << o;});
+        }
+
+        if (arg)
+          fail << "argument expected after " << pops.back () <<
+            info << "while parsing pkg-config --cflags output of " << f;
+
+        if (!pops.empty ())
+        {
+          auto p (lt.vars.insert (c_export_poptions));
+
+          // The only way we could already have this value is if this same
+          // library was also imported as a project (as opposed to installed).
+          // Unlikely but possible. In this case the values were set by the
+          // export stub and we shouldn't touch them.
+          //
+          if (p.second)
+            p.first.get () = move (pops);
+        }
+      }
+
+      // Parse --libs into loptions/libs.
+      //
+      {
+        strings lops;
+        names libs;
+
+        // Normally we will have zero or more -L's followed by one or more
+        // -l's, with the first one being the library itself. But sometimes
+        // we may have other linker options, for example, -Wl,... or
+        // -pthread. It's probably a bad idea to ignore them. Also,
+        // theoretically, we could have just the library name/path.
+        //
+        // The tricky part, of course, is to know whether what follows after
+        // an option we don't recognize is its argument or another option or
+        // library. What we do at the moment is stop recognizing just
+        // library names (without -l) after seeing an unknown option.
+        //
+
+        bool arg (false), first (true), known (true), have_L;
+        string o;
+        for (size_t b (0), e (0); !(o = next (lstr, b, e)).empty (); )
+        {
+          if (arg)
+          {
+            // Can only be an argument for an loption.
+            //
+            lops.push_back (move (o));
+            arg = false;
+            continue;
+          }
+
+          size_t n (o.size ());
+
+          // See if this is -L.
+          //
+          if (n >= 2 && o[0] == '-' && o[1] == 'L')
+          {
+            have_L = true;
+            lops.push_back (move (o));
+            arg = (n == 2);
+            continue;
+          }
+
+          // See if that's -l or just the library name/path.
+          //
+          if ((known && o[0] != '-') ||
+              (n > 2 && o[0] == '-' && o[1] == 'l'))
+          {
+            // First one is the library itself, which we skip. Note that we
+            // don't verify this and theoretically it could be some other
+            // library, but we haven't encountered such a beast yet.
+            //
+            if (first)
+            {
+              first = false;
+              continue;
+            }
+
+            libs.push_back (name (move (o), false));
+            continue;
+          }
+
+          // Otherwise we assume it is some other loption.
+          //
+          known = false;
+          lops.push_back (move (o));
+        }
+
+        if (arg)
+          fail << "argument expected after " << lops.back () <<
+            info << "while parsing pkg-config --libs output of " << f;
+
+        if (first)
+          fail << "library expected in '" << lstr << "'" <<
+            info << "while parsing pkg-config --libs output of " << f;
+
+        // Resolve -lfoo into the library file path using our import installed
+        // machinery (i.e., we are going to call search_library() that will
+        // probably call us again, and so on).
+        //
+        // The reason we do it is the link order. For general libraries it
+        // shouldn't matter if we imported them via an export stub, direct
+        // import installed, or via a .pc file (which we could have generated
+        // from the export stub). The exception is "system libraries" (which
+        // are really the extension of libc) such as -lm, -ldl, -lpthread,
+        // etc. Those we will detect and leave as -l*.
+        //
+        // If we managed to resolve all the -l's (sans system), then we can
+        // omit -L's for nice and tidy command line.
+        //
+        bool all (true);
+        optional<dir_paths> sp; // Populate lazily.
+
+        for (name& n: libs)
+        {
+          string& l (n.value);
+
+          // These ones are common/standard/POSIX.
+          //
+          if (l[0] != '-'      || // e.g., shell32.lib
+              l == "-lm"       ||
+              l == "-ldl"      ||
+              l == "-lrt"      ||
+              l == "-lpthread")
+            continue;
+
+          // Note: these list are most likely incomplete.
+          //
+          if (tclass == "linux")
+          {
+            // Some extras from libc (see libc6-dev) and other places.
+            //
+            if (l == "-lanl"     ||
+                l == "-lcrypt"   ||
+                l == "-lnsl"     ||
+                l == "-lresolv"  ||
+                l == "-lgcc")
+            continue;
+          }
+          else if (tclass == "macosx")
+          {
+            if (l == "-lSystem")
+              continue;
+          }
+
+          // Prepare the search paths.
+          //
+          if (have_L && !sp)
+          {
+            sp = dir_paths ();
+
+            // First enter the -L paths from the .pc file so that they take
+            // precedence.
+            //
+            for (auto i (lops.begin ()); i != lops.end (); ++i)
+            {
+              const string& o (*i);
+
+              if (o.size () >= 2 && o[0] == '-' && o[1] == 'L')
+              {
+                string p;
+
+                if (o.size () == 2)
+                  p = *++i; // We've verified it's there.
+                else
+                  p = string (o, 2);
+
+                dir_path d (move (p));
+
+                if (d.relative ())
+                  fail << "relative -L directory in '" << lstr << "'" <<
+                    info << "while parsing pkg-config --libs output of " << f;
+
+                sp->push_back (move (d));
+              }
+            }
+
+            // Then append system paths.
+            //
+            sp->insert (sp->end (), sys_sp->begin (), sys_sp->end ());
+          }
+
+          // @@ OUT: for now we assume out is undetermined, just like in
+          // link::resolve_library().
+          //
+          dir_path out;
+          string name (l, 2); // Sans -l.
+          const string* ext (nullptr);
+
+          prerequisite_key pk {
+            nullptr, {&lib::static_type, &out, &out, &name, ext}, &s};
+
+          if (lib* lt = static_cast<lib*> (
+                search_library (have_L ? sp : sys_sp, pk, lo)))
+          {
+            file& f (static_cast<file&> (link_member (*lt, lo)));
+            l = f.path ().string ();
+          }
+          else
+            // If we couldn't find the library, then leave it as -l.
+            //
+            all = false;
+        }
+
+        // If all the -l's resolved and no other options, then drop all the
+        // -L's. If we have unknown options, then leave them in to be safe.
+        //
+        if (all && known)
+          lops.clear ();
+
+        if (!lops.empty ())
+        {
+          if (cid == "msvc")
+          {
+            // Translate -L to /LIBPATH.
+            //
+            for (auto i (lops.begin ()); i != lops.end (); )
+            {
+              string& o (*i);
+              size_t n (o.size ());
+
+              if (n >= 2 && o[0] == '-' && o[1] == 'L')
+              {
+                o.replace (0, 2, "/LIBPATH:");
+
+                if (n == 2)
+                {
+                  o += *++i; // We've verified it's there.
+                  i = lops.erase (i);
+                  continue;
+                }
+              }
+
+              ++i;
+            }
+          }
+
+          auto p (lt.vars.insert (c_export_loptions));
+
+          if (p.second)
+            p.first.get () = move (lops);
+        }
+
+        if (!libs.empty ())
+        {
+          auto p (lt.vars.insert (c_export_libs));
+
+          if (p.second)
+            p.first.get () = move (libs);
+        }
+      }
+
+      return true;
+    }
+  }
+}
diff --git a/build2/cc/utility b/build2/cc/utility
index ae19d56..1ef65d8 100644
--- a/build2/cc/utility
+++ b/build2/cc/utility
@@ -43,19 +43,6 @@ namespace build2
     //
     target&
     link_member (bin::lib&, lorder);
-
-    // Append or hash library options from a pair of *.export.* variables
-    // (first one is cc.export.*) recursively, prerequisite libraries first.
-    //
-    void
-    append_lib_options (cstrings&, target&, lorder,
-                        const variable&,
-                        const variable&);
-
-    void
-    hash_lib_options (sha256&, target&, lorder,
-                      const variable&,
-                      const variable&);
   }
 }
 
diff --git a/build2/cc/utility.cxx b/build2/cc/utility.cxx
index 773ba8f..7be86e2 100644
--- a/build2/cc/utility.cxx
+++ b/build2/cc/utility.cxx
@@ -71,45 +71,5 @@ namespace build2
 
       return *r;
     }
-
-    void
-    append_lib_options (cstrings& args, target& l, lorder lo,
-                        const variable& cv,
-                        const variable& xv)
-    {
-      using namespace bin;
-
-      for (target* t: l.prerequisite_targets)
-      {
-        if (lib* l = t->is_a<lib> ())
-          t = &link_member (*l, lo); // Pick one of the members.
-
-        if (t->is_a<liba> () || t->is_a<libs> ())
-          append_lib_options (args, *t, lo, cv, xv);
-      }
-
-      append_options (args, l, cv);
-      append_options (args, l, xv);
-    }
-
-    void
-    hash_lib_options (sha256& csum, target& l, lorder lo,
-                      const variable& cv,
-                      const variable& xv)
-    {
-      using namespace bin;
-
-      for (target* t: l.prerequisite_targets)
-      {
-        if (lib* l = t->is_a<lib> ())
-          t = &link_member (*l, lo); // Pick one of the members.
-
-        if (t->is_a<liba> () || t->is_a<libs> ())
-          hash_lib_options (csum, *t, lo, cv, xv);
-      }
-
-      hash_options (csum, l, cv);
-      hash_options (csum, l, xv);
-    }
   }
 }
diff --git a/build2/context.txx b/build2/context.txx
index 6ff61c9..f40ecdc 100644
--- a/build2/context.txx
+++ b/build2/context.txx
@@ -12,7 +12,7 @@ namespace build2
 
     const dir_path& b (*relative_base);
 
-    if (b.empty ())
+    if (p.simple () || b.empty ())
       return p;
 
     if (p.sub (b))
diff --git a/build2/cxx/init.cxx b/build2/cxx/init.cxx
index 8202139..e504284 100644
--- a/build2/cxx/init.cxx
+++ b/build2/cxx/init.cxx
@@ -235,6 +235,8 @@ namespace build2
           cast<string> (r[cm.x_target_system]),
           cast<string> (r[cm.x_target_class]),
 
+          cast_null<process_path> (r["pkgconfig.path"]),
+
           cxx::static_type,
           hdr,
           inc
diff --git a/build2/pkgconfig/init b/build2/pkgconfig/init
new file mode 100644
index 0000000..53821ae
--- /dev/null
+++ b/build2/pkgconfig/init
@@ -0,0 +1,37 @@
+// file      : build2/pkgconfig/init -*- C++ -*-
+// copyright : Copyright (c) 2014-2016 Code Synthesis Ltd
+// license   : MIT; see accompanying LICENSE file
+
+#ifndef BUILD2_PKGCONFIG_INIT
+#define BUILD2_PKGCONFIG_INIT
+
+#include <build2/types>
+#include <build2/utility>
+
+#include <build2/module>
+
+namespace build2
+{
+  namespace pkgconfig
+  {
+    bool
+    config_init (scope&,
+                 scope&,
+                 const location&,
+                 unique_ptr<module_base>&,
+                 bool,
+                 bool,
+                 const variable_map&);
+
+    bool
+    init (scope&,
+          scope&,
+          const location&,
+          unique_ptr<module_base>&,
+          bool,
+          bool,
+          const variable_map&);
+  }
+}
+
+#endif // BUILD2_PKGCONFIG_INIT
diff --git a/build2/pkgconfig/init.cxx b/build2/pkgconfig/init.cxx
new file mode 100644
index 0000000..b7100e3
--- /dev/null
+++ b/build2/pkgconfig/init.cxx
@@ -0,0 +1,159 @@
+// file      : build2/pkgconfig/init.cxx -*- C++ -*-
+// copyright : Copyright (c) 2014-2016 Code Synthesis Ltd
+// license   : MIT; see accompanying LICENSE file
+
+#include <build2/pkgconfig/init>
+
+#include <build2/scope>
+#include <build2/target>
+#include <build2/variable>
+#include <build2/diagnostics>
+
+#include <build2/config/utility>
+
+using namespace std;
+using namespace butl;
+
+namespace build2
+{
+  namespace pkgconfig
+  {
+    bool
+    config_init (scope& rs,
+                 scope& bs,
+                 const location& l,
+                 unique_ptr<module_base>&,
+                 bool,
+                 bool optional,
+                 const variable_map& hints)
+    {
+      tracer trace ("pkgconfig::config_init");
+      l5 ([&]{trace << "for " << bs.out_path ();});
+
+      if (&rs != &bs)
+        fail (l) << "pkgconfig.config loaded for non-root scope";
+
+      // Enter variables.
+      //
+      // config.pkgconfig.target is a hint.
+      //
+      auto& vp (var_pool);
+
+      const variable& c_x (vp.insert<path> ("config.pkgconfig", true));
+      const variable& c_x_tgt (vp.insert<string> ("config.pkgconfig.target"));
+      const variable& x_path (vp.insert<process_path> ("pkgconfig.path"));
+
+      // Configure.
+      //
+
+      // Adjust module priority (between compilers and binutils).
+      //
+      config::save_module (rs, "pkgconfig", 325);
+
+      process_path pp;
+      bool new_val (false); // Set any new values?
+
+      auto p (config::omitted (rs, c_x));
+
+      if (const value* v = p.first)
+      {
+        const path& x (cast<path> (*v));
+
+        try
+        {
+          // If this is a user-specified value, then it's non-optional.
+          //
+          pp = process::path_search (x, true);
+          new_val = p.second;
+        }
+        catch (const process_error& e)
+        {
+          fail << "unable to execute " << x << ": " << e.what ();
+        }
+      }
+
+      string d; // Default name (pp.initial may be its shallow copy).
+
+      // If we have a target hint, then next try <triplet>-pkg-config.
+      //
+      if (pp.empty ())
+      {
+        if (const string* t = cast_null<string> (hints[c_x_tgt]))
+        {
+          d = *t;
+          d += "-pkg-config";
+
+          l5 ([&]{trace << "trying " << d;});
+          pp = process::try_path_search (d, true);
+        }
+      }
+
+      // Finallly, try just pkg-config.
+      //
+      if (pp.empty ())
+      {
+        d = "pkg-config";
+
+        l5 ([&]{trace << "trying " << d;});
+        pp = process::try_path_search (d, true);
+      }
+
+      bool conf (!pp.empty ());
+
+      if (!conf && !optional)
+        fail (l) << "unable to find pkg-config program";
+
+      // Config report.
+      //
+      if (verb >= (new_val ? 2 : 3))
+      {
+        diag_record dr (text);
+        dr << "pkgconfig " << project (rs) << '@' << rs.out_path () << '\n';
+
+        if (conf)
+          dr << "  pkg-config " << pp;
+        else
+          dr << "  pkg-config " << "not found, leaving unconfigured";
+      }
+
+      if (conf)
+        rs.assign (x_path) = move (pp);
+
+      return conf;
+    }
+
+    bool
+    init (scope& rs,
+          scope& bs,
+          const location& loc,
+          unique_ptr<module_base>&,
+          bool,
+          bool optional,
+          const variable_map& hints)
+    {
+      tracer trace ("pkgconfig::init");
+      l5 ([&]{trace << "for " << bs.out_path ();});
+
+      // Load pkgconfig.config.
+      //
+      if (!cast_false<bool> (rs["pkgconfig.config.loaded"]))
+      {
+        if (!load_module ("pkgconfig.config", rs, rs, loc, optional, hints))
+          return false;
+      }
+      else if (!cast_false<bool> (rs["pkgconfig.config.configured"]))
+      {
+        if (!optional)
+          fail << "pkgconfig module could not be configured" <<
+            info << "re-run with -V option for more information";
+
+        return false;
+      }
+
+      // For now pkgconfig and pkgconfig.config is pretty much the same.
+      //
+
+      return true;
+    }
+  }
+}
diff --git a/build2/utility b/build2/utility
index 3ccca61..7f05dd0 100644
--- a/build2/utility
+++ b/build2/utility
@@ -80,7 +80,7 @@ namespace build2
 
   // Start a process with the specified arguments printing the command at
   // verbosity level 3 and higher. Redirect STDOUT to a pipe. If error is
-  // false, then redirecting STDERR to STDOUT (this can used to suppress
+  // false, then redirecting STDERR to STDOUT (this can be used to suppress
   // diagnostics from the child process). Issue diagnostics and throw failed
   // in case of an error.
   //
diff --git a/build2/utility.cxx b/build2/utility.cxx
index ef90084..db0d6b2 100644
--- a/build2/utility.cxx
+++ b/build2/utility.cxx
@@ -31,10 +31,15 @@ namespace build2
   ostream&
   operator<< (ostream& os, const process_path& p)
   {
-    os << p.recall_string ();
+    if (p.empty ())
+      os << "<empty>";
+    else
+    {
+      os << p.recall_string ();
 
-    if (!p.effect.empty ())
-      os << '@' << p.effect.string (); // Suppress relative().
+      if (!p.effect.empty ())
+        os << '@' << p.effect.string (); // Suppress relative().
+    }
 
     return os;
   }