[DefaultOverrides] SIL de/serialization.

Author: nate-chandler

include/swift/SIL/Notifications.h

@@ -27,6 +27,7 @@ class SILNode;
 class ModuleDecl;
 class SILFunction;
 class SILWitnessTable;
+class SILDefaultOverrideTable;
 class SILDefaultWitnessTable;
 class SILGlobalVariable;
 class SILVTable;
@@ -50,6 +51,12 @@ class DeserializationNotificationHandlerBase {
   virtual void didDeserializeWitnessTableEntries(ModuleDecl *mod,
                                                  SILWitnessTable *wt) = 0;
 
+  /// Observe that we successfully deserialized a default override table's
+  /// entries.
+  virtual void
+  didDeserializeDefaultOverrideTableEntries(ModuleDecl *mod,
+                                            SILDefaultOverrideTable *ot) = 0;
+
   /// Observe that we successfully deserialized a default witness table's
   /// entries.
   virtual void
@@ -69,6 +76,10 @@ class DeserializationNotificationHandlerBase {
   virtual void didDeserialize(ModuleDecl *mod,
                               SILDefaultWitnessTable *wtable) = 0;
 
+  /// Observe that we deserialized a default override table declaration.
+  virtual void didDeserialize(ModuleDecl *mod,
+                              SILDefaultOverrideTable *otable) = 0;
+
   /// Observe that we deserialized a move only deinit declaration.
   virtual void didDeserialize(ModuleDecl *mod, SILMoveOnlyDeinit *deinit) = 0;
 
@@ -93,6 +104,10 @@ class DeserializationNotificationHandler
                                                  SILWitnessTable *wt) override {
   }
 
+  /// Observe that we successfully deserialized a override table's entries.
+  virtual void didDeserializeDefaultOverrideTableEntries(
+      ModuleDecl *mod, SILDefaultOverrideTable *ot) override {}
+
   /// Observe that we successfully deserialized a default witness table's
   /// entries.
   virtual void didDeserializeDefaultWitnessTableEntries(
@@ -113,6 +128,10 @@ class DeserializationNotificationHandler
   virtual void didDeserialize(ModuleDecl *mod,
                               SILDefaultWitnessTable *wtable) override {}
 
+  /// Observe that we deserialized a default override table declaration.
+  virtual void didDeserialize(ModuleDecl *mod,
+                              SILDefaultOverrideTable *otable) override {}
+
   /// Observe that we deserialized a move only deinit declaration.
   virtual void didDeserialize(ModuleDecl *mod,
                               SILMoveOnlyDeinit *deinit) override {}
@@ -242,11 +261,15 @@ class DeserializationNotificationHandlerSet final
   void
   didDeserializeDefaultWitnessTableEntries(ModuleDecl *mod,
                                            SILDefaultWitnessTable *wt) override;
+  void didDeserializeDefaultOverrideTableEntries(
+      ModuleDecl *mod, SILDefaultOverrideTable *ot) override;
   void didDeserialize(ModuleDecl *mod, SILGlobalVariable *var) override;
   void didDeserialize(ModuleDecl *mod, SILVTable *vtable) override;
   void didDeserialize(ModuleDecl *mod, SILWitnessTable *wtable) override;
   void didDeserialize(ModuleDecl *mod,
                       SILDefaultWitnessTable *wtable) override;
+  void didDeserialize(ModuleDecl *mod,
+                      SILDefaultOverrideTable *otable) override;
   void didDeserialize(ModuleDecl *mod, SILMoveOnlyDeinit *deinit) override;
 };
 } // namespace swift

include/swift/Serialization/SerializedSILLoader.h

@@ -70,6 +70,8 @@ class SerializedSILLoader {
   SILMoveOnlyDeinit *lookupMoveOnlyDeinit(const NominalTypeDecl *nomDecl);
   SILWitnessTable *lookupWitnessTable(SILWitnessTable *C);
   SILDefaultWitnessTable *lookupDefaultWitnessTable(SILDefaultWitnessTable *C);
+  SILDefaultOverrideTable *
+  lookupDefaultOverrideTable(SILDefaultOverrideTable *);
   SILDifferentiabilityWitness *
   lookupDifferentiabilityWitness(SILDifferentiabilityWitnessKey key);
 
@@ -106,6 +108,9 @@ class SerializedSILLoader {
   /// Deserialize all DefaultWitnessTables in all SILModules.
   void getAllDefaultWitnessTables();
 
+  /// Deserialize all DefaultOverrideTables in all SILModules.
+  void getAllDefaultOverrideTables();
+
   /// Deserialize all Properties in all SILModules.
   void getAllProperties();
 

lib/SIL/IR/Notifications.cpp

@@ -13,6 +13,7 @@
 #define DEBUG_TYPE "sil-notifications"
 
 #include "swift/SIL/Notifications.h"
+#include "swift/SIL/SILDefaultOverrideTable.h"
 #include "swift/SIL/SILMoveOnlyDeinit.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
@@ -49,9 +50,12 @@ DNS_CHAIN_METHOD(DeserializeWitnessTableEntries, ModuleDecl *,
                  SILWitnessTable *)
 DNS_CHAIN_METHOD(DeserializeDefaultWitnessTableEntries, ModuleDecl *,
                  SILDefaultWitnessTable *)
+DNS_CHAIN_METHOD(DeserializeDefaultOverrideTableEntries, ModuleDecl *,
+                 SILDefaultOverrideTable *)
 DNS_CHAIN_METHOD(Deserialize, ModuleDecl *, SILGlobalVariable *)
 DNS_CHAIN_METHOD(Deserialize, ModuleDecl *, SILVTable *)
 DNS_CHAIN_METHOD(Deserialize, ModuleDecl *, SILMoveOnlyDeinit *)
 DNS_CHAIN_METHOD(Deserialize, ModuleDecl *, SILWitnessTable *)
 DNS_CHAIN_METHOD(Deserialize, ModuleDecl *, SILDefaultWitnessTable *)
+DNS_CHAIN_METHOD(Deserialize, ModuleDecl *, SILDefaultOverrideTable *)
 #undef DNS_CHAIN_METHOD

lib/SIL/IR/SILModule.cpp

@@ -308,6 +308,13 @@ SILModule::lookUpDefaultOverrideTable(const ClassDecl *decl,
   auto found = DefaultOverrideTableMap.find(decl);
   if (found == DefaultOverrideTableMap.end()) {
     if (deserializeLazily) {
+      SILLinkage linkage = getSILLinkage(getDeclLinkage(decl), ForDefinition);
+      SILDefaultOverrideTable *otable =
+          SILDefaultOverrideTable::declare(*this, linkage, decl);
+      otable = getSILLoader()->lookupDefaultOverrideTable(otable);
+      if (otable)
+        DefaultOverrideTableMap[decl] = otable;
+      return otable;
     }
 
     return nullptr;

lib/Serialization/DeserializeSIL.cpp

@@ -193,6 +193,7 @@ SILDeserializer::SILDeserializer(
              kind == sil_index_block::SIL_GLOBALVAR_NAMES ||
              kind == sil_index_block::SIL_WITNESS_TABLE_NAMES ||
              kind == sil_index_block::SIL_DEFAULT_WITNESS_TABLE_NAMES ||
+             kind == sil_index_block::SIL_DEFAULT_OVERRIDE_TABLE_NAMES ||
              kind == sil_index_block::SIL_PROPERTY_OFFSETS ||
              kind == sil_index_block::SIL_DIFFERENTIABILITY_WITNESS_NAMES)) &&
            "Expect SIL_FUNC_NAMES, SIL_VTABLE_NAMES, SIL_GLOBALVAR_NAMES, \
@@ -212,6 +213,8 @@ SILDeserializer::SILDeserializer(
       WitnessTableList = readFuncTable(scratch, blobData);
     else if (kind == sil_index_block::SIL_DEFAULT_WITNESS_TABLE_NAMES)
       DefaultWitnessTableList = readFuncTable(scratch, blobData);
+    else if (kind == sil_index_block::SIL_DEFAULT_OVERRIDE_TABLE_NAMES)
+      DefaultOverrideTableList = readFuncTable(scratch, blobData);
     else if (kind == sil_index_block::SIL_DIFFERENTIABILITY_WITNESS_NAMES)
       DifferentiabilityWitnessList = readFuncTable(scratch, blobData);
     else if (kind == sil_index_block::SIL_PROPERTY_OFFSETS) {
@@ -256,6 +259,11 @@ SILDeserializer::SILDeserializer(
               offKind == sil_index_block::SIL_DEFAULT_WITNESS_TABLE_OFFSETS) &&
              "Expect a SIL_DEFAULT_WITNESS_TABLE_OFFSETS record.");
       MF->allocateBuffer(DefaultWitnessTables, scratch);
+    } else if (kind == sil_index_block::SIL_DEFAULT_OVERRIDE_TABLE_NAMES) {
+      assert((next.Kind == llvm::BitstreamEntry::Record &&
+              offKind == sil_index_block::SIL_DEFAULT_OVERRIDE_TABLE_OFFSETS) &&
+             "Expect a SIL_DEFAULT_OVERRIDE_TABLE_OFFSETS record.");
+      MF->allocateBuffer(DefaultOverrideTables, scratch);
     } else if (kind == sil_index_block::SIL_DIFFERENTIABILITY_WITNESS_NAMES) {
       assert((next.Kind == llvm::BitstreamEntry::Record &&
               offKind ==
@@ -1121,6 +1129,7 @@ llvm::Expected<SILFunction *> SILDeserializer::readSILFunctionChecked(
   Builder.setCurrentDebugScope(fn->getDebugScope());
   while (kind != SIL_FUNCTION && kind != SIL_VTABLE && kind != SIL_GLOBALVAR &&
          kind != SIL_MOVEONLY_DEINIT && kind != SIL_WITNESS_TABLE &&
+         kind != SIL_DEFAULT_OVERRIDE_TABLE &&
          kind != SIL_DIFFERENTIABILITY_WITNESS) {
     if (kind == SIL_BASIC_BLOCK)
       // Handle a SILBasicBlock record.
@@ -4091,6 +4100,7 @@ SILGlobalVariable *SILDeserializer::readGlobalVar(StringRef Name) {
 
   while (kind != SIL_FUNCTION && kind != SIL_VTABLE && kind != SIL_GLOBALVAR &&
          kind != SIL_MOVEONLY_DEINIT && kind != SIL_WITNESS_TABLE &&
+         kind != SIL_DEFAULT_OVERRIDE_TABLE &&
          kind != SIL_DIFFERENTIABILITY_WITNESS) {
     if (readSILInstruction(nullptr, Builder, kind, scratch))
       MF->fatal("readSILInstruction returns error");
@@ -4219,7 +4229,8 @@ SILVTable *SILDeserializer::readVTable(DeclID VId) {
   std::vector<SILVTable::Entry> vtableEntries;
   // Another SIL_VTABLE record means the end of this VTable.
   while (kind != SIL_VTABLE && kind != SIL_WITNESS_TABLE &&
-         kind != SIL_DEFAULT_WITNESS_TABLE && kind != SIL_FUNCTION &&
+         kind != SIL_DEFAULT_WITNESS_TABLE &&
+         kind != SIL_DEFAULT_OVERRIDE_TABLE && kind != SIL_FUNCTION &&
          kind != SIL_PROPERTY && kind != SIL_MOVEONLY_DEINIT) {
     assert(kind == SIL_VTABLE_ENTRY &&
            "Content of Vtable should be in SIL_VTABLE_ENTRY.");
@@ -4434,10 +4445,9 @@ void SILDeserializer::readWitnessTableEntries(
   unsigned kind = maybeKind.get();
 
   // Another record means the end of this WitnessTable.
-  while (kind != SIL_WITNESS_TABLE &&
-         kind != SIL_DEFAULT_WITNESS_TABLE &&
-         kind != SIL_DIFFERENTIABILITY_WITNESS &&
-         kind != SIL_FUNCTION) {
+  while (kind != SIL_WITNESS_TABLE && kind != SIL_DEFAULT_WITNESS_TABLE &&
+         kind != SIL_DEFAULT_OVERRIDE_TABLE &&
+         kind != SIL_DIFFERENTIABILITY_WITNESS && kind != SIL_FUNCTION) {
     if (kind == SIL_DEFAULT_WITNESS_TABLE_NO_ENTRY) {
       witnessEntries.push_back(SILDefaultWitnessTable::Entry());
     } else if (kind == SIL_WITNESS_BASE_ENTRY) {
@@ -4825,6 +4835,181 @@ SILDeserializer::lookupDefaultWitnessTable(SILDefaultWitnessTable *existingWt) {
   return Wt;
 }
 
+void SILDeserializer::readDefaultOverrideTableEntries(
+    llvm::BitstreamEntry &entry,
+    std::vector<SILDefaultOverrideTable::Entry> &entries) {
+  SmallVector<uint64_t, 64> scratch;
+  llvm::Expected<unsigned> maybeKind = SILCursor.readRecord(entry.ID, scratch);
+  if (!maybeKind)
+    MF->fatal(maybeKind.takeError());
+  unsigned kind = maybeKind.get();
+
+  // Another record means the end of this DefaultOverrideTable.
+  while (kind == SIL_DEFAULT_OVERRIDE_TABLE_ENTRY) {
+    ArrayRef<uint64_t> ListOfValues;
+    DeclID NameID;
+    DefaultOverrideTableEntryLayout::readRecord(scratch, NameID, ListOfValues);
+    SILFunction *impl = nullptr;
+    if (NameID != 0) {
+      impl = getFuncForReference(MF->getIdentifierText(NameID));
+    }
+    if (impl || NameID == 0) {
+      unsigned NextValueIndex = 0;
+      auto method = getSILDeclRef(MF, ListOfValues, NextValueIndex);
+      auto original = getSILDeclRef(MF, ListOfValues, NextValueIndex);
+      entries.push_back(SILDefaultOverrideTable::Entry{method, original, impl});
+    }
+
+    // Fetch the next record.
+    scratch.clear();
+    llvm::Expected<llvm::BitstreamEntry> maybeEntry =
+        SILCursor.advance(AF_DontPopBlockAtEnd);
+    if (!maybeEntry)
+      MF->fatal(maybeEntry.takeError());
+    entry = maybeEntry.get();
+    if (entry.Kind == llvm::BitstreamEntry::EndBlock)
+      // EndBlock means the end of this DefaultOverrideTable.
+      break;
+    maybeKind = SILCursor.readRecord(entry.ID, scratch);
+    if (!maybeKind)
+      MF->fatal(maybeKind.takeError());
+    kind = maybeKind.get();
+  }
+}
+
+SILDefaultOverrideTable *
+SILDeserializer::readDefaultOverrideTable(DeclID tableID,
+                                          SILDefaultOverrideTable *existingOt) {
+  if (tableID == 0)
+    return nullptr;
+  assert(tableID <= DefaultOverrideTables.size() &&
+         "invalid DefaultOverrideTable ID");
+
+  auto &oTableOrOffset = DefaultOverrideTables[tableID - 1];
+
+  if (oTableOrOffset.isFullyDeserialized())
+    return oTableOrOffset.get();
+
+  BCOffsetRAII restoreOffset(SILCursor);
+  if (llvm::Error Err = SILCursor.JumpToBit(oTableOrOffset.getOffset()))
+    MF->fatal(std::move(Err));
+  llvm::Expected<llvm::BitstreamEntry> maybeEntry =
+      SILCursor.advance(AF_DontPopBlockAtEnd);
+  if (!maybeEntry)
+    MF->fatal(maybeEntry.takeError());
+  llvm::BitstreamEntry entry = maybeEntry.get();
+  if (entry.Kind == llvm::BitstreamEntry::Error) {
+    LLVM_DEBUG(llvm::dbgs() << "Cursor advance error in "
+                               "readDefaultOverrideTable.\n");
+    return nullptr;
+  }
+
+  SmallVector<uint64_t, 64> scratch;
+  StringRef blobData;
+  llvm::Expected<unsigned> maybeKind =
+      SILCursor.readRecord(entry.ID, scratch, &blobData);
+  if (!maybeKind)
+    MF->fatal(maybeKind.takeError());
+  unsigned kind = maybeKind.get();
+  assert(kind == SIL_DEFAULT_OVERRIDE_TABLE &&
+         "expect a sil default override table");
+  (void)kind;
+
+  unsigned rawLinkage;
+  DeclID classID;
+  DefaultOverrideTableLayout::readRecord(scratch, classID, rawLinkage);
+
+  auto Linkage = fromStableSILLinkage(rawLinkage);
+  if (!Linkage) {
+    LLVM_DEBUG(llvm::dbgs() << "invalid linkage code " << rawLinkage
+                            << " for SILFunction\n");
+    MF->fatal("invalid linkage code");
+  }
+
+  ClassDecl *decl = cast<ClassDecl>(MF->getDecl(classID));
+  if (decl == nullptr) {
+    LLVM_DEBUG(llvm::dbgs() << "invalid class code " << classID << "\n");
+    MF->fatal("invalid class code");
+  }
+
+  PrettyStackTraceDecl trace("deserializing default override table for", decl);
+
+  if (!existingOt)
+    existingOt =
+        SILMod.lookUpDefaultOverrideTable(decl, /*deserializeLazily=*/false);
+  auto oT = existingOt;
+
+  // If we have an existing default override table, verify that the class
+  // matches up.
+  if (oT) {
+    if (oT->getClass() != decl) {
+      MF->fatal("Protocol mismatch");
+    }
+
+    // Don't override the linkage of a default override table with an existing
+    // declaration.
+
+  } else {
+    // Otherwise, create a new override table declaration.
+    oT = SILDefaultOverrideTable::declare(SILMod, *Linkage, decl);
+    if (Callback)
+      Callback->didDeserialize(MF->getAssociatedModule(), oT);
+  }
+
+  // Fetch the next record.
+  scratch.clear();
+  maybeEntry = SILCursor.advance(AF_DontPopBlockAtEnd);
+  if (!maybeEntry)
+    MF->fatal(maybeEntry.takeError());
+  entry = maybeEntry.get();
+  if (entry.Kind == llvm::BitstreamEntry::EndBlock)
+    return nullptr;
+
+  std::vector<SILDefaultOverrideTable::Entry> entries;
+  readDefaultOverrideTableEntries(entry, entries);
+
+  oT->define(entries);
+  oTableOrOffset.set(oT, /*fully deserialized*/ true);
+  if (Callback)
+    Callback->didDeserializeDefaultOverrideTableEntries(
+        MF->getAssociatedModule(), oT);
+  return oT;
+}
+
+SILDefaultOverrideTable *SILDeserializer::lookupDefaultOverrideTable(
+    SILDefaultOverrideTable *existingOt) {
+  assert(existingOt &&
+         "Cannot deserialize a null default override table declaration.");
+  assert(existingOt->isDeclaration() &&
+         "Cannot deserialize a default override table "
+         "definition.");
+
+  // If we don't have a default override table list, we can't look anything up.
+  if (!DefaultOverrideTableList)
+    return nullptr;
+
+  // Use the mangled name of the class to lookup the partially deserialized
+  // value from the default override table list.
+  auto iter = DefaultOverrideTableList->find(existingOt->getUniqueName());
+  if (iter == DefaultOverrideTableList->end())
+    return nullptr;
+
+  // Attempt to read the default override table.
+  auto Ot = readDefaultOverrideTable(*iter, existingOt);
+  if (Ot)
+    LLVM_DEBUG(llvm::dbgs() << "Deserialize SIL:\n"; Ot->dump());
+
+  return Ot;
+}
+
+void SILDeserializer::getAllDefaultOverrideTables() {
+  if (!DefaultOverrideTableList)
+    return;
+  for (unsigned index = 0, size = DefaultOverrideTables.size(); index < size;
+       ++index)
+    readDefaultOverrideTable(index + 1, nullptr);
+}
+
 SILDifferentiabilityWitness *
 SILDeserializer::readDifferentiabilityWitness(DeclID DId) {
   if (DId == 0)