Merge remote-tracking branch 'apple/main' into maxd/main-merge

Author: kateinoigakukun

.mailmap

@@ -79,6 +79,7 @@ Joe Shajrawi <[email protected]> <[email protected]>
 Johannes Weiß <[email protected]> <[email protected]>
 John Regner <[email protected]> <[email protected]>
 Karoy Lorentey <[email protected]> <[email protected]>
+Kavon Farvardin <[email protected]> <[email protected]>
 Keith Smiley <[email protected]> <[email protected]>
 Kevin Ballard <[email protected]> <[email protected]>
 Kevin Saldaña <[email protected]>

cmake/modules/SwiftConfigureSDK.cmake

@@ -297,9 +297,9 @@ macro(configure_sdk_unix name architectures)
         else()
           message(SEND_ERROR "Couldn't find SWIFT_SDK_ANDROID_ARCH_armv7_PATH")
         endif()
-        set(SWIFT_SDK_ANDROID_ARCH_${arch}_TRIPLE "armv7-none-linux-androideabi")
+        set(SWIFT_SDK_ANDROID_ARCH_${arch}_TRIPLE "armv7-unknown-linux-androideabi")
         # The Android ABI isn't part of the module triple.
-        set(SWIFT_SDK_ANDROID_ARCH_${arch}_MODULE "armv7-none-linux-android")
+        set(SWIFT_SDK_ANDROID_ARCH_${arch}_MODULE "armv7-unknown-linux-android")
       elseif("${arch}" STREQUAL "aarch64")
         set(SWIFT_SDK_ANDROID_ARCH_${arch}_NDK_TRIPLE "aarch64-linux-android")
         set(SWIFT_SDK_ANDROID_ARCH_${arch}_ALT_SPELLING "aarch64")

docs/ABI/Mangling.rst

@@ -1008,6 +1008,8 @@ Function Specializations
 ::
 
   specialization ::= type '_' type* 'Tg' SPEC-INFO     // Generic re-abstracted specialization
+  specialization ::= type '_' type* 'TB' SPEC-INFO     // Alternative mangling for generic re-abstracted specializations,
+                                                       // used for functions with re-abstracted resilient parameter types.
   specialization ::= type '_' type* 'Ts' SPEC-INFO     // Generic re-abstracted prespecialization
   specialization ::= type '_' type* 'TG' SPEC-INFO     // Generic not re-abstracted specialization
   specialization ::= type '_' type* 'Ti' SPEC-INFO     // Inlined function with generic substitutions.

docs/Android.md

@@ -103,7 +103,7 @@ $ NDK_PATH="path/to/android-ndk21"
 $ build/Ninja-ReleaseAssert/swift-linux-x86_64/bin/swiftc \     # The Swift compiler built in the previous step.
                                                                 # The location of the tools used to build Android binaries
     -tools-directory ${NDK_PATH}/toolchains/llvm/prebuilt/linux-x86_64/bin/ \
-    -target armv7a-none-linux-androideabi \                     # Targeting android-armv7, and supply the path to libgcc.
+    -target armv7a-unknown-linux-androideabi \                  # Targeting android-armv7, and supply the path to libgcc.
     -L ${NDK_PATH}/toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86_64/lib/gcc/arm-linux-androideabi/4.9.x/armv7-a \
     -sdk ${NDK_PATH}/platforms/android-21/arch-arm \            # Use the same architecture and API version as you used to build the stdlib in the previous step.
     hello.swift

include/swift/AST/ExtInfo.h

@@ -827,6 +827,7 @@ class SILExtInfo {
   SILExtInfo withNoEscape(bool noEscape = true) const {
     return builder.withNoEscape(noEscape).build();
   }
+  
 
   SILExtInfo withAsync(bool isAsync = true) const {
     return builder.withAsync(isAsync).build();

include/swift/AST/IRGenOptions.h

@@ -140,6 +140,9 @@ struct PointerAuthOptions : clang::PointerAuthOptions {
 
   /// The parent async context stored within a child async context.
   PointerAuthSchema AsyncContextParent;
+
+  /// The function to call to resume running in the parent context.
+  PointerAuthSchema AsyncContextResume;
 };
 
 enum class JITDebugArtifact : unsigned {

include/swift/AST/TypeExpansionContext.h

@@ -89,6 +89,10 @@ class TypeExpansionContext {
       other.expansion == this->expansion;
   }
 
+  bool operator!=(const TypeExpansionContext &other) const {
+    return !operator==(other);
+  }
+
   bool operator<(const TypeExpansionContext other) const {
     assert(other.inContext != this->inContext ||
            other.isContextWholeModule == this->isContextWholeModule);

include/swift/Demangling/DemangleNodes.def

@@ -104,6 +104,7 @@ NODE(GenericProtocolWitnessTableInstantiationFunction)
 NODE(ResilientProtocolWitnessTable)
 NODE(GenericSpecialization)
 NODE(GenericSpecializationNotReAbstracted)
+NODE(GenericSpecializationInResilienceDomain)
 NODE(GenericSpecializationParam)
 NODE(GenericSpecializationPrespecialized)
 NODE(InlinedGenericFunction)

include/swift/Driver/Compilation.h

@@ -24,6 +24,7 @@
 #include "swift/Basic/OutputFileMap.h"
 #include "swift/Basic/Statistic.h"
 #include "swift/Driver/Driver.h"
+#include "swift/Driver/FineGrainedDependencyDriverGraph.h"
 #include "swift/Driver/Job.h"
 #include "swift/Driver/Util.h"
 #include "llvm/ADT/StringRef.h"
@@ -78,6 +79,29 @@ using CommandSet = llvm::SmallPtrSet<const Job *, 16>;
 
 class Compilation {
 public:
+  struct Result {
+    /// Set to true if any job exits abnormally (i.e. crashes).
+    bool hadAbnormalExit;
+    /// The exit code of this driver process.
+    int exitCode;
+    /// The dependency graph built up during the compilation of this module.
+    ///
+    /// This data is used for cross-module module dependencies.
+    fine_grained_dependencies::ModuleDepGraph depGraph;
+
+    Result(const Result &) = delete;
+    Result &operator=(const Result &) = delete;
+
+    Result(Result &&) = default;
+    Result &operator=(Result &&) = default;
+
+    /// Construct a \c Compilation::Result from just an exit code.
+    static Result code(int code) {
+      return Compilation::Result{false, code,
+                                 fine_grained_dependencies::ModuleDepGraph()};
+    }
+  };
+
   class IncrementalSchemeComparator {
     const bool EnableIncrementalBuildWhenConstructed;
     const bool &EnableIncrementalBuild;
@@ -490,7 +514,7 @@ class Compilation {
   ///
   /// \returns result code for the Compilation's Jobs; 0 indicates success and
   /// -2 indicates that one of the Compilation's Jobs crashed during execution
-  int performJobs(std::unique_ptr<sys::TaskQueue> &&TQ);
+  Compilation::Result performJobs(std::unique_ptr<sys::TaskQueue> &&TQ);
 
   /// Returns whether the callee is permitted to pass -emit-loaded-module-trace
   /// to a frontend job.
@@ -534,13 +558,11 @@ class Compilation {
 private:
   /// Perform all jobs.
   ///
-  /// \param[out] abnormalExit Set to true if any job exits abnormally (i.e.
-  /// crashes).
   /// \param TQ The task queue on which jobs will be scheduled.
   ///
   /// \returns exit code of the first failed Job, or 0 on success. If a Job
   /// crashes during execution, a negative value will be returned.
-  int performJobsImpl(bool &abnormalExit, std::unique_ptr<sys::TaskQueue> &&TQ);
+  Compilation::Result performJobsImpl(std::unique_ptr<sys::TaskQueue> &&TQ);
 
   /// Performs a single Job by executing in place, if possible.
   ///
@@ -550,7 +572,7 @@ class Compilation {
   /// will no longer exist, or it will call exit() if the program was
   /// successfully executed. In the event of an error, this function will return
   /// a negative value indicating a failure to execute.
-  int performSingleCommand(const Job *Cmd);
+  Compilation::Result performSingleCommand(const Job *Cmd);
 };
 
 } // end namespace driver

include/swift/Driver/FineGrainedDependencyDriverGraph.h

@@ -188,8 +188,8 @@ class ModuleDepGraph {
   std::unordered_map<std::string, unsigned> dotFileSequenceNumber;
 
 public:
-  const bool verifyFineGrainedDependencyGraphAfterEveryImport;
-  const bool emitFineGrainedDependencyDotFileAfterEveryImport;
+  bool verifyFineGrainedDependencyGraphAfterEveryImport;
+  bool emitFineGrainedDependencyDotFileAfterEveryImport;
 
 private:
   /// If tracing dependencies, holds a vector used to hold the current path
@@ -203,7 +203,7 @@ class ModuleDepGraph {
       dependencyPathsToJobs;
 
   /// For helping with performance tuning, may be null:
-  UnifiedStatsReporter *const stats;
+  UnifiedStatsReporter *stats;
 
   //==============================================================================
   // MARK: ModuleDepGraph - mutating dependencies
@@ -493,7 +493,12 @@ class ModuleDepGraph {
 
   template <typename Nodes>
   std::vector<const driver::Job *>
-  findJobsToRecompileWhenNodesChange(const Nodes &);
+  findJobsToRecompileWhenNodesChange(const Nodes &nodes) {
+    std::vector<ModuleDepGraphNode *> foundDependents;
+    for (ModuleDepGraphNode *n : nodes)
+      findPreviouslyUntracedDependents(foundDependents, n);
+    return jobsContaining(foundDependents);
+  }
 
 private:
   std::vector<const driver::Job *>

include/swift/Runtime/Concurrency.h

@@ -22,6 +22,8 @@
 namespace swift {
 class DefaultActor;
 
+struct SwiftError;
+
 struct AsyncTaskAndContext {
   AsyncTask *Task;
   AsyncContext *InitialContext;
@@ -270,6 +272,24 @@ void swift_defaultActor_destroy(DefaultActor *actor);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_defaultActor_enqueue(Job *job, DefaultActor *actor);
 
+/// Resume a task from its continuation, given a normal result value.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_continuation_resume(/* +1 */ OpaqueValue *result,
+                               void *continuation,
+                               const Metadata *resumeType);
+
+/// Resume a task from its throwing continuation, given a normal result value.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_continuation_throwingResume(/* +1 */ OpaqueValue *result,
+                                       void *continuation,
+                                       const Metadata *resumeType);
+
+/// Resume a task from its throwing continuation by throwing an error.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_continuation_throwingResumeWithError(/* +1 */ SwiftError *error,
+                                                void *continuation,
+                                                const Metadata *resumeType);
+
 }
 
 #endif

include/swift/SIL/BasicBlockUtils.h

@@ -89,6 +89,8 @@ class DeadEndBlocks {
     }
     return ReachableBlocks.empty();
   }
+
+  const SILFunction *getFunction() const { return F; }
 };
 
 /// A struct that contains the intermediate state used in computing

include/swift/SIL/GenericSpecializationMangler.h

@@ -69,31 +69,36 @@ class SpecializationMangler : public Mangle::ASTMangler {
 // The mangler for specialized generic functions.
 class GenericSpecializationMangler : public SpecializationMangler {
 
-  SubstitutionMap SubMap;
-  bool isReAbstracted;
-  bool isInlined;
-  bool isPrespecializaton;
+  GenericSpecializationMangler(std::string origFuncName)
+      : SpecializationMangler(SpecializationPass::GenericSpecializer,
+                              IsNotSerialized, origFuncName) {}
+
+  GenericSignature getGenericSignature() {
+    assert(Function && "Need a SIL function to get a generic signature");
+    return Function->getLoweredFunctionType()->getInvocationGenericSignature();
+  }
+
+  void appendSubstitutions(GenericSignature sig, SubstitutionMap subs);
+
+  std::string manglePrespecialized(GenericSignature sig,
+                                      SubstitutionMap subs);
 
 public:
-  GenericSpecializationMangler(SILFunction *F, SubstitutionMap SubMap,
-                               IsSerialized_t Serialized, bool isReAbstracted,
-                               bool isInlined = false,
-                               bool isPrespecializaton = false)
+  GenericSpecializationMangler(SILFunction *F, IsSerialized_t Serialized)
       : SpecializationMangler(SpecializationPass::GenericSpecializer,
-                              Serialized, F),
-        SubMap(SubMap), isReAbstracted(isReAbstracted), isInlined(isInlined),
-        isPrespecializaton(isPrespecializaton) {}
+                              Serialized, F) {}
 
-  GenericSpecializationMangler(std::string origFuncName, SubstitutionMap SubMap)
-      : SpecializationMangler(SpecializationPass::GenericSpecializer,
-                              IsNotSerialized, origFuncName),
-        SubMap(SubMap), isReAbstracted(true), isInlined(false),
-        isPrespecializaton(true) {}
+  std::string mangleNotReabstracted(SubstitutionMap subs);
 
-  std::string mangle(GenericSignature Sig = GenericSignature());
+  std::string mangleReabstracted(SubstitutionMap subs, bool alternativeMangling);
 
-  // TODO: This utility should move from the libswiftSILOptimizer to
-  // libswiftSIL.
+  std::string mangleForDebugInfo(GenericSignature sig, SubstitutionMap subs,
+                                 bool forInlining);
+
+  std::string manglePrespecialized(SubstitutionMap subs) {
+    return manglePrespecialized(getGenericSignature(), subs);
+  }
+                                    
   static std::string manglePrespecialization(std::string unspecializedName,
                                              GenericSignature genericSig,
                                              GenericSignature specializedSig);

include/swift/SIL/OwnershipUtils.h

@@ -170,6 +170,15 @@ struct BorrowingOperand {
     return *this;
   }
 
+  // A set of operators so that a BorrowingOperand can be used like a normal
+  // operand in a light weight way.
+  operator const Operand *() const { return op; }
+  operator Operand *() { return op; }
+  const Operand *operator*() const { return op; }
+  Operand *operator*() { return op; }
+  const Operand *operator->() const { return op; }
+  Operand *operator->() { return op; }
+
   /// If \p op is a borrow introducing operand return it after doing some
   /// checks.
   static Optional<BorrowingOperand> get(Operand *op) {
@@ -425,7 +434,7 @@ struct BorrowedValue {
   ///
   /// NOTE: Scratch space is used internally to this method to store the end
   /// borrow scopes if needed.
-  bool areUsesWithinScope(ArrayRef<Operand *> instructions,
+  bool areUsesWithinScope(ArrayRef<Operand *> uses,
                           SmallVectorImpl<Operand *> &scratchSpace,
                           SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks,
                           DeadEndBlocks &deadEndBlocks) const;
@@ -447,6 +456,24 @@ struct BorrowedValue {
   bool visitInteriorPointerOperands(
       function_ref<void(const InteriorPointerOperand &)> func) const;
 
+  /// Visit all immediate uses of this borrowed value and if any of them are
+  /// reborrows, place them in BorrowingOperand form into \p
+  /// foundReborrows. Returns true if we appended any such reborrows to
+  /// foundReborrows... false otherwise.
+  bool
+  gatherReborrows(SmallVectorImpl<BorrowingOperand> &foundReborrows) const {
+    bool foundAnyReborrows = false;
+    for (auto *op : value->getUses()) {
+      if (auto borrowingOperand = BorrowingOperand::get(op)) {
+        if (borrowingOperand->isReborrow()) {
+          foundReborrows.push_back(*borrowingOperand);
+          foundAnyReborrows = true;
+        }
+      }
+    }
+    return foundAnyReborrows;
+  }
+
 private:
   /// Internal constructor for failable static constructor. Please do not expand
   /// its usage since it assumes the code passed in is well formed.

include/swift/SIL/SILArgumentConvention.h

@@ -32,7 +32,6 @@ struct SILArgumentConvention {
     Indirect_Out,
     Direct_Owned,
     Direct_Unowned,
-    Direct_Deallocating,
     Direct_Guaranteed,
   } Value;
 
@@ -86,7 +85,6 @@ struct SILArgumentConvention {
       case SILArgumentConvention::Indirect_Out:
       case SILArgumentConvention::Direct_Unowned:
       case SILArgumentConvention::Direct_Owned:
-      case SILArgumentConvention::Direct_Deallocating:
       case SILArgumentConvention::Direct_Guaranteed:
         return false;
     }
@@ -105,7 +103,6 @@ struct SILArgumentConvention {
     case SILArgumentConvention::Indirect_Out:
     case SILArgumentConvention::Indirect_InoutAliasable:
     case SILArgumentConvention::Direct_Unowned:
-    case SILArgumentConvention::Direct_Deallocating:
       return false;
     }
     llvm_unreachable("covered switch isn't covered?!");
@@ -123,7 +120,6 @@ struct SILArgumentConvention {
     case SILArgumentConvention::Indirect_InoutAliasable:
     case SILArgumentConvention::Direct_Unowned:
     case SILArgumentConvention::Direct_Owned:
-    case SILArgumentConvention::Direct_Deallocating:
       return false;
     }
     llvm_unreachable("covered switch isn't covered?!");
@@ -143,7 +139,6 @@ struct SILArgumentConvention {
     case SILArgumentConvention::Direct_Unowned:
     case SILArgumentConvention::Direct_Guaranteed:
     case SILArgumentConvention::Direct_Owned:
-    case SILArgumentConvention::Direct_Deallocating:
       return false;
     }
     llvm_unreachable("covered switch isn't covered?!");

include/swift/SIL/SILBuilder.h

@@ -782,7 +782,7 @@ class SILBuilder {
   }
 
   void emitEndBorrowOperation(SILLocation loc, SILValue v) {
-    if (!hasOwnership())
+    if (!hasOwnership() || v.getOwnershipKind() == OwnershipKind::None)
       return;
     createEndBorrow(loc, v);
   }

include/swift/SIL/SILDeclRef.h

@@ -428,6 +428,8 @@ struct SILDeclRef {
     assert(isAutoDiffDerivativeFunction());
     return pointer.get<AutoDiffDerivativeFunctionIdentifier *>();
   }
+  
+  bool hasAsync() const;
 
 private:
   friend struct llvm::DenseMapInfo<swift::SILDeclRef>;