SIL: Add 'fragile' bit to SILDefaultWitnessTable

We used to serialize default witness tables for all
protocols, which doesn't make much sense. Now only
serialize the fragile ones. For now, SILGen sets
the fragile bit on the default witness table of
all public protocols.

Author: slavapestov

include/swift/SIL/SILDefaultWitnessTable.h

@@ -98,12 +98,17 @@ class SILDefaultWitnessTable : public llvm::ilist_node<SILDefaultWitnessTable>,
   /// the default witness table from outside its defining translation unit.
   bool IsDeclaration;
 
+  /// Whether or not this witness table is fragile. Fragile means that the
+  /// table may be serialized and "inlined" into another module.
+  bool IsFragile;
+
   /// Private constructor for making SILDefaultWitnessTable declarations.
   SILDefaultWitnessTable(SILModule &M, SILLinkage Linkage,
                          const ProtocolDecl *Protocol);
 
   /// Private constructor for making SILDefaultWitnessTable definitions.
   SILDefaultWitnessTable(SILModule &M, SILLinkage Linkage,
+                         bool IsFragile,
                          const ProtocolDecl *Protocol,
                          ArrayRef<Entry> entries);
 
@@ -116,6 +121,7 @@ class SILDefaultWitnessTable : public llvm::ilist_node<SILDefaultWitnessTable>,
 
   /// Create a new SILDefaultWitnessTable definition with the given entries.
   static SILDefaultWitnessTable *create(SILModule &M, SILLinkage Linkage,
+                                        bool IsFragile,
                                         const ProtocolDecl *Protocol,
                                         ArrayRef<Entry> entries);
 
@@ -127,13 +133,19 @@ class SILDefaultWitnessTable : public llvm::ilist_node<SILDefaultWitnessTable>,
   /// Set the linkage of the default witness table.
   void setLinkage(SILLinkage l) { Linkage = l; }
 
-  void convertToDefinition(ArrayRef<Entry> entries);
+  void convertToDefinition(ArrayRef<Entry> entries, bool isFragile);
 
   ~SILDefaultWitnessTable();
 
   /// Return true if this is a declaration with no body.
   bool isDeclaration() const { return IsDeclaration; }
 
+  /// Return true if this is a definition with a body.
+  bool isDefinition() const { return !IsDeclaration; }
+
+  /// Returns true if this default witness table is fragile.
+  bool isFragile() const { return IsFragile; }
+
   /// Return the AST ProtocolDecl this default witness table is associated with.
   const ProtocolDecl *getProtocol() const { return Protocol; }
 

include/swift/Serialization/ModuleFormat.h

@@ -54,7 +54,7 @@ const uint16_t VERSION_MAJOR = 0;
 /// in source control, you should also update the comment to briefly
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
-const uint16_t VERSION_MINOR = 327; // Last change: begin_access/end_access
+const uint16_t VERSION_MINOR = 328; // Last change: default witness table fragile bit
 
 using DeclID = PointerEmbeddedInt<unsigned, 31>;
 using DeclIDField = BCFixed<31>;

lib/Parse/ParseSIL.cpp

@@ -4969,7 +4969,7 @@ ProtocolConformance *SILParser::parseProtocolConformanceHelper(
   return retVal;
 }
 
-/// decl-sil-witness ::= 'sil_witness_table' sil-linkage?
+/// decl-sil-witness ::= 'sil_witness_table' sil-linkage? fragile?
 ///                      normal-protocol-conformance decl-sil-witness-body
 /// normal-protocol-conformance ::=
 ///   generic-parameter-list? type: protocolName module ModuleName
@@ -5174,7 +5174,7 @@ bool Parser::parseSILWitnessTable() {
 }
 
 /// decl-sil-default-witness ::= 'sil_default_witness_table' 
-///                              sil-linkage identifier
+///                              sil-linkage? fragile? identifier
 ///                              decl-sil-default-witness-body
 /// decl-sil-default-witness-body:
 ///   '{' sil-default-witness-entry* '}'
@@ -5188,7 +5188,13 @@ bool Parser::parseSILDefaultWitnessTable() {
   // Parse the linkage.
   Optional<SILLinkage> Linkage;
   parseSILLinkage(Linkage, *this);
-  
+
+  bool isFragile = false;
+  if (parseDeclSILOptional(nullptr, &isFragile, nullptr, nullptr,
+                           nullptr, nullptr, nullptr, nullptr, nullptr,
+                           nullptr, WitnessState))
+    return true;
+
   Scope S(this, ScopeKind::TopLevel);
   // We should use WitnessTableBody. This ensures that the generic params
   // are visible.
@@ -5254,7 +5260,8 @@ bool Parser::parseSILDefaultWitnessTable() {
   if (!Linkage)
     Linkage = SILLinkage::Public;
 
-  SILDefaultWitnessTable::create(*SIL->M, *Linkage, protocol, witnessEntries);
+  SILDefaultWitnessTable::create(*SIL->M, *Linkage, isFragile, protocol,
+                                 witnessEntries);
   BodyScope.reset();
   return false;
 }

lib/SIL/SILDefaultWitnessTable.cpp

@@ -36,12 +36,13 @@ void SILDefaultWitnessTable::addDefaultWitnessTable() {
 
 SILDefaultWitnessTable *
 SILDefaultWitnessTable::create(SILModule &M, SILLinkage Linkage,
+                               bool IsFragile,
                                const ProtocolDecl *Protocol,
                                ArrayRef<SILDefaultWitnessTable::Entry> entries){
   // Allocate the witness table and initialize it.
   auto *buf = M.allocate<SILDefaultWitnessTable>(1);
   SILDefaultWitnessTable *wt =
-      ::new (buf) SILDefaultWitnessTable(M, Linkage, Protocol, entries);
+      ::new (buf) SILDefaultWitnessTable(M, Linkage, IsFragile, Protocol, entries);
 
   wt->addDefaultWitnessTable();
 
@@ -66,24 +67,26 @@ SILDefaultWitnessTable::create(SILModule &M, SILLinkage Linkage,
 SILDefaultWitnessTable::
 SILDefaultWitnessTable(SILModule &M,
                        SILLinkage Linkage,
+                       bool IsFragile,
                        const ProtocolDecl *Protocol,
                        ArrayRef<Entry> entries)
-  : Mod(M), Linkage(Linkage), Protocol(Protocol), Entries(),
-    IsDeclaration(true) {
+  : Mod(M), Linkage(Linkage), Protocol(Protocol),
+    Entries(), IsDeclaration(true), IsFragile(false) {
 
-  convertToDefinition(entries);
+  convertToDefinition(entries, IsFragile);
 }
 
 SILDefaultWitnessTable::SILDefaultWitnessTable(SILModule &M,
                                                SILLinkage Linkage,
                                                const ProtocolDecl *Protocol)
-  : Mod(M), Linkage(Linkage), Protocol(Protocol), Entries(),
-    IsDeclaration(true) {}
+  : Mod(M), Linkage(Linkage), Protocol(Protocol),
+    Entries(), IsDeclaration(true), IsFragile(false) {}
 
 void SILDefaultWitnessTable::
-convertToDefinition(ArrayRef<Entry> entries) {
+convertToDefinition(ArrayRef<Entry> entries, bool isFragile) {
   assert(IsDeclaration);
   IsDeclaration = false;
+  IsFragile = isFragile;
 
   Entries = Mod.allocateCopy(entries);
 

lib/SIL/SILModule.cpp

@@ -174,7 +174,7 @@ SILModule::lookUpWitnessTable(const ProtocolConformance *C,
     return wtable;
 
   // Otherwise try to deserialize it. If we succeed return the deserialized
-  // function.
+  // witness table.
   //
   // *NOTE* In practice, wtable will be deserializedTable, but I do not want to rely
   // on that behavior for now.
@@ -196,21 +196,20 @@ SILModule::lookUpDefaultWitnessTable(const ProtocolDecl *Protocol,
 
   auto found = DefaultWitnessTableMap.find(Protocol);
   if (found == DefaultWitnessTableMap.end()) {
-    if (deserializeLazily) {
-      SILLinkage linkage =
-        getSILLinkage(getDeclLinkage(Protocol), ForDefinition);
-      SILDefaultWitnessTable *wtable =
-        SILDefaultWitnessTable::create(*this, linkage, Protocol);
-      wtable = getSILLoader()->lookupDefaultWitnessTable(wtable);
-      if (wtable)
-        DefaultWitnessTableMap[Protocol] = wtable;
-      return wtable;
-    }
-
     return nullptr;
   }
 
-  return found->second;
+  auto *wtable = found->second;
+
+  if (wtable->isDefinition())
+    return wtable;
+
+  if (deserializeLazily)
+    if (auto deserialized = getSILLoader()->lookupDefaultWitnessTable(wtable))
+      return deserialized;
+
+  // If we fail, just return the declaration.
+  return wtable;
 }
 
 SILDefaultWitnessTable *

lib/SIL/SILVerifier.cpp

@@ -4085,12 +4085,17 @@ void SILDefaultWitnessTable::verify(const SILModule &M) const {
       continue;
 
     SILFunction *F = E.getWitness();
-    // FIXME
-    #if 0
-    assert(!isLessVisibleThan(F->getLinkage(), getLinkage()) &&
-           "Default witness tables should not reference "
-           "less visible functions.");
-    #endif
+
+    // If a SILDefaultWitnessTable is going to be serialized, it must only
+    // reference public or shared [fragile] functions.
+    if (isFragile()) {
+      assert((!isLessVisibleThan(F->getLinkage(), getLinkage()) ||
+              (F->isFragile() &&
+               F->getLinkage() == SILLinkage::Shared)) &&
+             "Default witness tables should not reference "
+             "less visible functions.");
+    }
+
     assert(F->getLoweredFunctionType()->getRepresentation() ==
            SILFunctionTypeRepresentation::WitnessMethod &&
            "Default witnesses must have witness_method representation.");

lib/SILGen/SILGenDecl.cpp

@@ -2025,16 +2025,48 @@ class SILGenDefaultWitnessTable
     : public SILGenWitnessTable<SILGenDefaultWitnessTable> {
   using super = SILGenWitnessTable<SILGenDefaultWitnessTable>;
 
-public:
   SILGenModule &SGM;
   ProtocolDecl *Proto;
   SILLinkage Linkage;
+  IsFragile_t isFragile;
 
   SmallVector<SILDefaultWitnessTable::Entry, 8> DefaultWitnesses;
 
-  SILGenDefaultWitnessTable(SILGenModule &SGM, ProtocolDecl *proto,
-                            SILLinkage linkage)
-      : SGM(SGM), Proto(proto), Linkage(linkage) { }
+public:
+  SILGenDefaultWitnessTable(SILGenModule &SGM, ProtocolDecl *proto)
+      : SGM(SGM), Proto(proto) {
+    Linkage = getSILLinkage(getDeclLinkage(Proto), ForDefinition);
+
+    isFragile = IsNotFragile;
+
+    // Serialize the witness table if we're serializing everything with
+    // -sil-serialize-all.
+    if (SGM.makeModuleFragile)
+      isFragile = IsFragile;
+
+    // Serialize the witness table if the protocol is externally
+    // visible.
+    if (Proto->getEffectiveAccess() >= Accessibility::Public)
+      isFragile = IsFragile;
+
+    // Not all protocols use witness tables; in this case we just skip
+    // all of emit() below completely.
+    if (!Lowering::TypeConverter::protocolRequiresWitnessTable(proto))
+      Proto = nullptr;
+  }
+
+  SILDefaultWitnessTable *emit() {
+    if (!Proto)
+      return nullptr;
+
+    visitProtocolDecl(Proto);
+
+    auto *wtable =
+      SGM.M.createDefaultWitnessTableDeclaration(Proto, Linkage);
+    wtable->convertToDefinition(DefaultWitnesses, IsFragile);
+
+    return wtable;
+  }
 
   void addMissingDefault() {
     DefaultWitnesses.push_back(SILDefaultWitnessTable::Entry());
@@ -2068,7 +2100,7 @@ class SILGenDefaultWitnessTable
                  SILDeclRef witnessRef,
                  IsFreeFunctionWitness_t isFree,
                  Witness witness) {
-    SILFunction *witnessFn = SGM.emitProtocolWitness(nullptr, IsNotFragile,
+    SILFunction *witnessFn = SGM.emitProtocolWitness(nullptr, isFragile,
                                                      requirementRef, witnessRef,
                                                      isFree, witness);
     auto entry = SILDefaultWitnessTable::Entry(requirementRef, witnessFn);
@@ -2102,15 +2134,8 @@ class SILGenDefaultWitnessTable
 } // end anonymous namespace
 
 void SILGenModule::emitDefaultWitnessTable(ProtocolDecl *protocol) {
-  SILLinkage linkage =
-      getSILLinkage(getDeclLinkage(protocol), ForDefinition);
-
-  SILGenDefaultWitnessTable builder(*this, protocol, linkage);
-  builder.visitProtocolDecl(protocol);
-
-  SILDefaultWitnessTable *defaultWitnesses =
-      M.createDefaultWitnessTableDeclaration(protocol, linkage);
-  defaultWitnesses->convertToDefinition(builder.DefaultWitnesses);
+  SILGenDefaultWitnessTable builder(*this, protocol);
+  builder.emit();
 }
 
 SILFunction *SILGenModule::

lib/Serialization/DeserializeSIL.cpp

@@ -2547,8 +2547,9 @@ readDefaultWitnessTable(DeclID WId, SILDefaultWitnessTable *existingWt) {
   (void)kind;
 
   unsigned RawLinkage;
+  bool isFragile;
   DeclID protoId;
-  DefaultWitnessTableLayout::readRecord(scratch, protoId, RawLinkage);
+  DefaultWitnessTableLayout::readRecord(scratch, protoId, RawLinkage, isFragile);
 
   auto Linkage = fromStableSILLinkage(RawLinkage);
   if (!Linkage) {
@@ -2627,7 +2628,7 @@ readDefaultWitnessTable(DeclID WId, SILDefaultWitnessTable *existingWt) {
     kind = SILCursor.readRecord(entry.ID, scratch);
   }
 
-  wT->convertToDefinition(witnessEntries);
+  wT->convertToDefinition(witnessEntries, isFragile);
   wTableOrOffset.set(wT, /*fully deserialized*/ true);
   if (Callback)
     Callback->didDeserializeDefaultWitnessTableEntries(MF->getAssociatedModule(), wT);

lib/Serialization/SILFormat.h

@@ -213,8 +213,9 @@ namespace sil_block {
 
   using DefaultWitnessTableLayout = BCRecordLayout<
     SIL_DEFAULT_WITNESS_TABLE,
-    DeclIDField,  // ID of ProtocolDecl
-    SILLinkageField  // Linkage
+    DeclIDField,      // ID of ProtocolDecl
+    SILLinkageField,  // Linkage
+    BCFixed<1>        // fragile
     // Default witness table entries will be serialized after.
   >;
 

lib/Serialization/SerializeSIL.cpp

@@ -1951,7 +1951,9 @@ writeSILDefaultWitnessTable(const SILDefaultWitnessTable &wt) {
     Out, ScratchRecord,
     SILAbbrCodes[DefaultWitnessTableLayout::Code],
     S.addDeclRef(wt.getProtocol()),
-    toStableSILLinkage(wt.getLinkage()));
+    toStableSILLinkage(wt.getLinkage()),
+    wt.isFragile()
+  );
 
   for (auto &entry : wt.getEntries()) {
     if (!entry.isValid()) {
@@ -2073,9 +2075,8 @@ void SILSerializer::writeSILBlock(const SILModule *SILMod) {
 
   // Write out DefaultWitnessTables.
   for (const SILDefaultWitnessTable &wt : SILMod->getDefaultWitnessTables()) {
-    // FIXME: Don't need to serialize private and internal default witness
-    // tables.
-    if (wt.getProtocol()->getDeclContext()->isChildContextOf(assocDC))
+    if ((ShouldSerializeAll || wt.isFragile()) &&
+        wt.getProtocol()->getDeclContext()->isChildContextOf(assocDC))
       writeSILDefaultWitnessTable(wt);
   }