[Dependency Scanning] Collect and report each module dependency's Link Libraries

Author: artemcm

include/swift-c/DependencyScan/DependencyScan.h

@@ -25,7 +25,7 @@
 /// SWIFTSCAN_VERSION_MINOR should increase when there are API additions.
 /// SWIFTSCAN_VERSION_MAJOR is intended for "major" source/ABI breaking changes.
 #define SWIFTSCAN_VERSION_MAJOR 0
-#define SWIFTSCAN_VERSION_MINOR 9
+#define SWIFTSCAN_VERSION_MINOR 10
 
 SWIFTSCAN_BEGIN_DECLS
 
@@ -46,6 +46,9 @@ typedef struct swiftscan_module_details_s *swiftscan_module_details_t;
 /// Opaque container to a dependency info of a given module.
 typedef struct swiftscan_dependency_info_s *swiftscan_dependency_info_t;
 
+/// Opaque container to a link library info.
+typedef struct swiftscan_link_library_info_s *swiftscan_link_library_info_t;
+
 /// Opaque container to an overall result of a dependency scan.
 typedef struct swiftscan_dependency_graph_s *swiftscan_dependency_graph_t;
 
@@ -64,6 +67,12 @@ typedef struct {
   size_t count;
 } swiftscan_dependency_set_t;
 
+/// Set of linked libraries
+typedef struct {
+  swiftscan_link_library_info_t *link_libraries;
+  size_t count;
+} swiftscan_link_library_set_t;
+
 typedef enum {
   SWIFTSCAN_DIAGNOSTIC_SEVERITY_ERROR = 0,
   SWIFTSCAN_DIAGNOSTIC_SEVERITY_WARNING = 1,
@@ -127,9 +136,21 @@ swiftscan_module_info_get_source_files(swiftscan_dependency_info_t info);
 SWIFTSCAN_PUBLIC swiftscan_string_set_t *
 swiftscan_module_info_get_direct_dependencies(swiftscan_dependency_info_t info);
 
+SWIFTSCAN_PUBLIC swiftscan_link_library_set_t *
+swiftscan_module_info_get_link_libraries(swiftscan_dependency_info_t info);
+
 SWIFTSCAN_PUBLIC swiftscan_module_details_t
 swiftscan_module_info_get_details(swiftscan_dependency_info_t info);
 
+//=== Link Library Info Functions ------------------------------------===//
+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_framework(
+    swiftscan_link_library_info_t info);
+SWIFTSCAN_PUBLIC bool swiftscan_link_library_info_get_should_force_load(
+    swiftscan_link_library_info_t info);
+
 //=== Dependency Module Info Details Functions ----------------------------===//
 
 SWIFTSCAN_PUBLIC swiftscan_dependency_info_kind_t

include/swift/AST/Import.h

@@ -36,6 +36,7 @@
 namespace swift {
 class ASTContext;
 class ModuleDecl;
+class ImportDecl;
 
 // MARK: - Fundamental import enums
 
@@ -102,6 +103,8 @@ using ImportOptions = OptionSet<ImportFlags>;
 
 void simple_display(llvm::raw_ostream &out, ImportOptions options);
 
+ImportOptions getImportOptions(ImportDecl *ID);
+
 // MARK: - Import Paths
 
 namespace detail {

include/swift/AST/ModuleDependencies.h

@@ -60,10 +60,19 @@ struct swiftscan_dependency_info_s {
    */
   swiftscan_string_set_t *direct_dependencies;
 
+  /// The list of link libraries for this module.
+  swiftscan_link_library_set_t *link_libraries;
+
   /// Specific details of a particular kind of module.
   swiftscan_module_details_t details;
 };
 
+struct swiftscan_link_library_info_s {
+  swiftscan_string_ref_t name;
+  bool isFramework;
+  bool forceLoad;
+};
+
 /// Swift modules to be built from a module interface, may have a bridging
 /// header.
 typedef struct {
@@ -103,6 +112,9 @@ typedef struct {
   /// A flag to indicate whether or not this module is a framework.
   bool is_framework;
 
+  /// A flag that indicates this dependency is associated with a static archive
+  bool is_static;
+
   /// The CASID for CASFileSystemRoot
   swiftscan_string_ref_t cas_fs_root_id;
 
@@ -140,6 +152,9 @@ typedef struct {
   /// A flag to indicate whether or not this module is a framework.
   bool is_framework;
 
+  /// A flag that indicates this dependency is associated with a static archive
+  bool is_static;
+
   /// ModuleCacheKey
   swiftscan_string_ref_t module_cache_key;
 } swiftscan_swift_binary_details_t;

include/swift/DependencyScan/DependencyScanImpl.h

@@ -55,6 +55,8 @@ using ContextHashIDField = IdentifierIDField;
 using IsFrameworkField = BCFixed<1>;
 /// A bit that indicates whether or not a module is a system module
 using IsSystemField = BCFixed<1>;
+/// A bit that indicates whether or not a module is that of a static archive
+using IsStaticField = BCFixed<1>;
 
 /// Arrays of various identifiers, distinguished for readability
 using IdentifierIDArryField = llvm::BCArray<IdentifierIDField>;
@@ -140,10 +142,11 @@ using SwiftInterfaceModuleDetailsLayout =
                    FlagIDArrayIDField,                  // extraPCMArgs
                    ContextHashIDField,                  // contextHash
                    IsFrameworkField,                    // isFramework
+                   IsStaticField,                       // isStatic
                    FileIDField,                         // bridgingHeaderFile
                    FileIDArrayIDField,                  // sourceFiles
                    FileIDArrayIDField,                  // bridgingSourceFiles
-                   IdentifierIDField,                  // bridgingModuleDependencies
+                   IdentifierIDField,                   // bridgingModuleDependencies
                    DependencyIDArrayIDField,            // swiftOverlayDependencies
                    IdentifierIDField,                   // CASFileSystemRootID
                    IdentifierIDField,                   // bridgingHeaderIncludeTree
@@ -174,6 +177,7 @@ using SwiftBinaryModuleDetailsLayout =
                    IdentifierIDField,                // headerModuleDependencies
                    FileIDArrayIDField,               // headerSourceFiles
                    IsFrameworkField,                 // isFramework
+                   IsStaticField,                    // isStatic
                    IdentifierIDField                 // moduleCacheKey
                    >;
 

include/swift/DependencyScan/SerializedModuleDependencyCacheFormat.h

@@ -1370,6 +1370,10 @@ def explain_module_dependency : Separate<["-"], "explain-module-dependency">,
   Flags<[NewDriverOnlyOption]>,
   HelpText<"Emit remark/notes describing why compilation may depend on a module with a given name.">;
 
+def explicit_auto_linking : Flag<["-"], "explicit-auto-linking">,
+  Flags<[NewDriverOnlyOption]>,
+  HelpText<"Instead of linker-load directives, have the driver specify all link dependencies on the linker invocation. Requires '-explicit-module-build'.">;
+
 def min_inlining_target_version : Separate<["-"], "target-min-inlining-version">,
   Flags<[FrontendOption, ModuleInterfaceOption]>,
   HelpText<"Require inlinable code with no '@available' attribute to back-deploy "

include/swift/Option/Options.td

@@ -306,9 +306,9 @@ void ConformanceLookupTable::updateLookupTable(NominalTypeDecl *nominal,
             if (!proto)
               continue;
             auto kp = proto->getKnownProtocolKind();
-            assert(!found.isSuppressed ||
-                   kp.has_value() &&
-                       "suppressed conformance for non-known protocol!?");
+           assert(!found.isSuppressed ||
+                  kp.has_value() &&
+                      "suppressed conformance for non-known protocol!?");
             if (!found.isSuppressed) {
               addProtocol(proto, found.Loc,
                           source.withUncheckedLoc(found.uncheckedLoc)

lib/AST/ConformanceLookupTable.cpp

@@ -483,7 +483,7 @@ SwiftDependencyScanningService::SwiftDependencyScanningService() {
 }
 
 bool
-swift::dependencies::checkImportNotTautological(const ImportPath::Module modulePath, 
+swift::dependencies::checkImportNotTautological(const ImportPath::Module modulePath,
                                                 const SourceLoc importLoc,
                                                 const SourceFile &SF,
                                                 bool isExported) {
@@ -509,6 +509,85 @@ swift::dependencies::checkImportNotTautological(const ImportPath::Module moduleP
   return false;
 }
 
+void
+swift::dependencies::registerCxxInteropLibraries(
+    const llvm::Triple &Target,
+    StringRef mainModuleName,
+    bool hasStaticCxx, bool hasStaticCxxStdlib,
+    std::function<void(const LinkLibrary&)> RegistrationCallback) {
+  if (Target.isOSDarwin())
+    RegistrationCallback(LinkLibrary("c++", LibraryKind::Library));
+  else if (Target.isOSLinux())
+    RegistrationCallback(LinkLibrary("stdc++", LibraryKind::Library));
+
+  // Do not try to link Cxx with itself.
+  if (mainModuleName != "Cxx") {
+    RegistrationCallback(LinkLibrary(Target.isOSWindows() && hasStaticCxx
+                                        ? "libswiftCxx"
+                                        : "swiftCxx",
+                                     LibraryKind::Library));
+  }
+
+  // Do not try to link CxxStdlib with the C++ standard library, Cxx or
+  // itself.
+  if (llvm::none_of(llvm::ArrayRef{"Cxx", "CxxStdlib", "std"},
+                    [mainModuleName](StringRef Name) {
+                      return mainModuleName == Name;
+                    })) {
+    // Only link with CxxStdlib on platforms where the overlay is available.
+    switch (Target.getOS()) {
+    case llvm::Triple::Linux:
+      if (!Target.isAndroid())
+        RegistrationCallback(LinkLibrary("swiftCxxStdlib",
+                                         LibraryKind::Library));
+      break;
+    case llvm::Triple::Win32: {
+      RegistrationCallback(
+          LinkLibrary(hasStaticCxxStdlib ? "libswiftCxxStdlib" : "swiftCxxStdlib",
+                      LibraryKind::Library));
+      break;
+    }
+    default:
+      if (Target.isOSDarwin())
+        RegistrationCallback(LinkLibrary("swiftCxxStdlib",
+                                         LibraryKind::Library));
+      break;
+    }
+  }
+}
+
+void
+swift::dependencies::registerBackDeployLibraries(
+    const IRGenOptions &IRGenOpts,
+    std::function<void(const LinkLibrary&)> RegistrationCallback) {
+  auto addBackDeployLib = [&](llvm::VersionTuple version,
+                              StringRef libraryName, bool forceLoad) {
+    std::optional<llvm::VersionTuple> compatibilityVersion;
+    if (libraryName == "swiftCompatibilityDynamicReplacements") {
+      compatibilityVersion = IRGenOpts.
+          AutolinkRuntimeCompatibilityDynamicReplacementLibraryVersion;
+    } else if (libraryName == "swiftCompatibilityConcurrency") {
+      compatibilityVersion =
+          IRGenOpts.AutolinkRuntimeCompatibilityConcurrencyLibraryVersion;
+    } else {
+      compatibilityVersion = IRGenOpts.
+          AutolinkRuntimeCompatibilityLibraryVersion;
+    }
+
+    if (!compatibilityVersion)
+      return;
+
+    if (*compatibilityVersion > version)
+      return;
+
+    RegistrationCallback({libraryName, LibraryKind::Library, forceLoad});
+  };
+
+#define BACK_DEPLOYMENT_LIB(Version, Filter, LibraryName, ForceLoad) \
+    addBackDeployLib(llvm::VersionTuple Version, LibraryName, ForceLoad);
+  #include "swift/Frontend/BackDeploymentLibs.def"
+}
+
 void SwiftDependencyTracker::addCommonSearchPathDeps(
     const SearchPathOptions &Opts) {
   // Add SDKSetting file.

lib/AST/ModuleDependencies.cpp

@@ -285,12 +285,20 @@ ModuleDependencyVector ClangImporter::bridgeClangModuleDependencies(
     if (Mapper)
       Mapper->mapInPlace(mappedPCMPath);
 
+    std::vector<LinkLibrary> LinkLibraries;
+    if (!clangModuleDep.UseExportAsModuleLinkName)
+      for (const auto &ll : clangModuleDep.LinkLibraries)
+        LinkLibraries.push_back(
+          {ll.Library,
+           ll.IsFramework ? LibraryKind::Framework : LibraryKind::Library});
+
     // Module-level dependencies.
     llvm::StringSet<> alreadyAddedModules;
     auto dependencies = ModuleDependencyInfo::forClangModule(
         pcmPath, mappedPCMPath, clangModuleDep.ClangModuleMapFile,
         clangModuleDep.ID.ContextHash, swiftArgs, fileDeps, capturedPCMArgs,
-        RootID, IncludeTree, /*module-cache-key*/ "", clangModuleDep.IsSystem);
+        LinkLibraries, RootID, IncludeTree, /*module-cache-key*/ "",
+        clangModuleDep.IsSystem);
     for (const auto &moduleName : clangModuleDep.ClangModuleDeps) {
       dependencies.addModuleImport(moduleName.ModuleName, &alreadyAddedModules);
       // It is safe to assume that all dependencies of a Clang module are Clang modules.

lib/ClangImporter/ClangModuleDependencyScanner.cpp

@@ -202,6 +202,46 @@ static void writeDependencies(llvm::raw_ostream &out,
   out << "\n";
 }
 
+void writeLinkLibraries(llvm::raw_ostream &out,
+                        const swiftscan_link_library_set_t *link_libraries,
+                        unsigned indentLevel, bool trailingComma) {
+  out.indent(indentLevel * 2);
+  out << "\"linkLibraries\": ";
+  out << "[\n";
+
+  for (size_t i = 0; i < link_libraries->count; ++i) {
+    const auto &llInfo = *link_libraries->link_libraries[i];
+    out.indent((indentLevel + 1) * 2);
+    out << "{\n";
+    auto entryIndentLevel = ((indentLevel + 2) * 2);
+    out.indent(entryIndentLevel);
+    out << "\"linkName\": ";
+    writeJSONValue(out, llInfo.name, indentLevel);
+    out << ",\n";
+    out.indent(entryIndentLevel);
+    out << "\"isFramework\": ";
+    writeJSONValue(out, llInfo.isFramework, entryIndentLevel);
+    out << ",\n";
+    out.indent(entryIndentLevel);
+    out << "\"shouldForceLoad\": ";
+    writeJSONValue(out, llInfo.forceLoad, entryIndentLevel);
+    out << "\n";
+    out.indent((indentLevel + 1) * 2);
+    out << "}";
+    if (i != link_libraries->count - 1) {
+      out << ",";
+    }
+    out << "\n";
+  }
+
+  out.indent(indentLevel * 2);
+  out << "]";
+
+  if (trailingComma)
+    out << ",";
+  out << "\n";
+}
+
 static const swiftscan_swift_textual_details_t *
 getAsTextualDependencyModule(swiftscan_module_details_t details) {
   if (details->kind == SWIFTSCAN_DEPENDENCY_INFO_SWIFT_TEXTUAL)
@@ -295,10 +335,13 @@ void writeJSON(llvm::raw_ostream &out,
     }
 
     // Direct dependencies.
-    if (swiftTextualDeps || swiftBinaryDeps || clangDeps)
+    if (swiftTextualDeps || swiftBinaryDeps || clangDeps) {
       writeDependencies(out, directDependencies,
                         "directDependencies", 3,
                         /*trailingComma=*/true);
+      writeLinkLibraries(out, moduleInfo.link_libraries,
+                         3, /*trailingComma=*/true);
+    }
     // Swift and Clang-specific details.
     out.indent(3 * 2);
     out << "\"details\": {\n";