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

llvm/trunk/cmake/modules/AddLLVM.cmake

if(LLVM_BINDINGS MATCHES "go")
     set(cc "${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}")
     set(cxx "${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1}")
     set(cppflags "")
     get_property(include_dirs DIRECTORY PROPERTY INCLUDE_DIRECTORIES)
     foreach(d ${include_dirs})
       set(cppflags "${cppflags} -I${d}")
     endforeach(d)
     set(ldflags "${CMAKE_EXE_LINKER_FLAGS}")
-    if (LLVM_LINK_LLVM_DYLIB)
-      set(linkmode "dylib")
-    else()
-      set(linkmode "component-libs")
-    endif()
     add_custom_command(OUTPUT ${binpath}
-      COMMAND ${CMAKE_BINARY_DIR}/bin/llvm-go "go=${GO_EXECUTABLE}" "cc=${cc}" "cxx=${cxx}" "cppflags=${cppflags}" "ldflags=${ldflags}" "linkmode=${linkmode}"
+      COMMAND ${CMAKE_BINARY_DIR}/bin/llvm-go "go=${GO_EXECUTABLE}" "cc=${cc}" "cxx=${cxx}" "cppflags=${cppflags}" "ldflags=${ldflags}"
               ${ARG_GOFLAGS} build -o ${binpath} ${pkgpath}
       DEPENDS llvm-config ${CMAKE_BINARY_DIR}/bin/llvm-go${CMAKE_EXECUTABLE_SUFFIX}
               ${llvmlibs} ${ARG_DEPENDS}
       COMMENT "Building Go executable ${binary}"
       VERBATIM)
     if (ARG_ALL)
       add_custom_target(${binary} ALL DEPENDS ${binpath})
     else()

llvm/trunk/tools/llvm-config/BuildVariables.inc.in

 #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_BUILD_SYSTEM "@LLVM_BUILD_SYSTEM@"
 #define LLVM_HAS_RTTI "@LLVM_HAS_RTTI@"
 #define LLVM_ENABLE_DYLIB "@LLVM_BUILD_LLVM_DYLIB@"
+#define LLVM_LINK_DYLIB "@LLVM_LINK_LLVM_DYLIB@"
 #define LLVM_ENABLE_SHARED "@LLVM_ENABLE_SHARED@"
 #define LLVM_DYLIB_COMPONENTS "@LLVM_DYLIB_COMPONENTS@"
+#define LLVM_DYLIB_VERSION "@LLVM_DYLIB_VERSION@"

llvm/trunk/tools/llvm-config/CMakeLists.txt

 # Use configure_file to create BuildVariables.inc.
 set(LLVM_SRC_ROOT ${LLVM_MAIN_SRC_DIR})
 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}")
 set(LLVM_BUILD_SYSTEM cmake)
 set(LLVM_HAS_RTTI ${LLVM_CONFIG_HAS_RTTI})
+set(LLVM_DYLIB_VERSION "${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}${LLVM_VERSION_SUFFIX}")
 
 # 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(BUILD_SHARED_LIBS)
   set(LLVM_ENABLE_SHARED ON)
 else()

llvm/trunk/tools/llvm-config/Makefile

 endif
 
 ifneq ($(REQUIRES_RTTI), 1)
   LLVM_HAS_RTTI := NO
 else
   LLVM_HAS_RTTI := YES
 endif
 
+LLVM_DYLIB_VERSION := $(LLVM_VERSION_MAJOR).$(LLVM_VERSION_MINOR)$(LLVM_VERSION_SUFFIX)
+
 # This is blank for now.  We need to be careful about adding stuff here:
 # LDFLAGS tend not to be portable, and we don't currently require the
 # user to use libtool when linking against LLVM.
 SUB_LDFLAGS :=
 
 $(ObjDir)/BuildVariables.inc: $(BUILDVARIABLES_SRCPATH) Makefile $(ObjDir)/.dir
   $(Echo) "Building llvm-config BuildVariables.inc file."
   $(Verb) $(ECHO) 's/@LLVM_SRC_ROOT@/$(subst /,\/,$(LLVM_SRC_ROOT))/' \
$(ObjDir)/BuildVariables.inc: $(BUILDVARIABLES_SRCPATH) Makefile $(ObjDir)/.dir
   $(Verb) $(ECHO) 's/@LLVM_ENABLE_SHARED@/OFF/' \
     >> temp.sed
   $(Verb) $(ECHO) 's/@LLVM_DYLIB_COMPONENTS@/all/' \
     >> temp.sed
   $(Verb) $(ECHO) 's/@LLVM_BUILD_SYSTEM@/autoconf/' \
     >> temp.sed
   $(Verb) $(ECHO) 's/@LLVM_HAS_RTTI@/$(LLVM_HAS_RTTI)/' \
     >> temp.sed
+  $(Verb) $(ECHO) 's/@LLVM_DYLIB_VERSION@/$(LLVM_DYLIB_VERSION)/' \
+    >> 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

llvm/trunk/tools/llvm-config/llvm-config.cpp

 #include "llvm/ADT/Twine.h"
 #include "llvm/Config/config.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdlib>
 #include <set>
-#include <vector>
 #include <unordered_set>
+#include <vector>
 
 using namespace llvm;
 
 // Include the build time variables we can report to the user. This is generated
 // at build time from the BuildVariables.inc.in file by the build system.
 #include "BuildVariables.inc"
 
 // Include the component table. This creates an array of struct
 // AvailableComponent entries, which record the component name, library name,
 // and required components for all of the available libraries.
 //
 // Not all components define a library, we also use "library groups" as a way to
 // create entries for pseudo groups like x86 or all-targets.
 #include "LibraryDependencies.inc"
 
+// 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,
+
+  // LinkModeShared will link with the dynamic component libraries if they
+  // exist, and return an error otherwise.
+  LinkModeShared = 1,
+
+  // 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,
+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, bool *HasMissing) {
+                           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, HasMissing);
+                   GetComponentLibraryPath, Missing);
   }
 
   if (GetComponentNames) {
     RequiredLibs.push_back(Name);
     return;
   }
 
   // Add to the required library list.
   if (AC->Library) {
-    if (!IncludeNonInstalled && HasMissing && !*HasMissing && ActiveLibDir) {
-      *HasMissing = !sys::fs::exists(*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, bool *HasMissing) {
+                         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;
+  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, GetComponentNames,
-                   ActiveLibDir, HasMissing);
+                   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 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) {
   // This just needs to be some symbol in the binary; C++ doesn't
   // allow taking the address of ::main however.
-  void *P = (void*) (intptr_t) GetExecutablePath;
+  void *P = (void *)(intptr_t)GetExecutablePath;
   return llvm::sys::fs::getMainExecutable(Argv0, P);
 }
 
 /// \brief Expand the semi-colon delimited LLVM_DYLIB_COMPONENTS into
 /// the full list of components.
 std::vector<std::string> GetAllDyLibComponents(const bool IsInDevelopmentTree,
                                                const bool GetComponentNames) {
   std::vector<StringRef> DyLibComponents;

 #if defined(CMAKE_CFG_INTDIR)
   if (!(CMAKE_CFG_INTDIR[0] == '.' && CMAKE_CFG_INTDIR[1] == '\0'))
     build_mode = CMAKE_CFG_INTDIR;
 #endif
 
   // Create an absolute path, and pop up one directory (we expect to be inside a
   // bin dir).
   sys::fs::make_absolute(CurrentPath);
-  CurrentExecPrefix = sys::path::parent_path(
-    sys::path::parent_path(CurrentPath)).str();
+  CurrentExecPrefix =
+      sys::path::parent_path(sys::path::parent_path(CurrentPath)).str();
 
   // Check to see if we are inside a development tree by comparing to possible
   // locations (prefix style or CMake style).
   if (sys::fs::equivalent(CurrentExecPrefix,
                           Twine(LLVM_OBJ_ROOT) + "/" + build_mode)) {
     IsInDevelopmentTree = true;
     DevelopmentTreeLayout = MakefileStyle;
 
case CMakeBuildModeStyle:
       ActivePrefix = ActiveObjRoot;
       ActiveBinDir = ActiveObjRoot + "/bin/" + build_mode;
       ActiveLibDir =
           ActiveObjRoot + "/lib" + LLVM_LIBDIR_SUFFIX + "/" + build_mode;
       break;
     }
 
     // We need to include files from both the source and object trees.
-    ActiveIncludeOption = ("-I" + ActiveIncludeDir + " " +
-                           "-I" + ActiveObjRoot + "/include");
+    ActiveIncludeOption =
+        ("-I" + ActiveIncludeDir + " " + "-I" + ActiveObjRoot + "/include");
   } else {
     ActivePrefix = CurrentExecPrefix;
     ActiveIncludeDir = ActivePrefix + "/include";
     ActiveBinDir = ActivePrefix + "/bin";
     ActiveLibDir = ActivePrefix + "/lib" + LLVM_LIBDIR_SUFFIX;
     ActiveIncludeOption = "-I" + ActiveIncludeDir;
   }
 
   /// We only use `shared library` mode in cases where the static library form
   /// of the components provided are not available; note however that this is
   /// skipped if we're run from within the build dir. However, once installed,
   /// we still need to provide correct output when the static archives are
   /// removed or, as in the case of CMake's `BUILD_SHARED_LIBS`, never present
   /// in the first place. This can't be done at configure/build time.
 
   StringRef SharedExt, SharedVersionedExt, SharedDir, SharedPrefix, StaticExt,
       StaticPrefix, StaticDir = "lib";
   const Triple HostTriple(Triple::normalize(LLVM_DEFAULT_TARGET_TRIPLE));
   if (HostTriple.isOSWindows()) {
     SharedExt = "dll";
-    SharedVersionedExt = PACKAGE_VERSION ".dll";
+    SharedVersionedExt = LLVM_DYLIB_VERSION ".dll";
     StaticExt = "a";
     SharedDir = ActiveBinDir;
     StaticDir = ActiveLibDir;
     StaticPrefix = SharedPrefix = "lib";
   } else if (HostTriple.isOSDarwin()) {
     SharedExt = "dylib";
-    SharedVersionedExt = PACKAGE_VERSION ".dylib";
+    SharedVersionedExt = LLVM_DYLIB_VERSION ".dylib";
     StaticExt = "a";
     StaticDir = SharedDir = ActiveLibDir;
     StaticPrefix = SharedPrefix = "lib";
   } else {
     // default to the unix values:
     SharedExt = "so";
-    SharedVersionedExt = PACKAGE_VERSION ".so";
+    SharedVersionedExt = LLVM_DYLIB_VERSION ".so";
     StaticExt = "a";
     StaticDir = SharedDir = ActiveLibDir;
     StaticPrefix = SharedPrefix = "lib";
   }
 
   const bool BuiltDyLib = (std::strcmp(LLVM_ENABLE_DYLIB, "ON") == 0);
 
   enum { CMake, AutoConf } ConfigTool;
   if (std::strcmp(LLVM_BUILD_SYSTEM, "cmake") == 0) {
     ConfigTool = CMake;
   } else {
     ConfigTool = AutoConf;
   }
 
   /// CMake style shared libs, ie each component is in a shared library.
   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.
+  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 || 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
       } else if (Arg == "--has-rtti") {
         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 = LinkModeShared;
+      } else if (Arg == "--link-static") {
+        LinkMode = LinkModeStatic;
       } else {
         usage();
       }
     } else {
       Components.push_back(Arg);
     }
   }
 
   if (!HasAnyOption)
     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.
-    bool HasMissing = false;
-    std::vector<std::string> RequiredLibs =
-        ComputeLibsForComponents(Components,
-                                 /*IncludeNonInstalled=*/IsInDevelopmentTree,
-                                 false, &ActiveLibDir, &HasMissing);
+    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,
+        &GetComponentLibraryPathFunction, &MissingLibs);
+    if (!MissingLibs.empty()) {
+      switch (LinkMode) {
+      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 = 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";
+        return 1;
+      }
+    } else if (LinkMode == LinkModeAuto) {
+      LinkMode = LinkModeStatic;
+    }
 
     if (PrintSharedMode) {
       std::unordered_set<std::string> FullDyLibComponents;
       std::vector<std::string> DyLibComponents =
           GetAllDyLibComponents(IsInDevelopmentTree, false);
 
       for (auto &Component : DyLibComponents) {
         FullDyLibComponents.insert(Component);
       }
       DyLibComponents.clear();
 
       for (auto &Lib : RequiredLibs) {
         if (!FullDyLibComponents.count(Lib)) {
           OS << "static\n";
           return 0;
         }
       }
       FullDyLibComponents.clear();
 
-      if (HasMissing && DyLibExists) {
+      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 (HasMissing && DyLibExists) {
-        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;
 }

llvm/trunk/tools/llvm-go/llvm-go.go

func llvmConfig(args ...string) string {
   }
 
   outstr := string(out)
   outstr = strings.TrimSuffix(outstr, "\n")
   outstr = strings.Replace(outstr, "\n", " ", -1)
   return outstr
 }
 
-func llvmFlags(linkmode string) compilerFlags {
-  ldflags := llvmConfig("--ldflags")
-  switch linkmode {
-  case linkmodeComponentLibs:
-    ldflags += " " + llvmConfig(append([]string{"--libs"}, components...)...)
-  case linkmodeDylib:
-    ldflags += " -lLLVM"
-  default:
-    panic("invalid linkmode: " + linkmode)
-  }
-  ldflags += " " + llvmConfig("--system-libs")
+func llvmFlags() compilerFlags {
+  ldflags := llvmConfig("--ldflags", "--libs", "--system-libs")
   if runtime.GOOS != "darwin" {
     // OS X doesn't like -rpath with cgo. See:
     // https://code.google.com/p/go/issues/detail?id=7293
     ldflags = "-Wl,-rpath," + llvmConfig("--libdir") + " " + ldflags
   }
   return compilerFlags{
     cpp: llvmConfig("--cppflags"),
     cxx: "-std=c++11",
func addTag(args []string, tag string) []string {
   }
   return args
 }
 
 func printComponents() {
   fmt.Println(strings.Join(components, " "))
 }
 
-func printConfig(linkmode string) {
-  flags := llvmFlags(linkmode)
+func printConfig() {
+  flags := llvmFlags()
 
   fmt.Printf(`// +build !byollvm
 
 // This file is generated by llvm-go, do not edit.
 
 package llvm
 
 /*
 #cgo CPPFLAGS: %s
 #cgo CXXFLAGS: %s
 #cgo LDFLAGS: %s
 */
 import "C"
 
 type (run_build_sh int)
 `, flags.cpp, flags.cxx, flags.ld)
 }
 
-func runGoWithLLVMEnv(args []string, cc, cxx, gocmd, llgo, cppflags, cxxflags, ldflags, linkmode string) {
+func runGoWithLLVMEnv(args []string, cc, cxx, gocmd, llgo, cppflags, cxxflags, ldflags string) {
   args = addTag(args, "byollvm")
 
   srcdir := llvmConfig("--src-root")
 
   tmpgopath, err := ioutil.TempDir("", "gopath")
   if err != nil {
     panic(err.Error())
   }
func runGoWithLLVMEnv(args []string, cc, cxx, gocmd, llgo, cppflags, cxxflags, ldflags string) {
   }
 
   newpath := os.Getenv("PATH")
 
   newgopathlist := []string{tmpgopath}
   newgopathlist = append(newgopathlist, filepath.SplitList(os.Getenv("GOPATH"))...)
   newgopath := strings.Join(newgopathlist, string(filepath.ListSeparator))
 
-  flags := llvmFlags(linkmode)
+  flags := llvmFlags()
 
   newenv := []string{
     "CC=" + cc,
     "CXX=" + cxx,
     "CGO_CPPFLAGS=" + flags.cpp + " " + cppflags,
     "CGO_CXXFLAGS=" + flags.cxx + " " + cxxflags,
     "CGO_LDFLAGS=" + flags.ld + " " + ldflags,
     "GOPATH=" + newgopath,

 func main() {
   cc := os.Getenv("CC")
   cxx := os.Getenv("CXX")
   cppflags := os.Getenv("CGO_CPPFLAGS")
   cxxflags := os.Getenv("CGO_CXXFLAGS")
   ldflags := os.Getenv("CGO_LDFLAGS")
   gocmd := "go"
   llgo := ""
-  linkmode := linkmodeComponentLibs
 
   flags := []struct {
     name string
     dest *string
   }{
     {"cc", &cc},
     {"cxx", &cxx},
     {"go", &gocmd},
     {"llgo", &llgo},
     {"cppflags", &cppflags},
     {"ldflags", &ldflags},
-    {"linkmode", &linkmode},
   }
 
   args := os.Args[1:]
 LOOP:
   for {
     if len(args) == 0 {
       usage()
     }
     for _, flag := range flags {
       if strings.HasPrefix(args[0], flag.name+"=") {
         *flag.dest = args[0][len(flag.name)+1:]
         args = args[1:]
         continue LOOP
       }
     }
     break
   }
 
   switch args[0] {
   case "build", "get", "install", "run", "test":
-    runGoWithLLVMEnv(args, cc, cxx, gocmd, llgo, cppflags, cxxflags, ldflags, linkmode)
+    runGoWithLLVMEnv(args, cc, cxx, gocmd, llgo, cppflags, cxxflags, ldflags)
   case "print-components":
     printComponents()
   case "print-config":
-    printConfig(linkmode)
+    printConfig()
   default:
     usage()
   }
 }