PruneVTables: Keep SILModule's vtable lookup table in sync with updates.

And add a verifier check to ensure the cache remains synced.

Author: jckarter

include/swift/SIL/SILVTable.h

@@ -64,7 +64,8 @@ class SILVTableEntry {
     // Please update the PointerIntPair above if you add/remove enums.
   };
 
-  SILVTableEntry() : ImplAndKind(nullptr, Kind::Normal) {}
+  SILVTableEntry() : ImplAndKind(nullptr, Kind::Normal),
+                     IsNonOverridden(false) {}
 
   SILVTableEntry(SILDeclRef Method, SILFunction *Implementation, Kind TheKind,
                  bool NonOverridden)
@@ -80,6 +81,19 @@ class SILVTableEntry {
   void setNonOverridden(bool value) { IsNonOverridden = value; }
 
   SILFunction *getImplementation() const { return ImplAndKind.getPointer(); }
+  
+  void print(llvm::raw_ostream &os) const;
+  
+  bool operator==(const SILVTableEntry &e) const {
+    return Method == e.Method
+      && getImplementation() == e.getImplementation()
+      && getKind() == e.getKind()
+      && isNonOverridden() == e.isNonOverridden();
+  }
+  
+  bool operator!=(const SILVTableEntry &e) const {
+    return !(*this == e);
+  }
 };
 
 /// A mapping from each dynamically-dispatchable method of a class to the
@@ -140,9 +154,13 @@ class SILVTable final : public SILAllocated<SILVTable>,
   }
 
   /// Return all of the method entries mutably.
+  /// If you do modify entries, make sure to invoke `updateVTableCache` to update the
+  /// SILModule's cache entry.
   MutableArrayRef<Entry> getMutableEntries() {
     return {getTrailingObjects<SILVTableEntry>(), NumEntries};
   }
+                          
+  void updateVTableCache(const Entry &entry);
 
   /// Look up the implementation function for the given method.
   Optional<Entry> getEntry(SILModule &M, SILDeclRef method) const;

lib/SIL/IR/SILPrinter.cpp

@@ -3103,52 +3103,56 @@ void SILInstruction::printInContext(llvm::raw_ostream &OS) const {
   SILPrinter(Ctx).printInContext(this);
 }
 
+void SILVTableEntry::print(llvm::raw_ostream &OS) const {
+  getMethod().print(OS);
+  OS << ": ";
+
+  PrintOptions QualifiedSILTypeOptions = PrintOptions::printQualifiedSILType();
+  bool HasSingleImplementation = false;
+  switch (getMethod().kind) {
+  default:
+    break;
+  case SILDeclRef::Kind::IVarDestroyer:
+  case SILDeclRef::Kind::Destroyer:
+  case SILDeclRef::Kind::Deallocator:
+    HasSingleImplementation = true;
+  }
+  // No need to emit the signature for methods that may have only
+  // single implementation, e.g. for destructors.
+  if (!HasSingleImplementation) {
+    QualifiedSILTypeOptions.CurrentModule =
+        getMethod().getDecl()->getDeclContext()->getParentModule();
+    getMethod().getDecl()->getInterfaceType().print(
+        OS, QualifiedSILTypeOptions);
+    OS << " : ";
+  }
+  OS << '@' << getImplementation()->getName();
+  switch (getKind()) {
+  case SILVTable::Entry::Kind::Normal:
+    break;
+  case SILVTable::Entry::Kind::Inherited:
+    OS << " [inherited]";
+    break;
+  case SILVTable::Entry::Kind::Override:
+    OS << " [override]";
+    break;
+  }
+  if (isNonOverridden()) {
+    OS << " [nonoverridden]";
+  }
+
+  OS << "\t// " << demangleSymbol(getImplementation()->getName());
+}
+
 void SILVTable::print(llvm::raw_ostream &OS, bool Verbose) const {
   OS << "sil_vtable ";
   if (isSerialized())
     OS << "[serialized] ";
   OS << getClass()->getName() << " {\n";
 
-  PrintOptions QualifiedSILTypeOptions = PrintOptions::printQualifiedSILType();
   for (auto &entry : getEntries()) {
     OS << "  ";
-    entry.getMethod().print(OS);
-    OS << ": ";
-
-    bool HasSingleImplementation = false;
-    switch (entry.getMethod().kind) {
-    default:
-      break;
-    case SILDeclRef::Kind::IVarDestroyer:
-    case SILDeclRef::Kind::Destroyer:
-    case SILDeclRef::Kind::Deallocator:
-      HasSingleImplementation = true;
-    }
-    // No need to emit the signature for methods that may have only
-    // single implementation, e.g. for destructors.
-    if (!HasSingleImplementation) {
-      QualifiedSILTypeOptions.CurrentModule =
-          entry.getMethod().getDecl()->getDeclContext()->getParentModule();
-      entry.getMethod().getDecl()->getInterfaceType().print(
-          OS, QualifiedSILTypeOptions);
-      OS << " : ";
-    }
-    OS << '@' << entry.getImplementation()->getName();
-    switch (entry.getKind()) {
-    case SILVTable::Entry::Kind::Normal:
-      break;
-    case SILVTable::Entry::Kind::Inherited:
-      OS << " [inherited]";
-      break;
-    case SILVTable::Entry::Kind::Override:
-      OS << " [override]";
-      break;
-    }
-    if (entry.isNonOverridden()) {
-      OS << " [nonoverridden]";
-    }
-
-    OS << "\t// " << demangleSymbol(entry.getImplementation()->getName());
+    entry.print(OS);
     OS << "\n";
   }
   OS << "}\n\n";

lib/SIL/IR/SILVTable.cpp

@@ -55,6 +55,11 @@ void SILVTable::removeFromVTableCache(Entry &entry) {
   M.VTableEntryCache.erase({this, entry.getMethod()});
 }
 
+void SILVTable::updateVTableCache(const Entry &entry) {
+  SILModule &M = entry.getImplementation()->getModule();
+  M.VTableEntryCache[{this, entry.getMethod()}] = entry;
+}
+
 SILVTable::SILVTable(ClassDecl *c, IsSerialized_t serialized,
                      ArrayRef<Entry> entries)
   : Class(c), Serialized(serialized), NumEntries(entries.size()) {

lib/SIL/Verifier/SILVerifier.cpp

@@ -5381,6 +5381,10 @@ void SILVTable::verify(const SILModule &M) const {
   for (unsigned i : indices(getEntries())) {
     auto &entry = getEntries()[i];
 
+    // Make sure the module's lookup cache is consistent.
+    assert(entry == *getEntry(const_cast<SILModule &>(M), entry.getMethod())
+           && "vtable entry is out of sync with method's vtable cache");
+    
     // All vtable entries must be decls in a class context.
     assert(entry.getMethod().hasDecl() && "vtable entry is not a decl");
     auto baseInfo = M.Types.getConstantInfo(TypeExpansionContext::minimal(),