Merge pull request #2727 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

CMakeLists.txt

@@ -50,6 +50,7 @@ set(CMAKE_CXX_EXTENSIONS NO)
 # First include general CMake utilities.
 include(SwiftUtils)
 include(CheckSymbolExists)
+include(CMakeDependentOption)
 
 #
 # User-configurable options that control the inclusion and default build
@@ -411,6 +412,24 @@ option(SWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY
   "Enable experimental Swift concurrency model"
   FALSE)
 
+option(SWIFT_ENABLE_DISPATCH
+  "Enable use of libdispatch"
+  TRUE)
+
+cmake_dependent_option(SWIFT_BUILD_SYNTAXPARSERLIB
+  "Build the Swift Syntax Parser library" TRUE
+  "SWIFT_ENABLE_DISPATCH" FALSE)
+cmake_dependent_option(SWIFT_BUILD_ONLY_SYNTAXPARSERLIB
+  "Only build the Swift Syntax Parser library" FALSE
+  "SWIFT_BUILD_SYNTAXPARSERLIB" FALSE)
+
+cmake_dependent_option(SWIFT_BUILD_SOURCEKIT
+  "Build SourceKit" TRUE
+  "SWIFT_ENABLE_DISPATCH" FALSE)
+cmake_dependent_option(SWIFT_ENABLE_SOURCEKIT_TESTS
+  "Enable running SourceKit tests" TRUE
+  "SWIFT_BUILD_SOURCEKIT" FALSE)
+
 #
 # End of user-configurable options.
 #
@@ -434,11 +453,6 @@ if(CMAKE_C_COMPILER_ID MATCHES Clang)
   add_compile_options($<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-Werror=gnu>)
 endif()
 
-option(SWIFT_BUILD_SYNTAXPARSERLIB "Build the Swift Syntax Parser library" TRUE)
-option(SWIFT_BUILD_ONLY_SYNTAXPARSERLIB "Only build the Swift Syntax Parser library" FALSE)
-option(SWIFT_BUILD_SOURCEKIT "Build SourceKit" TRUE)
-option(SWIFT_ENABLE_SOURCEKIT_TESTS "Enable running SourceKit tests" ${SWIFT_BUILD_SOURCEKIT})
-
 # Use dispatch as the system scheduler by default.
 # For convenience, we set this to false when concurrency is disabled.
 set(SWIFT_CONCURRENCY_USES_DISPATCH FALSE)
@@ -447,14 +461,12 @@ if(SWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY AND NOT SWIFT_STDLIB_SINGLE_THREADED_RU
 endif()
 
 set(SWIFT_BUILD_HOST_DISPATCH FALSE)
-if(SWIFT_BUILD_SYNTAXPARSERLIB OR SWIFT_BUILD_SOURCEKIT)
-  if(NOT CMAKE_SYSTEM_NAME STREQUAL Darwin)
+if(SWIFT_ENABLE_DISPATCH AND NOT CMAKE_SYSTEM_NAME STREQUAL Darwin)
+  if(SWIFT_BUILD_SYNTAXPARSERLIB OR SWIFT_BUILD_SOURCEKIT)
     set(SWIFT_BUILD_HOST_DISPATCH TRUE)
   endif()
-endif()
 
-if(SWIFT_BUILD_HOST_DISPATCH OR SWIFT_CONCURRENCY_USES_DISPATCH)
-  if(NOT CMAKE_SYSTEM_NAME STREQUAL Darwin)
+  if(SWIFT_BUILD_HOST_DISPATCH OR SWIFT_CONCURRENCY_USES_DISPATCH)
     if(NOT EXISTS "${SWIFT_PATH_TO_LIBDISPATCH_SOURCE}")
       message(SEND_ERROR "SyntaxParserLib, SourceKit, and concurrency require libdispatch on non-Darwin hosts.  Please specify SWIFT_PATH_TO_LIBDISPATCH_SOURCE")
     endif()
@@ -996,7 +1008,9 @@ if (LLVM_ENABLE_DOXYGEN)
   message(STATUS "Doxygen: enabled")
 endif()
 
-include(Libdispatch)
+if(SWIFT_ENABLE_DISPATCH)
+  include(Libdispatch)
+endif()
 
 # Add all of the subdirectories, where we actually do work.
 

docs/ABI/Mangling.rst

@@ -220,7 +220,6 @@ types where the metadata itself has unknown layout.)
   global ::= global 'Tm'                 // merged function
   global ::= entity                      // some identifiable thing
   global ::= from-type to-type generic-signature? 'TR'  // reabstraction thunk
-  global ::= from-type to-type generic-signature? 'TR'  // reabstraction thunk
   global ::= impl-function-type type 'Tz'     // objc-to-swift-async completion handler block implementation
   global ::= impl-function-type type 'TZ'     // objc-to-swift-async completion handler block implementation (predefined by runtime)
   global ::= from-type to-type self-type generic-signature? 'Ty'  // reabstraction thunk with dynamic 'Self' capture
@@ -230,6 +229,9 @@ types where the metadata itself has unknown layout.)
   global ::= type generic-signature 'TH' // key path equality
   global ::= type generic-signature 'Th' // key path hasher
   global ::= global generic-signature? 'TJ' AUTODIFF-FUNCTION-KIND INDEX-SUBSET 'p' INDEX-SUBSET 'r' // autodiff function
+  global ::= from-type to-type 'TJO' AUTODIFF-FUNCTION-KIND // autodiff self-reordering reabstraction thunk
+  global ::= from-type 'TJS' AUTODIFF-FUNCTION-KIND INDEX-SUBSET 'p' INDEX-SUBSET 'r' INDEX-SUBSET 'P' // autodiff linear map subset parameters thunk
+  global ::= global to-type 'TJS' AUTODIFF-FUNCTION-KIND INDEX-SUBSET 'p' INDEX-SUBSET 'r' INDEX-SUBSET 'P' // autodiff derivative function subset parameters thunk
 
   global ::= protocol 'TL'               // protocol requirements base descriptor
   global ::= assoc-type-name 'Tl'        // associated type descriptor

include/swift/AST/ASTMangler.h

@@ -192,6 +192,15 @@ class ASTMangler : public Mangler {
                                       AutoDiffLinearMapKind kind,
                                       AutoDiffConfig config);
 
+  /// Mangle the linear map self parameter reordering thunk the given:
+  /// - Mangled original function declaration.
+  /// - Linear map kind.
+  /// - Derivative function configuration: parameter/result indices and
+  ///   derivative generic signature.
+  std::string mangleAutoDiffSelfReorderingReabstractionThunk(
+      CanType fromType, CanType toType, GenericSignature signature,
+      AutoDiffLinearMapKind linearMapKind);
+
   /// Mangle the AutoDiff generated declaration for the given:
   /// - Generated declaration kind: linear map struct or branching trace enum.
   /// - Mangled original function name.

include/swift/AST/Attr.def

@@ -602,8 +602,8 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(async, Async,
   106)
 
 SIMPLE_DECL_ATTR(concurrent, Concurrent,
-  OnFunc | OnConstructor | OnAccessor | ConcurrencyOnly |
-  ABIStableToAdd | ABIStableToRemove |
+  OnFunc | OnConstructor | OnAccessor |
+  ABIBreakingToAdd | ABIBreakingToRemove |
   APIBreakingToAdd | APIBreakingToRemove,
   107)
 

include/swift/AST/DiagnosticsSema.def

@@ -2938,8 +2938,8 @@ ERROR(dynamic_self_non_method,none,
       "%select{global|local}0 function cannot return 'Self'", (bool))
 
 ERROR(dynamic_self_invalid,none,
-      "covariant 'Self' can only appear as the type of a property, subscript or method result; "
-      "did you mean '%0'?", (StringRef))
+      "covariant 'Self' can only appear as the possibly optional type of a "
+      "property, subscript or method result; did you mean '%0'?", (StringRef))
 ERROR(dynamic_self_in_mutable_property,none,
       "mutable property cannot have covariant 'Self' type", ())
 ERROR(dynamic_self_in_stored_property,none,

include/swift/AST/SILOptions.h

@@ -153,6 +153,11 @@ class SILOptions {
   /// Emit extra exclusvity markers for memory access and verify coverage.
   bool VerifyExclusivity = false;
 
+  /// When building the stdlib with opts should we lower ownership after
+  /// serialization? Otherwise we do before. Only set to true on Darwin for now.
+  ///
+  bool SerializeStdlibWithOwnershipWithOpts = false;
+
   /// Calls to the replaced method inside of the replacement method will call
   /// the previous implementation.
   ///

include/swift/Basic/Features.def

@@ -38,5 +38,6 @@ LANGUAGE_FEATURE(StaticAssert, 0, "#assert", langOpts.EnableExperimentalStaticAs
 LANGUAGE_FEATURE(AsyncAwait, 296, "async/await", true)
 LANGUAGE_FEATURE(MarkerProtocol, 0, "@_marker protocol", true)
 LANGUAGE_FEATURE(Actors, 0, "actors", langOpts.EnableExperimentalConcurrency)
+LANGUAGE_FEATURE(ConcurrentFunctions, 0, "@concurrent functions", true)
 
 #undef LANGUAGE_FEATURE

include/swift/Demangling/DemangleNodes.def

@@ -310,6 +310,8 @@ NODE(CanonicalPrespecializedGenericTypeCachingOnceToken)
 NODE(AsyncFunctionPointer)
 CONTEXT_NODE(AutoDiffFunction)
 NODE(AutoDiffFunctionKind)
+NODE(AutoDiffSelfReorderingReabstractionThunk)
+NODE(AutoDiffSubsetParametersThunk)
 NODE(IndexSubset)
 
 #undef CONTEXT_NODE

include/swift/Demangling/Demangler.h

@@ -569,7 +569,10 @@ class Demangler : public NodeFactory {
 
   NodePointer demangleTypeMangling();
   NodePointer demangleSymbolicReference(unsigned char rawKind);
+  NodePointer demangleAutoDiffFunction();
   NodePointer demangleAutoDiffFunctionKind();
+  NodePointer demangleAutoDiffSubsetParametersThunk();
+  NodePointer demangleAutoDiffSelfReorderingReabstractionThunk();
   NodePointer demangleIndexSubset();
 
   bool demangleBoundGenerics(Vector<NodePointer> &TypeListList,

include/swift/SIL/SILBitfield.h renamed to include/swift/SIL/BasicBlockBits.h

@@ -1,4 +1,4 @@
-//===--- SILBitField.h - Defines the bitfield utilities ---------*- C++ -*-===//
+//===--- BasicBlockBits.h - SILBasicBlock bit utilities ---------*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -10,7 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file defines the BasicBlockBitfield and BasicBlockFlag utilities.
+// This file defines utilities for BasicBlock bit fields and sets.
 //
 //===----------------------------------------------------------------------===//
 
@@ -211,6 +211,63 @@ template <unsigned N> class BasicBlockSetVector {
   }
 };
 
+/// A utility for processing basic blocks in a worklist.
+///
+/// It is basically a combination of a block vector and a block set. It can be
+/// used for typical worklist-processing algorithms.
+template <unsigned N> class BasicBlockWorklist {
+  llvm::SmallVector<SILBasicBlock *, N> worklist;
+  BasicBlockSet visited;
+  
+public:
+  /// Construct an empty worklist.
+  BasicBlockWorklist(SILFunction *function) : visited(function) {}
+
+  /// Initialize the worklist with \p initialBlock.
+  BasicBlockWorklist(SILBasicBlock *initialBlock)
+      : visited(initialBlock->getParent()) {
+    push(initialBlock);
+  }
+
+  /// Pops the last added element from the worklist or returns null, if the
+  /// worklist is empty.
+  SILBasicBlock *pop() {
+    if (worklist.empty())
+      return nullptr;
+    return worklist.pop_back_val();
+  }
+
+  /// Pushes \p block onto the worklist if \p block has never been push before.
+  bool pushIfNotVisited(SILBasicBlock *block) {
+    if (visited.insert(block)) {
+      worklist.push_back(block);
+      return true;
+    }
+    return false;
+  }
+
+  /// Like `pushIfNotVisited`, but requires that \p block has never been on the
+  /// worklist before.
+  void push(SILBasicBlock *block) {
+    assert(!visited.contains(block));
+    visited.insert(block);
+    worklist.push_back(block);
+  }
+
+  /// Like `pop`, but marks the returned block as "unvisited". This means, that
+  /// the block can be pushed onto the worklist again.
+  SILBasicBlock *popAndForget() {
+    if (worklist.empty())
+      return nullptr;
+    SILBasicBlock *block = worklist.pop_back_val();
+    visited.erase(block);
+    return block;
+  }
+
+  /// Returns true if \p block was visited, i.e. has been added to the worklist.
+  bool isVisited(SILBasicBlock *block) const { return visited.contains(block); }
+};
+
 } // namespace swift
 
 #endif