Protocol resilience preliminaries

include/swift/ABI/MetadataValues.h

@@ -980,6 +980,27 @@ static inline bool isValueWitnessTableMutable(StructLayoutFlags flags) {
   return uintptr_t(flags) & uintptr_t(StructLayoutFlags::IsVWTMutable);
 }
 
+/// Flags for class layout.
+enum class ClassLayoutFlags : uintptr_t {
+  /// Reserve space for 256 layout algorithms.
+  AlgorithmMask     = 0xff,
+
+  /// The ABI baseline algorithm, i.e. the algorithm implemented in Swift 5.
+  Swift5Algorithm   = 0x00,
+};
+static inline ClassLayoutFlags operator|(ClassLayoutFlags lhs,
+                                         ClassLayoutFlags rhs) {
+  return ClassLayoutFlags(uintptr_t(lhs) | uintptr_t(rhs));
+}
+static inline ClassLayoutFlags &operator|=(ClassLayoutFlags &lhs,
+                                           ClassLayoutFlags rhs) {
+  return (lhs = (lhs | rhs));
+}
+static inline ClassLayoutFlags getLayoutAlgorithm(ClassLayoutFlags flags) {
+  return ClassLayoutFlags(uintptr_t(flags)
+                             & uintptr_t(ClassLayoutFlags::AlgorithmMask));
+}
+
 /// Flags for enum layout.
 enum class EnumLayoutFlags : uintptr_t {
   /// Reserve space for 256 layout algorithms.

include/swift/Runtime/Metadata.h

@@ -1896,11 +1896,27 @@ struct TargetLiteralProtocolDescriptorList
 };
 using LiteralProtocolDescriptorList = TargetProtocolDescriptorList<InProcess>;
 
+/// A protocol requirement descriptor. This describes a single protocol
+/// requirement in a protocol descriptor. The index of the requirement in
+/// the descriptor determines the offset of the witness in a witness table
+/// for this protocol.
 template <typename Runtime>
 struct TargetProtocolRequirement {
   ProtocolRequirementFlags Flags;
   // TODO: name, type
 
+  /// A function pointer to a global symbol which is used by client code
+  /// to invoke the protocol requirement from a witness table. This pointer
+  /// is also to uniquely identify the requirement in resilient witness
+  /// tables, which is why it appears here.
+  ///
+  /// This forms the basis of our mechanism to hide witness table offsets
+  /// from clients, both when calling protocol requirements and when
+  /// defining witness tables.
+  ///
+  /// Will be null if the protocol is not resilient.
+  RelativeDirectPointer<void, /*nullable*/ true> Function;
+
   /// The optional default implementation of the protocol.
   RelativeDirectPointer<void, /*nullable*/ true> DefaultImplementation;
 };
@@ -4075,10 +4091,11 @@ swift_relocateClassMetadata(ClassMetadata *self,
 /// Initialize the field offset vector for a dependent-layout class, using the
 /// "Universal" layout strategy.
 SWIFT_RUNTIME_EXPORT
-void swift_initClassMetadata_UniversalStrategy(ClassMetadata *self,
-                                               size_t numFields,
-                                               const TypeLayout * const *fieldTypes,
-                                               size_t *fieldOffsets);
+void swift_initClassMetadata(ClassMetadata *self,
+                             ClassLayoutFlags flags,
+                             size_t numFields,
+                             const TypeLayout * const *fieldTypes,
+                             size_t *fieldOffsets);
 
 /// \brief Fetch a uniqued metadata for a metatype type.
 SWIFT_RUNTIME_EXPORT

include/swift/Runtime/RuntimeFunctions.def

@@ -914,14 +914,15 @@ FUNCTION(RelocateClassMetadata,
          ATTRS(NoUnwind))
 
 // struct FieldInfo { size_t Size; size_t AlignMask; };
-// void swift_initClassMetadata_UniversalStrategy(Metadata *self,
-//                                                size_t numFields,
-//                                                TypeLayout * const *fieldTypes,
-//                                                size_t *fieldOffsets);
-FUNCTION(InitClassMetadataUniversal,
-         swift_initClassMetadata_UniversalStrategy, C_CC,
-         RETURNS(VoidTy),
-         ARGS(TypeMetadataPtrTy, SizeTy,
+// void swift_initClassMetadata(Metadata *self,
+//                              ClassLayoutFlags flags,
+//                              size_t numFields,
+//                              TypeLayout * const *fieldTypes,
+//                              size_t *fieldOffsets);
+FUNCTION(InitClassMetadata,
+         swift_initClassMetadata, C_CC,
+         RETURNS(VoidTy),
+         ARGS(TypeMetadataPtrTy, SizeTy, SizeTy,
               Int8PtrPtrTy->getPointerTo(),
               SizeTy->getPointerTo()),
          ATTRS(NoUnwind))
@@ -934,7 +935,8 @@ FUNCTION(InitClassMetadataUniversal,
 FUNCTION(InitStructMetadata,
          swift_initStructMetadata, C_CC,
          RETURNS(VoidTy),
-         ARGS(TypeMetadataPtrTy, SizeTy, SizeTy, Int8PtrPtrTy->getPointerTo(0),
+         ARGS(TypeMetadataPtrTy, SizeTy, SizeTy,
+              Int8PtrPtrTy->getPointerTo(0),
               SizeTy->getPointerTo()),
          ATTRS(NoUnwind))
 

include/swift/SIL/SILWitnessTable.h

@@ -84,20 +84,13 @@ class SILWitnessTable : public llvm::ilist_node<SILWitnessTable>,
     ProtocolConformance *Witness;
   };
 
-  /// A witness table entry for an optional requirement that is not present.
-  struct MissingOptionalWitness {
-    /// The witness for the optional requirement that wasn't present.
-    ValueDecl *Witness;
-  };
-
   /// A witness table entry kind.
   enum WitnessKind {
     Invalid,
     Method,
     AssociatedType,
     AssociatedTypeProtocol,
-    BaseProtocol,
-    MissingOptional
+    BaseProtocol
   };
 
   /// A witness table entry.
@@ -108,7 +101,6 @@ class SILWitnessTable : public llvm::ilist_node<SILWitnessTable>,
       AssociatedTypeWitness AssociatedType;
       AssociatedTypeProtocolWitness AssociatedTypeProtocol;
       BaseProtocolWitness BaseProtocol;
-      MissingOptionalWitness MissingOptional;
     };
 
   public:
@@ -132,10 +124,6 @@ class SILWitnessTable : public llvm::ilist_node<SILWitnessTable>,
         BaseProtocol(BaseProtocol)
     {}
 
-    Entry(const MissingOptionalWitness &MissingOptional)
-      : Kind(WitnessKind::MissingOptional), MissingOptional(MissingOptional) {
-    }
-
     WitnessKind getKind() const { return Kind; }
 
     const MethodWitness &getMethodWitness() const {
@@ -156,11 +144,6 @@ class SILWitnessTable : public llvm::ilist_node<SILWitnessTable>,
       return BaseProtocol;
     }
 
-    const MissingOptionalWitness &getMissingOptionalWitness() const {
-      assert(Kind == WitnessKind::MissingOptional);
-      return MissingOptional;
-    }
-
     void removeWitnessMethod() {
       assert(Kind == WitnessKind::Method);
       if (Method.Witness) {

lib/IRGen/GenClass.cpp

@@ -1810,9 +1810,8 @@ namespace {
         break;
       }
       case FieldAccess::ConstantIndirect:
-        // Otherwise, swift_initClassMetadata_UniversalStrategy() will point
-        // the Objective-C runtime into the field offset vector of the
-        // instantiated metadata.
+        // Otherwise, swift_initClassMetadata() will point the Objective-C
+        // runtime into the field offset vector of the instantiated metadata.
         offsetPtr
           = llvm::ConstantPointerNull::get(IGM.IntPtrTy->getPointerTo());
         break;

lib/IRGen/GenDecl.cpp

@@ -1633,8 +1633,15 @@ bool LinkEntity::isAvailableExternally(IRGenModule &IGM) const {
   switch (getKind()) {
   case Kind::DispatchThunk:
   case Kind::DispatchThunkInitializer:
-  case Kind::DispatchThunkAllocator:
+  case Kind::DispatchThunkAllocator: {
+    auto *decl = getDecl();
+
+    // Protocol requirements don't have their own access control
+    if (auto *proto = dyn_cast<ProtocolDecl>(decl->getDeclContext()))
+      decl = proto;
+
     return ::isAvailableExternally(IGM, getDecl());
+  }
 
   case Kind::ValueWitnessTable:
   case Kind::TypeMetadata:

lib/IRGen/GenMeta.cpp

@@ -1405,9 +1405,11 @@ void irgen::emitInitializeFieldOffsetVector(IRGenFunction &IGF,
   auto numFields = IGF.IGM.getSize(Size(storedProperties.size()));
 
   if (isa<ClassDecl>(target)) {
-    IGF.Builder.CreateCall(IGF.IGM.getInitClassMetadataUniversalFn(),
-                           {metadata, numFields,
-                            fields.getAddress(), fieldVector});
+    ClassLayoutFlags flags = ClassLayoutFlags::Swift5Algorithm;
+
+    IGF.Builder.CreateCall(IGF.IGM.getInitClassMetadataFn(),
+                           {metadata, IGF.IGM.getSize(Size(uintptr_t(flags))),
+                            numFields, fields.getAddress(), fieldVector});
   } else {
     assert(isa<StructDecl>(target));
     StructLayoutFlags flags = StructLayoutFlags::Swift5Algorithm;
@@ -3555,6 +3557,9 @@ namespace {
         // Flags.
         reqt.addInt32(info.Flags.getIntValue());
 
+        // Dispatch thunk.
+        reqt.addRelativeAddressOrNull(info.Thunk);
+
         // Default implementation.
         reqt.addRelativeAddressOrNull(info.DefaultImpl);
 #ifndef NDEBUG
@@ -3592,6 +3597,7 @@ namespace {
 
     struct RequirementInfo {
       ProtocolRequirementFlags Flags;
+      llvm::Constant *Thunk;
       llvm::Constant *DefaultImpl;
     };
 
@@ -3601,36 +3607,41 @@ namespace {
       if (entry.isBase()) {
         assert(entry.isOutOfLineBase());
         auto flags = Flags(Flags::Kind::BaseProtocol);
-        return { flags, nullptr };
+        return { flags, nullptr, nullptr };
       }
 
       if (entry.isAssociatedType()) {
         auto flags = Flags(Flags::Kind::AssociatedTypeAccessFunction);
-        return { flags, nullptr };
+        return { flags, nullptr, nullptr };
       }
 
       if (entry.isAssociatedConformance()) {
         auto flags = Flags(Flags::Kind::AssociatedConformanceAccessFunction);
-        return { flags, nullptr };
+        return { flags, nullptr, nullptr };
       }
 
       assert(entry.isFunction());
-      auto func = entry.getFunction();
+      SILDeclRef func(entry.getFunction());
+
+      // Look up the dispatch thunk if the protocol is resilient.
+      llvm::Constant *thunk = nullptr;
+      if (Protocol->isResilient())
+        thunk = IGM.getAddrOfDispatchThunk(func, NotForDefinition);
 
       // Classify the function.
-      auto flags = getMethodDescriptorFlags<Flags>(func);
+      auto flags = getMethodDescriptorFlags<Flags>(func.getDecl());
 
       // Look for a default witness.
       llvm::Constant *defaultImpl = findDefaultWitness(func);
 
-      return { flags, defaultImpl };
+      return { flags, thunk, defaultImpl };
     }
 
-    llvm::Constant *findDefaultWitness(AbstractFunctionDecl *func) {
+    llvm::Constant *findDefaultWitness(SILDeclRef func) {
       if (!DefaultWitnesses) return nullptr;
 
       for (auto &entry : DefaultWitnesses->getResilientDefaultEntries()) {
-        if (entry.getRequirement().getDecl() != func)
+        if (entry.getRequirement() != func)
           continue;
         return IGM.getAddrOfSILFunction(entry.getWitness(), NotForDefinition);
       }

lib/IRGen/GenProto.cpp

@@ -730,18 +730,6 @@ void irgen::setProtocolWitnessTableName(IRGenModule &IGM, llvm::Value *wtable,
 }
 
 namespace {
-  /// A concrete witness table, together with its known layout.
-  class WitnessTable {
-    llvm::Value *Table;
-    const ProtocolInfo &Info;
-  public:
-    WitnessTable(llvm::Value *wtable, const ProtocolInfo &info)
-      : Table(wtable), Info(info) {}
-
-    llvm::Value *getTable() const { return Table; }
-    const ProtocolInfo &getInfo() const { return Info; }
-  };
-
   /// A class which lays out a witness table in the abstract.
   class WitnessTableLayout : public SILWitnessVisitor<WitnessTableLayout> {
     SmallVector<WitnessTableEntry, 16> Entries;
@@ -1194,8 +1182,7 @@ class AccessorConformanceInfo : public ConformanceInfo {
         : IGM(IGM), Table(table),
           ConcreteType(SILWT->getConformance()->getDeclContext()
                          ->mapTypeIntoContext(
-                           SILWT->getConformance()->getType()
-                             ->getCanonicalType())
+                           SILWT->getConformance()->getType())
                          ->getCanonicalType()),
           Conformance(*SILWT->getConformance()),
           ConformanceInContext(mapConformanceIntoContext(IGM,
@@ -1271,12 +1258,6 @@ class AccessorConformanceInfo : public ConformanceInfo {
       auto &entry = SILEntries.front();
       SILEntries = SILEntries.slice(1);
 
-      // Handle missing optional requirements.
-      if (entry.getKind() == SILWitnessTable::MissingOptional) {
-        Table.addNullPointer(IGM.Int8PtrTy);
-        return;
-      }
-
 #ifndef NDEBUG
       assert(entry.getKind() == SILWitnessTable::Method
              && "sil witness table does not match protocol");

lib/IRGen/GenThunk.cpp

@@ -50,7 +50,8 @@ IRGenModule::getAddrOfDispatchThunk(SILDeclRef declRef,
   Signature signature = getSignature(fnType);
   LinkInfo link = LinkInfo::get(*this, entity, forDefinition);
 
-  return createFunction(*this, link, signature);
+  entry = createFunction(*this, link, signature);
+  return entry;
 }
 
 static FunctionPointer lookupMethod(IRGenFunction &IGF,

lib/IRGen/IRGenModule.cpp

@@ -217,6 +217,7 @@ IRGenModule::IRGenModule(IRGenerator &irgen,
   ProtocolRequirementStructTy =
       createStructType(*this, "swift.protocol_requirement", {
     Int32Ty,                // flags
+    Int32Ty,                // thunk
     Int32Ty                 // default implementation
   });
 

lib/SIL/SILPrinter.cpp

@@ -2856,13 +2856,6 @@ void SILWitnessTable::print(llvm::raw_ostream &OS, bool Verbose) const {
       baseProtoWitness.Witness->printName(OS, Options);
       break;
     }
-    case MissingOptional: {
-      // optional requirement 'declref': <<not present>>
-      OS << "optional requirement '"
-         << witness.getMissingOptionalWitness().Witness->getBaseName()
-         << "': <<not present>>";
-      break;
-    }
     }
     OS << '\n';
   }

lib/SIL/SILWitnessTable.cpp

@@ -116,7 +116,6 @@ SILWitnessTable::~SILWitnessTable() {
     case AssociatedType:
     case AssociatedTypeProtocol:
     case BaseProtocol:
-    case MissingOptional:
     case Invalid:
       break;
     }
@@ -146,7 +145,6 @@ void SILWitnessTable::convertToDefinition(
     case AssociatedType:
     case AssociatedTypeProtocol:
     case BaseProtocol:
-    case MissingOptional:
     case Invalid:
       break;
     }

lib/SILGen/SILGenType.cpp

@@ -478,16 +478,6 @@ class SILGenConformance : public SILGenWitnessTable<SILGenConformance> {
                                IsFreeFunctionWitness_t isFree,
                                Witness witness) {
     // Emit the witness thunk and add it to the table.
-
-    // If this is a non-present optional requirement, emit a MissingOptional.
-    if (!witnessRef) {
-      auto *fd = requirementRef.getDecl();
-      assert(fd->getAttrs().hasAttribute<OptionalAttr>() &&
-             "Non-optional protocol requirement lacks a witness?");
-      Entries.push_back(SILWitnessTable::MissingOptionalWitness{ fd });
-      return;
-    }
-
     auto witnessLinkage = witnessRef.getLinkage(ForDefinition);
     auto witnessSerialized = Serialized;
     if (witnessSerialized &&

lib/SILOptimizer/IPO/DeadFunctionElimination.cpp

@@ -177,7 +177,6 @@ class FunctionLivenessComputation {
           break;
 
         case SILWitnessTable::Invalid:
-        case SILWitnessTable::MissingOptional:
         case SILWitnessTable::AssociatedType:
           break;
       }