BasicCalleeAnalysis: improve finding the actual called deinits of a destroy/release instruction

* C++: add a function `getDestructors(SILType type, bool isExactType)’: if the type is a final class or `isExactType` is true, then return the one and only destructor of that class.
* swift: add `getDestructor(ofExactType type: Type)` and `getIncompleteCallees`
* swift: remove `getDestructor` from the PassContext. The API of the `calleeAnalysis` can be used instead.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Analysis/CalleeAnalysis.swift

@@ -16,13 +16,32 @@ import SIL
 public struct CalleeAnalysis {
   let bridged: BridgedCalleeAnalysis
 
-  public func getCallees(callee: Value) -> FunctionArray {
+  public func getCallees(callee: Value) -> FunctionArray? {
+    let bridgedFuncs = CalleeAnalysis_getCallees(bridged, callee.bridged)
+    if bridgedFuncs.incomplete != 0 {
+      return nil
+    }
+    return FunctionArray(bridged: bridgedFuncs)
+  }
+
+  public func getIncompleteCallees(callee: Value) -> FunctionArray {
     return FunctionArray(bridged: CalleeAnalysis_getCallees(bridged, callee.bridged))
   }
 
-  public func getDestructors(destroyInst: Instruction) -> FunctionArray {
-    return FunctionArray(bridged:
-      CalleeAnalysis_getInstCallees(bridged, destroyInst.bridged))
+  public func getDestructor(ofExactType type: Type) -> Function? {
+    let destructors = FunctionArray(bridged: CalleeAnalysis_getDestructors(bridged, type.bridged, /*isExactType*/ 1))
+    if destructors.count == 1 {
+      return destructors[0]
+    }
+    return nil
+  }
+
+  public func getDestructors(of type: Type) -> FunctionArray? {
+    let bridgedDtors = CalleeAnalysis_getDestructors(bridged, type.bridged, /*isExactType*/ 0)
+    if bridgedDtors.incomplete != 0 {
+      return nil
+    }
+    return FunctionArray(bridged: bridgedDtors)
   }
 }
 
@@ -35,6 +54,4 @@ public struct FunctionArray : RandomAccessCollection, FormattedLikeArray {
   public subscript(_ index: Int) -> Function {
     return BridgedFunctionArray_get(bridged, index).function
   }
-
-  public var allCalleesKnown: Bool { bridged.incomplete == 0 }
 }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ReleaseDevirtualizer.swift

@@ -82,7 +82,7 @@ private func tryDevirtualizeReleaseOfObject(
 
   let type = allocRefInstruction.type
 
-  guard let dealloc = context.getDestructor(ofClass: type) else {
+  guard let dealloc = context.calleeAnalysis.getDestructor(ofExactType: type) else {
     return
   }
 

SwiftCompilerSources/Sources/Optimizer/PassManager/PassUtils.swift

@@ -112,10 +112,6 @@ struct PassContext {
     PassContext_fixStackNesting(_bridged, function.bridged)
   }
 
-  func getDestructor(ofClass type: Type) -> Function? {
-    PassContext_getDestructor(_bridged, type.bridged).function
-  }
-
   func getContextSubstitutionMap(for type: Type) -> SubstitutionMap {
     SubstitutionMap(PassContext_getContextSubstitutionMap(_bridged, type.bridged))
   }

include/swift/SILOptimizer/Analysis/BasicCalleeAnalysis.h

@@ -147,7 +147,7 @@ class CalleeCache {
 
   /// Return the list of callees that can potentially be called at the
   /// given instruction. E.g. it could be destructors.
-  CalleeList getCalleeList(SILInstruction *I) const;
+  CalleeList getDestructors(SILType type, bool isExactType) const;
 
   CalleeList getCalleeList(SILDeclRef Decl) const;
 
@@ -224,9 +224,9 @@ class BasicCalleeAnalysis : public SILAnalysis {
     return Cache->getCalleeListOfValue(callee);
   }
 
-  CalleeList getCalleeList(SILInstruction *I) {
+  CalleeList getDestructors(SILType type, bool isExactType) {
     updateCache();
-    return Cache->getCalleeList(I);
+    return Cache->getDestructors(type, isExactType);
   }
 };
 

include/swift/SILOptimizer/OptimizerBridging.h

@@ -96,8 +96,9 @@ BridgedCalleeAnalysis PassContext_getCalleeAnalysis(BridgedPassContext context);
 
 BridgedCalleeList CalleeAnalysis_getCallees(BridgedCalleeAnalysis calleeAnalysis,
                                             BridgedValue callee);
-BridgedCalleeList CalleeAnalysis_getInstCallees(BridgedCalleeAnalysis calleeAnalysis,
-                                                BridgedInstruction inst);
+BridgedCalleeList CalleeAnalysis_getDestructors(BridgedCalleeAnalysis calleeAnalysis,
+                                                BridgedType type,
+                                                SwiftInt isExactType);
 SwiftInt BridgedFunctionArray_size(BridgedCalleeList callees);
 BridgedFunction BridgedFunctionArray_get(BridgedCalleeList callees,
                                          SwiftInt index);
@@ -140,9 +141,6 @@ BridgedFunction BasicBlockSet_getFunction(BridgedBasicBlockSet set);
 
 void AllocRefInstBase_setIsStackAllocatable(BridgedInstruction arb);
 
-OptionalBridgedFunction PassContext_getDestructor(BridgedPassContext context,
-                                                  BridgedType type);
-
 BridgedSubstitutionMap
 PassContext_getContextSubstitutionMap(BridgedPassContext context,
                                       BridgedType bridgedType);

lib/SILOptimizer/Analysis/BasicCalleeAnalysis.cpp

@@ -287,19 +287,28 @@ CalleeList CalleeCache::getCalleeList(FullApplySite FAS) const {
   return getCalleeListForCalleeKind(FAS.getCalleeOrigin());
 }
 
-// Return the list of functions that can be called via the given instruction.
-CalleeList CalleeCache::getCalleeList(SILInstruction *I) const {
-  // We support only deallocation instructions at the moment.
-  assert((isa<StrongReleaseInst>(I) || isa<ReleaseValueInst>(I)) &&
-         "A deallocation instruction expected");
-  auto Ty = I->getOperand(0)->getType();
-  while (auto payloadTy = Ty.getOptionalObjectType())
-    Ty = payloadTy;
-  auto Class = Ty.getClassOrBoundGenericClass();
-  if (!Class || Class->hasClangNode())
+/// Return the list of destructors of the class type \p type.
+///
+/// If \p type is an optional, look through that optional.
+/// If \p exactType is true, then \p type is treated like a final class type.
+CalleeList CalleeCache::getDestructors(SILType type, bool isExactType) const {
+  while (auto payloadTy = type.getOptionalObjectType()) {
+    type = payloadTy;
+  }
+  ClassDecl *classDecl = type.getClassOrBoundGenericClass();
+  if (!classDecl || classDecl->hasClangNode())
+    return CalleeList();
+
+  if (isExactType || classDecl->isFinal()) {
+    // In case of a final class, just pick the deinit of the class.
+    SILDeclRef destructor = SILDeclRef(classDecl->getDestructor());
+    if (SILFunction *destrImpl = M.lookUpFunction(destructor))
+      return CalleeList(destrImpl);
     return CalleeList();
-  SILDeclRef Destructor = SILDeclRef(Class->getDestructor());
-  return getCalleeList(Destructor);
+  }
+  // If all that doesn't help get the list of deinits as we do for regular class
+  // methods.
+  return getCalleeList(SILDeclRef(classDecl->getDestructor()));
 }
 
 void BasicCalleeAnalysis::dump() const {
@@ -332,10 +341,11 @@ BridgedCalleeList CalleeAnalysis_getCallees(BridgedCalleeAnalysis calleeAnalysis
   return {cl.getOpaquePtr(), cl.getOpaqueKind(), cl.isIncomplete()};
 }
 
-BridgedCalleeList CalleeAnalysis_getInstCallees(BridgedCalleeAnalysis calleeAnalysis,
-                                                BridgedInstruction inst) {
+BridgedCalleeList CalleeAnalysis_getDestructors(BridgedCalleeAnalysis calleeAnalysis,
+                                                BridgedType type,
+                                                SwiftInt isExactType) {
   BasicCalleeAnalysis *bca = static_cast<BasicCalleeAnalysis *>(calleeAnalysis.bca);
-  CalleeList cl = bca->getCalleeList(castToInst(inst));
+  CalleeList cl = bca->getDestructors(castToSILType(type), isExactType != 0);
   return {cl.getOpaquePtr(), cl.getOpaqueKind(), cl.isIncomplete()};
 }
 

lib/SILOptimizer/Analysis/FunctionOrder.cpp

@@ -43,7 +43,9 @@ void BottomUpFunctionOrder::DFS(SILFunction *Start) {
       if (!FAS && !isa<StrongReleaseInst>(&I) && !isa<ReleaseValueInst>(&I))
         continue;
 
-      auto Callees = FAS ? BCA->getCalleeList(FAS) : BCA->getCalleeList(&I);
+      auto Callees = FAS ? BCA->getCalleeList(FAS)
+                         : BCA->getDestructors(I.getOperand(0)->getType(),
+                                               /*isExactType*/ false);
       for (auto *CalleeFn : Callees) {
         // If not yet visited, visit the callee.
         if (DFSNum.find(CalleeFn) == DFSNum.end()) {

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -1391,19 +1391,6 @@ void AllocRefInstBase_setIsStackAllocatable(BridgedInstruction arb) {
   castToInst<AllocRefInstBase>(arb)->setStackAllocatable();
 }
 
-OptionalBridgedFunction PassContext_getDestructor(BridgedPassContext context,
-                                                  BridgedType type) {
-  auto *cd = castToSILType(type).getClassOrBoundGenericClass();
-  assert(cd && "no class type allocated with alloc_ref");
-
-  auto *pm = castToPassInvocation(context)->getPassManager();
-  // Find the destructor of the type.
-  auto *destructor = cd->getDestructor();
-  SILDeclRef deallocRef(destructor, SILDeclRef::Kind::Deallocator);
-
-  return {pm->getModule()->lookUpFunction(deallocRef)};
-}
-
 BridgedSubstitutionMap
 PassContext_getContextSubstitutionMap(BridgedPassContext context,
                                       BridgedType bridgedType) {