SILOptimizer: Small cleanups for devirtualizer

Where possible, pass around a ClassDecl or a CanType instead of a
SILType that might wrap a metatype; the unwrapping logic was
repeated in several places.

Also add a FIXME for a bug I found by inspection.

Author: slavapestov

include/swift/SILOptimizer/Utils/Devirtualize.h

@@ -44,7 +44,7 @@ class Emitter;
 /// \p Subs a container to be used for storing the set of subclasses
 void getAllSubclasses(ClassHierarchyAnalysis *CHA,
                       ClassDecl *CD,
-                      SILType ClassType,
+                      CanType ClassType,
                       SILModule &M,
                       ClassHierarchyAnalysis::ClassList &Subs);
 
@@ -69,18 +69,19 @@ ApplySite tryDevirtualizeApply(ApplySite AI,
                                ClassHierarchyAnalysis *CHA,
                                OptRemark::Emitter *ORE = nullptr);
 bool canDevirtualizeApply(FullApplySite AI, ClassHierarchyAnalysis *CHA);
-bool isNominalTypeWithUnboundGenericParameters(SILType Ty, SILModule &M);
-bool canDevirtualizeClassMethod(FullApplySite AI, SILType ClassInstanceType,
+bool canDevirtualizeClassMethod(FullApplySite AI, ClassDecl *CD,
                                 OptRemark::Emitter *ORE = nullptr,
                                 bool isEffectivelyFinalMethod = false);
-SILFunction *getTargetClassMethod(SILModule &M, SILType ClassOrMetatypeType,
+SILFunction *getTargetClassMethod(SILModule &M, ClassDecl *CD,
                                   MethodInst *MI);
+CanType getSelfInstanceType(CanType ClassOrMetatypeType);
 
 /// Devirtualize the given apply site, which is known to be devirtualizable.
 ///
 /// The caller must call deleteDevirtualizedApply on the original apply site.
 FullApplySite devirtualizeClassMethod(FullApplySite AI,
                                       SILValue ClassInstance,
+                                      ClassDecl *CD,
                                       OptRemark::Emitter *ORE);
 
 /// Attempt to devirtualize the given apply site, which is known to be
@@ -89,7 +90,9 @@ FullApplySite devirtualizeClassMethod(FullApplySite AI,
 /// If this succeeds, the caller must call deleteDevirtualizedApply on
 /// the original apply site.
 FullApplySite
-tryDevirtualizeClassMethod(FullApplySite AI, SILValue ClassInstance,
+tryDevirtualizeClassMethod(FullApplySite AI,
+                           SILValue ClassInstance,
+                           ClassDecl *CD,
                            OptRemark::Emitter *ORE,
                            bool isEffectivelyFinalMethod = false);
 

lib/SILOptimizer/Mandatory/DiagnoseInfiniteRecursion.cpp

@@ -57,7 +57,7 @@ static bool hasRecursiveCallInPath(SILBasicBlock &Block,
 
       auto &M = FAI.getModule();
       if (auto *CMI = dyn_cast<ClassMethodInst>(FAI.getCallee())) {
-        auto ClassType = CMI->getOperand()->getType();
+        auto ClassType = CMI->getOperand()->getType().getASTType();
 
         // FIXME: If we're not inside the module context of the method,
         // we may have to deserialize vtables.  If the serialized tables
@@ -66,12 +66,12 @@ static bool hasRecursiveCallInPath(SILBasicBlock &Block,
         // Though, this has the added bonus of not looking into vtables
         // outside the current module.  Because we're not doing IPA, let
         // alone cross-module IPA, this is all well and good.
-        auto *BGC = ClassType.getNominalOrBoundGenericNominal();
-        if (BGC && BGC->getModuleContext() != TargetModule) {
+        auto *CD = ClassType.getClassOrBoundGenericClass();
+        if (CD && CD->getModuleContext() != TargetModule) {
           continue;
         }
 
-        auto *F = getTargetClassMethod(M, ClassType, CMI);
+        auto *F = getTargetClassMethod(M, CD, CMI);
         if (F == Target)
           return true;
 

lib/SILOptimizer/Transforms/SpeculativeDevirtualizer.cpp

@@ -118,14 +118,15 @@ static FullApplySite CloneApply(FullApplySite AI, SILBuilder &Builder) {
 /// Insert monomorphic inline caches for a specific class or metatype
 /// type \p SubClassTy.
 static FullApplySite speculateMonomorphicTarget(FullApplySite AI,
-                                                SILType SubType,
+                                                CanType SubType,
+                                                ClassDecl *CD,
                                                 CheckedCastBranchInst *&CCBI) {
-  CCBI = nullptr;
-  // Bail if this class_method cannot be devirtualized.
-  if (!canDevirtualizeClassMethod(AI, SubType))
+  if (SubType->hasDynamicSelfType())
     return FullApplySite();
 
-  if (SubType.getASTType()->hasDynamicSelfType())
+  CCBI = nullptr;
+  // Bail if this class_method cannot be devirtualized.
+  if (!canDevirtualizeClassMethod(AI, CD))
     return FullApplySite();
 
   // Can't speculate begin_apply yet.
@@ -144,7 +145,9 @@ static FullApplySite speculateMonomorphicTarget(FullApplySite AI,
   SILBasicBlock *Iden = F->createBasicBlock();
   // Virt is the block containing the slow virtual call.
   SILBasicBlock *Virt = F->createBasicBlock();
-  Iden->createPhiArgument(SubType, ValueOwnershipKind::Owned);
+  Iden->createPhiArgument(
+      SILType::getPrimitiveObjectType(SubType),
+      ValueOwnershipKind::Owned);
 
   SILBasicBlock *Continue = Entry->split(It);
 
@@ -155,8 +158,10 @@ static FullApplySite speculateMonomorphicTarget(FullApplySite AI,
   ClassMethodInst *CMI = cast<ClassMethodInst>(AI.getCallee());
 
   CCBI = Builder.createCheckedCastBranch(AI.getLoc(), /*exact*/ true,
-                                       CMI->getOperand(), SubType, Iden,
-                                       Virt);
+                                      CMI->getOperand(),
+                                      SILType::getPrimitiveObjectType(SubType),
+                                      Iden,
+                                      Virt);
   It = CCBI->getIterator();
 
   SILBuilderWithScope VirtBuilder(Virt, AI.getInstruction());
@@ -219,7 +224,7 @@ static FullApplySite speculateMonomorphicTarget(FullApplySite AI,
 
   // Devirtualize the apply instruction on the identical path.
   auto NewInst =
-    devirtualizeClassMethod(IdenAI, DownCastedClassInstance, nullptr);
+    devirtualizeClassMethod(IdenAI, DownCastedClassInstance, CD, nullptr);
   assert(NewInst && "Expected to be able to devirtualize apply!");
   (void)NewInst;
 
@@ -381,21 +386,20 @@ static bool tryToSpeculateTarget(FullApplySite AI, ClassHierarchyAnalysis *CHA,
   // with a value whose type is closer (in the class hierarchy) to the
   // actual dynamic type.
   auto SubTypeValue = stripUpCasts(CMI->getOperand());
-  SILType SubType = SubTypeValue->getType();
+  CanType SubType = SubTypeValue->getType().getASTType();
 
   // Bail if any generic types parameters of the class instance type are
   // unbound.
   // We cannot devirtualize unbound generic calls yet.
-  if (SubType.hasArchetype())
+  if (SubType->hasArchetype())
     return false;
 
-  auto &M = CMI->getModule();
-  auto ClassType = SubType;
-  if (SubType.is<MetatypeType>())
-    ClassType = SubType.getMetatypeInstanceType(M);
+  auto *F = CMI->getFunction();
+  auto &M = F->getModule();
 
   CheckedCastBranchInst *LastCCBI = nullptr;
 
+  auto ClassType = getSelfInstanceType(SubType);
   ClassDecl *CD = ClassType.getClassOrBoundGenericClass();
   assert(CD && "Expected decl for class type!");
 
@@ -404,15 +408,15 @@ static bool tryToSpeculateTarget(FullApplySite AI, ClassHierarchyAnalysis *CHA,
     // try to devirtualize it completely.
     ClassHierarchyAnalysis::ClassList Subs;
     if (isDefaultCaseKnown(CHA, AI, CD, Subs)) {
-      auto NewInst = tryDevirtualizeClassMethod(AI, SubTypeValue, &ORE);
+      auto NewInst = tryDevirtualizeClassMethod(AI, SubTypeValue, CD, &ORE);
       if (NewInst)
         deleteDevirtualizedApply(AI);
       return bool(NewInst);
     }
 
     LLVM_DEBUG(llvm::dbgs() << "Inserting monomorphic speculative call for "
                "class " << CD->getName() << "\n");
-    return !!speculateMonomorphicTarget(AI, SubType, LastCCBI);
+    return !!speculateMonomorphicTarget(AI, SubType, CD, LastCCBI);
   }
 
   // True if any instructions were changed or generated.
@@ -438,7 +442,7 @@ static bool tryToSpeculateTarget(FullApplySite AI, ClassHierarchyAnalysis *CHA,
 
   // Try to devirtualize the static class of instance
   // if it is possible.
-  if (auto F = getTargetClassMethod(M, SubType, CMI)) {
+  if (auto F = getTargetClassMethod(M, CD, CMI)) {
     // Do not devirtualize if a method in the base class is marked
     // as non-optimizable. This way it is easy to disable the
     // devirtualization of this method in the base class and
@@ -447,7 +451,7 @@ static bool tryToSpeculateTarget(FullApplySite AI, ClassHierarchyAnalysis *CHA,
       return false;
   }
 
-  auto FirstAI = speculateMonomorphicTarget(AI, SubType, LastCCBI);
+  auto FirstAI = speculateMonomorphicTarget(AI, SubType, CD, LastCCBI);
   if (FirstAI) {
     Changed = true;
     AI = FirstAI;
@@ -501,18 +505,15 @@ static bool tryToSpeculateTarget(FullApplySite AI, ClassHierarchyAnalysis *CHA,
     }
 
     CanType CanClassType = S->getDeclaredInterfaceType()->getCanonicalType();
-    SILType ClassType = SILType::getPrimitiveObjectType(CanClassType);
-
-    auto ClassOrMetatypeType = ClassType;
-    if (auto EMT = SubType.getAs<AnyMetatypeType>()) {
-      auto InstTy = ClassType.getASTType();
-      auto *MetaTy = MetatypeType::get(InstTy, EMT->getRepresentation());
-      auto CanMetaTy = CanMetatypeType(MetaTy);
-      ClassOrMetatypeType = SILType::getPrimitiveObjectType(CanMetaTy);
+
+    auto ClassOrMetatypeType = CanClassType;
+    if (auto MT = dyn_cast<MetatypeType>(SubType)) {
+      ClassOrMetatypeType = CanMetatypeType::get(CanClassType,
+                                                 MT->getRepresentation());
     }
 
     // Pass the metatype of the subclass.
-    auto NewAI = speculateMonomorphicTarget(AI, ClassOrMetatypeType, LastCCBI);
+    auto NewAI = speculateMonomorphicTarget(AI, ClassOrMetatypeType, S, LastCCBI);
     if (!NewAI) {
       NotHandledSubsNum++;
       continue;
@@ -567,7 +568,7 @@ static bool tryToSpeculateTarget(FullApplySite AI, ClassHierarchyAnalysis *CHA,
     ORE.emit(RB);
     return true;
   }
-  auto NewInst = tryDevirtualizeClassMethod(AI, SubTypeValue, nullptr);
+  auto NewInst = tryDevirtualizeClassMethod(AI, SubTypeValue, CD, nullptr);
   if (NewInst) {
     ORE.emit(RB);
     deleteDevirtualizedApply(AI);