Merge pull request #4755 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

SwiftCompilerSources/CMakeLists.txt

@@ -295,8 +295,6 @@ else()
       set(compatibility_libs
           "swiftCompatibility50-${platform}"
           "swiftCompatibility51-${platform}"
-          "swiftCompatibility56-${platform}"
-          "swiftCompatibilityConcurrency-${platform}"
           "swiftCompatibilityDynamicReplacements-${platform}")
 
       list(APPEND b0_deps ${compatibility_libs})

docs/CppInteroperability/SwiftTypeRepresentationInC++.md

@@ -8,7 +8,7 @@ C++.
 
 ### Value Types
 
-1) Primitive Swift types like `Int`, `Float` , `OpaquePointer`, `UnsafePointer<int>?` are mapped to primitive C++ types. `int` , `float`, `void *`, int `* _Nullable` .
+1) Primitive Swift types like `Int`, `Float` , `OpaquePointer`, `UnsafePointer<int>?` are mapped to primitive C++ types. `int` , `float`, `void *`, `int * _Nullable`.
 
 * Debug info: Does C++ debug info suffices?
 
@@ -29,13 +29,23 @@ class swift::String {
 ```c++
 class Foundation::URL {
   ...
-  union {
-    alignas(8) char buffer[8]; // Swift value is stored here.
-    void *resilientPtr;
-  };
+  uintptr_t pointer;         // pointer has alignment to compute buffer offset?
+  alignas(N) char buffer[M]; // Swift value is stored here.
 };
 ```
 
+concrete examples:
+
+```c++
+// representation for buffer aligned at 8:
+{/*pointer=*/0x3, ....}; // buffer is alignas(2^3 = 8)
+
+// representation for buffer aligned at 16:
+{/*pointer=*/0x4, ....}; // buffer is alignas(2^4 = 16)
+
+// where pointer < 10 for inline stores.
+```
+
 * Debug info: ...
 
 
@@ -44,10 +54,8 @@ class Foundation::URL {
 ```c++
 class CryptoKit::SHA256 {
   ...
-  union {
-    alignas(8) char buffer[8]; 
-    void *resilientPtr;        // Swift value is stored on the heap pointed by this pointer.
-  };
+  uintptr_t pointer;         // Swift value is stored on the heap pointed by this pointer.
+  alignas(8) char buffer[8];
 };
 ```
 
@@ -66,15 +74,13 @@ class swift::Array<swift::Int> {
 * Debug info: ...
 
 
-6) Generic opaque-layout / resilient / opaque-layout template type params Swift value type, e.g. SHA256`?`, is mapped to a C++ class that stores the value boxed up on the heap, e.g.:
+6) Generic opaque-layout / resilient / opaque-layout template type params Swift value type, e.g. `SHA256?`, is mapped to a C++ class that stores the value boxed up on the heap, e.g.:
 
 ```c++
 class swift::Optional<CryptoKit::SHA256> {
   ...
-  union {
-    alignas(8) char buffer[8]; 
-    void *resilientPtr;        // Swift value is stored on the heap pointed by this pointer.
-  };
+  uintptr_t pointer;        // Swift value is stored on the heap pointed by this pointer.
+  alignas(N) char buffer[M];
 }
 ```
 

docs/Lexicon.md

@@ -49,7 +49,7 @@ thunk helpers" sometimes seen in Swift backtraces come from.)
 
 Broadly, an "access path" is a list of "accesses" which must be chained together
 to compute some output from an input. For instance, the generics system has a
-type called a `ConformanceAccessPath` which explains how to, for example,
+type called a `ConformancePath` which explains how to, for example,
 walk from `T: Collection` to `T: Sequence` to `T.Iterator: IteratorProtocol`.
 There are several different kinds of "access path" in different parts of the compiler,
 but they all follow this basic theme.

include/swift/AST/ASTMangler.h

@@ -25,7 +25,7 @@ class NamedDecl;
 namespace swift {
 
 class AbstractClosureExpr;
-class ConformanceAccessPath;
+class ConformancePath;
 class RootProtocolConformance;
 
 namespace Mangle {
@@ -560,7 +560,7 @@ class ASTMangler : public Mangler {
   void appendConcreteProtocolConformance(
                                         const ProtocolConformance *conformance,
                                         GenericSignature sig);
-  void appendDependentProtocolConformance(const ConformanceAccessPath &path,
+  void appendDependentProtocolConformance(const ConformancePath &path,
                                           GenericSignature sig);
   void appendOpParamForLayoutConstraint(LayoutConstraint Layout);
 

include/swift/AST/GenericSignature.h

@@ -70,7 +70,7 @@ namespace rewriting {
 /// \c Sequence conformance of \c C (because \c Collection inherits
 /// \c Sequence). Finally, it extracts the conformance of the associated type
 /// \c Iterator to \c IteratorProtocol from the \c Sequence protocol.
-class ConformanceAccessPath {
+class ConformancePath {
 public:
   /// An entry in the conformance access path, which is described by the
   /// dependent type on which the conformance is stated as the protocol to
@@ -80,7 +80,7 @@ class ConformanceAccessPath {
 private:
   ArrayRef<Entry> path;
 
-  ConformanceAccessPath(ArrayRef<Entry> path) : path(path) {}
+  ConformancePath(ArrayRef<Entry> path) : path(path) {}
 
   friend class GenericSignatureImpl;
   friend class rewriting::RequirementMachine;
@@ -213,9 +213,9 @@ class GenericSignature {
   SmallVector<Requirement, 4>
   requirementsNotSatisfiedBy(GenericSignature otherSig) const;
 
-  /// Return the canonical version of the given type under this generic
+  /// Return the reduced version of the given type under this generic
   /// signature.
-  CanType getCanonicalTypeInContext(Type type) const;
+  CanType getReducedType(Type type) const;
 
   /// Check invariants.
   void verify() const;
@@ -383,7 +383,7 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   /// generic signature.
   ///
   /// The type parameters must be known to not be concrete within the context.
-  bool areSameTypeParameterInContext(Type type1, Type type2) const;
+  bool areReducedTypeParametersEqual(Type type1, Type type2) const;
 
   /// Determine if \c sig can prove \c requirement, meaning that it can deduce
   /// T: Foo or T == U (etc.) with the information it knows. This includes
@@ -392,26 +392,26 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   bool isRequirementSatisfied(
       Requirement requirement, bool allowMissing = false) const;
 
-  bool isCanonicalTypeInContext(Type type) const;
+  bool isReducedType(Type type) const;
 
   /// Determine whether the given type parameter is defined under this generic
   /// signature.
-  bool isValidTypeInContext(Type type) const;
+  bool isValidTypeParameter(Type type) const;
 
-  /// Retrieve the conformance access path used to extract the conformance of
+  /// Retrieve the conformance path used to extract the conformance of
   /// interface \c type to the given \c protocol.
   ///
-  /// \param type The interface type whose conformance access path is to be
+  /// \param type The type parameter whose conformance path is to be
   /// queried.
   /// \param protocol A protocol to which \c type conforms.
   ///
-  /// \returns the conformance access path that starts at a requirement of
+  /// \returns the conformance path that starts at a requirement of
   /// this generic signature and ends at the conformance that makes \c type
   /// conform to \c protocol.
   ///
-  /// \seealso ConformanceAccessPath
-  ConformanceAccessPath getConformanceAccessPath(Type type,
-                                                 ProtocolDecl *protocol) const;
+  /// \seealso ConformancePath
+  ConformancePath getConformancePath(Type type,
+                                     ProtocolDecl *protocol) const;
 
   /// Lookup a nested type with the given name within this type parameter.
   TypeDecl *lookupNestedType(Type type, Identifier name) const;
@@ -487,9 +487,9 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   SmallVector<Requirement, 4>
   requirementsNotSatisfiedBy(GenericSignature otherSig) const;
 
-  /// Return the canonical version of the given type under this generic
+  /// Return the reduced version of the given type under this generic
   /// signature.
-  CanType getCanonicalTypeInContext(Type type) const;
+  CanType getReducedType(Type type) const;
 };
 
 void simple_display(raw_ostream &out, GenericSignature sig);

include/swift/AST/Types.h

@@ -503,9 +503,9 @@ class alignas(1 << TypeAlignInBits) TypeBase
     return const_cast<TypeBase*>(this)->computeCanonicalType();
   }
 
-  /// getCanonicalType - Stronger canonicalization which folds away equivalent
+  /// getReducedType - Stronger canonicalization which folds away equivalent
   /// associated types, or type parameters that have been made concrete.
-  CanType getCanonicalType(GenericSignature sig);
+  CanType getReducedType(GenericSignature sig);
 
   /// Canonical protocol composition types are minimized only to a certain
   /// degree to preserve ABI compatibility. This routine enables performing

include/swift/Basic/Statistics.def

@@ -230,16 +230,8 @@ FRONTEND_STATISTIC(Sema, NumRequirementMachineCompletionSteps)
 /// Number of new rules added by concrete term unification.
 FRONTEND_STATISTIC(Sema, NumRequirementMachineUnifiedConcreteTerms)
 
-/// Number of generic signature builders constructed. Rough proxy for
-/// amount of work the GSB does analyzing type signatures.
-FRONTEND_STATISTIC(Sema, NumGenericSignatureBuilders)
-
-/// Number of steps in the GSB's redundant requirements algorithm, which is in
-/// the worst-case exponential.
-FRONTEND_STATISTIC(Sema, NumRedundantRequirementSteps)
-
-/// Number of conformance access paths we had to compute.
-FRONTEND_STATISTIC(Sema, NumConformanceAccessPathsRecorded)
+/// Number of conformance paths we had to compute.
+FRONTEND_STATISTIC(Sema, NumConformancePathsRecorded)
 
 /// Number of lazy requirement signatures registered.
 FRONTEND_STATISTIC(Sema, NumLazyRequirementSignatures)

include/swift/Frontend/BackDeploymentLibs.def

@@ -28,6 +28,5 @@ 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, 4), all, "swiftCompatibilityConcurrency")
-BACK_DEPLOYMENT_LIB((5, 6), all, "swiftCompatibility56")
 
 #undef BACK_DEPLOYMENT_LIB

include/swift/SIL/AbstractionPattern.h

@@ -514,7 +514,7 @@ class AbstractionPattern {
     OrigType = origType;
     GenericSig = CanGenericSignature();
     if (OrigType->hasTypeParameter()) {
-      assert(OrigType == signature.getCanonicalTypeInContext(origType));
+      assert(OrigType == signature.getReducedType(origType));
       GenericSig = signature;
     }
   }

include/swift/SIL/SILGlobalVariable.h

@@ -125,6 +125,12 @@ class SILGlobalVariable
     return getLoweredTypeInContext(context).castTo<SILFunctionType>();
   }
 
+  void unsafeSetLoweredType(SILType newType) { LoweredType = newType; }
+  void unsafeAppend(SILInstruction *i) { StaticInitializerBlock.push_back(i); }
+  void unsafeRemove(SILInstruction *i, SILModule &mod) {
+    StaticInitializerBlock.erase(i, mod);
+  }
+
   StringRef getName() const { return Name; }
 
   void setDeclaration(bool isD) { IsDeclaration = isD; }