tools/llvm-config/llvm-config.cpp

   1 //===-- llvm-config.cpp - LLVM project configuration utility --------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This tool encapsulates information about an LLVM project configuration for
  10 // use by other project's build environments (to determine installed path,
  11 // available features, required libraries, etc.).
  12 //
  13 // Note that although this tool *may* be used by some parts of LLVM's build
  14 // itself (i.e., the Makefiles use it to compute required libraries when linking
  15 // tools), this tool is primarily designed to support external projects.
  16 //
  17 //===----------------------------------------------------------------------===//
  18
  19 #include "llvm/Config/llvm-config.h"
  20 #include "llvm/ADT/STLExtras.h"
  21 #include "llvm/ADT/StringMap.h"
  22 #include "llvm/ADT/StringRef.h"
  23 #include "llvm/ADT/Triple.h"
  24 #include "llvm/ADT/Twine.h"
  25 #include "llvm/Config/config.h"
  26 #include "llvm/Support/FileSystem.h"
  27 #include "llvm/Support/Path.h"
  28 #include "llvm/Support/WithColor.h"
  29 #include "llvm/Support/raw_ostream.h"
  30 #include <cstdlib>
  31 #include <set>
  32 #include <unordered_set>
  33 #include <vector>
  34
  35 using namespace llvm;
  36
  37 // Include the build time variables we can report to the user. This is generated
  38 // at build time from the BuildVariables.inc.in file by the build system.
  39 #include "BuildVariables.inc"
  40
  41 // Include the component table. This creates an array of struct
  42 // AvailableComponent entries, which record the component name, library name,
  43 // and required components for all of the available libraries.
  44 //
  45 // Not all components define a library, we also use "library groups" as a way to
  46 // create entries for pseudo groups like x86 or all-targets.
  47 #include "LibraryDependencies.inc"
  48
  49 // LinkMode determines what libraries and flags are returned by llvm-config.
  50 enum LinkMode {
  51   // LinkModeAuto will link with the default link mode for the installation,
  52   // which is dependent on the value of LLVM_LINK_LLVM_DYLIB, and fall back
  53   // to the alternative if the required libraries are not available.
  54   LinkModeAuto = 0,
  55
  56   // LinkModeShared will link with the dynamic component libraries if they
  57   // exist, and return an error otherwise.
  58   LinkModeShared = 1,
  59
  60   // LinkModeStatic will link with the static component libraries if they
  61   // exist, and return an error otherwise.
  62   LinkModeStatic = 2,
  63 };
  64
  65 /// Traverse a single component adding to the topological ordering in
  66 /// \arg RequiredLibs.
  67 ///
  68 /// \param Name - The component to traverse.
  69 /// \param ComponentMap - A prebuilt map of component names to descriptors.
  70 /// \param VisitedComponents [in] [out] - The set of already visited components.
  71 /// \param RequiredLibs [out] - The ordered list of required
  72 /// libraries.
  73 /// \param GetComponentNames - Get the component names instead of the
  74 /// library name.
  75 static void VisitComponent(const std::string &Name,
  76                            const StringMap<AvailableComponent *> &ComponentMap,
  77                            std::set<AvailableComponent *> &VisitedComponents,
  78                            std::vector<std::string> &RequiredLibs,
  79                            bool IncludeNonInstalled, bool GetComponentNames,
  80                            const std::function<std::string(const StringRef &)>
  81                                *GetComponentLibraryPath,
  82                            std::vector<std::string> *Missing,
  83                            const std::string &DirSep) {
  84   // Lookup the component.
  85   AvailableComponent *AC = ComponentMap.lookup(Name);
  86   if (!AC) {
  87     errs() << "Can't find component: '" << Name << "' in the map. Available components are: ";
  88     for (const auto &Component : ComponentMap) {
  89       errs() << "'" << Component.first() << "' ";
  90     }
  91     errs() << "\n";
  92     report_fatal_error("abort");
  93   }
  94   assert(AC && "Invalid component name!");
  95
  96   // Add to the visited table.
  97   if (!VisitedComponents.insert(AC).second) {
  98     // We are done if the component has already been visited.
  99     return;
 100   }
 101
 102   // Only include non-installed components if requested.
 103   if (!AC->IsInstalled && !IncludeNonInstalled)
 104     return;
 105
 106   // Otherwise, visit all the dependencies.
 107   for (unsigned i = 0; AC->RequiredLibraries[i]; ++i) {
 108     VisitComponent(AC->RequiredLibraries[i], ComponentMap, VisitedComponents,
 109                    RequiredLibs, IncludeNonInstalled, GetComponentNames,
 110                    GetComponentLibraryPath, Missing, DirSep);
 111   }
 112
 113   if (GetComponentNames) {
 114     RequiredLibs.push_back(Name);
 115     return;
 116   }
 117
 118   // Add to the required library list.
 119   if (AC->Library) {
 120     if (Missing && GetComponentLibraryPath) {
 121       std::string path = (*GetComponentLibraryPath)(AC->Library);
 122       if (DirSep == "\\") {
 123         std::replace(path.begin(), path.end(), '/', '\\');
 124       }
 125       if (!sys::fs::exists(path))
 126         Missing->push_back(path);
 127     }
 128     RequiredLibs.push_back(AC->Library);
 129   }
 130 }
 131
 132 /// Compute the list of required libraries for a given list of
 133 /// components, in an order suitable for passing to a linker (that is, libraries
 134 /// appear prior to their dependencies).
 135 ///
 136 /// \param Components - The names of the components to find libraries for.
 137 /// \param IncludeNonInstalled - Whether non-installed components should be
 138 /// reported.
 139 /// \param GetComponentNames - True if one would prefer the component names.
 140 static std::vector<std::string> ComputeLibsForComponents(
 141     const std::vector<StringRef> &Components, bool IncludeNonInstalled,
 142     bool GetComponentNames, const std::function<std::string(const StringRef &)>
 143                                 *GetComponentLibraryPath,
 144     std::vector<std::string> *Missing, const std::string &DirSep) {
 145   std::vector<std::string> RequiredLibs;
 146   std::set<AvailableComponent *> VisitedComponents;
 147
 148   // Build a map of component names to information.
 149   StringMap<AvailableComponent *> ComponentMap;
 150   for (unsigned i = 0; i != array_lengthof(AvailableComponents); ++i) {
 151     AvailableComponent *AC = &AvailableComponents[i];
 152     ComponentMap[AC->Name] = AC;
 153   }
 154
 155   // Visit the components.
 156   for (unsigned i = 0, e = Components.size(); i != e; ++i) {
 157     // Users are allowed to provide mixed case component names.
 158     std::string ComponentLower = Components[i].lower();
 159
 160     // Validate that the user supplied a valid component name.
 161     if (!ComponentMap.count(ComponentLower)) {
 162       llvm::errs() << "llvm-config: unknown component name: " << Components[i]
 163                    << "\n";
 164       exit(1);
 165     }
 166
 167     VisitComponent(ComponentLower, ComponentMap, VisitedComponents,
 168                    RequiredLibs, IncludeNonInstalled, GetComponentNames,
 169                    GetComponentLibraryPath, Missing, DirSep);
 170   }
 171
 172   // The list is now ordered with leafs first, we want the libraries to printed
 173   // in the reverse order of dependency.
 174   std::reverse(RequiredLibs.begin(), RequiredLibs.end());
 175
 176   return RequiredLibs;
 177 }
 178
 179 /* *** */
 180
 181 static void usage() {
 182   errs() << "\
 183 usage: llvm-config <OPTION>... [<COMPONENT>...]\n\
 184 \n\
 185 Get various configuration information needed to compile programs which use\n\
 186 LLVM.  Typically called from 'configure' scripts.  Examples:\n\
 187   llvm-config --cxxflags\n\
 188   llvm-config --ldflags\n\
 189   llvm-config --libs engine bcreader scalaropts\n\
 190 \n\
 191 Options:\n\
 192   --version         Print LLVM version.\n\
 193   --prefix          Print the installation prefix.\n\
 194   --src-root        Print the source root LLVM was built from.\n\
 195   --obj-root        Print the object root used to build LLVM.\n\
 196   --bindir          Directory containing LLVM executables.\n\
 197   --includedir      Directory containing LLVM headers.\n\
 198   --libdir          Directory containing LLVM libraries.\n\
 199   --cmakedir        Directory containing LLVM cmake modules.\n\
 200   --cppflags        C preprocessor flags for files that include LLVM headers.\n\
 201   --cflags          C compiler flags for files that include LLVM headers.\n\
 202   --cxxflags        C++ compiler flags for files that include LLVM headers.\n\
 203   --ldflags         Print Linker flags.\n\
 204   --system-libs     System Libraries needed to link against LLVM components.\n\
 205   --libs            Libraries needed to link against LLVM components.\n\
 206   --libnames        Bare library names for in-tree builds.\n\
 207   --libfiles        Fully qualified library filenames for makefile depends.\n\
 208   --components      List of all possible components.\n\
 209   --targets-built   List of all targets currently built.\n\
 210   --host-target     Target triple used to configure LLVM.\n\
 211   --build-mode      Print build mode of LLVM tree (e.g. Debug or Release).\n\
 212   --assertion-mode  Print assertion mode of LLVM tree (ON or OFF).\n\
 213   --build-system    Print the build system used to build LLVM (always cmake).\n\
 214   --has-rtti        Print whether or not LLVM was built with rtti (YES or NO).\n\
 215   --has-global-isel Print whether or not LLVM was built with global-isel support (ON or OFF).\n\
 216   --shared-mode     Print how the provided components can be collectively linked (`shared` or `static`).\n\
 217   --link-shared     Link the components as shared libraries.\n\
 218   --link-static     Link the component libraries statically.\n\
 219   --ignore-libllvm  Ignore libLLVM and link component libraries instead.\n\
 220 Typical components:\n\
 221   all               All LLVM libraries (default).\n\
 222   engine            Either a native JIT or a bitcode interpreter.\n";
 223   exit(1);
 224 }
 225
 226 /// Compute the path to the main executable.
 227 std::string GetExecutablePath(const char *Argv0) {
 228   // This just needs to be some symbol in the binary; C++ doesn't
 229   // allow taking the address of ::main however.
 230   void *P = (void *)(intptr_t)GetExecutablePath;
 231   return llvm::sys::fs::getMainExecutable(Argv0, P);
 232 }
 233
 234 /// Expand the semi-colon delimited LLVM_DYLIB_COMPONENTS into
 235 /// the full list of components.
 236 std::vector<std::string> GetAllDyLibComponents(const bool IsInDevelopmentTree,
 237                                                const bool GetComponentNames,
 238                                                const std::string &DirSep) {
 239   std::vector<StringRef> DyLibComponents;
 240
 241   StringRef DyLibComponentsStr(LLVM_DYLIB_COMPONENTS);
 242   size_t Offset = 0;
 243   while (true) {
 244     const size_t NextOffset = DyLibComponentsStr.find(';', Offset);
 245     DyLibComponents.push_back(DyLibComponentsStr.substr(Offset, NextOffset-Offset));
 246     if (NextOffset == std::string::npos) {
 247       break;
 248     }
 249     Offset = NextOffset + 1;
 250   }
 251
 252   assert(!DyLibComponents.empty());
 253
 254   return ComputeLibsForComponents(DyLibComponents,
 255                                   /*IncludeNonInstalled=*/IsInDevelopmentTree,
 256                                   GetComponentNames, nullptr, nullptr, DirSep);
 257 }
 258
 259 int main(int argc, char **argv) {
 260   std::vector<StringRef> Components;
 261   bool PrintLibs = false, PrintLibNames = false, PrintLibFiles = false;
 262   bool PrintSystemLibs = false, PrintSharedMode = false;
 263   bool HasAnyOption = false;
 264
 265   // llvm-config is designed to support being run both from a development tree
 266   // and from an installed path. We try and auto-detect which case we are in so
 267   // that we can report the correct information when run from a development
 268   // tree.
 269   bool IsInDevelopmentTree;
 270   enum { CMakeStyle, CMakeBuildModeStyle } DevelopmentTreeLayout;
 271   llvm::SmallString<256> CurrentPath(GetExecutablePath(argv[0]));
 272   std::string CurrentExecPrefix;
 273   std::string ActiveObjRoot;
 274
 275   // If CMAKE_CFG_INTDIR is given, honor it as build mode.
 276   char const *build_mode = LLVM_BUILDMODE;
 277 #if defined(CMAKE_CFG_INTDIR)
 278   if (!(CMAKE_CFG_INTDIR[0] == '.' && CMAKE_CFG_INTDIR[1] == '\0'))
 279     build_mode = CMAKE_CFG_INTDIR;
 280 #endif
 281
 282   // Create an absolute path, and pop up one directory (we expect to be inside a
 283   // bin dir).
 284   sys::fs::make_absolute(CurrentPath);
 285   CurrentExecPrefix =
 286       sys::path::parent_path(sys::path::parent_path(CurrentPath)).str();
 287
 288   // Check to see if we are inside a development tree by comparing to possible
 289   // locations (prefix style or CMake style).
 290   if (sys::fs::equivalent(CurrentExecPrefix, LLVM_OBJ_ROOT)) {
 291     IsInDevelopmentTree = true;
 292     DevelopmentTreeLayout = CMakeStyle;
 293     ActiveObjRoot = LLVM_OBJ_ROOT;
 294   } else if (sys::fs::equivalent(CurrentExecPrefix,
 295                                  Twine(LLVM_OBJ_ROOT) + "/bin")) {
 296     IsInDevelopmentTree = true;
 297     DevelopmentTreeLayout = CMakeBuildModeStyle;
 298     ActiveObjRoot = LLVM_OBJ_ROOT;
 299   } else {
 300     IsInDevelopmentTree = false;
 301     DevelopmentTreeLayout = CMakeStyle; // Initialized to avoid warnings.
 302   }
 303
 304   // Compute various directory locations based on the derived location
 305   // information.
 306   std::string ActivePrefix, ActiveBinDir, ActiveIncludeDir, ActiveLibDir,
 307               ActiveCMakeDir;
 308   std::string ActiveIncludeOption;
 309   if (IsInDevelopmentTree) {
 310     ActiveIncludeDir = std::string(LLVM_SRC_ROOT) + "/include";
 311     ActivePrefix = CurrentExecPrefix;
 312
 313     // CMake organizes the products differently than a normal prefix style
 314     // layout.
 315     switch (DevelopmentTreeLayout) {
 316     case CMakeStyle:
 317       ActiveBinDir = ActiveObjRoot + "/bin";
 318       ActiveLibDir = ActiveObjRoot + "/lib" + LLVM_LIBDIR_SUFFIX;
 319       ActiveCMakeDir = ActiveLibDir + "/cmake/llvm";
 320       break;
 321     case CMakeBuildModeStyle:
 322       ActivePrefix = ActiveObjRoot;
 323       ActiveBinDir = ActiveObjRoot + "/bin/" + build_mode;
 324       ActiveLibDir =
 325           ActiveObjRoot + "/lib" + LLVM_LIBDIR_SUFFIX + "/" + build_mode;
 326       ActiveCMakeDir = ActiveLibDir + "/cmake/llvm";
 327       break;
 328     }
 329
 330     // We need to include files from both the source and object trees.
 331     ActiveIncludeOption =
 332         ("-I" + ActiveIncludeDir + " " + "-I" + ActiveObjRoot + "/include");
 333   } else {
 334     ActivePrefix = CurrentExecPrefix;
 335     ActiveIncludeDir = ActivePrefix + "/include";
 336     SmallString<256> path(StringRef(LLVM_TOOLS_INSTALL_DIR));
 337     sys::fs::make_absolute(ActivePrefix, path);
 338     ActiveBinDir = path.str();
 339     ActiveLibDir = ActivePrefix + "/lib" + LLVM_LIBDIR_SUFFIX;
 340     ActiveCMakeDir = ActiveLibDir + "/cmake/llvm";
 341     ActiveIncludeOption = "-I" + ActiveIncludeDir;
 342   }
 343
 344   /// We only use `shared library` mode in cases where the static library form
 345   /// of the components provided are not available; note however that this is
 346   /// skipped if we're run from within the build dir. However, once installed,
 347   /// we still need to provide correct output when the static archives are
 348   /// removed or, as in the case of CMake's `BUILD_SHARED_LIBS`, never present
 349   /// in the first place. This can't be done at configure/build time.
 350
 351   StringRef SharedExt, SharedVersionedExt, SharedDir, SharedPrefix, StaticExt,
 352       StaticPrefix, StaticDir = "lib", DirSep = "/";
 353   const Triple HostTriple(Triple::normalize(LLVM_HOST_TRIPLE));
 354   if (HostTriple.isOSWindows()) {
 355     SharedExt = "dll";
 356     SharedVersionedExt = LLVM_DYLIB_VERSION ".dll";
 357     if (HostTriple.isOSCygMing()) {
 358       StaticExt = "a";
 359       StaticPrefix = "lib";
 360     } else {
 361       StaticExt = "lib";
 362       DirSep = "\\";
 363       std::replace(ActiveObjRoot.begin(), ActiveObjRoot.end(), '/', '\\');
 364       std::replace(ActivePrefix.begin(), ActivePrefix.end(), '/', '\\');
 365       std::replace(ActiveBinDir.begin(), ActiveBinDir.end(), '/', '\\');
 366       std::replace(ActiveLibDir.begin(), ActiveLibDir.end(), '/', '\\');
 367       std::replace(ActiveCMakeDir.begin(), ActiveCMakeDir.end(), '/', '\\');
 368       std::replace(ActiveIncludeOption.begin(), ActiveIncludeOption.end(), '/',
 369                    '\\');
 370     }
 371     SharedDir = ActiveBinDir;
 372     StaticDir = ActiveLibDir;
 373   } else if (HostTriple.isOSDarwin()) {
 374     SharedExt = "dylib";
 375     SharedVersionedExt = LLVM_DYLIB_VERSION ".dylib";
 376     StaticExt = "a";
 377     StaticDir = SharedDir = ActiveLibDir;
 378     StaticPrefix = SharedPrefix = "lib";
 379   } else {
 380     // default to the unix values:
 381     SharedExt = "so";
 382     SharedVersionedExt = LLVM_DYLIB_VERSION ".so";
 383     StaticExt = "a";
 384     StaticDir = SharedDir = ActiveLibDir;
 385     StaticPrefix = SharedPrefix = "lib";
 386   }
 387
 388   const bool BuiltDyLib = !!LLVM_ENABLE_DYLIB;
 389
 390   /// CMake style shared libs, ie each component is in a shared library.
 391   const bool BuiltSharedLibs = !!LLVM_ENABLE_SHARED;
 392
 393   bool DyLibExists = false;
 394   const std::string DyLibName =
 395       (SharedPrefix + "LLVM-" + SharedVersionedExt).str();
 396
 397   // If LLVM_LINK_DYLIB is ON, the single shared library will be returned
 398   // for "--libs", etc, if they exist. This behaviour can be overridden with
 399   // --link-static or --link-shared.
 400   bool LinkDyLib = !!LLVM_LINK_DYLIB;
 401
 402   if (BuiltDyLib) {
 403     std::string path((SharedDir + DirSep + DyLibName).str());
 404     if (DirSep == "\\") {
 405       std::replace(path.begin(), path.end(), '/', '\\');
 406     }
 407     DyLibExists = sys::fs::exists(path);
 408     if (!DyLibExists) {
 409       // The shared library does not exist: don't error unless the user
 410       // explicitly passes --link-shared.
 411       LinkDyLib = false;
 412     }
 413   }
 414   LinkMode LinkMode =
 415       (LinkDyLib || BuiltSharedLibs) ? LinkModeShared : LinkModeAuto;
 416
 417   /// Get the component's library name without the lib prefix and the
 418   /// extension. Returns true if Lib is in a recognized format.
 419   auto GetComponentLibraryNameSlice = [&](const StringRef &Lib,
 420                                           StringRef &Out) {
 421     if (Lib.startswith("lib")) {
 422       unsigned FromEnd;
 423       if (Lib.endswith(StaticExt)) {
 424         FromEnd = StaticExt.size() + 1;
 425       } else if (Lib.endswith(SharedExt)) {
 426         FromEnd = SharedExt.size() + 1;
 427       } else {
 428         FromEnd = 0;
 429       }
 430
 431       if (FromEnd != 0) {
 432         Out = Lib.slice(3, Lib.size() - FromEnd);
 433         return true;
 434       }
 435     }
 436
 437     return false;
 438   };
 439   /// Maps Unixizms to the host platform.
 440   auto GetComponentLibraryFileName = [&](const StringRef &Lib,
 441                                          const bool Shared) {
 442     std::string LibFileName;
 443     if (Shared) {
 444       if (Lib == DyLibName) {
 445         // Treat the DyLibName specially. It is not a component library and
 446         // already has the necessary prefix and suffix (e.g. `.so`) added so
 447         // just return it unmodified.
 448         assert(Lib.endswith(SharedExt) && "DyLib is missing suffix");
 449         LibFileName = Lib;
 450       } else {
 451         LibFileName = (SharedPrefix + Lib + "." + SharedExt).str();
 452       }
 453     } else {
 454       // default to static
 455       LibFileName = (StaticPrefix + Lib + "." + StaticExt).str();
 456     }
 457
 458     return LibFileName;
 459   };
 460   /// Get the full path for a possibly shared component library.
 461   auto GetComponentLibraryPath = [&](const StringRef &Name, const bool Shared) {
 462     auto LibFileName = GetComponentLibraryFileName(Name, Shared);
 463     if (Shared) {
 464       return (SharedDir + DirSep + LibFileName).str();
 465     } else {
 466       return (StaticDir + DirSep + LibFileName).str();
 467     }
 468   };
 469
 470   raw_ostream &OS = outs();
 471   for (int i = 1; i != argc; ++i) {
 472     StringRef Arg = argv[i];
 473
 474     if (Arg.startswith("-")) {
 475       HasAnyOption = true;
 476       if (Arg == "--version") {
 477         OS << PACKAGE_VERSION << '\n';
 478       } else if (Arg == "--prefix") {
 479         OS << ActivePrefix << '\n';
 480       } else if (Arg == "--bindir") {
 481         OS << ActiveBinDir << '\n';
 482       } else if (Arg == "--includedir") {
 483         OS << ActiveIncludeDir << '\n';
 484       } else if (Arg == "--libdir") {
 485         OS << ActiveLibDir << '\n';
 486       } else if (Arg == "--cmakedir") {
 487         OS << ActiveCMakeDir << '\n';
 488       } else if (Arg == "--cppflags") {
 489         OS << ActiveIncludeOption << ' ' << LLVM_CPPFLAGS << '\n';
 490       } else if (Arg == "--cflags") {
 491         OS << ActiveIncludeOption << ' ' << LLVM_CFLAGS << '\n';
 492       } else if (Arg == "--cxxflags") {
 493         OS << ActiveIncludeOption << ' ' << LLVM_CXXFLAGS << '\n';
 494       } else if (Arg == "--ldflags") {
 495         OS << ((HostTriple.isWindowsMSVCEnvironment()) ? "-LIBPATH:" : "-L")
 496            << ActiveLibDir << ' ' << LLVM_LDFLAGS << '\n';
 497       } else if (Arg == "--system-libs") {
 498         PrintSystemLibs = true;
 499       } else if (Arg == "--libs") {
 500         PrintLibs = true;
 501       } else if (Arg == "--libnames") {
 502         PrintLibNames = true;
 503       } else if (Arg == "--libfiles") {
 504         PrintLibFiles = true;
 505       } else if (Arg == "--components") {
 506         /// If there are missing static archives and a dylib was
 507         /// built, print LLVM_DYLIB_COMPONENTS instead of everything
 508         /// in the manifest.
 509         std::vector<std::string> Components;
 510         for (unsigned j = 0; j != array_lengthof(AvailableComponents); ++j) {
 511           // Only include non-installed components when in a development tree.
 512           if (!AvailableComponents[j].IsInstalled && !IsInDevelopmentTree)
 513             continue;
 514
 515           Components.push_back(AvailableComponents[j].Name);
 516           if (AvailableComponents[j].Library && !IsInDevelopmentTree) {
 517             std::string path(
 518                 GetComponentLibraryPath(AvailableComponents[j].Library, false));
 519             if (DirSep == "\\") {
 520               std::replace(path.begin(), path.end(), '/', '\\');
 521             }
 522             if (DyLibExists && !sys::fs::exists(path)) {
 523               Components =
 524                   GetAllDyLibComponents(IsInDevelopmentTree, true, DirSep);
 525               llvm::sort(Components);
 526               break;
 527             }
 528           }
 529         }
 530
 531         for (unsigned I = 0; I < Components.size(); ++I) {
 532           if (I) {
 533             OS << ' ';
 534           }
 535
 536           OS << Components[I];
 537         }
 538         OS << '\n';
 539       } else if (Arg == "--targets-built") {
 540         OS << LLVM_TARGETS_BUILT << '\n';
 541       } else if (Arg == "--host-target") {
 542         OS << Triple::normalize(LLVM_DEFAULT_TARGET_TRIPLE) << '\n';
 543       } else if (Arg == "--build-mode") {
 544         OS << build_mode << '\n';
 545       } else if (Arg == "--assertion-mode") {
 546 #if defined(NDEBUG)
 547         OS << "OFF\n";
 548 #else
 549         OS << "ON\n";
 550 #endif
 551       } else if (Arg == "--build-system") {
 552         OS << LLVM_BUILD_SYSTEM << '\n';
 553       } else if (Arg == "--has-rtti") {
 554         OS << (LLVM_HAS_RTTI ? "YES" : "NO") << '\n';
 555       } else if (Arg == "--has-global-isel") {
 556         OS << (LLVM_HAS_GLOBAL_ISEL ? "ON" : "OFF") << '\n';
 557       } else if (Arg == "--shared-mode") {
 558         PrintSharedMode = true;
 559       } else if (Arg == "--obj-root") {
 560         OS << ActivePrefix << '\n';
 561       } else if (Arg == "--src-root") {
 562         OS << LLVM_SRC_ROOT << '\n';
 563       } else if (Arg == "--ignore-libllvm") {
 564         LinkDyLib = false;
 565         LinkMode = BuiltSharedLibs ? LinkModeShared : LinkModeAuto;
 566       } else if (Arg == "--link-shared") {
 567         LinkMode = LinkModeShared;
 568       } else if (Arg == "--link-static") {
 569         LinkMode = LinkModeStatic;
 570       } else {
 571         usage();
 572       }
 573     } else {
 574       Components.push_back(Arg);
 575     }
 576   }
 577
 578   if (!HasAnyOption)
 579     usage();
 580
 581   if (LinkMode == LinkModeShared && !DyLibExists && !BuiltSharedLibs) {
 582     WithColor::error(errs(), "llvm-config") << DyLibName << " is missing\n";
 583     return 1;
 584   }
 585
 586   if (PrintLibs || PrintLibNames || PrintLibFiles || PrintSystemLibs ||
 587       PrintSharedMode) {
 588
 589     if (PrintSharedMode && BuiltSharedLibs) {
 590       OS << "shared\n";
 591       return 0;
 592     }
 593
 594     // If no components were specified, default to "all".
 595     if (Components.empty())
 596       Components.push_back("all");
 597
 598     // Construct the list of all the required libraries.
 599     std::function<std::string(const StringRef &)>
 600         GetComponentLibraryPathFunction = [&](const StringRef &Name) {
 601           return GetComponentLibraryPath(Name, LinkMode == LinkModeShared);
 602         };
 603     std::vector<std::string> MissingLibs;
 604     std::vector<std::string> RequiredLibs = ComputeLibsForComponents(
 605         Components,
 606         /*IncludeNonInstalled=*/IsInDevelopmentTree, false,
 607         &GetComponentLibraryPathFunction, &MissingLibs, DirSep);
 608     if (!MissingLibs.empty()) {
 609       switch (LinkMode) {
 610       case LinkModeShared:
 611         if (LinkDyLib && !BuiltSharedLibs)
 612           break;
 613         // Using component shared libraries.
 614         for (auto &Lib : MissingLibs)
 615           WithColor::error(errs(), "llvm-config") << "missing: " << Lib << "\n";
 616         return 1;
 617       case LinkModeAuto:
 618         if (DyLibExists) {
 619           LinkMode = LinkModeShared;
 620           break;
 621         }
 622         WithColor::error(errs(), "llvm-config")
 623             << "component libraries and shared library\n\n";
 624         LLVM_FALLTHROUGH;
 625       case LinkModeStatic:
 626         for (auto &Lib : MissingLibs)
 627           WithColor::error(errs(), "llvm-config") << "missing: " << Lib << "\n";
 628         return 1;
 629       }
 630     } else if (LinkMode == LinkModeAuto) {
 631       LinkMode = LinkModeStatic;
 632     }
 633
 634     if (PrintSharedMode) {
 635       std::unordered_set<std::string> FullDyLibComponents;
 636       std::vector<std::string> DyLibComponents =
 637           GetAllDyLibComponents(IsInDevelopmentTree, false, DirSep);
 638
 639       for (auto &Component : DyLibComponents) {
 640         FullDyLibComponents.insert(Component);
 641       }
 642       DyLibComponents.clear();
 643
 644       for (auto &Lib : RequiredLibs) {
 645         if (!FullDyLibComponents.count(Lib)) {
 646           OS << "static\n";
 647           return 0;
 648         }
 649       }
 650       FullDyLibComponents.clear();
 651
 652       if (LinkMode == LinkModeShared) {
 653         OS << "shared\n";
 654         return 0;
 655       } else {
 656         OS << "static\n";
 657         return 0;
 658       }
 659     }
 660
 661     if (PrintLibs || PrintLibNames || PrintLibFiles) {
 662
 663       auto PrintForLib = [&](const StringRef &Lib) {
 664         const bool Shared = LinkMode == LinkModeShared;
 665         if (PrintLibNames) {
 666           OS << GetComponentLibraryFileName(Lib, Shared);
 667         } else if (PrintLibFiles) {
 668           OS << GetComponentLibraryPath(Lib, Shared);
 669         } else if (PrintLibs) {
 670           // On Windows, output full path to library without parameters.
 671           // Elsewhere, if this is a typical library name, include it using -l.
 672           if (HostTriple.isWindowsMSVCEnvironment()) {
 673             OS << GetComponentLibraryPath(Lib, Shared);
 674           } else {
 675             StringRef LibName;
 676             if (GetComponentLibraryNameSlice(Lib, LibName)) {
 677               // Extract library name (remove prefix and suffix).
 678               OS << "-l" << LibName;
 679             } else {
 680               // Lib is already a library name without prefix and suffix.
 681               OS << "-l" << Lib;
 682             }
 683           }
 684         }
 685       };
 686
 687       if (LinkMode == LinkModeShared && LinkDyLib) {
 688         PrintForLib(DyLibName);
 689       } else {
 690         for (unsigned i = 0, e = RequiredLibs.size(); i != e; ++i) {
 691           auto Lib = RequiredLibs[i];
 692           if (i)
 693             OS << ' ';
 694
 695           PrintForLib(Lib);
 696         }
 697       }
 698       OS << '\n';
 699     }
 700
 701     // Print SYSTEM_LIBS after --libs.
 702     // FIXME: Each LLVM component may have its dependent system libs.
 703     if (PrintSystemLibs) {
 704       // Output system libraries only if linking against a static
 705       // library (since the shared library links to all system libs
 706       // already)
 707       OS << (LinkMode == LinkModeStatic ? LLVM_SYSTEM_LIBS : "") << '\n';
 708     }
 709   } else if (!Components.empty()) {
 710     WithColor::error(errs(), "llvm-config")
 711         << "components given, but unused\n\n";
 712     usage();
 713   }
 714
 715   return 0;
 716 }