Merge branch 'main' into arm64e-disable

Author: adrian-prantl

docs/ABI/Mangling.rst

@@ -222,8 +222,8 @@ 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 ::= 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 ::= impl-function-type type 'Tz' index? // objc-to-swift-async completion handler block implementation
+  global ::= impl-function-type type 'TZ' index? // objc-to-swift-async completion handler block implementation (predefined by runtime)
   global ::= from-type to-type generic-signature? 'TR'  // reabstraction thunk
   global ::= impl-function-type type generic-signature? 'Tz'     // objc-to-swift-async completion handler block implementation
   global ::= impl-function-type type generic-signature? 'TZ'     // objc-to-swift-async completion handler block implementation (predefined by runtime)

docs/SIL.rst

@@ -2320,6 +2320,54 @@ The current list of interior pointer SIL instructions are:
 (*) We still need to finish adding support for project_box, but all other
 interior pointers are guarded already.
 
+Memory Lifetime
+~~~~~~~~~~~~~~~
+
+Similar to Ownership SSA, there are also lifetime rules for values in memory.
+With "memory" we refer to memory which is addressed by SIL instruction with
+address-type operands, like ``load``, ``store``, ``switch_enum_addr``, etc.
+
+Each memory location which holds a non-trivial value is either uninitialized
+or initialized. A memory location gets initialized by storing values into it
+(except assignment, which expects a location to be already initialized).
+A memory location gets de-initialized by "taking" from it or destroying it, e.g.
+with ``destroy_addr``. It is illegal to re-initialize a memory location or to
+use a location after it was de-initialized.
+
+If a memory location holds a trivial value (e.g. an ``Int``), it is not
+required to de-initialize the location.
+
+The SIL verifier checks this rule for memory locations which can be uniquely
+identified, for example and ``alloc_stack`` or an indirect parameter. The
+verifier cannot check memory locations which are potentially aliased, e.g.
+a ``ref_element_addr`` (a stored class property).
+
+Lifetime of Enums in Memory
+```````````````````````````
+
+The situation is a bit more complicated with enums, because an enum can have
+both, cases with non-trivial payloads and cases with no payload or trivial
+payloads.
+
+Even if an enum itself is not trivial (because it has at least on case with a
+non-trivial payload), it is not required to de-initialize such an enum memory
+location on paths where it's statically provable that the enum contains a
+trivial or non-payload case.
+
+That's the case if the destroy point is jointly dominated by:
+
+* a ``store [trivial]`` to the enum memory location.
+
+or
+
+* an ``inject_enum_addr`` to the enum memory location with a non-trivial or
+  non-payload case.
+
+or
+
+* a successor of a ``switch_enum`` or ``switch_enum_addr`` for a non-trivial
+  or non-payload case.
+
 Dead End Blocks
 ~~~~~~~~~~~~~~~
 

include/swift/AST/ASTMangler.h

@@ -172,6 +172,7 @@ class ASTMangler : public Mangler {
   std::string mangleObjCAsyncCompletionHandlerImpl(CanSILFunctionType BlockType,
                                                    CanType ResultType,
                                                    CanGenericSignature Sig,
+                                                   Optional<bool> FlagParamIsZeroOnError,
                                                    bool predefined);
 
   /// Mangle the derivative function (JVP/VJP), or optionally its vtable entry

include/swift/AST/FineGrainedDependencies.h

@@ -13,6 +13,7 @@
 #ifndef SWIFT_AST_FINE_GRAINED_DEPENDENCIES_H
 #define SWIFT_AST_FINE_GRAINED_DEPENDENCIES_H
 
+#include "swift/AST/EvaluatorDependencies.h"
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/Fingerprint.h"
 #include "swift/Basic/LLVM.h"
@@ -57,11 +58,14 @@
 //==============================================================================
 
 namespace swift {
+class Decl;
 class DependencyTracker;
 class DiagnosticEngine;
 class FrontendOptions;
 class ModuleDecl;
 class SourceFile;
+class NominalTypeDecl;
+class ValueDecl;
 
 /// Use a new namespace to help keep the experimental code from clashing.
 namespace fine_grained_dependencies {
@@ -417,6 +421,57 @@ class DependencyKey {
   // For import/export
   friend ::llvm::yaml::MappingTraits<DependencyKey>;
 
+public:
+  class Builder {
+  private:
+    const NodeKind kind;
+    const DeclAspect aspect;
+    const NominalTypeDecl *context;
+    StringRef name;
+
+  private:
+    // A private copy constructor so our clients are forced to use the
+    // move-only builder interface.
+    explicit Builder(NodeKind kind, DeclAspect aspect,
+                     const NominalTypeDecl *context, StringRef name)
+        : kind(kind), aspect(aspect), context(context), name(name) {}
+
+  public:
+    /// Creates a DependencyKey::Builder from the given \p kind and \p aspect
+    /// with a \c null context and empty name.
+    explicit Builder(NodeKind kind, DeclAspect aspect)
+        : kind(kind), aspect(aspect), context(nullptr), name("") {}
+
+  public:
+    /// Consumes this builder and returns a dependency key created from its
+    /// data.
+    DependencyKey build() &&;
+
+  public:
+    /// Extracts the data from the given \p ref into a this builder.
+    Builder fromReference(const evaluator::DependencyCollector::Reference &ref);
+
+  public:
+    /// Extracts the context data from the given declaration, if any.
+    Builder withContext(const Decl *D) &&;
+    /// Extracts the context data from the given decl-member pair, if any.
+    Builder withContext(std::pair<const NominalTypeDecl *, const ValueDecl *>
+                            holderAndMember) &&;
+
+  public:
+    /// Copies the name data for the given swiftdeps file into this builder.
+    Builder withName(StringRef swiftDeps) &&;
+    /// Copies the name of the given declaration into this builder, if any.
+    Builder withName(const Decl *decl) &&;
+    /// Extracts the name from the given decl-member pair, if any.
+    Builder withName(std::pair<const NominalTypeDecl *, const ValueDecl *>
+                         holderAndMember) &&;
+
+  private:
+    static StringRef getTopLevelName(const Decl *decl);
+  };
+
+private:
   NodeKind kind;
   DeclAspect aspect;
   /// The mangled context type name of the holder for \ref potentialMember, \ref
@@ -485,10 +540,6 @@ class DependencyKey {
   template <NodeKind kind, typename Entity>
   static DependencyKey createForProvidedEntityInterface(Entity);
 
-  /// Given some type of provided entity compute the context field of the key.
-  template <NodeKind kind, typename Entity>
-  static std::string computeContextForProvidedEntity(Entity);
-
   DependencyKey correspondingImplementation() const {
     return withAspect(DeclAspect::implementation);
   }
@@ -497,10 +548,6 @@ class DependencyKey {
     return DependencyKey(kind, aspect, context, name);
   }
 
-  /// Given some type of provided entity compute the name field of the key.
-  template <NodeKind kind, typename Entity>
-  static std::string computeNameForProvidedEntity(Entity);
-
   static DependencyKey createKeyForWholeSourceFile(DeclAspect,
                                                    StringRef swiftDeps);
 

include/swift/AST/SILOptions.h

@@ -89,6 +89,11 @@ class SILOptions {
   /// and go from OSSA to non-ownership SIL.
   bool StopOptimizationBeforeLoweringOwnership = false;
 
+  /// Do we always serialize SIL in OSSA form?
+  ///
+  /// If this is disabled we do not serialize in OSSA form when optimizing.
+  bool EnableOSSAModules = false;
+
   // The kind of function bodies to skip emitting.
   FunctionBodySkipping SkipFunctionBodies = FunctionBodySkipping::None;
 

include/swift/Basic/Features.def

@@ -39,5 +39,8 @@ 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)
+LANGUAGE_FEATURE(RethrowsProtocol, 0, "@rethrows protocol", true)
+LANGUAGE_FEATURE(GlobalActors, 0, "Global actors", langOpts.EnableExperimentalConcurrency)
+LANGUAGE_FEATURE(BuiltinJob, 0, "Builtin.Job type", true)
 
 #undef LANGUAGE_FEATURE

include/swift/Option/FrontendOptions.td

@@ -789,6 +789,10 @@ def disable_ast_verifier : Flag<["-"], "disable-ast-verifier">,
            "disabled. NOTE: Can not be used if enable-ast-verifier is used "
            "as well">;
 
+def enable_ossa_modules : Flag<["-"], "enable-ossa-modules">,
+  HelpText<"Always serialize SIL in ossa form. If this flag is not passed in, "
+           "when optimizing ownership will be lowered before serializing SIL">;
+
 def new_driver_path
   : Separate<["-"], "new-driver-path">, MetaVarName<"<path>">,
   HelpText<"Path of the new driver to be used">;

include/swift/SIL/AbstractionPattern.h

@@ -276,6 +276,20 @@ class AbstractionPattern {
       Async,
     };
 
+    enum {
+      AsyncCompletionParameterIndexMask = 0xFFEu,
+      AsyncCompletionParameterIndexShift = 1,
+      
+      AsyncCompletionErrorParameterIndexMask = 0x1FF000u,
+      AsyncCompletionErrorParameterIndexShift = 12,
+      
+      AsyncCompletionErrorFlagParameterIndexMask = 0x3FE00000u,
+      AsyncCompletionErrorFlagParameterIndexShift = 21,
+      
+      AsyncCompletionErrorFlagParameterPolarityMask = 0x40000000u,
+      AsyncCompletionErrorFlagParameterPolarityShift = 30,
+    };
+    
   public:
     enum ForeignKind {
       IsNotForeign,
@@ -304,16 +318,24 @@ class AbstractionPattern {
 
     EncodedForeignInfo(Async_t,
                        unsigned completionParameterIndex,
-                       Optional<unsigned> completionErrorParameterIndex)
-      : Value(1
-              + (unsigned(IsAsync) - 1)
-              + (unsigned(completionParameterIndex) << 1)
-              + ((completionErrorParameterIndex ? *completionErrorParameterIndex + 1
-                                                : 0) << 21)) {
-        assert(getKind() == IsAsync);
-        assert(getAsyncCompletionHandlerParamIndex() == completionParameterIndex);
-        assert(getAsyncCompletionHandlerErrorParamIndex() == completionErrorParameterIndex);
-      }
+                       Optional<unsigned> completionErrorParameterIndex,
+                       Optional<unsigned> completionErrorFlagParameterIndex,
+                       bool completionErrorFlagIsZeroOnError)
+    : Value(1
+      + (unsigned(IsAsync) - 1)
+      + (unsigned(completionParameterIndex) << AsyncCompletionParameterIndexShift)
+      + ((completionErrorParameterIndex ? *completionErrorParameterIndex + 1
+                                        : 0) << AsyncCompletionErrorParameterIndexShift)
+      + ((completionErrorFlagParameterIndex ? *completionErrorFlagParameterIndex + 1
+                                            : 0) << AsyncCompletionErrorFlagParameterIndexShift)
+      + (unsigned(completionErrorFlagIsZeroOnError) << AsyncCompletionErrorFlagParameterPolarityShift)){
+
+      assert(getKind() == IsAsync);
+      assert(getAsyncCompletionHandlerParamIndex() == completionParameterIndex);
+      assert(getAsyncCompletionHandlerErrorParamIndex() == completionErrorParameterIndex);
+      assert(getAsyncCompletionHandlerErrorFlagParamIndex() == completionErrorFlagParameterIndex);
+      assert(isCompletionErrorFlagZeroOnError() == completionErrorFlagIsZeroOnError);
+    }
 
   public:
     static EncodedForeignInfo
@@ -345,18 +367,37 @@ class AbstractionPattern {
 
     unsigned getAsyncCompletionHandlerParamIndex() const {
       assert(getKind() == IsAsync);
-      return ((Value - 1) >> 1) & 0xFFFFFu;
+      return ((Value - 1) & AsyncCompletionParameterIndexMask)
+        >> AsyncCompletionParameterIndexShift;
     }
 
     Optional<unsigned> getAsyncCompletionHandlerErrorParamIndex() const {
       assert(getKind() == IsAsync);
 
-      unsigned encodedValue = (Value - 1) >> 21;
+      unsigned encodedValue = ((Value - 1) & AsyncCompletionErrorParameterIndexMask)
+        >> AsyncCompletionErrorParameterIndexShift;
+      if (encodedValue == 0) {
+        return llvm::None;
+      }
+      return encodedValue - 1;
+    }
+
+    Optional<unsigned> getAsyncCompletionHandlerErrorFlagParamIndex() const {
+      assert(getKind() == IsAsync);
+
+      unsigned encodedValue = ((Value - 1) & AsyncCompletionErrorFlagParameterIndexMask)
+        >> AsyncCompletionErrorFlagParameterIndexShift;
       if (encodedValue == 0) {
         return llvm::None;
       }
       return encodedValue - 1;
     }
+    
+    bool isCompletionErrorFlagZeroOnError() const {
+      assert(getKind() == IsAsync);
+
+      return (Value - 1) & AsyncCompletionErrorFlagParameterPolarityMask;
+    }
 
     unsigned getForeignParamIndex() const {
       switch (getKind()) {

include/swift/SIL/MemoryLifetime.h

@@ -114,6 +114,11 @@ class MemoryLocations {
     /// Bit 2 is never set because Inner is completly represented by its
     /// sub-locations 3 and 4. But bit 0 is set in location 0 (the "self" bit),
     /// because it represents the untracked field ``Outer.z``.
+    ///
+    /// Single-payload enums are represented by a location with a single sub-
+    /// location (the projected payload address, i.e. an ``init_enum_data_addr``
+    /// or an ``unchecked_take_enum_data_addr``.
+    /// Multi-payload enums are not supported right now.
     Bits subLocations;
 
     /// The accumulated parent bits, including the "self" bit.
@@ -142,6 +147,12 @@ class MemoryLocations {
     /// \endcode
     int parentIdx;
 
+    /// Returns true if the location with index \p idx is this location or a
+    /// sub location of this location.
+    bool isSubLocation(unsigned idx) const {
+      return idx < subLocations.size() && subLocations.test(idx);
+    }
+
   private:
     friend class MemoryLocations;
 
@@ -178,11 +189,18 @@ class MemoryLocations {
   /// small. They can be handled separately with handleSingleBlockLocations().
   llvm::SmallVector<SingleValueInstruction *, 16> singleBlockLocations;
 
+  /// A Cache for single-payload enums.
+  llvm::DenseMap<SILType, EnumElementDecl *> singlePayloadEnums;
+
   /// The bit-set of locations for which numNonTrivialFieldsNotCovered is > 0.
   Bits nonTrivialLocations;
 
+  /// If true, support init_enum_data_addr and unchecked_take_enum_data_addr
+  bool handleEnumDataProjections;
+
 public:
-  MemoryLocations() {}
+  MemoryLocations(bool handleEnumDataProjections) :
+    handleEnumDataProjections(handleEnumDataProjections) {}
 
   MemoryLocations(const MemoryLocations &) = delete;
   MemoryLocations &operator=(const MemoryLocations &) = delete;
@@ -207,6 +225,9 @@ class MemoryLocations {
   const Location *getLocation(unsigned index) const {
     return &locations[index];
   }
+  
+  /// Returns the root location of \p index.
+  const Location *getRootLocation(unsigned index) const;
 
   /// Registers an address projection instruction for a location.
   void registerProjection(SingleValueInstruction *projection, unsigned locIdx) {
@@ -262,6 +283,15 @@ class MemoryLocations {
   // (locationIdx, fieldNr) -> subLocationIdx
   using SubLocationMap = llvm::DenseMap<std::pair<unsigned, unsigned>, unsigned>;
 
+  /// Returns the payload case of a single-payload enum.
+  ///
+  /// Returns null if \p enumTy is not a single-payload enum.
+  /// We are currently only handling enum data projections for single-payload
+  /// enums, because it's much simpler to represent them with Locations. We
+  /// could also support multi-payload enums, but that gets complicated. Most
+  /// importantly, we can handle Swift.Optional.
+  EnumElementDecl *getSinglePayloadEnumCase(SILType enumTy);
+
   /// Helper function called by analyzeLocation to check all uses of the
   /// location recursively.
   ///