Merge pull request #4020 from swiftwasm/main

Author: MaxDesiatov

include/swift/Basic/FileTypes.def

@@ -95,4 +95,6 @@ TYPE("pcm",                 ClangModuleFile,           "pcm",             "")
 TYPE("pch",                 PCH,                       "pch",             "")
 TYPE("none",                Nothing,                   "",                "")
 
+TYPE("abi-baseline-json",   SwiftABIDescriptor,        "abi.json",        "")
+
 #undef TYPE

include/swift/Option/FrontendOptions.td

@@ -215,8 +215,10 @@ def dependency_scan_cache_remarks : Flag<["-"], "Rdependency-scan-cache">,
 def enable_copy_propagation : Flag<["-"], "enable-copy-propagation">,
   HelpText<"Run SIL copy propagation with lexical lifetimes to shorten object "
            "lifetimes while preserving variable lifetimes.">;
-def disable_copy_propagation : Flag<["-"], "disable-copy-propagation">,
-  HelpText<"Don't run SIL copy propagation to preserve object lifetime.">;
+def copy_propagation_state_EQ :
+  Joined<["-"], "enable-copy-propagation=">,
+  HelpText<"Whether to enable copy propagation">,
+  MetaVarName<"true|requested-passes-only|false">;
 
 def enable_infer_public_concurrent_value : Flag<["-"], "enable-infer-public-sendable">,
     HelpText<"Enable inference of Sendable conformances for public structs and enums">;

include/swift/Runtime/AtomicWaitQueue.h

@@ -106,9 +106,28 @@ class AtomicWaitQueue {
     return referenceCount == 1;
   }
 
+  /// This queue is being re-used with new construction arguments.
+  /// Update it appropriately.
+  void updateForNewArguments() {
+    // We intentionally take no arguments so that only calls to
+    // createQueue with no arguments will succeed at calling this no-op
+    // implementation.  Queue types with construction arguments
+    // will need to implement this method to take the appropriate
+    // arguments.  Hopefully this discourages people from forgetting
+    // that queues can be re-used if created in a loop.
+  }
+
   /// An RAII helper class for signalling that the current thread is a
   /// worker thread which has acquired the lock.
   ///
+  /// `AtomicWaitQueue` does not require the global lock to be held
+  /// while creating or publishing the queue.  Clients taking advantage
+  /// of this should inform the Worker class that a created queue has
+  /// been published by calling `flagQueueIsPublished`.  Clients who
+  /// wish to publish the queue while holding the global lock, perhaps
+  /// to get a rule that all stores are done under the lock, may instead
+  /// use `tryPublishQueue`.
+  ///
   /// The expected use pattern is something like:
   ///
   /// ```
@@ -117,26 +136,47 @@ class AtomicWaitQueue {
   ///   while (true) {
   ///     if (oldStatus.isDone()) return;
   ///
-  ///     // Try to publish the wait queue.  If this succeeds, we've become
-  ///     // the worker thread.
-  ///     bool published = worker.tryPublishQueue([&] {
-  ///       auto newStatus = oldStatus.withLock(worker.createQueue());
-  ///       return myAtomic.compare_exchange_weak(oldStatus, newStatus,
-  ///                                 /*success*/ std::memory_order_release,
-  ///                                 /*failure*/ std::memory_order_acquire);
-  ///     });
-  ///     if (!published) continue;
+  ///     if (oldStatus.hasWaitQueue()) {
+  ///       bool waited = worker.tryReloadAndWait([&] {
+  ///         oldStatus = myAtomic.load(std::memory_order_acquire);
+  ///         return (oldStatus.hasWaitQueue() ? oldStatus.getWaitQueue()
+  ///                                          : nullptr);
+  ///       });
   ///
-  ///     // Do the actual work here.
+  ///       // If we waited, `oldStatus` will be out of date; reload it.
+  ///       //
+  ///       // (For the pattern in this example, where the worker thread
+  ///       // always transitions the status to done, this is actually
+  ///       // unnecessary: by virtue of having successfully waited, we've
+  ///       // synchronized with the worker thread and know that the status
+  ///       // is done, so we could just return.  But in general, this
+  ///       // reload is necessary.)
+  ///       if (waited)
+  ///         oldStatus = myAtomic.load(std::memory_order_acquire);
   ///
-  ///     // "Unpublish" the queue from the the atomic.
-  ///     while (true) {
-  ///       auto newStatus = oldStatus.withDone(true);
-  ///       if (myAtomic.compare_exchange_weak(oldStatus, newStatus,
+  ///       // Go back and reconsider the updated status.
+  ///       continue;
+  ///     }
+  ///
+  ///     // Create a queue and try to publish it.  If this succeeds,
+  ///     // we've become the worker thread.  We don't have to worry
+  ///     // about the queue leaking if we don't use it; that's managed
+  ///     // by the Worker class.
+  ///     {
+  ///       auto queue = worker.createQueue();
+  ///       auto newStatus = oldStatus.withWaitQueue(queue);
+  ///       if (!myAtomic.compare_exchange_weak(oldStatus, newStatus,
   ///                                 /*success*/ std::memory_order_release,
   ///                                 /*failure*/ std::memory_order_acquire))
-  ///         break;
+  ///         continue;
+  ///       worker.flagQueueIsPublished(queue);
   ///     }
+  ///
+  ///     // Do the actual work here.
+  ///
+  ///     // Report that the work is done and "unpublish" the queue from
+  ///     // the atomic.
+  ///     myAtomic.store(oldStatus.withDone(true), std::memory_order_release);
   ///     worker.finishAndUnpublishQueue([]{});
   ///     return;
   ///   }
@@ -182,6 +222,19 @@ class AtomicWaitQueue {
       return Published;
     }
 
+    /// Given that this thread is not the worker thread and there seems
+    /// to be a wait queue in place, try to wait on it.
+    ///
+    /// Acquire the global lock and call the given function.  If it
+    /// returns a wait queue, wait on that queue and return true;
+    /// otherwise, return false.
+    template <class Fn>
+    bool tryReloadAndWait(Fn &&fn) {
+      assert(!isWorkerThread());
+      typename Impl::Waiter waiter(GlobalLock);
+      return waiter.tryReloadAndWait(std::forward<Fn>(fn));
+    }
+
     /// Given that this thread is the worker thread, return the queue
     /// that's been created and published for it.
     Impl *getPublishedQueue() const {
@@ -195,14 +248,18 @@ class AtomicWaitQueue {
     ///
     /// The Worker object takes ownership of the queue until it's
     /// published, so you can safely call this even if publishing
-    /// might fail.  Note that the same queue will be returned on
-    /// successive invocations, so take care if the arguments might
-    /// change during the loop.
+    /// might fail.
+    ///
+    /// Note that the same queue will be returned on successive
+    /// invocations.  Queues that accept arguments for construction
+    /// should implement `updateForNewArguments`.
     template <class... Args>
     Impl *createQueue(Args &&...args) {
       assert(!Published);
       if (!CurrentQueue)
         CurrentQueue = asImpl().createNewQueue(std::forward<Args>(args)...);
+      else
+        CurrentQueue->updateForNewArguments(std::forward<Args>(args)...);
       return CurrentQueue;
     }
 

include/swift/Runtime/Config.h

@@ -330,9 +330,14 @@ extern uintptr_t __COMPATIBILITY_LIBRARIES_CANNOT_CHECK_THE_IS_SWIFT_BIT_DIRECTL
 
 /// Copy an address-discriminated signed pointer from the source to the dest.
 template <class T>
-SWIFT_RUNTIME_ATTRIBUTE_ALWAYS_INLINE
-static inline void swift_ptrauth_copy(T *dest, const T *src, unsigned extra) {
+SWIFT_RUNTIME_ATTRIBUTE_ALWAYS_INLINE static inline void
+swift_ptrauth_copy(T *dest, const T *src, unsigned extra, bool allowNull) {
 #if SWIFT_PTRAUTH
+  if (allowNull && *src == nullptr) {
+    *dest = nullptr;
+    return;
+  }
+
   *dest = ptrauth_auth_and_resign(*src,
                                   ptrauth_key_function_pointer,
                                   ptrauth_blend_discriminator(src, extra),
@@ -348,8 +353,13 @@ static inline void swift_ptrauth_copy(T *dest, const T *src, unsigned extra) {
 template <class T>
 SWIFT_RUNTIME_ATTRIBUTE_ALWAYS_INLINE
 static inline void swift_ptrauth_copy_data(T *dest, const T *src,
-                                           unsigned extra) {
+                                           unsigned extra, bool allowNull) {
 #if SWIFT_PTRAUTH
+  if (allowNull && *src == nullptr) {
+    *dest = nullptr;
+    return;
+  }
+
   *dest = ptrauth_auth_and_resign(*src,
                                   ptrauth_key_process_independent_data,
                                   ptrauth_blend_discriminator(src, extra),
@@ -365,11 +375,11 @@ static inline void swift_ptrauth_copy_data(T *dest, const T *src,
 template <class T>
 SWIFT_RUNTIME_ATTRIBUTE_ALWAYS_INLINE static inline void
 swift_ptrauth_copy_code_or_data(T *dest, const T *src, unsigned extra,
-                                bool isCode) {
+                                bool isCode, bool allowNull) {
   if (isCode) {
-    return swift_ptrauth_copy(dest, src, extra);
+    return swift_ptrauth_copy(dest, src, extra, allowNull);
   } else {
-    return swift_ptrauth_copy_data(dest, src, extra);
+    return swift_ptrauth_copy_data(dest, src, extra, allowNull);
   }
 }
 

lib/Basic/FileTypes.cpp

@@ -84,6 +84,7 @@ bool file_types::isTextual(ID Id) {
   case file_types::TY_SwiftOverlayFile:
   case file_types::TY_JSONDependencies:
   case file_types::TY_JSONFeatures:
+  case file_types::TY_SwiftABIDescriptor:
     return true;
   case file_types::TY_Image:
   case file_types::TY_Object:
@@ -157,6 +158,7 @@ bool file_types::isAfterLLVM(ID Id) {
   case file_types::TY_JSONDependencies:
   case file_types::TY_JSONFeatures:
   case file_types::TY_IndexUnitOutputPath:
+  case file_types::TY_SwiftABIDescriptor:
     return false;
   case file_types::TY_INVALID:
     llvm_unreachable("Invalid type ID.");
@@ -208,6 +210,7 @@ bool file_types::isPartOfSwiftCompilation(ID Id) {
   case file_types::TY_JSONDependencies:
   case file_types::TY_JSONFeatures:
   case file_types::TY_IndexUnitOutputPath:
+  case file_types::TY_SwiftABIDescriptor:
     return false;
   case file_types::TY_INVALID:
     llvm_unreachable("Invalid type ID.");

lib/Driver/Driver.cpp

@@ -2087,6 +2087,7 @@ void Driver::buildActions(SmallVectorImpl<const Action *> &TopLevelActions,
       case file_types::TY_SwiftOverlayFile:
       case file_types::TY_JSONDependencies:
       case file_types::TY_JSONFeatures:
+      case file_types::TY_SwiftABIDescriptor:
         // We could in theory handle assembly or LLVM input, but let's not.
         // FIXME: What about LTO?
         Diags.diagnose(SourceLoc(), diag::error_unexpected_input_file,

lib/Driver/ToolChains.cpp

@@ -682,6 +682,7 @@ const char *ToolChain::JobContext::computeFrontendModeForCompile() const {
   case file_types::TY_SwiftCrossImportDir:
   case file_types::TY_SwiftOverlayFile:
   case file_types::TY_IndexUnitOutputPath:
+  case file_types::TY_SwiftABIDescriptor:
     llvm_unreachable("Output type can never be primary output.");
   case file_types::TY_INVALID:
     llvm_unreachable("Invalid type ID");
@@ -941,6 +942,7 @@ ToolChain::constructInvocation(const BackendJobAction &job,
     case file_types::TY_SwiftCrossImportDir:
     case file_types::TY_SwiftOverlayFile:
     case file_types::TY_IndexUnitOutputPath:
+    case file_types::TY_SwiftABIDescriptor:
       llvm_unreachable("Output type can never be primary output.");
     case file_types::TY_INVALID:
       llvm_unreachable("Invalid type ID");

lib/Frontend/ArgsToFrontendOutputsConverter.cpp

@@ -599,6 +599,7 @@ createFromTypeToPathMap(const TypeToPathMap *map) {
        paths.PrivateModuleInterfaceOutputPath},
       {file_types::TY_YAMLOptRecord, paths.YAMLOptRecordPath},
       {file_types::TY_BitstreamOptRecord, paths.BitstreamOptRecordPath},
+      {file_types::TY_SwiftABIDescriptor, paths.ABIDescriptorOutputPath},
   };
   for (const std::pair<file_types::ID, std::string &> &typeAndString :
        typesAndStrings) {

lib/Frontend/CompilerInvocation.cpp

@@ -1466,6 +1466,42 @@ static bool ParseSILArgs(SILOptions &Opts, ArgList &Args,
   // -Ounchecked might also set removal of runtime asserts (cond_fail).
   Opts.RemoveRuntimeAsserts |= Args.hasArg(OPT_RemoveRuntimeAsserts);
 
+  Optional<CopyPropagationOption> specifiedCopyPropagationOption;
+  if (Arg *A = Args.getLastArg(OPT_copy_propagation_state_EQ)) {
+    specifiedCopyPropagationOption =
+        llvm::StringSwitch<Optional<CopyPropagationOption>>(A->getValue())
+            .Case("true", CopyPropagationOption::On)
+            .Case("false", CopyPropagationOption::Off)
+            .Case("requested-passes-only",
+                  CopyPropagationOption::RequestedPassesOnly)
+            .Default(None);
+  }
+  if (Args.hasArg(OPT_enable_copy_propagation)) {
+    if (specifiedCopyPropagationOption) {
+      if (*specifiedCopyPropagationOption == CopyPropagationOption::Off) {
+        // Error if copy propagation has been set to ::Off via the meta-var form
+        // and enabled via the flag.
+        Diags.diagnose(SourceLoc(), diag::error_invalid_arg_combination,
+                       "enable-copy-propagation",
+                       "enable-copy-propagation=false");
+        return true;
+      } else if (*specifiedCopyPropagationOption ==
+                 CopyPropagationOption::RequestedPassesOnly) {
+        // Error if copy propagation has been set to ::RequestedPassesOnly via
+        // the meta-var form and enabled via the flag.
+        Diags.diagnose(SourceLoc(), diag::error_invalid_arg_combination,
+                       "enable-copy-propagation",
+                       "enable-copy-propagation=requested-passes-only");
+        return true;
+      }
+    } else {
+      specifiedCopyPropagationOption = CopyPropagationOption::On;
+    }
+  }
+  if (specifiedCopyPropagationOption) {
+    Opts.CopyPropagation = *specifiedCopyPropagationOption;
+  }
+
   Optional<bool> enableLexicalBorrowScopesFlag;
   if (Arg *A = Args.getLastArg(OPT_enable_lexical_borrow_scopes)) {
     enableLexicalBorrowScopesFlag =
@@ -1525,13 +1561,14 @@ static bool ParseSILArgs(SILOptions &Opts, ArgList &Args,
     return true;
   }
 
-  // -enable-copy-propagation implies -enable-lexical-lifetimes unless
-  // otherwise specified.
-  if (Args.hasArg(OPT_enable_copy_propagation))
+  // Unless overridden below, enabling copy propagation means enabling lexical
+  // lifetimes.
+  if (Opts.CopyPropagation == CopyPropagationOption::On)
     Opts.LexicalLifetimes = LexicalLifetimesOption::On;
 
-  // -disable-copy-propagation implies -enable-lexical-lifetimes=false
-  if (Args.hasArg(OPT_disable_copy_propagation))
+  // Unless overridden below, disable copy propagation means disabling lexical
+  // lifetimes.
+  if (Opts.CopyPropagation == CopyPropagationOption::Off)
     Opts.LexicalLifetimes = LexicalLifetimesOption::DiagnosticMarkersOnly;
 
   // If move-only is enabled, always enable lexical lifetime as well.  Move-only
@@ -1554,24 +1591,6 @@ static bool ParseSILArgs(SILOptions &Opts, ArgList &Args,
     }
   }
 
-  if (Args.hasArg(OPT_enable_copy_propagation) &&
-      Args.hasArg(OPT_disable_copy_propagation)) {
-    // Error if copy propagation is enabled and copy propagation is disabled.
-    Diags.diagnose(SourceLoc(), diag::error_invalid_arg_combination,
-                   "enable-copy-propagation", "disable-copy-propagation");
-    return true;
-  } else if (Args.hasArg(OPT_enable_copy_propagation) &&
-             !Args.hasArg(OPT_disable_copy_propagation)) {
-    Opts.CopyPropagation = CopyPropagationOption::On;
-  } else if (!Args.hasArg(OPT_enable_copy_propagation) &&
-             Args.hasArg(OPT_disable_copy_propagation)) {
-    Opts.CopyPropagation = CopyPropagationOption::Off;
-  } else /*if (!Args.hasArg(OPT_enable_copy_propagation) &&
-            !Args.hasArg(OPT_disable_copy_propagation))*/
-  {
-    Opts.CopyPropagation = CopyPropagationOption::RequestedPassesOnly;
-  }
-
   Opts.EnableARCOptimizations &= !Args.hasArg(OPT_disable_arc_opts);
   Opts.EnableOSSAModules |= Args.hasArg(OPT_enable_ossa_modules);
   Opts.EnableOSSAOptimizations &= !Args.hasArg(OPT_disable_ossa_opts);

lib/FrontendTool/FrontendTool.cpp

@@ -1379,10 +1379,14 @@ static bool validateTBDIfNeeded(const CompilerInvocation &Invocation,
     // may have serialized hand-crafted SIL definitions that are invisible to
     // TBDGen as it is an AST-only traversal.
     if (auto *mod = MSF.dyn_cast<ModuleDecl *>()) {
-      return llvm::none_of(mod->getFiles(), [](const FileUnit *File) -> bool {
+      bool hasSIB = llvm::any_of(mod->getFiles(), [](const FileUnit *File) -> bool {
         auto SASTF = dyn_cast<SerializedASTFile>(File);
         return SASTF && SASTF->isSIB();
       });
+
+      if (hasSIB) {
+        return false;
+      }
     }
 
     // "Default" mode's behavior varies if using a debug compiler.

lib/SIL/IR/AbstractionPattern.cpp

@@ -1649,8 +1649,8 @@ class SubstFunctionTypePatternVisitor
       newGPMapping.insert({gp, newParamTy});
       auto substGPTy = Type(gp).subst(substGPMap)->castTo<GenericTypeParamType>();
       substRequirements.push_back(Requirement(RequirementKind::SameType,
-                                              substGPTy,
-                                              newParamTy));
+                                              newParamTy,
+                                              substGPTy));
       assert(!substReplacementTypes[substGPTy->getIndex()]);
       substReplacementTypes[substGPTy->getIndex()] = substParamTy;
     }