Merge pull request #1252 from swiftwasm/maxd/master-merge

Resolve conflicts with master

Author: MaxDesiatov

docs/ABI/TypeMetadata.rst

@@ -222,13 +222,18 @@ classes.
   record is stored at **offset 0**, in place of an integer kind discriminator.
 - The **super pointer** pointing to the metadata record for the superclass is
   stored at **offset 1**. If the class is a root class, it is null.
-- Two words are reserved for use by the Objective-C runtime at **offset 2**
-  and **offset 3**.
-- The **rodata pointer** is stored at **offset 4**; it points to an Objective-C
-  compatible rodata record for the class. This pointer value includes a tag.
+- On platforms which support Objective-C interoperability, two words are
+  reserved for use by the Objective-C runtime at **offset 2** and **offset
+  3**; on other platforms, nothing is reserved.
+- On platforms which support Objective-C interoperability, the **rodata 
+  pointer** is stored at **offset 4**; on other platforms, it is not present. 
+  The rodata pointer points to an Objective-C compatible rodata record for the 
+  class. This pointer value includes a tag.
   The **low bit is always set to 1** for Swift classes and always set to 0 for
   Objective-C classes.
-- The **class flags** are a 32-bit field at **offset 5**.
+- The **class flags** are a 32-bit field at **offset 5** on platforms which 
+  support Objective-C interoperability; on other platforms, the field is at 
+  **offset 2**.
 - The **instance address point** is a 32-bit field following the class flags.
   A pointer to an instance of this class points this number of bytes after the
   beginning of the instance.
@@ -246,8 +251,11 @@ classes.
   object size.  This is the number of bytes of storage in the class metadata
   object.
 - The `nominal type descriptor`_ for the most-derived class type is referenced
-  at an offset immediately following the class object address point. This is
-  **offset 8** on a 64-bit platform or **offset 11** on a 32-bit platform.
+  at an offset immediately following the class object address point. On 64-bit
+  and 32-bit platforms which support Objective-C interoperability, this is,
+  respectively, at **offset 8** and at **offset 11**; in platforms that do not
+  support Objective-C interoperability, this is, respectively, at **offset 5** 
+  and at **offset 8**.
 - For each Swift class in the class's inheritance hierarchy, in order starting
   from the root class and working down to the most derived class, the following
   fields are present:

include/swift/AST/ASTContext.h

@@ -254,11 +254,6 @@ class ASTContext final {
   /// The request-evaluator that is used to process various requests.
   Evaluator evaluator;
 
-  /// The set of top-level modules we have loaded.
-  /// This map is used for iteration, therefore it's a MapVector and not a
-  /// DenseMap.
-  llvm::MapVector<Identifier, ModuleDecl*> LoadedModules;
-
   /// The builtin module.
   ModuleDecl * const TheBuiltinModule;
 
@@ -787,8 +782,24 @@ class ASTContext final {
   /// The loader is owned by the AST context.
   ClangModuleLoader *getDWARFModuleLoader() const;
 
+public:
   namelookup::ImportCache &getImportCache() const;
 
+  /// Returns an iterator over the modules that are known by this context
+  /// to be loaded.
+  ///
+  /// Iteration order is guaranteed to match the order in which
+  /// \c addLoadedModule was called to register the loaded module
+  /// with this context.
+  iterator_range<llvm::MapVector<Identifier, ModuleDecl *>::const_iterator>
+  getLoadedModules() const;
+
+  /// Returns the number of loaded modules known by this context to be loaded.
+  unsigned getNumLoadedModules() const {
+    auto eltRange = getLoadedModules();
+    return std::distance(eltRange.begin(), eltRange.end());
+  }
+
   /// Asks every module loader to verify the ASTs it has loaded.
   ///
   /// Does nothing in non-asserts (NDEBUG) builds.
@@ -828,6 +839,11 @@ class ASTContext final {
     return const_cast<ASTContext *>(this)->getStdlibModule(false);
   }
 
+  /// Insert an externally-sourced module into the set of known loaded modules
+  /// in this context.
+  void addLoadedModule(ModuleDecl *M);
+
+public:
   /// Retrieve the current generation number, which reflects the
   /// number of times a module import has caused mass invalidation of
   /// lookup tables.

include/swift/AST/DiagnosticsFrontend.def

@@ -295,6 +295,9 @@ ERROR(error_optimization_remark_pattern, none, "%0 in '%1'",
 ERROR(error_invalid_debug_prefix_map, none,
       "invalid argument '%0' to -debug-prefix-map; it must be of the form "
       "'original=remapped'", (StringRef))
+ERROR(error_invalid_coverage_prefix_map, none,
+      "invalid argument '%0' to -coverage-prefix-map; it must be of the form "
+      "'original=remapped'", (StringRef))
 
 
 ERROR(error_unable_to_write_swift_ranges_file, none,

include/swift/AST/DiagnosticsSema.def

@@ -253,6 +253,10 @@ ERROR(no_candidates_match_result_type,none,
       "no '%0' candidates produce the expected contextual result type %1",
       (StringRef, Type))
 
+ERROR(no_candidates_match_argument_type,none,
+      "no '%0' candidates produce the expected type %1 for parameter #%2",
+      (StringRef, Type, unsigned))
+
 ERROR(cannot_infer_closure_parameter_type,none,
       "unable to infer type of a closure parameter %0 in the current context",
        (StringRef))

include/swift/AST/FineGrainedDependencies.h

@@ -19,6 +19,7 @@
 #include "swift/Basic/Range.h"
 #include "swift/Basic/ReferenceDependencyKeys.h"
 #include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/SetVector.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/YAMLParser.h"
@@ -684,7 +685,7 @@ class SourceFileDepGraphNode : public DepGraphNode {
   size_t sequenceNumber = ~0;
 
   /// Holds the sequence numbers of definitions I depend upon.
-  std::unordered_set<size_t> defsIDependUpon;
+  llvm::SetVector<size_t> defsIDependUpon;
 
   /// True iff a Decl exists for this node.
   /// If a provides and a depends in the existing system both have the same key,

include/swift/AST/IRGenOptions.h

@@ -169,6 +169,9 @@ class IRGenOptions {
   /// Path prefixes that should be rewritten in debug info.
   PathRemapper DebugPrefixMap;
 
+  /// Path prefixes that should be rewritten in coverage info.
+  PathRemapper CoveragePrefixMap;
+
   /// What level of debug info to generate.
   IRGenDebugInfoLevel DebugInfoLevel : 2;
 

include/swift/AST/ModuleDependencies.h

@@ -73,6 +73,11 @@ class SwiftModuleDependenciesStorage : public ModuleDependenciesStorageBase {
   /// interface.
   const std::vector<std::string> buildCommandLine;
 
+  /// To build a PCM to be used by this Swift module, we need to append these
+  /// arguments to the generic PCM build arguments reported from the dependency
+  /// graph.
+  const std::vector<std::string> extraPCMArgs;
+
   /// The hash value that will be used for the generated module
   const std::string contextHash;
 
@@ -92,10 +97,12 @@ class SwiftModuleDependenciesStorage : public ModuleDependenciesStorageBase {
       const std::string &compiledModulePath,
       const Optional<std::string> &swiftInterfaceFile,
       ArrayRef<StringRef> buildCommandLine,
+      ArrayRef<StringRef> extraPCMArgs,
       StringRef contextHash
   ) : ModuleDependenciesStorageBase(/*isSwiftModule=*/true, compiledModulePath),
       swiftInterfaceFile(swiftInterfaceFile),
       buildCommandLine(buildCommandLine.begin(), buildCommandLine.end()),
+      extraPCMArgs(extraPCMArgs.begin(), extraPCMArgs.end()),
       contextHash(contextHash) { }
 
   ModuleDependenciesStorageBase *clone() const override {
@@ -176,18 +183,31 @@ class ModuleDependencies {
       const std::string &compiledModulePath,
       const std::string &swiftInterfaceFile,
       ArrayRef<StringRef> buildCommands,
+      ArrayRef<StringRef> extraPCMArgs,
       StringRef contextHash) {
     return ModuleDependencies(
         std::make_unique<SwiftModuleDependenciesStorage>(
-          compiledModulePath, swiftInterfaceFile, buildCommands, contextHash));
+          compiledModulePath, swiftInterfaceFile, buildCommands,
+          extraPCMArgs, contextHash));
   }
 
   /// Describe the module dependencies for a serialized or parsed Swift module.
   static ModuleDependencies forSwiftModule(
       const std::string &compiledModulePath) {
     return ModuleDependencies(
         std::make_unique<SwiftModuleDependenciesStorage>(
-          compiledModulePath, None, ArrayRef<StringRef>(), StringRef()));
+          compiledModulePath, None, ArrayRef<StringRef>(),
+          ArrayRef<StringRef>(), StringRef()));
+  }
+
+  /// Describe the main Swift module.
+  static ModuleDependencies forMainSwiftModule(
+      const std::string &compiledModulePath,
+      ArrayRef<StringRef> extraPCMArgs) {
+    return ModuleDependencies(
+        std::make_unique<SwiftModuleDependenciesStorage>(
+          compiledModulePath, None, ArrayRef<StringRef>(), extraPCMArgs,
+          StringRef()));
   }
 
   /// Describe the module dependencies for a Clang module that can be

include/swift/AST/ModuleLoader.h

@@ -89,6 +89,7 @@ struct SubCompilerInstanceInfo {
   CompilerInstance* Instance;
   StringRef Hash;
   ArrayRef<StringRef> BuildArguments;
+  ArrayRef<StringRef> ExtraPCMArgs;
 };
 
 /// Abstract interface to run an action in a sub ASTContext.
@@ -97,7 +98,8 @@ struct InterfaceSubContextDelegate {
                                StringRef interfacePath,
                                StringRef outputPath,
                                SourceLoc diagLoc,
-  llvm::function_ref<bool(ASTContext&,ArrayRef<StringRef>, StringRef)> action) = 0;
+  llvm::function_ref<bool(ASTContext&,ArrayRef<StringRef>,
+                          ArrayRef<StringRef>, StringRef)> action) = 0;
   virtual bool runInSubCompilerInstance(StringRef moduleName,
                                         StringRef interfacePath,
                                         StringRef outputPath,

include/swift/AST/SILOptions.h

@@ -161,10 +161,6 @@ class SILOptions {
   /// Enable large loadable types IRGen pass.
   bool EnableLargeLoadableTypes = true;
 
-  /// Should the default pass pipelines strip ownership during the diagnostic
-  /// pipeline or after serialization.
-  bool StripOwnershipAfterSerialization = true;
-
   /// The name of the file to which the backend should save optimization
   /// records.
   std::string OptRecordFile;

include/swift/Frontend/ModuleInterfaceLoader.h

@@ -244,7 +244,6 @@ struct InterfaceSubContextDelegateImpl: InterfaceSubContextDelegate {
   llvm::StringSaver ArgSaver;
   std::vector<StringRef> GenericArgs;
   CompilerInvocation subInvocation;
-  std::vector<SupplementaryOutputPaths> ModuleOutputPaths;
 
   template<typename ...ArgTypes>
   InFlightDiagnostic diagnose(StringRef interfacePath,
@@ -280,7 +279,8 @@ struct InterfaceSubContextDelegateImpl: InterfaceSubContextDelegate {
                        StringRef interfacePath,
                        StringRef outputPath,
                        SourceLoc diagLoc,
-    llvm::function_ref<bool(ASTContext&, ArrayRef<StringRef>, StringRef)> action) override;
+    llvm::function_ref<bool(ASTContext&, ArrayRef<StringRef>,
+                            ArrayRef<StringRef>, StringRef)> action) override;
   bool runInSubCompilerInstance(StringRef moduleName,
                                 StringRef interfacePath,
                                 StringRef outputPath,

include/swift/Option/FrontendOptions.td

@@ -289,10 +289,6 @@ def disable_sil_partial_apply : Flag<["-"], "disable-sil-partial-apply">,
 def enable_spec_devirt : Flag<["-"], "enable-spec-devirt">,
   HelpText<"Enable speculative devirtualization pass.">;
 
-def enable_ownership_stripping_after_serialization
-  : Flag<["-"], "enable-ownership-stripping-after-serialization">,
-  HelpText<"Strip ownership after serialization">;
-
 def disable_access_control : Flag<["-"], "disable-access-control">,
   HelpText<"Don't respect access control restrictions">;
 def enable_access_control : Flag<["-"], "enable-access-control">,

include/swift/Option/Options.td

@@ -724,6 +724,9 @@ def gdwarf_types : Flag<["-"], "gdwarf-types">,
 def debug_prefix_map : Separate<["-"], "debug-prefix-map">,
     Flags<[FrontendOption]>,
     HelpText<"Remap source paths in debug info">;
+def coverage_prefix_map : Separate<["-"], "coverage-prefix-map">,
+  Flags<[FrontendOption]>,
+  HelpText<"Remap source paths in coverage info">;
 
 def debug_info_format : Joined<["-"], "debug-info-format=">,
   Flags<[FrontendOption]>,

lib/AST/ASTContext.cpp

@@ -156,6 +156,11 @@ struct ASTContext::Implementation {
   /// The set of cleanups to be called when the ASTContext is destroyed.
   std::vector<std::function<void(void)>> Cleanups;
 
+  /// The set of top-level modules we have loaded.
+  /// This map is used for iteration, therefore it's a MapVector and not a
+  /// DenseMap.
+  llvm::MapVector<Identifier, ModuleDecl *> LoadedModules;
+
   // FIXME: This is a StringMap rather than a StringSet because StringSet
   // doesn't allow passing in a pre-existing allocator.
   llvm::StringMap<Identifier::Aligner, llvm::BumpPtrAllocator&>
@@ -1538,8 +1543,18 @@ ModuleDecl *ASTContext::getLoadedModule(
   return nullptr;
 }
 
+iterator_range<llvm::MapVector<Identifier, ModuleDecl *>::const_iterator>
+ASTContext::getLoadedModules() const {
+  return {getImpl().LoadedModules.begin(), getImpl().LoadedModules.end()};
+}
+
 ModuleDecl *ASTContext::getLoadedModule(Identifier ModuleName) const {
-  return LoadedModules.lookup(ModuleName);
+  return getImpl().LoadedModules.lookup(ModuleName);
+}
+
+void ASTContext::addLoadedModule(ModuleDecl *M) {
+  assert(M);
+  getImpl().LoadedModules[M->getName()] = M;
 }
 
 static AllocationArena getArena(GenericSignature genericSig) {

lib/ClangImporter/ClangImporter.cpp

@@ -1829,9 +1829,9 @@ ModuleDecl *ClangImporter::Implementation::finishLoadingClangModule(
   if (clangModule->isSubModule()) {
     finishLoadingClangModule(clangModule->getTopLevelModule(), importLoc);
   } else {
-    ModuleDecl *&loaded = SwiftContext.LoadedModules[result->getName()];
-    if (!loaded)
-      loaded = result;
+
+    if (!SwiftContext.getLoadedModule(result->getName()))
+      SwiftContext.addLoadedModule(result);
   }
 
   return result;
@@ -3372,10 +3372,12 @@ ModuleDecl *ClangModuleUnit::getOverlayModule() const {
     if (overlay == M) {
       overlay = nullptr;
     } else {
-      auto &sharedModuleRef = Ctx.LoadedModules[M->getName()];
+      // FIXME: This bizarre and twisty invariant is due to nested
+      // re-entrancy in both clang module loading and overlay module loading.
+      auto *sharedModuleRef = Ctx.getLoadedModule(M->getName());
       assert(!sharedModuleRef || sharedModuleRef == overlay ||
              sharedModuleRef == M);
-      sharedModuleRef = overlay;
+      Ctx.addLoadedModule(overlay);
     }
 
     auto mutableThis = const_cast<ClangModuleUnit *>(this);

lib/ClangImporter/ClangModuleDependencyScanner.cpp

@@ -229,9 +229,23 @@ void ClangImporter::recordModuleDependencies(
       swiftArgs.push_back(arg.str());
     };
     // Add all args inheritted from creating the importer.
-    for (auto arg: allArgs) {
-      addClangArg(arg);
+    auto It = allArgs.begin();
+    while(It != allArgs.end()) {
+      StringRef arg = *It;
+      // Remove the -target arguments because we should use the target triple
+      // from the depending Swift modules.
+      if (arg == "-target") {
+        It += 2;
+      } else if (arg.startswith("-fapinotes-swift-version=")) {
+        // Remove the apinotes version because we should use the language version
+        // specified in the interface file.
+        It += 1;
+      } else {
+        addClangArg(*It);
+        ++ It;
+      }
     }
+
     // Swift frontend action: -emit-pcm
     swiftArgs.push_back("-emit-pcm");
     swiftArgs.push_back("-module-name");

lib/ClangImporter/DWARFImporter.cpp

@@ -121,9 +121,8 @@ ModuleDecl *ClangImporter::Implementation::loadModuleDWARF(
   (void) namelookup::getAllImports(decl);
 
   // Register the module with the ASTContext so it is available for lookups.
-  ModuleDecl *&loaded = SwiftContext.LoadedModules[name];
-  if (!loaded)
-    loaded = decl;
+  if (!SwiftContext.getLoadedModule(name))
+    SwiftContext.addLoadedModule(decl);
 
   return decl;
 }

lib/Driver/Driver.cpp

@@ -179,6 +179,12 @@ static void validateDebugInfoArgs(DiagnosticEngine &diags,
   for (auto A : args.getAllArgValues(options::OPT_debug_prefix_map))
     if (A.find('=') == StringRef::npos)
       diags.diagnose(SourceLoc(), diag::error_invalid_debug_prefix_map, A);
+
+  // Check for any -coverage-prefix-map options that aren't of the form
+  // 'original=remapped' (either side can be empty, however).
+  for (auto A : args.getAllArgValues(options::OPT_coverage_prefix_map))
+    if (A.find('=') == StringRef::npos)
+      diags.diagnose(SourceLoc(), diag::error_invalid_coverage_prefix_map, A);
 }
 
 static void validateVerifyIncrementalDependencyArgs(DiagnosticEngine &diags,

lib/Driver/ToolChains.cpp

@@ -262,6 +262,7 @@ void ToolChain::addCommonFrontendArgs(const OutputInfo &OI,
 
   // Pass on file paths that should be remapped in debug info.
   inputArgs.AddAllArgs(arguments, options::OPT_debug_prefix_map);
+  inputArgs.AddAllArgs(arguments, options::OPT_coverage_prefix_map);
 
   // Pass through the values passed to -Xfrontend.
   inputArgs.AddAllArgValues(arguments, options::OPT_Xfrontend);