Merge pull request #5203 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

docs/HowToGuides/GettingStarted.md

@@ -187,7 +187,7 @@ toolchain as a one-off, there are a couple of differences:
 
 ### Spot check dependencies
 
-* Run `cmake --version`; this should be 3.19.6 or higher.
+* Run `cmake --version`; this should be at least 3.19.6 (3.22.2 if you want to generate an Xcode project on macOS).
 * Run `python3 --version`; check that this succeeds.
 * Run `ninja --version`; check that this succeeds.
 * If you installed and want to use Sccache: Run `sccache --version`; check

include/swift/AST/AccessScope.h

@@ -20,20 +20,40 @@
 
 namespace swift {
 
+/// Used to provide the kind of scope limitation in AccessScope::Value
+enum class AccessLimitKind : uint8_t { None = 0, Private, Package };
+
 /// The wrapper around the outermost DeclContext from which
 /// a particular declaration can be accessed.
 class AccessScope {
-  /// The declaration context (if not public) along with a bit saying
-  /// whether this scope is private, SPI or not.
-  /// If the declaration context is set, the bit means that the scope is
-  /// private or not. If the declaration context is null, the bit means that
-  /// this scope is SPI or not.
-  llvm::PointerIntPair<const DeclContext *, 1, bool> Value;
+  /// The declaration context along with an enum indicating the level of
+  /// scope limitation.
+  /// If the declaration context is set, and the limit kind is Private, the
+  /// access level is considered 'private'. Whether it's 'internal' or
+  /// 'fileprivate' is determined by what the declaration context casts to. If
+  /// the declaration context is null, and the limit kind is None, the access
+  /// level is considered 'public'. If the limit kind is Private, the access
+  /// level is considered SPI. If it's Package, the access level is considered
+  /// 'package'. Below is a table showing the combinations.
+  ///
+  /// AccessLimitKind       DC == nullptr               DC != nullptr
+  /// ---------------------------------------------------------------------------
+  ///  None                    public                  fileprivate or internal (check DC to tell which)
+  ///  Private               `@_spi` public                private
+  ///  Package                 package                    (unused)
+
+  llvm::PointerIntPair<const DeclContext *, 2, AccessLimitKind> Value;
 
 public:
-  AccessScope(const DeclContext *DC, bool isPrivate = false);
+  AccessScope(const DeclContext *DC,
+              AccessLimitKind limitKind = AccessLimitKind::None);
 
-  static AccessScope getPublic() { return AccessScope(nullptr, false); }
+  static AccessScope getPublic() {
+    return AccessScope(nullptr, AccessLimitKind::None);
+  }
+  static AccessScope getPackage() {
+    return AccessScope(nullptr, AccessLimitKind::Package);
+  }
 
   /// Check if private access is allowed. This is a lexical scope check in Swift
   /// 3 mode. In Swift 4 mode, declarations and extensions of the same type will
@@ -46,25 +66,46 @@ class AccessScope {
   bool operator==(AccessScope RHS) const { return Value == RHS.Value; }
   bool operator!=(AccessScope RHS) const { return !(*this == RHS); }
   bool hasEqualDeclContextWith(AccessScope RHS) const {
+    if (isPublic())
+      return RHS.isPublic();
+    if (isPackage())
+      return RHS.isPackage();
     return getDeclContext() == RHS.getDeclContext();
   }
 
-  bool isPublic() const { return !Value.getPointer(); }
-  bool isPrivate() const { return Value.getPointer() && Value.getInt(); }
+  bool isPublic() const {
+    return !Value.getPointer() && Value.getInt() == AccessLimitKind::None;
+  }
+  bool isPrivate() const {
+    return Value.getPointer() && Value.getInt() == AccessLimitKind::Private;
+  }
   bool isFileScope() const;
   bool isInternal() const;
+  bool isPackage() const {
+    return !Value.getPointer() && Value.getInt() == AccessLimitKind::Package;
+  }
 
-  /// Returns true if this is a child scope of the specified other access scope.
-  ///
+  /// Returns true if this scope is more restrictive than the argument scope.
+  /// It's often used to compute the min access scope. The order of restrictiveness
+  /// is: private (most restrictive), fileprivate, internal, package, public (least restrictive).
   /// \see DeclContext::isChildContextOf
   bool isChildOf(AccessScope AS) const {
-    if (!isPublic() && !AS.isPublic())
-      return allowsPrivateAccess(getDeclContext(), AS.getDeclContext());
-    if (isPublic() && AS.isPublic())
-      return false;
-    return AS.isPublic();
+    if (isInternalOrLess()) {
+      if (AS.isInternalOrLess())
+        return allowsPrivateAccess(getDeclContext(), AS.getDeclContext());
+      else
+        return AS.isPackage() || AS.isPublic();
+    }
+    if (isPackage())
+      return AS.isPublic();
+
+    // If this is public, it can't be less than access level of AS
+    // so return false
+    return false;
   }
 
+  bool isInternalOrLess() const { return getDeclContext() != nullptr; }
+
   /// Returns the associated access level for diagnostic purposes.
   AccessLevel accessLevelForDiagnostics() const;
 

include/swift/AST/Availability.h

@@ -224,6 +224,9 @@ class UnavailabilityReason {
 /// See #unionWith, #intersectWith, and #constrainWith.
 ///
 /// [lattice]: http://mathworld.wolfram.com/Lattice.html
+///
+/// NOTE: Generally you should use the utilities on \c AvailabilityInference
+/// to create an \c AvailabilityContext, rather than creating one directly.
 class AvailabilityContext {
   VersionRange OSVersion;
   llvm::Optional<bool> SPI;
@@ -345,6 +348,13 @@ class AvailabilityInference {
   ///  We assume a declaration without an annotation is always available.
   static AvailabilityContext availableRange(const Decl *D, ASTContext &C);
 
+  /// Returns the availability context for a declaration with the given
+  /// @available attribute.
+  ///
+  /// NOTE: The attribute must be active on the current platform.
+  static AvailabilityContext availableRange(const AvailableAttr *attr,
+                                            ASTContext &C);
+
   /// Returns the attribute that should be used to determine the availability
   /// range of the given declaration, or nullptr if there is none.
   static const AvailableAttr *attrForAnnotatedAvailableRange(const Decl *D,

include/swift/AST/IRGenOptions.h

@@ -422,6 +422,9 @@ class IRGenOptions {
   /// Collocate metadata functions in their own section.
   unsigned CollocatedMetadataFunctions : 1;
 
+  /// Use relative (and constant) protocol witness tables.
+  unsigned UseRelativeProtocolWitnessTables : 1;
+
   /// The number of threads for multi-threaded code generation.
   unsigned NumThreads = 0;
 
@@ -493,7 +496,8 @@ class IRGenOptions {
         InternalizeAtLink(false), InternalizeSymbols(false),
         EmitGenericRODatas(false), NoPreallocatedInstantiationCaches(false),
         DisableReadonlyStaticObjects(false),
-        CollocatedMetadataFunctions(false), CmdArgs(),
+        CollocatedMetadataFunctions(false),
+        UseRelativeProtocolWitnessTables(false), CmdArgs(),
         SanitizeCoverage(llvm::SanitizerCoverageOptions()),
         TypeInfoFilter(TypeInfoDumpFilter::All) {
 #ifndef NDEBUG

include/swift/Option/FrontendOptions.td

@@ -1119,6 +1119,13 @@ def disable_collocate_metadata_functions :
   Flag<["-"], "disable-collocate-metadata-functions">,
   HelpText<"Disable collocate metadata functions">;
 
+def enable_relative_protocol_witness_tables :
+  Flag<["-"], "enable-relative-protocol-witness-tables">,
+  HelpText<"Enable relative protocol witness tables">;
+def disable_relative_protocol_witness_tables :
+  Flag<["-"], "disable-relative-protocol-witness-tables">,
+  HelpText<"Disable relative protocol witness tables">;
+
 def enable_new_llvm_pass_manager :
   Flag<["-"], "enable-new-llvm-pass-manager">,
   HelpText<"Enable the new llvm pass manager">;

include/swift/Runtime/Metadata.h

@@ -354,6 +354,11 @@ swift_getWitnessTable(const ProtocolConformanceDescriptor *conformance,
                       const Metadata *type,
                       const void * const *instantiationArgs);
 
+const WitnessTable *
+swift_getWitnessTableRelative(const ProtocolConformanceDescriptor *conformance,
+                      const Metadata *type,
+                      const void * const *instantiationArgs);
+
 /// Retrieve an associated type witness from the given witness table.
 ///
 /// \param wtable The witness table.
@@ -369,6 +374,13 @@ MetadataResponse swift_getAssociatedTypeWitness(
                                           const Metadata *conformingType,
                                           const ProtocolRequirement *reqBase,
                                           const ProtocolRequirement *assocType);
+SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
+MetadataResponse swift_getAssociatedTypeWitnessRelative(
+                                          MetadataRequest request,
+                                          WitnessTable *wtable,
+                                          const Metadata *conformingType,
+                                          const ProtocolRequirement *reqBase,
+                                          const ProtocolRequirement *assocType);
 
 /// Retrieve an associated conformance witness table from the given witness
 /// table.
@@ -388,6 +400,14 @@ const WitnessTable *swift_getAssociatedConformanceWitness(
                                   const ProtocolRequirement *reqBase,
                                   const ProtocolRequirement *assocConformance);
 
+SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
+const WitnessTable *swift_getAssociatedConformanceWitnessRelative(
+                                  WitnessTable *wtable,
+                                  const Metadata *conformingType,
+                                  const Metadata *assocType,
+                                  const ProtocolRequirement *reqBase,
+                                  const ProtocolRequirement *assocConformance);
+
 /// Determine whether two protocol conformance descriptors describe the same
 /// conformance of a type to a protocol.
 ///

include/swift/Runtime/RuntimeFunctions.def

@@ -907,6 +907,13 @@ FUNCTION(GetWitnessTable, swift_getWitnessTable, C_CC, AlwaysAvailable,
               WitnessTablePtrPtrTy),
          ATTRS(NoUnwind, ReadOnly),
          EFFECT(MetaData)) // ?
+FUNCTION(GetWitnessTableRelative, swift_getWitnessTableRelative, C_CC, AlwaysAvailable,
+         RETURNS(WitnessTablePtrTy),
+         ARGS(ProtocolConformanceDescriptorPtrTy,
+              TypeMetadataPtrTy,
+              WitnessTablePtrPtrTy),
+         ATTRS(NoUnwind, ReadOnly),
+         EFFECT(MetaData)) // ?
 
 // MetadataResponse swift_getAssociatedTypeWitness(
 //                                            MetadataRequest request,
@@ -924,6 +931,16 @@ FUNCTION(GetAssociatedTypeWitness, swift_getAssociatedTypeWitness,
               ProtocolRequirementStructTy->getPointerTo()),
          ATTRS(NoUnwind, ReadNone, WillReturn),
          EFFECT(MetaData)) // ?
+FUNCTION(GetAssociatedTypeWitnessRelative, swift_getAssociatedTypeWitnessRelative,
+         SwiftCC, AlwaysAvailable,
+         RETURNS(TypeMetadataResponseTy),
+         ARGS(SizeTy,
+              WitnessTablePtrTy,
+              TypeMetadataPtrTy,
+              ProtocolRequirementStructTy->getPointerTo(),
+              ProtocolRequirementStructTy->getPointerTo()),
+         ATTRS(NoUnwind, ReadNone, WillReturn),
+         EFFECT(MetaData)) // ?
 
 // SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
 // const WitnessTable *swift_getAssociatedConformanceWitness(
@@ -942,6 +959,16 @@ FUNCTION(GetAssociatedConformanceWitness,
               ProtocolRequirementStructTy->getPointerTo()),
          ATTRS(NoUnwind, ReadNone, WillReturn),
          EFFECT(MetaData)) // ?
+FUNCTION(GetAssociatedConformanceWitnessRelative,
+         swift_getAssociatedConformanceWitnessRelative, SwiftCC, AlwaysAvailable,
+         RETURNS(WitnessTablePtrTy),
+         ARGS(WitnessTablePtrTy,
+              TypeMetadataPtrTy,
+              TypeMetadataPtrTy,
+              ProtocolRequirementStructTy->getPointerTo(),
+              ProtocolRequirementStructTy->getPointerTo()),
+         ATTRS(NoUnwind, ReadNone, WillReturn),
+         EFFECT(MetaData)) // ?
 
 // SWIFT_RUNTIME_EXPORT
 //     SWIFT_CC(swift) bool swift_compareProtocolConformanceDescriptors(

lib/AST/Availability.cpp

@@ -229,9 +229,7 @@ AvailabilityInference::annotatedAvailableRange(const Decl *D, ASTContext &Ctx) {
   if (!bestAvailAttr)
     return None;
 
-  return AvailabilityContext{
-    VersionRange::allGTE(bestAvailAttr->Introduced.value()),
-    bestAvailAttr->IsSPI};
+  return availableRange(bestAvailAttr, Ctx);
 }
 
 bool Decl::isAvailableAsSPI() const {
@@ -283,11 +281,8 @@ AvailabilityInference::annotatedAvailableRangeForAttr(const SpecializeAttr* attr
       bestAvailAttr = availAttr;
   }
 
-  if (bestAvailAttr) {
-    return AvailabilityContext{
-      VersionRange::allGTE(bestAvailAttr->Introduced.value())
-    };
-  }
+  if (bestAvailAttr)
+    return availableRange(bestAvailAttr, ctx);
 
   return AvailabilityContext::alwaysAvailable();
 }
@@ -320,6 +315,14 @@ AvailabilityContext AvailabilityInference::availableRange(const Decl *D,
   return AvailabilityContext::alwaysAvailable();
 }
 
+AvailabilityContext
+AvailabilityInference::availableRange(const AvailableAttr *attr,
+                                      ASTContext &Ctx) {
+  assert(attr->isActivePlatform(Ctx));
+  return AvailabilityContext{VersionRange::allGTE(attr->Introduced.value()),
+                             attr->IsSPI};
+}
+
 namespace {
 /// Infers the availability required to access a type.
 class AvailabilityInferenceTypeWalker : public TypeWalker {

lib/AST/Decl.cpp

@@ -3732,11 +3732,13 @@ getAccessScopeForFormalAccess(const ValueDecl *VD,
   while (!resultDC->isModuleScopeContext()) {
     if (isa<TopLevelCodeDecl>(resultDC)) {
       return AccessScope(resultDC->getModuleScopeContext(),
-                         access == AccessLevel::Private);
+                         access == AccessLevel::Private
+                             ? AccessLimitKind::Private
+                             : AccessLimitKind::None);
     }
 
     if (resultDC->isLocalContext() || access == AccessLevel::Private)
-      return AccessScope(resultDC, /*private*/true);
+      return AccessScope(resultDC, AccessLimitKind::Private);
 
     if (auto enclosingNominal = dyn_cast<GenericTypeDecl>(resultDC)) {
       auto enclosingAccess =
@@ -3767,7 +3769,9 @@ getAccessScopeForFormalAccess(const ValueDecl *VD,
   case AccessLevel::Private:
   case AccessLevel::FilePrivate:
     assert(resultDC->isModuleScopeContext());
-    return AccessScope(resultDC, access == AccessLevel::Private);
+    return AccessScope(resultDC, access == AccessLevel::Private
+                                     ? AccessLimitKind::Private
+                                     : AccessLimitKind::None);
   case AccessLevel::Internal:
     return AccessScope(resultDC->getParentModule());
   case AccessLevel::Public:

lib/AST/DeclContext.cpp

@@ -1180,11 +1180,13 @@ getPrivateDeclContext(const DeclContext *DC, const SourceFile *useSF) {
   return lastExtension ? lastExtension : DC;
 }
 
-AccessScope::AccessScope(const DeclContext *DC, bool isPrivate)
-    : Value(DC, isPrivate) {
-  if (isPrivate) {
+AccessScope::AccessScope(const DeclContext *DC, AccessLimitKind limitKind)
+    : Value(DC, limitKind) {
+  auto isPrivate = false;
+  if (limitKind == AccessLimitKind::Private) {
     DC = getPrivateDeclContext(DC, DC->getParentSourceFile());
     Value.setPointer(DC);
+    isPrivate = true;
   }
   if (!DC || isa<ModuleDecl>(DC))
     assert(!isPrivate && "public or internal scope can't be private");

lib/Frontend/CompilerInvocation.cpp

@@ -2482,6 +2482,10 @@ static bool ParseIRGenArgs(IRGenOptions &Opts, ArgList &Args,
       Args.hasFlag(OPT_enable_collocate_metadata_functions,
                    OPT_disable_collocate_metadata_functions,
                    Opts.CollocatedMetadataFunctions);
+  Opts.UseRelativeProtocolWitnessTables =
+    Args.hasFlag(OPT_enable_relative_protocol_witness_tables,
+                 OPT_disable_relative_protocol_witness_tables,
+                 Opts.UseRelativeProtocolWitnessTables);
   return false;
 }
 

lib/IRGen/GenOpaque.cpp

@@ -308,9 +308,20 @@ llvm::PointerType *IRGenModule::getEnumValueWitnessTablePtrTy() {
 
 Address irgen::slotForLoadOfOpaqueWitness(IRGenFunction &IGF,
                                           llvm::Value *table,
-                                          WitnessIndex index) {
+                                          WitnessIndex index,
+                                          bool areEntriesRelative) {
   assert(table->getType() == IGF.IGM.WitnessTablePtrTy);
 
+  // Are we loading from a relative protocol witness table.
+  if (areEntriesRelative) {
+    llvm::Value *slot =
+      IGF.Builder.CreateBitOrPointerCast(table, IGF.IGM.RelativeAddressPtrTy);
+    if (index.getValue() != 0)
+      slot = IGF.Builder.CreateConstInBoundsGEP1_32(IGF.IGM.RelativeAddressTy,
+                                                    slot, index.getValue());
+    return Address(slot, IGF.IGM.RelativeAddressTy, Alignment(4));
+  }
+
   // GEP to the appropriate index, avoiding spurious IR in the trivial case.
   llvm::Value *slot = table;
   if (index.getValue() != 0)
@@ -326,8 +337,12 @@ llvm::Value *irgen::emitInvariantLoadOfOpaqueWitness(IRGenFunction &IGF,
                                                      llvm::Value *table,
                                                      WitnessIndex index,
                                                      llvm::Value **slotPtr) {
-  auto slot = slotForLoadOfOpaqueWitness(IGF, table, index);
+  auto isRelativeTable = IGF.IGM.IRGen.Opts.UseRelativeProtocolWitnessTables;
+  auto slot = slotForLoadOfOpaqueWitness(IGF, table, index, isRelativeTable);
   if (slotPtr) *slotPtr = slot.getAddress();
+  if (isRelativeTable) {
+    return IGF.emitLoadOfRelativePointer(slot, false, IGF.IGM.Int8Ty);
+  }
   return IGF.emitInvariantLoad(slot);
 }