Add [serialized] flag to sil_vtables

Author: swiftix

include/swift/SIL/SILVTable.h

@@ -32,6 +32,7 @@
 namespace swift {
 
 class ClassDecl;
+enum IsSerialized_t : unsigned char;
 class SILFunction;
 class SILModule;
 
@@ -93,14 +94,18 @@ class SILVTable : public llvm::ilist_node<SILVTable>,
   /// The ClassDecl mapped to this VTable.
   ClassDecl *Class;
 
+  /// Whether or not this vtable is serialized, which allows
+  /// devirtualization from another module.
+  bool Serialized : 1;
+
   /// The number of SILVTables entries.
-  unsigned NumEntries;
+  unsigned NumEntries : 31;
 
   /// Tail-allocated SILVTable entries.
   Entry Entries[1];
 
   /// Private constructor. Create SILVTables by calling SILVTable::create.
-  SILVTable(ClassDecl *c, ArrayRef<Entry> entries);
+  SILVTable(ClassDecl *c, IsSerialized_t serialized, ArrayRef<Entry> entries);
 
 public:
   ~SILVTable();
@@ -109,11 +114,15 @@ class SILVTable : public llvm::ilist_node<SILVTable>,
   /// The SILDeclRef keys should reference the most-overridden members available
   /// through the class.
   static SILVTable *create(SILModule &M, ClassDecl *Class,
+                           IsSerialized_t Serialized,
                            ArrayRef<Entry> Entries);
 
   /// Return the class that the vtable represents.
   ClassDecl *getClass() const { return Class; }
 
+  /// Returns true if this vtable is going to be (or was) serialized.
+  IsSerialized_t isSerialized() const;
+
   /// Return all of the method entries.
   ArrayRef<Entry> getEntries() const { return {Entries, NumEntries}; }
 

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 = 371; // Last change: SILFunctionType.noescape
+const uint16_t VERSION_MINOR = 372; // Last change: VTable serialized
 
 using DeclID = PointerEmbeddedInt<unsigned, 31>;
 using DeclIDField = BCFixed<31>;

lib/ParseSIL/ParseSIL.cpp

@@ -5109,6 +5109,12 @@ bool SILParserTUState::parseSILVTable(Parser &P) {
   P.consumeToken(tok::kw_sil_vtable);
   SILParser VTableState(P);
 
+  IsSerialized_t Serialized = IsNotSerialized;
+  if (parseDeclSILOptional(nullptr, &Serialized, nullptr, nullptr,
+                           nullptr, nullptr, nullptr, nullptr, nullptr,
+                           nullptr, VTableState))
+    return true;
+
   // Parse the class name.
   Identifier Name;
   SourceLoc Loc;
@@ -5196,7 +5202,7 @@ bool SILParserTUState::parseSILVTable(Parser &P) {
   P.parseMatchingToken(tok::r_brace, RBraceLoc, diag::expected_sil_rbrace,
                        LBraceLoc);
 
-  SILVTable::create(M, theClass, vtableEntries);
+  SILVTable::create(M, theClass, Serialized, vtableEntries);
   return false;
 }
 

lib/SIL/SILPrinter.cpp

@@ -2536,7 +2536,11 @@ void SILInstruction::printInContext(llvm::raw_ostream &OS) const {
 }
 
 void SILVTable::print(llvm::raw_ostream &OS, bool Verbose) const {
-  OS << "sil_vtable " << getClass()->getName() << " {\n";
+  OS << "sil_vtable ";
+  if (isSerialized())
+    OS << "[serialized] ";
+  OS << getClass()->getName() << " {\n";
+
   PrintOptions QualifiedSILTypeOptions = PrintOptions::printQualifiedSILType();
   for (auto &entry : getEntries()) {
     OS << "  ";

lib/SIL/SILVTable.cpp

@@ -24,13 +24,14 @@
 using namespace swift;
 
 SILVTable *SILVTable::create(SILModule &M, ClassDecl *Class,
+                             IsSerialized_t Serialized,
                              ArrayRef<Entry> Entries) {
   // SILVTable contains one element declared in Entries.  We must allocate
   // space for it, because its default ctor will write to it.
   unsigned NumTailElements = std::max((unsigned)Entries.size(), 1U)-1;
   void *buf = M.allocate(sizeof(SILVTable) + sizeof(Entry) * NumTailElements,
                          alignof(SILVTable));
-  SILVTable *vt = ::new (buf) SILVTable(Class, Entries);
+  SILVTable *vt = ::new (buf) SILVTable(Class, Serialized, Entries);
   M.vtables.push_back(vt);
   M.VTableMap[Class] = vt;
   // Update the Module's cache with new vtable + vtable entries:
@@ -57,9 +58,13 @@ void SILVTable::removeFromVTableCache(Entry &entry) {
   M.VTableEntryCache.erase({this, entry.Method});
 }
 
-SILVTable::SILVTable(ClassDecl *c, ArrayRef<Entry> entries)
-  : Class(c), NumEntries(entries.size())
-{
+IsSerialized_t SILVTable::isSerialized() const {
+  return Serialized ? IsSerialized : IsNotSerialized;
+}
+
+SILVTable::SILVTable(ClassDecl *c, IsSerialized_t serialized,
+                     ArrayRef<Entry> entries)
+  : Class(c), Serialized(serialized), NumEntries(entries.size()) {
   memcpy(Entries, entries.begin(), sizeof(Entry) * NumEntries);
 
   // Bump the reference count of functions referenced by this table.

lib/SIL/SILVerifier.cpp

@@ -4438,7 +4438,7 @@ void SILVTable::verify(const SILModule &M) const {
     assert(entry.Method.hasDecl() && "vtable entry is not a decl");
     auto baseInfo = M.Types.getConstantInfo(entry.Method);
     ValueDecl *decl = entry.Method.getDecl();
-    
+
     assert((!isa<FuncDecl>(decl)
             || !cast<FuncDecl>(decl)->isObservingAccessor())
            && "observing accessors shouldn't have vtable entries");

lib/SILGen/SILGenType.cpp

@@ -226,8 +226,14 @@ class SILGenVTable : public SILVTableVisitor<SILGenVTable> {
                                dtorFn->getLinkage()});
     }
 
+    IsSerialized_t serialized = IsNotSerialized;
+    auto classIsPublic = theClass->getEffectiveAccess() >= AccessLevel::Public;
+    // Only public, fixed-layout classes should be serialized.
+    if (classIsPublic && theClass->hasFixedLayout())
+      serialized = IsSerialized;
+
     // Finally, create the vtable.
-    SILVTable::create(SGM.M, theClass, vtableEntries);
+    SILVTable::create(SGM.M, theClass, serialized, vtableEntries);
   }
 
   void visitAncestor(ClassDecl *ancestor) {

lib/Serialization/DeserializeSIL.cpp

@@ -2486,7 +2486,8 @@ SILVTable *SILDeserializer::readVTable(DeclID VId) {
   (void)kind;
 
   DeclID ClassID;
-  VTableLayout::readRecord(scratch, ClassID);
+  unsigned Serialized;
+  VTableLayout::readRecord(scratch, ClassID, Serialized);
   if (ClassID == 0) {
     DEBUG(llvm::dbgs() << "VTable classID is 0.\n");
     return nullptr;
@@ -2539,7 +2540,10 @@ SILVTable *SILDeserializer::readVTable(DeclID VId) {
       break;
     kind = SILCursor.readRecord(entry.ID, scratch);
   }
-  SILVTable *vT = SILVTable::create(SILMod, theClass, vtableEntries);
+  SILVTable *vT = SILVTable::create(
+      SILMod, theClass,
+      (Serialized) ? IsSerialized : IsNotSerialized,
+      vtableEntries);
   vTableOrOffset = vT;
 
   if (Callback) Callback->didDeserialize(MF->getAssociatedModule(), vT);

lib/Serialization/SILFormat.h

@@ -186,7 +186,8 @@ namespace sil_block {
 
   using VTableLayout = BCRecordLayout<
     SIL_VTABLE,
-    DeclIDField   // Class Decl
+    DeclIDField,   // Class Decl
+    BCFixed<1>     // IsSerialized.
   >;
 
   using VTableEntryLayout = BCRecordLayout<

lib/Serialization/SerializeSIL.cpp

@@ -2080,7 +2080,8 @@ void SILSerializer::writeSILVTable(const SILVTable &vt) {
   VTableList[vt.getClass()->getName()] = NextVTableID++;
   VTableOffset.push_back(Out.GetCurrentBitNo());
   VTableLayout::emitRecord(Out, ScratchRecord, SILAbbrCodes[VTableLayout::Code],
-                           S.addDeclRef(vt.getClass()));
+                           S.addDeclRef(vt.getClass()),
+                           vt.isSerialized() == IsSerialized ? 1 : 0);
 
   for (auto &entry : vt.getEntries()) {
     SmallVector<ValueID, 4> ListOfValues;
@@ -2287,7 +2288,7 @@ void SILSerializer::writeSILBlock(const SILModule *SILMod) {
   const DeclContext *assocDC = SILMod->getAssociatedContext();
   assert(assocDC && "cannot serialize SIL without an associated DeclContext");
   for (const SILVTable &vt : SILMod->getVTables()) {
-    if ((ShouldSerializeAll || SILMod->getOptions().SILSerializeVTables) &&
+    if ((ShouldSerializeAll || vt.isSerialized()) &&
         vt.getClass()->isChildContextOf(assocDC))
       writeSILVTable(vt);
   }