Make `llvm-config` work when static versions of LLVM's components aren't installed.

[DiamondLovesYou]

Summary

The following only applies if the following is true:

• llvm-config isn't inside the build tree (ie it's installed).
• LLVM is built with shared libs (via --enable-shared or LLVM_BUILD_LLVM_DYLIB) enabled.
• llvm-config finds the platform specific shared library file in the 'lib' subfolder within the install root (ie it finds 'libLLVM-3.7.0svn.so' or 'libLLVM.so.3.7.0svn' on Linux).

If llvm-config, when visiting all the components, finds a missing
archive, it will override the set of RequiredLibs to only include
that shared library. Note that this means that if one has installed
only select libraries in static form and component X and it's deps are
among them, --libname X will still print static archive names. I
wouldn't recommend doing that (installing shared library + only some
static libraries) for obvious reasons, but I thought it should be
documented nonetheless.

[brad.king]

tools/llvm-config/llvm-config.cpp

380

When building with CMake the value of BUILD_SHARED_LIBS may have "true" values other than ON. The value could be configured in the header file with

#cmakedefine BUILD_SHARED_LIBS

and then the logic here can just use #ifdef. Or, one could configure another variable that is known to be set as desired:

if(BUILD_SHARED_LIBS)
  set(LLVM_ENABLE_SHARED ON)
else()
  set(LLVM_ENABLE_SHARED OFF)
endif()

[DiamondLovesYou]

tools/llvm-config/llvm-config.cpp

380

But doesn't CMake build separate shared libraries for each component? Meaning libLLVM-3.7.0svn.so wouldn't exist, meaning llvm-config would still use the old behavior? Please correct me if I'm wrong.

[delcypher]

tools/llvm-config/llvm-config.cpp

380

But doesn't CMake build separate shared libraries for each component

Yes and No. It's complicated if you use BUILD_SHARED_LIBS then think the answer is yes but I don't think that's how it is intended for LLVM to ship and I never build that way.

Chris Bieneman, implemented support for building a single shared library (see LLVM_BUILD_LLVM_DYLIB option). What complicates matters more is that the shared library can have all C++ symbols hidden (see LLVM_DYLIB_EXPORT_ALL) and the components inside the library can be customised using LLVM_DYLIB_COMPONENTS (this currently isn't a CMake cache variable and it probably should be!). The end result of this is just because you have a single shared library it doesn't necessarily mean that all the components are available.

[DiamondLovesYou]

Make this patch do the Right Thing on Windows. Also fix a typo in a comment.

[beanz]

In general I think this patch is moving in the right direction. Eventually we'll need to add better support for working with the CMake-generated shared library. In particular because LLVM_DYLIB_COMPONENTS can be modified to control what LLVM libraries end up in the dylib you can reasonably end up in a position where an llvm-config command might need to return a mix of static and shared libraries.

My plan had been at some point to bake this into the CMake scripts and have that be installed, but we will need that support in llvm-config at some point too.

tools/llvm-config/llvm-config.cpp

380

LLVM_DYLIB_COMPONENTS doesn't need to be a cached value, and I don't think it should be. The only benefit to making it a cached value would be that it would show up in ccmake and the CMake GUI, but it brings downsides because there is no cache invalidation in CMake. If you override it on the command line the overridden value will end up in the cache, so there is no requirement for this to be cached. With it not being in the cache, if the default value changes it will update everyone's build directories, which should work without issue.

[DiamondLovesYou]

tools/llvm-config/llvm-config.cpp

380

Or one could use a shadow variable to check for changes and keep LLVM_DYLIB_COMPONENTS as a cached variable so it can show up in the CMake GUI.

At any rate, this discussion is tangential to Brad's original comment, which is fixed.

[DiamondLovesYou]

Bump. Could I get someone's attention to review this? I'd like to get it accepted.

[DiamondLovesYou]

I've created a better patch similar to this one: http://reviews.llvm.org/D13198.

bindings/ocaml/Makefile.ocaml

 ifndef SYSTEM_LLVM_CONFIG
 all-local:: build-deplibs
 clean-local:: clean-deplibs
 install-local:: install-deplibs
 uninstall-local:: uninstall-deplibs
 
 build-deplibs: $(OutputLibs)
 
+$(OcamlDir)/%.so: $(LibDir)/%.so
+  $(Verb) ln -sf $< $@
 $(OcamlDir)/%.a: $(LibDir)/%.a
   $(Verb) ln -sf $< $@
 
 $(OcamlDir)/%.o: $(LibDir)/%.o
   $(Verb) ln -sf $< $@
 
 clean-deplibs:
   $(Verb) $(RM) -f $(OutputLibs)

tools/llvm-config/BuildVariables.inc.in

 #define LLVM_CPPFLAGS "@LLVM_CPPFLAGS@"
 #define LLVM_CFLAGS "@LLVM_CFLAGS@"
 #define LLVM_LDFLAGS "@LLVM_LDFLAGS@"
 #define LLVM_CXXFLAGS "@LLVM_CXXFLAGS@"
 #define LLVM_BUILDMODE "@LLVM_BUILDMODE@"
 #define LLVM_LIBDIR_SUFFIX "@LLVM_LIBDIR_SUFFIX@"
 #define LLVM_TARGETS_BUILT "@LLVM_TARGETS_BUILT@"
 #define LLVM_SYSTEM_LIBS "@LLVM_SYSTEM_LIBS@"
+#define LLVM_ENABLE_SHARED "@LLVM_ENABLE_SHARED@"
+#define LLVM_BUILT_WITH_CMAKE "@LLVM_BUILT_WITH_CMAKE@"

tools/llvm-config/CMakeLists.txt

 set(LLVM_OBJ_ROOT ${LLVM_BINARY_DIR})
 set(LLVM_CPPFLAGS "${CMAKE_CPP_FLAGS} ${CMAKE_CPP_FLAGS_${uppercase_CMAKE_BUILD_TYPE}} ${LLVM_DEFINITIONS}")
 set(LLVM_CFLAGS "${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_${uppercase_CMAKE_BUILD_TYPE}} ${LLVM_DEFINITIONS}")
 set(LLVM_CXXFLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_${uppercase_CMAKE_BUILD_TYPE}} ${COMPILE_FLAGS} ${LLVM_DEFINITIONS}")
 # Use the C++ link flags, since they should be a superset of C link flags.
 set(LLVM_LDFLAGS "${CMAKE_CXX_LINK_FLAGS}")
 set(LLVM_BUILDMODE ${CMAKE_BUILD_TYPE})
 set(LLVM_SYSTEM_LIBS ${SYSTEM_LIBS})
+if(LLVM_BUILD_LLVM_DYLIB)
+  set(LLVM_ENABLE_SHARED ON)
+else()
+  set(LLVM_ENABLE_SHARED OFF)
+endif()
+set(LLVM_BUILT_WITH_CMAKE ON)
 string(REPLACE ";" " " LLVM_TARGETS_BUILT "${LLVM_TARGETS_TO_BUILD}")
 configure_file(${BUILDVARIABLES_SRCPATH} ${BUILDVARIABLES_OBJPATH} @ONLY)
 
 # Set build-time environment(s).
 add_definitions(-DCMAKE_CFG_INTDIR="${CMAKE_CFG_INTDIR}")
 
 # Add the dependency on the generation step.
 add_file_dependencies(${CMAKE_CURRENT_SOURCE_DIR}/llvm-config.cpp ${BUILDVARIABLES_OBJPATH})

tools/llvm-config/Makefile

$(ObjDir)/BuildVariables.inc: $(BUILDVARIABLES_SRCPATH) Makefile $(ObjDir)/.dir
   $(Verb) $(ECHO) 's/@LLVM_BUILDMODE@/$(subst /,\/,$(BuildMode))/' \
     >> temp.sed
   $(Verb) $(ECHO) 's/@LLVM_LIBDIR_SUFFIX@//' \
     >> temp.sed
   $(Verb) $(ECHO) 's/@LLVM_SYSTEM_LIBS@/$(subst /,\/,$(LLVM_SYSTEM_LIBS))/' \
     >> temp.sed
   $(Verb) $(ECHO) 's/@LLVM_TARGETS_BUILT@/$(subst /,\/,$(TARGETS_TO_BUILD))/' \
     >> temp.sed
+  $(if $(filter-out $(ENABLE_SHARED),0),\
+    $(Verb) $(ECHO) 's/@LLVM_ENABLE_SHARED@/ON/',\
+    $(Verb) $(ECHO) 's/@LLVM_ENABLE_SHARED@/OFF/') \
+    >> temp.sed
+  $(Verb) $(ECHO) 's/@LLVM_BUILT_WITH_CMAKE@/OFF/' >> temp.sed
   $(Verb) $(SED) -f temp.sed < $< > $@
   $(Verb) $(RM) temp.sed
 
 # When cross-compiling, install a version of llvm-config that runs on the host.
 ifeq ($(LLVM_CROSS_COMPILING),1)
 install:: $(DESTDIR)$(PROJ_bindir)
   $(Echo) Installing llvm-config-host
   $(Verb) $(ProgInstall) $(BuildLLVMToolDir)/llvm-config \
     $(DESTDIR)$(PROJ_bindir)/$(program_prefix)llvm-config-host
 endif

tools/llvm-config/llvm-config.cpp

 /// \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.
 static void VisitComponent(StringRef Name,
                            const StringMap<AvailableComponent*> &ComponentMap,
                            std::set<AvailableComponent*> &VisitedComponents,
                            std::vector<StringRef> &RequiredLibs,
-                           bool IncludeNonInstalled) {
+                           bool IncludeNonInstalled,
+                           std::string &ActiveLibDir,
+                           bool &HasMissing) {
   // 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);
+                   RequiredLibs, IncludeNonInstalled, ActiveLibDir,
+                   HasMissing);
   }
 
   // Add to the required library list.
-  if (AC->Library)
+  if (AC->Library) {
+    if (!IncludeNonInstalled && !HasMissing) {
+      HasMissing = !sys::fs::exists(ActiveLibDir + "/" + AC->Library);
+    }
     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 RequiredLibs [out] - On return, the ordered list of libraries that
 /// are required to link the given components.
 /// \param IncludeNonInstalled - Whether non-installed components should be
 /// reported.
 static void ComputeLibsForComponents(const std::vector<StringRef> &Components,
                                      std::vector<StringRef> &RequiredLibs,
-                                     bool IncludeNonInstalled) {
+                                     bool IncludeNonInstalled,
+                                     std::string &ActiveLibDir,
+                                     bool &HasMissing) {
   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];
     ComponentMap[AC->Name] = AC;
   }
 
   // Visit the components.
   for (unsigned i = 0, e = Components.size(); i != e; ++i) {
     // Users are allowed to provide mixed case component names.
     std::string ComponentLower = Components[i].lower();
 
     // Validate that the user supplied a valid component name.
     if (!ComponentMap.count(ComponentLower)) {
       llvm::errs() << "llvm-config: unknown component name: " << Components[i]
                    << "\n";
       exit(1);
     }
 
     VisitComponent(ComponentLower, ComponentMap, VisitedComponents,
-                   RequiredLibs, IncludeNonInstalled);
+                   RequiredLibs, IncludeNonInstalled, ActiveLibDir,
+                   HasMissing);
   }
 
   // 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());
 }
 
 /* *** */
#endif
 
   if (PrintLibs || PrintLibNames || PrintLibFiles || PrintSystemLibs) {
     // If no components were specified, default to "all".
     if (Components.empty())
       Components.push_back("all");
 
     // Construct the list of all the required libraries.
     std::vector<StringRef> RequiredLibs;
+    bool HasMissing = false;
     ComputeLibsForComponents(Components, RequiredLibs,
-                             /*IncludeNonInstalled=*/IsInDevelopmentTree);
+                             /*IncludeNonInstalled=*/IsInDevelopmentTree,
+                             ActiveLibDir, HasMissing);
 
     if (PrintLibs || PrintLibNames || PrintLibFiles) {
+      // The following only applies if the following is true:
+      //
+      // * `llvm-config` isn't inside the build tree (ie it's installed).
+      // * LLVM is built with shared libs (via `--enable-shared` or
+      //   `LLVM_BUILD_LLVM_DYLIB`) enabled.
+      // * `llvm-config` finds the platform specific shared library file in the
+      //   'lib' subfolder within the install root (ie it finds
+      //   'libLLVM-3.7.0svn.so' or 'libLLVM.so.3.7.0svn' on Linux).
+      //
+      // If `llvm-config`, when visiting all the components, finds a missing
+      // archive, it will override the set of `RequiredLibs` to only include
+      // that shared library. Note that this means that if one has installed
+      // only select libraries in static form and component X and it's deps are
+      // among them, `--libname X` will still print static archive names. I
+      // wouldn't recommend doing that (installing shared library + only some
+      // static libraries) for obvious reasons, but I thought it should be
+      // documented nonetheless.
+      const bool BuiltWithSharedLib = (std::strcmp(LLVM_ENABLE_SHARED, "ON") == 0);
+      if(BuiltWithSharedLib && HasMissing) {
+        std::string SharedExt; std::string SharedDir; std::string Prefix;
+        {
+          const Triple HostTriple(Triple::normalize(LLVM_DEFAULT_TARGET_TRIPLE));
+          if (HostTriple.isOSWindows() || HostTriple.isOSCygMing()) {
+            SharedExt = "dll";
+            SharedDir = ActiveBinDir;
+            Prefix = "";
+          } else if (HostTriple.isOSDarwin()) {
+            SharedExt = "dylib";
+            SharedDir = ActiveLibDir;
+            Prefix = "lib";
+          } else {
+            // default to linux' ext:
+            SharedExt = "so";
+            SharedDir = ActiveLibDir;
+            Prefix = "lib";
+          }
+        }
+        std::string SharedLibName;
+        if(std::strcmp(LLVM_BUILT_WITH_CMAKE, "ON") == 0) {
+          SharedLibName = Prefix + "LLVM." + SharedExt + "." PACKAGE_VERSION;
+        } else {
+          SharedLibName = Prefix + "LLVM-" PACKAGE_VERSION "." + SharedExt;
+        }
+
+        const std::string SharedLibPath = SharedDir + "/" + SharedLibName;
+        if (sys::fs::exists(SharedLibPath)) {
+          RequiredLibs.clear();
+          RequiredLibs.push_back(SharedLibName);
+        }
+      }
+
       for (unsigned i = 0, e = RequiredLibs.size(); i != e; ++i) {
         StringRef Lib = RequiredLibs[i];
         if (i)
           OS << ' ';
 
         if (PrintLibNames) {
           OS << Lib;
         } else if (PrintLibFiles) {
           OS << ActiveLibDir << '/' << Lib;
         } else if (PrintLibs) {
           // If this is a typical library name, include it using -l.
-          if (Lib.startswith("lib") && Lib.endswith(".a")) {
-            OS << "-l" << Lib.slice(3, Lib.size()-2);
+          if (Lib.startswith("lib")) {
+            size_t FromEnd = 0;
+            if (Lib.endswith(".a")) {
+              FromEnd = 2;
+            } else if (Lib.endswith(".so")) {
+              FromEnd = 3;
+            } else if (Lib.endswith(".so." PACKAGE_VERSION)) {
+              FromEnd = 4 + std::strlen(PACKAGE_VERSION);
+            } else if (Lib.endswith(".dylib")) {
+              FromEnd = 6;
+            } else if (Lib.endswith(".dylib." PACKAGE_VERSION)) {
+              FromEnd = 7 + std::strlen(PACKAGE_VERSION);
+            } else {
+              FromEnd = 0;
+            }
+
+            if (FromEnd != 0) {
+              OS << "-l" << Lib.slice(3, Lib.size() - FromEnd);
+            } else {
+              OS << "-l:" << Lib;
+            }
             continue;
           }
 
           // Otherwise, print the full path.
           OS << ActiveLibDir << '/' << Lib;
         }
       }
       OS << '\n';