tools/llvm-config: improve shared library support

[axw]

Summary

r252532 added support for reporting the monolithic library
when LLVM_BUILD_LLVM_DYLIB is used. This would only be done
if the individual components were not found, and the dynamic
library is found.

This diff extends this as follows:

• If LLVM_LINK_LLVM_DYLIB is set, then prefer the shared library, even if all component libraries exist.
• Two flags, --link-shared and --link-static are introduced to provide explicit guidance. If --link-shared is passed and the shared library does not exist, an error results.

Additionally, changed the expected shared library names from
(e.g.) LLVM-3.8.0 to LLVM-3.8. The former exists only in an
installation (and then only in CMake builds I think?), and not
in the build tree; this breaks usage of llvm-config during
builds, e.g. by llvm-go.

[DiamondLovesYou]

It looks like if LLVM is built with LLVM_LINK_LLVM_DYLIB=ON and --link-static is provided and the static archives are removed, llvm-config doesn't error and still prints the shared lib with --libs.

[beanz]

LGTM.

[beanz]

Sorry, didn't notice Richard's comments. Those need to be addressed first.

[axw]

In D15033#297984, @DiamondLovesYou wrote:

It looks like if LLVM is built with LLVM_LINK_LLVM_DYLIB=ON and --link-static is provided and the static archives are removed, llvm-config doesn't error and still prints the shared lib with --libs.

I've updated it to cater for this. It's a bit more complicated in order to keep current behaviour.

I'd prefer if we didn't do this "if static exists use, otherwise use shared", and rather just use whatever the installation is supposed to as according to LLVM_LINK_LLVM_DYLIB. Richard, if you have no objections, I'll change it to do that.

[axw]

Fail on non-existing static libraries when --link-static supplied

[DiamondLovesYou]

In D15033#302259, @axw wrote:

In D15033#297984, @DiamondLovesYou wrote:

It looks like if LLVM is built with LLVM_LINK_LLVM_DYLIB=ON and --link-static is provided and the static archives are removed, llvm-config doesn't error and still prints the shared lib with --libs.

I've updated it to cater for this. It's a bit more complicated in order to keep current behaviour.

I'd prefer if we didn't do this "if static exists use, otherwise use shared", and rather just use whatever the installation is supposed to as according to LLVM_LINK_LLVM_DYLIB. Richard, if you have no objections, I'll change it to do that.

I disagree. Such complexity is easier to maintain upstream, and avoids multiple downstream solutions for this problem. The problem can still happen if LLVM_LINK_LLVM_DYLIB=OFF, and it would be Nice to automatically delegate to the dylib (if it exists) for external tools so things will Just Work (absent of --link-static).

[axw]

In D15033#310485, @DiamondLovesYou wrote:

In D15033#302259, @axw wrote:

In D15033#297984, @DiamondLovesYou wrote:

It looks like if LLVM is built with LLVM_LINK_LLVM_DYLIB=ON and --link-static is provided and the static archives are removed, llvm-config doesn't error and still prints the shared lib with --libs.

I've updated it to cater for this. It's a bit more complicated in order to keep current behaviour.

I'd prefer if we didn't do this "if static exists use, otherwise use shared", and rather just use whatever the installation is supposed to as according to LLVM_LINK_LLVM_DYLIB. Richard, if you have no objections, I'll change it to do that.

I disagree. Such complexity is easier to maintain upstream, and avoids multiple downstream solutions for this problem.

My contention is that the complexity is unnecessary in the first place; I don't see why anything should work around broken installations, regardless of whether that be in llvm-config or its users. The solution should be to fix the installation, not make everything more complicated. Anyway, I don't want to block the primary change with side debate, so forget this for now please.

The problem can still happen if LLVM_LINK_LLVM_DYLIB=OFF, and it would be Nice to automatically delegate to the dylib (if it exists) for external tools so things will Just Work (absent of --link-static).

Oops, I need to make a change to how ComputeLibsForComponents is called. Will do that later, fix up formatting and ping again. Thanks.

[DiamondLovesYou]

Anyway, I don't want to block the primary change with side debate, so forget this for now please.

Sure.

[axw]

Don't check IncludeNonInstalled when updating MissingLibs

[axw]

Format

[axw]

PTAL.

[DiamondLovesYou]

LGTM

[axw]

Thanks @DiamondLovesYou. @beanz, are you okay with this landing now? I'd like to get it in before the branch if possible.

[beanz]

Yes. LGTM!

Thanks,
-Chris

[axw]

I have reverted this, because it breaks if you have BUILD_SHARED_LIBS=on and we're about to branch for 3.8. I'll reapply when D15986 (or another fix) is ready to land.

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()

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@"

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()

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

tools/llvm-config/llvm-config.cpp

 // 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,
+
+  // LinkModeDyLib will link with the single dynamic library if it exists,
+  // and return an error if it does not exist.
+  LinkModeDyLib   = 1,
+
+  // LinkModeStatic will link with the individual component static libraries
+  // if they exist, and fail if any one does not exist.
+  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, bool *HasMissing) {
+                           const std::string *ActiveLibDir, 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);
+                   ActiveLibDir, 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 (!IncludeNonInstalled && Missing && ActiveLibDir) {
+      std::string path = *ActiveLibDir + "/" + 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::string *ActiveLibDir, 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];
     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);
+                   ActiveLibDir, 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\
 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) {
#endif
   /// 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 ? LinkModeDyLib : 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)) {
#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 = LinkModeDyLib;
+      } 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 (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> MissingLibs;
     std::vector<std::string> RequiredLibs =
         ComputeLibsForComponents(Components,
                                  /*IncludeNonInstalled=*/IsInDevelopmentTree,
-                                 false, &ActiveLibDir, &HasMissing);
+                                 false, &ActiveLibDir, &MissingLibs);
+    if (!MissingLibs.empty()) {
+      switch (LinkMode) {
+      case LinkModeDyLib:
+          break;
+      case LinkModeAuto:
+        if (DyLibExists) {
+          LinkMode = LinkModeDyLib;
+          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 == LinkModeDyLib) {
         OS << "shared\n";
         return 0;
       } else {
         OS << "static\n";
         return 0;
       }
     }
 
if (PrintLibs || PrintLibNames || PrintLibFiles) {
             }
           } else {
             // Otherwise, print the full path.
             OS << GetComponentLibraryPath(Lib, ForceShared);
           }
         }
       };
 
-      if (HasMissing && DyLibExists) {
+      if (LinkMode == LinkModeDyLib) {
         PrintForLib(DyLibName, true);
       } else {
         for (unsigned i = 0, e = RequiredLibs.size(); i != e; ++i) {
           auto Lib = RequiredLibs[i];
           if (i)
             OS << ' ';
 
           PrintForLib(Lib, false);

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()
   }
 }