Merge pull request #3714 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

include/swift-c/SyntaxParser/SwiftSyntaxCDataTypes.h

@@ -27,6 +27,7 @@
 #define SWIFT_C_SYNTAX_C_DATA_TYPES_H
 
 #include <stdbool.h>
+#include <stdint.h>
 
 /// Offset+length in UTF8 bytes.
 typedef struct {

include/swift/AST/Types.h

@@ -4653,7 +4653,9 @@ class SILFunctionType final
       AutoDiffDerivativeFunctionKind kind, Lowering::TypeConverter &TC,
       LookupConformanceFn lookupConformance,
       CanGenericSignature derivativeFunctionGenericSignature = nullptr,
-      bool isReabstractionThunk = false);
+      bool isReabstractionThunk = false,
+      CanType origTypeOfAbstraction = CanType());
+
 
   /// Returns the type of the transpose function for the given parameter
   /// indices, transpose function generic signature (optional), and other

include/swift/SILOptimizer/Utils/OwnershipOptUtils.h

@@ -71,9 +71,10 @@ struct OwnershipFixupContext {
     /// and use this to seed that new lifetime.
     SmallVector<Operand *, 8> allAddressUsesFromOldValue;
 
-    /// This is the interior pointer operand that the new value we want to RAUW
-    /// is transitively derived from and enables us to know the underlying
-    /// borrowed base value that we need to lifetime extend.
+    /// This is the interior pointer (e.g. ref_element_addr)
+    /// that the new value we want to RAUW is transitively derived from and
+    /// enables us to know the underlying borrowed base value that we need to
+    /// lifetime extend.
     ///
     /// This is only initialized when the interior pointer has uses that must be
     /// replaced.
@@ -149,9 +150,15 @@ class OwnershipRAUWHelper {
   operator bool() const { return isValid(); }
   bool isValid() const { return bool(ctx) && bool(oldValue) && bool(newValue); }
 
-  /// Perform the actual RAUW. We require that \p newValue and \p oldValue have
-  /// the same type at this point (in contrast to when calling
-  /// OwnershipRAUWFixupHelper::get()).
+  /// True if replacement requires copying the original instruction's source
+  /// operand, creating a new borrow scope for that copy, then cloning the
+  /// original.
+  bool requiresCopyBorrowAndClone() const {
+    return ctx->extraAddressFixupInfo.base;
+  }
+
+  /// Perform OSSA fixup on newValue and return a fixed-up value based that can
+  /// be used to replace all uses of oldValue.
   ///
   /// This is so that we can avoid creating "forwarding" transformation
   /// instructions before we know if we can perform the RAUW. Any such

lib/SIL/IR/SILFunctionType.cpp

@@ -362,7 +362,8 @@ getSemanticResults(SILFunctionType *functionType, IndexSubset *parameterIndices,
 }
 
 static CanGenericSignature buildDifferentiableGenericSignature(CanGenericSignature sig,
-                                                               CanType tanType) {
+                                                               CanType tanType,
+                                                               CanType origTypeOfAbstraction) {
   if (!sig)
     return sig;
 
@@ -390,6 +391,20 @@ static CanGenericSignature buildDifferentiableGenericSignature(CanGenericSignatu
     }
   }
 
+  if (origTypeOfAbstraction) {
+    (void) origTypeOfAbstraction.findIf([&](Type t) -> bool {
+      if (auto *at = t->getAs<ArchetypeType>()) {
+        types.insert(at->getInterfaceType()->getCanonicalType());
+        for (auto *proto : at->getConformsTo()) {
+          reqs.push_back(Requirement(RequirementKind::Conformance,
+                                     at->getInterfaceType(),
+                                     proto->getDeclaredInterfaceType()));
+        }
+      }
+      return false;
+    });
+  }
+
   return evaluateOrDefault(
       ctx.evaluator,
       AbstractGenericSignatureRequest{sig.getPointer(), {}, reqs},
@@ -427,14 +442,15 @@ static CanType getAutoDiffTangentTypeForLinearMap(
 static CanSILFunctionType getAutoDiffDifferentialType(
     SILFunctionType *originalFnTy, IndexSubset *parameterIndices,
     IndexSubset *resultIndices, LookupConformanceFn lookupConformance,
+    CanType origTypeOfAbstraction,
     TypeConverter &TC) {
   // Given the tangent type and the corresponding original parameter's
   // convention, returns the tangent parameter's convention.
   auto getTangentParameterConvention =
       [&](CanType tanType,
           ParameterConvention origParamConv) -> ParameterConvention {
     auto sig = buildDifferentiableGenericSignature(
-      originalFnTy->getSubstGenericSignature(), tanType);
+      originalFnTy->getSubstGenericSignature(), tanType, origTypeOfAbstraction);
 
     tanType = tanType->getCanonicalType(sig);
     AbstractionPattern pattern(sig, tanType);
@@ -462,7 +478,7 @@ static CanSILFunctionType getAutoDiffDifferentialType(
       [&](CanType tanType,
           ResultConvention origResConv) -> ResultConvention {
     auto sig = buildDifferentiableGenericSignature(
-      originalFnTy->getSubstGenericSignature(), tanType);
+      originalFnTy->getSubstGenericSignature(), tanType, origTypeOfAbstraction);
 
     tanType = tanType->getCanonicalType(sig);
     AbstractionPattern pattern(sig, tanType);
@@ -565,7 +581,7 @@ static CanSILFunctionType getAutoDiffDifferentialType(
 static CanSILFunctionType getAutoDiffPullbackType(
     SILFunctionType *originalFnTy, IndexSubset *parameterIndices,
     IndexSubset *resultIndices, LookupConformanceFn lookupConformance,
-    TypeConverter &TC) {
+    CanType origTypeOfAbstraction, TypeConverter &TC) {
   auto &ctx = originalFnTy->getASTContext();
   SmallVector<GenericTypeParamType *, 4> substGenericParams;
   SmallVector<Requirement, 4> substRequirements;
@@ -582,7 +598,7 @@ static CanSILFunctionType getAutoDiffPullbackType(
       [&](CanType tanType,
           ResultConvention origResConv) -> ParameterConvention {
     auto sig = buildDifferentiableGenericSignature(
-      originalFnTy->getSubstGenericSignature(), tanType);
+      originalFnTy->getSubstGenericSignature(), tanType, origTypeOfAbstraction);
 
     tanType = tanType->getCanonicalType(sig);
     AbstractionPattern pattern(sig, tanType);
@@ -613,7 +629,7 @@ static CanSILFunctionType getAutoDiffPullbackType(
       [&](CanType tanType,
           ParameterConvention origParamConv) -> ResultConvention {
     auto sig = buildDifferentiableGenericSignature(
-      originalFnTy->getSubstGenericSignature(), tanType);
+      originalFnTy->getSubstGenericSignature(), tanType, origTypeOfAbstraction);
 
     tanType = tanType->getCanonicalType(sig);
     AbstractionPattern pattern(sig, tanType);
@@ -780,7 +796,8 @@ CanSILFunctionType SILFunctionType::getAutoDiffDerivativeFunctionType(
     AutoDiffDerivativeFunctionKind kind, TypeConverter &TC,
     LookupConformanceFn lookupConformance,
     CanGenericSignature derivativeFnInvocationGenSig,
-    bool isReabstractionThunk) {
+    bool isReabstractionThunk,
+    CanType origTypeOfAbstraction) {
   assert(parameterIndices);
   assert(!parameterIndices->isEmpty() && "Parameter indices must not be empty");
   assert(resultIndices);
@@ -810,12 +827,14 @@ CanSILFunctionType SILFunctionType::getAutoDiffDerivativeFunctionType(
   case AutoDiffDerivativeFunctionKind::JVP:
     closureType =
         getAutoDiffDifferentialType(constrainedOriginalFnTy, parameterIndices,
-                                    resultIndices, lookupConformance, TC);
+                                    resultIndices, lookupConformance,
+                                    origTypeOfAbstraction, TC);
     break;
   case AutoDiffDerivativeFunctionKind::VJP:
     closureType =
         getAutoDiffPullbackType(constrainedOriginalFnTy, parameterIndices,
-                                resultIndices, lookupConformance, TC);
+                                resultIndices, lookupConformance,
+                                origTypeOfAbstraction, TC);
     break;
   }
   // Compute the derivative function parameters.

lib/SIL/IR/TypeLowering.cpp

@@ -331,19 +331,23 @@ namespace {
         CanSILFunctionType type, AbstractionPattern origType) {
       auto &M = TC.M;
       auto origTy = type->getWithoutDifferentiability();
-      // Pass the `AbstractionPattern` generic signature to
-      // `SILFunctionType:getAutoDiffDerivativeFunctionType` for correct type
-      // lowering.
+      // Pass the original type of abstraction pattern to
+      // `SILFunctionType:getAutoDiffDerivativeFunctionType` to get the
+      // necessary generic requirements.
+      auto origTypeOfAbstraction =
+          origType.hasGenericSignature() ? origType.getType() : CanType();
       auto jvpTy = origTy->getAutoDiffDerivativeFunctionType(
           type->getDifferentiabilityParameterIndices(),
           type->getDifferentiabilityResultIndices(),
           AutoDiffDerivativeFunctionKind::JVP, TC,
-          LookUpConformanceInModule(&M), CanGenericSignature());
+          LookUpConformanceInModule(&M), CanGenericSignature(),
+          false, origTypeOfAbstraction);
       auto vjpTy = origTy->getAutoDiffDerivativeFunctionType(
           type->getDifferentiabilityParameterIndices(),
           type->getDifferentiabilityResultIndices(),
           AutoDiffDerivativeFunctionKind::VJP, TC,
-          LookUpConformanceInModule(&M), CanGenericSignature());
+          LookUpConformanceInModule(&M), CanGenericSignature(),
+          false, origTypeOfAbstraction);
       RecursiveProperties props;
       props.addSubobject(classifyType(origType, origTy, TC, Expansion));
       props.addSubobject(classifyType(origType, jvpTy, TC, Expansion));

lib/SILOptimizer/Transforms/CSE.cpp

@@ -1033,7 +1033,10 @@ bool CSE::processNode(DominanceInfoNode *Node) {
         OwnershipRAUWHelper helper(RAUWFixupContext,
                                    cast<SingleValueInstruction>(Inst),
                                    cast<SingleValueInstruction>(AvailInst));
-        if (!helper.isValid())
+        // If RAUW requires cloning the original, then there's no point. If it
+        // also requires introducing a copy and new borrow scope, then it's a
+        // very bad idea.
+        if (!helper.isValid() || helper.requiresCopyBorrowAndClone())
           continue;
         // Replace SingleValueInstruction using OSSA RAUW here
         nextI = helper.perform();

lib/SILOptimizer/Utils/OwnershipOptUtils.cpp

@@ -1041,10 +1041,9 @@ OwnershipRAUWHelper::replaceAddressUses(SingleValueInstruction *oldValue,
                                         SILValue newValue) {
   assert(oldValue->getType().isAddress() && newValue->getType().isAddress());
 
-  // If we are replacing addresses, see if we need to handle interior pointer
-  // fixups. If we don't have any extra info, then we know that we can just RAUW
-  // without any further work.
-  if (!ctx->extraAddressFixupInfo.base)
+  // If newValue was not generated by an interior pointer, then it cannot
+  // be within a borrow scope, so direct replacement works.
+  if (!requiresCopyBorrowAndClone())
     return replaceAllUsesAndErase(oldValue, newValue, ctx->callbacks);
 
   // We are RAUWing two addresses and we found that:

stdlib/CMakeLists.txt

@@ -138,6 +138,10 @@ option(SWIFT_STDLIB_PASSTHROUGH_METADATA_ALLOCATOR
        "Build stdlib without a custom implementation of MetadataAllocator, relying on malloc+free instead."
        FALSE)
 
+option(SWIFT_STDLIB_SHORT_MANGLING_LOOKUPS
+       "Build stdlib with fast-path context descriptor lookups based on well-known short manglings."
+       TRUE)
+
 option(SWIFT_STDLIB_HAS_COMMANDLINE
        "Build stdlib with the CommandLine enum and support for argv/argc."
        TRUE)

stdlib/cmake/modules/AddSwiftStdlib.cmake

@@ -363,6 +363,10 @@ function(_add_target_variant_c_compile_flags)
     list(APPEND result "-DSWIFT_STDLIB_PASSTHROUGH_METADATA_ALLOCATOR")
   endif()
 
+  if(SWIFT_STDLIB_SHORT_MANGLING_LOOKUPS)
+    list(APPEND result "-DSWIFT_STDLIB_SHORT_MANGLING_LOOKUPS")
+  endif()
+
   if(SWIFT_STDLIB_SUPPORTS_BACKTRACE_REPORTING)
     list(APPEND result "-DSWIFT_STDLIB_SUPPORTS_BACKTRACE_REPORTING")
   endif()

stdlib/public/Concurrency/GlobalExecutor.cpp

@@ -275,7 +275,7 @@ static constexpr size_t globalQueueCacheCount =
     static_cast<size_t>(JobPriority::UserInteractive) + 1;
 static std::atomic<dispatch_queue_t> globalQueueCache[globalQueueCacheCount];
 
-#ifdef SWIFT_CONCURRENCY_BACK_DEPLOYMENT
+#if defined(SWIFT_CONCURRENCY_BACK_DEPLOYMENT) || defined(__linux__)
 extern "C" void dispatch_queue_set_width(dispatch_queue_t dq, long width);
 #endif
 
@@ -295,7 +295,7 @@ static dispatch_queue_t getGlobalQueue(JobPriority priority) {
   if (SWIFT_LIKELY(queue))
     return queue;
 
-#ifdef SWIFT_CONCURRENCY_BACK_DEPLOYMENT
+#if defined(SWIFT_CONCURRENCY_BACK_DEPLOYMENT) || defined(__linux__)
   const int DISPATCH_QUEUE_WIDTH_MAX_LOGICAL_CPUS = -3;
 
   // Create a new cooperative concurrent queue and swap it in.