AST,DependencyScan,IRGen,Serialization,Tooling: track library style (#78777)

Track if the dependency is static or dynamic. This is in preparation for
helping rename the static library to differentiate it from import
libraries.

Author: compnerd

include/swift-c/DependencyScan/DependencyScan.h

@@ -155,6 +155,8 @@ swiftscan_module_info_get_details(swiftscan_dependency_info_t info);
 SWIFTSCAN_PUBLIC swiftscan_string_ref_t
 swiftscan_link_library_info_get_link_name(
     swiftscan_link_library_info_t info);
+SWIFTSCAN_PUBLIC bool
+swiftscan_link_library_info_get_is_static(swiftscan_link_library_info_t info);
 SWIFTSCAN_PUBLIC bool swiftscan_link_library_info_get_is_framework(
     swiftscan_link_library_info_t info);
 SWIFTSCAN_PUBLIC bool swiftscan_link_library_info_get_should_force_load(

include/swift/AST/IRGenOptions.h

@@ -33,6 +33,7 @@
 #include "llvm/Support/VersionTuple.h"
 #include <optional>
 #include <string>
+#include <tuple>
 #include <vector>
 
 namespace swift {
@@ -258,7 +259,7 @@ class IRGenOptions {
   SmallVector<LinkLibrary, 4> LinkLibraries;
 
   /// The public dependent libraries specified on the command line.
-  std::vector<std::string> PublicLinkLibraries;
+  std::vector<std::tuple<std::string, bool>> PublicLinkLibraries;
 
   /// If non-empty, the (unmangled) name of a dummy symbol to emit that can be
   /// used to force-load this module.

include/swift/AST/LinkLibrary.h

@@ -32,16 +32,19 @@ class LinkLibrary {
 private:
   std::string Name;
   unsigned Kind : 1;
+  unsigned Static : 1;
   unsigned ForceLoad : 1;
 
 public:
-  LinkLibrary(StringRef N, LibraryKind K, bool forceLoad = false)
-    : Name(N), Kind(static_cast<unsigned>(K)), ForceLoad(forceLoad) {
+  LinkLibrary(StringRef N, LibraryKind K, bool Static, bool forceLoad = false)
+      : Name(N), Kind(static_cast<unsigned>(K)), Static(Static),
+        ForceLoad(forceLoad) {
     assert(getKind() == K && "not enough bits for the kind");
   }
 
   LibraryKind getKind() const { return static_cast<LibraryKind>(Kind); }
   StringRef getName() const { return Name; }
+  bool isStaticLibrary() const { return Static; }
   bool shouldForceLoad() const { return ForceLoad; }
 };
 

include/swift/DependencyScan/DependencyScanImpl.h

@@ -69,6 +69,7 @@ struct swiftscan_dependency_info_s {
 
 struct swiftscan_link_library_info_s {
   swiftscan_string_ref_t name;
+  bool isStatic;
   bool isFramework;
   bool forceLoad;
 };

include/swift/DependencyScan/SerializedModuleDependencyCacheFormat.h

@@ -41,7 +41,7 @@ using llvm::BCVBR;
 const unsigned char MODULE_DEPENDENCY_CACHE_FORMAT_SIGNATURE[] = {'I', 'M', 'D','C'};
 const unsigned MODULE_DEPENDENCY_CACHE_FORMAT_VERSION_MAJOR = 9;
 /// Increment this on every change.
-const unsigned MODULE_DEPENDENCY_CACHE_FORMAT_VERSION_MINOR = 0;
+const unsigned MODULE_DEPENDENCY_CACHE_FORMAT_VERSION_MINOR = 1;
 
 /// Various identifiers in this format will rely on having their strings mapped
 /// using this ID.
@@ -148,12 +148,12 @@ using IdentifierArrayLayout =
 // A record for a given link library node containing information
 // required for the build system client to capture a requirement
 // to link a given dependency library.
-using LinkLibraryLayout =
-    BCRecordLayout<LINK_LIBRARY_NODE,            // ID
-                   IdentifierIDField,            // libraryName
-                   IsFrameworkField,             // isFramework
-                   IsForceLoadField              // forceLoad
-                   >;
+using LinkLibraryLayout = BCRecordLayout<LINK_LIBRARY_NODE, // ID
+                                         IdentifierIDField, // libraryName
+                                         IsFrameworkField,  // isFramework
+                                         IsStaticField,     // isStatic
+                                         IsForceLoadField   // forceLoad
+                                         >;
 using LinkLibraryArrayLayout =
     BCRecordLayout<LINK_LIBRARY_ARRAY_NODE, IdentifierIDArryField>;
 

include/swift/Frontend/Frontend.h

@@ -230,8 +230,8 @@ class CompilerInvocation {
     return ClangImporterOpts.ExtraArgs;
   }
 
-  void addLinkLibrary(StringRef name, LibraryKind kind) {
-    IRGenOpts.LinkLibraries.push_back({name, kind});
+  void addLinkLibrary(StringRef name, LibraryKind kind, bool isStaticLibrary) {
+    IRGenOpts.LinkLibraries.emplace_back(name, kind, isStaticLibrary);
   }
 
   ArrayRef<LinkLibrary> getLinkLibraries() const {

include/swift/Serialization/SerializationOptions.h

@@ -20,6 +20,7 @@
 
 #include <set>
 #include <string>
+#include <tuple>
 #include <vector>
 
 namespace swift {
@@ -150,7 +151,7 @@ class SerializationOptions {
     uint64_t getSize() const { return Size; }
   };
   ArrayRef<FileDependency> Dependencies;
-  ArrayRef<std::string> PublicDependentLibraries;
+  ArrayRef<std::tuple<std::string, bool>> PublicDependentLibraries;
 
   bool AutolinkForceLoad = false;
   bool SerializeAllSIL = false;

lib/AST/ModuleDependencies.cpp

@@ -503,24 +503,33 @@ swift::dependencies::checkImportNotTautological(const ImportPath::Module moduleP
   return false;
 }
 
-void
-swift::dependencies::registerCxxInteropLibraries(
-    const llvm::Triple &Target,
-    StringRef mainModuleName,
-    bool hasStaticCxx, bool hasStaticCxxStdlib, CXXStdlibKind cxxStdlibKind,
-    std::function<void(const LinkLibrary&)> RegistrationCallback) {
-  if (cxxStdlibKind == CXXStdlibKind::Libcxx)
-    RegistrationCallback(LinkLibrary("c++", LibraryKind::Library));
-  else if (cxxStdlibKind == CXXStdlibKind::Libstdcxx)
-    RegistrationCallback(LinkLibrary("stdc++", LibraryKind::Library));
+void swift::dependencies::registerCxxInteropLibraries(
+    const llvm::Triple &Target, StringRef mainModuleName, bool hasStaticCxx,
+    bool hasStaticCxxStdlib, CXXStdlibKind cxxStdlibKind,
+    std::function<void(const LinkLibrary &)> RegistrationCallback) {
+
+  switch (cxxStdlibKind) {
+  case CXXStdlibKind::Libcxx:
+    RegistrationCallback(
+        LinkLibrary{"c++", LibraryKind::Library, /*static=*/false});
+    break;
+  case CXXStdlibKind::Libstdcxx:
+    RegistrationCallback(
+        LinkLibrary{"stdc++", LibraryKind::Library, /*static=*/false});
+    break;
+  case CXXStdlibKind::Msvcprt:
+    // FIXME: should we be explicitly linking in msvcprt or will the module do
+    // so?
+    break;
+  case CXXStdlibKind::Unknown:
+    // FIXME: we should probably emit a warning or a note here.
+    break;
+  }
 
   // Do not try to link Cxx with itself.
-  if (mainModuleName != CXX_MODULE_NAME) {
-    RegistrationCallback(LinkLibrary(Target.isOSWindows() && hasStaticCxx
-                                        ? "libswiftCxx"
-                                        : "swiftCxx",
-                                     LibraryKind::Library));
-  }
+  if (mainModuleName != CXX_MODULE_NAME)
+    RegistrationCallback(
+        LinkLibrary{"swiftCxx", LibraryKind::Library, hasStaticCxx});
 
   // Do not try to link CxxStdlib with the C++ standard library, Cxx or
   // itself.
@@ -529,19 +538,9 @@ swift::dependencies::registerCxxInteropLibraries(
                       return mainModuleName == Name;
                     })) {
     // Only link with CxxStdlib on platforms where the overlay is available.
-    switch (Target.getOS()) {
-    case llvm::Triple::Win32: {
-      RegistrationCallback(
-          LinkLibrary(hasStaticCxxStdlib ? "libswiftCxxStdlib" : "swiftCxxStdlib",
-                      LibraryKind::Library));
-      break;
-    }
-    default:
-      if (Target.isOSDarwin() || Target.isOSLinux())
-        RegistrationCallback(LinkLibrary("swiftCxxStdlib",
-                                         LibraryKind::Library));
-      break;
-    }
+    if (Target.isOSDarwin() || Target.isOSLinux() || Target.isOSWindows())
+      RegistrationCallback(LinkLibrary{"swiftCxxStdlib", LibraryKind::Library,
+                                       hasStaticCxxStdlib});
   }
 }
 
@@ -569,7 +568,8 @@ swift::dependencies::registerBackDeployLibraries(
     if (*compatibilityVersion > version)
       return;
 
-    RegistrationCallback({libraryName, LibraryKind::Library, forceLoad});
+    RegistrationCallback(
+        {libraryName, LibraryKind::Library, /*static=*/true, forceLoad});
   };
 
 #define BACK_DEPLOYMENT_LIB(Version, Filter, LibraryName, ForceLoad) \

lib/ClangImporter/ClangImporter.cpp

@@ -4105,15 +4105,11 @@ void ClangModuleUnit::collectLinkLibraries(
   if (clangModule->UseExportAsModuleLinkName)
     return;
 
-  for (auto clangLinkLib : clangModule->LinkLibraries) {
-    LibraryKind kind;
-    if (clangLinkLib.IsFramework)
-      kind = LibraryKind::Framework;
-    else
-      kind = LibraryKind::Library;
-
-    callback(LinkLibrary(clangLinkLib.Library, kind));
-  }
+  for (auto clangLinkLib : clangModule->LinkLibraries)
+    callback(LinkLibrary{clangLinkLib.Library,
+                         clangLinkLib.IsFramework ? LibraryKind::Framework
+                                                  : LibraryKind::Library,
+                         /*static=*/false});
 }
 
 StringRef ClangModuleUnit::getFilename() const {

lib/ClangImporter/ClangModuleDependencyScanner.cpp

@@ -266,9 +266,10 @@ ModuleDependencyVector ClangImporter::bridgeClangModuleDependencies(
 
     std::vector<LinkLibrary> LinkLibraries;
     for (const auto &ll : clangModuleDep.LinkLibraries)
-      LinkLibraries.push_back(
-        {ll.Library,
-         ll.IsFramework ? LibraryKind::Framework : LibraryKind::Library});
+      LinkLibraries.emplace_back(
+          ll.Library,
+          ll.IsFramework ? LibraryKind::Framework : LibraryKind::Library,
+          /*static=*/false);
 
     // Module-level dependencies.
     llvm::StringSet<> alreadyAddedModules;