|
36 | 36 | #include "swift/Strings.h" |
37 | 37 | #include "clang/Basic/Module.h" |
38 | 38 | #include "llvm/ADT/SetVector.h" |
| 39 | +#include "llvm/ADT/SetOperations.h" |
39 | 40 | #include "llvm/ADT/StringMap.h" |
40 | 41 | #include "llvm/ADT/StringRef.h" |
41 | 42 | #include "llvm/ADT/StringSet.h" |
|
47 | 48 | #include <set> |
48 | 49 | #include <string> |
49 | 50 | #include <sstream> |
| 51 | +#include <algorithm> |
50 | 52 |
|
51 | 53 | using namespace swift; |
52 | 54 | using namespace swift::dependencies; |
@@ -157,6 +159,149 @@ static void findAllImportedClangModules(ASTContext &ctx, StringRef moduleName, |
157 | 159 | } |
158 | 160 | } |
159 | 161 |
|
| 162 | +// Get all dependencies's IDs of this module from its cached |
| 163 | +// ModuleDependencyInfo |
| 164 | +static ArrayRef<ModuleDependencyID> |
| 165 | +getDependencies(const ModuleDependencyID &moduleID, |
| 166 | + const ModuleDependenciesCache &cache) { |
| 167 | + const auto &optionalModuleInfo = |
| 168 | + cache.findDependency(moduleID.first, moduleID.second); |
| 169 | + assert(optionalModuleInfo.has_value()); |
| 170 | + return optionalModuleInfo.value()->getModuleDependencies(); |
| 171 | +} |
| 172 | + |
| 173 | +/// Implements a topological sort via recursion and reverse postorder DFS. |
| 174 | +/// Does not bother handling cycles, relying on a DAG guarantee by the client. |
| 175 | +static std::vector<ModuleDependencyID> |
| 176 | +computeTopologicalSortOfExplicitDependencies( |
| 177 | + const ModuleDependencyIDSetVector &allModules, |
| 178 | + const ModuleDependenciesCache &cache) { |
| 179 | + std::unordered_set<ModuleDependencyID> visited; |
| 180 | + std::vector<ModuleDependencyID> result; |
| 181 | + std::stack<ModuleDependencyID> stack; |
| 182 | + |
| 183 | + // Must be explicitly-typed to allow recursion |
| 184 | + std::function<void(const ModuleDependencyID &)> visit; |
| 185 | + visit = [&visit, &cache, &visited, &result, |
| 186 | + &stack](const ModuleDependencyID &moduleID) { |
| 187 | + // Mark this node as visited -- we are done if it already was. |
| 188 | + if (!visited.insert(moduleID).second) |
| 189 | + return; |
| 190 | + |
| 191 | + // Otherwise, visit each adjacent node. |
| 192 | + for (const auto &succID : getDependencies(moduleID, cache)) { |
| 193 | + // We don't worry if successor is already in this current stack, |
| 194 | + // since that would mean we have found a cycle, which should not |
| 195 | + // be possible because we checked for cycles earlier. |
| 196 | + stack.push(succID); |
| 197 | + visit(succID); |
| 198 | + auto top = stack.top(); |
| 199 | + stack.pop(); |
| 200 | + assert(top == succID); |
| 201 | + } |
| 202 | + |
| 203 | + // Add to the result. |
| 204 | + result.push_back(moduleID); |
| 205 | + }; |
| 206 | + |
| 207 | + for (const auto &modID : allModules) { |
| 208 | + assert(stack.empty()); |
| 209 | + stack.push(modID); |
| 210 | + visit(modID); |
| 211 | + auto top = stack.top(); |
| 212 | + stack.pop(); |
| 213 | + assert(top == modID); |
| 214 | + } |
| 215 | + |
| 216 | + std::reverse(result.begin(), result.end()); |
| 217 | + return result; |
| 218 | +} |
| 219 | + |
| 220 | +/// For each module in the graph, compute a set of all its dependencies, |
| 221 | +/// direct *and* transitive. |
| 222 | +static std::unordered_map<ModuleDependencyID, |
| 223 | + std::set<ModuleDependencyID>> |
| 224 | +computeTransitiveClosureOfExplicitDependencies( |
| 225 | + const std::vector<ModuleDependencyID> &topologicallySortedModuleList, |
| 226 | + const ModuleDependenciesCache &cache) { |
| 227 | + // The usage of an ordered ::set is important to ensure the |
| 228 | + // dependencies are listed in a deterministic order. |
| 229 | + std::unordered_map<ModuleDependencyID, std::set<ModuleDependencyID>> |
| 230 | + result; |
| 231 | + for (const auto &modID : topologicallySortedModuleList) |
| 232 | + result[modID] = {modID}; |
| 233 | + |
| 234 | + // Traverse the set of modules in reverse topological order, assimilating |
| 235 | + // transitive closures |
| 236 | + for (auto it = topologicallySortedModuleList.rbegin(), |
| 237 | + end = topologicallySortedModuleList.rend(); |
| 238 | + it != end; ++it) { |
| 239 | + const auto &modID = *it; |
| 240 | + auto &modReachableSet = result[modID]; |
| 241 | + for (const auto &succID : getDependencies(modID, cache)) { |
| 242 | + const auto &succReachableSet = result[succID]; |
| 243 | + llvm::set_union(modReachableSet, succReachableSet); |
| 244 | + } |
| 245 | + } |
| 246 | + return result; |
| 247 | +} |
| 248 | + |
| 249 | +static void |
| 250 | +resolveExplicitModuleInputs(ModuleDependencyID moduleID, |
| 251 | + const ModuleDependencyInfo &resolvingDepInfo, |
| 252 | + const std::set<ModuleDependencyID> &dependencies, |
| 253 | + ModuleDependenciesCache &cache) { |
| 254 | + auto resolvingInterfaceDepDetails = |
| 255 | + resolvingDepInfo.getAsSwiftInterfaceModule(); |
| 256 | + assert(resolvingInterfaceDepDetails && |
| 257 | + "Expected Swift Interface dependency."); |
| 258 | + |
| 259 | + auto commandLine = resolvingInterfaceDepDetails->buildCommandLine; |
| 260 | + for (const auto &depModuleID : dependencies) { |
| 261 | + const auto optionalDepInfo = |
| 262 | + cache.findDependency(depModuleID.first, depModuleID.second); |
| 263 | + assert(optionalDepInfo.has_value()); |
| 264 | + const auto depInfo = optionalDepInfo.value(); |
| 265 | + switch (depModuleID.second) { |
| 266 | + case swift::ModuleDependencyKind::SwiftInterface: { |
| 267 | + auto interfaceDepDetails = depInfo->getAsSwiftInterfaceModule(); |
| 268 | + assert(interfaceDepDetails && "Expected Swift Interface dependency."); |
| 269 | + commandLine.push_back("-swift-module-file=" + depModuleID.first + "=" + |
| 270 | + interfaceDepDetails->moduleOutputPath); |
| 271 | + } break; |
| 272 | + case swift::ModuleDependencyKind::SwiftBinary: { |
| 273 | + auto binaryDepDetails = depInfo->getAsSwiftBinaryModule(); |
| 274 | + assert(binaryDepDetails && "Expected Swift Binary Module dependency."); |
| 275 | + commandLine.push_back("-swift-module-file=" + depModuleID.first + "=" + |
| 276 | + binaryDepDetails->compiledModulePath); |
| 277 | + } break; |
| 278 | + case swift::ModuleDependencyKind::SwiftPlaceholder: { |
| 279 | + auto placeholderDetails = depInfo->getAsPlaceholderDependencyModule(); |
| 280 | + assert(placeholderDetails && "Expected Swift Placeholder dependency."); |
| 281 | + commandLine.push_back("-swift-module-file=" + depModuleID.first + "=" + |
| 282 | + placeholderDetails->compiledModulePath); |
| 283 | + } break; |
| 284 | + case swift::ModuleDependencyKind::Clang: { |
| 285 | + auto clangDepDetails = depInfo->getAsClangModule(); |
| 286 | + assert(clangDepDetails && "Expected Clang Module dependency."); |
| 287 | + commandLine.push_back("-Xcc"); |
| 288 | + commandLine.push_back("-fmodule-file=" + depModuleID.first + "=" + |
| 289 | + clangDepDetails->pcmOutputPath); |
| 290 | + commandLine.push_back("-Xcc"); |
| 291 | + commandLine.push_back("-fmodule-map-file=" + |
| 292 | + clangDepDetails->moduleMapFile); |
| 293 | + } break; |
| 294 | + default: |
| 295 | + llvm_unreachable("Unhandled dependency kind."); |
| 296 | + } |
| 297 | + } |
| 298 | + |
| 299 | + // Update the dependency in the cache with the modified command-line. |
| 300 | + auto dependencyInfoCopy = resolvingDepInfo; |
| 301 | + dependencyInfoCopy.updateCommandLine(commandLine); |
| 302 | + cache.updateDependency(moduleID, dependencyInfoCopy); |
| 303 | +} |
| 304 | + |
160 | 305 | /// Resolve the direct dependencies of the given module. |
161 | 306 | static ArrayRef<ModuleDependencyID> |
162 | 307 | resolveDirectDependencies(CompilerInstance &instance, ModuleDependencyID module, |
@@ -1475,8 +1620,29 @@ swift::dependencies::performModuleScan(CompilerInstance &instance, |
1475 | 1620 | if (diagnoseCycle(instance, cache, mainModuleID, ASTDelegate)) |
1476 | 1621 | return std::make_error_code(std::errc::not_supported); |
1477 | 1622 |
|
| 1623 | + // Resolve Swift dependency command-line arguments |
| 1624 | + // Must happen after cycle detection, because it relies on |
| 1625 | + // the DAG property of the dependency graph. |
| 1626 | + auto topoSortedModuleList = |
| 1627 | + computeTopologicalSortOfExplicitDependencies(allModules, cache); |
| 1628 | + auto moduleTransitiveClosures = |
| 1629 | + computeTransitiveClosureOfExplicitDependencies(topoSortedModuleList, |
| 1630 | + cache); |
| 1631 | + for (const auto &dependencyClosure : moduleTransitiveClosures) { |
| 1632 | + auto &modID = dependencyClosure.first; |
| 1633 | + // For main module or binary modules, no command-line to resolve. |
| 1634 | + // For Clang modules, their dependencies are resolved by the clang Scanner |
| 1635 | + // itself for us. |
| 1636 | + if (modID.second != ModuleDependencyKind::SwiftInterface) |
| 1637 | + continue; |
| 1638 | + auto optionalDeps = cache.findDependency(modID.first, modID.second); |
| 1639 | + assert(optionalDeps.has_value()); |
| 1640 | + auto deps = optionalDeps.value(); |
| 1641 | + resolveExplicitModuleInputs(modID, *deps, dependencyClosure.second, cache); |
| 1642 | + } |
| 1643 | + |
1478 | 1644 | auto dependencyGraph = generateFullDependencyGraph( |
1479 | | - instance, cache, ASTDelegate, allModules.getArrayRef()); |
| 1645 | + instance, cache, ASTDelegate, topoSortedModuleList); |
1480 | 1646 | // Update the dependency tracker. |
1481 | 1647 | if (auto depTracker = instance.getDependencyTracker()) { |
1482 | 1648 | for (auto module : allModules) { |
|
0 commit comments