llvm-config: handle BUILD_SHARED_LIBS correctly

[axw]

Summary

llvm-config will print out library names according
to the build configuration: libLLVM-X.Y.so with
LLVM_LINK_LLVM_DYLIB=ON, static archives if OFF.
It should print out shared libraries if the
BUILD_SHARED_LIBS configuration is used, but this
is not currently being handled correctly.

Now if BUILD_SHARED_LIBS=ON, we will print out the
individual component shared libraries.
BUILD_SHARED_LIBS is mutually exclusive with
LLVM_LINK_LLVM_DYLIB, so there can be no fallback
to the single shared library or to static archives.

[axw]

Revert comment change

[nhaehnle]

Works for me, thanks a lot!

[rivanvx]

Works for me. Needs rebase to current master.

[DiamondLovesYou]

LGTM

tools/llvm-config/llvm-config.cpp

 
 // LinkMode determines what libraries and flags are returned by llvm-config.
 enum LinkMode {
   // LinkModeAuto will link with the default link mode for the installation,
   // which is dependent on the value of LLVM_LINK_LLVM_DYLIB, and fall back
   // to the alternative if the required libraries are not available.
   LinkModeAuto = 0,
 
-  // LinkModeDyLib will link with the single dynamic library if it exists,
-  // and return an error if it does not exist.
-  LinkModeDyLib = 1,
+  // LinkModeShared will link with the dynamic component libraries if they
+  // exist, and return an error otherwise.
+  LinkModeShared = 1,
 
-  // LinkModeStatic will link with the individual component static libraries
-  // if they exist, and fail if any one does not exist.
+  // LinkModeStatic will link with the static component libraries if they
+  // exist, and return an error otherwise.
   LinkModeStatic = 2,
 };
 
 /// \brief Traverse a single component adding to the topological ordering in
 /// \arg RequiredLibs.
 ///
 /// \param Name - The component to traverse.
 /// \param ComponentMap - A prebuilt map of component names to descriptors.
 /// \param VisitedComponents [in] [out] - The set of already visited components.
 /// \param RequiredLibs [out] - The ordered list of required
 /// libraries.
 /// \param GetComponentNames - Get the component names instead of the
 /// library name.
 static void VisitComponent(const std::string &Name,
                            const StringMap<AvailableComponent *> &ComponentMap,
                            std::set<AvailableComponent *> &VisitedComponents,
                            std::vector<std::string> &RequiredLibs,
                            bool IncludeNonInstalled, bool GetComponentNames,
-                           const std::string *ActiveLibDir,
+                           const std::function<std::string(const StringRef &)>
+                               *GetComponentLibraryPath,
                            std::vector<std::string> *Missing) {
   // Lookup the component.
   AvailableComponent *AC = ComponentMap.lookup(Name);
   assert(AC && "Invalid component name!");
 
   // Add to the visited table.
   if (!VisitedComponents.insert(AC).second) {
     // We are done if the component has already been visited.
     return;
   }
 
   // Only include non-installed components if requested.
   if (!AC->IsInstalled && !IncludeNonInstalled)
     return;
 
   // Otherwise, visit all the dependencies.
   for (unsigned i = 0; AC->RequiredLibraries[i]; ++i) {
     VisitComponent(AC->RequiredLibraries[i], ComponentMap, VisitedComponents,
                    RequiredLibs, IncludeNonInstalled, GetComponentNames,
-                   ActiveLibDir, Missing);
+                   GetComponentLibraryPath, Missing);
   }
 
   if (GetComponentNames) {
     RequiredLibs.push_back(Name);
     return;
   }
 
   // Add to the required library list.
   if (AC->Library) {
-    if (Missing && ActiveLibDir) {
-      std::string path = *ActiveLibDir + "/" + AC->Library;
+    if (Missing && GetComponentLibraryPath) {
+      std::string path = (*GetComponentLibraryPath)(AC->Library);
       if (!sys::fs::exists(path))
         Missing->push_back(path);
     }
     RequiredLibs.push_back(AC->Library);
   }
 }
 
 /// \brief Compute the list of required libraries for a given list of
 /// components, in an order suitable for passing to a linker (that is, libraries
 /// appear prior to their dependencies).
 ///
 /// \param Components - The names of the components to find libraries for.
 /// \param IncludeNonInstalled - Whether non-installed components should be
 /// reported.
 /// \param GetComponentNames - True if one would prefer the component names.
 static std::vector<std::string>
 ComputeLibsForComponents(const std::vector<StringRef> &Components,
                          bool IncludeNonInstalled, bool GetComponentNames,
-                         const std::string *ActiveLibDir,
+                         const std::function<std::string(const StringRef &)>
+                             *GetComponentLibraryPath,
                          std::vector<std::string> *Missing) {
   std::vector<std::string> RequiredLibs;
   std::set<AvailableComponent *> VisitedComponents;
 
   // Build a map of component names to information.
   StringMap<AvailableComponent *> ComponentMap;
   for (unsigned i = 0; i != array_lengthof(AvailableComponents); ++i) {
     AvailableComponent *AC = &AvailableComponents[i];
for (unsigned i = 0, e = Components.size(); i != e; ++i) {
     if (!ComponentMap.count(ComponentLower)) {
       llvm::errs() << "llvm-config: unknown component name: " << Components[i]
                    << "\n";
       exit(1);
     }
 
     VisitComponent(ComponentLower, ComponentMap, VisitedComponents,
                    RequiredLibs, IncludeNonInstalled, GetComponentNames,
-                   ActiveLibDir, Missing);
+                   GetComponentLibraryPath, Missing);
   }
 
   // The list is now ordered with leafs first, we want the libraries to printed
   // in the reverse order of dependency.
   std::reverse(RequiredLibs.begin(), RequiredLibs.end());
 
   return RequiredLibs;
 }
Options:\n\
   --components      List of all possible components.\n\
   --targets-built   List of all targets currently built.\n\
   --host-target     Target triple used to configure LLVM.\n\
   --build-mode      Print build mode of LLVM tree (e.g. Debug or Release).\n\
   --assertion-mode  Print assertion mode of LLVM tree (ON or OFF).\n\
   --build-system    Print the build system used to build LLVM (autoconf or cmake).\n\
   --has-rtti        Print whether or not LLVM was built with rtti (YES or NO).\n\
   --shared-mode     Print how the provided components can be collectively linked (`shared` or `static`).\n\
-  --link-shared     Link the components as a shared library.\n\
-  --link-static     Link the components as a static libraries.\n\
+  --link-shared     Link the components as shared libraries.\n\
+  --link-static     Link the component libraries statically.\n\
 Typical components:\n\
   all               All LLVM libraries (default).\n\
   engine            Either a native JIT or a bitcode interpreter.\n";
   exit(1);
 }
 
 /// \brief Compute the path to the main executable.
 std::string GetExecutablePath(const char *Argv0) {
const bool BuiltSharedLibs =
       (ConfigTool == CMake && std::strcmp(LLVM_ENABLE_SHARED, "ON") == 0);
 
   bool DyLibExists = false;
   const std::string DyLibName =
       (SharedPrefix + "LLVM-" + SharedVersionedExt).str();
 
   // If LLVM_LINK_DYLIB is ON, the single shared library will be returned
   // for "--libs", etc, if they exist. This behaviour can be overridden with
-  // --link-static or --link-shared.
+  // --link-components or --link-libllvm.
   bool LinkDyLib = (std::strcmp(LLVM_LINK_DYLIB, "ON") == 0);
 
   if (BuiltDyLib) {
     DyLibExists = sys::fs::exists(SharedDir + "/" + DyLibName);
     if (!DyLibExists) {
       // The shared library does not exist: don't error unless the user
       // explicitly passes --link-shared.
       LinkDyLib = false;
     }
   }
-  LinkMode LinkMode = LinkDyLib ? LinkModeDyLib : LinkModeAuto;
+  LinkMode LinkMode =
+      (LinkDyLib || BuiltSharedLibs) ? LinkModeShared : LinkModeAuto;
 
   /// Get the component's library name without the lib prefix and the
   /// extension. Returns true if Lib is in a recognized format.
   auto GetComponentLibraryNameSlice = [&](const StringRef &Lib,
                                           StringRef &Out) {
     if (Lib.startswith("lib")) {
       unsigned FromEnd;
       if (Lib.endswith(StaticExt)) {
if (Lib.startswith("lib")) {
         return true;
       }
     }
 
     return false;
   };
   /// Maps Unixizms to the host platform.
   auto GetComponentLibraryFileName = [&](const StringRef &Lib,
-                                         const bool ForceShared) {
+                                         const bool Shared) {
     std::string LibFileName = Lib;
     StringRef LibName;
     if (GetComponentLibraryNameSlice(Lib, LibName)) {
-      if (BuiltSharedLibs || ForceShared) {
+      if (Shared) {
         LibFileName = (SharedPrefix + LibName + "." + SharedExt).str();
       } else {
         // default to static
         LibFileName = (StaticPrefix + LibName + "." + StaticExt).str();
       }
     }
 
     return LibFileName;
   };
   /// Get the full path for a possibly shared component library.
-  auto GetComponentLibraryPath = [&](const StringRef &Name,
-                                     const bool ForceShared) {
-    auto LibFileName = GetComponentLibraryFileName(Name, ForceShared);
-    if (BuiltSharedLibs || ForceShared) {
+  auto GetComponentLibraryPath = [&](const StringRef &Name, const bool Shared) {
+    auto LibFileName = GetComponentLibraryFileName(Name, Shared);
+    if (Shared) {
       return (SharedDir + "/" + LibFileName).str();
     } else {
       return (StaticDir + "/" + LibFileName).str();
     }
   };
 
   raw_ostream &OS = outs();
   for (int i = 1; i != argc; ++i) {
#endif
         OS << LLVM_HAS_RTTI << '\n';
       } else if (Arg == "--shared-mode") {
         PrintSharedMode = true;
       } else if (Arg == "--obj-root") {
         OS << ActivePrefix << '\n';
       } else if (Arg == "--src-root") {
         OS << LLVM_SRC_ROOT << '\n';
       } else if (Arg == "--link-shared") {
-        LinkMode = LinkModeDyLib;
+        LinkMode = LinkModeShared;
       } else if (Arg == "--link-static") {
         LinkMode = LinkModeStatic;
       } else {
         usage();
       }
     } else {
       Components.push_back(Arg);
     }
   }
 
   if (!HasAnyOption)
     usage();
 
-  if (LinkMode == LinkModeDyLib && !DyLibExists) {
-    errs() << "llvm-config: error: " << DyLibName << " is missing\n\n";
-    usage();
+  if (LinkMode == LinkModeShared && !DyLibExists && !BuiltSharedLibs) {
+    errs() << "llvm-config: error: " << DyLibName << " is missing\n";
+    return 1;
   }
 
   if (PrintLibs || PrintLibNames || PrintLibFiles || PrintSystemLibs ||
       PrintSharedMode) {
 
     if (PrintSharedMode && BuiltSharedLibs) {
       OS << "shared\n";
       return 0;
     }
 
     // If no components were specified, default to "all".
     if (Components.empty())
       Components.push_back("all");
 
     // Construct the list of all the required libraries.
+    std::function<std::string(const StringRef &)>
+        GetComponentLibraryPathFunction = [&](const StringRef &Name) {
+          return GetComponentLibraryPath(Name, LinkMode == LinkModeShared);
+        };
     std::vector<std::string> MissingLibs;
-    std::vector<std::string> RequiredLibs =
-        ComputeLibsForComponents(Components,
-                                 /*IncludeNonInstalled=*/IsInDevelopmentTree,
-                                 false, &ActiveLibDir, &MissingLibs);
+    std::vector<std::string> RequiredLibs = ComputeLibsForComponents(
+        Components,
+        /*IncludeNonInstalled=*/IsInDevelopmentTree, false,
+        &GetComponentLibraryPathFunction, &MissingLibs);
     if (!MissingLibs.empty()) {
       switch (LinkMode) {
-      case LinkModeDyLib:
+      case LinkModeShared:
+        if (DyLibExists && !BuiltSharedLibs)
           break;
+        // Using component shared libraries.
+        for (auto &Lib : MissingLibs)
+          errs() << "llvm-config: error: missing: " << Lib << "\n";
+        return 1;
       case LinkModeAuto:
         if (DyLibExists) {
-          LinkMode = LinkModeDyLib;
+          LinkMode = LinkModeShared;
           break;
         }
         errs()
             << "llvm-config: error: component libraries and shared library\n\n";
       // fall through
       case LinkModeStatic:
         for (auto &Lib : MissingLibs)
           errs() << "llvm-config: error: missing: " << Lib << "\n";
if (PrintSharedMode) {
       for (auto &Lib : RequiredLibs) {
         if (!FullDyLibComponents.count(Lib)) {
           OS << "static\n";
           return 0;
         }
       }
       FullDyLibComponents.clear();
 
-      if (LinkMode == LinkModeDyLib) {
+      if (LinkMode == LinkModeShared) {
         OS << "shared\n";
         return 0;
       } else {
         OS << "static\n";
         return 0;
       }
     }
 
     if (PrintLibs || PrintLibNames || PrintLibFiles) {
 
-      auto PrintForLib = [&](const StringRef &Lib, const bool ForceShared) {
+      auto PrintForLib = [&](const StringRef &Lib) {
+        const bool Shared = LinkMode == LinkModeShared;
         if (PrintLibNames) {
-          OS << GetComponentLibraryFileName(Lib, ForceShared);
+          OS << GetComponentLibraryFileName(Lib, Shared);
         } else if (PrintLibFiles) {
-          OS << GetComponentLibraryPath(Lib, ForceShared);
+          OS << GetComponentLibraryPath(Lib, Shared);
         } else if (PrintLibs) {
           // If this is a typical library name, include it using -l.
           StringRef LibName;
           if (Lib.startswith("lib")) {
             if (GetComponentLibraryNameSlice(Lib, LibName)) {
               OS << "-l" << LibName;
             } else {
-              OS << "-l:" << GetComponentLibraryFileName(Lib, ForceShared);
+              OS << "-l:" << GetComponentLibraryFileName(Lib, Shared);
             }
           } else {
             // Otherwise, print the full path.
-            OS << GetComponentLibraryPath(Lib, ForceShared);
+            OS << GetComponentLibraryPath(Lib, Shared);
           }
         }
       };
 
-      if (LinkMode == LinkModeDyLib) {
-        PrintForLib(DyLibName, true);
+      if (LinkMode == LinkModeShared && !BuiltSharedLibs) {
+        PrintForLib(DyLibName);
       } else {
         for (unsigned i = 0, e = RequiredLibs.size(); i != e; ++i) {
           auto Lib = RequiredLibs[i];
           if (i)
             OS << ' ';
 
-          PrintForLib(Lib, false);
+          PrintForLib(Lib);
         }
       }
       OS << '\n';
     }
 
     // Print SYSTEM_LIBS after --libs.
     // FIXME: Each LLVM component may have its dependent system libs.
     if (PrintSystemLibs)
       OS << LLVM_SYSTEM_LIBS << '\n';
   } else if (!Components.empty()) {
     errs() << "llvm-config: error: components given, but unused\n\n";
     usage();
   }
 
   return 0;
 }