Merge pull request #39342 from DougGregor/back-deploy-concurrency-5.5

Back-deploy concurrency

Author: DougGregor

CMakeLists.txt

@@ -1004,6 +1004,11 @@ else()
     add_subdirectory(stdlib/toolchain)
   endif()
 
+  if (BUILD_SWIFT_CONCURRENCY_BACK_DEPLOYMENT_LIBRARIES)
+    # Build the back-deployed concurrency library.
+    add_subdirectory(stdlib/public/BackDeployConcurrency)
+  endif()
+
   # Some tools (e.g. swift-reflection-dump) rely on a host swiftReflection, so
   # ensure we build that when building tools.
   if(SWIFT_INCLUDE_TOOLS)

cmake/modules/Libdispatch.cmake

@@ -69,6 +69,11 @@ foreach(sdk ${DISPATCH_SDKS})
   foreach(arch ${ARCHS})
     set(LIBDISPATCH_VARIANT_NAME "libdispatch-${SWIFT_SDK_${sdk}_LIB_SUBDIR}-${arch}")
 
+    if(sdk MATCHES WINDOWS)
+      set(SWIFT_LIBDISPATCH_COMPILER_TRIPLE_CMAKE_ARGS -DCMAKE_C_COMPILER_TARGET=${SWIFT_SDK_WINDOWS_ARCH_${arch}_TRIPLE};-DCMAKE_CXX_COMPILER_TARGET=${SWIFT_SDK_WINDOWS_ARCH_${arch}_TRIPLE})
+    endif()
+
+
     if(NOT sdk STREQUAL ANDROID)
       set(SWIFT_LIBDISPATCH_SYSTEM_PROCESSOR  -DCMAKE_SYSTEM_PROCESSOR=${arch})
     endif()
@@ -80,6 +85,7 @@ foreach(sdk ${DISPATCH_SDKS})
                           -DCMAKE_AR=${CMAKE_AR}
                           -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
                           ${SWIFT_LIBDISPATCH_COMPILER_CMAKE_ARGS}
+                          ${SWIFT_LIBDISPATCH_COMPILER_TRIPLE_CMAKE_ARGS}
                           -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
                           -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
                           -DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}

cmake/modules/SwiftComponents.cmake

@@ -46,6 +46,7 @@
 # The set of "defined" swift components are as follows:
 #
 # * autolink-driver -- the Swift driver support tools
+# * back-deployment -- Swift back-deployment libraries
 # * compiler -- the Swift compiler and (on supported platforms) the REPL.
 # * clang-builtin-headers -- install a copy of Clang builtin headers under
 #   'lib/swift/clang'.  This is useful when Swift compiler is installed in
@@ -66,7 +67,7 @@
 # * toolchain-dev-tools -- install development tools useful in a shared toolchain
 # * dev -- headers and libraries required to use Swift compiler as a library.
 set(_SWIFT_DEFINED_COMPONENTS
-  "autolink-driver;compiler;clang-builtin-headers;clang-resource-dir-symlink;clang-builtin-headers-in-clang-resource-dir;stdlib;stdlib-experimental;sdk-overlay;parser-lib;editor-integration;tools;testsuite-tools;toolchain-tools;toolchain-dev-tools;dev;license;sourcekit-xpc-service;sourcekit-inproc;swift-remote-mirror;swift-remote-mirror-headers")
+  "autolink-driver;back-deployment;compiler;clang-builtin-headers;clang-resource-dir-symlink;clang-builtin-headers-in-clang-resource-dir;stdlib;stdlib-experimental;sdk-overlay;parser-lib;editor-integration;tools;testsuite-tools;toolchain-tools;toolchain-dev-tools;dev;license;sourcekit-xpc-service;sourcekit-inproc;swift-remote-mirror;swift-remote-mirror-headers")
 
 # The default install components include all of the defined components, except
 # for the following exceptions.
@@ -85,6 +86,8 @@ else()
   list(REMOVE_ITEM _SWIFT_DEFAULT_COMPONENTS "sourcekit-xpc-service")
 endif()
 list(REMOVE_ITEM _SWIFT_DEFAULT_COMPONENTS "stdlib-experimental")
+# back-deployment libraries are opt-in
+list(REMOVE_ITEM _SWIFT_DEFAULT_COMPONENTS "back-deployment")
 
 macro(swift_configure_components)
   # Set the SWIFT_INSTALL_COMPONENTS variable to the default value if it is not passed in via -D

include/swift/AST/ASTContext.h

@@ -731,6 +731,9 @@ class ASTContext final {
   /// Get the runtime availability of support for concurrency.
   AvailabilityContext getConcurrencyAvailability();
 
+  /// Get the back-deployed availability for concurrency.
+  AvailabilityContext getBackDeployedConcurrencyAvailability();
+
   /// Get the runtime availability of support for differentiation.
   AvailabilityContext getDifferentiationAvailability();
 
@@ -750,6 +753,11 @@ class ASTContext final {
   /// compiler for the target platform.
   AvailabilityContext getSwift55Availability();
 
+  // Note: Update this function if you add a new getSwiftXYAvailability above.
+  /// Get the runtime availability for a particular version of Swift (5.0+).
+  AvailabilityContext
+  getSwift5PlusAvailability(llvm::VersionTuple swiftVersion);
+
   /// Get the runtime availability of features that have been introduced in the
   /// Swift compiler for future versions of the target platform.
   AvailabilityContext getSwiftFutureAvailability();

include/swift/AST/ASTMangler.h

@@ -57,6 +57,10 @@ class ASTMangler : public Mangler {
   /// to fill these in.
   bool AllowSymbolicReferences = false;
 
+  /// If enabled, allows the use of standard substitutions for types in the
+  /// concurrency library.
+  bool AllowConcurrencyStandardSubstitutions = true;
+
 public:
   using SymbolicReferent = llvm::PointerUnion<const NominalTypeDecl *,
                                               const OpaqueTypeDecl *>;

include/swift/AST/IRGenOptions.h

@@ -381,6 +381,8 @@ class IRGenOptions {
   /// Pull in runtime compatibility shim libraries by autolinking.
   Optional<llvm::VersionTuple> AutolinkRuntimeCompatibilityLibraryVersion;
   Optional<llvm::VersionTuple> AutolinkRuntimeCompatibilityDynamicReplacementLibraryVersion;
+  Optional<llvm::VersionTuple>
+      AutolinkRuntimeCompatibilityConcurrencyLibraryVersion;
 
   JITDebugArtifact DumpJIT = JITDebugArtifact::None;
 

include/swift/Demangling/ManglingUtils.h

@@ -99,7 +99,12 @@ char translateOperatorChar(char op);
 std::string translateOperator(StringRef Op);
 
 /// Returns the standard type kind for an 'S' substitution, e.g. 'i' for "Int".
-llvm::Optional<StringRef> getStandardTypeSubst(StringRef TypeName);
+///
+/// \param allowConcurrencyManglings When true, allows the standard
+/// substitutions for types in the _Concurrency module that were introduced in
+/// Swift 5.5.
+llvm::Optional<StringRef> getStandardTypeSubst(
+    StringRef TypeName, bool allowConcurrencyManglings);
 
 /// Mangles an identifier using a generic Mangler class.
 ///

include/swift/Demangling/StandardTypesMangling.def

@@ -13,10 +13,10 @@
 /// STANDARD_TYPE(KIND, MANGLING, TYPENAME)
 ///   The 1-character MANGLING for a known TYPENAME of KIND.
 ///
-/// STANDARD_TYPE_2(KIND, MANGLING, TYPENAME)
+/// STANDARD_TYPE_CONCURRENCY(KIND, MANGLING, TYPENAME)
 ///   The 1-character MANGLING for a known TYPENAME of KIND that is in the
-///   second level of standard types, all of which are mangled with the form
-///   Sc<MANGLING>.
+///   second level of standard types in the Concurrency model, all of which are
+///   mangled with the form Sc<MANGLING>.
 ///
 /// OBJC_INTEROP_STANDARD_TYPE(KIND, MANGLING, TYPENAME)
 ///   The 1-character MANGLING for a known TYPENAME of KIND, for a type that's
@@ -79,25 +79,25 @@ STANDARD_TYPE(Protocol, y, StringProtocol)
 STANDARD_TYPE(Protocol, Z, SignedInteger)
 STANDARD_TYPE(Protocol, z, BinaryInteger)
 
-STANDARD_TYPE_2(Protocol, A, Actor)
-STANDARD_TYPE_2(Structure, C, CheckedContinuation)
-STANDARD_TYPE_2(Structure, c, UnsafeContinuation)
-STANDARD_TYPE_2(Structure, E, CancellationError)
-STANDARD_TYPE_2(Structure, e, UnownedSerialExecutor)
-STANDARD_TYPE_2(Protocol, F, Executor)
-STANDARD_TYPE_2(Protocol, f, SerialExecutor)
-STANDARD_TYPE_2(Structure, G, TaskGroup)
-STANDARD_TYPE_2(Structure, g, ThrowingTaskGroup)
-STANDARD_TYPE_2(Protocol, I, AsyncIteratorProtocol)
-STANDARD_TYPE_2(Protocol, i, AsyncSequence)
-STANDARD_TYPE_2(Structure, J, UnownedJob)
-STANDARD_TYPE_2(Class, M, MainActor)
-STANDARD_TYPE_2(Structure, P, TaskPriority)
-STANDARD_TYPE_2(Structure, S, AsyncStream)
-STANDARD_TYPE_2(Structure, s, AsyncThrowingStream)
-STANDARD_TYPE_2(Structure, T, Task)
-STANDARD_TYPE_2(Structure, t, UnsafeCurrentTask)
+STANDARD_TYPE_CONCURRENCY(Protocol, A, Actor)
+STANDARD_TYPE_CONCURRENCY(Structure, C, CheckedContinuation)
+STANDARD_TYPE_CONCURRENCY(Structure, c, UnsafeContinuation)
+STANDARD_TYPE_CONCURRENCY(Structure, E, CancellationError)
+STANDARD_TYPE_CONCURRENCY(Structure, e, UnownedSerialExecutor)
+STANDARD_TYPE_CONCURRENCY(Protocol, F, Executor)
+STANDARD_TYPE_CONCURRENCY(Protocol, f, SerialExecutor)
+STANDARD_TYPE_CONCURRENCY(Structure, G, TaskGroup)
+STANDARD_TYPE_CONCURRENCY(Structure, g, ThrowingTaskGroup)
+STANDARD_TYPE_CONCURRENCY(Protocol, I, AsyncIteratorProtocol)
+STANDARD_TYPE_CONCURRENCY(Protocol, i, AsyncSequence)
+STANDARD_TYPE_CONCURRENCY(Structure, J, UnownedJob)
+STANDARD_TYPE_CONCURRENCY(Class, M, MainActor)
+STANDARD_TYPE_CONCURRENCY(Structure, P, TaskPriority)
+STANDARD_TYPE_CONCURRENCY(Structure, S, AsyncStream)
+STANDARD_TYPE_CONCURRENCY(Structure, s, AsyncThrowingStream)
+STANDARD_TYPE_CONCURRENCY(Structure, T, Task)
+STANDARD_TYPE_CONCURRENCY(Structure, t, UnsafeCurrentTask)
 
 #undef STANDARD_TYPE
 #undef OBJC_INTEROP_STANDARD_TYPE
-#undef STANDARD_TYPE_2
+#undef STANDARD_TYPE_CONCURRENCY

include/swift/Frontend/BackDeploymentLibs.def

@@ -27,5 +27,6 @@
 BACK_DEPLOYMENT_LIB((5, 0), all, "swiftCompatibility50")
 BACK_DEPLOYMENT_LIB((5, 1), all, "swiftCompatibility51")
 BACK_DEPLOYMENT_LIB((5, 0), executable, "swiftCompatibilityDynamicReplacements")
+BACK_DEPLOYMENT_LIB((5, 5), all, "swiftCompatibilityConcurrency")
 
 #undef BACK_DEPLOYMENT_LIB

include/swift/Option/FrontendOptions.td

@@ -765,7 +765,6 @@ def type_info_dump_filter_EQ : Joined<["-"], "type-info-dump-filter=">,
   Flags<[FrontendOption]>,
   HelpText<"One of 'all', 'resilient' or 'fragile'">;
 
-
 def emit_ldadd_cfile_path
   : Separate<["-"], "emit-ldadd-cfile-path">, MetaVarName<"<path>">,
     HelpText<"Generate .c file defining symbols to add back">;

include/swift/Option/Options.td

@@ -1206,6 +1206,12 @@ def disable_autolinking_runtime_compatibility_dynamic_replacements
       HelpText<"Do not use autolinking for the dynamic replacement runtime "
                "compatibility library">;
 
+def disable_autolinking_runtime_compatibility_concurrency
+    : Flag<[ "-" ], "disable-autolinking-runtime-compatibility-concurrency">,
+      Flags<[ FrontendOption ]>,
+      HelpText<"Do not use autolinking for the concurrency runtime "
+               "compatibility library">;
+
 def emit_symbol_graph: Flag<["-"], "emit-symbol-graph">,
   Flags<[FrontendOption, NoInteractiveOption, SupplementaryOutput, HelpHidden]>,
   HelpText<"Emit a symbol graph">;

include/swift/Runtime/Exclusivity.h

@@ -40,25 +40,6 @@ SWIFT_RUNTIME_EXPORT
 void swift_beginAccess(void *pointer, ValueBuffer *buffer,
                        ExclusivityFlags flags, void *pc);
 
-/// Loads the replacement function pointer from \p ReplFnPtr and returns the
-/// replacement function if it should be called.
-/// Returns null if the original function (which is passed in \p CurrFn) should
-/// be called.
-#ifdef __APPLE__
-__attribute__((weak_import))
-#endif
-SWIFT_RUNTIME_EXPORT
-char *swift_getFunctionReplacement(char **ReplFnPtr, char *CurrFn);
-
-/// Returns the original function of a replaced function, which is loaded from
-/// \p OrigFnPtr.
-/// This function is called from a replacement function to call the original
-/// function.
-#ifdef __APPLE__
-__attribute__((weak_import))
-#endif
-SWIFT_RUNTIME_EXPORT
-char *swift_getOrigOfReplaceable(char **OrigFnPtr);
 
 /// Stop dynamically tracking an access.
 SWIFT_RUNTIME_EXPORT
@@ -91,6 +72,13 @@ void swift_dumpTrackedAccesses();
 
 #endif
 
+// When building the concurrency library for back deployment, we rename these
+// symbols unformly so they don't conflict with the real concurrency library.
+#ifdef SWIFT_CONCURRENCY_BACK_DEPLOYMENT
+#  define swift_task_enterThreadLocalContext swift_task_enterThreadLocalContextBackDeploy
+#  define swift_task_exitThreadLocalContext swift_task_exitThreadLocalContextBackDeploy
+#endif
+
 /// Called when a task inits, resumes and returns control to caller synchronous
 /// code to update any exclusivity specific state associated with the task.
 ///

include/swift/Runtime/FunctionReplacement.h

@@ -0,0 +1,42 @@
+//===--- FunctionReplacement.h --------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_RUNTIME_FUNCTIONREPLACEMENT_H
+#define SWIFT_RUNTIME_FUNCTIONREPLACEMENT_H
+
+#include "swift/Runtime/Config.h"
+
+namespace swift {
+
+/// Loads the replacement function pointer from \p ReplFnPtr and returns the
+/// replacement function if it should be called.
+/// Returns null if the original function (which is passed in \p CurrFn) should
+/// be called.
+#ifdef __APPLE__
+__attribute__((weak_import))
+#endif
+SWIFT_RUNTIME_EXPORT char *
+swift_getFunctionReplacement(char **ReplFnPtr, char *CurrFn);
+
+/// Returns the original function of a replaced function, which is loaded from
+/// \p OrigFnPtr.
+/// This function is called from a replacement function to call the original
+/// function.
+#ifdef __APPLE__
+__attribute__((weak_import))
+#endif
+SWIFT_RUNTIME_EXPORT char *
+swift_getOrigOfReplaceable(char **OrigFnPtr);
+
+} // namespace swift
+
+#endif

include/swift/Runtime/RuntimeFunctions.def

@@ -610,6 +610,24 @@ FUNCTION(GetFunctionMetadataGlobalActor,
               TypeMetadataPtrTy),
          ATTRS(NoUnwind, ReadOnly))
 
+// Metadata *
+// swift_getFunctionTypeMetadataGlobalActorBackDeploy(unsigned long flags,
+//                                                    unsigned long diffKind,
+//                                               const Metadata **parameters,
+//                                               const uint32_t *parameterFlags,
+//                                               const Metadata *result,
+//                                               const Metadata *globalActor);
+FUNCTION(GetFunctionMetadataGlobalActorBackDeploy,
+         swift_getFunctionTypeMetadataGlobalActorBackDeploy,
+         C_CC, OpaqueTypeAvailability,
+         RETURNS(TypeMetadataPtrTy),
+         ARGS(SizeTy,
+              SizeTy,
+              TypeMetadataPtrTy->getPointerTo(0),
+              Int32Ty->getPointerTo(0),
+              TypeMetadataPtrTy,
+              TypeMetadataPtrTy),
+         ATTRS(NoUnwind, ReadOnly))
 
 // Metadata *swift_getFunctionTypeMetadata0(unsigned long flags,
 //                                          const Metadata *resultMetadata);

lib/AST/ASTMangler.cpp

@@ -2935,7 +2935,8 @@ bool ASTMangler::tryAppendStandardSubstitution(const GenericTypeDecl *decl) {
     return false;
 
   if (isa<NominalTypeDecl>(decl)) {
-    if (auto Subst = getStandardTypeSubst(decl->getName().str())) {
+    if (auto Subst = getStandardTypeSubst(
+            decl->getName().str(), AllowConcurrencyStandardSubstitutions)) {
       if (!SubstMerging.tryMergeSubst(*this, *Subst, /*isStandardSubst*/ true)){
         appendOperator("S", *Subst);
       }

lib/AST/Availability.cpp

@@ -330,6 +330,10 @@ AvailabilityContext ASTContext::getConcurrencyAvailability() {
   return getSwift55Availability();
 }
 
+AvailabilityContext ASTContext::getBackDeployedConcurrencyAvailability() {
+  return getSwift51Availability();
+}
+
 AvailabilityContext ASTContext::getDifferentiationAvailability() {
   return getSwiftFutureAvailability();
 }
@@ -446,3 +450,20 @@ AvailabilityContext ASTContext::getSwiftFutureAvailability() {
     return AvailabilityContext::alwaysAvailable();
   }
 }
+
+AvailabilityContext
+ASTContext::getSwift5PlusAvailability(llvm::VersionTuple swiftVersion) {
+  if (swiftVersion.getMajor() == 5) {
+    switch (*swiftVersion.getMinor()) {
+    case 0: return getSwift50Availability();
+    case 1: return getSwift51Availability();
+    case 2: return getSwift52Availability();
+    case 3: return getSwift53Availability();
+    case 4: return getSwift54Availability();
+    case 5: return getSwift55Availability();
+    default: break;
+    }
+  }
+  llvm::report_fatal_error("Missing call to getSwiftXYAvailability for Swift " +
+                           swiftVersion.getAsString());
+}