VTableSpecializer: make sure to specialize tables of superclasses

Fixes an IRGen crash if a superclass of a class is generic and not used otherwise.

rdar://122405558

Author: eeckstein

lib/SILOptimizer/Transforms/VTableSpecializer.cpp

@@ -38,6 +38,7 @@ namespace {
 
 class VTableSpecializer : public SILModuleTransform {
   bool specializeVTables(SILModule &module);
+  bool specializeVTablesOfSuperclasses(SILModule &module);
 
   /// The entry point to the transformation.
   void run() override {
@@ -85,9 +86,11 @@ static bool specializeVTablesInFunction(SILFunction &func, SILModule &module,
 bool VTableSpecializer::specializeVTables(SILModule &module) {
   bool changed = false;
   for (SILFunction &func : module) {
-    specializeVTablesInFunction(func, module, this);
+    changed |= specializeVTablesInFunction(func, module, this);
   }
 
+  changed |= specializeVTablesOfSuperclasses(module);
+
   for (SILVTable *vtable : module.getVTables()) {
     if (vtable->getClass()->isGenericContext()) continue;
 
@@ -112,6 +115,28 @@ bool VTableSpecializer::specializeVTables(SILModule &module) {
   return changed;
 }
 
+bool VTableSpecializer::specializeVTablesOfSuperclasses(SILModule &module) {
+  bool changed = false;
+  // The module's vtable table can grow while we are specializing superclass vtables.
+  for (unsigned i = 0; i < module.getVTables().size(); ++i) {
+    SILVTable *vtable = module.getVTables()[i];
+    if (vtable->getClass()->isGenericContext() && !vtable->getClassType())
+      continue;
+
+    SILType superClassTy;
+    if (SILType classTy = vtable->getClassType()) {
+      superClassTy = classTy.getSuperclass();
+    } else {
+      if (Type superTy = vtable->getClass()->getSuperclass())
+        superClassTy = SILType::getPrimitiveObjectType(superTy->getCanonicalType());
+    }
+    if (superClassTy) {
+      changed |= (specializeVTableForType(superClassTy, module, this) != nullptr);
+    }
+  }
+  return changed;
+}
+
 SILVTable *swift::specializeVTableForType(SILType classTy, SILModule &module,
                                 SILTransform *transform) {
   CanType astType = classTy.getASTType();

test/embedded/generic-classes.swift

@@ -22,16 +22,31 @@ func makeItFoo<F: Fooable>(f: F) {
   f.foo()
 }
 
+class BaseClass<A> {
+  func test() {}
+}
+
+class SubClass1<B>: BaseClass<Int> {
+  override func test() {}
+}
+
+class SubClass2 : SubClass1<Int> {
+  override func test() { print("SubClass2") }
+}
+
 @main
 struct Main {
   static func main() {
     let f = GenericFooableClass<Int>()
     makeItFoo(f: f)
     let g: GenericFooableClass = GenericFooableSubClass<Int>()
     makeItFoo(f: g)
+    let x = SubClass2()
+    x.test()
   }
 }
 
 // CHECK: GenericFooableClass<T>.foo
 // CHECK: GenericFooableSubClass<T>.foo
+// CHECK: SubClass2