Merge pull request swiftlang#12549 from swiftix/sil-serialization-before-optimizations5

Enable the serialization of sil_vtables by default and completely remove the -sil-serialize-vtables option

Author: swiftix

CMakeLists.txt

@@ -251,10 +251,6 @@ option(SWIFT_RUNTIME_CLOBBER_FREED_OBJECTS
     "Overwrite memory for deallocated Swift objects"
     "${SWIFT_RUNTIME_CLOBBER_FREED_OBJECTS_default}")
 
-option(SWIFT_SERIALIZE_STDLIB_UNITTEST
-    "Compile the StdlibUnittest module with -sil-serialize-all to increase the test coverage for the optimizer"
-    FALSE)
-
 option(SWIFT_STDLIB_SIL_DEBUGGING
     "Compile the Swift standard library with -gsil to enable debugging and profiling on SIL level"
     FALSE)
@@ -296,20 +292,6 @@ option(SWIFT_STDLIB_ENABLE_SIL_OWNERSHIP
   "Build the standard libraries and overlays with sil ownership enabled."
   FALSE)
 
-option(SWIFT_STDLIB_SIL_SERIALIZE_ALL
-    "Build the standard libraries and overlays serializing all method bodies"
-    TRUE)
-
-if(SWIFT_SERIALIZE_STDLIB_UNITTEST AND SWIFT_STDLIB_ENABLE_RESILIENCE)
-  message(WARNING "Ignoring SWIFT_SERIALIZE_STDLIB_UNITTEST because SWIFT_STDLIB_ENABLE_RESILIENCE is set")
-  set(SWIFT_SERIALIZE_STDLIB_UNITTEST FALSE)
-endif()
-
-if(SWIFT_STDLIB_SIL_SERIALIZE_ALL AND SWIFT_STDLIB_ENABLE_RESILIENCE)
-  message(WARNING "Ignoring SWIFT_STDLIB_SIL_SERIALIZE_ALL because SWIFT_STDLIB_ENABLE_RESILIENCE is set")
-  set(SWIFT_STDLIB_SIL_SERIALIZE_ALL FALSE)
-endif()
-
 #
 # End of user-configurable options.
 #

cmake/modules/SwiftSource.cmake

@@ -254,11 +254,6 @@ function(_compile_swift_files
         "-nostdimport" "-parse-stdlib" "-module-name" "Swift")
     list(APPEND swift_flags "-Xfrontend" "-group-info-path"
                             "-Xfrontend" "${GROUP_INFO_JSON_FILE}")
-    if (NOT SWIFT_STDLIB_ENABLE_RESILIENCE)
-      if (SWIFT_STDLIB_SIL_SERIALIZE_ALL)
-        list(APPEND swift_flags "-Xfrontend" "-sil-serialize-vtables")
-      endif()
-    endif()
   endif()
 
   # Force swift 3 compatibility mode for Standard Library and overlay.

include/swift/AST/SILOptions.h

@@ -150,12 +150,6 @@ class SILOptions {
   /// \brief Enable large loadable types IRGen pass.
   bool EnableLargeLoadableTypes = true;
 
-  /// If set, SIL vtables will be serialized.
-  ///
-  /// It is supposed to be used only for compiling overlays.
-  /// User code should never be compiled with this flag set.
-  bool SILSerializeVTables = false;
-
   SILOptions() {}
 
   /// Return a hash code of any components from these options that should

include/swift/Option/FrontendOptions.td

@@ -372,9 +372,6 @@ def sil_merge_partial_modules : Flag<["-"], "sil-merge-partial-modules">,
 def sil_link_all : Flag<["-"], "sil-link-all">,
   HelpText<"Link all SIL functions">;
 
-def sil_serialize_vtables : Flag<["-"], "sil-serialize-vtables">,
-  HelpText<"Serialize eligible SIL vtables">;
-
 def sil_verify_all : Flag<["-"], "sil-verify-all">,
   HelpText<"Verify SIL after each transform">;
 

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/Frontend/CompilerInvocation.cpp

@@ -1208,9 +1208,6 @@ static bool ParseSILArgs(SILOptions &Opts, ArgList &Args,
   if (Args.hasArg(OPT_sil_merge_partial_modules))
     Opts.MergePartialModules = true;
 
-  Opts.SILSerializeVTables |=
-    Args.hasArg(OPT_sil_serialize_vtables);
-
   // Parse the optimization level.
   // Default to Onone settings if no option is passed.
   IRGenOpts.Optimize = false;

lib/ParseSIL/ParseSIL.cpp

@@ -5108,6 +5108,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;
@@ -5195,7 +5201,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.