llvm-config: Add preliminary Windows support

[• ehsan]

Summary

This patch adds Windows support for a few of the llvm-config commands,
including cflags, ldflags, libs, and system-libs.

Currently llvm-config is untested, so this patch adds tests for the
commands that it fixes as well.

[• ehsan]

This fixes a couple of bugs in the previous iteration of the patch.

[rnk]

lgtm

lib/Support/CMakeLists.txt

2–6

Seems simpler as

if (MSVC OR MINGW)
  set(system_libs ${system_libs} psapi shell32 ole32 uuid)
elseif (CMAKE_HOST_UNIX)
  ...

[chapuni]

Is this the direction that llvm-config emits "native" DirSep?
I suppose the primary user of llvm-config would be unix tools, like shell scripts and Make(1).

In my curiosity, who is an user to use native paths of llvm-config?

I suggest to add a flag like "--native", or "--dos", to change the behavior.

[chapuni]

Sorry, I misunderstood that the behavior weren't just for MSVC host. It is better.
That said, I suggest to keep behavior, just for the separator, by default. (lib's prefix and sufiix should be fine)

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

364 ↗

(On Diff #47348)

It confuses cross compilation, due to r252532. http://reviews.llvm.org/D13198

I will fix it later.

lib/Support/CMakeLists.txt

 set(system_libs)
-if( NOT MSVC )
+if( MSVC )
+  # libuuid required for FOLDERID_Profile usage in lib/Support/Windows/Path.inc.
+  set(system_libs ${system_libs} psapi shell32 ole32 uuid)
+else()
   if( MINGW )
     # libuuid required for FOLDERID_Profile usage in lib/Support/Windows/Path.inc.
     set(system_libs ${system_libs} psapi shell32 ole32 uuid)
   elseif( CMAKE_HOST_UNIX )
     if( HAVE_LIBRT )
       set(system_libs ${system_libs} rt)
     endif()
     if( HAVE_LIBDL )
       set(system_libs ${system_libs} ${CMAKE_DL_LIBS})
elseif( CMAKE_HOST_UNIX )
     if( LLVM_ENABLE_THREADS AND HAVE_LIBPTHREAD )
       set(system_libs ${system_libs} pthread)
     endif()
     if ( LLVM_ENABLE_ZLIB AND HAVE_LIBZ )
       set(system_libs ${system_libs} z)
     endif()
     set(system_libs ${system_libs} m)
   endif( MINGW )
-endif( NOT MSVC )
+endif( MSVC )
 
 add_llvm_library(LLVMSupport
   APFloat.cpp
   APInt.cpp
   APSInt.cpp
   ARMBuildAttrs.cpp
   ARMWinEH.cpp
   Allocator.cpp

test/tools/llvm-config/cflags.test

+RUN: llvm-config --cflags 2>&1 | FileCheck %s
+RUN: llvm-config --cppflags 2>&1 | FileCheck %s
+RUN: llvm-config --cxxflags 2>&1 | FileCheck %s
+CHECK: -I
+CHECK: {{[/\\]}}include
+CHECK-NOT: error
+CHECK-NOT: warning

test/tools/llvm-config/ldflags.test

+RUN: llvm-config --ldflags 2>&1 | FileCheck %s
+CHECK: -L
+CHECK: {{[/\\]}}lib
+CHECK-NOT: error
+CHECK-NOT: warning

test/tools/llvm-config/libs.test

+RUN: llvm-config --libs core 2>&1 | FileCheck %s
+CHECK: LLVMCore
+CHECK: LLVMSupport
+CHECK-NOT: error
+CHECK-NOT: warning

test/tools/llvm-config/system-libs.test

+RUN: llvm-config --system-libs 2>&1 | FileCheck %s
+CHECK: -l
+CHECK-NOT: error
+CHECK-NOT: warning

tools/llvm-config/llvm-config.cpp

 /// 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::function<std::string(const StringRef &)>
                                *GetComponentLibraryPath,
-                           std::vector<std::string> *Missing) {
+                           std::vector<std::string> *Missing,
+                           const std::string &DirSep) {
   // 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,
-                   GetComponentLibraryPath, Missing);
+                   GetComponentLibraryPath, Missing, DirSep);
   }
 
   if (GetComponentNames) {
     RequiredLibs.push_back(Name);
     return;
   }
 
   // Add to the required library list.
   if (AC->Library) {
     if (Missing && GetComponentLibraryPath) {
       std::string path = (*GetComponentLibraryPath)(AC->Library);
+      if (DirSep == "\\") {
+        std::replace(path.begin(), path.end(), '/', '\\');
+      }
       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::function<std::string(const StringRef &)>
+static std::vector<std::string> ComputeLibsForComponents(
+    const std::vector<StringRef> &Components, bool IncludeNonInstalled,
+    bool GetComponentNames, const std::function<std::string(const StringRef &)>
                                 *GetComponentLibraryPath,
-                         std::vector<std::string> *Missing) {
+    std::vector<std::string> *Missing, const std::string &DirSep) {
   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,
-                   GetComponentLibraryPath, Missing);
+                   GetComponentLibraryPath, Missing, DirSep);
   }
 
   // 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;
 }
std::string GetExecutablePath(const char *Argv0) {
   // allow taking the address of ::main however.
   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) {
+                                               const bool GetComponentNames,
+                                               const std::string &DirSep) {
   std::vector<StringRef> DyLibComponents;
 
   StringRef DyLibComponentsStr(LLVM_DYLIB_COMPONENTS);
   size_t Offset = 0;
   while (true) {
     const size_t NextOffset = DyLibComponentsStr.find(';', Offset);
     DyLibComponents.push_back(DyLibComponentsStr.substr(Offset, NextOffset));
     if (NextOffset == std::string::npos) {
       break;
     }
     Offset = NextOffset + 1;
   }
 
   assert(!DyLibComponents.empty());
 
   return ComputeLibsForComponents(DyLibComponents,
                                   /*IncludeNonInstalled=*/IsInDevelopmentTree,
-                                  GetComponentNames, nullptr, nullptr);
+                                  GetComponentNames, nullptr, nullptr, DirSep);
 }
 
 int main(int argc, char **argv) {
   std::vector<StringRef> Components;
   bool PrintLibs = false, PrintLibNames = false, PrintLibFiles = false;
   bool PrintSystemLibs = false, PrintSharedMode = false;
   bool HasAnyOption = false;
 
#endif
   /// 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";
+      StaticPrefix, StaticDir = "lib", DirSep = "/";
   const Triple HostTriple(Triple::normalize(LLVM_DEFAULT_TARGET_TRIPLE));
   if (HostTriple.isOSWindows()) {
     SharedExt = "dll";
     SharedVersionedExt = LLVM_DYLIB_VERSION ".dll";
+    if (HostTriple.isOSCygMing()) {
       StaticExt = "a";
+      StaticPrefix = SharedPrefix = "lib";
+    } else {
+      StaticExt = "lib";
+      DirSep = "\\";
+      std::replace(ActiveObjRoot.begin(), ActiveObjRoot.end(), '/', '\\');
+      std::replace(ActivePrefix.begin(), ActivePrefix.end(), '/', '\\');
+      std::replace(ActiveBinDir.begin(), ActiveBinDir.end(), '/', '\\');
+      std::replace(ActiveLibDir.begin(), ActiveLibDir.end(), '/', '\\');
+      std::replace(ActiveIncludeOption.begin(), ActiveIncludeOption.end(), '/',
+                   '\\');
+    }
     SharedDir = ActiveBinDir;
     StaticDir = ActiveLibDir;
-    StaticPrefix = SharedPrefix = "lib";
   } else if (HostTriple.isOSDarwin()) {
     SharedExt = "dylib";
     SharedVersionedExt = LLVM_DYLIB_VERSION ".dylib";
     StaticExt = "a";
     StaticDir = SharedDir = ActiveLibDir;
     StaticPrefix = SharedPrefix = "lib";
   } else {
     // default to the unix values:
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);
+    std::string path((SharedDir + DirSep + DyLibName).str());
+    if (DirSep == "\\") {
+      std::replace(path.begin(), path.end(), '/', '\\');
+    }
+    DyLibExists = sys::fs::exists(path);
     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;
if (Lib.startswith("lib")) {
       }
     }
 
     return false;
   };
   /// Maps Unixizms to the host platform.
   auto GetComponentLibraryFileName = [&](const StringRef &Lib,
                                          const bool Shared) {
-    std::string LibFileName = Lib;
-    StringRef LibName;
-    if (GetComponentLibraryNameSlice(Lib, LibName)) {
-      if (Shared) {
-        LibFileName = (SharedPrefix + LibName + "." + SharedExt).str();
-      } else {
-        // default to static
-        LibFileName = (StaticPrefix + LibName + "." + StaticExt).str();
-      }
+    std::string LibFileName;
+      LibFileName = (SharedPrefix + Lib + "." + SharedExt).str();
+      LibFileName = (StaticPrefix + Lib + "." + StaticExt).str();
     }
 
     return LibFileName;
   };
   /// Get the full path for a possibly shared component library.
   auto GetComponentLibraryPath = [&](const StringRef &Name, const bool Shared) {
     auto LibFileName = GetComponentLibraryFileName(Name, Shared);
     if (Shared) {
-      return (SharedDir + "/" + LibFileName).str();
+      return (SharedDir + DirSep + LibFileName).str();
     } else {
-      return (StaticDir + "/" + LibFileName).str();
+      return (StaticDir + DirSep + LibFileName).str();
     }
   };
 
   raw_ostream &OS = outs();
   for (int i = 1; i != argc; ++i) {
     StringRef Arg = argv[i];
 
     if (Arg.startswith("-")) {
if (Arg.startswith("-")) {
         std::vector<std::string> Components;
         for (unsigned j = 0; j != array_lengthof(AvailableComponents); ++j) {
           // Only include non-installed components when in a development tree.
           if (!AvailableComponents[j].IsInstalled && !IsInDevelopmentTree)
             continue;
 
           Components.push_back(AvailableComponents[j].Name);
           if (AvailableComponents[j].Library && !IsInDevelopmentTree) {
-            if (DyLibExists &&
-                !sys::fs::exists(GetComponentLibraryPath(
-                    AvailableComponents[j].Library, false))) {
-              Components = GetAllDyLibComponents(IsInDevelopmentTree, true);
+            std::string path(
+                GetComponentLibraryPath(AvailableComponents[j].Library, false));
+            if (DirSep == "\\") {
+              std::replace(path.begin(), path.end(), '/', '\\');
+            }
+            if (DyLibExists && !sys::fs::exists(path)) {
+              Components =
+                  GetAllDyLibComponents(IsInDevelopmentTree, true, DirSep);
               std::sort(Components.begin(), Components.end());
               break;
             }
           }
         }
 
         for (unsigned I = 0; I < Components.size(); ++I) {
           if (I) {
if (PrintLibs || PrintLibNames || PrintLibFiles || PrintSystemLibs ||
     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);
+        &GetComponentLibraryPathFunction, &MissingLibs, DirSep);
     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";
if (!MissingLibs.empty()) {
       }
     } else if (LinkMode == LinkModeAuto) {
       LinkMode = LinkModeStatic;
     }
 
     if (PrintSharedMode) {
       std::unordered_set<std::string> FullDyLibComponents;
       std::vector<std::string> DyLibComponents =
-          GetAllDyLibComponents(IsInDevelopmentTree, false);
+          GetAllDyLibComponents(IsInDevelopmentTree, false, DirSep);
 
       for (auto &Component : DyLibComponents) {
         FullDyLibComponents.insert(Component);
       }
       DyLibComponents.clear();
 
       for (auto &Lib : RequiredLibs) {
         if (!FullDyLibComponents.count(Lib)) {

utils/llvm-build/llvmbuild/main.py

""")
   /// The list of libraries required when linking this component.\n')
         f.write('  const char *RequiredLibraries[%d];\n' % (
             max_required_libraries))
         f.write('} AvailableComponents[%d] = {\n' % len(entries))
         for name,library_name,required_names,is_installed in entries:
             if library_name is None:
                 library_name_as_cstr = 'nullptr'
             else:
-                library_name_as_cstr = '"lib%s.a"' % library_name
+                library_name_as_cstr = '"%s"' % library_name
             if is_installed:
                 is_installed_as_cstr = 'true'
             else:
                 is_installed_as_cstr = 'false'
             f.write('  { "%s", %s, %s, { %s } },\n' % (
                 name, library_name_as_cstr, is_installed_as_cstr,
                 ', '.join('"%s"' % dep
                           for dep in required_names)))